| [ 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,blackBright:x,redBright:x,greenBright:x,yellowBright:x,blueBright:x,magentaBright:x,cyanBright:x,whiteBright:x,bgBlackBright:x,bgRedBright:x,bgGreenBright:x,bgYellowBright:x,bgBlueBright:x,bgMagentaBright:x,bgCyanBright:x,bgWhiteBright:x}}; 1534 module.exports=create(); 1535 module.exports.createColors = create; 1536 1537 1538 /***/ }), 1539 1540 /***/ 1443: 1541 /***/ ((module) => { 1542 1543 module.exports = function postcssPrefixSelector(options) { 1544 const prefix = options.prefix; 1545 const prefixWithSpace = /\s+$/.test(prefix) ? prefix : `$prefix} `; 1546 const ignoreFiles = options.ignoreFiles ? [].concat(options.ignoreFiles) : []; 1547 const includeFiles = options.includeFiles 1548 ? [].concat(options.includeFiles) 1549 : []; 1550 1551 return function (root) { 1552 if ( 1553 ignoreFiles.length && 1554 root.source.input.file && 1555 isFileInArray(root.source.input.file, ignoreFiles) 1556 ) { 1557 return; 1558 } 1559 if ( 1560 includeFiles.length && 1561 root.source.input.file && 1562 !isFileInArray(root.source.input.file, includeFiles) 1563 ) { 1564 return; 1565 } 1566 1567 root.walkRules((rule) => { 1568 const keyframeRules = [ 1569 'keyframes', 1570 '-webkit-keyframes', 1571 '-moz-keyframes', 1572 '-o-keyframes', 1573 '-ms-keyframes', 1574 ]; 1575 1576 if (rule.parent && keyframeRules.includes(rule.parent.name)) { 1577 return; 1578 } 1579 1580 rule.selectors = rule.selectors.map((selector) => { 1581 if (options.exclude && excludeSelector(selector, options.exclude)) { 1582 return selector; 1583 } 1584 1585 if (options.transform) { 1586 return options.transform( 1587 prefix, 1588 selector, 1589 prefixWithSpace + selector, 1590 root.source.input.file, 1591 rule 1592 ); 1593 } 1594 1595 return prefixWithSpace + selector; 1596 }); 1597 }); 1598 }; 1599 }; 1600 1601 function isFileInArray(file, arr) { 1602 return arr.some((ruleOrString) => { 1603 if (ruleOrString instanceof RegExp) { 1604 return ruleOrString.test(file); 1605 } 1606 1607 return file.includes(ruleOrString); 1608 }); 1609 } 1610 1611 function excludeSelector(selector, excludeArr) { 1612 return excludeArr.some((excludeRule) => { 1613 if (excludeRule instanceof RegExp) { 1614 return excludeRule.test(selector); 1615 } 1616 1617 return selector === excludeRule; 1618 }); 1619 } 1620 1621 1622 /***/ }), 1623 1624 /***/ 5404: 1625 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 1626 1627 const CSSValueParser = __webpack_require__(1544) 1628 1629 /** 1630 * @type {import('postcss').PluginCreator} 1631 */ 1632 module.exports = (opts) => { 1633 1634 const DEFAULTS = { 1635 skipHostRelativeUrls: true, 1636 } 1637 const config = Object.assign(DEFAULTS, opts) 1638 1639 return { 1640 postcssPlugin: 'rebaseUrl', 1641 1642 Declaration(decl) { 1643 // The faster way to find Declaration node 1644 const parsedValue = CSSValueParser(decl.value) 1645 1646 let valueChanged = false 1647 parsedValue.walk(node => { 1648 if (node.type !== 'function' || node.value !== 'url') { 1649 return 1650 } 1651 1652 const urlVal = node.nodes[0].value 1653 1654 // bases relative URLs with rootUrl 1655 const basedUrl = new URL(urlVal, opts.rootUrl) 1656 1657 // skip host-relative, already normalized URLs (e.g. `/images/image.jpg`, without `..`s) 1658 if ((basedUrl.pathname === urlVal) && config.skipHostRelativeUrls) { 1659 return false // skip this value 1660 } 1661 1662 node.nodes[0].value = basedUrl.toString() 1663 valueChanged = true 1664 1665 return false // do not walk deeper 1666 }) 1667 1668 if (valueChanged) { 1669 decl.value = CSSValueParser.stringify(parsedValue) 1670 } 1671 1672 } 1673 } 1674 } 1675 1676 module.exports.postcss = true 1677 1678 1679 /***/ }), 1680 1681 /***/ 1544: 1682 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 1683 1684 var parse = __webpack_require__(8491); 1685 var walk = __webpack_require__(3815); 1686 var stringify = __webpack_require__(4725); 1687 1688 function ValueParser(value) { 1689 if (this instanceof ValueParser) { 1690 this.nodes = parse(value); 1691 return this; 1692 } 1693 return new ValueParser(value); 1694 } 1695 1696 ValueParser.prototype.toString = function() { 1697 return Array.isArray(this.nodes) ? stringify(this.nodes) : ""; 1698 }; 1699 1700 ValueParser.prototype.walk = function(cb, bubble) { 1701 walk(this.nodes, cb, bubble); 1702 return this; 1703 }; 1704 1705 ValueParser.unit = __webpack_require__(1524); 1706 1707 ValueParser.walk = walk; 1708 1709 ValueParser.stringify = stringify; 1710 1711 module.exports = ValueParser; 1712 1713 1714 /***/ }), 1715 1716 /***/ 8491: 1717 /***/ ((module) => { 1718 1719 var openParentheses = "(".charCodeAt(0); 1720 var closeParentheses = ")".charCodeAt(0); 1721 var singleQuote = "'".charCodeAt(0); 1722 var doubleQuote = '"'.charCodeAt(0); 1723 var backslash = "\\".charCodeAt(0); 1724 var slash = "/".charCodeAt(0); 1725 var comma = ",".charCodeAt(0); 1726 var colon = ":".charCodeAt(0); 1727 var star = "*".charCodeAt(0); 1728 var uLower = "u".charCodeAt(0); 1729 var uUpper = "U".charCodeAt(0); 1730 var plus = "+".charCodeAt(0); 1731 var isUnicodeRange = /^[a-f0-9?-]+$/i; 1732 1733 module.exports = function(input) { 1734 var tokens = []; 1735 var value = input; 1736 1737 var next, 1738 quote, 1739 prev, 1740 token, 1741 escape, 1742 escapePos, 1743 whitespacePos, 1744 parenthesesOpenPos; 1745 var pos = 0; 1746 var code = value.charCodeAt(pos); 1747 var max = value.length; 1748 var stack = [{ nodes: tokens }]; 1749 var balanced = 0; 1750 var parent; 1751 1752 var name = ""; 1753 var before = ""; 1754 var after = ""; 1755 1756 while (pos < max) { 1757 // Whitespaces 1758 if (code <= 32) { 1759 next = pos; 1760 do { 1761 next += 1; 1762 code = value.charCodeAt(next); 1763 } while (code <= 32); 1764 token = value.slice(pos, next); 1765 1766 prev = tokens[tokens.length - 1]; 1767 if (code === closeParentheses && balanced) { 1768 after = token; 1769 } else if (prev && prev.type === "div") { 1770 prev.after = token; 1771 prev.sourceEndIndex += token.length; 1772 } else if ( 1773 code === comma || 1774 code === colon || 1775 (code === slash && 1776 value.charCodeAt(next + 1) !== star && 1777 (!parent || 1778 (parent && parent.type === "function" && parent.value !== "calc"))) 1779 ) { 1780 before = token; 1781 } else { 1782 tokens.push({ 1783 type: "space", 1784 sourceIndex: pos, 1785 sourceEndIndex: next, 1786 value: token 1787 }); 1788 } 1789 1790 pos = next; 1791 1792 // Quotes 1793 } else if (code === singleQuote || code === doubleQuote) { 1794 next = pos; 1795 quote = code === singleQuote ? "'" : '"'; 1796 token = { 1797 type: "string", 1798 sourceIndex: pos, 1799 quote: quote 1800 }; 1801 do { 1802 escape = false; 1803 next = value.indexOf(quote, next + 1); 1804 if (~next) { 1805 escapePos = next; 1806 while (value.charCodeAt(escapePos - 1) === backslash) { 1807 escapePos -= 1; 1808 escape = !escape; 1809 } 1810 } else { 1811 value += quote; 1812 next = value.length - 1; 1813 token.unclosed = true; 1814 } 1815 } while (escape); 1816 token.value = value.slice(pos + 1, next); 1817 token.sourceEndIndex = token.unclosed ? next : next + 1; 1818 tokens.push(token); 1819 pos = next + 1; 1820 code = value.charCodeAt(pos); 1821 1822 // Comments 1823 } else if (code === slash && value.charCodeAt(pos + 1) === star) { 1824 next = value.indexOf("*/", pos); 1825 1826 token = { 1827 type: "comment", 1828 sourceIndex: pos, 1829 sourceEndIndex: next + 2 1830 }; 1831 1832 if (next === -1) { 1833 token.unclosed = true; 1834 next = value.length; 1835 token.sourceEndIndex = next; 1836 } 1837 1838 token.value = value.slice(pos + 2, next); 1839 tokens.push(token); 1840 1841 pos = next + 2; 1842 code = value.charCodeAt(pos); 1843 1844 // Operation within calc 1845 } else if ( 1846 (code === slash || code === star) && 1847 parent && 1848 parent.type === "function" && 1849 parent.value === "calc" 1850 ) { 1851 token = value[pos]; 1852 tokens.push({ 1853 type: "word", 1854 sourceIndex: pos - before.length, 1855 sourceEndIndex: pos + token.length, 1856 value: token 1857 }); 1858 pos += 1; 1859 code = value.charCodeAt(pos); 1860 1861 // Dividers 1862 } else if (code === slash || code === comma || code === colon) { 1863 token = value[pos]; 1864 1865 tokens.push({ 1866 type: "div", 1867 sourceIndex: pos - before.length, 1868 sourceEndIndex: pos + token.length, 1869 value: token, 1870 before: before, 1871 after: "" 1872 }); 1873 before = ""; 1874 1875 pos += 1; 1876 code = value.charCodeAt(pos); 1877 1878 // Open parentheses 1879 } else if (openParentheses === code) { 1880 // Whitespaces after open parentheses 1881 next = pos; 1882 do { 1883 next += 1; 1884 code = value.charCodeAt(next); 1885 } while (code <= 32); 1886 parenthesesOpenPos = pos; 1887 token = { 1888 type: "function", 1889 sourceIndex: pos - name.length, 1890 value: name, 1891 before: value.slice(parenthesesOpenPos + 1, next) 1892 }; 1893 pos = next; 1894 1895 if (name === "url" && code !== singleQuote && code !== doubleQuote) { 1896 next -= 1; 1897 do { 1898 escape = false; 1899 next = value.indexOf(")", next + 1); 1900 if (~next) { 1901 escapePos = next; 1902 while (value.charCodeAt(escapePos - 1) === backslash) { 1903 escapePos -= 1; 1904 escape = !escape; 1905 } 1906 } else { 1907 value += ")"; 1908 next = value.length - 1; 1909 token.unclosed = true; 1910 } 1911 } while (escape); 1912 // Whitespaces before closed 1913 whitespacePos = next; 1914 do { 1915 whitespacePos -= 1; 1916 code = value.charCodeAt(whitespacePos); 1917 } while (code <= 32); 1918 if (parenthesesOpenPos < whitespacePos) { 1919 if (pos !== whitespacePos + 1) { 1920 token.nodes = [ 1921 { 1922 type: "word", 1923 sourceIndex: pos, 1924 sourceEndIndex: whitespacePos + 1, 1925 value: value.slice(pos, whitespacePos + 1) 1926 } 1927 ]; 1928 } else { 1929 token.nodes = []; 1930 } 1931 if (token.unclosed && whitespacePos + 1 !== next) { 1932 token.after = ""; 1933 token.nodes.push({ 1934 type: "space", 1935 sourceIndex: whitespacePos + 1, 1936 sourceEndIndex: next, 1937 value: value.slice(whitespacePos + 1, next) 1938 }); 1939 } else { 1940 token.after = value.slice(whitespacePos + 1, next); 1941 token.sourceEndIndex = next; 1942 } 1943 } else { 1944 token.after = ""; 1945 token.nodes = []; 1946 } 1947 pos = next + 1; 1948 token.sourceEndIndex = token.unclosed ? next : pos; 1949 code = value.charCodeAt(pos); 1950 tokens.push(token); 1951 } else { 1952 balanced += 1; 1953 token.after = ""; 1954 token.sourceEndIndex = pos + 1; 1955 tokens.push(token); 1956 stack.push(token); 1957 tokens = token.nodes = []; 1958 parent = token; 1959 } 1960 name = ""; 1961 1962 // Close parentheses 1963 } else if (closeParentheses === code && balanced) { 1964 pos += 1; 1965 code = value.charCodeAt(pos); 1966 1967 parent.after = after; 1968 parent.sourceEndIndex += after.length; 1969 after = ""; 1970 balanced -= 1; 1971 stack[stack.length - 1].sourceEndIndex = pos; 1972 stack.pop(); 1973 parent = stack[balanced]; 1974 tokens = parent.nodes; 1975 1976 // Words 1977 } else { 1978 next = pos; 1979 do { 1980 if (code === backslash) { 1981 next += 1; 1982 } 1983 next += 1; 1984 code = value.charCodeAt(next); 1985 } while ( 1986 next < max && 1987 !( 1988 code <= 32 || 1989 code === singleQuote || 1990 code === doubleQuote || 1991 code === comma || 1992 code === colon || 1993 code === slash || 1994 code === openParentheses || 1995 (code === star && 1996 parent && 1997 parent.type === "function" && 1998 parent.value === "calc") || 1999 (code === slash && 2000 parent.type === "function" && 2001 parent.value === "calc") || 2002 (code === closeParentheses && balanced) 2003 ) 2004 ); 2005 token = value.slice(pos, next); 2006 2007 if (openParentheses === code) { 2008 name = token; 2009 } else if ( 2010 (uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) && 2011 plus === token.charCodeAt(1) && 2012 isUnicodeRange.test(token.slice(2)) 2013 ) { 2014 tokens.push({ 2015 type: "unicode-range", 2016 sourceIndex: pos, 2017 sourceEndIndex: next, 2018 value: token 2019 }); 2020 } else { 2021 tokens.push({ 2022 type: "word", 2023 sourceIndex: pos, 2024 sourceEndIndex: next, 2025 value: token 2026 }); 2027 } 2028 2029 pos = next; 2030 } 2031 } 2032 2033 for (pos = stack.length - 1; pos; pos -= 1) { 2034 stack[pos].unclosed = true; 2035 stack[pos].sourceEndIndex = value.length; 2036 } 2037 2038 return stack[0].nodes; 2039 }; 2040 2041 2042 /***/ }), 2043 2044 /***/ 4725: 2045 /***/ ((module) => { 2046 2047 function stringifyNode(node, custom) { 2048 var type = node.type; 2049 var value = node.value; 2050 var buf; 2051 var customResult; 2052 2053 if (custom && (customResult = custom(node)) !== undefined) { 2054 return customResult; 2055 } else if (type === "word" || type === "space") { 2056 return value; 2057 } else if (type === "string") { 2058 buf = node.quote || ""; 2059 return buf + value + (node.unclosed ? "" : buf); 2060 } else if (type === "comment") { 2061 return "/*" + value + (node.unclosed ? "" : "*/"); 2062 } else if (type === "div") { 2063 return (node.before || "") + value + (node.after || ""); 2064 } else if (Array.isArray(node.nodes)) { 2065 buf = stringify(node.nodes, custom); 2066 if (type !== "function") { 2067 return buf; 2068 } 2069 return ( 2070 value + 2071 "(" + 2072 (node.before || "") + 2073 buf + 2074 (node.after || "") + 2075 (node.unclosed ? "" : ")") 2076 ); 2077 } 2078 return value; 2079 } 2080 2081 function stringify(nodes, custom) { 2082 var result, i; 2083 2084 if (Array.isArray(nodes)) { 2085 result = ""; 2086 for (i = nodes.length - 1; ~i; i -= 1) { 2087 result = stringifyNode(nodes[i], custom) + result; 2088 } 2089 return result; 2090 } 2091 return stringifyNode(nodes, custom); 2092 } 2093 2094 module.exports = stringify; 2095 2096 2097 /***/ }), 2098 2099 /***/ 1524: 2100 /***/ ((module) => { 2101 2102 var minus = "-".charCodeAt(0); 2103 var plus = "+".charCodeAt(0); 2104 var dot = ".".charCodeAt(0); 2105 var exp = "e".charCodeAt(0); 2106 var EXP = "E".charCodeAt(0); 2107 2108 // Check if three code points would start a number 2109 // https://www.w3.org/TR/css-syntax-3/#starts-with-a-number 2110 function likeNumber(value) { 2111 var code = value.charCodeAt(0); 2112 var nextCode; 2113 2114 if (code === plus || code === minus) { 2115 nextCode = value.charCodeAt(1); 2116 2117 if (nextCode >= 48 && nextCode <= 57) { 2118 return true; 2119 } 2120 2121 var nextNextCode = value.charCodeAt(2); 2122 2123 if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) { 2124 return true; 2125 } 2126 2127 return false; 2128 } 2129 2130 if (code === dot) { 2131 nextCode = value.charCodeAt(1); 2132 2133 if (nextCode >= 48 && nextCode <= 57) { 2134 return true; 2135 } 2136 2137 return false; 2138 } 2139 2140 if (code >= 48 && code <= 57) { 2141 return true; 2142 } 2143 2144 return false; 2145 } 2146 2147 // Consume a number 2148 // https://www.w3.org/TR/css-syntax-3/#consume-number 2149 module.exports = function(value) { 2150 var pos = 0; 2151 var length = value.length; 2152 var code; 2153 var nextCode; 2154 var nextNextCode; 2155 2156 if (length === 0 || !likeNumber(value)) { 2157 return false; 2158 } 2159 2160 code = value.charCodeAt(pos); 2161 2162 if (code === plus || code === minus) { 2163 pos++; 2164 } 2165 2166 while (pos < length) { 2167 code = value.charCodeAt(pos); 2168 2169 if (code < 48 || code > 57) { 2170 break; 2171 } 2172 2173 pos += 1; 2174 } 2175 2176 code = value.charCodeAt(pos); 2177 nextCode = value.charCodeAt(pos + 1); 2178 2179 if (code === dot && nextCode >= 48 && nextCode <= 57) { 2180 pos += 2; 2181 2182 while (pos < length) { 2183 code = value.charCodeAt(pos); 2184 2185 if (code < 48 || code > 57) { 2186 break; 2187 } 2188 2189 pos += 1; 2190 } 2191 } 2192 2193 code = value.charCodeAt(pos); 2194 nextCode = value.charCodeAt(pos + 1); 2195 nextNextCode = value.charCodeAt(pos + 2); 2196 2197 if ( 2198 (code === exp || code === EXP) && 2199 ((nextCode >= 48 && nextCode <= 57) || 2200 ((nextCode === plus || nextCode === minus) && 2201 nextNextCode >= 48 && 2202 nextNextCode <= 57)) 2203 ) { 2204 pos += nextCode === plus || nextCode === minus ? 3 : 2; 2205 2206 while (pos < length) { 2207 code = value.charCodeAt(pos); 2208 2209 if (code < 48 || code > 57) { 2210 break; 2211 } 2212 2213 pos += 1; 2214 } 2215 } 2216 2217 return { 2218 number: value.slice(0, pos), 2219 unit: value.slice(pos) 2220 }; 2221 }; 2222 2223 2224 /***/ }), 2225 2226 /***/ 3815: 2227 /***/ ((module) => { 2228 2229 module.exports = function walk(nodes, cb, bubble) { 2230 var i, max, node, result; 2231 2232 for (i = 0, max = nodes.length; i < max; i += 1) { 2233 node = nodes[i]; 2234 if (!bubble) { 2235 result = cb(node, i, nodes); 2236 } 2237 2238 if ( 2239 result !== false && 2240 node.type === "function" && 2241 Array.isArray(node.nodes) 2242 ) { 2243 walk(node.nodes, cb, bubble); 2244 } 2245 2246 if (bubble) { 2247 cb(node, i, nodes); 2248 } 2249 } 2250 }; 2251 2252 2253 /***/ }), 2254 2255 /***/ 1326: 2256 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2257 2258 "use strict"; 2259 2260 2261 let Container = __webpack_require__(683) 2262 2263 class AtRule extends Container { 2264 constructor(defaults) { 2265 super(defaults) 2266 this.type = 'atrule' 2267 } 2268 2269 append(...children) { 2270 if (!this.proxyOf.nodes) this.nodes = [] 2271 return super.append(...children) 2272 } 2273 2274 prepend(...children) { 2275 if (!this.proxyOf.nodes) this.nodes = [] 2276 return super.prepend(...children) 2277 } 2278 } 2279 2280 module.exports = AtRule 2281 AtRule.default = AtRule 2282 2283 Container.registerAtRule(AtRule) 2284 2285 2286 /***/ }), 2287 2288 /***/ 6589: 2289 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2290 2291 "use strict"; 2292 2293 2294 let Node = __webpack_require__(7490) 2295 2296 class Comment extends Node { 2297 constructor(defaults) { 2298 super(defaults) 2299 this.type = 'comment' 2300 } 2301 } 2302 2303 module.exports = Comment 2304 Comment.default = Comment 2305 2306 2307 /***/ }), 2308 2309 /***/ 683: 2310 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2311 2312 "use strict"; 2313 2314 2315 let Comment = __webpack_require__(6589) 2316 let Declaration = __webpack_require__(1516) 2317 let Node = __webpack_require__(7490) 2318 let { isClean, my } = __webpack_require__(1381) 2319 2320 let AtRule, parse, Root, Rule 2321 2322 function cleanSource(nodes) { 2323 return nodes.map(i => { 2324 if (i.nodes) i.nodes = cleanSource(i.nodes) 2325 delete i.source 2326 return i 2327 }) 2328 } 2329 2330 function markTreeDirty(node) { 2331 node[isClean] = false 2332 if (node.proxyOf.nodes) { 2333 for (let i of node.proxyOf.nodes) { 2334 markTreeDirty(i) 2335 } 2336 } 2337 } 2338 2339 class Container extends Node { 2340 append(...children) { 2341 for (let child of children) { 2342 let nodes = this.normalize(child, this.last) 2343 for (let node of nodes) this.proxyOf.nodes.push(node) 2344 } 2345 2346 this.markDirty() 2347 2348 return this 2349 } 2350 2351 cleanRaws(keepBetween) { 2352 super.cleanRaws(keepBetween) 2353 if (this.nodes) { 2354 for (let node of this.nodes) node.cleanRaws(keepBetween) 2355 } 2356 } 2357 2358 each(callback) { 2359 if (!this.proxyOf.nodes) return undefined 2360 let iterator = this.getIterator() 2361 2362 let index, result 2363 while (this.indexes[iterator] < this.proxyOf.nodes.length) { 2364 index = this.indexes[iterator] 2365 result = callback(this.proxyOf.nodes[index], index) 2366 if (result === false) break 2367 2368 this.indexes[iterator] += 1 2369 } 2370 2371 delete this.indexes[iterator] 2372 return result 2373 } 2374 2375 every(condition) { 2376 return this.nodes.every(condition) 2377 } 2378 2379 getIterator() { 2380 if (!this.lastEach) this.lastEach = 0 2381 if (!this.indexes) this.indexes = {} 2382 2383 this.lastEach += 1 2384 let iterator = this.lastEach 2385 this.indexes[iterator] = 0 2386 2387 return iterator 2388 } 2389 2390 getProxyProcessor() { 2391 return { 2392 get(node, prop) { 2393 if (prop === 'proxyOf') { 2394 return node 2395 } else if (!node[prop]) { 2396 return node[prop] 2397 } else if ( 2398 prop === 'each' || 2399 (typeof prop === 'string' && prop.startsWith('walk')) 2400 ) { 2401 return (...args) => { 2402 return node[prop]( 2403 ...args.map(i => { 2404 if (typeof i === 'function') { 2405 return (child, index) => i(child.toProxy(), index) 2406 } else { 2407 return i 2408 } 2409 }) 2410 ) 2411 } 2412 } else if (prop === 'every' || prop === 'some') { 2413 return cb => { 2414 return node[prop]((child, ...other) => 2415 cb(child.toProxy(), ...other) 2416 ) 2417 } 2418 } else if (prop === 'root') { 2419 return () => node.root().toProxy() 2420 } else if (prop === 'nodes') { 2421 return node.nodes.map(i => i.toProxy()) 2422 } else if (prop === 'first' || prop === 'last') { 2423 return node[prop].toProxy() 2424 } else { 2425 return node[prop] 2426 } 2427 }, 2428 2429 set(node, prop, value) { 2430 if (node[prop] === value) return true 2431 node[prop] = value 2432 if (prop === 'name' || prop === 'params' || prop === 'selector') { 2433 node.markDirty() 2434 } 2435 return true 2436 } 2437 } 2438 } 2439 2440 index(child) { 2441 if (typeof child === 'number') return child 2442 if (child.proxyOf) child = child.proxyOf 2443 return this.proxyOf.nodes.indexOf(child) 2444 } 2445 2446 insertAfter(exist, add) { 2447 let existIndex = this.index(exist) 2448 let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse() 2449 existIndex = this.index(exist) 2450 for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node) 2451 2452 let index 2453 for (let id in this.indexes) { 2454 index = this.indexes[id] 2455 if (existIndex < index) { 2456 this.indexes[id] = index + nodes.length 2457 } 2458 } 2459 2460 this.markDirty() 2461 2462 return this 2463 } 2464 2465 insertBefore(exist, add) { 2466 let existIndex = this.index(exist) 2467 let type = existIndex === 0 ? 'prepend' : false 2468 let nodes = this.normalize( 2469 add, 2470 this.proxyOf.nodes[existIndex], 2471 type 2472 ).reverse() 2473 existIndex = this.index(exist) 2474 for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node) 2475 2476 let index 2477 for (let id in this.indexes) { 2478 index = this.indexes[id] 2479 if (existIndex <= index) { 2480 this.indexes[id] = index + nodes.length 2481 } 2482 } 2483 2484 this.markDirty() 2485 2486 return this 2487 } 2488 2489 normalize(nodes, sample) { 2490 if (typeof nodes === 'string') { 2491 nodes = cleanSource(parse(nodes).nodes) 2492 } else if (typeof nodes === 'undefined') { 2493 nodes = [] 2494 } else if (Array.isArray(nodes)) { 2495 nodes = nodes.slice(0) 2496 for (let i of nodes) { 2497 if (i.parent) i.parent.removeChild(i, 'ignore') 2498 } 2499 } else if (nodes.type === 'root' && this.type !== 'document') { 2500 nodes = nodes.nodes.slice(0) 2501 for (let i of nodes) { 2502 if (i.parent) i.parent.removeChild(i, 'ignore') 2503 } 2504 } else if (nodes.type) { 2505 nodes = [nodes] 2506 } else if (nodes.prop) { 2507 if (typeof nodes.value === 'undefined') { 2508 throw new Error('Value field is missed in node creation') 2509 } else if (typeof nodes.value !== 'string') { 2510 nodes.value = String(nodes.value) 2511 } 2512 nodes = [new Declaration(nodes)] 2513 } else if (nodes.selector || nodes.selectors) { 2514 nodes = [new Rule(nodes)] 2515 } else if (nodes.name) { 2516 nodes = [new AtRule(nodes)] 2517 } else if (nodes.text) { 2518 nodes = [new Comment(nodes)] 2519 } else { 2520 throw new Error('Unknown node type in node creation') 2521 } 2522 2523 let processed = nodes.map(i => { 2524 /* c8 ignore next */ 2525 if (!i[my]) Container.rebuild(i) 2526 i = i.proxyOf 2527 if (i.parent) i.parent.removeChild(i) 2528 if (i[isClean]) markTreeDirty(i) 2529 2530 if (!i.raws) i.raws = {} 2531 if (typeof i.raws.before === 'undefined') { 2532 if (sample && typeof sample.raws.before !== 'undefined') { 2533 i.raws.before = sample.raws.before.replace(/\S/g, '') 2534 } 2535 } 2536 i.parent = this.proxyOf 2537 return i 2538 }) 2539 2540 return processed 2541 } 2542 2543 prepend(...children) { 2544 children = children.reverse() 2545 for (let child of children) { 2546 let nodes = this.normalize(child, this.first, 'prepend').reverse() 2547 for (let node of nodes) this.proxyOf.nodes.unshift(node) 2548 for (let id in this.indexes) { 2549 this.indexes[id] = this.indexes[id] + nodes.length 2550 } 2551 } 2552 2553 this.markDirty() 2554 2555 return this 2556 } 2557 2558 push(child) { 2559 child.parent = this 2560 this.proxyOf.nodes.push(child) 2561 return this 2562 } 2563 2564 removeAll() { 2565 for (let node of this.proxyOf.nodes) node.parent = undefined 2566 this.proxyOf.nodes = [] 2567 2568 this.markDirty() 2569 2570 return this 2571 } 2572 2573 removeChild(child) { 2574 child = this.index(child) 2575 this.proxyOf.nodes[child].parent = undefined 2576 this.proxyOf.nodes.splice(child, 1) 2577 2578 let index 2579 for (let id in this.indexes) { 2580 index = this.indexes[id] 2581 if (index >= child) { 2582 this.indexes[id] = index - 1 2583 } 2584 } 2585 2586 this.markDirty() 2587 2588 return this 2589 } 2590 2591 replaceValues(pattern, opts, callback) { 2592 if (!callback) { 2593 callback = opts 2594 opts = {} 2595 } 2596 2597 this.walkDecls(decl => { 2598 if (opts.props && !opts.props.includes(decl.prop)) return 2599 if (opts.fast && !decl.value.includes(opts.fast)) return 2600 2601 decl.value = decl.value.replace(pattern, callback) 2602 }) 2603 2604 this.markDirty() 2605 2606 return this 2607 } 2608 2609 some(condition) { 2610 return this.nodes.some(condition) 2611 } 2612 2613 walk(callback) { 2614 return this.each((child, i) => { 2615 let result 2616 try { 2617 result = callback(child, i) 2618 } catch (e) { 2619 throw child.addToError(e) 2620 } 2621 if (result !== false && child.walk) { 2622 result = child.walk(callback) 2623 } 2624 2625 return result 2626 }) 2627 } 2628 2629 walkAtRules(name, callback) { 2630 if (!callback) { 2631 callback = name 2632 return this.walk((child, i) => { 2633 if (child.type === 'atrule') { 2634 return callback(child, i) 2635 } 2636 }) 2637 } 2638 if (name instanceof RegExp) { 2639 return this.walk((child, i) => { 2640 if (child.type === 'atrule' && name.test(child.name)) { 2641 return callback(child, i) 2642 } 2643 }) 2644 } 2645 return this.walk((child, i) => { 2646 if (child.type === 'atrule' && child.name === name) { 2647 return callback(child, i) 2648 } 2649 }) 2650 } 2651 2652 walkComments(callback) { 2653 return this.walk((child, i) => { 2654 if (child.type === 'comment') { 2655 return callback(child, i) 2656 } 2657 }) 2658 } 2659 2660 walkDecls(prop, callback) { 2661 if (!callback) { 2662 callback = prop 2663 return this.walk((child, i) => { 2664 if (child.type === 'decl') { 2665 return callback(child, i) 2666 } 2667 }) 2668 } 2669 if (prop instanceof RegExp) { 2670 return this.walk((child, i) => { 2671 if (child.type === 'decl' && prop.test(child.prop)) { 2672 return callback(child, i) 2673 } 2674 }) 2675 } 2676 return this.walk((child, i) => { 2677 if (child.type === 'decl' && child.prop === prop) { 2678 return callback(child, i) 2679 } 2680 }) 2681 } 2682 2683 walkRules(selector, callback) { 2684 if (!callback) { 2685 callback = selector 2686 2687 return this.walk((child, i) => { 2688 if (child.type === 'rule') { 2689 return callback(child, i) 2690 } 2691 }) 2692 } 2693 if (selector instanceof RegExp) { 2694 return this.walk((child, i) => { 2695 if (child.type === 'rule' && selector.test(child.selector)) { 2696 return callback(child, i) 2697 } 2698 }) 2699 } 2700 return this.walk((child, i) => { 2701 if (child.type === 'rule' && child.selector === selector) { 2702 return callback(child, i) 2703 } 2704 }) 2705 } 2706 2707 get first() { 2708 if (!this.proxyOf.nodes) return undefined 2709 return this.proxyOf.nodes[0] 2710 } 2711 2712 get last() { 2713 if (!this.proxyOf.nodes) return undefined 2714 return this.proxyOf.nodes[this.proxyOf.nodes.length - 1] 2715 } 2716 } 2717 2718 Container.registerParse = dependant => { 2719 parse = dependant 2720 } 2721 2722 Container.registerRule = dependant => { 2723 Rule = dependant 2724 } 2725 2726 Container.registerAtRule = dependant => { 2727 AtRule = dependant 2728 } 2729 2730 Container.registerRoot = dependant => { 2731 Root = dependant 2732 } 2733 2734 module.exports = Container 2735 Container.default = Container 2736 2737 /* c8 ignore start */ 2738 Container.rebuild = node => { 2739 if (node.type === 'atrule') { 2740 Object.setPrototypeOf(node, AtRule.prototype) 2741 } else if (node.type === 'rule') { 2742 Object.setPrototypeOf(node, Rule.prototype) 2743 } else if (node.type === 'decl') { 2744 Object.setPrototypeOf(node, Declaration.prototype) 2745 } else if (node.type === 'comment') { 2746 Object.setPrototypeOf(node, Comment.prototype) 2747 } else if (node.type === 'root') { 2748 Object.setPrototypeOf(node, Root.prototype) 2749 } 2750 2751 node[my] = true 2752 2753 if (node.nodes) { 2754 node.nodes.forEach(child => { 2755 Container.rebuild(child) 2756 }) 2757 } 2758 } 2759 /* c8 ignore stop */ 2760 2761 2762 /***/ }), 2763 2764 /***/ 356: 2765 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2766 2767 "use strict"; 2768 2769 2770 let pico = __webpack_require__(2775) 2771 2772 let terminalHighlight = __webpack_require__(9746) 2773 2774 class CssSyntaxError extends Error { 2775 constructor(message, line, column, source, file, plugin) { 2776 super(message) 2777 this.name = 'CssSyntaxError' 2778 this.reason = message 2779 2780 if (file) { 2781 this.file = file 2782 } 2783 if (source) { 2784 this.source = source 2785 } 2786 if (plugin) { 2787 this.plugin = plugin 2788 } 2789 if (typeof line !== 'undefined' && typeof column !== 'undefined') { 2790 if (typeof line === 'number') { 2791 this.line = line 2792 this.column = column 2793 } else { 2794 this.line = line.line 2795 this.column = line.column 2796 this.endLine = column.line 2797 this.endColumn = column.column 2798 } 2799 } 2800 2801 this.setMessage() 2802 2803 if (Error.captureStackTrace) { 2804 Error.captureStackTrace(this, CssSyntaxError) 2805 } 2806 } 2807 2808 setMessage() { 2809 this.message = this.plugin ? this.plugin + ': ' : '' 2810 this.message += this.file ? this.file : '<css input>' 2811 if (typeof this.line !== 'undefined') { 2812 this.message += ':' + this.line + ':' + this.column 2813 } 2814 this.message += ': ' + this.reason 2815 } 2816 2817 showSourceCode(color) { 2818 if (!this.source) return '' 2819 2820 let css = this.source 2821 if (color == null) color = pico.isColorSupported 2822 2823 let aside = text => text 2824 let mark = text => text 2825 let highlight = text => text 2826 if (color) { 2827 let { bold, gray, red } = pico.createColors(true) 2828 mark = text => bold(red(text)) 2829 aside = text => gray(text) 2830 if (terminalHighlight) { 2831 highlight = text => terminalHighlight(text) 2832 } 2833 } 2834 2835 let lines = css.split(/\r?\n/) 2836 let start = Math.max(this.line - 3, 0) 2837 let end = Math.min(this.line + 2, lines.length) 2838 let maxWidth = String(end).length 2839 2840 return lines 2841 .slice(start, end) 2842 .map((line, index) => { 2843 let number = start + 1 + index 2844 let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ' 2845 if (number === this.line) { 2846 if (line.length > 160) { 2847 let padding = 20 2848 let subLineStart = Math.max(0, this.column - padding) 2849 let subLineEnd = Math.max( 2850 this.column + padding, 2851 this.endColumn + padding 2852 ) 2853 let subLine = line.slice(subLineStart, subLineEnd) 2854 2855 let spacing = 2856 aside(gutter.replace(/\d/g, ' ')) + 2857 line 2858 .slice(0, Math.min(this.column - 1, padding - 1)) 2859 .replace(/[^\t]/g, ' ') 2860 2861 return ( 2862 mark('>') + 2863 aside(gutter) + 2864 highlight(subLine) + 2865 '\n ' + 2866 spacing + 2867 mark('^') 2868 ) 2869 } 2870 2871 let spacing = 2872 aside(gutter.replace(/\d/g, ' ')) + 2873 line.slice(0, this.column - 1).replace(/[^\t]/g, ' ') 2874 2875 return ( 2876 mark('>') + 2877 aside(gutter) + 2878 highlight(line) + 2879 '\n ' + 2880 spacing + 2881 mark('^') 2882 ) 2883 } 2884 2885 return ' ' + aside(gutter) + highlight(line) 2886 }) 2887 .join('\n') 2888 } 2889 2890 toString() { 2891 let code = this.showSourceCode() 2892 if (code) { 2893 code = '\n\n' + code + '\n' 2894 } 2895 return this.name + ': ' + this.message + code 2896 } 2897 } 2898 2899 module.exports = CssSyntaxError 2900 CssSyntaxError.default = CssSyntaxError 2901 2902 2903 /***/ }), 2904 2905 /***/ 1516: 2906 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2907 2908 "use strict"; 2909 2910 2911 let Node = __webpack_require__(7490) 2912 2913 class Declaration extends Node { 2914 constructor(defaults) { 2915 if ( 2916 defaults && 2917 typeof defaults.value !== 'undefined' && 2918 typeof defaults.value !== 'string' 2919 ) { 2920 defaults = { ...defaults, value: String(defaults.value) } 2921 } 2922 super(defaults) 2923 this.type = 'decl' 2924 } 2925 2926 get variable() { 2927 return this.prop.startsWith('--') || this.prop[0] === '$' 2928 } 2929 } 2930 2931 module.exports = Declaration 2932 Declaration.default = Declaration 2933 2934 2935 /***/ }), 2936 2937 /***/ 271: 2938 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2939 2940 "use strict"; 2941 2942 2943 let Container = __webpack_require__(683) 2944 2945 let LazyResult, Processor 2946 2947 class Document extends Container { 2948 constructor(defaults) { 2949 // type needs to be passed to super, otherwise child roots won't be normalized correctly 2950 super({ type: 'document', ...defaults }) 2951 2952 if (!this.nodes) { 2953 this.nodes = [] 2954 } 2955 } 2956 2957 toResult(opts = {}) { 2958 let lazy = new LazyResult(new Processor(), this, opts) 2959 2960 return lazy.stringify() 2961 } 2962 } 2963 2964 Document.registerLazyResult = dependant => { 2965 LazyResult = dependant 2966 } 2967 2968 Document.registerProcessor = dependant => { 2969 Processor = dependant 2970 } 2971 2972 module.exports = Document 2973 Document.default = Document 2974 2975 2976 /***/ }), 2977 2978 /***/ 8940: 2979 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2980 2981 "use strict"; 2982 2983 2984 let AtRule = __webpack_require__(1326) 2985 let Comment = __webpack_require__(6589) 2986 let Declaration = __webpack_require__(1516) 2987 let Input = __webpack_require__(5380) 2988 let PreviousMap = __webpack_require__(5696) 2989 let Root = __webpack_require__(9434) 2990 let Rule = __webpack_require__(4092) 2991 2992 function fromJSON(json, inputs) { 2993 if (Array.isArray(json)) return json.map(n => fromJSON(n)) 2994 2995 let { inputs: ownInputs, ...defaults } = json 2996 if (ownInputs) { 2997 inputs = [] 2998 for (let input of ownInputs) { 2999 let inputHydrated = { ...input, __proto__: Input.prototype } 3000 if (inputHydrated.map) { 3001 inputHydrated.map = { 3002 ...inputHydrated.map, 3003 __proto__: PreviousMap.prototype 3004 } 3005 } 3006 inputs.push(inputHydrated) 3007 } 3008 } 3009 if (defaults.nodes) { 3010 defaults.nodes = json.nodes.map(n => fromJSON(n, inputs)) 3011 } 3012 if (defaults.source) { 3013 let { inputId, ...source } = defaults.source 3014 defaults.source = source 3015 if (inputId != null) { 3016 defaults.source.input = inputs[inputId] 3017 } 3018 } 3019 if (defaults.type === 'root') { 3020 return new Root(defaults) 3021 } else if (defaults.type === 'decl') { 3022 return new Declaration(defaults) 3023 } else if (defaults.type === 'rule') { 3024 return new Rule(defaults) 3025 } else if (defaults.type === 'comment') { 3026 return new Comment(defaults) 3027 } else if (defaults.type === 'atrule') { 3028 return new AtRule(defaults) 3029 } else { 3030 throw new Error('Unknown node type: ' + json.type) 3031 } 3032 } 3033 3034 module.exports = fromJSON 3035 fromJSON.default = fromJSON 3036 3037 3038 /***/ }), 3039 3040 /***/ 5380: 3041 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3042 3043 "use strict"; 3044 3045 3046 let { nanoid } = __webpack_require__(5042) 3047 let { isAbsolute, resolve } = __webpack_require__(197) 3048 let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(1866) 3049 let { fileURLToPath, pathToFileURL } = __webpack_require__(2739) 3050 3051 let CssSyntaxError = __webpack_require__(356) 3052 let PreviousMap = __webpack_require__(5696) 3053 let terminalHighlight = __webpack_require__(9746) 3054 3055 let fromOffsetCache = Symbol('fromOffsetCache') 3056 3057 let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator) 3058 let pathAvailable = Boolean(resolve && isAbsolute) 3059 3060 class Input { 3061 constructor(css, opts = {}) { 3062 if ( 3063 css === null || 3064 typeof css === 'undefined' || 3065 (typeof css === 'object' && !css.toString) 3066 ) { 3067 throw new Error(`PostCSS received $css} instead of CSS string`) 3068 } 3069 3070 this.css = css.toString() 3071 3072 if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') { 3073 this.hasBOM = true 3074 this.css = this.css.slice(1) 3075 } else { 3076 this.hasBOM = false 3077 } 3078 3079 if (opts.from) { 3080 if ( 3081 !pathAvailable || 3082 /^\w+:\/\//.test(opts.from) || 3083 isAbsolute(opts.from) 3084 ) { 3085 this.file = opts.from 3086 } else { 3087 this.file = resolve(opts.from) 3088 } 3089 } 3090 3091 if (pathAvailable && sourceMapAvailable) { 3092 let map = new PreviousMap(this.css, opts) 3093 if (map.text) { 3094 this.map = map 3095 let file = map.consumer().file 3096 if (!this.file && file) this.file = this.mapResolve(file) 3097 } 3098 } 3099 3100 if (!this.file) { 3101 this.id = '<input css ' + nanoid(6) + '>' 3102 } 3103 if (this.map) this.map.file = this.from 3104 } 3105 3106 error(message, line, column, opts = {}) { 3107 let endColumn, endLine, result 3108 3109 if (line && typeof line === 'object') { 3110 let start = line 3111 let end = column 3112 if (typeof start.offset === 'number') { 3113 let pos = this.fromOffset(start.offset) 3114 line = pos.line 3115 column = pos.col 3116 } else { 3117 line = start.line 3118 column = start.column 3119 } 3120 if (typeof end.offset === 'number') { 3121 let pos = this.fromOffset(end.offset) 3122 endLine = pos.line 3123 endColumn = pos.col 3124 } else { 3125 endLine = end.line 3126 endColumn = end.column 3127 } 3128 } else if (!column) { 3129 let pos = this.fromOffset(line) 3130 line = pos.line 3131 column = pos.col 3132 } 3133 3134 let origin = this.origin(line, column, endLine, endColumn) 3135 if (origin) { 3136 result = new CssSyntaxError( 3137 message, 3138 origin.endLine === undefined 3139 ? origin.line 3140 : { column: origin.column, line: origin.line }, 3141 origin.endLine === undefined 3142 ? origin.column 3143 : { column: origin.endColumn, line: origin.endLine }, 3144 origin.source, 3145 origin.file, 3146 opts.plugin 3147 ) 3148 } else { 3149 result = new CssSyntaxError( 3150 message, 3151 endLine === undefined ? line : { column, line }, 3152 endLine === undefined ? column : { column: endColumn, line: endLine }, 3153 this.css, 3154 this.file, 3155 opts.plugin 3156 ) 3157 } 3158 3159 result.input = { column, endColumn, endLine, line, source: this.css } 3160 if (this.file) { 3161 if (pathToFileURL) { 3162 result.input.url = pathToFileURL(this.file).toString() 3163 } 3164 result.input.file = this.file 3165 } 3166 3167 return result 3168 } 3169 3170 fromOffset(offset) { 3171 let lastLine, lineToIndex 3172 if (!this[fromOffsetCache]) { 3173 let lines = this.css.split('\n') 3174 lineToIndex = new Array(lines.length) 3175 let prevIndex = 0 3176 3177 for (let i = 0, l = lines.length; i < l; i++) { 3178 lineToIndex[i] = prevIndex 3179 prevIndex += lines[i].length + 1 3180 } 3181 3182 this[fromOffsetCache] = lineToIndex 3183 } else { 3184 lineToIndex = this[fromOffsetCache] 3185 } 3186 lastLine = lineToIndex[lineToIndex.length - 1] 3187 3188 let min = 0 3189 if (offset >= lastLine) { 3190 min = lineToIndex.length - 1 3191 } else { 3192 let max = lineToIndex.length - 2 3193 let mid 3194 while (min < max) { 3195 mid = min + ((max - min) >> 1) 3196 if (offset < lineToIndex[mid]) { 3197 max = mid - 1 3198 } else if (offset >= lineToIndex[mid + 1]) { 3199 min = mid + 1 3200 } else { 3201 min = mid 3202 break 3203 } 3204 } 3205 } 3206 return { 3207 col: offset - lineToIndex[min] + 1, 3208 line: min + 1 3209 } 3210 } 3211 3212 mapResolve(file) { 3213 if (/^\w+:\/\//.test(file)) { 3214 return file 3215 } 3216 return resolve(this.map.consumer().sourceRoot || this.map.root || '.', file) 3217 } 3218 3219 origin(line, column, endLine, endColumn) { 3220 if (!this.map) return false 3221 let consumer = this.map.consumer() 3222 3223 let from = consumer.originalPositionFor({ column, line }) 3224 if (!from.source) return false 3225 3226 let to 3227 if (typeof endLine === 'number') { 3228 to = consumer.originalPositionFor({ column: endColumn, line: endLine }) 3229 } 3230 3231 let fromUrl 3232 3233 if (isAbsolute(from.source)) { 3234 fromUrl = pathToFileURL(from.source) 3235 } else { 3236 fromUrl = new URL( 3237 from.source, 3238 this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile) 3239 ) 3240 } 3241 3242 let result = { 3243 column: from.column, 3244 endColumn: to && to.column, 3245 endLine: to && to.line, 3246 line: from.line, 3247 url: fromUrl.toString() 3248 } 3249 3250 if (fromUrl.protocol === 'file:') { 3251 if (fileURLToPath) { 3252 result.file = fileURLToPath(fromUrl) 3253 } else { 3254 /* c8 ignore next 2 */ 3255 throw new Error(`file: protocol is not available in this PostCSS build`) 3256 } 3257 } 3258 3259 let source = consumer.sourceContentFor(from.source) 3260 if (source) result.source = source 3261 3262 return result 3263 } 3264 3265 toJSON() { 3266 let json = {} 3267 for (let name of ['hasBOM', 'css', 'file', 'id']) { 3268 if (this[name] != null) { 3269 json[name] = this[name] 3270 } 3271 } 3272 if (this.map) { 3273 json.map = { ...this.map } 3274 if (json.map.consumerCache) { 3275 json.map.consumerCache = undefined 3276 } 3277 } 3278 return json 3279 } 3280 3281 get from() { 3282 return this.file || this.id 3283 } 3284 } 3285 3286 module.exports = Input 3287 Input.default = Input 3288 3289 if (terminalHighlight && terminalHighlight.registerInput) { 3290 terminalHighlight.registerInput(Input) 3291 } 3292 3293 3294 /***/ }), 3295 3296 /***/ 448: 3297 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3298 3299 "use strict"; 3300 3301 3302 let Container = __webpack_require__(683) 3303 let Document = __webpack_require__(271) 3304 let MapGenerator = __webpack_require__(1670) 3305 let parse = __webpack_require__(4295) 3306 let Result = __webpack_require__(9055) 3307 let Root = __webpack_require__(9434) 3308 let stringify = __webpack_require__(633) 3309 let { isClean, my } = __webpack_require__(1381) 3310 let warnOnce = __webpack_require__(3122) 3311 3312 const TYPE_TO_CLASS_NAME = { 3313 atrule: 'AtRule', 3314 comment: 'Comment', 3315 decl: 'Declaration', 3316 document: 'Document', 3317 root: 'Root', 3318 rule: 'Rule' 3319 } 3320 3321 const PLUGIN_PROPS = { 3322 AtRule: true, 3323 AtRuleExit: true, 3324 Comment: true, 3325 CommentExit: true, 3326 Declaration: true, 3327 DeclarationExit: true, 3328 Document: true, 3329 DocumentExit: true, 3330 Once: true, 3331 OnceExit: true, 3332 postcssPlugin: true, 3333 prepare: true, 3334 Root: true, 3335 RootExit: true, 3336 Rule: true, 3337 RuleExit: true 3338 } 3339 3340 const NOT_VISITORS = { 3341 Once: true, 3342 postcssPlugin: true, 3343 prepare: true 3344 } 3345 3346 const CHILDREN = 0 3347 3348 function isPromise(obj) { 3349 return typeof obj === 'object' && typeof obj.then === 'function' 3350 } 3351 3352 function getEvents(node) { 3353 let key = false 3354 let type = TYPE_TO_CLASS_NAME[node.type] 3355 if (node.type === 'decl') { 3356 key = node.prop.toLowerCase() 3357 } else if (node.type === 'atrule') { 3358 key = node.name.toLowerCase() 3359 } 3360 3361 if (key && node.append) { 3362 return [ 3363 type, 3364 type + '-' + key, 3365 CHILDREN, 3366 type + 'Exit', 3367 type + 'Exit-' + key 3368 ] 3369 } else if (key) { 3370 return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key] 3371 } else if (node.append) { 3372 return [type, CHILDREN, type + 'Exit'] 3373 } else { 3374 return [type, type + 'Exit'] 3375 } 3376 } 3377 3378 function toStack(node) { 3379 let events 3380 if (node.type === 'document') { 3381 events = ['Document', CHILDREN, 'DocumentExit'] 3382 } else if (node.type === 'root') { 3383 events = ['Root', CHILDREN, 'RootExit'] 3384 } else { 3385 events = getEvents(node) 3386 } 3387 3388 return { 3389 eventIndex: 0, 3390 events, 3391 iterator: 0, 3392 node, 3393 visitorIndex: 0, 3394 visitors: [] 3395 } 3396 } 3397 3398 function cleanMarks(node) { 3399 node[isClean] = false 3400 if (node.nodes) node.nodes.forEach(i => cleanMarks(i)) 3401 return node 3402 } 3403 3404 let postcss = {} 3405 3406 class LazyResult { 3407 constructor(processor, css, opts) { 3408 this.stringified = false 3409 this.processed = false 3410 3411 let root 3412 if ( 3413 typeof css === 'object' && 3414 css !== null && 3415 (css.type === 'root' || css.type === 'document') 3416 ) { 3417 root = cleanMarks(css) 3418 } else if (css instanceof LazyResult || css instanceof Result) { 3419 root = cleanMarks(css.root) 3420 if (css.map) { 3421 if (typeof opts.map === 'undefined') opts.map = {} 3422 if (!opts.map.inline) opts.map.inline = false 3423 opts.map.prev = css.map 3424 } 3425 } else { 3426 let parser = parse 3427 if (opts.syntax) parser = opts.syntax.parse 3428 if (opts.parser) parser = opts.parser 3429 if (parser.parse) parser = parser.parse 3430 3431 try { 3432 root = parser(css, opts) 3433 } catch (error) { 3434 this.processed = true 3435 this.error = error 3436 } 3437 3438 if (root && !root[my]) { 3439 /* c8 ignore next 2 */ 3440 Container.rebuild(root) 3441 } 3442 } 3443 3444 this.result = new Result(processor, root, opts) 3445 this.helpers = { ...postcss, postcss, result: this.result } 3446 this.plugins = this.processor.plugins.map(plugin => { 3447 if (typeof plugin === 'object' && plugin.prepare) { 3448 return { ...plugin, ...plugin.prepare(this.result) } 3449 } else { 3450 return plugin 3451 } 3452 }) 3453 } 3454 3455 async() { 3456 if (this.error) return Promise.reject(this.error) 3457 if (this.processed) return Promise.resolve(this.result) 3458 if (!this.processing) { 3459 this.processing = this.runAsync() 3460 } 3461 return this.processing 3462 } 3463 3464 catch(onRejected) { 3465 return this.async().catch(onRejected) 3466 } 3467 3468 finally(onFinally) { 3469 return this.async().then(onFinally, onFinally) 3470 } 3471 3472 getAsyncError() { 3473 throw new Error('Use process(css).then(cb) to work with async plugins') 3474 } 3475 3476 handleError(error, node) { 3477 let plugin = this.result.lastPlugin 3478 try { 3479 if (node) node.addToError(error) 3480 this.error = error 3481 if (error.name === 'CssSyntaxError' && !error.plugin) { 3482 error.plugin = plugin.postcssPlugin 3483 error.setMessage() 3484 } else if (plugin.postcssVersion) { 3485 if (false) {} 3486 } 3487 } catch (err) { 3488 /* c8 ignore next 3 */ 3489 // eslint-disable-next-line no-console 3490 if (console && console.error) console.error(err) 3491 } 3492 return error 3493 } 3494 3495 prepareVisitors() { 3496 this.listeners = {} 3497 let add = (plugin, type, cb) => { 3498 if (!this.listeners[type]) this.listeners[type] = [] 3499 this.listeners[type].push([plugin, cb]) 3500 } 3501 for (let plugin of this.plugins) { 3502 if (typeof plugin === 'object') { 3503 for (let event in plugin) { 3504 if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) { 3505 throw new Error( 3506 `Unknown event $event} in $plugin.postcssPlugin}. ` + 3507 `Try to update PostCSS ($this.processor.version} now).` 3508 ) 3509 } 3510 if (!NOT_VISITORS[event]) { 3511 if (typeof plugin[event] === 'object') { 3512 for (let filter in plugin[event]) { 3513 if (filter === '*') { 3514 add(plugin, event, plugin[event][filter]) 3515 } else { 3516 add( 3517 plugin, 3518 event + '-' + filter.toLowerCase(), 3519 plugin[event][filter] 3520 ) 3521 } 3522 } 3523 } else if (typeof plugin[event] === 'function') { 3524 add(plugin, event, plugin[event]) 3525 } 3526 } 3527 } 3528 } 3529 } 3530 this.hasListener = Object.keys(this.listeners).length > 0 3531 } 3532 3533 async runAsync() { 3534 this.plugin = 0 3535 for (let i = 0; i < this.plugins.length; i++) { 3536 let plugin = this.plugins[i] 3537 let promise = this.runOnRoot(plugin) 3538 if (isPromise(promise)) { 3539 try { 3540 await promise 3541 } catch (error) { 3542 throw this.handleError(error) 3543 } 3544 } 3545 } 3546 3547 this.prepareVisitors() 3548 if (this.hasListener) { 3549 let root = this.result.root 3550 while (!root[isClean]) { 3551 root[isClean] = true 3552 let stack = [toStack(root)] 3553 while (stack.length > 0) { 3554 let promise = this.visitTick(stack) 3555 if (isPromise(promise)) { 3556 try { 3557 await promise 3558 } catch (e) { 3559 let node = stack[stack.length - 1].node 3560 throw this.handleError(e, node) 3561 } 3562 } 3563 } 3564 } 3565 3566 if (this.listeners.OnceExit) { 3567 for (let [plugin, visitor] of this.listeners.OnceExit) { 3568 this.result.lastPlugin = plugin 3569 try { 3570 if (root.type === 'document') { 3571 let roots = root.nodes.map(subRoot => 3572 visitor(subRoot, this.helpers) 3573 ) 3574 3575 await Promise.all(roots) 3576 } else { 3577 await visitor(root, this.helpers) 3578 } 3579 } catch (e) { 3580 throw this.handleError(e) 3581 } 3582 } 3583 } 3584 } 3585 3586 this.processed = true 3587 return this.stringify() 3588 } 3589 3590 runOnRoot(plugin) { 3591 this.result.lastPlugin = plugin 3592 try { 3593 if (typeof plugin === 'object' && plugin.Once) { 3594 if (this.result.root.type === 'document') { 3595 let roots = this.result.root.nodes.map(root => 3596 plugin.Once(root, this.helpers) 3597 ) 3598 3599 if (isPromise(roots[0])) { 3600 return Promise.all(roots) 3601 } 3602 3603 return roots 3604 } 3605 3606 return plugin.Once(this.result.root, this.helpers) 3607 } else if (typeof plugin === 'function') { 3608 return plugin(this.result.root, this.result) 3609 } 3610 } catch (error) { 3611 throw this.handleError(error) 3612 } 3613 } 3614 3615 stringify() { 3616 if (this.error) throw this.error 3617 if (this.stringified) return this.result 3618 this.stringified = true 3619 3620 this.sync() 3621 3622 let opts = this.result.opts 3623 let str = stringify 3624 if (opts.syntax) str = opts.syntax.stringify 3625 if (opts.stringifier) str = opts.stringifier 3626 if (str.stringify) str = str.stringify 3627 3628 let map = new MapGenerator(str, this.result.root, this.result.opts) 3629 let data = map.generate() 3630 this.result.css = data[0] 3631 this.result.map = data[1] 3632 3633 return this.result 3634 } 3635 3636 sync() { 3637 if (this.error) throw this.error 3638 if (this.processed) return this.result 3639 this.processed = true 3640 3641 if (this.processing) { 3642 throw this.getAsyncError() 3643 } 3644 3645 for (let plugin of this.plugins) { 3646 let promise = this.runOnRoot(plugin) 3647 if (isPromise(promise)) { 3648 throw this.getAsyncError() 3649 } 3650 } 3651 3652 this.prepareVisitors() 3653 if (this.hasListener) { 3654 let root = this.result.root 3655 while (!root[isClean]) { 3656 root[isClean] = true 3657 this.walkSync(root) 3658 } 3659 if (this.listeners.OnceExit) { 3660 if (root.type === 'document') { 3661 for (let subRoot of root.nodes) { 3662 this.visitSync(this.listeners.OnceExit, subRoot) 3663 } 3664 } else { 3665 this.visitSync(this.listeners.OnceExit, root) 3666 } 3667 } 3668 } 3669 3670 return this.result 3671 } 3672 3673 then(onFulfilled, onRejected) { 3674 if (false) {} 3675 return this.async().then(onFulfilled, onRejected) 3676 } 3677 3678 toString() { 3679 return this.css 3680 } 3681 3682 visitSync(visitors, node) { 3683 for (let [plugin, visitor] of visitors) { 3684 this.result.lastPlugin = plugin 3685 let promise 3686 try { 3687 promise = visitor(node, this.helpers) 3688 } catch (e) { 3689 throw this.handleError(e, node.proxyOf) 3690 } 3691 if (node.type !== 'root' && node.type !== 'document' && !node.parent) { 3692 return true 3693 } 3694 if (isPromise(promise)) { 3695 throw this.getAsyncError() 3696 } 3697 } 3698 } 3699 3700 visitTick(stack) { 3701 let visit = stack[stack.length - 1] 3702 let { node, visitors } = visit 3703 3704 if (node.type !== 'root' && node.type !== 'document' && !node.parent) { 3705 stack.pop() 3706 return 3707 } 3708 3709 if (visitors.length > 0 && visit.visitorIndex < visitors.length) { 3710 let [plugin, visitor] = visitors[visit.visitorIndex] 3711 visit.visitorIndex += 1 3712 if (visit.visitorIndex === visitors.length) { 3713 visit.visitors = [] 3714 visit.visitorIndex = 0 3715 } 3716 this.result.lastPlugin = plugin 3717 try { 3718 return visitor(node.toProxy(), this.helpers) 3719 } catch (e) { 3720 throw this.handleError(e, node) 3721 } 3722 } 3723 3724 if (visit.iterator !== 0) { 3725 let iterator = visit.iterator 3726 let child 3727 while ((child = node.nodes[node.indexes[iterator]])) { 3728 node.indexes[iterator] += 1 3729 if (!child[isClean]) { 3730 child[isClean] = true 3731 stack.push(toStack(child)) 3732 return 3733 } 3734 } 3735 visit.iterator = 0 3736 delete node.indexes[iterator] 3737 } 3738 3739 let events = visit.events 3740 while (visit.eventIndex < events.length) { 3741 let event = events[visit.eventIndex] 3742 visit.eventIndex += 1 3743 if (event === CHILDREN) { 3744 if (node.nodes && node.nodes.length) { 3745 node[isClean] = true 3746 visit.iterator = node.getIterator() 3747 } 3748 return 3749 } else if (this.listeners[event]) { 3750 visit.visitors = this.listeners[event] 3751 return 3752 } 3753 } 3754 stack.pop() 3755 } 3756 3757 walkSync(node) { 3758 node[isClean] = true 3759 let events = getEvents(node) 3760 for (let event of events) { 3761 if (event === CHILDREN) { 3762 if (node.nodes) { 3763 node.each(child => { 3764 if (!child[isClean]) this.walkSync(child) 3765 }) 3766 } 3767 } else { 3768 let visitors = this.listeners[event] 3769 if (visitors) { 3770 if (this.visitSync(visitors, node.toProxy())) return 3771 } 3772 } 3773 } 3774 } 3775 3776 warnings() { 3777 return this.sync().warnings() 3778 } 3779 3780 get content() { 3781 return this.stringify().content 3782 } 3783 3784 get css() { 3785 return this.stringify().css 3786 } 3787 3788 get map() { 3789 return this.stringify().map 3790 } 3791 3792 get messages() { 3793 return this.sync().messages 3794 } 3795 3796 get opts() { 3797 return this.result.opts 3798 } 3799 3800 get processor() { 3801 return this.result.processor 3802 } 3803 3804 get root() { 3805 return this.sync().root 3806 } 3807 3808 get [Symbol.toStringTag]() { 3809 return 'LazyResult' 3810 } 3811 } 3812 3813 LazyResult.registerPostcss = dependant => { 3814 postcss = dependant 3815 } 3816 3817 module.exports = LazyResult 3818 LazyResult.default = LazyResult 3819 3820 Root.registerLazyResult(LazyResult) 3821 Document.registerLazyResult(LazyResult) 3822 3823 3824 /***/ }), 3825 3826 /***/ 7374: 3827 /***/ ((module) => { 3828 3829 "use strict"; 3830 3831 3832 let list = { 3833 comma(string) { 3834 return list.split(string, [','], true) 3835 }, 3836 3837 space(string) { 3838 let spaces = [' ', '\n', '\t'] 3839 return list.split(string, spaces) 3840 }, 3841 3842 split(string, separators, last) { 3843 let array = [] 3844 let current = '' 3845 let split = false 3846 3847 let func = 0 3848 let inQuote = false 3849 let prevQuote = '' 3850 let escape = false 3851 3852 for (let letter of string) { 3853 if (escape) { 3854 escape = false 3855 } else if (letter === '\\') { 3856 escape = true 3857 } else if (inQuote) { 3858 if (letter === prevQuote) { 3859 inQuote = false 3860 } 3861 } else if (letter === '"' || letter === "'") { 3862 inQuote = true 3863 prevQuote = letter 3864 } else if (letter === '(') { 3865 func += 1 3866 } else if (letter === ')') { 3867 if (func > 0) func -= 1 3868 } else if (func === 0) { 3869 if (separators.includes(letter)) split = true 3870 } 3871 3872 if (split) { 3873 if (current !== '') array.push(current.trim()) 3874 current = '' 3875 split = false 3876 } else { 3877 current += letter 3878 } 3879 } 3880 3881 if (last || current !== '') array.push(current.trim()) 3882 return array 3883 } 3884 } 3885 3886 module.exports = list 3887 list.default = list 3888 3889 3890 /***/ }), 3891 3892 /***/ 1670: 3893 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3894 3895 "use strict"; 3896 3897 3898 let { dirname, relative, resolve, sep } = __webpack_require__(197) 3899 let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(1866) 3900 let { pathToFileURL } = __webpack_require__(2739) 3901 3902 let Input = __webpack_require__(5380) 3903 3904 let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator) 3905 let pathAvailable = Boolean(dirname && resolve && relative && sep) 3906 3907 class MapGenerator { 3908 constructor(stringify, root, opts, cssString) { 3909 this.stringify = stringify 3910 this.mapOpts = opts.map || {} 3911 this.root = root 3912 this.opts = opts 3913 this.css = cssString 3914 this.originalCSS = cssString 3915 this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute 3916 3917 this.memoizedFileURLs = new Map() 3918 this.memoizedPaths = new Map() 3919 this.memoizedURLs = new Map() 3920 } 3921 3922 addAnnotation() { 3923 let content 3924 3925 if (this.isInline()) { 3926 content = 3927 'data:application/json;base64,' + this.toBase64(this.map.toString()) 3928 } else if (typeof this.mapOpts.annotation === 'string') { 3929 content = this.mapOpts.annotation 3930 } else if (typeof this.mapOpts.annotation === 'function') { 3931 content = this.mapOpts.annotation(this.opts.to, this.root) 3932 } else { 3933 content = this.outputFile() + '.map' 3934 } 3935 let eol = '\n' 3936 if (this.css.includes('\r\n')) eol = '\r\n' 3937 3938 this.css += eol + '/*# sourceMappingURL=' + content + ' */' 3939 } 3940 3941 applyPrevMaps() { 3942 for (let prev of this.previous()) { 3943 let from = this.toUrl(this.path(prev.file)) 3944 let root = prev.root || dirname(prev.file) 3945 let map 3946 3947 if (this.mapOpts.sourcesContent === false) { 3948 map = new SourceMapConsumer(prev.text) 3949 if (map.sourcesContent) { 3950 map.sourcesContent = null 3951 } 3952 } else { 3953 map = prev.consumer() 3954 } 3955 3956 this.map.applySourceMap(map, from, this.toUrl(this.path(root))) 3957 } 3958 } 3959 3960 clearAnnotation() { 3961 if (this.mapOpts.annotation === false) return 3962 3963 if (this.root) { 3964 let node 3965 for (let i = this.root.nodes.length - 1; i >= 0; i--) { 3966 node = this.root.nodes[i] 3967 if (node.type !== 'comment') continue 3968 if (node.text.startsWith('# sourceMappingURL=')) { 3969 this.root.removeChild(i) 3970 } 3971 } 3972 } else if (this.css) { 3973 this.css = this.css.replace(/\n*\/\*#[\S\s]*?\*\/$/gm, '') 3974 } 3975 } 3976 3977 generate() { 3978 this.clearAnnotation() 3979 if (pathAvailable && sourceMapAvailable && this.isMap()) { 3980 return this.generateMap() 3981 } else { 3982 let result = '' 3983 this.stringify(this.root, i => { 3984 result += i 3985 }) 3986 return [result] 3987 } 3988 } 3989 3990 generateMap() { 3991 if (this.root) { 3992 this.generateString() 3993 } else if (this.previous().length === 1) { 3994 let prev = this.previous()[0].consumer() 3995 prev.file = this.outputFile() 3996 this.map = SourceMapGenerator.fromSourceMap(prev, { 3997 ignoreInvalidMapping: true 3998 }) 3999 } else { 4000 this.map = new SourceMapGenerator({ 4001 file: this.outputFile(), 4002 ignoreInvalidMapping: true 4003 }) 4004 this.map.addMapping({ 4005 generated: { column: 0, line: 1 }, 4006 original: { column: 0, line: 1 }, 4007 source: this.opts.from 4008 ? this.toUrl(this.path(this.opts.from)) 4009 : '<no source>' 4010 }) 4011 } 4012 4013 if (this.isSourcesContent()) this.setSourcesContent() 4014 if (this.root && this.previous().length > 0) this.applyPrevMaps() 4015 if (this.isAnnotation()) this.addAnnotation() 4016 4017 if (this.isInline()) { 4018 return [this.css] 4019 } else { 4020 return [this.css, this.map] 4021 } 4022 } 4023 4024 generateString() { 4025 this.css = '' 4026 this.map = new SourceMapGenerator({ 4027 file: this.outputFile(), 4028 ignoreInvalidMapping: true 4029 }) 4030 4031 let line = 1 4032 let column = 1 4033 4034 let noSource = '<no source>' 4035 let mapping = { 4036 generated: { column: 0, line: 0 }, 4037 original: { column: 0, line: 0 }, 4038 source: '' 4039 } 4040 4041 let last, lines 4042 this.stringify(this.root, (str, node, type) => { 4043 this.css += str 4044 4045 if (node && type !== 'end') { 4046 mapping.generated.line = line 4047 mapping.generated.column = column - 1 4048 if (node.source && node.source.start) { 4049 mapping.source = this.sourcePath(node) 4050 mapping.original.line = node.source.start.line 4051 mapping.original.column = node.source.start.column - 1 4052 this.map.addMapping(mapping) 4053 } else { 4054 mapping.source = noSource 4055 mapping.original.line = 1 4056 mapping.original.column = 0 4057 this.map.addMapping(mapping) 4058 } 4059 } 4060 4061 lines = str.match(/\n/g) 4062 if (lines) { 4063 line += lines.length 4064 last = str.lastIndexOf('\n') 4065 column = str.length - last 4066 } else { 4067 column += str.length 4068 } 4069 4070 if (node && type !== 'start') { 4071 let p = node.parent || { raws: {} } 4072 let childless = 4073 node.type === 'decl' || (node.type === 'atrule' && !node.nodes) 4074 if (!childless || node !== p.last || p.raws.semicolon) { 4075 if (node.source && node.source.end) { 4076 mapping.source = this.sourcePath(node) 4077 mapping.original.line = node.source.end.line 4078 mapping.original.column = node.source.end.column - 1 4079 mapping.generated.line = line 4080 mapping.generated.column = column - 2 4081 this.map.addMapping(mapping) 4082 } else { 4083 mapping.source = noSource 4084 mapping.original.line = 1 4085 mapping.original.column = 0 4086 mapping.generated.line = line 4087 mapping.generated.column = column - 1 4088 this.map.addMapping(mapping) 4089 } 4090 } 4091 } 4092 }) 4093 } 4094 4095 isAnnotation() { 4096 if (this.isInline()) { 4097 return true 4098 } 4099 if (typeof this.mapOpts.annotation !== 'undefined') { 4100 return this.mapOpts.annotation 4101 } 4102 if (this.previous().length) { 4103 return this.previous().some(i => i.annotation) 4104 } 4105 return true 4106 } 4107 4108 isInline() { 4109 if (typeof this.mapOpts.inline !== 'undefined') { 4110 return this.mapOpts.inline 4111 } 4112 4113 let annotation = this.mapOpts.annotation 4114 if (typeof annotation !== 'undefined' && annotation !== true) { 4115 return false 4116 } 4117 4118 if (this.previous().length) { 4119 return this.previous().some(i => i.inline) 4120 } 4121 return true 4122 } 4123 4124 isMap() { 4125 if (typeof this.opts.map !== 'undefined') { 4126 return !!this.opts.map 4127 } 4128 return this.previous().length > 0 4129 } 4130 4131 isSourcesContent() { 4132 if (typeof this.mapOpts.sourcesContent !== 'undefined') { 4133 return this.mapOpts.sourcesContent 4134 } 4135 if (this.previous().length) { 4136 return this.previous().some(i => i.withContent()) 4137 } 4138 return true 4139 } 4140 4141 outputFile() { 4142 if (this.opts.to) { 4143 return this.path(this.opts.to) 4144 } else if (this.opts.from) { 4145 return this.path(this.opts.from) 4146 } else { 4147 return 'to.css' 4148 } 4149 } 4150 4151 path(file) { 4152 if (this.mapOpts.absolute) return file 4153 if (file.charCodeAt(0) === 60 /* `<` */) return file 4154 if (/^\w+:\/\//.test(file)) return file 4155 let cached = this.memoizedPaths.get(file) 4156 if (cached) return cached 4157 4158 let from = this.opts.to ? dirname(this.opts.to) : '.' 4159 4160 if (typeof this.mapOpts.annotation === 'string') { 4161 from = dirname(resolve(from, this.mapOpts.annotation)) 4162 } 4163 4164 let path = relative(from, file) 4165 this.memoizedPaths.set(file, path) 4166 4167 return path 4168 } 4169 4170 previous() { 4171 if (!this.previousMaps) { 4172 this.previousMaps = [] 4173 if (this.root) { 4174 this.root.walk(node => { 4175 if (node.source && node.source.input.map) { 4176 let map = node.source.input.map 4177 if (!this.previousMaps.includes(map)) { 4178 this.previousMaps.push(map) 4179 } 4180 } 4181 }) 4182 } else { 4183 let input = new Input(this.originalCSS, this.opts) 4184 if (input.map) this.previousMaps.push(input.map) 4185 } 4186 } 4187 4188 return this.previousMaps 4189 } 4190 4191 setSourcesContent() { 4192 let already = {} 4193 if (this.root) { 4194 this.root.walk(node => { 4195 if (node.source) { 4196 let from = node.source.input.from 4197 if (from && !already[from]) { 4198 already[from] = true 4199 let fromUrl = this.usesFileUrls 4200 ? this.toFileUrl(from) 4201 : this.toUrl(this.path(from)) 4202 this.map.setSourceContent(fromUrl, node.source.input.css) 4203 } 4204 } 4205 }) 4206 } else if (this.css) { 4207 let from = this.opts.from 4208 ? this.toUrl(this.path(this.opts.from)) 4209 : '<no source>' 4210 this.map.setSourceContent(from, this.css) 4211 } 4212 } 4213 4214 sourcePath(node) { 4215 if (this.mapOpts.from) { 4216 return this.toUrl(this.mapOpts.from) 4217 } else if (this.usesFileUrls) { 4218 return this.toFileUrl(node.source.input.from) 4219 } else { 4220 return this.toUrl(this.path(node.source.input.from)) 4221 } 4222 } 4223 4224 toBase64(str) { 4225 if (Buffer) { 4226 return Buffer.from(str).toString('base64') 4227 } else { 4228 return window.btoa(unescape(encodeURIComponent(str))) 4229 } 4230 } 4231 4232 toFileUrl(path) { 4233 let cached = this.memoizedFileURLs.get(path) 4234 if (cached) return cached 4235 4236 if (pathToFileURL) { 4237 let fileURL = pathToFileURL(path).toString() 4238 this.memoizedFileURLs.set(path, fileURL) 4239 4240 return fileURL 4241 } else { 4242 throw new Error( 4243 '`map.absolute` option is not available in this PostCSS build' 4244 ) 4245 } 4246 } 4247 4248 toUrl(path) { 4249 let cached = this.memoizedURLs.get(path) 4250 if (cached) return cached 4251 4252 if (sep === '\\') { 4253 path = path.replace(/\\/g, '/') 4254 } 4255 4256 let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent) 4257 this.memoizedURLs.set(path, url) 4258 4259 return url 4260 } 4261 } 4262 4263 module.exports = MapGenerator 4264 4265 4266 /***/ }), 4267 4268 /***/ 7661: 4269 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4270 4271 "use strict"; 4272 4273 4274 let MapGenerator = __webpack_require__(1670) 4275 let parse = __webpack_require__(4295) 4276 const Result = __webpack_require__(9055) 4277 let stringify = __webpack_require__(633) 4278 let warnOnce = __webpack_require__(3122) 4279 4280 class NoWorkResult { 4281 constructor(processor, css, opts) { 4282 css = css.toString() 4283 this.stringified = false 4284 4285 this._processor = processor 4286 this._css = css 4287 this._opts = opts 4288 this._map = undefined 4289 let root 4290 4291 let str = stringify 4292 this.result = new Result(this._processor, root, this._opts) 4293 this.result.css = css 4294 4295 let self = this 4296 Object.defineProperty(this.result, 'root', { 4297 get() { 4298 return self.root 4299 } 4300 }) 4301 4302 let map = new MapGenerator(str, root, this._opts, css) 4303 if (map.isMap()) { 4304 let [generatedCSS, generatedMap] = map.generate() 4305 if (generatedCSS) { 4306 this.result.css = generatedCSS 4307 } 4308 if (generatedMap) { 4309 this.result.map = generatedMap 4310 } 4311 } else { 4312 map.clearAnnotation() 4313 this.result.css = map.css 4314 } 4315 } 4316 4317 async() { 4318 if (this.error) return Promise.reject(this.error) 4319 return Promise.resolve(this.result) 4320 } 4321 4322 catch(onRejected) { 4323 return this.async().catch(onRejected) 4324 } 4325 4326 finally(onFinally) { 4327 return this.async().then(onFinally, onFinally) 4328 } 4329 4330 sync() { 4331 if (this.error) throw this.error 4332 return this.result 4333 } 4334 4335 then(onFulfilled, onRejected) { 4336 if (false) {} 4337 4338 return this.async().then(onFulfilled, onRejected) 4339 } 4340 4341 toString() { 4342 return this._css 4343 } 4344 4345 warnings() { 4346 return [] 4347 } 4348 4349 get content() { 4350 return this.result.css 4351 } 4352 4353 get css() { 4354 return this.result.css 4355 } 4356 4357 get map() { 4358 return this.result.map 4359 } 4360 4361 get messages() { 4362 return [] 4363 } 4364 4365 get opts() { 4366 return this.result.opts 4367 } 4368 4369 get processor() { 4370 return this.result.processor 4371 } 4372 4373 get root() { 4374 if (this._root) { 4375 return this._root 4376 } 4377 4378 let root 4379 let parser = parse 4380 4381 try { 4382 root = parser(this._css, this._opts) 4383 } catch (error) { 4384 this.error = error 4385 } 4386 4387 if (this.error) { 4388 throw this.error 4389 } else { 4390 this._root = root 4391 return root 4392 } 4393 } 4394 4395 get [Symbol.toStringTag]() { 4396 return 'NoWorkResult' 4397 } 4398 } 4399 4400 module.exports = NoWorkResult 4401 NoWorkResult.default = NoWorkResult 4402 4403 4404 /***/ }), 4405 4406 /***/ 7490: 4407 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4408 4409 "use strict"; 4410 4411 4412 let CssSyntaxError = __webpack_require__(356) 4413 let Stringifier = __webpack_require__(346) 4414 let stringify = __webpack_require__(633) 4415 let { isClean, my } = __webpack_require__(1381) 4416 4417 function cloneNode(obj, parent) { 4418 let cloned = new obj.constructor() 4419 4420 for (let i in obj) { 4421 if (!Object.prototype.hasOwnProperty.call(obj, i)) { 4422 /* c8 ignore next 2 */ 4423 continue 4424 } 4425 if (i === 'proxyCache') continue 4426 let value = obj[i] 4427 let type = typeof value 4428 4429 if (i === 'parent' && type === 'object') { 4430 if (parent) cloned[i] = parent 4431 } else if (i === 'source') { 4432 cloned[i] = value 4433 } else if (Array.isArray(value)) { 4434 cloned[i] = value.map(j => cloneNode(j, cloned)) 4435 } else { 4436 if (type === 'object' && value !== null) value = cloneNode(value) 4437 cloned[i] = value 4438 } 4439 } 4440 4441 return cloned 4442 } 4443 4444 function sourceOffset(inputCSS, position) { 4445 // Not all custom syntaxes support `offset` in `source.start` and `source.end` 4446 if ( 4447 position && 4448 typeof position.offset !== 'undefined' 4449 ) { 4450 return position.offset; 4451 } 4452 4453 let column = 1 4454 let line = 1 4455 let offset = 0 4456 4457 for (let i = 0; i < inputCSS.length; i++) { 4458 if (line === position.line && column === position.column) { 4459 offset = i 4460 break 4461 } 4462 4463 if (inputCSS[i] === '\n') { 4464 column = 1 4465 line += 1 4466 } else { 4467 column += 1 4468 } 4469 } 4470 4471 return offset 4472 } 4473 4474 class Node { 4475 constructor(defaults = {}) { 4476 this.raws = {} 4477 this[isClean] = false 4478 this[my] = true 4479 4480 for (let name in defaults) { 4481 if (name === 'nodes') { 4482 this.nodes = [] 4483 for (let node of defaults[name]) { 4484 if (typeof node.clone === 'function') { 4485 this.append(node.clone()) 4486 } else { 4487 this.append(node) 4488 } 4489 } 4490 } else { 4491 this[name] = defaults[name] 4492 } 4493 } 4494 } 4495 4496 addToError(error) { 4497 error.postcssNode = this 4498 if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) { 4499 let s = this.source 4500 error.stack = error.stack.replace( 4501 /\n\s{4}at /, 4502 `$&$s.input.from}:$s.start.line}:$s.start.column}$&` 4503 ) 4504 } 4505 return error 4506 } 4507 4508 after(add) { 4509 this.parent.insertAfter(this, add) 4510 return this 4511 } 4512 4513 assign(overrides = {}) { 4514 for (let name in overrides) { 4515 this[name] = overrides[name] 4516 } 4517 return this 4518 } 4519 4520 before(add) { 4521 this.parent.insertBefore(this, add) 4522 return this 4523 } 4524 4525 cleanRaws(keepBetween) { 4526 delete this.raws.before 4527 delete this.raws.after 4528 if (!keepBetween) delete this.raws.between 4529 } 4530 4531 clone(overrides = {}) { 4532 let cloned = cloneNode(this) 4533 for (let name in overrides) { 4534 cloned[name] = overrides[name] 4535 } 4536 return cloned 4537 } 4538 4539 cloneAfter(overrides = {}) { 4540 let cloned = this.clone(overrides) 4541 this.parent.insertAfter(this, cloned) 4542 return cloned 4543 } 4544 4545 cloneBefore(overrides = {}) { 4546 let cloned = this.clone(overrides) 4547 this.parent.insertBefore(this, cloned) 4548 return cloned 4549 } 4550 4551 error(message, opts = {}) { 4552 if (this.source) { 4553 let { end, start } = this.rangeBy(opts) 4554 return this.source.input.error( 4555 message, 4556 { column: start.column, line: start.line }, 4557 { column: end.column, line: end.line }, 4558 opts 4559 ) 4560 } 4561 return new CssSyntaxError(message) 4562 } 4563 4564 getProxyProcessor() { 4565 return { 4566 get(node, prop) { 4567 if (prop === 'proxyOf') { 4568 return node 4569 } else if (prop === 'root') { 4570 return () => node.root().toProxy() 4571 } else { 4572 return node[prop] 4573 } 4574 }, 4575 4576 set(node, prop, value) { 4577 if (node[prop] === value) return true 4578 node[prop] = value 4579 if ( 4580 prop === 'prop' || 4581 prop === 'value' || 4582 prop === 'name' || 4583 prop === 'params' || 4584 prop === 'important' || 4585 /* c8 ignore next */ 4586 prop === 'text' 4587 ) { 4588 node.markDirty() 4589 } 4590 return true 4591 } 4592 } 4593 } 4594 4595 /* c8 ignore next 3 */ 4596 markClean() { 4597 this[isClean] = true 4598 } 4599 4600 markDirty() { 4601 if (this[isClean]) { 4602 this[isClean] = false 4603 let next = this 4604 while ((next = next.parent)) { 4605 next[isClean] = false 4606 } 4607 } 4608 } 4609 4610 next() { 4611 if (!this.parent) return undefined 4612 let index = this.parent.index(this) 4613 return this.parent.nodes[index + 1] 4614 } 4615 4616 positionBy(opts) { 4617 let pos = this.source.start 4618 if (opts.index) { 4619 pos = this.positionInside(opts.index) 4620 } else if (opts.word) { 4621 let stringRepresentation = this.source.input.css.slice( 4622 sourceOffset(this.source.input.css, this.source.start), 4623 sourceOffset(this.source.input.css, this.source.end) 4624 ) 4625 let index = stringRepresentation.indexOf(opts.word) 4626 if (index !== -1) pos = this.positionInside(index) 4627 } 4628 return pos 4629 } 4630 4631 positionInside(index) { 4632 let column = this.source.start.column 4633 let line = this.source.start.line 4634 let offset = sourceOffset(this.source.input.css, this.source.start) 4635 let end = offset + index 4636 4637 for (let i = offset; i < end; i++) { 4638 if (this.source.input.css[i] === '\n') { 4639 column = 1 4640 line += 1 4641 } else { 4642 column += 1 4643 } 4644 } 4645 4646 return { column, line } 4647 } 4648 4649 prev() { 4650 if (!this.parent) return undefined 4651 let index = this.parent.index(this) 4652 return this.parent.nodes[index - 1] 4653 } 4654 4655 rangeBy(opts) { 4656 let start = { 4657 column: this.source.start.column, 4658 line: this.source.start.line 4659 } 4660 let end = this.source.end 4661 ? { 4662 column: this.source.end.column + 1, 4663 line: this.source.end.line 4664 } 4665 : { 4666 column: start.column + 1, 4667 line: start.line 4668 } 4669 4670 if (opts.word) { 4671 let stringRepresentation = this.source.input.css.slice( 4672 sourceOffset(this.source.input.css, this.source.start), 4673 sourceOffset(this.source.input.css, this.source.end) 4674 ) 4675 let index = stringRepresentation.indexOf(opts.word) 4676 if (index !== -1) { 4677 start = this.positionInside(index) 4678 end = this.positionInside( 4679 index + opts.word.length, 4680 ) 4681 } 4682 } else { 4683 if (opts.start) { 4684 start = { 4685 column: opts.start.column, 4686 line: opts.start.line 4687 } 4688 } else if (opts.index) { 4689 start = this.positionInside(opts.index) 4690 } 4691 4692 if (opts.end) { 4693 end = { 4694 column: opts.end.column, 4695 line: opts.end.line 4696 } 4697 } else if (typeof opts.endIndex === 'number') { 4698 end = this.positionInside(opts.endIndex) 4699 } else if (opts.index) { 4700 end = this.positionInside(opts.index + 1) 4701 } 4702 } 4703 4704 if ( 4705 end.line < start.line || 4706 (end.line === start.line && end.column <= start.column) 4707 ) { 4708 end = { column: start.column + 1, line: start.line } 4709 } 4710 4711 return { end, start } 4712 } 4713 4714 raw(prop, defaultType) { 4715 let str = new Stringifier() 4716 return str.raw(this, prop, defaultType) 4717 } 4718 4719 remove() { 4720 if (this.parent) { 4721 this.parent.removeChild(this) 4722 } 4723 this.parent = undefined 4724 return this 4725 } 4726 4727 replaceWith(...nodes) { 4728 if (this.parent) { 4729 let bookmark = this 4730 let foundSelf = false 4731 for (let node of nodes) { 4732 if (node === this) { 4733 foundSelf = true 4734 } else if (foundSelf) { 4735 this.parent.insertAfter(bookmark, node) 4736 bookmark = node 4737 } else { 4738 this.parent.insertBefore(bookmark, node) 4739 } 4740 } 4741 4742 if (!foundSelf) { 4743 this.remove() 4744 } 4745 } 4746 4747 return this 4748 } 4749 4750 root() { 4751 let result = this 4752 while (result.parent && result.parent.type !== 'document') { 4753 result = result.parent 4754 } 4755 return result 4756 } 4757 4758 toJSON(_, inputs) { 4759 let fixed = {} 4760 let emitInputs = inputs == null 4761 inputs = inputs || new Map() 4762 let inputsNextIndex = 0 4763 4764 for (let name in this) { 4765 if (!Object.prototype.hasOwnProperty.call(this, name)) { 4766 /* c8 ignore next 2 */ 4767 continue 4768 } 4769 if (name === 'parent' || name === 'proxyCache') continue 4770 let value = this[name] 4771 4772 if (Array.isArray(value)) { 4773 fixed[name] = value.map(i => { 4774 if (typeof i === 'object' && i.toJSON) { 4775 return i.toJSON(null, inputs) 4776 } else { 4777 return i 4778 } 4779 }) 4780 } else if (typeof value === 'object' && value.toJSON) { 4781 fixed[name] = value.toJSON(null, inputs) 4782 } else if (name === 'source') { 4783 let inputId = inputs.get(value.input) 4784 if (inputId == null) { 4785 inputId = inputsNextIndex 4786 inputs.set(value.input, inputsNextIndex) 4787 inputsNextIndex++ 4788 } 4789 fixed[name] = { 4790 end: value.end, 4791 inputId, 4792 start: value.start 4793 } 4794 } else { 4795 fixed[name] = value 4796 } 4797 } 4798 4799 if (emitInputs) { 4800 fixed.inputs = [...inputs.keys()].map(input => input.toJSON()) 4801 } 4802 4803 return fixed 4804 } 4805 4806 toProxy() { 4807 if (!this.proxyCache) { 4808 this.proxyCache = new Proxy(this, this.getProxyProcessor()) 4809 } 4810 return this.proxyCache 4811 } 4812 4813 toString(stringifier = stringify) { 4814 if (stringifier.stringify) stringifier = stringifier.stringify 4815 let result = '' 4816 stringifier(this, i => { 4817 result += i 4818 }) 4819 return result 4820 } 4821 4822 warn(result, text, opts) { 4823 let data = { node: this } 4824 for (let i in opts) data[i] = opts[i] 4825 return result.warn(text, data) 4826 } 4827 4828 get proxyOf() { 4829 return this 4830 } 4831 } 4832 4833 module.exports = Node 4834 Node.default = Node 4835 4836 4837 /***/ }), 4838 4839 /***/ 4295: 4840 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4841 4842 "use strict"; 4843 4844 4845 let Container = __webpack_require__(683) 4846 let Input = __webpack_require__(5380) 4847 let Parser = __webpack_require__(3937) 4848 4849 function parse(css, opts) { 4850 let input = new Input(css, opts) 4851 let parser = new Parser(input) 4852 try { 4853 parser.parse() 4854 } catch (e) { 4855 if (false) {} 4856 throw e 4857 } 4858 4859 return parser.root 4860 } 4861 4862 module.exports = parse 4863 parse.default = parse 4864 4865 Container.registerParse(parse) 4866 4867 4868 /***/ }), 4869 4870 /***/ 3937: 4871 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4872 4873 "use strict"; 4874 4875 4876 let AtRule = __webpack_require__(1326) 4877 let Comment = __webpack_require__(6589) 4878 let Declaration = __webpack_require__(1516) 4879 let Root = __webpack_require__(9434) 4880 let Rule = __webpack_require__(4092) 4881 let tokenizer = __webpack_require__(2327) 4882 4883 const SAFE_COMMENT_NEIGHBOR = { 4884 empty: true, 4885 space: true 4886 } 4887 4888 function findLastWithPosition(tokens) { 4889 for (let i = tokens.length - 1; i >= 0; i--) { 4890 let token = tokens[i] 4891 let pos = token[3] || token[2] 4892 if (pos) return pos 4893 } 4894 } 4895 4896 class Parser { 4897 constructor(input) { 4898 this.input = input 4899 4900 this.root = new Root() 4901 this.current = this.root 4902 this.spaces = '' 4903 this.semicolon = false 4904 4905 this.createTokenizer() 4906 this.root.source = { input, start: { column: 1, line: 1, offset: 0 } } 4907 } 4908 4909 atrule(token) { 4910 let node = new AtRule() 4911 node.name = token[1].slice(1) 4912 if (node.name === '') { 4913 this.unnamedAtrule(node, token) 4914 } 4915 this.init(node, token[2]) 4916 4917 let type 4918 let prev 4919 let shift 4920 let last = false 4921 let open = false 4922 let params = [] 4923 let brackets = [] 4924 4925 while (!this.tokenizer.endOfFile()) { 4926 token = this.tokenizer.nextToken() 4927 type = token[0] 4928 4929 if (type === '(' || type === '[') { 4930 brackets.push(type === '(' ? ')' : ']') 4931 } else if (type === '{' && brackets.length > 0) { 4932 brackets.push('}') 4933 } else if (type === brackets[brackets.length - 1]) { 4934 brackets.pop() 4935 } 4936 4937 if (brackets.length === 0) { 4938 if (type === ';') { 4939 node.source.end = this.getPosition(token[2]) 4940 node.source.end.offset++ 4941 this.semicolon = true 4942 break 4943 } else if (type === '{') { 4944 open = true 4945 break 4946 } else if (type === '}') { 4947 if (params.length > 0) { 4948 shift = params.length - 1 4949 prev = params[shift] 4950 while (prev && prev[0] === 'space') { 4951 prev = params[--shift] 4952 } 4953 if (prev) { 4954 node.source.end = this.getPosition(prev[3] || prev[2]) 4955 node.source.end.offset++ 4956 } 4957 } 4958 this.end(token) 4959 break 4960 } else { 4961 params.push(token) 4962 } 4963 } else { 4964 params.push(token) 4965 } 4966 4967 if (this.tokenizer.endOfFile()) { 4968 last = true 4969 break 4970 } 4971 } 4972 4973 node.raws.between = this.spacesAndCommentsFromEnd(params) 4974 if (params.length) { 4975 node.raws.afterName = this.spacesAndCommentsFromStart(params) 4976 this.raw(node, 'params', params) 4977 if (last) { 4978 token = params[params.length - 1] 4979 node.source.end = this.getPosition(token[3] || token[2]) 4980 node.source.end.offset++ 4981 this.spaces = node.raws.between 4982 node.raws.between = '' 4983 } 4984 } else { 4985 node.raws.afterName = '' 4986 node.params = '' 4987 } 4988 4989 if (open) { 4990 node.nodes = [] 4991 this.current = node 4992 } 4993 } 4994 4995 checkMissedSemicolon(tokens) { 4996 let colon = this.colon(tokens) 4997 if (colon === false) return 4998 4999 let founded = 0 5000 let token 5001 for (let j = colon - 1; j >= 0; j--) { 5002 token = tokens[j] 5003 if (token[0] !== 'space') { 5004 founded += 1 5005 if (founded === 2) break 5006 } 5007 } 5008 // If the token is a word, e.g. `!important`, `red` or any other valid property's value. 5009 // Then we need to return the colon after that word token. [3] is the "end" colon of that word. 5010 // And because we need it after that one we do +1 to get the next one. 5011 throw this.input.error( 5012 'Missed semicolon', 5013 token[0] === 'word' ? token[3] + 1 : token[2] 5014 ) 5015 } 5016 5017 colon(tokens) { 5018 let brackets = 0 5019 let prev, token, type 5020 for (let [i, element] of tokens.entries()) { 5021 token = element 5022 type = token[0] 5023 5024 if (type === '(') { 5025 brackets += 1 5026 } 5027 if (type === ')') { 5028 brackets -= 1 5029 } 5030 if (brackets === 0 && type === ':') { 5031 if (!prev) { 5032 this.doubleColon(token) 5033 } else if (prev[0] === 'word' && prev[1] === 'progid') { 5034 continue 5035 } else { 5036 return i 5037 } 5038 } 5039 5040 prev = token 5041 } 5042 return false 5043 } 5044 5045 comment(token) { 5046 let node = new Comment() 5047 this.init(node, token[2]) 5048 node.source.end = this.getPosition(token[3] || token[2]) 5049 node.source.end.offset++ 5050 5051 let text = token[1].slice(2, -2) 5052 if (/^\s*$/.test(text)) { 5053 node.text = '' 5054 node.raws.left = text 5055 node.raws.right = '' 5056 } else { 5057 let match = text.match(/^(\s*)([^]*\S)(\s*)$/) 5058 node.text = match[2] 5059 node.raws.left = match[1] 5060 node.raws.right = match[3] 5061 } 5062 } 5063 5064 createTokenizer() { 5065 this.tokenizer = tokenizer(this.input) 5066 } 5067 5068 decl(tokens, customProperty) { 5069 let node = new Declaration() 5070 this.init(node, tokens[0][2]) 5071 5072 let last = tokens[tokens.length - 1] 5073 if (last[0] === ';') { 5074 this.semicolon = true 5075 tokens.pop() 5076 } 5077 5078 node.source.end = this.getPosition( 5079 last[3] || last[2] || findLastWithPosition(tokens) 5080 ) 5081 node.source.end.offset++ 5082 5083 while (tokens[0][0] !== 'word') { 5084 if (tokens.length === 1) this.unknownWord(tokens) 5085 node.raws.before += tokens.shift()[1] 5086 } 5087 node.source.start = this.getPosition(tokens[0][2]) 5088 5089 node.prop = '' 5090 while (tokens.length) { 5091 let type = tokens[0][0] 5092 if (type === ':' || type === 'space' || type === 'comment') { 5093 break 5094 } 5095 node.prop += tokens.shift()[1] 5096 } 5097 5098 node.raws.between = '' 5099 5100 let token 5101 while (tokens.length) { 5102 token = tokens.shift() 5103 5104 if (token[0] === ':') { 5105 node.raws.between += token[1] 5106 break 5107 } else { 5108 if (token[0] === 'word' && /\w/.test(token[1])) { 5109 this.unknownWord([token]) 5110 } 5111 node.raws.between += token[1] 5112 } 5113 } 5114 5115 if (node.prop[0] === '_' || node.prop[0] === '*') { 5116 node.raws.before += node.prop[0] 5117 node.prop = node.prop.slice(1) 5118 } 5119 5120 let firstSpaces = [] 5121 let next 5122 while (tokens.length) { 5123 next = tokens[0][0] 5124 if (next !== 'space' && next !== 'comment') break 5125 firstSpaces.push(tokens.shift()) 5126 } 5127 5128 this.precheckMissedSemicolon(tokens) 5129 5130 for (let i = tokens.length - 1; i >= 0; i--) { 5131 token = tokens[i] 5132 if (token[1].toLowerCase() === '!important') { 5133 node.important = true 5134 let string = this.stringFrom(tokens, i) 5135 string = this.spacesFromEnd(tokens) + string 5136 if (string !== ' !important') node.raws.important = string 5137 break 5138 } else if (token[1].toLowerCase() === 'important') { 5139 let cache = tokens.slice(0) 5140 let str = '' 5141 for (let j = i; j > 0; j--) { 5142 let type = cache[j][0] 5143 if (str.trim().startsWith('!') && type !== 'space') { 5144 break 5145 } 5146 str = cache.pop()[1] + str 5147 } 5148 if (str.trim().startsWith('!')) { 5149 node.important = true 5150 node.raws.important = str 5151 tokens = cache 5152 } 5153 } 5154 5155 if (token[0] !== 'space' && token[0] !== 'comment') { 5156 break 5157 } 5158 } 5159 5160 let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment') 5161 5162 if (hasWord) { 5163 node.raws.between += firstSpaces.map(i => i[1]).join('') 5164 firstSpaces = [] 5165 } 5166 this.raw(node, 'value', firstSpaces.concat(tokens), customProperty) 5167 5168 if (node.value.includes(':') && !customProperty) { 5169 this.checkMissedSemicolon(tokens) 5170 } 5171 } 5172 5173 doubleColon(token) { 5174 throw this.input.error( 5175 'Double colon', 5176 { offset: token[2] }, 5177 { offset: token[2] + token[1].length } 5178 ) 5179 } 5180 5181 emptyRule(token) { 5182 let node = new Rule() 5183 this.init(node, token[2]) 5184 node.selector = '' 5185 node.raws.between = '' 5186 this.current = node 5187 } 5188 5189 end(token) { 5190 if (this.current.nodes && this.current.nodes.length) { 5191 this.current.raws.semicolon = this.semicolon 5192 } 5193 this.semicolon = false 5194 5195 this.current.raws.after = (this.current.raws.after || '') + this.spaces 5196 this.spaces = '' 5197 5198 if (this.current.parent) { 5199 this.current.source.end = this.getPosition(token[2]) 5200 this.current.source.end.offset++ 5201 this.current = this.current.parent 5202 } else { 5203 this.unexpectedClose(token) 5204 } 5205 } 5206 5207 endFile() { 5208 if (this.current.parent) this.unclosedBlock() 5209 if (this.current.nodes && this.current.nodes.length) { 5210 this.current.raws.semicolon = this.semicolon 5211 } 5212 this.current.raws.after = (this.current.raws.after || '') + this.spaces 5213 this.root.source.end = this.getPosition(this.tokenizer.position()) 5214 } 5215 5216 freeSemicolon(token) { 5217 this.spaces += token[1] 5218 if (this.current.nodes) { 5219 let prev = this.current.nodes[this.current.nodes.length - 1] 5220 if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) { 5221 prev.raws.ownSemicolon = this.spaces 5222 this.spaces = '' 5223 } 5224 } 5225 } 5226 5227 // Helpers 5228 5229 getPosition(offset) { 5230 let pos = this.input.fromOffset(offset) 5231 return { 5232 column: pos.col, 5233 line: pos.line, 5234 offset 5235 } 5236 } 5237 5238 init(node, offset) { 5239 this.current.push(node) 5240 node.source = { 5241 input: this.input, 5242 start: this.getPosition(offset) 5243 } 5244 node.raws.before = this.spaces 5245 this.spaces = '' 5246 if (node.type !== 'comment') this.semicolon = false 5247 } 5248 5249 other(start) { 5250 let end = false 5251 let type = null 5252 let colon = false 5253 let bracket = null 5254 let brackets = [] 5255 let customProperty = start[1].startsWith('--') 5256 5257 let tokens = [] 5258 let token = start 5259 while (token) { 5260 type = token[0] 5261 tokens.push(token) 5262 5263 if (type === '(' || type === '[') { 5264 if (!bracket) bracket = token 5265 brackets.push(type === '(' ? ')' : ']') 5266 } else if (customProperty && colon && type === '{') { 5267 if (!bracket) bracket = token 5268 brackets.push('}') 5269 } else if (brackets.length === 0) { 5270 if (type === ';') { 5271 if (colon) { 5272 this.decl(tokens, customProperty) 5273 return 5274 } else { 5275 break 5276 } 5277 } else if (type === '{') { 5278 this.rule(tokens) 5279 return 5280 } else if (type === '}') { 5281 this.tokenizer.back(tokens.pop()) 5282 end = true 5283 break 5284 } else if (type === ':') { 5285 colon = true 5286 } 5287 } else if (type === brackets[brackets.length - 1]) { 5288 brackets.pop() 5289 if (brackets.length === 0) bracket = null 5290 } 5291 5292 token = this.tokenizer.nextToken() 5293 } 5294 5295 if (this.tokenizer.endOfFile()) end = true 5296 if (brackets.length > 0) this.unclosedBracket(bracket) 5297 5298 if (end && colon) { 5299 if (!customProperty) { 5300 while (tokens.length) { 5301 token = tokens[tokens.length - 1][0] 5302 if (token !== 'space' && token !== 'comment') break 5303 this.tokenizer.back(tokens.pop()) 5304 } 5305 } 5306 this.decl(tokens, customProperty) 5307 } else { 5308 this.unknownWord(tokens) 5309 } 5310 } 5311 5312 parse() { 5313 let token 5314 while (!this.tokenizer.endOfFile()) { 5315 token = this.tokenizer.nextToken() 5316 5317 switch (token[0]) { 5318 case 'space': 5319 this.spaces += token[1] 5320 break 5321 5322 case ';': 5323 this.freeSemicolon(token) 5324 break 5325 5326 case '}': 5327 this.end(token) 5328 break 5329 5330 case 'comment': 5331 this.comment(token) 5332 break 5333 5334 case 'at-word': 5335 this.atrule(token) 5336 break 5337 5338 case '{': 5339 this.emptyRule(token) 5340 break 5341 5342 default: 5343 this.other(token) 5344 break 5345 } 5346 } 5347 this.endFile() 5348 } 5349 5350 precheckMissedSemicolon(/* tokens */) { 5351 // Hook for Safe Parser 5352 } 5353 5354 raw(node, prop, tokens, customProperty) { 5355 let token, type 5356 let length = tokens.length 5357 let value = '' 5358 let clean = true 5359 let next, prev 5360 5361 for (let i = 0; i < length; i += 1) { 5362 token = tokens[i] 5363 type = token[0] 5364 if (type === 'space' && i === length - 1 && !customProperty) { 5365 clean = false 5366 } else if (type === 'comment') { 5367 prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty' 5368 next = tokens[i + 1] ? tokens[i + 1][0] : 'empty' 5369 if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) { 5370 if (value.slice(-1) === ',') { 5371 clean = false 5372 } else { 5373 value += token[1] 5374 } 5375 } else { 5376 clean = false 5377 } 5378 } else { 5379 value += token[1] 5380 } 5381 } 5382 if (!clean) { 5383 let raw = tokens.reduce((all, i) => all + i[1], '') 5384 node.raws[prop] = { raw, value } 5385 } 5386 node[prop] = value 5387 } 5388 5389 rule(tokens) { 5390 tokens.pop() 5391 5392 let node = new Rule() 5393 this.init(node, tokens[0][2]) 5394 5395 node.raws.between = this.spacesAndCommentsFromEnd(tokens) 5396 this.raw(node, 'selector', tokens) 5397 this.current = node 5398 } 5399 5400 spacesAndCommentsFromEnd(tokens) { 5401 let lastTokenType 5402 let spaces = '' 5403 while (tokens.length) { 5404 lastTokenType = tokens[tokens.length - 1][0] 5405 if (lastTokenType !== 'space' && lastTokenType !== 'comment') break 5406 spaces = tokens.pop()[1] + spaces 5407 } 5408 return spaces 5409 } 5410 5411 // Errors 5412 5413 spacesAndCommentsFromStart(tokens) { 5414 let next 5415 let spaces = '' 5416 while (tokens.length) { 5417 next = tokens[0][0] 5418 if (next !== 'space' && next !== 'comment') break 5419 spaces += tokens.shift()[1] 5420 } 5421 return spaces 5422 } 5423 5424 spacesFromEnd(tokens) { 5425 let lastTokenType 5426 let spaces = '' 5427 while (tokens.length) { 5428 lastTokenType = tokens[tokens.length - 1][0] 5429 if (lastTokenType !== 'space') break 5430 spaces = tokens.pop()[1] + spaces 5431 } 5432 return spaces 5433 } 5434 5435 stringFrom(tokens, from) { 5436 let result = '' 5437 for (let i = from; i < tokens.length; i++) { 5438 result += tokens[i][1] 5439 } 5440 tokens.splice(from, tokens.length - from) 5441 return result 5442 } 5443 5444 unclosedBlock() { 5445 let pos = this.current.source.start 5446 throw this.input.error('Unclosed block', pos.line, pos.column) 5447 } 5448 5449 unclosedBracket(bracket) { 5450 throw this.input.error( 5451 'Unclosed bracket', 5452 { offset: bracket[2] }, 5453 { offset: bracket[2] + 1 } 5454 ) 5455 } 5456 5457 unexpectedClose(token) { 5458 throw this.input.error( 5459 'Unexpected }', 5460 { offset: token[2] }, 5461 { offset: token[2] + 1 } 5462 ) 5463 } 5464 5465 unknownWord(tokens) { 5466 throw this.input.error( 5467 'Unknown word', 5468 { offset: tokens[0][2] }, 5469 { offset: tokens[0][2] + tokens[0][1].length } 5470 ) 5471 } 5472 5473 unnamedAtrule(node, token) { 5474 throw this.input.error( 5475 'At-rule without name', 5476 { offset: token[2] }, 5477 { offset: token[2] + token[1].length } 5478 ) 5479 } 5480 } 5481 5482 module.exports = Parser 5483 5484 5485 /***/ }), 5486 5487 /***/ 4529: 5488 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5489 5490 "use strict"; 5491 5492 5493 let AtRule = __webpack_require__(1326) 5494 let Comment = __webpack_require__(6589) 5495 let Container = __webpack_require__(683) 5496 let CssSyntaxError = __webpack_require__(356) 5497 let Declaration = __webpack_require__(1516) 5498 let Document = __webpack_require__(271) 5499 let fromJSON = __webpack_require__(8940) 5500 let Input = __webpack_require__(5380) 5501 let LazyResult = __webpack_require__(448) 5502 let list = __webpack_require__(7374) 5503 let Node = __webpack_require__(7490) 5504 let parse = __webpack_require__(4295) 5505 let Processor = __webpack_require__(9656) 5506 let Result = __webpack_require__(9055) 5507 let Root = __webpack_require__(9434) 5508 let Rule = __webpack_require__(4092) 5509 let stringify = __webpack_require__(633) 5510 let Warning = __webpack_require__(5776) 5511 5512 function postcss(...plugins) { 5513 if (plugins.length === 1 && Array.isArray(plugins[0])) { 5514 plugins = plugins[0] 5515 } 5516 return new Processor(plugins) 5517 } 5518 5519 postcss.plugin = function plugin(name, initializer) { 5520 let warningPrinted = false 5521 function creator(...args) { 5522 // eslint-disable-next-line no-console 5523 if (console && console.warn && !warningPrinted) { 5524 warningPrinted = true 5525 // eslint-disable-next-line no-console 5526 console.warn( 5527 name + 5528 ': postcss.plugin was deprecated. Migration guide:\n' + 5529 'https://evilmartians.com/chronicles/postcss-8-plugin-migration' 5530 ) 5531 if (process.env.LANG && process.env.LANG.startsWith('cn')) { 5532 /* c8 ignore next 7 */ 5533 // eslint-disable-next-line no-console 5534 console.warn( 5535 name + 5536 ': 里面 postcss.plugin 被弃用. 迁移指南:\n' + 5537 'https://www.w3ctech.com/topic/2226' 5538 ) 5539 } 5540 } 5541 let transformer = initializer(...args) 5542 transformer.postcssPlugin = name 5543 transformer.postcssVersion = new Processor().version 5544 return transformer 5545 } 5546 5547 let cache 5548 Object.defineProperty(creator, 'postcss', { 5549 get() { 5550 if (!cache) cache = creator() 5551 return cache 5552 } 5553 }) 5554 5555 creator.process = function (css, processOpts, pluginOpts) { 5556 return postcss([creator(pluginOpts)]).process(css, processOpts) 5557 } 5558 5559 return creator 5560 } 5561 5562 postcss.stringify = stringify 5563 postcss.parse = parse 5564 postcss.fromJSON = fromJSON 5565 postcss.list = list 5566 5567 postcss.comment = defaults => new Comment(defaults) 5568 postcss.atRule = defaults => new AtRule(defaults) 5569 postcss.decl = defaults => new Declaration(defaults) 5570 postcss.rule = defaults => new Rule(defaults) 5571 postcss.root = defaults => new Root(defaults) 5572 postcss.document = defaults => new Document(defaults) 5573 5574 postcss.CssSyntaxError = CssSyntaxError 5575 postcss.Declaration = Declaration 5576 postcss.Container = Container 5577 postcss.Processor = Processor 5578 postcss.Document = Document 5579 postcss.Comment = Comment 5580 postcss.Warning = Warning 5581 postcss.AtRule = AtRule 5582 postcss.Result = Result 5583 postcss.Input = Input 5584 postcss.Rule = Rule 5585 postcss.Root = Root 5586 postcss.Node = Node 5587 5588 LazyResult.registerPostcss(postcss) 5589 5590 module.exports = postcss 5591 postcss.default = postcss 5592 5593 5594 /***/ }), 5595 5596 /***/ 5696: 5597 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5598 5599 "use strict"; 5600 5601 5602 let { existsSync, readFileSync } = __webpack_require__(9977) 5603 let { dirname, join } = __webpack_require__(197) 5604 let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(1866) 5605 5606 function fromBase64(str) { 5607 if (Buffer) { 5608 return Buffer.from(str, 'base64').toString() 5609 } else { 5610 /* c8 ignore next 2 */ 5611 return window.atob(str) 5612 } 5613 } 5614 5615 class PreviousMap { 5616 constructor(css, opts) { 5617 if (opts.map === false) return 5618 this.loadAnnotation(css) 5619 this.inline = this.startWith(this.annotation, 'data:') 5620 5621 let prev = opts.map ? opts.map.prev : undefined 5622 let text = this.loadMap(opts.from, prev) 5623 if (!this.mapFile && opts.from) { 5624 this.mapFile = opts.from 5625 } 5626 if (this.mapFile) this.root = dirname(this.mapFile) 5627 if (text) this.text = text 5628 } 5629 5630 consumer() { 5631 if (!this.consumerCache) { 5632 this.consumerCache = new SourceMapConsumer(this.text) 5633 } 5634 return this.consumerCache 5635 } 5636 5637 decodeInline(text) { 5638 let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/ 5639 let baseUri = /^data:application\/json;base64,/ 5640 let charsetUri = /^data:application\/json;charset=utf-?8,/ 5641 let uri = /^data:application\/json,/ 5642 5643 let uriMatch = text.match(charsetUri) || text.match(uri) 5644 if (uriMatch) { 5645 return decodeURIComponent(text.substr(uriMatch[0].length)) 5646 } 5647 5648 let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri) 5649 if (baseUriMatch) { 5650 return fromBase64(text.substr(baseUriMatch[0].length)) 5651 } 5652 5653 let encoding = text.match(/data:application\/json;([^,]+),/)[1] 5654 throw new Error('Unsupported source map encoding ' + encoding) 5655 } 5656 5657 getAnnotationURL(sourceMapString) { 5658 return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim() 5659 } 5660 5661 isMap(map) { 5662 if (typeof map !== 'object') return false 5663 return ( 5664 typeof map.mappings === 'string' || 5665 typeof map._mappings === 'string' || 5666 Array.isArray(map.sections) 5667 ) 5668 } 5669 5670 loadAnnotation(css) { 5671 let comments = css.match(/\/\*\s*# sourceMappingURL=/g) 5672 if (!comments) return 5673 5674 // sourceMappingURLs from comments, strings, etc. 5675 let start = css.lastIndexOf(comments.pop()) 5676 let end = css.indexOf('*/', start) 5677 5678 if (start > -1 && end > -1) { 5679 // Locate the last sourceMappingURL to avoid pickin 5680 this.annotation = this.getAnnotationURL(css.substring(start, end)) 5681 } 5682 } 5683 5684 loadFile(path) { 5685 this.root = dirname(path) 5686 if (existsSync(path)) { 5687 this.mapFile = path 5688 return readFileSync(path, 'utf-8').toString().trim() 5689 } 5690 } 5691 5692 loadMap(file, prev) { 5693 if (prev === false) return false 5694 5695 if (prev) { 5696 if (typeof prev === 'string') { 5697 return prev 5698 } else if (typeof prev === 'function') { 5699 let prevPath = prev(file) 5700 if (prevPath) { 5701 let map = this.loadFile(prevPath) 5702 if (!map) { 5703 throw new Error( 5704 'Unable to load previous source map: ' + prevPath.toString() 5705 ) 5706 } 5707 return map 5708 } 5709 } else if (prev instanceof SourceMapConsumer) { 5710 return SourceMapGenerator.fromSourceMap(prev).toString() 5711 } else if (prev instanceof SourceMapGenerator) { 5712 return prev.toString() 5713 } else if (this.isMap(prev)) { 5714 return JSON.stringify(prev) 5715 } else { 5716 throw new Error( 5717 'Unsupported previous source map format: ' + prev.toString() 5718 ) 5719 } 5720 } else if (this.inline) { 5721 return this.decodeInline(this.annotation) 5722 } else if (this.annotation) { 5723 let map = this.annotation 5724 if (file) map = join(dirname(file), map) 5725 return this.loadFile(map) 5726 } 5727 } 5728 5729 startWith(string, start) { 5730 if (!string) return false 5731 return string.substr(0, start.length) === start 5732 } 5733 5734 withContent() { 5735 return !!( 5736 this.consumer().sourcesContent && 5737 this.consumer().sourcesContent.length > 0 5738 ) 5739 } 5740 } 5741 5742 module.exports = PreviousMap 5743 PreviousMap.default = PreviousMap 5744 5745 5746 /***/ }), 5747 5748 /***/ 9656: 5749 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5750 5751 "use strict"; 5752 5753 5754 let Document = __webpack_require__(271) 5755 let LazyResult = __webpack_require__(448) 5756 let NoWorkResult = __webpack_require__(7661) 5757 let Root = __webpack_require__(9434) 5758 5759 class Processor { 5760 constructor(plugins = []) { 5761 this.version = '8.4.49' 5762 this.plugins = this.normalize(plugins) 5763 } 5764 5765 normalize(plugins) { 5766 let normalized = [] 5767 for (let i of plugins) { 5768 if (i.postcss === true) { 5769 i = i() 5770 } else if (i.postcss) { 5771 i = i.postcss 5772 } 5773 5774 if (typeof i === 'object' && Array.isArray(i.plugins)) { 5775 normalized = normalized.concat(i.plugins) 5776 } else if (typeof i === 'object' && i.postcssPlugin) { 5777 normalized.push(i) 5778 } else if (typeof i === 'function') { 5779 normalized.push(i) 5780 } else if (typeof i === 'object' && (i.parse || i.stringify)) { 5781 if (false) {} 5782 } else { 5783 throw new Error(i + ' is not a PostCSS plugin') 5784 } 5785 } 5786 return normalized 5787 } 5788 5789 process(css, opts = {}) { 5790 if ( 5791 !this.plugins.length && 5792 !opts.parser && 5793 !opts.stringifier && 5794 !opts.syntax 5795 ) { 5796 return new NoWorkResult(this, css, opts) 5797 } else { 5798 return new LazyResult(this, css, opts) 5799 } 5800 } 5801 5802 use(plugin) { 5803 this.plugins = this.plugins.concat(this.normalize([plugin])) 5804 return this 5805 } 5806 } 5807 5808 module.exports = Processor 5809 Processor.default = Processor 5810 5811 Root.registerProcessor(Processor) 5812 Document.registerProcessor(Processor) 5813 5814 5815 /***/ }), 5816 5817 /***/ 9055: 5818 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5819 5820 "use strict"; 5821 5822 5823 let Warning = __webpack_require__(5776) 5824 5825 class Result { 5826 constructor(processor, root, opts) { 5827 this.processor = processor 5828 this.messages = [] 5829 this.root = root 5830 this.opts = opts 5831 this.css = undefined 5832 this.map = undefined 5833 } 5834 5835 toString() { 5836 return this.css 5837 } 5838 5839 warn(text, opts = {}) { 5840 if (!opts.plugin) { 5841 if (this.lastPlugin && this.lastPlugin.postcssPlugin) { 5842 opts.plugin = this.lastPlugin.postcssPlugin 5843 } 5844 } 5845 5846 let warning = new Warning(text, opts) 5847 this.messages.push(warning) 5848 5849 return warning 5850 } 5851 5852 warnings() { 5853 return this.messages.filter(i => i.type === 'warning') 5854 } 5855 5856 get content() { 5857 return this.css 5858 } 5859 } 5860 5861 module.exports = Result 5862 Result.default = Result 5863 5864 5865 /***/ }), 5866 5867 /***/ 9434: 5868 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5869 5870 "use strict"; 5871 5872 5873 let Container = __webpack_require__(683) 5874 5875 let LazyResult, Processor 5876 5877 class Root extends Container { 5878 constructor(defaults) { 5879 super(defaults) 5880 this.type = 'root' 5881 if (!this.nodes) this.nodes = [] 5882 } 5883 5884 normalize(child, sample, type) { 5885 let nodes = super.normalize(child) 5886 5887 if (sample) { 5888 if (type === 'prepend') { 5889 if (this.nodes.length > 1) { 5890 sample.raws.before = this.nodes[1].raws.before 5891 } else { 5892 delete sample.raws.before 5893 } 5894 } else if (this.first !== sample) { 5895 for (let node of nodes) { 5896 node.raws.before = sample.raws.before 5897 } 5898 } 5899 } 5900 5901 return nodes 5902 } 5903 5904 removeChild(child, ignore) { 5905 let index = this.index(child) 5906 5907 if (!ignore && index === 0 && this.nodes.length > 1) { 5908 this.nodes[1].raws.before = this.nodes[index].raws.before 5909 } 5910 5911 return super.removeChild(child) 5912 } 5913 5914 toResult(opts = {}) { 5915 let lazy = new LazyResult(new Processor(), this, opts) 5916 return lazy.stringify() 5917 } 5918 } 5919 5920 Root.registerLazyResult = dependant => { 5921 LazyResult = dependant 5922 } 5923 5924 Root.registerProcessor = dependant => { 5925 Processor = dependant 5926 } 5927 5928 module.exports = Root 5929 Root.default = Root 5930 5931 Container.registerRoot(Root) 5932 5933 5934 /***/ }), 5935 5936 /***/ 4092: 5937 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5938 5939 "use strict"; 5940 5941 5942 let Container = __webpack_require__(683) 5943 let list = __webpack_require__(7374) 5944 5945 class Rule extends Container { 5946 constructor(defaults) { 5947 super(defaults) 5948 this.type = 'rule' 5949 if (!this.nodes) this.nodes = [] 5950 } 5951 5952 get selectors() { 5953 return list.comma(this.selector) 5954 } 5955 5956 set selectors(values) { 5957 let match = this.selector ? this.selector.match(/,\s*/) : null 5958 let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen') 5959 this.selector = values.join(sep) 5960 } 5961 } 5962 5963 module.exports = Rule 5964 Rule.default = Rule 5965 5966 Container.registerRule(Rule) 5967 5968 5969 /***/ }), 5970 5971 /***/ 346: 5972 /***/ ((module) => { 5973 5974 "use strict"; 5975 5976 5977 const DEFAULT_RAW = { 5978 after: '\n', 5979 beforeClose: '\n', 5980 beforeComment: '\n', 5981 beforeDecl: '\n', 5982 beforeOpen: ' ', 5983 beforeRule: '\n', 5984 colon: ': ', 5985 commentLeft: ' ', 5986 commentRight: ' ', 5987 emptyBody: '', 5988 indent: ' ', 5989 semicolon: false 5990 } 5991 5992 function capitalize(str) { 5993 return str[0].toUpperCase() + str.slice(1) 5994 } 5995 5996 class Stringifier { 5997 constructor(builder) { 5998 this.builder = builder 5999 } 6000 6001 atrule(node, semicolon) { 6002 let name = '@' + node.name 6003 let params = node.params ? this.rawValue(node, 'params') : '' 6004 6005 if (typeof node.raws.afterName !== 'undefined') { 6006 name += node.raws.afterName 6007 } else if (params) { 6008 name += ' ' 6009 } 6010 6011 if (node.nodes) { 6012 this.block(node, name + params) 6013 } else { 6014 let end = (node.raws.between || '') + (semicolon ? ';' : '') 6015 this.builder(name + params + end, node) 6016 } 6017 } 6018 6019 beforeAfter(node, detect) { 6020 let value 6021 if (node.type === 'decl') { 6022 value = this.raw(node, null, 'beforeDecl') 6023 } else if (node.type === 'comment') { 6024 value = this.raw(node, null, 'beforeComment') 6025 } else if (detect === 'before') { 6026 value = this.raw(node, null, 'beforeRule') 6027 } else { 6028 value = this.raw(node, null, 'beforeClose') 6029 } 6030 6031 let buf = node.parent 6032 let depth = 0 6033 while (buf && buf.type !== 'root') { 6034 depth += 1 6035 buf = buf.parent 6036 } 6037 6038 if (value.includes('\n')) { 6039 let indent = this.raw(node, null, 'indent') 6040 if (indent.length) { 6041 for (let step = 0; step < depth; step++) value += indent 6042 } 6043 } 6044 6045 return value 6046 } 6047 6048 block(node, start) { 6049 let between = this.raw(node, 'between', 'beforeOpen') 6050 this.builder(start + between + '{', node, 'start') 6051 6052 let after 6053 if (node.nodes && node.nodes.length) { 6054 this.body(node) 6055 after = this.raw(node, 'after') 6056 } else { 6057 after = this.raw(node, 'after', 'emptyBody') 6058 } 6059 6060 if (after) this.builder(after) 6061 this.builder('}', node, 'end') 6062 } 6063 6064 body(node) { 6065 let last = node.nodes.length - 1 6066 while (last > 0) { 6067 if (node.nodes[last].type !== 'comment') break 6068 last -= 1 6069 } 6070 6071 let semicolon = this.raw(node, 'semicolon') 6072 for (let i = 0; i < node.nodes.length; i++) { 6073 let child = node.nodes[i] 6074 let before = this.raw(child, 'before') 6075 if (before) this.builder(before) 6076 this.stringify(child, last !== i || semicolon) 6077 } 6078 } 6079 6080 comment(node) { 6081 let left = this.raw(node, 'left', 'commentLeft') 6082 let right = this.raw(node, 'right', 'commentRight') 6083 this.builder('/*' + left + node.text + right + '*/', node) 6084 } 6085 6086 decl(node, semicolon) { 6087 let between = this.raw(node, 'between', 'colon') 6088 let string = node.prop + between + this.rawValue(node, 'value') 6089 6090 if (node.important) { 6091 string += node.raws.important || ' !important' 6092 } 6093 6094 if (semicolon) string += ';' 6095 this.builder(string, node) 6096 } 6097 6098 document(node) { 6099 this.body(node) 6100 } 6101 6102 raw(node, own, detect) { 6103 let value 6104 if (!detect) detect = own 6105 6106 // Already had 6107 if (own) { 6108 value = node.raws[own] 6109 if (typeof value !== 'undefined') return value 6110 } 6111 6112 let parent = node.parent 6113 6114 if (detect === 'before') { 6115 // Hack for first rule in CSS 6116 if (!parent || (parent.type === 'root' && parent.first === node)) { 6117 return '' 6118 } 6119 6120 // `root` nodes in `document` should use only their own raws 6121 if (parent && parent.type === 'document') { 6122 return '' 6123 } 6124 } 6125 6126 // Floating child without parent 6127 if (!parent) return DEFAULT_RAW[detect] 6128 6129 // Detect style by other nodes 6130 let root = node.root() 6131 if (!root.rawCache) root.rawCache = {} 6132 if (typeof root.rawCache[detect] !== 'undefined') { 6133 return root.rawCache[detect] 6134 } 6135 6136 if (detect === 'before' || detect === 'after') { 6137 return this.beforeAfter(node, detect) 6138 } else { 6139 let method = 'raw' + capitalize(detect) 6140 if (this[method]) { 6141 value = this[method](root, node) 6142 } else { 6143 root.walk(i => { 6144 value = i.raws[own] 6145 if (typeof value !== 'undefined') return false 6146 }) 6147 } 6148 } 6149 6150 if (typeof value === 'undefined') value = DEFAULT_RAW[detect] 6151 6152 root.rawCache[detect] = value 6153 return value 6154 } 6155 6156 rawBeforeClose(root) { 6157 let value 6158 root.walk(i => { 6159 if (i.nodes && i.nodes.length > 0) { 6160 if (typeof i.raws.after !== 'undefined') { 6161 value = i.raws.after 6162 if (value.includes('\n')) { 6163 value = value.replace(/[^\n]+$/, '') 6164 } 6165 return false 6166 } 6167 } 6168 }) 6169 if (value) value = value.replace(/\S/g, '') 6170 return value 6171 } 6172 6173 rawBeforeComment(root, node) { 6174 let value 6175 root.walkComments(i => { 6176 if (typeof i.raws.before !== 'undefined') { 6177 value = i.raws.before 6178 if (value.includes('\n')) { 6179 value = value.replace(/[^\n]+$/, '') 6180 } 6181 return false 6182 } 6183 }) 6184 if (typeof value === 'undefined') { 6185 value = this.raw(node, null, 'beforeDecl') 6186 } else if (value) { 6187 value = value.replace(/\S/g, '') 6188 } 6189 return value 6190 } 6191 6192 rawBeforeDecl(root, node) { 6193 let value 6194 root.walkDecls(i => { 6195 if (typeof i.raws.before !== 'undefined') { 6196 value = i.raws.before 6197 if (value.includes('\n')) { 6198 value = value.replace(/[^\n]+$/, '') 6199 } 6200 return false 6201 } 6202 }) 6203 if (typeof value === 'undefined') { 6204 value = this.raw(node, null, 'beforeRule') 6205 } else if (value) { 6206 value = value.replace(/\S/g, '') 6207 } 6208 return value 6209 } 6210 6211 rawBeforeOpen(root) { 6212 let value 6213 root.walk(i => { 6214 if (i.type !== 'decl') { 6215 value = i.raws.between 6216 if (typeof value !== 'undefined') return false 6217 } 6218 }) 6219 return value 6220 } 6221 6222 rawBeforeRule(root) { 6223 let value 6224 root.walk(i => { 6225 if (i.nodes && (i.parent !== root || root.first !== i)) { 6226 if (typeof i.raws.before !== 'undefined') { 6227 value = i.raws.before 6228 if (value.includes('\n')) { 6229 value = value.replace(/[^\n]+$/, '') 6230 } 6231 return false 6232 } 6233 } 6234 }) 6235 if (value) value = value.replace(/\S/g, '') 6236 return value 6237 } 6238 6239 rawColon(root) { 6240 let value 6241 root.walkDecls(i => { 6242 if (typeof i.raws.between !== 'undefined') { 6243 value = i.raws.between.replace(/[^\s:]/g, '') 6244 return false 6245 } 6246 }) 6247 return value 6248 } 6249 6250 rawEmptyBody(root) { 6251 let value 6252 root.walk(i => { 6253 if (i.nodes && i.nodes.length === 0) { 6254 value = i.raws.after 6255 if (typeof value !== 'undefined') return false 6256 } 6257 }) 6258 return value 6259 } 6260 6261 rawIndent(root) { 6262 if (root.raws.indent) return root.raws.indent 6263 let value 6264 root.walk(i => { 6265 let p = i.parent 6266 if (p && p !== root && p.parent && p.parent === root) { 6267 if (typeof i.raws.before !== 'undefined') { 6268 let parts = i.raws.before.split('\n') 6269 value = parts[parts.length - 1] 6270 value = value.replace(/\S/g, '') 6271 return false 6272 } 6273 } 6274 }) 6275 return value 6276 } 6277 6278 rawSemicolon(root) { 6279 let value 6280 root.walk(i => { 6281 if (i.nodes && i.nodes.length && i.last.type === 'decl') { 6282 value = i.raws.semicolon 6283 if (typeof value !== 'undefined') return false 6284 } 6285 }) 6286 return value 6287 } 6288 6289 rawValue(node, prop) { 6290 let value = node[prop] 6291 let raw = node.raws[prop] 6292 if (raw && raw.value === value) { 6293 return raw.raw 6294 } 6295 6296 return value 6297 } 6298 6299 root(node) { 6300 this.body(node) 6301 if (node.raws.after) this.builder(node.raws.after) 6302 } 6303 6304 rule(node) { 6305 this.block(node, this.rawValue(node, 'selector')) 6306 if (node.raws.ownSemicolon) { 6307 this.builder(node.raws.ownSemicolon, node, 'end') 6308 } 6309 } 6310 6311 stringify(node, semicolon) { 6312 /* c8 ignore start */ 6313 if (!this[node.type]) { 6314 throw new Error( 6315 'Unknown AST node type ' + 6316 node.type + 6317 '. ' + 6318 'Maybe you need to change PostCSS stringifier.' 6319 ) 6320 } 6321 /* c8 ignore stop */ 6322 this[node.type](node, semicolon) 6323 } 6324 } 6325 6326 module.exports = Stringifier 6327 Stringifier.default = Stringifier 6328 6329 6330 /***/ }), 6331 6332 /***/ 633: 6333 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6334 6335 "use strict"; 6336 6337 6338 let Stringifier = __webpack_require__(346) 6339 6340 function stringify(node, builder) { 6341 let str = new Stringifier(builder) 6342 str.stringify(node) 6343 } 6344 6345 module.exports = stringify 6346 stringify.default = stringify 6347 6348 6349 /***/ }), 6350 6351 /***/ 1381: 6352 /***/ ((module) => { 6353 6354 "use strict"; 6355 6356 6357 module.exports.isClean = Symbol('isClean') 6358 6359 module.exports.my = Symbol('my') 6360 6361 6362 /***/ }), 6363 6364 /***/ 2327: 6365 /***/ ((module) => { 6366 6367 "use strict"; 6368 6369 6370 const SINGLE_QUOTE = "'".charCodeAt(0) 6371 const DOUBLE_QUOTE = '"'.charCodeAt(0) 6372 const BACKSLASH = '\\'.charCodeAt(0) 6373 const SLASH = '/'.charCodeAt(0) 6374 const NEWLINE = '\n'.charCodeAt(0) 6375 const SPACE = ' '.charCodeAt(0) 6376 const FEED = '\f'.charCodeAt(0) 6377 const TAB = '\t'.charCodeAt(0) 6378 const CR = '\r'.charCodeAt(0) 6379 const OPEN_SQUARE = '['.charCodeAt(0) 6380 const CLOSE_SQUARE = ']'.charCodeAt(0) 6381 const OPEN_PARENTHESES = '('.charCodeAt(0) 6382 const CLOSE_PARENTHESES = ')'.charCodeAt(0) 6383 const OPEN_CURLY = '{'.charCodeAt(0) 6384 const CLOSE_CURLY = '}'.charCodeAt(0) 6385 const SEMICOLON = ';'.charCodeAt(0) 6386 const ASTERISK = '*'.charCodeAt(0) 6387 const COLON = ':'.charCodeAt(0) 6388 const AT = '@'.charCodeAt(0) 6389 6390 const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g 6391 const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g 6392 const RE_BAD_BRACKET = /.[\r\n"'(/\\]/ 6393 const RE_HEX_ESCAPE = /[\da-f]/i 6394 6395 module.exports = function tokenizer(input, options = {}) { 6396 let css = input.css.valueOf() 6397 let ignore = options.ignoreErrors 6398 6399 let code, content, escape, next, quote 6400 let currentToken, escaped, escapePos, n, prev 6401 6402 let length = css.length 6403 let pos = 0 6404 let buffer = [] 6405 let returned = [] 6406 6407 function position() { 6408 return pos 6409 } 6410 6411 function unclosed(what) { 6412 throw input.error('Unclosed ' + what, pos) 6413 } 6414 6415 function endOfFile() { 6416 return returned.length === 0 && pos >= length 6417 } 6418 6419 function nextToken(opts) { 6420 if (returned.length) return returned.pop() 6421 if (pos >= length) return 6422 6423 let ignoreUnclosed = opts ? opts.ignoreUnclosed : false 6424 6425 code = css.charCodeAt(pos) 6426 6427 switch (code) { 6428 case NEWLINE: 6429 case SPACE: 6430 case TAB: 6431 case CR: 6432 case FEED: { 6433 next = pos 6434 do { 6435 next += 1 6436 code = css.charCodeAt(next) 6437 } while ( 6438 code === SPACE || 6439 code === NEWLINE || 6440 code === TAB || 6441 code === CR || 6442 code === FEED 6443 ) 6444 6445 currentToken = ['space', css.slice(pos, next)] 6446 pos = next - 1 6447 break 6448 } 6449 6450 case OPEN_SQUARE: 6451 case CLOSE_SQUARE: 6452 case OPEN_CURLY: 6453 case CLOSE_CURLY: 6454 case COLON: 6455 case SEMICOLON: 6456 case CLOSE_PARENTHESES: { 6457 let controlChar = String.fromCharCode(code) 6458 currentToken = [controlChar, controlChar, pos] 6459 break 6460 } 6461 6462 case OPEN_PARENTHESES: { 6463 prev = buffer.length ? buffer.pop()[1] : '' 6464 n = css.charCodeAt(pos + 1) 6465 if ( 6466 prev === 'url' && 6467 n !== SINGLE_QUOTE && 6468 n !== DOUBLE_QUOTE && 6469 n !== SPACE && 6470 n !== NEWLINE && 6471 n !== TAB && 6472 n !== FEED && 6473 n !== CR 6474 ) { 6475 next = pos 6476 do { 6477 escaped = false 6478 next = css.indexOf(')', next + 1) 6479 if (next === -1) { 6480 if (ignore || ignoreUnclosed) { 6481 next = pos 6482 break 6483 } else { 6484 unclosed('bracket') 6485 } 6486 } 6487 escapePos = next 6488 while (css.charCodeAt(escapePos - 1) === BACKSLASH) { 6489 escapePos -= 1 6490 escaped = !escaped 6491 } 6492 } while (escaped) 6493 6494 currentToken = ['brackets', css.slice(pos, next + 1), pos, next] 6495 6496 pos = next 6497 } else { 6498 next = css.indexOf(')', pos + 1) 6499 content = css.slice(pos, next + 1) 6500 6501 if (next === -1 || RE_BAD_BRACKET.test(content)) { 6502 currentToken = ['(', '(', pos] 6503 } else { 6504 currentToken = ['brackets', content, pos, next] 6505 pos = next 6506 } 6507 } 6508 6509 break 6510 } 6511 6512 case SINGLE_QUOTE: 6513 case DOUBLE_QUOTE: { 6514 quote = code === SINGLE_QUOTE ? "'" : '"' 6515 next = pos 6516 do { 6517 escaped = false 6518 next = css.indexOf(quote, next + 1) 6519 if (next === -1) { 6520 if (ignore || ignoreUnclosed) { 6521 next = pos + 1 6522 break 6523 } else { 6524 unclosed('string') 6525 } 6526 } 6527 escapePos = next 6528 while (css.charCodeAt(escapePos - 1) === BACKSLASH) { 6529 escapePos -= 1 6530 escaped = !escaped 6531 } 6532 } while (escaped) 6533 6534 currentToken = ['string', css.slice(pos, next + 1), pos, next] 6535 pos = next 6536 break 6537 } 6538 6539 case AT: { 6540 RE_AT_END.lastIndex = pos + 1 6541 RE_AT_END.test(css) 6542 if (RE_AT_END.lastIndex === 0) { 6543 next = css.length - 1 6544 } else { 6545 next = RE_AT_END.lastIndex - 2 6546 } 6547 6548 currentToken = ['at-word', css.slice(pos, next + 1), pos, next] 6549 6550 pos = next 6551 break 6552 } 6553 6554 case BACKSLASH: { 6555 next = pos 6556 escape = true 6557 while (css.charCodeAt(next + 1) === BACKSLASH) { 6558 next += 1 6559 escape = !escape 6560 } 6561 code = css.charCodeAt(next + 1) 6562 if ( 6563 escape && 6564 code !== SLASH && 6565 code !== SPACE && 6566 code !== NEWLINE && 6567 code !== TAB && 6568 code !== CR && 6569 code !== FEED 6570 ) { 6571 next += 1 6572 if (RE_HEX_ESCAPE.test(css.charAt(next))) { 6573 while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) { 6574 next += 1 6575 } 6576 if (css.charCodeAt(next + 1) === SPACE) { 6577 next += 1 6578 } 6579 } 6580 } 6581 6582 currentToken = ['word', css.slice(pos, next + 1), pos, next] 6583 6584 pos = next 6585 break 6586 } 6587 6588 default: { 6589 if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) { 6590 next = css.indexOf('*/', pos + 2) + 1 6591 if (next === 0) { 6592 if (ignore || ignoreUnclosed) { 6593 next = css.length 6594 } else { 6595 unclosed('comment') 6596 } 6597 } 6598 6599 currentToken = ['comment', css.slice(pos, next + 1), pos, next] 6600 pos = next 6601 } else { 6602 RE_WORD_END.lastIndex = pos + 1 6603 RE_WORD_END.test(css) 6604 if (RE_WORD_END.lastIndex === 0) { 6605 next = css.length - 1 6606 } else { 6607 next = RE_WORD_END.lastIndex - 2 6608 } 6609 6610 currentToken = ['word', css.slice(pos, next + 1), pos, next] 6611 buffer.push(currentToken) 6612 pos = next 6613 } 6614 6615 break 6616 } 6617 } 6618 6619 pos++ 6620 return currentToken 6621 } 6622 6623 function back(token) { 6624 returned.push(token) 6625 } 6626 6627 return { 6628 back, 6629 endOfFile, 6630 nextToken, 6631 position 6632 } 6633 } 6634 6635 6636 /***/ }), 6637 6638 /***/ 3122: 6639 /***/ ((module) => { 6640 6641 "use strict"; 6642 /* eslint-disable no-console */ 6643 6644 6645 let printed = {} 6646 6647 module.exports = function warnOnce(message) { 6648 if (printed[message]) return 6649 printed[message] = true 6650 6651 if (typeof console !== 'undefined' && console.warn) { 6652 console.warn(message) 6653 } 6654 } 6655 6656 6657 /***/ }), 6658 6659 /***/ 5776: 6660 /***/ ((module) => { 6661 6662 "use strict"; 6663 6664 6665 class Warning { 6666 constructor(text, opts = {}) { 6667 this.type = 'warning' 6668 this.text = text 6669 6670 if (opts.node && opts.node.source) { 6671 let range = opts.node.rangeBy(opts) 6672 this.line = range.start.line 6673 this.column = range.start.column 6674 this.endLine = range.end.line 6675 this.endColumn = range.end.column 6676 } 6677 6678 for (let opt in opts) this[opt] = opts[opt] 6679 } 6680 6681 toString() { 6682 if (this.node) { 6683 return this.node.error(this.text, { 6684 index: this.index, 6685 plugin: this.plugin, 6686 word: this.word 6687 }).message 6688 } 6689 6690 if (this.plugin) { 6691 return this.plugin + ': ' + this.text 6692 } 6693 6694 return this.text 6695 } 6696 } 6697 6698 module.exports = Warning 6699 Warning.default = Warning 6700 6701 6702 /***/ }), 6703 6704 /***/ 628: 6705 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6706 6707 "use strict"; 6708 /** 6709 * Copyright (c) 2013-present, Facebook, Inc. 6710 * 6711 * This source code is licensed under the MIT license found in the 6712 * LICENSE file in the root directory of this source tree. 6713 */ 6714 6715 6716 6717 var ReactPropTypesSecret = __webpack_require__(4067); 6718 6719 function emptyFunction() {} 6720 function emptyFunctionWithReset() {} 6721 emptyFunctionWithReset.resetWarningCache = emptyFunction; 6722 6723 module.exports = function() { 6724 function shim(props, propName, componentName, location, propFullName, secret) { 6725 if (secret === ReactPropTypesSecret) { 6726 // It is still safe when called from React. 6727 return; 6728 } 6729 var err = new Error( 6730 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 6731 'Use PropTypes.checkPropTypes() to call them. ' + 6732 'Read more at http://fb.me/use-check-prop-types' 6733 ); 6734 err.name = 'Invariant Violation'; 6735 throw err; 6736 }; 6737 shim.isRequired = shim; 6738 function getShim() { 6739 return shim; 6740 }; 6741 // Important! 6742 // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`. 6743 var ReactPropTypes = { 6744 array: shim, 6745 bigint: shim, 6746 bool: shim, 6747 func: shim, 6748 number: shim, 6749 object: shim, 6750 string: shim, 6751 symbol: shim, 6752 6753 any: shim, 6754 arrayOf: getShim, 6755 element: shim, 6756 elementType: shim, 6757 instanceOf: getShim, 6758 node: shim, 6759 objectOf: getShim, 6760 oneOf: getShim, 6761 oneOfType: getShim, 6762 shape: getShim, 6763 exact: getShim, 6764 6765 checkPropTypes: emptyFunctionWithReset, 6766 resetWarningCache: emptyFunction 6767 }; 6768 6769 ReactPropTypes.PropTypes = ReactPropTypes; 6770 6771 return ReactPropTypes; 6772 }; 6773 6774 6775 /***/ }), 6776 6777 /***/ 5826: 6778 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6779 6780 /** 6781 * Copyright (c) 2013-present, Facebook, Inc. 6782 * 6783 * This source code is licensed under the MIT license found in the 6784 * LICENSE file in the root directory of this source tree. 6785 */ 6786 6787 if (false) { var throwOnDirectAccess, ReactIs; } else { 6788 // By explicitly using `prop-types` you are opting into new production behavior. 6789 // http://fb.me/prop-types-in-prod 6790 module.exports = __webpack_require__(628)(); 6791 } 6792 6793 6794 /***/ }), 6795 6796 /***/ 4067: 6797 /***/ ((module) => { 6798 6799 "use strict"; 6800 /** 6801 * Copyright (c) 2013-present, Facebook, Inc. 6802 * 6803 * This source code is licensed under the MIT license found in the 6804 * LICENSE file in the root directory of this source tree. 6805 */ 6806 6807 6808 6809 var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; 6810 6811 module.exports = ReactPropTypesSecret; 6812 6813 6814 /***/ }), 6815 6816 /***/ 4462: 6817 /***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6818 6819 "use strict"; 6820 6821 var __extends = (this && this.__extends) || (function () { 6822 var extendStatics = Object.setPrototypeOf || 6823 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 6824 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 6825 return function (d, b) { 6826 extendStatics(d, b); 6827 function __() { this.constructor = d; } 6828 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 6829 }; 6830 })(); 6831 var __assign = (this && this.__assign) || Object.assign || function(t) { 6832 for (var s, i = 1, n = arguments.length; i < n; i++) { 6833 s = arguments[i]; 6834 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) 6835 t[p] = s[p]; 6836 } 6837 return t; 6838 }; 6839 var __rest = (this && this.__rest) || function (s, e) { 6840 var t = {}; 6841 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) 6842 t[p] = s[p]; 6843 if (s != null && typeof Object.getOwnPropertySymbols === "function") 6844 for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0) 6845 t[p[i]] = s[p[i]]; 6846 return t; 6847 }; 6848 exports.__esModule = true; 6849 var React = __webpack_require__(1609); 6850 var PropTypes = __webpack_require__(5826); 6851 var autosize = __webpack_require__(4306); 6852 var _getLineHeight = __webpack_require__(461); 6853 var getLineHeight = _getLineHeight; 6854 var RESIZED = "autosize:resized"; 6855 /** 6856 * A light replacement for built-in textarea component 6857 * which automaticaly adjusts its height to match the content 6858 */ 6859 var TextareaAutosizeClass = /** @class */ (function (_super) { 6860 __extends(TextareaAutosizeClass, _super); 6861 function TextareaAutosizeClass() { 6862 var _this = _super !== null && _super.apply(this, arguments) || this; 6863 _this.state = { 6864 lineHeight: null 6865 }; 6866 _this.textarea = null; 6867 _this.onResize = function (e) { 6868 if (_this.props.onResize) { 6869 _this.props.onResize(e); 6870 } 6871 }; 6872 _this.updateLineHeight = function () { 6873 if (_this.textarea) { 6874 _this.setState({ 6875 lineHeight: getLineHeight(_this.textarea) 6876 }); 6877 } 6878 }; 6879 _this.onChange = function (e) { 6880 var onChange = _this.props.onChange; 6881 _this.currentValue = e.currentTarget.value; 6882 onChange && onChange(e); 6883 }; 6884 return _this; 6885 } 6886 TextareaAutosizeClass.prototype.componentDidMount = function () { 6887 var _this = this; 6888 var _a = this.props, maxRows = _a.maxRows, async = _a.async; 6889 if (typeof maxRows === "number") { 6890 this.updateLineHeight(); 6891 } 6892 if (typeof maxRows === "number" || async) { 6893 /* 6894 the defer is needed to: 6895 - force "autosize" to activate the scrollbar when this.props.maxRows is passed 6896 - support StyledComponents (see #71) 6897 */ 6898 setTimeout(function () { return _this.textarea && autosize(_this.textarea); }); 6899 } 6900 else { 6901 this.textarea && autosize(this.textarea); 6902 } 6903 if (this.textarea) { 6904 this.textarea.addEventListener(RESIZED, this.onResize); 6905 } 6906 }; 6907 TextareaAutosizeClass.prototype.componentWillUnmount = function () { 6908 if (this.textarea) { 6909 this.textarea.removeEventListener(RESIZED, this.onResize); 6910 autosize.destroy(this.textarea); 6911 } 6912 }; 6913 TextareaAutosizeClass.prototype.render = function () { 6914 var _this = this; 6915 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; 6916 var maxHeight = maxRows && lineHeight ? lineHeight * maxRows : null; 6917 return (React.createElement("textarea", __assign({}, props, { onChange: this.onChange, style: maxHeight ? __assign({}, style, { maxHeight: maxHeight }) : style, ref: function (element) { 6918 _this.textarea = element; 6919 if (typeof _this.props.innerRef === 'function') { 6920 _this.props.innerRef(element); 6921 } 6922 else if (_this.props.innerRef) { 6923 _this.props.innerRef.current = element; 6924 } 6925 } }), children)); 6926 }; 6927 TextareaAutosizeClass.prototype.componentDidUpdate = function () { 6928 this.textarea && autosize.update(this.textarea); 6929 }; 6930 TextareaAutosizeClass.defaultProps = { 6931 rows: 1, 6932 async: false 6933 }; 6934 TextareaAutosizeClass.propTypes = { 6935 rows: PropTypes.number, 6936 maxRows: PropTypes.number, 6937 onResize: PropTypes.func, 6938 innerRef: PropTypes.any, 6939 async: PropTypes.bool 6940 }; 6941 return TextareaAutosizeClass; 6942 }(React.Component)); 6943 exports.TextareaAutosize = React.forwardRef(function (props, ref) { 6944 return React.createElement(TextareaAutosizeClass, __assign({}, props, { innerRef: ref })); 6945 }); 6946 6947 6948 /***/ }), 6949 6950 /***/ 4132: 6951 /***/ ((__unused_webpack_module, exports, __webpack_require__) => { 6952 6953 "use strict"; 6954 var __webpack_unused_export__; 6955 6956 __webpack_unused_export__ = true; 6957 var TextareaAutosize_1 = __webpack_require__(4462); 6958 exports.A = TextareaAutosize_1.TextareaAutosize; 6959 6960 6961 /***/ }), 6962 6963 /***/ 9681: 6964 /***/ ((module) => { 6965 6966 var characterMap = { 6967 "À": "A", 6968 "Á": "A", 6969 "Â": "A", 6970 "Ã": "A", 6971 "Ä": "A", 6972 "Å": "A", 6973 "Ấ": "A", 6974 "Ắ": "A", 6975 "Ẳ": "A", 6976 "Ẵ": "A", 6977 "Ặ": "A", 6978 "Æ": "AE", 6979 "Ầ": "A", 6980 "Ằ": "A", 6981 "Ȃ": "A", 6982 "Ả": "A", 6983 "Ạ": "A", 6984 "Ẩ": "A", 6985 "Ẫ": "A", 6986 "Ậ": "A", 6987 "Ç": "C", 6988 "Ḉ": "C", 6989 "È": "E", 6990 "É": "E", 6991 "Ê": "E", 6992 "Ë": "E", 6993 "Ế": "E", 6994 "Ḗ": "E", 6995 "Ề": "E", 6996 "Ḕ": "E", 6997 "Ḝ": "E", 6998 "Ȇ": "E", 6999 "Ẻ": "E", 7000 "Ẽ": "E", 7001 "Ẹ": "E", 7002 "Ể": "E", 7003 "Ễ": "E", 7004 "Ệ": "E", 7005 "Ì": "I", 7006 "Í": "I", 7007 "Î": "I", 7008 "Ï": "I", 7009 "Ḯ": "I", 7010 "Ȋ": "I", 7011 "Ỉ": "I", 7012 "Ị": "I", 7013 "Ð": "D", 7014 "Ñ": "N", 7015 "Ò": "O", 7016 "Ó": "O", 7017 "Ô": "O", 7018 "Õ": "O", 7019 "Ö": "O", 7020 "Ø": "O", 7021 "Ố": "O", 7022 "Ṍ": "O", 7023 "Ṓ": "O", 7024 "Ȏ": "O", 7025 "Ỏ": "O", 7026 "Ọ": "O", 7027 "Ổ": "O", 7028 "Ỗ": "O", 7029 "Ộ": "O", 7030 "Ờ": "O", 7031 "Ở": "O", 7032 "Ỡ": "O", 7033 "Ớ": "O", 7034 "Ợ": "O", 7035 "Ù": "U", 7036 "Ú": "U", 7037 "Û": "U", 7038 "Ü": "U", 7039 "Ủ": "U", 7040 "Ụ": "U", 7041 "Ử": "U", 7042 "Ữ": "U", 7043 "Ự": "U", 7044 "Ý": "Y", 7045 "à": "a", 7046 "á": "a", 7047 "â": "a", 7048 "ã": "a", 7049 "ä": "a", 7050 "å": "a", 7051 "ấ": "a", 7052 "ắ": "a", 7053 "ẳ": "a", 7054 "ẵ": "a", 7055 "ặ": "a", 7056 "æ": "ae", 7057 "ầ": "a", 7058 "ằ": "a", 7059 "ȃ": "a", 7060 "ả": "a", 7061 "ạ": "a", 7062 "ẩ": "a", 7063 "ẫ": "a", 7064 "ậ": "a", 7065 "ç": "c", 7066 "ḉ": "c", 7067 "è": "e", 7068 "é": "e", 7069 "ê": "e", 7070 "ë": "e", 7071 "ế": "e", 7072 "ḗ": "e", 7073 "ề": "e", 7074 "ḕ": "e", 7075 "ḝ": "e", 7076 "ȇ": "e", 7077 "ẻ": "e", 7078 "ẽ": "e", 7079 "ẹ": "e", 7080 "ể": "e", 7081 "ễ": "e", 7082 "ệ": "e", 7083 "ì": "i", 7084 "í": "i", 7085 "î": "i", 7086 "ï": "i", 7087 "ḯ": "i", 7088 "ȋ": "i", 7089 "ỉ": "i", 7090 "ị": "i", 7091 "ð": "d", 7092 "ñ": "n", 7093 "ò": "o", 7094 "ó": "o", 7095 "ô": "o", 7096 "õ": "o", 7097 "ö": "o", 7098 "ø": "o", 7099 "ố": "o", 7100 "ṍ": "o", 7101 "ṓ": "o", 7102 "ȏ": "o", 7103 "ỏ": "o", 7104 "ọ": "o", 7105 "ổ": "o", 7106 "ỗ": "o", 7107 "ộ": "o", 7108 "ờ": "o", 7109 "ở": "o", 7110 "ỡ": "o", 7111 "ớ": "o", 7112 "ợ": "o", 7113 "ù": "u", 7114 "ú": "u", 7115 "û": "u", 7116 "ü": "u", 7117 "ủ": "u", 7118 "ụ": "u", 7119 "ử": "u", 7120 "ữ": "u", 7121 "ự": "u", 7122 "ý": "y", 7123 "ÿ": "y", 7124 "Ā": "A", 7125 "ā": "a", 7126 "Ă": "A", 7127 "ă": "a", 7128 "Ą": "A", 7129 "ą": "a", 7130 "Ć": "C", 7131 "ć": "c", 7132 "Ĉ": "C", 7133 "ĉ": "c", 7134 "Ċ": "C", 7135 "ċ": "c", 7136 "Č": "C", 7137 "č": "c", 7138 "C̆": "C", 7139 "c̆": "c", 7140 "Ď": "D", 7141 "ď": "d", 7142 "Đ": "D", 7143 "đ": "d", 7144 "Ē": "E", 7145 "ē": "e", 7146 "Ĕ": "E", 7147 "ĕ": "e", 7148 "Ė": "E", 7149 "ė": "e", 7150 "Ę": "E", 7151 "ę": "e", 7152 "Ě": "E", 7153 "ě": "e", 7154 "Ĝ": "G", 7155 "Ǵ": "G", 7156 "ĝ": "g", 7157 "ǵ": "g", 7158 "Ğ": "G", 7159 "ğ": "g", 7160 "Ġ": "G", 7161 "ġ": "g", 7162 "Ģ": "G", 7163 "ģ": "g", 7164 "Ĥ": "H", 7165 "ĥ": "h", 7166 "Ħ": "H", 7167 "ħ": "h", 7168 "Ḫ": "H", 7169 "ḫ": "h", 7170 "Ĩ": "I", 7171 "ĩ": "i", 7172 "Ī": "I", 7173 "ī": "i", 7174 "Ĭ": "I", 7175 "ĭ": "i", 7176 "Į": "I", 7177 "į": "i", 7178 "İ": "I", 7179 "ı": "i", 7180 "IJ": "IJ", 7181 "ij": "ij", 7182 "Ĵ": "J", 7183 "ĵ": "j", 7184 "Ķ": "K", 7185 "ķ": "k", 7186 "Ḱ": "K", 7187 "ḱ": "k", 7188 "K̆": "K", 7189 "k̆": "k", 7190 "Ĺ": "L", 7191 "ĺ": "l", 7192 "Ļ": "L", 7193 "ļ": "l", 7194 "Ľ": "L", 7195 "ľ": "l", 7196 "Ŀ": "L", 7197 "ŀ": "l", 7198 "Ł": "l", 7199 "ł": "l", 7200 "Ḿ": "M", 7201 "ḿ": "m", 7202 "M̆": "M", 7203 "m̆": "m", 7204 "Ń": "N", 7205 "ń": "n", 7206 "Ņ": "N", 7207 "ņ": "n", 7208 "Ň": "N", 7209 "ň": "n", 7210 "ʼn": "n", 7211 "N̆": "N", 7212 "n̆": "n", 7213 "Ō": "O", 7214 "ō": "o", 7215 "Ŏ": "O", 7216 "ŏ": "o", 7217 "Ő": "O", 7218 "ő": "o", 7219 "Œ": "OE", 7220 "œ": "oe", 7221 "P̆": "P", 7222 "p̆": "p", 7223 "Ŕ": "R", 7224 "ŕ": "r", 7225 "Ŗ": "R", 7226 "ŗ": "r", 7227 "Ř": "R", 7228 "ř": "r", 7229 "R̆": "R", 7230 "r̆": "r", 7231 "Ȓ": "R", 7232 "ȓ": "r", 7233 "Ś": "S", 7234 "ś": "s", 7235 "Ŝ": "S", 7236 "ŝ": "s", 7237 "Ş": "S", 7238 "Ș": "S", 7239 "ș": "s", 7240 "ş": "s", 7241 "Š": "S", 7242 "š": "s", 7243 "Ţ": "T", 7244 "ţ": "t", 7245 "ț": "t", 7246 "Ț": "T", 7247 "Ť": "T", 7248 "ť": "t", 7249 "Ŧ": "T", 7250 "ŧ": "t", 7251 "T̆": "T", 7252 "t̆": "t", 7253 "Ũ": "U", 7254 "ũ": "u", 7255 "Ū": "U", 7256 "ū": "u", 7257 "Ŭ": "U", 7258 "ŭ": "u", 7259 "Ů": "U", 7260 "ů": "u", 7261 "Ű": "U", 7262 "ű": "u", 7263 "Ų": "U", 7264 "ų": "u", 7265 "Ȗ": "U", 7266 "ȗ": "u", 7267 "V̆": "V", 7268 "v̆": "v", 7269 "Ŵ": "W", 7270 "ŵ": "w", 7271 "Ẃ": "W", 7272 "ẃ": "w", 7273 "X̆": "X", 7274 "x̆": "x", 7275 "Ŷ": "Y", 7276 "ŷ": "y", 7277 "Ÿ": "Y", 7278 "Y̆": "Y", 7279 "y̆": "y", 7280 "Ź": "Z", 7281 "ź": "z", 7282 "Ż": "Z", 7283 "ż": "z", 7284 "Ž": "Z", 7285 "ž": "z", 7286 "ſ": "s", 7287 "ƒ": "f", 7288 "Ơ": "O", 7289 "ơ": "o", 7290 "Ư": "U", 7291 "ư": "u", 7292 "Ǎ": "A", 7293 "ǎ": "a", 7294 "Ǐ": "I", 7295 "ǐ": "i", 7296 "Ǒ": "O", 7297 "ǒ": "o", 7298 "Ǔ": "U", 7299 "ǔ": "u", 7300 "Ǖ": "U", 7301 "ǖ": "u", 7302 "Ǘ": "U", 7303 "ǘ": "u", 7304 "Ǚ": "U", 7305 "ǚ": "u", 7306 "Ǜ": "U", 7307 "ǜ": "u", 7308 "Ứ": "U", 7309 "ứ": "u", 7310 "Ṹ": "U", 7311 "ṹ": "u", 7312 "Ǻ": "A", 7313 "ǻ": "a", 7314 "Ǽ": "AE", 7315 "ǽ": "ae", 7316 "Ǿ": "O", 7317 "ǿ": "o", 7318 "Þ": "TH", 7319 "þ": "th", 7320 "Ṕ": "P", 7321 "ṕ": "p", 7322 "Ṥ": "S", 7323 "ṥ": "s", 7324 "X́": "X", 7325 "x́": "x", 7326 "Ѓ": "Г", 7327 "ѓ": "г", 7328 "Ќ": "К", 7329 "ќ": "к", 7330 "A̋": "A", 7331 "a̋": "a", 7332 "E̋": "E", 7333 "e̋": "e", 7334 "I̋": "I", 7335 "i̋": "i", 7336 "Ǹ": "N", 7337 "ǹ": "n", 7338 "Ồ": "O", 7339 "ồ": "o", 7340 "Ṑ": "O", 7341 "ṑ": "o", 7342 "Ừ": "U", 7343 "ừ": "u", 7344 "Ẁ": "W", 7345 "ẁ": "w", 7346 "Ỳ": "Y", 7347 "ỳ": "y", 7348 "Ȁ": "A", 7349 "ȁ": "a", 7350 "Ȅ": "E", 7351 "ȅ": "e", 7352 "Ȉ": "I", 7353 "ȉ": "i", 7354 "Ȍ": "O", 7355 "ȍ": "o", 7356 "Ȑ": "R", 7357 "ȑ": "r", 7358 "Ȕ": "U", 7359 "ȕ": "u", 7360 "B̌": "B", 7361 "b̌": "b", 7362 "Č̣": "C", 7363 "č̣": "c", 7364 "Ê̌": "E", 7365 "ê̌": "e", 7366 "F̌": "F", 7367 "f̌": "f", 7368 "Ǧ": "G", 7369 "ǧ": "g", 7370 "Ȟ": "H", 7371 "ȟ": "h", 7372 "J̌": "J", 7373 "ǰ": "j", 7374 "Ǩ": "K", 7375 "ǩ": "k", 7376 "M̌": "M", 7377 "m̌": "m", 7378 "P̌": "P", 7379 "p̌": "p", 7380 "Q̌": "Q", 7381 "q̌": "q", 7382 "Ř̩": "R", 7383 "ř̩": "r", 7384 "Ṧ": "S", 7385 "ṧ": "s", 7386 "V̌": "V", 7387 "v̌": "v", 7388 "W̌": "W", 7389 "w̌": "w", 7390 "X̌": "X", 7391 "x̌": "x", 7392 "Y̌": "Y", 7393 "y̌": "y", 7394 "A̧": "A", 7395 "a̧": "a", 7396 "B̧": "B", 7397 "b̧": "b", 7398 "Ḑ": "D", 7399 "ḑ": "d", 7400 "Ȩ": "E", 7401 "ȩ": "e", 7402 "Ɛ̧": "E", 7403 "ɛ̧": "e", 7404 "Ḩ": "H", 7405 "ḩ": "h", 7406 "I̧": "I", 7407 "i̧": "i", 7408 "Ɨ̧": "I", 7409 "ɨ̧": "i", 7410 "M̧": "M", 7411 "m̧": "m", 7412 "O̧": "O", 7413 "o̧": "o", 7414 "Q̧": "Q", 7415 "q̧": "q", 7416 "U̧": "U", 7417 "u̧": "u", 7418 "X̧": "X", 7419 "x̧": "x", 7420 "Z̧": "Z", 7421 "z̧": "z", 7422 "й":"и", 7423 "Й":"И", 7424 "ё":"е", 7425 "Ё":"Е", 7426 }; 7427 7428 var chars = Object.keys(characterMap).join('|'); 7429 var allAccents = new RegExp(chars, 'g'); 7430 var firstAccent = new RegExp(chars, ''); 7431 7432 function matcher(match) { 7433 return characterMap[match]; 7434 } 7435 7436 var removeAccents = function(string) { 7437 return string.replace(allAccents, matcher); 7438 }; 7439 7440 var hasAccents = function(string) { 7441 return !!string.match(firstAccent); 7442 }; 7443 7444 module.exports = removeAccents; 7445 module.exports.has = hasAccents; 7446 module.exports.remove = removeAccents; 7447 7448 7449 /***/ }), 7450 7451 /***/ 1609: 7452 /***/ ((module) => { 7453 7454 "use strict"; 7455 module.exports = window["React"]; 7456 7457 /***/ }), 7458 7459 /***/ 9746: 7460 /***/ (() => { 7461 7462 /* (ignored) */ 7463 7464 /***/ }), 7465 7466 /***/ 9977: 7467 /***/ (() => { 7468 7469 /* (ignored) */ 7470 7471 /***/ }), 7472 7473 /***/ 197: 7474 /***/ (() => { 7475 7476 /* (ignored) */ 7477 7478 /***/ }), 7479 7480 /***/ 1866: 7481 /***/ (() => { 7482 7483 /* (ignored) */ 7484 7485 /***/ }), 7486 7487 /***/ 2739: 7488 /***/ (() => { 7489 7490 /* (ignored) */ 7491 7492 /***/ }), 7493 7494 /***/ 5042: 7495 /***/ ((module) => { 7496 7497 // This alphabet uses `A-Za-z0-9_-` symbols. 7498 // The order of characters is optimized for better gzip and brotli compression. 7499 // References to the same file (works both for gzip and brotli): 7500 // `'use`, `andom`, and `rict'` 7501 // References to the brotli default dictionary: 7502 // `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf` 7503 let urlAlphabet = 7504 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict' 7505 7506 let customAlphabet = (alphabet, defaultSize = 21) => { 7507 return (size = defaultSize) => { 7508 let id = '' 7509 // A compact alternative for `for (var i = 0; i < step; i++)`. 7510 let i = size | 0 7511 while (i--) { 7512 // `| 0` is more compact and faster than `Math.floor()`. 7513 id += alphabet[(Math.random() * alphabet.length) | 0] 7514 } 7515 return id 7516 } 7517 } 7518 7519 let nanoid = (size = 21) => { 7520 let id = '' 7521 // A compact alternative for `for (var i = 0; i < step; i++)`. 7522 let i = size | 0 7523 while (i--) { 7524 // `| 0` is more compact and faster than `Math.floor()`. 7525 id += urlAlphabet[(Math.random() * 64) | 0] 7526 } 7527 return id 7528 } 7529 7530 module.exports = { nanoid, customAlphabet } 7531 7532 7533 /***/ }) 7534 7535 /******/ }); 7536 /************************************************************************/ 7537 /******/ // The module cache 7538 /******/ var __webpack_module_cache__ = {}; 7539 /******/ 7540 /******/ // The require function 7541 /******/ function __webpack_require__(moduleId) { 7542 /******/ // Check if module is in cache 7543 /******/ var cachedModule = __webpack_module_cache__[moduleId]; 7544 /******/ if (cachedModule !== undefined) { 7545 /******/ return cachedModule.exports; 7546 /******/ } 7547 /******/ // Create a new module (and put it into the cache) 7548 /******/ var module = __webpack_module_cache__[moduleId] = { 7549 /******/ // no module.id needed 7550 /******/ // no module.loaded needed 7551 /******/ exports: {} 7552 /******/ }; 7553 /******/ 7554 /******/ // Execute the module function 7555 /******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__); 7556 /******/ 7557 /******/ // Return the exports of the module 7558 /******/ return module.exports; 7559 /******/ } 7560 /******/ 7561 /************************************************************************/ 7562 /******/ /* webpack/runtime/compat get default export */ 7563 /******/ (() => { 7564 /******/ // getDefaultExport function for compatibility with non-harmony modules 7565 /******/ __webpack_require__.n = (module) => { 7566 /******/ var getter = module && module.__esModule ? 7567 /******/ () => (module['default']) : 7568 /******/ () => (module); 7569 /******/ __webpack_require__.d(getter, { a: getter }); 7570 /******/ return getter; 7571 /******/ }; 7572 /******/ })(); 7573 /******/ 7574 /******/ /* webpack/runtime/define property getters */ 7575 /******/ (() => { 7576 /******/ // define getter functions for harmony exports 7577 /******/ __webpack_require__.d = (exports, definition) => { 7578 /******/ for(var key in definition) { 7579 /******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 7580 /******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 7581 /******/ } 7582 /******/ } 7583 /******/ }; 7584 /******/ })(); 7585 /******/ 7586 /******/ /* webpack/runtime/hasOwnProperty shorthand */ 7587 /******/ (() => { 7588 /******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) 7589 /******/ })(); 7590 /******/ 7591 /******/ /* webpack/runtime/make namespace object */ 7592 /******/ (() => { 7593 /******/ // define __esModule on exports 7594 /******/ __webpack_require__.r = (exports) => { 7595 /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 7596 /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 7597 /******/ } 7598 /******/ Object.defineProperty(exports, '__esModule', { value: true }); 7599 /******/ }; 7600 /******/ })(); 7601 /******/ 7602 /************************************************************************/ 7603 var __webpack_exports__ = {}; 7604 // This entry needs to be wrapped in an IIFE because it needs to be in strict mode. 7605 (() => { 7606 "use strict"; 7607 // ESM COMPAT FLAG 7608 __webpack_require__.r(__webpack_exports__); 7609 7610 // EXPORTS 7611 __webpack_require__.d(__webpack_exports__, { 7612 AlignmentControl: () => (/* reexport */ AlignmentControl), 7613 AlignmentToolbar: () => (/* reexport */ AlignmentToolbar), 7614 Autocomplete: () => (/* reexport */ autocomplete), 7615 BlockAlignmentControl: () => (/* reexport */ BlockAlignmentControl), 7616 BlockAlignmentToolbar: () => (/* reexport */ BlockAlignmentToolbar), 7617 BlockBreadcrumb: () => (/* reexport */ block_breadcrumb), 7618 BlockCanvas: () => (/* reexport */ block_canvas), 7619 BlockColorsStyleSelector: () => (/* reexport */ color_style_selector), 7620 BlockContextProvider: () => (/* reexport */ BlockContextProvider), 7621 BlockControls: () => (/* reexport */ block_controls), 7622 BlockEdit: () => (/* reexport */ BlockEdit), 7623 BlockEditorKeyboardShortcuts: () => (/* reexport */ keyboard_shortcuts), 7624 BlockEditorProvider: () => (/* reexport */ provider), 7625 BlockFormatControls: () => (/* reexport */ BlockFormatControls), 7626 BlockIcon: () => (/* reexport */ block_icon), 7627 BlockInspector: () => (/* reexport */ block_inspector), 7628 BlockList: () => (/* reexport */ BlockList), 7629 BlockMover: () => (/* reexport */ block_mover), 7630 BlockNavigationDropdown: () => (/* reexport */ dropdown), 7631 BlockPopover: () => (/* reexport */ block_popover), 7632 BlockPreview: () => (/* reexport */ block_preview), 7633 BlockSelectionClearer: () => (/* reexport */ BlockSelectionClearer), 7634 BlockSettingsMenu: () => (/* reexport */ block_settings_menu), 7635 BlockSettingsMenuControls: () => (/* reexport */ block_settings_menu_controls), 7636 BlockStyles: () => (/* reexport */ block_styles), 7637 BlockTitle: () => (/* reexport */ BlockTitle), 7638 BlockToolbar: () => (/* reexport */ BlockToolbar), 7639 BlockTools: () => (/* reexport */ BlockTools), 7640 BlockVerticalAlignmentControl: () => (/* reexport */ BlockVerticalAlignmentControl), 7641 BlockVerticalAlignmentToolbar: () => (/* reexport */ BlockVerticalAlignmentToolbar), 7642 ButtonBlockAppender: () => (/* reexport */ button_block_appender), 7643 ButtonBlockerAppender: () => (/* reexport */ ButtonBlockerAppender), 7644 ColorPalette: () => (/* reexport */ color_palette), 7645 ColorPaletteControl: () => (/* reexport */ ColorPaletteControl), 7646 ContrastChecker: () => (/* reexport */ contrast_checker), 7647 CopyHandler: () => (/* reexport */ CopyHandler), 7648 DefaultBlockAppender: () => (/* reexport */ DefaultBlockAppender), 7649 FontSizePicker: () => (/* reexport */ font_size_picker), 7650 HeadingLevelDropdown: () => (/* reexport */ HeadingLevelDropdown), 7651 HeightControl: () => (/* reexport */ HeightControl), 7652 InnerBlocks: () => (/* reexport */ inner_blocks), 7653 Inserter: () => (/* reexport */ inserter), 7654 InspectorAdvancedControls: () => (/* reexport */ InspectorAdvancedControls), 7655 InspectorControls: () => (/* reexport */ inspector_controls), 7656 JustifyContentControl: () => (/* reexport */ JustifyContentControl), 7657 JustifyToolbar: () => (/* reexport */ JustifyToolbar), 7658 LineHeightControl: () => (/* reexport */ line_height_control), 7659 MediaPlaceholder: () => (/* reexport */ media_placeholder), 7660 MediaReplaceFlow: () => (/* reexport */ media_replace_flow), 7661 MediaUpload: () => (/* reexport */ media_upload), 7662 MediaUploadCheck: () => (/* reexport */ check), 7663 MultiSelectScrollIntoView: () => (/* reexport */ MultiSelectScrollIntoView), 7664 NavigableToolbar: () => (/* reexport */ NavigableToolbar), 7665 ObserveTyping: () => (/* reexport */ observe_typing), 7666 PanelColorSettings: () => (/* reexport */ panel_color_settings), 7667 PlainText: () => (/* reexport */ plain_text), 7668 RecursionProvider: () => (/* reexport */ RecursionProvider), 7669 RichText: () => (/* reexport */ rich_text), 7670 RichTextShortcut: () => (/* reexport */ RichTextShortcut), 7671 RichTextToolbarButton: () => (/* reexport */ RichTextToolbarButton), 7672 SETTINGS_DEFAULTS: () => (/* reexport */ SETTINGS_DEFAULTS), 7673 SkipToSelectedBlock: () => (/* reexport */ SkipToSelectedBlock), 7674 ToolSelector: () => (/* reexport */ tool_selector), 7675 Typewriter: () => (/* reexport */ typewriter), 7676 URLInput: () => (/* reexport */ url_input), 7677 URLInputButton: () => (/* reexport */ url_input_button), 7678 URLPopover: () => (/* reexport */ url_popover), 7679 Warning: () => (/* reexport */ warning), 7680 WritingFlow: () => (/* reexport */ writing_flow), 7681 __experimentalBlockAlignmentMatrixControl: () => (/* reexport */ block_alignment_matrix_control), 7682 __experimentalBlockFullHeightAligmentControl: () => (/* reexport */ block_full_height_alignment_control), 7683 __experimentalBlockPatternSetup: () => (/* reexport */ block_pattern_setup), 7684 __experimentalBlockPatternsList: () => (/* reexport */ block_patterns_list), 7685 __experimentalBlockVariationPicker: () => (/* reexport */ block_variation_picker), 7686 __experimentalBlockVariationTransforms: () => (/* reexport */ block_variation_transforms), 7687 __experimentalBorderRadiusControl: () => (/* reexport */ BorderRadiusControl), 7688 __experimentalColorGradientControl: () => (/* reexport */ control), 7689 __experimentalColorGradientSettingsDropdown: () => (/* reexport */ ColorGradientSettingsDropdown), 7690 __experimentalDateFormatPicker: () => (/* reexport */ DateFormatPicker), 7691 __experimentalDuotoneControl: () => (/* reexport */ duotone_control), 7692 __experimentalFontAppearanceControl: () => (/* reexport */ FontAppearanceControl), 7693 __experimentalFontFamilyControl: () => (/* reexport */ FontFamilyControl), 7694 __experimentalGetBorderClassesAndStyles: () => (/* reexport */ getBorderClassesAndStyles), 7695 __experimentalGetColorClassesAndStyles: () => (/* reexport */ getColorClassesAndStyles), 7696 __experimentalGetElementClassName: () => (/* reexport */ __experimentalGetElementClassName), 7697 __experimentalGetGapCSSValue: () => (/* reexport */ getGapCSSValue), 7698 __experimentalGetGradientClass: () => (/* reexport */ __experimentalGetGradientClass), 7699 __experimentalGetGradientObjectByGradientValue: () => (/* reexport */ __experimentalGetGradientObjectByGradientValue), 7700 __experimentalGetShadowClassesAndStyles: () => (/* reexport */ getShadowClassesAndStyles), 7701 __experimentalGetSpacingClassesAndStyles: () => (/* reexport */ getSpacingClassesAndStyles), 7702 __experimentalImageEditor: () => (/* reexport */ ImageEditor), 7703 __experimentalImageSizeControl: () => (/* reexport */ ImageSizeControl), 7704 __experimentalImageURLInputUI: () => (/* reexport */ ImageURLInputUI), 7705 __experimentalInspectorPopoverHeader: () => (/* reexport */ InspectorPopoverHeader), 7706 __experimentalLetterSpacingControl: () => (/* reexport */ LetterSpacingControl), 7707 __experimentalLibrary: () => (/* reexport */ library), 7708 __experimentalLinkControl: () => (/* reexport */ link_control), 7709 __experimentalLinkControlSearchInput: () => (/* reexport */ search_input), 7710 __experimentalLinkControlSearchItem: () => (/* reexport */ search_item), 7711 __experimentalLinkControlSearchResults: () => (/* reexport */ LinkControlSearchResults), 7712 __experimentalListView: () => (/* reexport */ components_list_view), 7713 __experimentalPanelColorGradientSettings: () => (/* reexport */ panel_color_gradient_settings), 7714 __experimentalPreviewOptions: () => (/* reexport */ PreviewOptions), 7715 __experimentalPublishDateTimePicker: () => (/* reexport */ publish_date_time_picker), 7716 __experimentalRecursionProvider: () => (/* reexport */ DeprecatedExperimentalRecursionProvider), 7717 __experimentalResponsiveBlockControl: () => (/* reexport */ responsive_block_control), 7718 __experimentalSpacingSizesControl: () => (/* reexport */ SpacingSizesControl), 7719 __experimentalTextDecorationControl: () => (/* reexport */ TextDecorationControl), 7720 __experimentalTextTransformControl: () => (/* reexport */ TextTransformControl), 7721 __experimentalUnitControl: () => (/* reexport */ UnitControl), 7722 __experimentalUseBlockOverlayActive: () => (/* reexport */ useBlockOverlayActive), 7723 __experimentalUseBlockPreview: () => (/* reexport */ useBlockPreview), 7724 __experimentalUseBorderProps: () => (/* reexport */ useBorderProps), 7725 __experimentalUseColorProps: () => (/* reexport */ useColorProps), 7726 __experimentalUseCustomSides: () => (/* reexport */ useCustomSides), 7727 __experimentalUseGradient: () => (/* reexport */ __experimentalUseGradient), 7728 __experimentalUseHasRecursion: () => (/* reexport */ DeprecatedExperimentalUseHasRecursion), 7729 __experimentalUseMultipleOriginColorsAndGradients: () => (/* reexport */ useMultipleOriginColorsAndGradients), 7730 __experimentalUseResizeCanvas: () => (/* reexport */ useResizeCanvas), 7731 __experimentalWritingModeControl: () => (/* reexport */ WritingModeControl), 7732 __unstableBlockNameContext: () => (/* reexport */ block_name_context), 7733 __unstableBlockSettingsMenuFirstItem: () => (/* reexport */ block_settings_menu_first_item), 7734 __unstableBlockToolbarLastItem: () => (/* reexport */ block_toolbar_last_item), 7735 __unstableEditorStyles: () => (/* reexport */ editor_styles), 7736 __unstableIframe: () => (/* reexport */ iframe), 7737 __unstableInserterMenuExtension: () => (/* reexport */ inserter_menu_extension), 7738 __unstableRichTextInputEvent: () => (/* reexport */ __unstableRichTextInputEvent), 7739 __unstableUseBlockSelectionClearer: () => (/* reexport */ useBlockSelectionClearer), 7740 __unstableUseClipboardHandler: () => (/* reexport */ __unstableUseClipboardHandler), 7741 __unstableUseMouseMoveTypingReset: () => (/* reexport */ useMouseMoveTypingReset), 7742 __unstableUseTypewriter: () => (/* reexport */ useTypewriter), 7743 __unstableUseTypingObserver: () => (/* reexport */ useTypingObserver), 7744 createCustomColorsHOC: () => (/* reexport */ createCustomColorsHOC), 7745 getColorClassName: () => (/* reexport */ getColorClassName), 7746 getColorObjectByAttributeValues: () => (/* reexport */ getColorObjectByAttributeValues), 7747 getColorObjectByColorValue: () => (/* reexport */ getColorObjectByColorValue), 7748 getComputedFluidTypographyValue: () => (/* reexport */ getComputedFluidTypographyValue), 7749 getCustomValueFromPreset: () => (/* reexport */ getCustomValueFromPreset), 7750 getFontSize: () => (/* reexport */ utils_getFontSize), 7751 getFontSizeClass: () => (/* reexport */ getFontSizeClass), 7752 getFontSizeObjectByValue: () => (/* reexport */ utils_getFontSizeObjectByValue), 7753 getGradientSlugByValue: () => (/* reexport */ getGradientSlugByValue), 7754 getGradientValueBySlug: () => (/* reexport */ getGradientValueBySlug), 7755 getPxFromCssUnit: () => (/* reexport */ get_px_from_css_unit), 7756 getSpacingPresetCssVar: () => (/* reexport */ getSpacingPresetCssVar), 7757 getTypographyClassesAndStyles: () => (/* reexport */ getTypographyClassesAndStyles), 7758 isValueSpacingPreset: () => (/* reexport */ isValueSpacingPreset), 7759 privateApis: () => (/* reexport */ privateApis), 7760 store: () => (/* reexport */ store), 7761 storeConfig: () => (/* reexport */ storeConfig), 7762 transformStyles: () => (/* reexport */ transform_styles), 7763 useBlockBindingsUtils: () => (/* reexport */ useBlockBindingsUtils), 7764 useBlockCommands: () => (/* reexport */ useBlockCommands), 7765 useBlockDisplayInformation: () => (/* reexport */ useBlockDisplayInformation), 7766 useBlockEditContext: () => (/* reexport */ useBlockEditContext), 7767 useBlockEditingMode: () => (/* reexport */ useBlockEditingMode), 7768 useBlockProps: () => (/* reexport */ use_block_props_useBlockProps), 7769 useCachedTruthy: () => (/* reexport */ useCachedTruthy), 7770 useHasRecursion: () => (/* reexport */ useHasRecursion), 7771 useInnerBlocksProps: () => (/* reexport */ useInnerBlocksProps), 7772 useSetting: () => (/* reexport */ useSetting), 7773 useSettings: () => (/* reexport */ use_settings_useSettings), 7774 useStyleOverride: () => (/* reexport */ useStyleOverride), 7775 withColorContext: () => (/* reexport */ with_color_context), 7776 withColors: () => (/* reexport */ withColors), 7777 withFontSizes: () => (/* reexport */ with_font_sizes) 7778 }); 7779 7780 // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/private-selectors.js 7781 var private_selectors_namespaceObject = {}; 7782 __webpack_require__.r(private_selectors_namespaceObject); 7783 __webpack_require__.d(private_selectors_namespaceObject, { 7784 getAllPatterns: () => (getAllPatterns), 7785 getBlockRemovalRules: () => (getBlockRemovalRules), 7786 getBlockSettings: () => (getBlockSettings), 7787 getBlockStyles: () => (getBlockStyles), 7788 getBlockWithoutAttributes: () => (getBlockWithoutAttributes), 7789 getContentLockingParent: () => (getContentLockingParent), 7790 getEnabledBlockParents: () => (getEnabledBlockParents), 7791 getEnabledClientIdsTree: () => (getEnabledClientIdsTree), 7792 getExpandedBlock: () => (getExpandedBlock), 7793 getInserterMediaCategories: () => (getInserterMediaCategories), 7794 getLastFocus: () => (getLastFocus), 7795 getLastInsertedBlocksClientIds: () => (getLastInsertedBlocksClientIds), 7796 getOpenedBlockSettingsMenu: () => (getOpenedBlockSettingsMenu), 7797 getParentSectionBlock: () => (getParentSectionBlock), 7798 getPatternBySlug: () => (getPatternBySlug), 7799 getRegisteredInserterMediaCategories: () => (getRegisteredInserterMediaCategories), 7800 getRemovalPromptData: () => (getRemovalPromptData), 7801 getReusableBlocks: () => (getReusableBlocks), 7802 getSectionRootClientId: () => (getSectionRootClientId), 7803 getStyleOverrides: () => (getStyleOverrides), 7804 getTemporarilyEditingAsBlocks: () => (getTemporarilyEditingAsBlocks), 7805 getTemporarilyEditingFocusModeToRevert: () => (getTemporarilyEditingFocusModeToRevert), 7806 getZoomLevel: () => (getZoomLevel), 7807 hasAllowedPatterns: () => (hasAllowedPatterns), 7808 isBlockInterfaceHidden: () => (private_selectors_isBlockInterfaceHidden), 7809 isBlockSubtreeDisabled: () => (isBlockSubtreeDisabled), 7810 isDragging: () => (private_selectors_isDragging), 7811 isResolvingPatterns: () => (isResolvingPatterns), 7812 isSectionBlock: () => (isSectionBlock), 7813 isZoomOut: () => (isZoomOut), 7814 isZoomOutMode: () => (isZoomOutMode) 7815 }); 7816 7817 // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/selectors.js 7818 var selectors_namespaceObject = {}; 7819 __webpack_require__.r(selectors_namespaceObject); 7820 __webpack_require__.d(selectors_namespaceObject, { 7821 __experimentalGetActiveBlockIdByBlockNames: () => (__experimentalGetActiveBlockIdByBlockNames), 7822 __experimentalGetAllowedBlocks: () => (__experimentalGetAllowedBlocks), 7823 __experimentalGetAllowedPatterns: () => (__experimentalGetAllowedPatterns), 7824 __experimentalGetBlockListSettingsForBlocks: () => (__experimentalGetBlockListSettingsForBlocks), 7825 __experimentalGetDirectInsertBlock: () => (__experimentalGetDirectInsertBlock), 7826 __experimentalGetGlobalBlocksByName: () => (__experimentalGetGlobalBlocksByName), 7827 __experimentalGetLastBlockAttributeChanges: () => (__experimentalGetLastBlockAttributeChanges), 7828 __experimentalGetParsedPattern: () => (__experimentalGetParsedPattern), 7829 __experimentalGetPatternTransformItems: () => (__experimentalGetPatternTransformItems), 7830 __experimentalGetPatternsByBlockTypes: () => (__experimentalGetPatternsByBlockTypes), 7831 __experimentalGetReusableBlockTitle: () => (__experimentalGetReusableBlockTitle), 7832 __unstableGetBlockWithoutInnerBlocks: () => (__unstableGetBlockWithoutInnerBlocks), 7833 __unstableGetClientIdWithClientIdsTree: () => (__unstableGetClientIdWithClientIdsTree), 7834 __unstableGetClientIdsTree: () => (__unstableGetClientIdsTree), 7835 __unstableGetContentLockingParent: () => (__unstableGetContentLockingParent), 7836 __unstableGetEditorMode: () => (__unstableGetEditorMode), 7837 __unstableGetSelectedBlocksWithPartialSelection: () => (__unstableGetSelectedBlocksWithPartialSelection), 7838 __unstableGetTemporarilyEditingAsBlocks: () => (__unstableGetTemporarilyEditingAsBlocks), 7839 __unstableGetTemporarilyEditingFocusModeToRevert: () => (__unstableGetTemporarilyEditingFocusModeToRevert), 7840 __unstableGetVisibleBlocks: () => (__unstableGetVisibleBlocks), 7841 __unstableHasActiveBlockOverlayActive: () => (__unstableHasActiveBlockOverlayActive), 7842 __unstableIsFullySelected: () => (__unstableIsFullySelected), 7843 __unstableIsLastBlockChangeIgnored: () => (__unstableIsLastBlockChangeIgnored), 7844 __unstableIsSelectionCollapsed: () => (__unstableIsSelectionCollapsed), 7845 __unstableIsSelectionMergeable: () => (__unstableIsSelectionMergeable), 7846 __unstableIsWithinBlockOverlay: () => (__unstableIsWithinBlockOverlay), 7847 __unstableSelectionHasUnmergeableBlock: () => (__unstableSelectionHasUnmergeableBlock), 7848 areInnerBlocksControlled: () => (areInnerBlocksControlled), 7849 canEditBlock: () => (canEditBlock), 7850 canInsertBlockType: () => (canInsertBlockType), 7851 canInsertBlocks: () => (canInsertBlocks), 7852 canLockBlockType: () => (canLockBlockType), 7853 canMoveBlock: () => (canMoveBlock), 7854 canMoveBlocks: () => (canMoveBlocks), 7855 canRemoveBlock: () => (canRemoveBlock), 7856 canRemoveBlocks: () => (canRemoveBlocks), 7857 didAutomaticChange: () => (didAutomaticChange), 7858 getAdjacentBlockClientId: () => (getAdjacentBlockClientId), 7859 getAllowedBlocks: () => (getAllowedBlocks), 7860 getBlock: () => (getBlock), 7861 getBlockAttributes: () => (getBlockAttributes), 7862 getBlockCount: () => (getBlockCount), 7863 getBlockEditingMode: () => (getBlockEditingMode), 7864 getBlockHierarchyRootClientId: () => (getBlockHierarchyRootClientId), 7865 getBlockIndex: () => (getBlockIndex), 7866 getBlockInsertionPoint: () => (getBlockInsertionPoint), 7867 getBlockListSettings: () => (getBlockListSettings), 7868 getBlockMode: () => (getBlockMode), 7869 getBlockName: () => (getBlockName), 7870 getBlockNamesByClientId: () => (getBlockNamesByClientId), 7871 getBlockOrder: () => (getBlockOrder), 7872 getBlockParents: () => (getBlockParents), 7873 getBlockParentsByBlockName: () => (getBlockParentsByBlockName), 7874 getBlockRootClientId: () => (getBlockRootClientId), 7875 getBlockSelectionEnd: () => (getBlockSelectionEnd), 7876 getBlockSelectionStart: () => (getBlockSelectionStart), 7877 getBlockTransformItems: () => (getBlockTransformItems), 7878 getBlocks: () => (getBlocks), 7879 getBlocksByClientId: () => (getBlocksByClientId), 7880 getBlocksByName: () => (getBlocksByName), 7881 getClientIdsOfDescendants: () => (getClientIdsOfDescendants), 7882 getClientIdsWithDescendants: () => (getClientIdsWithDescendants), 7883 getDirectInsertBlock: () => (getDirectInsertBlock), 7884 getDraggedBlockClientIds: () => (getDraggedBlockClientIds), 7885 getFirstMultiSelectedBlockClientId: () => (getFirstMultiSelectedBlockClientId), 7886 getGlobalBlockCount: () => (getGlobalBlockCount), 7887 getHoveredBlockClientId: () => (getHoveredBlockClientId), 7888 getInserterItems: () => (getInserterItems), 7889 getLastMultiSelectedBlockClientId: () => (getLastMultiSelectedBlockClientId), 7890 getLowestCommonAncestorWithSelectedBlock: () => (getLowestCommonAncestorWithSelectedBlock), 7891 getMultiSelectedBlockClientIds: () => (getMultiSelectedBlockClientIds), 7892 getMultiSelectedBlocks: () => (getMultiSelectedBlocks), 7893 getMultiSelectedBlocksEndClientId: () => (getMultiSelectedBlocksEndClientId), 7894 getMultiSelectedBlocksStartClientId: () => (getMultiSelectedBlocksStartClientId), 7895 getNextBlockClientId: () => (getNextBlockClientId), 7896 getPatternsByBlockTypes: () => (getPatternsByBlockTypes), 7897 getPreviousBlockClientId: () => (getPreviousBlockClientId), 7898 getSelectedBlock: () => (getSelectedBlock), 7899 getSelectedBlockClientId: () => (getSelectedBlockClientId), 7900 getSelectedBlockClientIds: () => (getSelectedBlockClientIds), 7901 getSelectedBlockCount: () => (getSelectedBlockCount), 7902 getSelectedBlocksInitialCaretPosition: () => (getSelectedBlocksInitialCaretPosition), 7903 getSelectionEnd: () => (getSelectionEnd), 7904 getSelectionStart: () => (getSelectionStart), 7905 getSettings: () => (getSettings), 7906 getTemplate: () => (getTemplate), 7907 getTemplateLock: () => (getTemplateLock), 7908 hasBlockMovingClientId: () => (selectors_hasBlockMovingClientId), 7909 hasDraggedInnerBlock: () => (hasDraggedInnerBlock), 7910 hasInserterItems: () => (hasInserterItems), 7911 hasMultiSelection: () => (hasMultiSelection), 7912 hasSelectedBlock: () => (hasSelectedBlock), 7913 hasSelectedInnerBlock: () => (hasSelectedInnerBlock), 7914 isAncestorBeingDragged: () => (isAncestorBeingDragged), 7915 isAncestorMultiSelected: () => (isAncestorMultiSelected), 7916 isBlockBeingDragged: () => (isBlockBeingDragged), 7917 isBlockHighlighted: () => (isBlockHighlighted), 7918 isBlockInsertionPointVisible: () => (isBlockInsertionPointVisible), 7919 isBlockMultiSelected: () => (isBlockMultiSelected), 7920 isBlockSelected: () => (isBlockSelected), 7921 isBlockValid: () => (isBlockValid), 7922 isBlockVisible: () => (isBlockVisible), 7923 isBlockWithinSelection: () => (isBlockWithinSelection), 7924 isCaretWithinFormattedText: () => (isCaretWithinFormattedText), 7925 isDraggingBlocks: () => (isDraggingBlocks), 7926 isFirstMultiSelectedBlock: () => (isFirstMultiSelectedBlock), 7927 isGroupable: () => (isGroupable), 7928 isLastBlockChangePersistent: () => (isLastBlockChangePersistent), 7929 isMultiSelecting: () => (selectors_isMultiSelecting), 7930 isNavigationMode: () => (isNavigationMode), 7931 isSelectionEnabled: () => (selectors_isSelectionEnabled), 7932 isTyping: () => (selectors_isTyping), 7933 isUngroupable: () => (isUngroupable), 7934 isValidTemplate: () => (isValidTemplate), 7935 wasBlockJustInserted: () => (wasBlockJustInserted) 7936 }); 7937 7938 // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/private-actions.js 7939 var private_actions_namespaceObject = {}; 7940 __webpack_require__.r(private_actions_namespaceObject); 7941 __webpack_require__.d(private_actions_namespaceObject, { 7942 __experimentalUpdateSettings: () => (__experimentalUpdateSettings), 7943 clearBlockRemovalPrompt: () => (clearBlockRemovalPrompt), 7944 deleteStyleOverride: () => (deleteStyleOverride), 7945 ensureDefaultBlock: () => (ensureDefaultBlock), 7946 expandBlock: () => (expandBlock), 7947 hideBlockInterface: () => (hideBlockInterface), 7948 modifyContentLockBlock: () => (modifyContentLockBlock), 7949 privateRemoveBlocks: () => (privateRemoveBlocks), 7950 resetZoomLevel: () => (resetZoomLevel), 7951 setBlockRemovalRules: () => (setBlockRemovalRules), 7952 setLastFocus: () => (setLastFocus), 7953 setOpenedBlockSettingsMenu: () => (setOpenedBlockSettingsMenu), 7954 setStyleOverride: () => (setStyleOverride), 7955 setZoomLevel: () => (setZoomLevel), 7956 showBlockInterface: () => (showBlockInterface), 7957 startDragging: () => (startDragging), 7958 stopDragging: () => (stopDragging), 7959 stopEditingAsBlocks: () => (stopEditingAsBlocks) 7960 }); 7961 7962 // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/actions.js 7963 var actions_namespaceObject = {}; 7964 __webpack_require__.r(actions_namespaceObject); 7965 __webpack_require__.d(actions_namespaceObject, { 7966 __unstableDeleteSelection: () => (__unstableDeleteSelection), 7967 __unstableExpandSelection: () => (__unstableExpandSelection), 7968 __unstableMarkAutomaticChange: () => (__unstableMarkAutomaticChange), 7969 __unstableMarkLastChangeAsPersistent: () => (__unstableMarkLastChangeAsPersistent), 7970 __unstableMarkNextChangeAsNotPersistent: () => (__unstableMarkNextChangeAsNotPersistent), 7971 __unstableSaveReusableBlock: () => (__unstableSaveReusableBlock), 7972 __unstableSetEditorMode: () => (__unstableSetEditorMode), 7973 __unstableSetTemporarilyEditingAsBlocks: () => (__unstableSetTemporarilyEditingAsBlocks), 7974 __unstableSplitSelection: () => (__unstableSplitSelection), 7975 clearSelectedBlock: () => (clearSelectedBlock), 7976 duplicateBlocks: () => (duplicateBlocks), 7977 enterFormattedText: () => (enterFormattedText), 7978 exitFormattedText: () => (exitFormattedText), 7979 flashBlock: () => (flashBlock), 7980 hideInsertionPoint: () => (hideInsertionPoint), 7981 hoverBlock: () => (hoverBlock), 7982 insertAfterBlock: () => (insertAfterBlock), 7983 insertBeforeBlock: () => (insertBeforeBlock), 7984 insertBlock: () => (insertBlock), 7985 insertBlocks: () => (insertBlocks), 7986 insertDefaultBlock: () => (insertDefaultBlock), 7987 mergeBlocks: () => (mergeBlocks), 7988 moveBlockToPosition: () => (moveBlockToPosition), 7989 moveBlocksDown: () => (moveBlocksDown), 7990 moveBlocksToPosition: () => (moveBlocksToPosition), 7991 moveBlocksUp: () => (moveBlocksUp), 7992 multiSelect: () => (multiSelect), 7993 receiveBlocks: () => (receiveBlocks), 7994 registerInserterMediaCategory: () => (registerInserterMediaCategory), 7995 removeBlock: () => (removeBlock), 7996 removeBlocks: () => (removeBlocks), 7997 replaceBlock: () => (replaceBlock), 7998 replaceBlocks: () => (replaceBlocks), 7999 replaceInnerBlocks: () => (replaceInnerBlocks), 8000 resetBlocks: () => (resetBlocks), 8001 resetSelection: () => (resetSelection), 8002 selectBlock: () => (selectBlock), 8003 selectNextBlock: () => (selectNextBlock), 8004 selectPreviousBlock: () => (selectPreviousBlock), 8005 selectionChange: () => (selectionChange), 8006 setBlockEditingMode: () => (setBlockEditingMode), 8007 setBlockMovingClientId: () => (setBlockMovingClientId), 8008 setBlockVisibility: () => (setBlockVisibility), 8009 setHasControlledInnerBlocks: () => (setHasControlledInnerBlocks), 8010 setNavigationMode: () => (setNavigationMode), 8011 setTemplateValidity: () => (setTemplateValidity), 8012 showInsertionPoint: () => (showInsertionPoint), 8013 startDraggingBlocks: () => (startDraggingBlocks), 8014 startMultiSelect: () => (startMultiSelect), 8015 startTyping: () => (startTyping), 8016 stopDraggingBlocks: () => (stopDraggingBlocks), 8017 stopMultiSelect: () => (stopMultiSelect), 8018 stopTyping: () => (stopTyping), 8019 synchronizeTemplate: () => (synchronizeTemplate), 8020 toggleBlockHighlight: () => (toggleBlockHighlight), 8021 toggleBlockMode: () => (toggleBlockMode), 8022 toggleSelection: () => (toggleSelection), 8023 unsetBlockEditingMode: () => (unsetBlockEditingMode), 8024 updateBlock: () => (updateBlock), 8025 updateBlockAttributes: () => (updateBlockAttributes), 8026 updateBlockListSettings: () => (updateBlockListSettings), 8027 updateSettings: () => (updateSettings), 8028 validateBlocksToTemplate: () => (validateBlocksToTemplate) 8029 }); 8030 8031 // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/components/global-styles/index.js 8032 var global_styles_namespaceObject = {}; 8033 __webpack_require__.r(global_styles_namespaceObject); 8034 __webpack_require__.d(global_styles_namespaceObject, { 8035 AdvancedPanel: () => (AdvancedPanel), 8036 BackgroundPanel: () => (background_panel_BackgroundImagePanel), 8037 BorderPanel: () => (BorderPanel), 8038 ColorPanel: () => (ColorPanel), 8039 DimensionsPanel: () => (DimensionsPanel), 8040 FiltersPanel: () => (FiltersPanel), 8041 GlobalStylesContext: () => (GlobalStylesContext), 8042 ImageSettingsPanel: () => (ImageSettingsPanel), 8043 TypographyPanel: () => (TypographyPanel), 8044 areGlobalStyleConfigsEqual: () => (areGlobalStyleConfigsEqual), 8045 getBlockCSSSelector: () => (getBlockCSSSelector), 8046 getBlockSelectors: () => (getBlockSelectors), 8047 getGlobalStylesChanges: () => (getGlobalStylesChanges), 8048 getLayoutStyles: () => (getLayoutStyles), 8049 toStyles: () => (toStyles), 8050 useGlobalSetting: () => (useGlobalSetting), 8051 useGlobalStyle: () => (useGlobalStyle), 8052 useGlobalStylesOutput: () => (useGlobalStylesOutput), 8053 useGlobalStylesOutputWithConfig: () => (useGlobalStylesOutputWithConfig), 8054 useGlobalStylesReset: () => (useGlobalStylesReset), 8055 useHasBackgroundPanel: () => (useHasBackgroundPanel), 8056 useHasBorderPanel: () => (useHasBorderPanel), 8057 useHasBorderPanelControls: () => (useHasBorderPanelControls), 8058 useHasColorPanel: () => (useHasColorPanel), 8059 useHasDimensionsPanel: () => (useHasDimensionsPanel), 8060 useHasFiltersPanel: () => (useHasFiltersPanel), 8061 useHasImageSettingsPanel: () => (useHasImageSettingsPanel), 8062 useHasTypographyPanel: () => (useHasTypographyPanel), 8063 useSettingsForBlockElement: () => (useSettingsForBlockElement) 8064 }); 8065 8066 ;// external ["wp","blocks"] 8067 const external_wp_blocks_namespaceObject = window["wp"]["blocks"]; 8068 ;// external ["wp","element"] 8069 const external_wp_element_namespaceObject = window["wp"]["element"]; 8070 ;// external ["wp","data"] 8071 const external_wp_data_namespaceObject = window["wp"]["data"]; 8072 ;// external ["wp","compose"] 8073 const external_wp_compose_namespaceObject = window["wp"]["compose"]; 8074 ;// external ["wp","hooks"] 8075 const external_wp_hooks_namespaceObject = window["wp"]["hooks"]; 8076 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit/context.js 8077 /** 8078 * WordPress dependencies 8079 */ 8080 8081 const mayDisplayControlsKey = Symbol('mayDisplayControls'); 8082 const mayDisplayParentControlsKey = Symbol('mayDisplayParentControls'); 8083 const blockEditingModeKey = Symbol('blockEditingMode'); 8084 const blockBindingsKey = Symbol('blockBindings'); 8085 const isPreviewModeKey = Symbol('isPreviewMode'); 8086 const DEFAULT_BLOCK_EDIT_CONTEXT = { 8087 name: '', 8088 isSelected: false 8089 }; 8090 const Context = (0,external_wp_element_namespaceObject.createContext)(DEFAULT_BLOCK_EDIT_CONTEXT); 8091 const { 8092 Provider 8093 } = Context; 8094 8095 8096 /** 8097 * A hook that returns the block edit context. 8098 * 8099 * @return {Object} Block edit context 8100 */ 8101 function useBlockEditContext() { 8102 return (0,external_wp_element_namespaceObject.useContext)(Context); 8103 } 8104 8105 ;// external ["wp","deprecated"] 8106 const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"]; 8107 var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject); 8108 // EXTERNAL MODULE: ./node_modules/fast-deep-equal/es6/index.js 8109 var es6 = __webpack_require__(7734); 8110 var es6_default = /*#__PURE__*/__webpack_require__.n(es6); 8111 ;// external ["wp","i18n"] 8112 const external_wp_i18n_namespaceObject = window["wp"]["i18n"]; 8113 ;// ./node_modules/@wordpress/block-editor/build-module/store/defaults.js 8114 /** 8115 * WordPress dependencies 8116 */ 8117 8118 const PREFERENCES_DEFAULTS = { 8119 insertUsage: {} 8120 }; 8121 8122 /** 8123 * The default editor settings 8124 * 8125 * @typedef {Object} SETTINGS_DEFAULT 8126 * @property {boolean} alignWide Enable/Disable Wide/Full Alignments 8127 * @property {boolean} supportsLayout Enable/disable layouts support in container blocks. 8128 * @property {boolean} imageEditing Image Editing settings set to false to disable. 8129 * @property {Array} imageSizes Available image sizes 8130 * @property {number} maxWidth Max width to constraint resizing 8131 * @property {boolean|Array} allowedBlockTypes Allowed block types 8132 * @property {boolean} hasFixedToolbar Whether or not the editor toolbar is fixed 8133 * @property {boolean} distractionFree Whether or not the editor UI is distraction free 8134 * @property {boolean} focusMode Whether the focus mode is enabled or not 8135 * @property {Array} styles Editor Styles 8136 * @property {boolean} keepCaretInsideBlock Whether caret should move between blocks in edit mode 8137 * @property {string} bodyPlaceholder Empty post placeholder 8138 * @property {string} titlePlaceholder Empty title placeholder 8139 * @property {boolean} canLockBlocks Whether the user can manage Block Lock state 8140 * @property {boolean} codeEditingEnabled Whether or not the user can switch to the code editor 8141 * @property {boolean} generateAnchors Enable/Disable auto anchor generation for Heading blocks 8142 * @property {boolean} enableOpenverseMediaCategory Enable/Disable the Openverse media category in the inserter. 8143 * @property {boolean} clearBlockSelection Whether the block editor should clear selection on mousedown when a block is not clicked. 8144 * @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. 8145 * @property {boolean} __experimentalBlockDirectory Whether the user has enabled the Block Directory 8146 * @property {Array} __experimentalBlockPatterns Array of objects representing the block patterns 8147 * @property {Array} __experimentalBlockPatternCategories Array of objects representing the block pattern categories 8148 */ 8149 const SETTINGS_DEFAULTS = { 8150 alignWide: false, 8151 supportsLayout: true, 8152 // colors setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults. 8153 // The setting is only kept for backward compatibility purposes. 8154 colors: [{ 8155 name: (0,external_wp_i18n_namespaceObject.__)('Black'), 8156 slug: 'black', 8157 color: '#000000' 8158 }, { 8159 name: (0,external_wp_i18n_namespaceObject.__)('Cyan bluish gray'), 8160 slug: 'cyan-bluish-gray', 8161 color: '#abb8c3' 8162 }, { 8163 name: (0,external_wp_i18n_namespaceObject.__)('White'), 8164 slug: 'white', 8165 color: '#ffffff' 8166 }, { 8167 name: (0,external_wp_i18n_namespaceObject.__)('Pale pink'), 8168 slug: 'pale-pink', 8169 color: '#f78da7' 8170 }, { 8171 name: (0,external_wp_i18n_namespaceObject.__)('Vivid red'), 8172 slug: 'vivid-red', 8173 color: '#cf2e2e' 8174 }, { 8175 name: (0,external_wp_i18n_namespaceObject.__)('Luminous vivid orange'), 8176 slug: 'luminous-vivid-orange', 8177 color: '#ff6900' 8178 }, { 8179 name: (0,external_wp_i18n_namespaceObject.__)('Luminous vivid amber'), 8180 slug: 'luminous-vivid-amber', 8181 color: '#fcb900' 8182 }, { 8183 name: (0,external_wp_i18n_namespaceObject.__)('Light green cyan'), 8184 slug: 'light-green-cyan', 8185 color: '#7bdcb5' 8186 }, { 8187 name: (0,external_wp_i18n_namespaceObject.__)('Vivid green cyan'), 8188 slug: 'vivid-green-cyan', 8189 color: '#00d084' 8190 }, { 8191 name: (0,external_wp_i18n_namespaceObject.__)('Pale cyan blue'), 8192 slug: 'pale-cyan-blue', 8193 color: '#8ed1fc' 8194 }, { 8195 name: (0,external_wp_i18n_namespaceObject.__)('Vivid cyan blue'), 8196 slug: 'vivid-cyan-blue', 8197 color: '#0693e3' 8198 }, { 8199 name: (0,external_wp_i18n_namespaceObject.__)('Vivid purple'), 8200 slug: 'vivid-purple', 8201 color: '#9b51e0' 8202 }], 8203 // fontSizes setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults. 8204 // The setting is only kept for backward compatibility purposes. 8205 fontSizes: [{ 8206 name: (0,external_wp_i18n_namespaceObject._x)('Small', 'font size name'), 8207 size: 13, 8208 slug: 'small' 8209 }, { 8210 name: (0,external_wp_i18n_namespaceObject._x)('Normal', 'font size name'), 8211 size: 16, 8212 slug: 'normal' 8213 }, { 8214 name: (0,external_wp_i18n_namespaceObject._x)('Medium', 'font size name'), 8215 size: 20, 8216 slug: 'medium' 8217 }, { 8218 name: (0,external_wp_i18n_namespaceObject._x)('Large', 'font size name'), 8219 size: 36, 8220 slug: 'large' 8221 }, { 8222 name: (0,external_wp_i18n_namespaceObject._x)('Huge', 'font size name'), 8223 size: 42, 8224 slug: 'huge' 8225 }], 8226 // Image default size slug. 8227 imageDefaultSize: 'large', 8228 imageSizes: [{ 8229 slug: 'thumbnail', 8230 name: (0,external_wp_i18n_namespaceObject.__)('Thumbnail') 8231 }, { 8232 slug: 'medium', 8233 name: (0,external_wp_i18n_namespaceObject.__)('Medium') 8234 }, { 8235 slug: 'large', 8236 name: (0,external_wp_i18n_namespaceObject.__)('Large') 8237 }, { 8238 slug: 'full', 8239 name: (0,external_wp_i18n_namespaceObject.__)('Full Size') 8240 }], 8241 // Allow plugin to disable Image Editor if need be. 8242 imageEditing: true, 8243 // This is current max width of the block inner area 8244 // It's used to constraint image resizing and this value could be overridden later by themes 8245 maxWidth: 580, 8246 // Allowed block types for the editor, defaulting to true (all supported). 8247 allowedBlockTypes: true, 8248 // Maximum upload size in bytes allowed for the site. 8249 maxUploadFileSize: 0, 8250 // List of allowed mime types and file extensions. 8251 allowedMimeTypes: null, 8252 // Allows to disable block locking interface. 8253 canLockBlocks: true, 8254 // Allows to disable Openverse media category in the inserter. 8255 enableOpenverseMediaCategory: true, 8256 clearBlockSelection: true, 8257 __experimentalCanUserUseUnfilteredHTML: false, 8258 __experimentalBlockDirectory: false, 8259 __mobileEnablePageTemplates: false, 8260 __experimentalBlockPatterns: [], 8261 __experimentalBlockPatternCategories: [], 8262 __unstableIsPreviewMode: false, 8263 // These settings will be completely revamped in the future. 8264 // The goal is to evolve this into an API which will instruct 8265 // the block inspector to animate transitions between what it 8266 // displays based on the relationship between the selected block 8267 // and its parent, and only enable it if the parent is controlling 8268 // its children blocks. 8269 blockInspectorAnimation: { 8270 animationParent: 'core/navigation', 8271 'core/navigation': { 8272 enterDirection: 'leftToRight' 8273 }, 8274 'core/navigation-submenu': { 8275 enterDirection: 'rightToLeft' 8276 }, 8277 'core/navigation-link': { 8278 enterDirection: 'rightToLeft' 8279 }, 8280 'core/search': { 8281 enterDirection: 'rightToLeft' 8282 }, 8283 'core/social-links': { 8284 enterDirection: 'rightToLeft' 8285 }, 8286 'core/page-list': { 8287 enterDirection: 'rightToLeft' 8288 }, 8289 'core/spacer': { 8290 enterDirection: 'rightToLeft' 8291 }, 8292 'core/home-link': { 8293 enterDirection: 'rightToLeft' 8294 }, 8295 'core/site-title': { 8296 enterDirection: 'rightToLeft' 8297 }, 8298 'core/site-logo': { 8299 enterDirection: 'rightToLeft' 8300 } 8301 }, 8302 generateAnchors: false, 8303 // gradients setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults. 8304 // The setting is only kept for backward compatibility purposes. 8305 gradients: [{ 8306 name: (0,external_wp_i18n_namespaceObject.__)('Vivid cyan blue to vivid purple'), 8307 gradient: 'linear-gradient(135deg,rgba(6,147,227,1) 0%,rgb(155,81,224) 100%)', 8308 slug: 'vivid-cyan-blue-to-vivid-purple' 8309 }, { 8310 name: (0,external_wp_i18n_namespaceObject.__)('Light green cyan to vivid green cyan'), 8311 gradient: 'linear-gradient(135deg,rgb(122,220,180) 0%,rgb(0,208,130) 100%)', 8312 slug: 'light-green-cyan-to-vivid-green-cyan' 8313 }, { 8314 name: (0,external_wp_i18n_namespaceObject.__)('Luminous vivid amber to luminous vivid orange'), 8315 gradient: 'linear-gradient(135deg,rgba(252,185,0,1) 0%,rgba(255,105,0,1) 100%)', 8316 slug: 'luminous-vivid-amber-to-luminous-vivid-orange' 8317 }, { 8318 name: (0,external_wp_i18n_namespaceObject.__)('Luminous vivid orange to vivid red'), 8319 gradient: 'linear-gradient(135deg,rgba(255,105,0,1) 0%,rgb(207,46,46) 100%)', 8320 slug: 'luminous-vivid-orange-to-vivid-red' 8321 }, { 8322 name: (0,external_wp_i18n_namespaceObject.__)('Very light gray to cyan bluish gray'), 8323 gradient: 'linear-gradient(135deg,rgb(238,238,238) 0%,rgb(169,184,195) 100%)', 8324 slug: 'very-light-gray-to-cyan-bluish-gray' 8325 }, { 8326 name: (0,external_wp_i18n_namespaceObject.__)('Cool to warm spectrum'), 8327 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%)', 8328 slug: 'cool-to-warm-spectrum' 8329 }, { 8330 name: (0,external_wp_i18n_namespaceObject.__)('Blush light purple'), 8331 gradient: 'linear-gradient(135deg,rgb(255,206,236) 0%,rgb(152,150,240) 100%)', 8332 slug: 'blush-light-purple' 8333 }, { 8334 name: (0,external_wp_i18n_namespaceObject.__)('Blush bordeaux'), 8335 gradient: 'linear-gradient(135deg,rgb(254,205,165) 0%,rgb(254,45,45) 50%,rgb(107,0,62) 100%)', 8336 slug: 'blush-bordeaux' 8337 }, { 8338 name: (0,external_wp_i18n_namespaceObject.__)('Luminous dusk'), 8339 gradient: 'linear-gradient(135deg,rgb(255,203,112) 0%,rgb(199,81,192) 50%,rgb(65,88,208) 100%)', 8340 slug: 'luminous-dusk' 8341 }, { 8342 name: (0,external_wp_i18n_namespaceObject.__)('Pale ocean'), 8343 gradient: 'linear-gradient(135deg,rgb(255,245,203) 0%,rgb(182,227,212) 50%,rgb(51,167,181) 100%)', 8344 slug: 'pale-ocean' 8345 }, { 8346 name: (0,external_wp_i18n_namespaceObject.__)('Electric grass'), 8347 gradient: 'linear-gradient(135deg,rgb(202,248,128) 0%,rgb(113,206,126) 100%)', 8348 slug: 'electric-grass' 8349 }, { 8350 name: (0,external_wp_i18n_namespaceObject.__)('Midnight'), 8351 gradient: 'linear-gradient(135deg,rgb(2,3,129) 0%,rgb(40,116,252) 100%)', 8352 slug: 'midnight' 8353 }], 8354 __unstableResolvedAssets: { 8355 styles: [], 8356 scripts: [] 8357 } 8358 }; 8359 8360 ;// ./node_modules/@wordpress/block-editor/build-module/store/array.js 8361 /** 8362 * Insert one or multiple elements into a given position of an array. 8363 * 8364 * @param {Array} array Source array. 8365 * @param {*} elements Elements to insert. 8366 * @param {number} index Insert Position. 8367 * 8368 * @return {Array} Result. 8369 */ 8370 function insertAt(array, elements, index) { 8371 return [...array.slice(0, index), ...(Array.isArray(elements) ? elements : [elements]), ...array.slice(index)]; 8372 } 8373 8374 /** 8375 * Moves an element in an array. 8376 * 8377 * @param {Array} array Source array. 8378 * @param {number} from Source index. 8379 * @param {number} to Destination index. 8380 * @param {number} count Number of elements to move. 8381 * 8382 * @return {Array} Result. 8383 */ 8384 function moveTo(array, from, to, count = 1) { 8385 const withoutMovedElements = [...array]; 8386 withoutMovedElements.splice(from, count); 8387 return insertAt(withoutMovedElements, array.slice(from, from + count), to); 8388 } 8389 8390 ;// ./node_modules/@wordpress/block-editor/build-module/store/reducer.js 8391 /** 8392 * External dependencies 8393 */ 8394 8395 8396 /** 8397 * WordPress dependencies 8398 */ 8399 8400 8401 8402 /** 8403 * Internal dependencies 8404 */ 8405 8406 8407 const identity = x => x; 8408 8409 /** 8410 * Given an array of blocks, returns an object where each key is a nesting 8411 * context, the value of which is an array of block client IDs existing within 8412 * that nesting context. 8413 * 8414 * @param {Array} blocks Blocks to map. 8415 * @param {?string} rootClientId Assumed root client ID. 8416 * 8417 * @return {Object} Block order map object. 8418 */ 8419 function mapBlockOrder(blocks, rootClientId = '') { 8420 const result = new Map(); 8421 const current = []; 8422 result.set(rootClientId, current); 8423 blocks.forEach(block => { 8424 const { 8425 clientId, 8426 innerBlocks 8427 } = block; 8428 current.push(clientId); 8429 mapBlockOrder(innerBlocks, clientId).forEach((order, subClientId) => { 8430 result.set(subClientId, order); 8431 }); 8432 }); 8433 return result; 8434 } 8435 8436 /** 8437 * Given an array of blocks, returns an object where each key contains 8438 * the clientId of the block and the value is the parent of the block. 8439 * 8440 * @param {Array} blocks Blocks to map. 8441 * @param {?string} rootClientId Assumed root client ID. 8442 * 8443 * @return {Object} Block order map object. 8444 */ 8445 function mapBlockParents(blocks, rootClientId = '') { 8446 const result = []; 8447 const stack = [[rootClientId, blocks]]; 8448 while (stack.length) { 8449 const [parent, currentBlocks] = stack.shift(); 8450 currentBlocks.forEach(({ 8451 innerBlocks, 8452 ...block 8453 }) => { 8454 result.push([block.clientId, parent]); 8455 if (innerBlocks?.length) { 8456 stack.push([block.clientId, innerBlocks]); 8457 } 8458 }); 8459 } 8460 return result; 8461 } 8462 8463 /** 8464 * Helper method to iterate through all blocks, recursing into inner blocks, 8465 * applying a transformation function to each one. 8466 * Returns a flattened object with the transformed blocks. 8467 * 8468 * @param {Array} blocks Blocks to flatten. 8469 * @param {Function} transform Transforming function to be applied to each block. 8470 * 8471 * @return {Array} Flattened object. 8472 */ 8473 function flattenBlocks(blocks, transform = identity) { 8474 const result = []; 8475 const stack = [...blocks]; 8476 while (stack.length) { 8477 const { 8478 innerBlocks, 8479 ...block 8480 } = stack.shift(); 8481 stack.push(...innerBlocks); 8482 result.push([block.clientId, transform(block)]); 8483 } 8484 return result; 8485 } 8486 function getFlattenedClientIds(blocks) { 8487 const result = {}; 8488 const stack = [...blocks]; 8489 while (stack.length) { 8490 const { 8491 innerBlocks, 8492 ...block 8493 } = stack.shift(); 8494 stack.push(...innerBlocks); 8495 result[block.clientId] = true; 8496 } 8497 return result; 8498 } 8499 8500 /** 8501 * Given an array of blocks, returns an object containing all blocks, without 8502 * attributes, recursing into inner blocks. Keys correspond to the block client 8503 * ID, the value of which is the attributes object. 8504 * 8505 * @param {Array} blocks Blocks to flatten. 8506 * 8507 * @return {Array} Flattened block attributes object. 8508 */ 8509 function getFlattenedBlocksWithoutAttributes(blocks) { 8510 return flattenBlocks(blocks, block => { 8511 const { 8512 attributes, 8513 ...restBlock 8514 } = block; 8515 return restBlock; 8516 }); 8517 } 8518 8519 /** 8520 * Given an array of blocks, returns an object containing all block attributes, 8521 * recursing into inner blocks. Keys correspond to the block client ID, the 8522 * value of which is the attributes object. 8523 * 8524 * @param {Array} blocks Blocks to flatten. 8525 * 8526 * @return {Array} Flattened block attributes object. 8527 */ 8528 function getFlattenedBlockAttributes(blocks) { 8529 return flattenBlocks(blocks, block => block.attributes); 8530 } 8531 8532 /** 8533 * Returns true if the two object arguments have the same keys, or false 8534 * otherwise. 8535 * 8536 * @param {Object} a First object. 8537 * @param {Object} b Second object. 8538 * 8539 * @return {boolean} Whether the two objects have the same keys. 8540 */ 8541 function hasSameKeys(a, b) { 8542 return es6_default()(Object.keys(a), Object.keys(b)); 8543 } 8544 8545 /** 8546 * Returns true if, given the currently dispatching action and the previously 8547 * dispatched action, the two actions are updating the same block attribute, or 8548 * false otherwise. 8549 * 8550 * @param {Object} action Currently dispatching action. 8551 * @param {Object} lastAction Previously dispatched action. 8552 * 8553 * @return {boolean} Whether actions are updating the same block attribute. 8554 */ 8555 function isUpdatingSameBlockAttribute(action, lastAction) { 8556 return action.type === 'UPDATE_BLOCK_ATTRIBUTES' && lastAction !== undefined && lastAction.type === 'UPDATE_BLOCK_ATTRIBUTES' && es6_default()(action.clientIds, lastAction.clientIds) && hasSameKeys(action.attributes, lastAction.attributes); 8557 } 8558 function updateBlockTreeForBlocks(state, blocks) { 8559 const treeToUpdate = state.tree; 8560 const stack = [...blocks]; 8561 const flattenedBlocks = [...blocks]; 8562 while (stack.length) { 8563 const block = stack.shift(); 8564 stack.push(...block.innerBlocks); 8565 flattenedBlocks.push(...block.innerBlocks); 8566 } 8567 // Create objects before mutating them, that way it's always defined. 8568 for (const block of flattenedBlocks) { 8569 treeToUpdate.set(block.clientId, {}); 8570 } 8571 for (const block of flattenedBlocks) { 8572 treeToUpdate.set(block.clientId, Object.assign(treeToUpdate.get(block.clientId), { 8573 ...state.byClientId.get(block.clientId), 8574 attributes: state.attributes.get(block.clientId), 8575 innerBlocks: block.innerBlocks.map(subBlock => treeToUpdate.get(subBlock.clientId)) 8576 })); 8577 } 8578 } 8579 function updateParentInnerBlocksInTree(state, updatedClientIds, updateChildrenOfUpdatedClientIds = false) { 8580 const treeToUpdate = state.tree; 8581 const uncontrolledParents = new Set([]); 8582 const controlledParents = new Set(); 8583 for (const clientId of updatedClientIds) { 8584 let current = updateChildrenOfUpdatedClientIds ? clientId : state.parents.get(clientId); 8585 do { 8586 if (state.controlledInnerBlocks[current]) { 8587 // Should stop on controlled blocks. 8588 // If we reach a controlled parent, break out of the loop. 8589 controlledParents.add(current); 8590 break; 8591 } else { 8592 // Else continue traversing up through parents. 8593 uncontrolledParents.add(current); 8594 current = state.parents.get(current); 8595 } 8596 } while (current !== undefined); 8597 } 8598 8599 // To make sure the order of assignments doesn't matter, 8600 // we first create empty objects and mutates the inner blocks later. 8601 for (const clientId of uncontrolledParents) { 8602 treeToUpdate.set(clientId, { 8603 ...treeToUpdate.get(clientId) 8604 }); 8605 } 8606 for (const clientId of uncontrolledParents) { 8607 treeToUpdate.get(clientId).innerBlocks = (state.order.get(clientId) || []).map(subClientId => treeToUpdate.get(subClientId)); 8608 } 8609 8610 // Controlled parent blocks, need a dedicated key for their inner blocks 8611 // to be used when doing getBlocks( controlledBlockClientId ). 8612 for (const clientId of controlledParents) { 8613 treeToUpdate.set('controlled||' + clientId, { 8614 innerBlocks: (state.order.get(clientId) || []).map(subClientId => treeToUpdate.get(subClientId)) 8615 }); 8616 } 8617 } 8618 8619 /** 8620 * Higher-order reducer intended to compute full block objects key for each block in the post. 8621 * This is a denormalization to optimize the performance of the getBlock selectors and avoid 8622 * recomputing the block objects and avoid heavy memoization. 8623 * 8624 * @param {Function} reducer Original reducer function. 8625 * 8626 * @return {Function} Enhanced reducer function. 8627 */ 8628 const withBlockTree = reducer => (state = {}, action) => { 8629 const newState = reducer(state, action); 8630 if (newState === state) { 8631 return state; 8632 } 8633 newState.tree = state.tree ? state.tree : new Map(); 8634 switch (action.type) { 8635 case 'RECEIVE_BLOCKS': 8636 case 'INSERT_BLOCKS': 8637 { 8638 newState.tree = new Map(newState.tree); 8639 updateBlockTreeForBlocks(newState, action.blocks); 8640 updateParentInnerBlocksInTree(newState, action.rootClientId ? [action.rootClientId] : [''], true); 8641 break; 8642 } 8643 case 'UPDATE_BLOCK': 8644 newState.tree = new Map(newState.tree); 8645 newState.tree.set(action.clientId, { 8646 ...newState.tree.get(action.clientId), 8647 ...newState.byClientId.get(action.clientId), 8648 attributes: newState.attributes.get(action.clientId) 8649 }); 8650 updateParentInnerBlocksInTree(newState, [action.clientId], false); 8651 break; 8652 case 'SYNC_DERIVED_BLOCK_ATTRIBUTES': 8653 case 'UPDATE_BLOCK_ATTRIBUTES': 8654 { 8655 newState.tree = new Map(newState.tree); 8656 action.clientIds.forEach(clientId => { 8657 newState.tree.set(clientId, { 8658 ...newState.tree.get(clientId), 8659 attributes: newState.attributes.get(clientId) 8660 }); 8661 }); 8662 updateParentInnerBlocksInTree(newState, action.clientIds, false); 8663 break; 8664 } 8665 case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': 8666 { 8667 const inserterClientIds = getFlattenedClientIds(action.blocks); 8668 newState.tree = new Map(newState.tree); 8669 action.replacedClientIds.forEach(clientId => { 8670 newState.tree.delete(clientId); 8671 // Controlled inner blocks are only removed 8672 // if the block doesn't move to another position 8673 // otherwise their content will be lost. 8674 if (!inserterClientIds[clientId]) { 8675 newState.tree.delete('controlled||' + clientId); 8676 } 8677 }); 8678 updateBlockTreeForBlocks(newState, action.blocks); 8679 updateParentInnerBlocksInTree(newState, action.blocks.map(b => b.clientId), false); 8680 8681 // If there are no replaced blocks, it means we're removing blocks so we need to update their parent. 8682 const parentsOfRemovedBlocks = []; 8683 for (const clientId of action.clientIds) { 8684 const parentId = state.parents.get(clientId); 8685 if (parentId !== undefined && (parentId === '' || newState.byClientId.get(parentId))) { 8686 parentsOfRemovedBlocks.push(parentId); 8687 } 8688 } 8689 updateParentInnerBlocksInTree(newState, parentsOfRemovedBlocks, true); 8690 break; 8691 } 8692 case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': 8693 const parentsOfRemovedBlocks = []; 8694 for (const clientId of action.clientIds) { 8695 const parentId = state.parents.get(clientId); 8696 if (parentId !== undefined && (parentId === '' || newState.byClientId.get(parentId))) { 8697 parentsOfRemovedBlocks.push(parentId); 8698 } 8699 } 8700 newState.tree = new Map(newState.tree); 8701 action.removedClientIds.forEach(clientId => { 8702 newState.tree.delete(clientId); 8703 newState.tree.delete('controlled||' + clientId); 8704 }); 8705 updateParentInnerBlocksInTree(newState, parentsOfRemovedBlocks, true); 8706 break; 8707 case 'MOVE_BLOCKS_TO_POSITION': 8708 { 8709 const updatedBlockUids = []; 8710 if (action.fromRootClientId) { 8711 updatedBlockUids.push(action.fromRootClientId); 8712 } else { 8713 updatedBlockUids.push(''); 8714 } 8715 if (action.toRootClientId) { 8716 updatedBlockUids.push(action.toRootClientId); 8717 } 8718 newState.tree = new Map(newState.tree); 8719 updateParentInnerBlocksInTree(newState, updatedBlockUids, true); 8720 break; 8721 } 8722 case 'MOVE_BLOCKS_UP': 8723 case 'MOVE_BLOCKS_DOWN': 8724 { 8725 const updatedBlockUids = [action.rootClientId ? action.rootClientId : '']; 8726 newState.tree = new Map(newState.tree); 8727 updateParentInnerBlocksInTree(newState, updatedBlockUids, true); 8728 break; 8729 } 8730 case 'SAVE_REUSABLE_BLOCK_SUCCESS': 8731 { 8732 const updatedBlockUids = []; 8733 newState.attributes.forEach((attributes, clientId) => { 8734 if (newState.byClientId.get(clientId).name === 'core/block' && attributes.ref === action.updatedId) { 8735 updatedBlockUids.push(clientId); 8736 } 8737 }); 8738 newState.tree = new Map(newState.tree); 8739 updatedBlockUids.forEach(clientId => { 8740 newState.tree.set(clientId, { 8741 ...newState.byClientId.get(clientId), 8742 attributes: newState.attributes.get(clientId), 8743 innerBlocks: newState.tree.get(clientId).innerBlocks 8744 }); 8745 }); 8746 updateParentInnerBlocksInTree(newState, updatedBlockUids, false); 8747 } 8748 } 8749 return newState; 8750 }; 8751 8752 /** 8753 * Higher-order reducer intended to augment the blocks reducer, assigning an 8754 * `isPersistentChange` property value corresponding to whether a change in 8755 * state can be considered as persistent. All changes are considered persistent 8756 * except when updating the same block attribute as in the previous action. 8757 * 8758 * @param {Function} reducer Original reducer function. 8759 * 8760 * @return {Function} Enhanced reducer function. 8761 */ 8762 function withPersistentBlockChange(reducer) { 8763 let lastAction; 8764 let markNextChangeAsNotPersistent = false; 8765 let explicitPersistent; 8766 return (state, action) => { 8767 let nextState = reducer(state, action); 8768 let nextIsPersistentChange; 8769 if (action.type === 'SET_EXPLICIT_PERSISTENT') { 8770 var _state$isPersistentCh; 8771 explicitPersistent = action.isPersistentChange; 8772 nextIsPersistentChange = (_state$isPersistentCh = state.isPersistentChange) !== null && _state$isPersistentCh !== void 0 ? _state$isPersistentCh : true; 8773 } 8774 if (explicitPersistent !== undefined) { 8775 nextIsPersistentChange = explicitPersistent; 8776 return nextIsPersistentChange === nextState.isPersistentChange ? nextState : { 8777 ...nextState, 8778 isPersistentChange: nextIsPersistentChange 8779 }; 8780 } 8781 const isExplicitPersistentChange = action.type === 'MARK_LAST_CHANGE_AS_PERSISTENT' || markNextChangeAsNotPersistent; 8782 8783 // Defer to previous state value (or default) unless changing or 8784 // explicitly marking as persistent. 8785 if (state === nextState && !isExplicitPersistentChange) { 8786 var _state$isPersistentCh2; 8787 markNextChangeAsNotPersistent = action.type === 'MARK_NEXT_CHANGE_AS_NOT_PERSISTENT'; 8788 nextIsPersistentChange = (_state$isPersistentCh2 = state?.isPersistentChange) !== null && _state$isPersistentCh2 !== void 0 ? _state$isPersistentCh2 : true; 8789 if (state.isPersistentChange === nextIsPersistentChange) { 8790 return state; 8791 } 8792 return { 8793 ...nextState, 8794 isPersistentChange: nextIsPersistentChange 8795 }; 8796 } 8797 nextState = { 8798 ...nextState, 8799 isPersistentChange: isExplicitPersistentChange ? !markNextChangeAsNotPersistent : !isUpdatingSameBlockAttribute(action, lastAction) 8800 }; 8801 8802 // In comparing against the previous action, consider only those which 8803 // would have qualified as one which would have been ignored or not 8804 // have resulted in a changed state. 8805 lastAction = action; 8806 markNextChangeAsNotPersistent = action.type === 'MARK_NEXT_CHANGE_AS_NOT_PERSISTENT'; 8807 return nextState; 8808 }; 8809 } 8810 8811 /** 8812 * Higher-order reducer intended to augment the blocks reducer, assigning an 8813 * `isIgnoredChange` property value corresponding to whether a change in state 8814 * can be considered as ignored. A change is considered ignored when the result 8815 * of an action not incurred by direct user interaction. 8816 * 8817 * @param {Function} reducer Original reducer function. 8818 * 8819 * @return {Function} Enhanced reducer function. 8820 */ 8821 function withIgnoredBlockChange(reducer) { 8822 /** 8823 * Set of action types for which a blocks state change should be ignored. 8824 * 8825 * @type {Set} 8826 */ 8827 const IGNORED_ACTION_TYPES = new Set(['RECEIVE_BLOCKS']); 8828 return (state, action) => { 8829 const nextState = reducer(state, action); 8830 if (nextState !== state) { 8831 nextState.isIgnoredChange = IGNORED_ACTION_TYPES.has(action.type); 8832 } 8833 return nextState; 8834 }; 8835 } 8836 8837 /** 8838 * Higher-order reducer targeting the combined blocks reducer, augmenting 8839 * block client IDs in remove action to include cascade of inner blocks. 8840 * 8841 * @param {Function} reducer Original reducer function. 8842 * 8843 * @return {Function} Enhanced reducer function. 8844 */ 8845 const withInnerBlocksRemoveCascade = reducer => (state, action) => { 8846 // Gets all children which need to be removed. 8847 const getAllChildren = clientIds => { 8848 let result = clientIds; 8849 for (let i = 0; i < result.length; i++) { 8850 if (!state.order.get(result[i]) || action.keepControlledInnerBlocks && action.keepControlledInnerBlocks[result[i]]) { 8851 continue; 8852 } 8853 if (result === clientIds) { 8854 result = [...result]; 8855 } 8856 result.push(...state.order.get(result[i])); 8857 } 8858 return result; 8859 }; 8860 if (state) { 8861 switch (action.type) { 8862 case 'REMOVE_BLOCKS': 8863 action = { 8864 ...action, 8865 type: 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN', 8866 removedClientIds: getAllChildren(action.clientIds) 8867 }; 8868 break; 8869 case 'REPLACE_BLOCKS': 8870 action = { 8871 ...action, 8872 type: 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN', 8873 replacedClientIds: getAllChildren(action.clientIds) 8874 }; 8875 break; 8876 } 8877 } 8878 return reducer(state, action); 8879 }; 8880 8881 /** 8882 * Higher-order reducer which targets the combined blocks reducer and handles 8883 * the `RESET_BLOCKS` action. When dispatched, this action will replace all 8884 * blocks that exist in the post, leaving blocks that exist only in state (e.g. 8885 * reusable blocks and blocks controlled by inner blocks controllers) alone. 8886 * 8887 * @param {Function} reducer Original reducer function. 8888 * 8889 * @return {Function} Enhanced reducer function. 8890 */ 8891 const withBlockReset = reducer => (state, action) => { 8892 if (action.type === 'RESET_BLOCKS') { 8893 const newState = { 8894 ...state, 8895 byClientId: new Map(getFlattenedBlocksWithoutAttributes(action.blocks)), 8896 attributes: new Map(getFlattenedBlockAttributes(action.blocks)), 8897 order: mapBlockOrder(action.blocks), 8898 parents: new Map(mapBlockParents(action.blocks)), 8899 controlledInnerBlocks: {} 8900 }; 8901 newState.tree = new Map(state?.tree); 8902 updateBlockTreeForBlocks(newState, action.blocks); 8903 newState.tree.set('', { 8904 innerBlocks: action.blocks.map(subBlock => newState.tree.get(subBlock.clientId)) 8905 }); 8906 return newState; 8907 } 8908 return reducer(state, action); 8909 }; 8910 8911 /** 8912 * Higher-order reducer which targets the combined blocks reducer and handles 8913 * the `REPLACE_INNER_BLOCKS` action. When dispatched, this action the state 8914 * should become equivalent to the execution of a `REMOVE_BLOCKS` action 8915 * containing all the child's of the root block followed by the execution of 8916 * `INSERT_BLOCKS` with the new blocks. 8917 * 8918 * @param {Function} reducer Original reducer function. 8919 * 8920 * @return {Function} Enhanced reducer function. 8921 */ 8922 const withReplaceInnerBlocks = reducer => (state, action) => { 8923 if (action.type !== 'REPLACE_INNER_BLOCKS') { 8924 return reducer(state, action); 8925 } 8926 8927 // Finds every nested inner block controller. We must check the action blocks 8928 // and not just the block parent state because some inner block controllers 8929 // should be deleted if specified, whereas others should not be deleted. If 8930 // a controlled should not be deleted, then we need to avoid deleting its 8931 // inner blocks from the block state because its inner blocks will not be 8932 // attached to the block in the action. 8933 const nestedControllers = {}; 8934 if (Object.keys(state.controlledInnerBlocks).length) { 8935 const stack = [...action.blocks]; 8936 while (stack.length) { 8937 const { 8938 innerBlocks, 8939 ...block 8940 } = stack.shift(); 8941 stack.push(...innerBlocks); 8942 if (!!state.controlledInnerBlocks[block.clientId]) { 8943 nestedControllers[block.clientId] = true; 8944 } 8945 } 8946 } 8947 8948 // The `keepControlledInnerBlocks` prop will keep the inner blocks of the 8949 // marked block in the block state so that they can be reattached to the 8950 // marked block when we re-insert everything a few lines below. 8951 let stateAfterBlocksRemoval = state; 8952 if (state.order.get(action.rootClientId)) { 8953 stateAfterBlocksRemoval = reducer(stateAfterBlocksRemoval, { 8954 type: 'REMOVE_BLOCKS', 8955 keepControlledInnerBlocks: nestedControllers, 8956 clientIds: state.order.get(action.rootClientId) 8957 }); 8958 } 8959 let stateAfterInsert = stateAfterBlocksRemoval; 8960 if (action.blocks.length) { 8961 stateAfterInsert = reducer(stateAfterInsert, { 8962 ...action, 8963 type: 'INSERT_BLOCKS', 8964 index: 0 8965 }); 8966 8967 // We need to re-attach the controlled inner blocks to the blocks tree and 8968 // preserve their block order. Otherwise, an inner block controller's blocks 8969 // will be deleted entirely from its entity. 8970 const stateAfterInsertOrder = new Map(stateAfterInsert.order); 8971 Object.keys(nestedControllers).forEach(key => { 8972 if (state.order.get(key)) { 8973 stateAfterInsertOrder.set(key, state.order.get(key)); 8974 } 8975 }); 8976 stateAfterInsert.order = stateAfterInsertOrder; 8977 stateAfterInsert.tree = new Map(stateAfterInsert.tree); 8978 Object.keys(nestedControllers).forEach(_key => { 8979 const key = `controlled||$_key}`; 8980 if (state.tree.has(key)) { 8981 stateAfterInsert.tree.set(key, state.tree.get(key)); 8982 } 8983 }); 8984 } 8985 return stateAfterInsert; 8986 }; 8987 8988 /** 8989 * Higher-order reducer which targets the combined blocks reducer and handles 8990 * the `SAVE_REUSABLE_BLOCK_SUCCESS` action. This action can't be handled by 8991 * regular reducers and needs a higher-order reducer since it needs access to 8992 * both `byClientId` and `attributes` simultaneously. 8993 * 8994 * @param {Function} reducer Original reducer function. 8995 * 8996 * @return {Function} Enhanced reducer function. 8997 */ 8998 const withSaveReusableBlock = reducer => (state, action) => { 8999 if (state && action.type === 'SAVE_REUSABLE_BLOCK_SUCCESS') { 9000 const { 9001 id, 9002 updatedId 9003 } = action; 9004 9005 // If a temporary reusable block is saved, we swap the temporary id with the final one. 9006 if (id === updatedId) { 9007 return state; 9008 } 9009 state = { 9010 ...state 9011 }; 9012 state.attributes = new Map(state.attributes); 9013 state.attributes.forEach((attributes, clientId) => { 9014 const { 9015 name 9016 } = state.byClientId.get(clientId); 9017 if (name === 'core/block' && attributes.ref === id) { 9018 state.attributes.set(clientId, { 9019 ...attributes, 9020 ref: updatedId 9021 }); 9022 } 9023 }); 9024 } 9025 return reducer(state, action); 9026 }; 9027 /** 9028 * Higher-order reducer which removes blocks from state when switching parent block controlled state. 9029 * 9030 * @param {Function} reducer Original reducer function. 9031 * 9032 * @return {Function} Enhanced reducer function. 9033 */ 9034 const withResetControlledBlocks = reducer => (state, action) => { 9035 if (action.type === 'SET_HAS_CONTROLLED_INNER_BLOCKS') { 9036 // when switching a block from controlled to uncontrolled or inverse, 9037 // we need to remove its content first. 9038 const tempState = reducer(state, { 9039 type: 'REPLACE_INNER_BLOCKS', 9040 rootClientId: action.clientId, 9041 blocks: [] 9042 }); 9043 return reducer(tempState, action); 9044 } 9045 return reducer(state, action); 9046 }; 9047 9048 /** 9049 * Reducer returning the blocks state. 9050 * 9051 * @param {Object} state Current state. 9052 * @param {Object} action Dispatched action. 9053 * 9054 * @return {Object} Updated state. 9055 */ 9056 const blocks = (0,external_wp_compose_namespaceObject.pipe)(external_wp_data_namespaceObject.combineReducers, withSaveReusableBlock, 9057 // Needs to be before withBlockCache. 9058 withBlockTree, 9059 // Needs to be before withInnerBlocksRemoveCascade. 9060 withInnerBlocksRemoveCascade, withReplaceInnerBlocks, 9061 // Needs to be after withInnerBlocksRemoveCascade. 9062 withBlockReset, withPersistentBlockChange, withIgnoredBlockChange, withResetControlledBlocks)({ 9063 // The state is using a Map instead of a plain object for performance reasons. 9064 // You can run the "./test/performance.js" unit test to check the impact 9065 // code changes can have on this reducer. 9066 byClientId(state = new Map(), action) { 9067 switch (action.type) { 9068 case 'RECEIVE_BLOCKS': 9069 case 'INSERT_BLOCKS': 9070 { 9071 const newState = new Map(state); 9072 getFlattenedBlocksWithoutAttributes(action.blocks).forEach(([key, value]) => { 9073 newState.set(key, value); 9074 }); 9075 return newState; 9076 } 9077 case 'UPDATE_BLOCK': 9078 { 9079 // Ignore updates if block isn't known. 9080 if (!state.has(action.clientId)) { 9081 return state; 9082 } 9083 9084 // Do nothing if only attributes change. 9085 const { 9086 attributes, 9087 ...changes 9088 } = action.updates; 9089 if (Object.values(changes).length === 0) { 9090 return state; 9091 } 9092 const newState = new Map(state); 9093 newState.set(action.clientId, { 9094 ...state.get(action.clientId), 9095 ...changes 9096 }); 9097 return newState; 9098 } 9099 case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9100 { 9101 if (!action.blocks) { 9102 return state; 9103 } 9104 const newState = new Map(state); 9105 action.replacedClientIds.forEach(clientId => { 9106 newState.delete(clientId); 9107 }); 9108 getFlattenedBlocksWithoutAttributes(action.blocks).forEach(([key, value]) => { 9109 newState.set(key, value); 9110 }); 9111 return newState; 9112 } 9113 case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9114 { 9115 const newState = new Map(state); 9116 action.removedClientIds.forEach(clientId => { 9117 newState.delete(clientId); 9118 }); 9119 return newState; 9120 } 9121 } 9122 return state; 9123 }, 9124 // The state is using a Map instead of a plain object for performance reasons. 9125 // You can run the "./test/performance.js" unit test to check the impact 9126 // code changes can have on this reducer. 9127 attributes(state = new Map(), action) { 9128 switch (action.type) { 9129 case 'RECEIVE_BLOCKS': 9130 case 'INSERT_BLOCKS': 9131 { 9132 const newState = new Map(state); 9133 getFlattenedBlockAttributes(action.blocks).forEach(([key, value]) => { 9134 newState.set(key, value); 9135 }); 9136 return newState; 9137 } 9138 case 'UPDATE_BLOCK': 9139 { 9140 // Ignore updates if block isn't known or there are no attribute changes. 9141 if (!state.get(action.clientId) || !action.updates.attributes) { 9142 return state; 9143 } 9144 const newState = new Map(state); 9145 newState.set(action.clientId, { 9146 ...state.get(action.clientId), 9147 ...action.updates.attributes 9148 }); 9149 return newState; 9150 } 9151 case 'SYNC_DERIVED_BLOCK_ATTRIBUTES': 9152 case 'UPDATE_BLOCK_ATTRIBUTES': 9153 { 9154 // Avoid a state change if none of the block IDs are known. 9155 if (action.clientIds.every(id => !state.get(id))) { 9156 return state; 9157 } 9158 let hasChange = false; 9159 const newState = new Map(state); 9160 for (const clientId of action.clientIds) { 9161 var _action$attributes; 9162 const updatedAttributeEntries = Object.entries(action.uniqueByBlock ? action.attributes[clientId] : (_action$attributes = action.attributes) !== null && _action$attributes !== void 0 ? _action$attributes : {}); 9163 if (updatedAttributeEntries.length === 0) { 9164 continue; 9165 } 9166 let hasUpdatedAttributes = false; 9167 const existingAttributes = state.get(clientId); 9168 const newAttributes = {}; 9169 updatedAttributeEntries.forEach(([key, value]) => { 9170 if (existingAttributes[key] !== value) { 9171 hasUpdatedAttributes = true; 9172 newAttributes[key] = value; 9173 } 9174 }); 9175 hasChange = hasChange || hasUpdatedAttributes; 9176 if (hasUpdatedAttributes) { 9177 newState.set(clientId, { 9178 ...existingAttributes, 9179 ...newAttributes 9180 }); 9181 } 9182 } 9183 return hasChange ? newState : state; 9184 } 9185 case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9186 { 9187 if (!action.blocks) { 9188 return state; 9189 } 9190 const newState = new Map(state); 9191 action.replacedClientIds.forEach(clientId => { 9192 newState.delete(clientId); 9193 }); 9194 getFlattenedBlockAttributes(action.blocks).forEach(([key, value]) => { 9195 newState.set(key, value); 9196 }); 9197 return newState; 9198 } 9199 case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9200 { 9201 const newState = new Map(state); 9202 action.removedClientIds.forEach(clientId => { 9203 newState.delete(clientId); 9204 }); 9205 return newState; 9206 } 9207 } 9208 return state; 9209 }, 9210 // The state is using a Map instead of a plain object for performance reasons. 9211 // You can run the "./test/performance.js" unit test to check the impact 9212 // code changes can have on this reducer. 9213 order(state = new Map(), action) { 9214 switch (action.type) { 9215 case 'RECEIVE_BLOCKS': 9216 { 9217 var _state$get; 9218 const blockOrder = mapBlockOrder(action.blocks); 9219 const newState = new Map(state); 9220 blockOrder.forEach((order, clientId) => { 9221 if (clientId !== '') { 9222 newState.set(clientId, order); 9223 } 9224 }); 9225 newState.set('', ((_state$get = state.get('')) !== null && _state$get !== void 0 ? _state$get : []).concat(blockOrder[''])); 9226 return newState; 9227 } 9228 case 'INSERT_BLOCKS': 9229 { 9230 const { 9231 rootClientId = '' 9232 } = action; 9233 const subState = state.get(rootClientId) || []; 9234 const mappedBlocks = mapBlockOrder(action.blocks, rootClientId); 9235 const { 9236 index = subState.length 9237 } = action; 9238 const newState = new Map(state); 9239 mappedBlocks.forEach((order, clientId) => { 9240 newState.set(clientId, order); 9241 }); 9242 newState.set(rootClientId, insertAt(subState, mappedBlocks.get(rootClientId), index)); 9243 return newState; 9244 } 9245 case 'MOVE_BLOCKS_TO_POSITION': 9246 { 9247 var _state$get$filter; 9248 const { 9249 fromRootClientId = '', 9250 toRootClientId = '', 9251 clientIds 9252 } = action; 9253 const { 9254 index = state.get(toRootClientId).length 9255 } = action; 9256 9257 // Moving inside the same parent block. 9258 if (fromRootClientId === toRootClientId) { 9259 const subState = state.get(toRootClientId); 9260 const fromIndex = subState.indexOf(clientIds[0]); 9261 const newState = new Map(state); 9262 newState.set(toRootClientId, moveTo(state.get(toRootClientId), fromIndex, index, clientIds.length)); 9263 return newState; 9264 } 9265 9266 // Moving from a parent block to another. 9267 const newState = new Map(state); 9268 newState.set(fromRootClientId, (_state$get$filter = state.get(fromRootClientId)?.filter(id => !clientIds.includes(id))) !== null && _state$get$filter !== void 0 ? _state$get$filter : []); 9269 newState.set(toRootClientId, insertAt(state.get(toRootClientId), clientIds, index)); 9270 return newState; 9271 } 9272 case 'MOVE_BLOCKS_UP': 9273 { 9274 const { 9275 clientIds, 9276 rootClientId = '' 9277 } = action; 9278 const firstClientId = clientIds[0]; 9279 const subState = state.get(rootClientId); 9280 if (!subState.length || firstClientId === subState[0]) { 9281 return state; 9282 } 9283 const firstIndex = subState.indexOf(firstClientId); 9284 const newState = new Map(state); 9285 newState.set(rootClientId, moveTo(subState, firstIndex, firstIndex - 1, clientIds.length)); 9286 return newState; 9287 } 9288 case 'MOVE_BLOCKS_DOWN': 9289 { 9290 const { 9291 clientIds, 9292 rootClientId = '' 9293 } = action; 9294 const firstClientId = clientIds[0]; 9295 const lastClientId = clientIds[clientIds.length - 1]; 9296 const subState = state.get(rootClientId); 9297 if (!subState.length || lastClientId === subState[subState.length - 1]) { 9298 return state; 9299 } 9300 const firstIndex = subState.indexOf(firstClientId); 9301 const newState = new Map(state); 9302 newState.set(rootClientId, moveTo(subState, firstIndex, firstIndex + 1, clientIds.length)); 9303 return newState; 9304 } 9305 case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9306 { 9307 const { 9308 clientIds 9309 } = action; 9310 if (!action.blocks) { 9311 return state; 9312 } 9313 const mappedBlocks = mapBlockOrder(action.blocks); 9314 const newState = new Map(state); 9315 action.replacedClientIds.forEach(clientId => { 9316 newState.delete(clientId); 9317 }); 9318 mappedBlocks.forEach((order, clientId) => { 9319 if (clientId !== '') { 9320 newState.set(clientId, order); 9321 } 9322 }); 9323 newState.forEach((order, clientId) => { 9324 const newSubOrder = Object.values(order).reduce((result, subClientId) => { 9325 if (subClientId === clientIds[0]) { 9326 return [...result, ...mappedBlocks.get('')]; 9327 } 9328 if (clientIds.indexOf(subClientId) === -1) { 9329 result.push(subClientId); 9330 } 9331 return result; 9332 }, []); 9333 newState.set(clientId, newSubOrder); 9334 }); 9335 return newState; 9336 } 9337 case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9338 { 9339 const newState = new Map(state); 9340 // Remove inner block ordering for removed blocks. 9341 action.removedClientIds.forEach(clientId => { 9342 newState.delete(clientId); 9343 }); 9344 newState.forEach((order, clientId) => { 9345 var _order$filter; 9346 const newSubOrder = (_order$filter = order?.filter(id => !action.removedClientIds.includes(id))) !== null && _order$filter !== void 0 ? _order$filter : []; 9347 if (newSubOrder.length !== order.length) { 9348 newState.set(clientId, newSubOrder); 9349 } 9350 }); 9351 return newState; 9352 } 9353 } 9354 return state; 9355 }, 9356 // While technically redundant data as the inverse of `order`, it serves as 9357 // an optimization for the selectors which derive the ancestry of a block. 9358 parents(state = new Map(), action) { 9359 switch (action.type) { 9360 case 'RECEIVE_BLOCKS': 9361 { 9362 const newState = new Map(state); 9363 mapBlockParents(action.blocks).forEach(([key, value]) => { 9364 newState.set(key, value); 9365 }); 9366 return newState; 9367 } 9368 case 'INSERT_BLOCKS': 9369 { 9370 const newState = new Map(state); 9371 mapBlockParents(action.blocks, action.rootClientId || '').forEach(([key, value]) => { 9372 newState.set(key, value); 9373 }); 9374 return newState; 9375 } 9376 case 'MOVE_BLOCKS_TO_POSITION': 9377 { 9378 const newState = new Map(state); 9379 action.clientIds.forEach(id => { 9380 newState.set(id, action.toRootClientId || ''); 9381 }); 9382 return newState; 9383 } 9384 case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9385 { 9386 const newState = new Map(state); 9387 action.replacedClientIds.forEach(clientId => { 9388 newState.delete(clientId); 9389 }); 9390 mapBlockParents(action.blocks, state.get(action.clientIds[0])).forEach(([key, value]) => { 9391 newState.set(key, value); 9392 }); 9393 return newState; 9394 } 9395 case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9396 { 9397 const newState = new Map(state); 9398 action.removedClientIds.forEach(clientId => { 9399 newState.delete(clientId); 9400 }); 9401 return newState; 9402 } 9403 } 9404 return state; 9405 }, 9406 controlledInnerBlocks(state = {}, { 9407 type, 9408 clientId, 9409 hasControlledInnerBlocks 9410 }) { 9411 if (type === 'SET_HAS_CONTROLLED_INNER_BLOCKS') { 9412 return { 9413 ...state, 9414 [clientId]: hasControlledInnerBlocks 9415 }; 9416 } 9417 return state; 9418 } 9419 }); 9420 9421 /** 9422 * Reducer returning visibility status of block interface. 9423 * 9424 * @param {boolean} state Current state. 9425 * @param {Object} action Dispatched action. 9426 * 9427 * @return {boolean} Updated state. 9428 */ 9429 function isBlockInterfaceHidden(state = false, action) { 9430 switch (action.type) { 9431 case 'HIDE_BLOCK_INTERFACE': 9432 return true; 9433 case 'SHOW_BLOCK_INTERFACE': 9434 return false; 9435 } 9436 return state; 9437 } 9438 9439 /** 9440 * Reducer returning typing state. 9441 * 9442 * @param {boolean} state Current state. 9443 * @param {Object} action Dispatched action. 9444 * 9445 * @return {boolean} Updated state. 9446 */ 9447 function isTyping(state = false, action) { 9448 switch (action.type) { 9449 case 'START_TYPING': 9450 return true; 9451 case 'STOP_TYPING': 9452 return false; 9453 } 9454 return state; 9455 } 9456 9457 /** 9458 * Reducer returning dragging state. It is possible for a user to be dragging 9459 * data from outside of the editor, so this state is separate from `draggedBlocks`. 9460 * 9461 * @param {boolean} state Current state. 9462 * @param {Object} action Dispatched action. 9463 * 9464 * @return {boolean} Updated state. 9465 */ 9466 function isDragging(state = false, action) { 9467 switch (action.type) { 9468 case 'START_DRAGGING': 9469 return true; 9470 case 'STOP_DRAGGING': 9471 return false; 9472 } 9473 return state; 9474 } 9475 9476 /** 9477 * Reducer returning dragged block client id. 9478 * 9479 * @param {string[]} state Current state. 9480 * @param {Object} action Dispatched action. 9481 * 9482 * @return {string[]} Updated state. 9483 */ 9484 function draggedBlocks(state = [], action) { 9485 switch (action.type) { 9486 case 'START_DRAGGING_BLOCKS': 9487 return action.clientIds; 9488 case 'STOP_DRAGGING_BLOCKS': 9489 return []; 9490 } 9491 return state; 9492 } 9493 9494 /** 9495 * Reducer tracking the visible blocks. 9496 * 9497 * @param {Record<string,boolean>} state Current state. 9498 * @param {Object} action Dispatched action. 9499 * 9500 * @return {Record<string,boolean>} Block visibility. 9501 */ 9502 function blockVisibility(state = {}, action) { 9503 if (action.type === 'SET_BLOCK_VISIBILITY') { 9504 return { 9505 ...state, 9506 ...action.updates 9507 }; 9508 } 9509 return state; 9510 } 9511 9512 /** 9513 * Internal helper reducer for selectionStart and selectionEnd. Can hold a block 9514 * selection, represented by an object with property clientId. 9515 * 9516 * @param {Object} state Current state. 9517 * @param {Object} action Dispatched action. 9518 * 9519 * @return {Object} Updated state. 9520 */ 9521 function selectionHelper(state = {}, action) { 9522 switch (action.type) { 9523 case 'CLEAR_SELECTED_BLOCK': 9524 { 9525 if (state.clientId) { 9526 return {}; 9527 } 9528 return state; 9529 } 9530 case 'SELECT_BLOCK': 9531 if (action.clientId === state.clientId) { 9532 return state; 9533 } 9534 return { 9535 clientId: action.clientId 9536 }; 9537 case 'REPLACE_INNER_BLOCKS': 9538 case 'INSERT_BLOCKS': 9539 { 9540 if (!action.updateSelection || !action.blocks.length) { 9541 return state; 9542 } 9543 return { 9544 clientId: action.blocks[0].clientId 9545 }; 9546 } 9547 case 'REMOVE_BLOCKS': 9548 if (!action.clientIds || !action.clientIds.length || action.clientIds.indexOf(state.clientId) === -1) { 9549 return state; 9550 } 9551 return {}; 9552 case 'REPLACE_BLOCKS': 9553 { 9554 if (action.clientIds.indexOf(state.clientId) === -1) { 9555 return state; 9556 } 9557 const blockToSelect = action.blocks[action.indexToSelect] || action.blocks[action.blocks.length - 1]; 9558 if (!blockToSelect) { 9559 return {}; 9560 } 9561 if (blockToSelect.clientId === state.clientId) { 9562 return state; 9563 } 9564 return { 9565 clientId: blockToSelect.clientId 9566 }; 9567 } 9568 } 9569 return state; 9570 } 9571 9572 /** 9573 * Reducer returning the selection state. 9574 * 9575 * @param {boolean} state Current state. 9576 * @param {Object} action Dispatched action. 9577 * 9578 * @return {boolean} Updated state. 9579 */ 9580 function selection(state = {}, action) { 9581 switch (action.type) { 9582 case 'SELECTION_CHANGE': 9583 if (action.clientId) { 9584 return { 9585 selectionStart: { 9586 clientId: action.clientId, 9587 attributeKey: action.attributeKey, 9588 offset: action.startOffset 9589 }, 9590 selectionEnd: { 9591 clientId: action.clientId, 9592 attributeKey: action.attributeKey, 9593 offset: action.endOffset 9594 } 9595 }; 9596 } 9597 return { 9598 selectionStart: action.start || state.selectionStart, 9599 selectionEnd: action.end || state.selectionEnd 9600 }; 9601 case 'RESET_SELECTION': 9602 const { 9603 selectionStart, 9604 selectionEnd 9605 } = action; 9606 return { 9607 selectionStart, 9608 selectionEnd 9609 }; 9610 case 'MULTI_SELECT': 9611 const { 9612 start, 9613 end 9614 } = action; 9615 if (start === state.selectionStart?.clientId && end === state.selectionEnd?.clientId) { 9616 return state; 9617 } 9618 return { 9619 selectionStart: { 9620 clientId: start 9621 }, 9622 selectionEnd: { 9623 clientId: end 9624 } 9625 }; 9626 case 'RESET_BLOCKS': 9627 const startClientId = state?.selectionStart?.clientId; 9628 const endClientId = state?.selectionEnd?.clientId; 9629 9630 // Do nothing if there's no selected block. 9631 if (!startClientId && !endClientId) { 9632 return state; 9633 } 9634 9635 // If the start of the selection won't exist after reset, remove selection. 9636 if (!action.blocks.some(block => block.clientId === startClientId)) { 9637 return { 9638 selectionStart: {}, 9639 selectionEnd: {} 9640 }; 9641 } 9642 9643 // If the end of the selection won't exist after reset, collapse selection. 9644 if (!action.blocks.some(block => block.clientId === endClientId)) { 9645 return { 9646 ...state, 9647 selectionEnd: state.selectionStart 9648 }; 9649 } 9650 } 9651 const selectionStart = selectionHelper(state.selectionStart, action); 9652 const selectionEnd = selectionHelper(state.selectionEnd, action); 9653 if (selectionStart === state.selectionStart && selectionEnd === state.selectionEnd) { 9654 return state; 9655 } 9656 return { 9657 selectionStart, 9658 selectionEnd 9659 }; 9660 } 9661 9662 /** 9663 * Reducer returning whether the user is multi-selecting. 9664 * 9665 * @param {boolean} state Current state. 9666 * @param {Object} action Dispatched action. 9667 * 9668 * @return {boolean} Updated state. 9669 */ 9670 function isMultiSelecting(state = false, action) { 9671 switch (action.type) { 9672 case 'START_MULTI_SELECT': 9673 return true; 9674 case 'STOP_MULTI_SELECT': 9675 return false; 9676 } 9677 return state; 9678 } 9679 9680 /** 9681 * Reducer returning whether selection is enabled. 9682 * 9683 * @param {boolean} state Current state. 9684 * @param {Object} action Dispatched action. 9685 * 9686 * @return {boolean} Updated state. 9687 */ 9688 function isSelectionEnabled(state = true, action) { 9689 switch (action.type) { 9690 case 'TOGGLE_SELECTION': 9691 return action.isSelectionEnabled; 9692 } 9693 return state; 9694 } 9695 9696 /** 9697 * Reducer returning the data needed to display a prompt when certain blocks 9698 * are removed, or `false` if no such prompt is requested. 9699 * 9700 * @param {boolean} state Current state. 9701 * @param {Object} action Dispatched action. 9702 * 9703 * @return {Object|false} Data for removal prompt display, if any. 9704 */ 9705 function removalPromptData(state = false, action) { 9706 switch (action.type) { 9707 case 'DISPLAY_BLOCK_REMOVAL_PROMPT': 9708 const { 9709 clientIds, 9710 selectPrevious, 9711 message 9712 } = action; 9713 return { 9714 clientIds, 9715 selectPrevious, 9716 message 9717 }; 9718 case 'CLEAR_BLOCK_REMOVAL_PROMPT': 9719 return false; 9720 } 9721 return state; 9722 } 9723 9724 /** 9725 * Reducer returning any rules that a block editor may provide in order to 9726 * prevent a user from accidentally removing certain blocks. These rules are 9727 * then used to display a confirmation prompt to the user. For instance, in the 9728 * Site Editor, the Query Loop block is important enough to warrant such 9729 * confirmation. 9730 * 9731 * The data is a record whose keys are block types (e.g. 'core/query') and 9732 * whose values are the explanation to be shown to users (e.g. 'Query Loop 9733 * displays a list of posts or pages.'). 9734 * 9735 * @param {boolean} state Current state. 9736 * @param {Object} action Dispatched action. 9737 * 9738 * @return {Record<string,string>} Updated state. 9739 */ 9740 function blockRemovalRules(state = false, action) { 9741 switch (action.type) { 9742 case 'SET_BLOCK_REMOVAL_RULES': 9743 return action.rules; 9744 } 9745 return state; 9746 } 9747 9748 /** 9749 * Reducer returning the initial block selection. 9750 * 9751 * Currently this in only used to restore the selection after block deletion and 9752 * pasting new content.This reducer should eventually be removed in favour of setting 9753 * selection directly. 9754 * 9755 * @param {boolean} state Current state. 9756 * @param {Object} action Dispatched action. 9757 * 9758 * @return {number|null} Initial position: 0, -1 or null. 9759 */ 9760 function initialPosition(state = null, action) { 9761 if (action.type === 'REPLACE_BLOCKS' && action.initialPosition !== undefined) { 9762 return action.initialPosition; 9763 } else if (['MULTI_SELECT', 'SELECT_BLOCK', 'RESET_SELECTION', 'INSERT_BLOCKS', 'REPLACE_INNER_BLOCKS'].includes(action.type)) { 9764 return action.initialPosition; 9765 } 9766 return state; 9767 } 9768 function blocksMode(state = {}, action) { 9769 if (action.type === 'TOGGLE_BLOCK_MODE') { 9770 const { 9771 clientId 9772 } = action; 9773 return { 9774 ...state, 9775 [clientId]: state[clientId] && state[clientId] === 'html' ? 'visual' : 'html' 9776 }; 9777 } 9778 return state; 9779 } 9780 9781 /** 9782 * Reducer returning the block insertion point visibility, either null if there 9783 * is not an explicit insertion point assigned, or an object of its `index` and 9784 * `rootClientId`. 9785 * 9786 * @param {Object} state Current state. 9787 * @param {Object} action Dispatched action. 9788 * 9789 * @return {Object} Updated state. 9790 */ 9791 function insertionPoint(state = null, action) { 9792 switch (action.type) { 9793 case 'SHOW_INSERTION_POINT': 9794 { 9795 const { 9796 rootClientId, 9797 index, 9798 __unstableWithInserter, 9799 operation, 9800 nearestSide 9801 } = action; 9802 const nextState = { 9803 rootClientId, 9804 index, 9805 __unstableWithInserter, 9806 operation, 9807 nearestSide 9808 }; 9809 9810 // Bail out updates if the states are the same. 9811 return es6_default()(state, nextState) ? state : nextState; 9812 } 9813 case 'HIDE_INSERTION_POINT': 9814 return null; 9815 } 9816 return state; 9817 } 9818 9819 /** 9820 * Reducer returning whether the post blocks match the defined template or not. 9821 * 9822 * @param {Object} state Current state. 9823 * @param {Object} action Dispatched action. 9824 * 9825 * @return {boolean} Updated state. 9826 */ 9827 function template(state = { 9828 isValid: true 9829 }, action) { 9830 switch (action.type) { 9831 case 'SET_TEMPLATE_VALIDITY': 9832 return { 9833 ...state, 9834 isValid: action.isValid 9835 }; 9836 } 9837 return state; 9838 } 9839 9840 /** 9841 * Reducer returning the editor setting. 9842 * 9843 * @param {Object} state Current state. 9844 * @param {Object} action Dispatched action. 9845 * 9846 * @return {Object} Updated state. 9847 */ 9848 function settings(state = SETTINGS_DEFAULTS, action) { 9849 switch (action.type) { 9850 case 'UPDATE_SETTINGS': 9851 if (action.reset) { 9852 return { 9853 ...SETTINGS_DEFAULTS, 9854 ...action.settings 9855 }; 9856 } 9857 return { 9858 ...state, 9859 ...action.settings 9860 }; 9861 } 9862 return state; 9863 } 9864 9865 /** 9866 * Reducer returning the user preferences. 9867 * 9868 * @param {Object} state Current state. 9869 * @param {Object} action Dispatched action. 9870 * 9871 * @return {string} Updated state. 9872 */ 9873 function preferences(state = PREFERENCES_DEFAULTS, action) { 9874 switch (action.type) { 9875 case 'INSERT_BLOCKS': 9876 case 'REPLACE_BLOCKS': 9877 { 9878 const nextInsertUsage = action.blocks.reduce((prevUsage, block) => { 9879 const { 9880 attributes, 9881 name: blockName 9882 } = block; 9883 let id = blockName; 9884 // If a block variation match is found change the name to be the same with the 9885 // one that is used for block variations in the Inserter (`getItemFromVariation`). 9886 const match = (0,external_wp_data_namespaceObject.select)(external_wp_blocks_namespaceObject.store).getActiveBlockVariation(blockName, attributes); 9887 if (match?.name) { 9888 id += '/' + match.name; 9889 } 9890 if (blockName === 'core/block') { 9891 id += '/' + attributes.ref; 9892 } 9893 return { 9894 ...prevUsage, 9895 [id]: { 9896 time: action.time, 9897 count: prevUsage[id] ? prevUsage[id].count + 1 : 1 9898 } 9899 }; 9900 }, state.insertUsage); 9901 return { 9902 ...state, 9903 insertUsage: nextInsertUsage 9904 }; 9905 } 9906 } 9907 return state; 9908 } 9909 9910 /** 9911 * Reducer returning an object where each key is a block client ID, its value 9912 * representing the settings for its nested blocks. 9913 * 9914 * @param {Object} state Current state. 9915 * @param {Object} action Dispatched action. 9916 * 9917 * @return {Object} Updated state. 9918 */ 9919 const blockListSettings = (state = {}, action) => { 9920 switch (action.type) { 9921 // Even if the replaced blocks have the same client ID, our logic 9922 // should correct the state. 9923 case 'REPLACE_BLOCKS': 9924 case 'REMOVE_BLOCKS': 9925 { 9926 return Object.fromEntries(Object.entries(state).filter(([id]) => !action.clientIds.includes(id))); 9927 } 9928 case 'UPDATE_BLOCK_LIST_SETTINGS': 9929 { 9930 const updates = typeof action.clientId === 'string' ? { 9931 [action.clientId]: action.settings 9932 } : action.clientId; 9933 9934 // Remove settings that are the same as the current state. 9935 for (const clientId in updates) { 9936 if (!updates[clientId]) { 9937 if (!state[clientId]) { 9938 delete updates[clientId]; 9939 } 9940 } else if (es6_default()(state[clientId], updates[clientId])) { 9941 delete updates[clientId]; 9942 } 9943 } 9944 if (Object.keys(updates).length === 0) { 9945 return state; 9946 } 9947 const merged = { 9948 ...state, 9949 ...updates 9950 }; 9951 for (const clientId in updates) { 9952 if (!updates[clientId]) { 9953 delete merged[clientId]; 9954 } 9955 } 9956 return merged; 9957 } 9958 } 9959 return state; 9960 }; 9961 9962 /** 9963 * Reducer returning which mode is enabled. 9964 * 9965 * @param {string} state Current state. 9966 * @param {Object} action Dispatched action. 9967 * 9968 * @return {string} Updated state. 9969 */ 9970 function editorMode(state = 'edit', action) { 9971 // Let inserting block in navigation mode always trigger Edit mode. 9972 if (action.type === 'INSERT_BLOCKS' && state === 'navigation') { 9973 return 'edit'; 9974 } 9975 if (action.type === 'SET_EDITOR_MODE') { 9976 return action.mode; 9977 } 9978 return state; 9979 } 9980 9981 /** 9982 * Reducer returning whether the block moving mode is enabled or not. 9983 * 9984 * @param {string|null} state Current state. 9985 * @param {Object} action Dispatched action. 9986 * 9987 * @return {string|null} Updated state. 9988 */ 9989 function hasBlockMovingClientId(state = null, action) { 9990 if (action.type === 'SET_BLOCK_MOVING_MODE') { 9991 return action.hasBlockMovingClientId; 9992 } 9993 if (action.type === 'SET_EDITOR_MODE') { 9994 return null; 9995 } 9996 return state; 9997 } 9998 9999 /** 10000 * Reducer return an updated state representing the most recent block attribute 10001 * update. The state is structured as an object where the keys represent the 10002 * client IDs of blocks, the values a subset of attributes from the most recent 10003 * block update. The state is always reset to null if the last action is 10004 * anything other than an attributes update. 10005 * 10006 * @param {Object<string,Object>} state Current state. 10007 * @param {Object} action Action object. 10008 * 10009 * @return {[string,Object]} Updated state. 10010 */ 10011 function lastBlockAttributesChange(state = null, action) { 10012 switch (action.type) { 10013 case 'UPDATE_BLOCK': 10014 if (!action.updates.attributes) { 10015 break; 10016 } 10017 return { 10018 [action.clientId]: action.updates.attributes 10019 }; 10020 case 'UPDATE_BLOCK_ATTRIBUTES': 10021 return action.clientIds.reduce((accumulator, id) => ({ 10022 ...accumulator, 10023 [id]: action.uniqueByBlock ? action.attributes[id] : action.attributes 10024 }), {}); 10025 } 10026 return state; 10027 } 10028 10029 /** 10030 * Reducer returning current highlighted block. 10031 * 10032 * @param {boolean} state Current highlighted block. 10033 * @param {Object} action Dispatched action. 10034 * 10035 * @return {string} Updated state. 10036 */ 10037 function highlightedBlock(state, action) { 10038 switch (action.type) { 10039 case 'TOGGLE_BLOCK_HIGHLIGHT': 10040 const { 10041 clientId, 10042 isHighlighted 10043 } = action; 10044 if (isHighlighted) { 10045 return clientId; 10046 } else if (state === clientId) { 10047 return null; 10048 } 10049 return state; 10050 case 'SELECT_BLOCK': 10051 if (action.clientId !== state) { 10052 return null; 10053 } 10054 } 10055 return state; 10056 } 10057 10058 /** 10059 * Reducer returning current expanded block in the list view. 10060 * 10061 * @param {string|null} state Current expanded block. 10062 * @param {Object} action Dispatched action. 10063 * 10064 * @return {string|null} Updated state. 10065 */ 10066 function expandedBlock(state = null, action) { 10067 switch (action.type) { 10068 case 'SET_BLOCK_EXPANDED_IN_LIST_VIEW': 10069 return action.clientId; 10070 case 'SELECT_BLOCK': 10071 if (action.clientId !== state) { 10072 return null; 10073 } 10074 } 10075 return state; 10076 } 10077 10078 /** 10079 * Reducer returning the block insertion event list state. 10080 * 10081 * @param {Object} state Current state. 10082 * @param {Object} action Dispatched action. 10083 * 10084 * @return {Object} Updated state. 10085 */ 10086 function lastBlockInserted(state = {}, action) { 10087 switch (action.type) { 10088 case 'INSERT_BLOCKS': 10089 case 'REPLACE_BLOCKS': 10090 if (!action.blocks.length) { 10091 return state; 10092 } 10093 const clientIds = action.blocks.map(block => { 10094 return block.clientId; 10095 }); 10096 const source = action.meta?.source; 10097 return { 10098 clientIds, 10099 source 10100 }; 10101 case 'RESET_BLOCKS': 10102 return {}; 10103 } 10104 return state; 10105 } 10106 10107 /** 10108 * Reducer returning the block that is eding temporarily edited as blocks. 10109 * 10110 * @param {Object} state Current state. 10111 * @param {Object} action Dispatched action. 10112 * 10113 * @return {Object} Updated state. 10114 */ 10115 function temporarilyEditingAsBlocks(state = '', action) { 10116 if (action.type === 'SET_TEMPORARILY_EDITING_AS_BLOCKS') { 10117 return action.temporarilyEditingAsBlocks; 10118 } 10119 return state; 10120 } 10121 10122 /** 10123 * Reducer returning the focus mode that should be used when temporarily edit as blocks finishes. 10124 * 10125 * @param {Object} state Current state. 10126 * @param {Object} action Dispatched action. 10127 * 10128 * @return {Object} Updated state. 10129 */ 10130 function temporarilyEditingFocusModeRevert(state = '', action) { 10131 if (action.type === 'SET_TEMPORARILY_EDITING_AS_BLOCKS') { 10132 return action.focusModeToRevert; 10133 } 10134 return state; 10135 } 10136 10137 /** 10138 * Reducer returning a map of block client IDs to block editing modes. 10139 * 10140 * @param {Map} state Current state. 10141 * @param {Object} action Dispatched action. 10142 * 10143 * @return {Map} Updated state. 10144 */ 10145 function blockEditingModes(state = new Map(), action) { 10146 switch (action.type) { 10147 case 'SET_BLOCK_EDITING_MODE': 10148 return new Map(state).set(action.clientId, action.mode); 10149 case 'UNSET_BLOCK_EDITING_MODE': 10150 { 10151 const newState = new Map(state); 10152 newState.delete(action.clientId); 10153 return newState; 10154 } 10155 case 'RESET_BLOCKS': 10156 { 10157 return state.has('') ? new Map().set('', state.get('')) : state; 10158 } 10159 } 10160 return state; 10161 } 10162 10163 /** 10164 * Reducer returning the clientId of the block settings menu that is currently open. 10165 * 10166 * @param {string|null} state Current state. 10167 * @param {Object} action Dispatched action. 10168 * 10169 * @return {string|null} Updated state. 10170 */ 10171 function openedBlockSettingsMenu(state = null, action) { 10172 if ('SET_OPENED_BLOCK_SETTINGS_MENU' === action.type) { 10173 var _action$clientId; 10174 return (_action$clientId = action?.clientId) !== null && _action$clientId !== void 0 ? _action$clientId : null; 10175 } 10176 return state; 10177 } 10178 10179 /** 10180 * Reducer returning a map of style IDs to style overrides. 10181 * 10182 * @param {Map} state Current state. 10183 * @param {Object} action Dispatched action. 10184 * 10185 * @return {Map} Updated state. 10186 */ 10187 function styleOverrides(state = new Map(), action) { 10188 switch (action.type) { 10189 case 'SET_STYLE_OVERRIDE': 10190 return new Map(state).set(action.id, action.style); 10191 case 'DELETE_STYLE_OVERRIDE': 10192 { 10193 const newState = new Map(state); 10194 newState.delete(action.id); 10195 return newState; 10196 } 10197 } 10198 return state; 10199 } 10200 10201 /** 10202 * Reducer returning a map of the registered inserter media categories. 10203 * 10204 * @param {Array} state Current state. 10205 * @param {Object} action Dispatched action. 10206 * 10207 * @return {Array} Updated state. 10208 */ 10209 function registeredInserterMediaCategories(state = [], action) { 10210 switch (action.type) { 10211 case 'REGISTER_INSERTER_MEDIA_CATEGORY': 10212 return [...state, action.category]; 10213 } 10214 return state; 10215 } 10216 10217 /** 10218 * Reducer setting last focused element 10219 * 10220 * @param {boolean} state Current state. 10221 * @param {Object} action Dispatched action. 10222 * 10223 * @return {boolean} Updated state. 10224 */ 10225 function lastFocus(state = false, action) { 10226 switch (action.type) { 10227 case 'LAST_FOCUS': 10228 return action.lastFocus; 10229 } 10230 return state; 10231 } 10232 10233 /** 10234 * Reducer setting currently hovered block. 10235 * 10236 * @param {boolean} state Current state. 10237 * @param {Object} action Dispatched action. 10238 * 10239 * @return {boolean} Updated state. 10240 */ 10241 function hoveredBlockClientId(state = false, action) { 10242 switch (action.type) { 10243 case 'HOVER_BLOCK': 10244 return action.clientId; 10245 } 10246 return state; 10247 } 10248 10249 /** 10250 * Reducer setting zoom out state. 10251 * 10252 * @param {boolean} state Current state. 10253 * @param {Object} action Dispatched action. 10254 * 10255 * @return {boolean} Updated state. 10256 */ 10257 function zoomLevel(state = 100, action) { 10258 switch (action.type) { 10259 case 'SET_ZOOM_LEVEL': 10260 return action.zoom; 10261 case 'RESET_ZOOM_LEVEL': 10262 return 100; 10263 } 10264 return state; 10265 } 10266 const combinedReducers = (0,external_wp_data_namespaceObject.combineReducers)({ 10267 blocks, 10268 isDragging, 10269 isTyping, 10270 isBlockInterfaceHidden, 10271 draggedBlocks, 10272 selection, 10273 isMultiSelecting, 10274 isSelectionEnabled, 10275 initialPosition, 10276 blocksMode, 10277 blockListSettings, 10278 insertionPoint, 10279 template, 10280 settings, 10281 preferences, 10282 lastBlockAttributesChange, 10283 lastFocus, 10284 editorMode, 10285 hasBlockMovingClientId, 10286 expandedBlock, 10287 highlightedBlock, 10288 lastBlockInserted, 10289 temporarilyEditingAsBlocks, 10290 temporarilyEditingFocusModeRevert, 10291 blockVisibility, 10292 blockEditingModes, 10293 styleOverrides, 10294 removalPromptData, 10295 blockRemovalRules, 10296 openedBlockSettingsMenu, 10297 registeredInserterMediaCategories, 10298 hoveredBlockClientId, 10299 zoomLevel 10300 }); 10301 function withAutomaticChangeReset(reducer) { 10302 return (state, action) => { 10303 const nextState = reducer(state, action); 10304 if (!state) { 10305 return nextState; 10306 } 10307 10308 // Take over the last value without creating a new reference. 10309 nextState.automaticChangeStatus = state.automaticChangeStatus; 10310 if (action.type === 'MARK_AUTOMATIC_CHANGE') { 10311 return { 10312 ...nextState, 10313 automaticChangeStatus: 'pending' 10314 }; 10315 } 10316 if (action.type === 'MARK_AUTOMATIC_CHANGE_FINAL' && state.automaticChangeStatus === 'pending') { 10317 return { 10318 ...nextState, 10319 automaticChangeStatus: 'final' 10320 }; 10321 } 10322 10323 // If there's a change that doesn't affect blocks or selection, maintain 10324 // the current status. 10325 if (nextState.blocks === state.blocks && nextState.selection === state.selection) { 10326 return nextState; 10327 } 10328 10329 // As long as the state is not final, ignore any selection changes. 10330 if (nextState.automaticChangeStatus !== 'final' && nextState.selection !== state.selection) { 10331 return nextState; 10332 } 10333 10334 // Reset the status if blocks change or selection changes (when status is final). 10335 return { 10336 ...nextState, 10337 automaticChangeStatus: undefined 10338 }; 10339 }; 10340 } 10341 /* harmony default export */ const reducer = (withAutomaticChangeReset(combinedReducers)); 10342 10343 ;// external ["wp","primitives"] 10344 const external_wp_primitives_namespaceObject = window["wp"]["primitives"]; 10345 ;// external "ReactJSXRuntime" 10346 const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"]; 10347 ;// ./node_modules/@wordpress/icons/build-module/library/symbol.js 10348 /** 10349 * WordPress dependencies 10350 */ 10351 10352 10353 const symbol = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 10354 xmlns: "http://www.w3.org/2000/svg", 10355 viewBox: "0 0 24 24", 10356 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 10357 d: "M21.3 10.8l-5.6-5.6c-.7-.7-1.8-.7-2.5 0l-5.6 5.6c-.7.7-.7 1.8 0 2.5l5.6 5.6c.3.3.8.5 1.2.5s.9-.2 1.2-.5l5.6-5.6c.8-.7.8-1.9.1-2.5zm-1 1.4l-5.6 5.6c-.1.1-.3.1-.4 0l-5.6-5.6c-.1-.1-.1-.3 0-.4l5.6-5.6s.1-.1.2-.1.1 0 .2.1l5.6 5.6c.1.1.1.3 0 .4zm-16.6-.4L10 5.5l-1-1-6.3 6.3c-.7.7-.7 1.8 0 2.5L9 19.5l1.1-1.1-6.3-6.3c-.2 0-.2-.2-.1-.3z" 10358 }) 10359 }); 10360 /* harmony default export */ const library_symbol = (symbol); 10361 10362 ;// external ["wp","richText"] 10363 const external_wp_richText_namespaceObject = window["wp"]["richText"]; 10364 ;// external ["wp","blockSerializationDefaultParser"] 10365 const external_wp_blockSerializationDefaultParser_namespaceObject = window["wp"]["blockSerializationDefaultParser"]; 10366 ;// ./node_modules/@wordpress/block-editor/build-module/store/private-keys.js 10367 const globalStylesDataKey = Symbol('globalStylesDataKey'); 10368 const globalStylesLinksDataKey = Symbol('globalStylesLinks'); 10369 const selectBlockPatternsKey = Symbol('selectBlockPatternsKey'); 10370 const reusableBlocksSelectKey = Symbol('reusableBlocksSelect'); 10371 const sectionRootClientIdKey = Symbol('sectionRootClientIdKey'); 10372 10373 ;// external ["wp","privateApis"] 10374 const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"]; 10375 ;// ./node_modules/@wordpress/block-editor/build-module/lock-unlock.js 10376 /** 10377 * WordPress dependencies 10378 */ 10379 10380 const { 10381 lock, 10382 unlock 10383 } = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)('I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.', '@wordpress/block-editor'); 10384 10385 ;// ./node_modules/@wordpress/block-editor/build-module/store/constants.js 10386 const STORE_NAME = 'core/block-editor'; 10387 10388 ;// ./node_modules/@wordpress/block-editor/build-module/store/utils.js 10389 /** 10390 * WordPress dependencies 10391 */ 10392 10393 10394 10395 /** 10396 * Internal dependencies 10397 */ 10398 10399 10400 10401 const withRootClientIdOptionKey = Symbol('withRootClientId'); 10402 const parsedPatternCache = new WeakMap(); 10403 const grammarMapCache = new WeakMap(); 10404 function parsePattern(pattern) { 10405 const blocks = (0,external_wp_blocks_namespaceObject.parse)(pattern.content, { 10406 __unstableSkipMigrationLogs: true 10407 }); 10408 if (blocks.length === 1) { 10409 blocks[0].attributes = { 10410 ...blocks[0].attributes, 10411 metadata: { 10412 ...(blocks[0].attributes.metadata || {}), 10413 categories: pattern.categories, 10414 patternName: pattern.name, 10415 name: blocks[0].attributes.metadata?.name || pattern.title 10416 } 10417 }; 10418 } 10419 return { 10420 ...pattern, 10421 blocks 10422 }; 10423 } 10424 function getParsedPattern(pattern) { 10425 let parsedPattern = parsedPatternCache.get(pattern); 10426 if (!parsedPattern) { 10427 parsedPattern = parsePattern(pattern); 10428 parsedPatternCache.set(pattern, parsedPattern); 10429 } 10430 return parsedPattern; 10431 } 10432 function getGrammar(pattern) { 10433 let grammarMap = grammarMapCache.get(pattern); 10434 if (!grammarMap) { 10435 grammarMap = (0,external_wp_blockSerializationDefaultParser_namespaceObject.parse)(pattern.content); 10436 // Block names are null only at the top level for whitespace. 10437 grammarMap = grammarMap.filter(block => block.blockName !== null); 10438 grammarMapCache.set(pattern, grammarMap); 10439 } 10440 return grammarMap; 10441 } 10442 const checkAllowList = (list, item, defaultResult = null) => { 10443 if (typeof list === 'boolean') { 10444 return list; 10445 } 10446 if (Array.isArray(list)) { 10447 // TODO: when there is a canonical way to detect that we are editing a post 10448 // the following check should be changed to something like: 10449 // if ( list.includes( 'core/post-content' ) && getEditorMode() === 'post-content' && item === null ) 10450 if (list.includes('core/post-content') && item === null) { 10451 return true; 10452 } 10453 return list.includes(item); 10454 } 10455 return defaultResult; 10456 }; 10457 const checkAllowListRecursive = (blocks, allowedBlockTypes) => { 10458 if (typeof allowedBlockTypes === 'boolean') { 10459 return allowedBlockTypes; 10460 } 10461 const blocksQueue = [...blocks]; 10462 while (blocksQueue.length > 0) { 10463 const block = blocksQueue.shift(); 10464 const isAllowed = checkAllowList(allowedBlockTypes, block.name || block.blockName, true); 10465 if (!isAllowed) { 10466 return false; 10467 } 10468 block.innerBlocks?.forEach(innerBlock => { 10469 blocksQueue.push(innerBlock); 10470 }); 10471 } 10472 return true; 10473 }; 10474 const getAllPatternsDependants = select => state => { 10475 return [state.settings.__experimentalBlockPatterns, state.settings.__experimentalUserPatternCategories, state.settings.__experimentalReusableBlocks, state.settings[selectBlockPatternsKey]?.(select), state.blockPatterns, unlock(select(STORE_NAME)).getReusableBlocks()]; 10476 }; 10477 function getInsertBlockTypeDependants(state, rootClientId) { 10478 return [state.blockListSettings[rootClientId], state.blocks.byClientId.get(rootClientId), state.settings.allowedBlockTypes, state.settings.templateLock, state.blockEditingModes]; 10479 } 10480 10481 ;// ./node_modules/@wordpress/block-editor/build-module/utils/sorting.js 10482 /** 10483 * Recursive stable sorting comparator function. 10484 * 10485 * @param {string|Function} field Field to sort by. 10486 * @param {Array} items Items to sort. 10487 * @param {string} order Order, 'asc' or 'desc'. 10488 * @return {Function} Comparison function to be used in a `.sort()`. 10489 */ 10490 const comparator = (field, items, order) => { 10491 return (a, b) => { 10492 let cmpA, cmpB; 10493 if (typeof field === 'function') { 10494 cmpA = field(a); 10495 cmpB = field(b); 10496 } else { 10497 cmpA = a[field]; 10498 cmpB = b[field]; 10499 } 10500 if (cmpA > cmpB) { 10501 return order === 'asc' ? 1 : -1; 10502 } else if (cmpB > cmpA) { 10503 return order === 'asc' ? -1 : 1; 10504 } 10505 const orderA = items.findIndex(item => item === a); 10506 const orderB = items.findIndex(item => item === b); 10507 10508 // Stable sort: maintaining original array order 10509 if (orderA > orderB) { 10510 return 1; 10511 } else if (orderB > orderA) { 10512 return -1; 10513 } 10514 return 0; 10515 }; 10516 }; 10517 10518 /** 10519 * Order items by a certain key. 10520 * Supports decorator functions that allow complex picking of a comparison field. 10521 * Sorts in ascending order by default, but supports descending as well. 10522 * Stable sort - maintains original order of equal items. 10523 * 10524 * @param {Array} items Items to order. 10525 * @param {string|Function} field Field to order by. 10526 * @param {string} order Sorting order, `asc` or `desc`. 10527 * @return {Array} Sorted items. 10528 */ 10529 function orderBy(items, field, order = 'asc') { 10530 return items.concat().sort(comparator(field, items, order)); 10531 } 10532 10533 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/utils.js 10534 /** 10535 * WordPress dependencies 10536 */ 10537 10538 10539 const INSERTER_PATTERN_TYPES = { 10540 user: 'user', 10541 theme: 'theme', 10542 directory: 'directory' 10543 }; 10544 const INSERTER_SYNC_TYPES = { 10545 full: 'fully', 10546 unsynced: 'unsynced' 10547 }; 10548 const allPatternsCategory = { 10549 name: 'allPatterns', 10550 label: (0,external_wp_i18n_namespaceObject._x)('All', 'patterns') 10551 }; 10552 const myPatternsCategory = { 10553 name: 'myPatterns', 10554 label: (0,external_wp_i18n_namespaceObject.__)('My patterns') 10555 }; 10556 function isPatternFiltered(pattern, sourceFilter, syncFilter) { 10557 const isUserPattern = pattern.name.startsWith('core/block'); 10558 const isDirectoryPattern = pattern.source === 'core' || pattern.source?.startsWith('pattern-directory'); 10559 10560 // If theme source selected, filter out user created patterns and those from 10561 // the core patterns directory. 10562 if (sourceFilter === INSERTER_PATTERN_TYPES.theme && (isUserPattern || isDirectoryPattern)) { 10563 return true; 10564 } 10565 10566 // If the directory source is selected, filter out user created patterns 10567 // and those bundled with the theme. 10568 if (sourceFilter === INSERTER_PATTERN_TYPES.directory && (isUserPattern || !isDirectoryPattern)) { 10569 return true; 10570 } 10571 10572 // If user source selected, filter out theme patterns. 10573 if (sourceFilter === INSERTER_PATTERN_TYPES.user && pattern.type !== INSERTER_PATTERN_TYPES.user) { 10574 return true; 10575 } 10576 10577 // Filter by sync status. 10578 if (syncFilter === INSERTER_SYNC_TYPES.full && pattern.syncStatus !== '') { 10579 return true; 10580 } 10581 if (syncFilter === INSERTER_SYNC_TYPES.unsynced && pattern.syncStatus !== 'unsynced' && isUserPattern) { 10582 return true; 10583 } 10584 return false; 10585 } 10586 10587 ;// ./node_modules/@wordpress/block-editor/build-module/utils/object.js 10588 /** 10589 * Immutably sets a value inside an object. Like `lodash#set`, but returning a 10590 * new object. Treats nullish initial values as empty objects. Clones any 10591 * nested objects. Supports arrays, too. 10592 * 10593 * @param {Object} object Object to set a value in. 10594 * @param {number|string|Array} path Path in the object to modify. 10595 * @param {*} value New value to set. 10596 * @return {Object} Cloned object with the new value set. 10597 */ 10598 function setImmutably(object, path, value) { 10599 // Normalize path 10600 path = Array.isArray(path) ? [...path] : [path]; 10601 10602 // Shallowly clone the base of the object 10603 object = Array.isArray(object) ? [...object] : { 10604 ...object 10605 }; 10606 const leaf = path.pop(); 10607 10608 // Traverse object from root to leaf, shallowly cloning at each level 10609 let prev = object; 10610 for (const key of path) { 10611 const lvl = prev[key]; 10612 prev = prev[key] = Array.isArray(lvl) ? [...lvl] : { 10613 ...lvl 10614 }; 10615 } 10616 prev[leaf] = value; 10617 return object; 10618 } 10619 10620 /** 10621 * Helper util to return a value from a certain path of the object. 10622 * Path is specified as either: 10623 * - a string of properties, separated by dots, for example: "x.y". 10624 * - an array of properties, for example `[ 'x', 'y' ]`. 10625 * You can also specify a default value in case the result is nullish. 10626 * 10627 * @param {Object} object Input object. 10628 * @param {string|Array} path Path to the object property. 10629 * @param {*} defaultValue Default value if the value at the specified path is nullish. 10630 * @return {*} Value of the object property at the specified path. 10631 */ 10632 const getValueFromObjectPath = (object, path, defaultValue) => { 10633 var _value; 10634 const arrayPath = Array.isArray(path) ? path : path.split('.'); 10635 let value = object; 10636 arrayPath.forEach(fieldName => { 10637 value = value?.[fieldName]; 10638 }); 10639 return (_value = value) !== null && _value !== void 0 ? _value : defaultValue; 10640 }; 10641 10642 /** 10643 * Helper util to filter out objects with duplicate values for a given property. 10644 * 10645 * @param {Object[]} array Array of objects to filter. 10646 * @param {string} property Property to filter unique values by. 10647 * 10648 * @return {Object[]} Array of objects with unique values for the specified property. 10649 */ 10650 function uniqByProperty(array, property) { 10651 const seen = new Set(); 10652 return array.filter(item => { 10653 const value = item[property]; 10654 return seen.has(value) ? false : seen.add(value); 10655 }); 10656 } 10657 10658 ;// ./node_modules/@wordpress/block-editor/build-module/store/get-block-settings.js 10659 /** 10660 * WordPress dependencies 10661 */ 10662 10663 10664 10665 /** 10666 * Internal dependencies 10667 */ 10668 10669 10670 const blockedPaths = ['color', 'border', 'dimensions', 'typography', 'spacing']; 10671 const deprecatedFlags = { 10672 'color.palette': settings => settings.colors, 10673 'color.gradients': settings => settings.gradients, 10674 'color.custom': settings => settings.disableCustomColors === undefined ? undefined : !settings.disableCustomColors, 10675 'color.customGradient': settings => settings.disableCustomGradients === undefined ? undefined : !settings.disableCustomGradients, 10676 'typography.fontSizes': settings => settings.fontSizes, 10677 'typography.customFontSize': settings => settings.disableCustomFontSizes === undefined ? undefined : !settings.disableCustomFontSizes, 10678 'typography.lineHeight': settings => settings.enableCustomLineHeight, 10679 'spacing.units': settings => { 10680 if (settings.enableCustomUnits === undefined) { 10681 return; 10682 } 10683 if (settings.enableCustomUnits === true) { 10684 return ['px', 'em', 'rem', 'vh', 'vw', '%']; 10685 } 10686 return settings.enableCustomUnits; 10687 }, 10688 'spacing.padding': settings => settings.enableCustomSpacing 10689 }; 10690 const prefixedFlags = { 10691 /* 10692 * These were only available in the plugin 10693 * and can be removed when the minimum WordPress version 10694 * for the plugin is 5.9. 10695 */ 10696 'border.customColor': 'border.color', 10697 'border.customStyle': 'border.style', 10698 'border.customWidth': 'border.width', 10699 'typography.customFontStyle': 'typography.fontStyle', 10700 'typography.customFontWeight': 'typography.fontWeight', 10701 'typography.customLetterSpacing': 'typography.letterSpacing', 10702 'typography.customTextDecorations': 'typography.textDecoration', 10703 'typography.customTextTransforms': 'typography.textTransform', 10704 /* 10705 * These were part of WordPress 5.8 and we need to keep them. 10706 */ 10707 'border.customRadius': 'border.radius', 10708 'spacing.customMargin': 'spacing.margin', 10709 'spacing.customPadding': 'spacing.padding', 10710 'typography.customLineHeight': 'typography.lineHeight' 10711 }; 10712 10713 /** 10714 * Remove `custom` prefixes for flags that did not land in 5.8. 10715 * 10716 * This provides continued support for `custom` prefixed properties. It will 10717 * be removed once third party devs have had sufficient time to update themes, 10718 * plugins, etc. 10719 * 10720 * @see https://github.com/WordPress/gutenberg/pull/34485 10721 * 10722 * @param {string} path Path to desired value in settings. 10723 * @return {string} The value for defined setting. 10724 */ 10725 const removeCustomPrefixes = path => { 10726 return prefixedFlags[path] || path; 10727 }; 10728 function getBlockSettings(state, clientId, ...paths) { 10729 const blockName = getBlockName(state, clientId); 10730 const candidates = []; 10731 if (clientId) { 10732 let id = clientId; 10733 do { 10734 const name = getBlockName(state, id); 10735 if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, '__experimentalSettings', false)) { 10736 candidates.push(id); 10737 } 10738 } while (id = state.blocks.parents.get(id)); 10739 } 10740 return paths.map(path => { 10741 if (blockedPaths.includes(path)) { 10742 // eslint-disable-next-line no-console 10743 console.warn('Top level useSetting paths are disabled. Please use a subpath to query the information needed.'); 10744 return undefined; 10745 } 10746 10747 // 0. Allow third parties to filter the block's settings at runtime. 10748 let result = (0,external_wp_hooks_namespaceObject.applyFilters)('blockEditor.useSetting.before', undefined, path, clientId, blockName); 10749 if (undefined !== result) { 10750 return result; 10751 } 10752 const normalizedPath = removeCustomPrefixes(path); 10753 10754 // 1. Take settings from the block instance or its ancestors. 10755 // Start from the current block and work our way up the ancestors. 10756 for (const candidateClientId of candidates) { 10757 var _getValueFromObjectPa; 10758 const candidateAtts = getBlockAttributes(state, candidateClientId); 10759 result = (_getValueFromObjectPa = getValueFromObjectPath(candidateAtts.settings?.blocks?.[blockName], normalizedPath)) !== null && _getValueFromObjectPa !== void 0 ? _getValueFromObjectPa : getValueFromObjectPath(candidateAtts.settings, normalizedPath); 10760 if (result !== undefined) { 10761 // Stop the search for more distant ancestors and move on. 10762 break; 10763 } 10764 } 10765 10766 // 2. Fall back to the settings from the block editor store (__experimentalFeatures). 10767 const settings = getSettings(state); 10768 if (result === undefined && blockName) { 10769 result = getValueFromObjectPath(settings.__experimentalFeatures?.blocks?.[blockName], normalizedPath); 10770 } 10771 if (result === undefined) { 10772 result = getValueFromObjectPath(settings.__experimentalFeatures, normalizedPath); 10773 } 10774 10775 // Return if the setting was found in either the block instance or the store. 10776 if (result !== undefined) { 10777 if (external_wp_blocks_namespaceObject.__EXPERIMENTAL_PATHS_WITH_OVERRIDE[normalizedPath]) { 10778 var _ref, _result$custom; 10779 return (_ref = (_result$custom = result.custom) !== null && _result$custom !== void 0 ? _result$custom : result.theme) !== null && _ref !== void 0 ? _ref : result.default; 10780 } 10781 return result; 10782 } 10783 10784 // 3. Otherwise, use deprecated settings. 10785 const deprecatedSettingsValue = deprecatedFlags[normalizedPath]?.(settings); 10786 if (deprecatedSettingsValue !== undefined) { 10787 return deprecatedSettingsValue; 10788 } 10789 10790 // 4. Fallback for typography.dropCap: 10791 // This is only necessary to support typography.dropCap. 10792 // when __experimentalFeatures are not present (core without plugin). 10793 // To remove when __experimentalFeatures are ported to core. 10794 return normalizedPath === 'typography.dropCap' ? true : undefined; 10795 }); 10796 } 10797 10798 ;// ./node_modules/@wordpress/block-editor/build-module/store/private-selectors.js 10799 /** 10800 * WordPress dependencies 10801 */ 10802 10803 10804 /** 10805 * Internal dependencies 10806 */ 10807 10808 10809 10810 10811 10812 10813 10814 10815 /** 10816 * Returns true if the block interface is hidden, or false otherwise. 10817 * 10818 * @param {Object} state Global application state. 10819 * 10820 * @return {boolean} Whether the block toolbar is hidden. 10821 */ 10822 function private_selectors_isBlockInterfaceHidden(state) { 10823 return state.isBlockInterfaceHidden; 10824 } 10825 10826 /** 10827 * Gets the client ids of the last inserted blocks. 10828 * 10829 * @param {Object} state Global application state. 10830 * @return {Array|undefined} Client Ids of the last inserted block(s). 10831 */ 10832 function getLastInsertedBlocksClientIds(state) { 10833 return state?.lastBlockInserted?.clientIds; 10834 } 10835 function getBlockWithoutAttributes(state, clientId) { 10836 return state.blocks.byClientId.get(clientId); 10837 } 10838 10839 /** 10840 * Returns true if all of the descendants of a block with the given client ID 10841 * have an editing mode of 'disabled', or false otherwise. 10842 * 10843 * @param {Object} state Global application state. 10844 * @param {string} clientId The block client ID. 10845 * 10846 * @return {boolean} Whether the block descendants are disabled. 10847 */ 10848 const isBlockSubtreeDisabled = (state, clientId) => { 10849 const isChildSubtreeDisabled = childClientId => { 10850 return getBlockEditingMode(state, childClientId) === 'disabled' && getBlockOrder(state, childClientId).every(isChildSubtreeDisabled); 10851 }; 10852 return getBlockOrder(state, clientId).every(isChildSubtreeDisabled); 10853 }; 10854 function getEnabledClientIdsTreeUnmemoized(state, rootClientId) { 10855 const blockOrder = getBlockOrder(state, rootClientId); 10856 const result = []; 10857 for (const clientId of blockOrder) { 10858 const innerBlocks = getEnabledClientIdsTreeUnmemoized(state, clientId); 10859 if (getBlockEditingMode(state, clientId) !== 'disabled') { 10860 result.push({ 10861 clientId, 10862 innerBlocks 10863 }); 10864 } else { 10865 result.push(...innerBlocks); 10866 } 10867 } 10868 return result; 10869 } 10870 10871 /** 10872 * Returns a tree of block objects with only clientID and innerBlocks set. 10873 * Blocks with a 'disabled' editing mode are not included. 10874 * 10875 * @param {Object} state Global application state. 10876 * @param {?string} rootClientId Optional root client ID of block list. 10877 * 10878 * @return {Object[]} Tree of block objects with only clientID and innerBlocks set. 10879 */ 10880 const getEnabledClientIdsTree = (0,external_wp_data_namespaceObject.createSelector)(getEnabledClientIdsTreeUnmemoized, state => [state.blocks.order, state.blockEditingModes, state.settings.templateLock, state.blockListSettings, state.editorMode]); 10881 10882 /** 10883 * Returns a list of a given block's ancestors, from top to bottom. Blocks with 10884 * a 'disabled' editing mode are excluded. 10885 * 10886 * @see getBlockParents 10887 * 10888 * @param {Object} state Global application state. 10889 * @param {string} clientId The block client ID. 10890 * @param {boolean} ascending Order results from bottom to top (true) or top 10891 * to bottom (false). 10892 */ 10893 const getEnabledBlockParents = (0,external_wp_data_namespaceObject.createSelector)((state, clientId, ascending = false) => { 10894 return getBlockParents(state, clientId, ascending).filter(parent => getBlockEditingMode(state, parent) !== 'disabled'); 10895 }, state => [state.blocks.parents, state.blockEditingModes, state.settings.templateLock, state.blockListSettings]); 10896 10897 /** 10898 * Selector that returns the data needed to display a prompt when certain 10899 * blocks are removed, or `false` if no such prompt is requested. 10900 * 10901 * @param {Object} state Global application state. 10902 * 10903 * @return {Object|false} Data for removal prompt display, if any. 10904 */ 10905 function getRemovalPromptData(state) { 10906 return state.removalPromptData; 10907 } 10908 10909 /** 10910 * Returns true if removal prompt exists, or false otherwise. 10911 * 10912 * @param {Object} state Global application state. 10913 * 10914 * @return {boolean} Whether removal prompt exists. 10915 */ 10916 function getBlockRemovalRules(state) { 10917 return state.blockRemovalRules; 10918 } 10919 10920 /** 10921 * Returns the client ID of the block settings menu that is currently open. 10922 * 10923 * @param {Object} state Global application state. 10924 * @return {string|null} The client ID of the block menu that is currently open. 10925 */ 10926 function getOpenedBlockSettingsMenu(state) { 10927 return state.openedBlockSettingsMenu; 10928 } 10929 10930 /** 10931 * Returns all style overrides, intended to be merged with global editor styles. 10932 * 10933 * Overrides are sorted to match the order of the blocks they relate to. This 10934 * is useful to maintain correct CSS cascade order. 10935 * 10936 * @param {Object} state Global application state. 10937 * 10938 * @return {Array} An array of style ID to style override pairs. 10939 */ 10940 const getStyleOverrides = (0,external_wp_data_namespaceObject.createSelector)(state => { 10941 const clientIds = getClientIdsWithDescendants(state); 10942 const clientIdMap = clientIds.reduce((acc, clientId, index) => { 10943 acc[clientId] = index; 10944 return acc; 10945 }, {}); 10946 return [...state.styleOverrides].sort((overrideA, overrideB) => { 10947 var _clientIdMap$clientId, _clientIdMap$clientId2; 10948 // Once the overrides Map is spread to an array, the first element 10949 // is the key, while the second is the override itself including 10950 // the clientId to sort by. 10951 const [, { 10952 clientId: clientIdA 10953 }] = overrideA; 10954 const [, { 10955 clientId: clientIdB 10956 }] = overrideB; 10957 const aIndex = (_clientIdMap$clientId = clientIdMap[clientIdA]) !== null && _clientIdMap$clientId !== void 0 ? _clientIdMap$clientId : -1; 10958 const bIndex = (_clientIdMap$clientId2 = clientIdMap[clientIdB]) !== null && _clientIdMap$clientId2 !== void 0 ? _clientIdMap$clientId2 : -1; 10959 return aIndex - bIndex; 10960 }); 10961 }, state => [state.blocks.order, state.styleOverrides]); 10962 10963 /** @typedef {import('./actions').InserterMediaCategory} InserterMediaCategory */ 10964 /** 10965 * Returns the registered inserter media categories through the public API. 10966 * 10967 * @param {Object} state Editor state. 10968 * 10969 * @return {InserterMediaCategory[]} Inserter media categories. 10970 */ 10971 function getRegisteredInserterMediaCategories(state) { 10972 return state.registeredInserterMediaCategories; 10973 } 10974 10975 /** 10976 * Returns an array containing the allowed inserter media categories. 10977 * It merges the registered media categories from extenders with the 10978 * core ones. It also takes into account the allowed `mime_types`, which 10979 * can be altered by `upload_mimes` filter and restrict some of them. 10980 * 10981 * @param {Object} state Global application state. 10982 * 10983 * @return {InserterMediaCategory[]} Client IDs of descendants. 10984 */ 10985 const getInserterMediaCategories = (0,external_wp_data_namespaceObject.createSelector)(state => { 10986 const { 10987 settings: { 10988 inserterMediaCategories, 10989 allowedMimeTypes, 10990 enableOpenverseMediaCategory 10991 }, 10992 registeredInserterMediaCategories 10993 } = state; 10994 // The allowed `mime_types` can be altered by `upload_mimes` filter and restrict 10995 // some of them. In this case we shouldn't add the category to the available media 10996 // categories list in the inserter. 10997 if (!inserterMediaCategories && !registeredInserterMediaCategories.length || !allowedMimeTypes) { 10998 return; 10999 } 11000 const coreInserterMediaCategoriesNames = inserterMediaCategories?.map(({ 11001 name 11002 }) => name) || []; 11003 const mergedCategories = [...(inserterMediaCategories || []), ...(registeredInserterMediaCategories || []).filter(({ 11004 name 11005 }) => !coreInserterMediaCategoriesNames.includes(name))]; 11006 return mergedCategories.filter(category => { 11007 // Check if Openverse category is enabled. 11008 if (!enableOpenverseMediaCategory && category.name === 'openverse') { 11009 return false; 11010 } 11011 return Object.values(allowedMimeTypes).some(mimeType => mimeType.startsWith(`$category.mediaType}/`)); 11012 }); 11013 }, state => [state.settings.inserterMediaCategories, state.settings.allowedMimeTypes, state.settings.enableOpenverseMediaCategory, state.registeredInserterMediaCategories]); 11014 11015 /** 11016 * Returns whether there is at least one allowed pattern for inner blocks children. 11017 * This is useful for deferring the parsing of all patterns until needed. 11018 * 11019 * @param {Object} state Editor state. 11020 * @param {string} [rootClientId=null] Target root client ID. 11021 * 11022 * @return {boolean} If there is at least one allowed pattern. 11023 */ 11024 const hasAllowedPatterns = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null) => { 11025 const { 11026 getAllPatterns 11027 } = unlock(select(STORE_NAME)); 11028 const patterns = getAllPatterns(); 11029 const { 11030 allowedBlockTypes 11031 } = getSettings(state); 11032 return patterns.some(pattern => { 11033 const { 11034 inserter = true 11035 } = pattern; 11036 if (!inserter) { 11037 return false; 11038 } 11039 const grammar = getGrammar(pattern); 11040 return checkAllowListRecursive(grammar, allowedBlockTypes) && grammar.every(({ 11041 name: blockName 11042 }) => canInsertBlockType(state, blockName, rootClientId)); 11043 }); 11044 }, (state, rootClientId) => [...getAllPatternsDependants(select)(state), ...getInsertBlockTypeDependants(state, rootClientId)])); 11045 function mapUserPattern(userPattern, __experimentalUserPatternCategories = []) { 11046 return { 11047 name: `core/block/$userPattern.id}`, 11048 id: userPattern.id, 11049 type: INSERTER_PATTERN_TYPES.user, 11050 title: userPattern.title.raw, 11051 categories: userPattern.wp_pattern_category.map(catId => { 11052 const category = __experimentalUserPatternCategories.find(({ 11053 id 11054 }) => id === catId); 11055 return category ? category.slug : catId; 11056 }), 11057 content: userPattern.content.raw, 11058 syncStatus: userPattern.wp_pattern_sync_status 11059 }; 11060 } 11061 const getPatternBySlug = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, patternName) => { 11062 var _state$settings$__exp, _state$settings$selec; 11063 // Only fetch reusable blocks if we know we need them. To do: maybe 11064 // use the entity record API to retrieve the block by slug. 11065 if (patternName?.startsWith('core/block/')) { 11066 const _id = parseInt(patternName.slice('core/block/'.length), 10); 11067 const block = unlock(select(STORE_NAME)).getReusableBlocks().find(({ 11068 id 11069 }) => id === _id); 11070 if (!block) { 11071 return null; 11072 } 11073 return mapUserPattern(block, state.settings.__experimentalUserPatternCategories); 11074 } 11075 return [ 11076 // This setting is left for back compat. 11077 ...((_state$settings$__exp = state.settings.__experimentalBlockPatterns) !== null && _state$settings$__exp !== void 0 ? _state$settings$__exp : []), ...((_state$settings$selec = state.settings[selectBlockPatternsKey]?.(select)) !== null && _state$settings$selec !== void 0 ? _state$settings$selec : [])].find(({ 11078 name 11079 }) => name === patternName); 11080 }, (state, patternName) => patternName?.startsWith('core/block/') ? [unlock(select(STORE_NAME)).getReusableBlocks(), state.settings.__experimentalReusableBlocks] : [state.settings.__experimentalBlockPatterns, state.settings[selectBlockPatternsKey]?.(select)])); 11081 const getAllPatterns = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)(state => { 11082 var _state$settings$__exp2, _state$settings$selec2; 11083 return [...unlock(select(STORE_NAME)).getReusableBlocks().map(userPattern => mapUserPattern(userPattern, state.settings.__experimentalUserPatternCategories)), 11084 // This setting is left for back compat. 11085 ...((_state$settings$__exp2 = state.settings.__experimentalBlockPatterns) !== null && _state$settings$__exp2 !== void 0 ? _state$settings$__exp2 : []), ...((_state$settings$selec2 = state.settings[selectBlockPatternsKey]?.(select)) !== null && _state$settings$selec2 !== void 0 ? _state$settings$selec2 : [])].filter((x, index, arr) => index === arr.findIndex(y => x.name === y.name)); 11086 }, getAllPatternsDependants(select))); 11087 const isResolvingPatterns = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)(state => { 11088 const blockPatternsSelect = state.settings[selectBlockPatternsKey]; 11089 const reusableBlocksSelect = state.settings[reusableBlocksSelectKey]; 11090 return (blockPatternsSelect ? blockPatternsSelect(select) === undefined : false) || (reusableBlocksSelect ? reusableBlocksSelect(select) === undefined : false); 11091 }, getAllPatternsDependants(select))); 11092 const EMPTY_ARRAY = []; 11093 const getReusableBlocks = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => state => { 11094 var _ref; 11095 const reusableBlocksSelect = state.settings[reusableBlocksSelectKey]; 11096 return (_ref = reusableBlocksSelect ? reusableBlocksSelect(select) : state.settings.__experimentalReusableBlocks) !== null && _ref !== void 0 ? _ref : EMPTY_ARRAY; 11097 }); 11098 11099 /** 11100 * Returns the element of the last element that had focus when focus left the editor canvas. 11101 * 11102 * @param {Object} state Block editor state. 11103 * 11104 * @return {Object} Element. 11105 */ 11106 function getLastFocus(state) { 11107 return state.lastFocus; 11108 } 11109 11110 /** 11111 * Returns true if the user is dragging anything, or false otherwise. It is possible for a 11112 * user to be dragging data from outside of the editor, so this selector is separate from 11113 * the `isDraggingBlocks` selector which only returns true if the user is dragging blocks. 11114 * 11115 * @param {Object} state Global application state. 11116 * 11117 * @return {boolean} Whether user is dragging. 11118 */ 11119 function private_selectors_isDragging(state) { 11120 return state.isDragging; 11121 } 11122 11123 /** 11124 * Retrieves the expanded block from the state. 11125 * 11126 * @param {Object} state Block editor state. 11127 * 11128 * @return {string|null} The client ID of the expanded block, if set. 11129 */ 11130 function getExpandedBlock(state) { 11131 return state.expandedBlock; 11132 } 11133 11134 /** 11135 * Retrieves the client ID of the ancestor block that is content locking the block 11136 * with the provided client ID. 11137 * 11138 * @param {Object} state Global application state. 11139 * @param {Object} clientId Client Id of the block. 11140 * 11141 * @return {?string} Client ID of the ancestor block that is content locking the block. 11142 */ 11143 const getContentLockingParent = (0,external_wp_data_namespaceObject.createSelector)((state, clientId) => { 11144 let current = clientId; 11145 let result; 11146 while (current = state.blocks.parents.get(current)) { 11147 if (getBlockName(state, current) === 'core/block' || getTemplateLock(state, current) === 'contentOnly') { 11148 result = current; 11149 } 11150 } 11151 return result; 11152 }, state => [state.blocks.parents, state.blockListSettings]); 11153 11154 /** 11155 * Retrieves the client ID of the block that is content locked but is 11156 * currently being temporarily edited as a non-locked block. 11157 * 11158 * @param {Object} state Global application state. 11159 * 11160 * @return {?string} The client ID of the block being temporarily edited as a non-locked block. 11161 */ 11162 function getTemporarilyEditingAsBlocks(state) { 11163 return state.temporarilyEditingAsBlocks; 11164 } 11165 11166 /** 11167 * Returns the focus mode that should be reapplied when the user stops editing 11168 * a content locked blocks as a block without locking. 11169 * 11170 * @param {Object} state Global application state. 11171 * 11172 * @return {?string} The focus mode that should be re-set when temporarily editing as blocks stops. 11173 */ 11174 function getTemporarilyEditingFocusModeToRevert(state) { 11175 return state.temporarilyEditingFocusModeRevert; 11176 } 11177 11178 /** 11179 * Returns the style attributes of multiple blocks. 11180 * 11181 * @param {Object} state Global application state. 11182 * @param {string[]} clientIds An array of block client IDs. 11183 * 11184 * @return {Object} An object where keys are client IDs and values are the corresponding block styles or undefined. 11185 */ 11186 const getBlockStyles = (0,external_wp_data_namespaceObject.createSelector)((state, clientIds) => clientIds.reduce((styles, clientId) => { 11187 styles[clientId] = state.blocks.attributes.get(clientId)?.style; 11188 return styles; 11189 }, {}), (state, clientIds) => [...clientIds.map(clientId => state.blocks.attributes.get(clientId)?.style)]); 11190 11191 /** 11192 * Returns whether zoom out mode is enabled. 11193 * 11194 * @param {Object} state Editor state. 11195 * 11196 * @return {boolean} Is zoom out mode enabled. 11197 */ 11198 function isZoomOutMode(state) { 11199 return __unstableGetEditorMode(state) === 'zoom-out'; 11200 } 11201 11202 /** 11203 * Retrieves the client ID of the block which contains the blocks 11204 * acting as "sections" in the editor. This is typically the "main content" 11205 * of the template/post. 11206 * 11207 * @param {Object} state Editor state. 11208 * 11209 * @return {string|undefined} The section root client ID or undefined if not set. 11210 */ 11211 function getSectionRootClientId(state) { 11212 return state.settings?.[sectionRootClientIdKey]; 11213 } 11214 11215 /** 11216 * Returns the zoom out state. 11217 * 11218 * @param {Object} state Global application state. 11219 * @return {boolean} The zoom out state. 11220 */ 11221 function getZoomLevel(state) { 11222 return state.zoomLevel; 11223 } 11224 11225 /** 11226 * Returns whether the editor is considered zoomed out. 11227 * 11228 * @param {Object} state Global application state. 11229 * @return {boolean} Whether the editor is zoomed. 11230 */ 11231 function isZoomOut(state) { 11232 return getZoomLevel(state) < 100; 11233 } 11234 11235 /** 11236 * Retrieves the client ID of the parent section block. 11237 * 11238 * @param {Object} state Global application state. 11239 * @param {string} clientId Client Id of the block. 11240 * 11241 * @return {?string} Client ID of the ancestor block that is content locking the block. 11242 */ 11243 const getParentSectionBlock = (state, clientId) => { 11244 let current = clientId; 11245 let result; 11246 while (!result && (current = state.blocks.parents.get(current))) { 11247 if (isSectionBlock(state, current)) { 11248 result = current; 11249 } 11250 } 11251 return result; 11252 }; 11253 11254 /** 11255 * Retrieves the client ID is a content locking parent 11256 * 11257 * @param {Object} state Global application state. 11258 * @param {string} clientId Client Id of the block. 11259 * 11260 * @return {boolean} Whether the block is a content locking parent. 11261 */ 11262 function isSectionBlock(state, clientId) { 11263 const sectionRootClientId = getSectionRootClientId(state); 11264 const sectionClientIds = getBlockOrder(state, sectionRootClientId); 11265 return getBlockName(state, clientId) === 'core/block' || getTemplateLock(state, clientId) === 'contentOnly' || isNavigationMode(state) && sectionClientIds.includes(clientId); 11266 } 11267 11268 ;// ./node_modules/@wordpress/block-editor/build-module/store/selectors.js 11269 /** 11270 * WordPress dependencies 11271 */ 11272 11273 11274 11275 11276 11277 11278 11279 11280 /** 11281 * Internal dependencies 11282 */ 11283 11284 11285 11286 11287 11288 11289 /** 11290 * A block selection object. 11291 * 11292 * @typedef {Object} WPBlockSelection 11293 * 11294 * @property {string} clientId A block client ID. 11295 * @property {string} attributeKey A block attribute key. 11296 * @property {number} offset An attribute value offset, based on the rich 11297 * text value. See `wp.richText.create`. 11298 */ 11299 11300 // Module constants. 11301 const MILLISECONDS_PER_HOUR = 3600 * 1000; 11302 const MILLISECONDS_PER_DAY = 24 * 3600 * 1000; 11303 const MILLISECONDS_PER_WEEK = 7 * 24 * 3600 * 1000; 11304 11305 /** 11306 * Shared reference to an empty array for cases where it is important to avoid 11307 * returning a new array reference on every invocation, as in a connected or 11308 * other pure component which performs `shouldComponentUpdate` check on props. 11309 * This should be used as a last resort, since the normalized data should be 11310 * maintained by the reducer result in state. 11311 * 11312 * @type {Array} 11313 */ 11314 const selectors_EMPTY_ARRAY = []; 11315 11316 /** 11317 * Shared reference to an empty Set for cases where it is important to avoid 11318 * returning a new Set reference on every invocation, as in a connected or 11319 * other pure component which performs `shouldComponentUpdate` check on props. 11320 * This should be used as a last resort, since the normalized data should be 11321 * maintained by the reducer result in state. 11322 * 11323 * @type {Set} 11324 */ 11325 const EMPTY_SET = new Set(); 11326 const EMPTY_OBJECT = {}; 11327 11328 /** 11329 * Returns a block's name given its client ID, or null if no block exists with 11330 * the client ID. 11331 * 11332 * @param {Object} state Editor state. 11333 * @param {string} clientId Block client ID. 11334 * 11335 * @return {string} Block name. 11336 */ 11337 function getBlockName(state, clientId) { 11338 const block = state.blocks.byClientId.get(clientId); 11339 const socialLinkName = 'core/social-link'; 11340 if (external_wp_element_namespaceObject.Platform.OS !== 'web' && block?.name === socialLinkName) { 11341 const attributes = state.blocks.attributes.get(clientId); 11342 const { 11343 service 11344 } = attributes !== null && attributes !== void 0 ? attributes : {}; 11345 return service ? `$socialLinkName}-$service}` : socialLinkName; 11346 } 11347 return block ? block.name : null; 11348 } 11349 11350 /** 11351 * Returns whether a block is valid or not. 11352 * 11353 * @param {Object} state Editor state. 11354 * @param {string} clientId Block client ID. 11355 * 11356 * @return {boolean} Is Valid. 11357 */ 11358 function isBlockValid(state, clientId) { 11359 const block = state.blocks.byClientId.get(clientId); 11360 return !!block && block.isValid; 11361 } 11362 11363 /** 11364 * Returns a block's attributes given its client ID, or null if no block exists with 11365 * the client ID. 11366 * 11367 * @param {Object} state Editor state. 11368 * @param {string} clientId Block client ID. 11369 * 11370 * @return {Object?} Block attributes. 11371 */ 11372 function getBlockAttributes(state, clientId) { 11373 const block = state.blocks.byClientId.get(clientId); 11374 if (!block) { 11375 return null; 11376 } 11377 return state.blocks.attributes.get(clientId); 11378 } 11379 11380 /** 11381 * Returns a block given its client ID. This is a parsed copy of the block, 11382 * containing its `blockName`, `clientId`, and current `attributes` state. This 11383 * is not the block's registration settings, which must be retrieved from the 11384 * blocks module registration store. 11385 * 11386 * getBlock recurses through its inner blocks until all its children blocks have 11387 * been retrieved. Note that getBlock will not return the child inner blocks of 11388 * an inner block controller. This is because an inner block controller syncs 11389 * itself with its own entity, and should therefore not be included with the 11390 * blocks of a different entity. For example, say you call `getBlocks( TP )` to 11391 * get the blocks of a template part. If another template part is a child of TP, 11392 * then the nested template part's child blocks will not be returned. This way, 11393 * the template block itself is considered part of the parent, but the children 11394 * are not. 11395 * 11396 * @param {Object} state Editor state. 11397 * @param {string} clientId Block client ID. 11398 * 11399 * @return {Object} Parsed block object. 11400 */ 11401 function getBlock(state, clientId) { 11402 if (!state.blocks.byClientId.has(clientId)) { 11403 return null; 11404 } 11405 return state.blocks.tree.get(clientId); 11406 } 11407 const __unstableGetBlockWithoutInnerBlocks = (0,external_wp_data_namespaceObject.createSelector)((state, clientId) => { 11408 const block = state.blocks.byClientId.get(clientId); 11409 if (!block) { 11410 return null; 11411 } 11412 return { 11413 ...block, 11414 attributes: getBlockAttributes(state, clientId) 11415 }; 11416 }, (state, clientId) => [state.blocks.byClientId.get(clientId), state.blocks.attributes.get(clientId)]); 11417 11418 /** 11419 * Returns all block objects for the current post being edited as an array in 11420 * the order they appear in the post. Note that this will exclude child blocks 11421 * of nested inner block controllers. 11422 * 11423 * @param {Object} state Editor state. 11424 * @param {?string} rootClientId Optional root client ID of block list. 11425 * 11426 * @return {Object[]} Post blocks. 11427 */ 11428 function getBlocks(state, rootClientId) { 11429 const treeKey = !rootClientId || !areInnerBlocksControlled(state, rootClientId) ? rootClientId || '' : 'controlled||' + rootClientId; 11430 return state.blocks.tree.get(treeKey)?.innerBlocks || selectors_EMPTY_ARRAY; 11431 } 11432 11433 /** 11434 * Returns a stripped down block object containing only its client ID, 11435 * and its inner blocks' client IDs. 11436 * 11437 * @deprecated 11438 * 11439 * @param {Object} state Editor state. 11440 * @param {string} clientId Client ID of the block to get. 11441 * 11442 * @return {Object} Client IDs of the post blocks. 11443 */ 11444 const __unstableGetClientIdWithClientIdsTree = (0,external_wp_data_namespaceObject.createSelector)((state, clientId) => { 11445 external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__unstableGetClientIdWithClientIdsTree", { 11446 since: '6.3', 11447 version: '6.5' 11448 }); 11449 return { 11450 clientId, 11451 innerBlocks: __unstableGetClientIdsTree(state, clientId) 11452 }; 11453 }, state => [state.blocks.order]); 11454 11455 /** 11456 * Returns the block tree represented in the block-editor store from the 11457 * given root, consisting of stripped down block objects containing only 11458 * their client IDs, and their inner blocks' client IDs. 11459 * 11460 * @deprecated 11461 * 11462 * @param {Object} state Editor state. 11463 * @param {?string} rootClientId Optional root client ID of block list. 11464 * 11465 * @return {Object[]} Client IDs of the post blocks. 11466 */ 11467 const __unstableGetClientIdsTree = (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = '') => { 11468 external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__unstableGetClientIdsTree", { 11469 since: '6.3', 11470 version: '6.5' 11471 }); 11472 return getBlockOrder(state, rootClientId).map(clientId => __unstableGetClientIdWithClientIdsTree(state, clientId)); 11473 }, state => [state.blocks.order]); 11474 11475 /** 11476 * Returns an array containing the clientIds of all descendants of the blocks 11477 * given. Returned ids are ordered first by the order of the ids given, then 11478 * by the order that they appear in the editor. 11479 * 11480 * @param {Object} state Global application state. 11481 * @param {string|string[]} rootIds Client ID(s) for which descendant blocks are to be returned. 11482 * 11483 * @return {Array} Client IDs of descendants. 11484 */ 11485 const getClientIdsOfDescendants = (0,external_wp_data_namespaceObject.createSelector)((state, rootIds) => { 11486 rootIds = Array.isArray(rootIds) ? [...rootIds] : [rootIds]; 11487 const ids = []; 11488 11489 // Add the descendants of the root blocks first. 11490 for (const rootId of rootIds) { 11491 const order = state.blocks.order.get(rootId); 11492 if (order) { 11493 ids.push(...order); 11494 } 11495 } 11496 let index = 0; 11497 11498 // Add the descendants of the descendants, recursively. 11499 while (index < ids.length) { 11500 const id = ids[index]; 11501 const order = state.blocks.order.get(id); 11502 if (order) { 11503 ids.splice(index + 1, 0, ...order); 11504 } 11505 index++; 11506 } 11507 return ids; 11508 }, state => [state.blocks.order]); 11509 11510 /** 11511 * Returns an array containing the clientIds of the top-level blocks and 11512 * their descendants of any depth (for nested blocks). Ids are returned 11513 * in the same order that they appear in the editor. 11514 * 11515 * @param {Object} state Global application state. 11516 * 11517 * @return {Array} ids of top-level and descendant blocks. 11518 */ 11519 const getClientIdsWithDescendants = state => getClientIdsOfDescendants(state, ''); 11520 11521 /** 11522 * Returns the total number of blocks, or the total number of blocks with a specific name in a post. 11523 * The number returned includes nested blocks. 11524 * 11525 * @param {Object} state Global application state. 11526 * @param {?string} blockName Optional block name, if specified only blocks of that type will be counted. 11527 * 11528 * @return {number} Number of blocks in the post, or number of blocks with name equal to blockName. 11529 */ 11530 const getGlobalBlockCount = (0,external_wp_data_namespaceObject.createSelector)((state, blockName) => { 11531 const clientIds = getClientIdsWithDescendants(state); 11532 if (!blockName) { 11533 return clientIds.length; 11534 } 11535 let count = 0; 11536 for (const clientId of clientIds) { 11537 const block = state.blocks.byClientId.get(clientId); 11538 if (block.name === blockName) { 11539 count++; 11540 } 11541 } 11542 return count; 11543 }, state => [state.blocks.order, state.blocks.byClientId]); 11544 11545 /** 11546 * Returns all blocks that match a blockName. Results include nested blocks. 11547 * 11548 * @param {Object} state Global application state. 11549 * @param {string[]} blockName Block name(s) for which clientIds are to be returned. 11550 * 11551 * @return {Array} Array of clientIds of blocks with name equal to blockName. 11552 */ 11553 const getBlocksByName = (0,external_wp_data_namespaceObject.createSelector)((state, blockName) => { 11554 if (!blockName) { 11555 return selectors_EMPTY_ARRAY; 11556 } 11557 const blockNames = Array.isArray(blockName) ? blockName : [blockName]; 11558 const clientIds = getClientIdsWithDescendants(state); 11559 const foundBlocks = clientIds.filter(clientId => { 11560 const block = state.blocks.byClientId.get(clientId); 11561 return blockNames.includes(block.name); 11562 }); 11563 return foundBlocks.length > 0 ? foundBlocks : selectors_EMPTY_ARRAY; 11564 }, state => [state.blocks.order, state.blocks.byClientId]); 11565 11566 /** 11567 * Returns all global blocks that match a blockName. Results include nested blocks. 11568 * 11569 * @deprecated 11570 * 11571 * @param {Object} state Global application state. 11572 * @param {string[]} blockName Block name(s) for which clientIds are to be returned. 11573 * 11574 * @return {Array} Array of clientIds of blocks with name equal to blockName. 11575 */ 11576 function __experimentalGetGlobalBlocksByName(state, blockName) { 11577 external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__experimentalGetGlobalBlocksByName", { 11578 since: '6.5', 11579 alternative: `wp.data.select( 'core/block-editor' ).getBlocksByName` 11580 }); 11581 return getBlocksByName(state, blockName); 11582 } 11583 11584 /** 11585 * Given an array of block client IDs, returns the corresponding array of block 11586 * objects. 11587 * 11588 * @param {Object} state Editor state. 11589 * @param {string[]} clientIds Client IDs for which blocks are to be returned. 11590 * 11591 * @return {WPBlock[]} Block objects. 11592 */ 11593 const getBlocksByClientId = (0,external_wp_data_namespaceObject.createSelector)((state, clientIds) => (Array.isArray(clientIds) ? clientIds : [clientIds]).map(clientId => getBlock(state, clientId)), (state, clientIds) => (Array.isArray(clientIds) ? clientIds : [clientIds]).map(clientId => state.blocks.tree.get(clientId))); 11594 11595 /** 11596 * Given an array of block client IDs, returns the corresponding array of block 11597 * names. 11598 * 11599 * @param {Object} state Editor state. 11600 * @param {string[]} clientIds Client IDs for which block names are to be returned. 11601 * 11602 * @return {string[]} Block names. 11603 */ 11604 const getBlockNamesByClientId = (0,external_wp_data_namespaceObject.createSelector)((state, clientIds) => getBlocksByClientId(state, clientIds).filter(Boolean).map(block => block.name), (state, clientIds) => getBlocksByClientId(state, clientIds)); 11605 11606 /** 11607 * Returns the number of blocks currently present in the post. 11608 * 11609 * @param {Object} state Editor state. 11610 * @param {?string} rootClientId Optional root client ID of block list. 11611 * 11612 * @return {number} Number of blocks in the post. 11613 */ 11614 function getBlockCount(state, rootClientId) { 11615 return getBlockOrder(state, rootClientId).length; 11616 } 11617 11618 /** 11619 * Returns the current selection start block client ID, attribute key and text 11620 * offset. 11621 * 11622 * @param {Object} state Block editor state. 11623 * 11624 * @return {WPBlockSelection} Selection start information. 11625 */ 11626 function getSelectionStart(state) { 11627 return state.selection.selectionStart; 11628 } 11629 11630 /** 11631 * Returns the current selection end block client ID, attribute key and text 11632 * offset. 11633 * 11634 * @param {Object} state Block editor state. 11635 * 11636 * @return {WPBlockSelection} Selection end information. 11637 */ 11638 function getSelectionEnd(state) { 11639 return state.selection.selectionEnd; 11640 } 11641 11642 /** 11643 * Returns the current block selection start. This value may be null, and it 11644 * may represent either a singular block selection or multi-selection start. 11645 * A selection is singular if its start and end match. 11646 * 11647 * @param {Object} state Global application state. 11648 * 11649 * @return {?string} Client ID of block selection start. 11650 */ 11651 function getBlockSelectionStart(state) { 11652 return state.selection.selectionStart.clientId; 11653 } 11654 11655 /** 11656 * Returns the current block selection end. This value may be null, and it 11657 * may represent either a singular block selection or multi-selection end. 11658 * A selection is singular if its start and end match. 11659 * 11660 * @param {Object} state Global application state. 11661 * 11662 * @return {?string} Client ID of block selection end. 11663 */ 11664 function getBlockSelectionEnd(state) { 11665 return state.selection.selectionEnd.clientId; 11666 } 11667 11668 /** 11669 * Returns the number of blocks currently selected in the post. 11670 * 11671 * @param {Object} state Global application state. 11672 * 11673 * @return {number} Number of blocks selected in the post. 11674 */ 11675 function getSelectedBlockCount(state) { 11676 const multiSelectedBlockCount = getMultiSelectedBlockClientIds(state).length; 11677 if (multiSelectedBlockCount) { 11678 return multiSelectedBlockCount; 11679 } 11680 return state.selection.selectionStart.clientId ? 1 : 0; 11681 } 11682 11683 /** 11684 * Returns true if there is a single selected block, or false otherwise. 11685 * 11686 * @param {Object} state Editor state. 11687 * 11688 * @return {boolean} Whether a single block is selected. 11689 */ 11690 function hasSelectedBlock(state) { 11691 const { 11692 selectionStart, 11693 selectionEnd 11694 } = state.selection; 11695 return !!selectionStart.clientId && selectionStart.clientId === selectionEnd.clientId; 11696 } 11697 11698 /** 11699 * Returns the currently selected block client ID, or null if there is no 11700 * selected block. 11701 * 11702 * @param {Object} state Editor state. 11703 * 11704 * @return {?string} Selected block client ID. 11705 */ 11706 function getSelectedBlockClientId(state) { 11707 const { 11708 selectionStart, 11709 selectionEnd 11710 } = state.selection; 11711 const { 11712 clientId 11713 } = selectionStart; 11714 if (!clientId || clientId !== selectionEnd.clientId) { 11715 return null; 11716 } 11717 return clientId; 11718 } 11719 11720 /** 11721 * Returns the currently selected block, or null if there is no selected block. 11722 * 11723 * @param {Object} state Global application state. 11724 * 11725 * @return {?Object} Selected block. 11726 */ 11727 function getSelectedBlock(state) { 11728 const clientId = getSelectedBlockClientId(state); 11729 return clientId ? getBlock(state, clientId) : null; 11730 } 11731 11732 /** 11733 * Given a block client ID, returns the root block from which the block is 11734 * nested, an empty string for top-level blocks, or null if the block does not 11735 * exist. 11736 * 11737 * @param {Object} state Editor state. 11738 * @param {string} clientId Block from which to find root client ID. 11739 * 11740 * @return {?string} Root client ID, if exists 11741 */ 11742 function getBlockRootClientId(state, clientId) { 11743 var _state$blocks$parents; 11744 return (_state$blocks$parents = state.blocks.parents.get(clientId)) !== null && _state$blocks$parents !== void 0 ? _state$blocks$parents : null; 11745 } 11746 11747 /** 11748 * Given a block client ID, returns the list of all its parents from top to bottom. 11749 * 11750 * @param {Object} state Editor state. 11751 * @param {string} clientId Block from which to find root client ID. 11752 * @param {boolean} ascending Order results from bottom to top (true) or top to bottom (false). 11753 * 11754 * @return {Array} ClientIDs of the parent blocks. 11755 */ 11756 const getBlockParents = (0,external_wp_data_namespaceObject.createSelector)((state, clientId, ascending = false) => { 11757 const parents = []; 11758 let current = clientId; 11759 while (current = state.blocks.parents.get(current)) { 11760 parents.push(current); 11761 } 11762 if (!parents.length) { 11763 return selectors_EMPTY_ARRAY; 11764 } 11765 return ascending ? parents : parents.reverse(); 11766 }, state => [state.blocks.parents]); 11767 11768 /** 11769 * Given a block client ID and a block name, returns the list of all its parents 11770 * from top to bottom, filtered by the given name(s). For example, if passed 11771 * 'core/group' as the blockName, it will only return parents which are group 11772 * blocks. If passed `[ 'core/group', 'core/cover']`, as the blockName, it will 11773 * return parents which are group blocks and parents which are cover blocks. 11774 * 11775 * @param {Object} state Editor state. 11776 * @param {string} clientId Block from which to find root client ID. 11777 * @param {string|string[]} blockName Block name(s) to filter. 11778 * @param {boolean} ascending Order results from bottom to top (true) or top to bottom (false). 11779 * 11780 * @return {Array} ClientIDs of the parent blocks. 11781 */ 11782 const getBlockParentsByBlockName = (0,external_wp_data_namespaceObject.createSelector)((state, clientId, blockName, ascending = false) => { 11783 const parents = getBlockParents(state, clientId, ascending); 11784 const hasName = Array.isArray(blockName) ? name => blockName.includes(name) : name => blockName === name; 11785 return parents.filter(id => hasName(getBlockName(state, id))); 11786 }, state => [state.blocks.parents]); 11787 /** 11788 * Given a block client ID, returns the root of the hierarchy from which the block is nested, return the block itself for root level blocks. 11789 * 11790 * @param {Object} state Editor state. 11791 * @param {string} clientId Block from which to find root client ID. 11792 * 11793 * @return {string} Root client ID 11794 */ 11795 function getBlockHierarchyRootClientId(state, clientId) { 11796 let current = clientId; 11797 let parent; 11798 do { 11799 parent = current; 11800 current = state.blocks.parents.get(current); 11801 } while (current); 11802 return parent; 11803 } 11804 11805 /** 11806 * Given a block client ID, returns the lowest common ancestor with selected client ID. 11807 * 11808 * @param {Object} state Editor state. 11809 * @param {string} clientId Block from which to find common ancestor client ID. 11810 * 11811 * @return {string} Common ancestor client ID or undefined 11812 */ 11813 function getLowestCommonAncestorWithSelectedBlock(state, clientId) { 11814 const selectedId = getSelectedBlockClientId(state); 11815 const clientParents = [...getBlockParents(state, clientId), clientId]; 11816 const selectedParents = [...getBlockParents(state, selectedId), selectedId]; 11817 let lowestCommonAncestor; 11818 const maxDepth = Math.min(clientParents.length, selectedParents.length); 11819 for (let index = 0; index < maxDepth; index++) { 11820 if (clientParents[index] === selectedParents[index]) { 11821 lowestCommonAncestor = clientParents[index]; 11822 } else { 11823 break; 11824 } 11825 } 11826 return lowestCommonAncestor; 11827 } 11828 11829 /** 11830 * Returns the client ID of the block adjacent one at the given reference 11831 * startClientId and modifier directionality. Defaults start startClientId to 11832 * the selected block, and direction as next block. Returns null if there is no 11833 * adjacent block. 11834 * 11835 * @param {Object} state Editor state. 11836 * @param {?string} startClientId Optional client ID of block from which to 11837 * search. 11838 * @param {?number} modifier Directionality multiplier (1 next, -1 11839 * previous). 11840 * 11841 * @return {?string} Return the client ID of the block, or null if none exists. 11842 */ 11843 function getAdjacentBlockClientId(state, startClientId, modifier = 1) { 11844 // Default to selected block. 11845 if (startClientId === undefined) { 11846 startClientId = getSelectedBlockClientId(state); 11847 } 11848 11849 // Try multi-selection starting at extent based on modifier. 11850 if (startClientId === undefined) { 11851 if (modifier < 0) { 11852 startClientId = getFirstMultiSelectedBlockClientId(state); 11853 } else { 11854 startClientId = getLastMultiSelectedBlockClientId(state); 11855 } 11856 } 11857 11858 // Validate working start client ID. 11859 if (!startClientId) { 11860 return null; 11861 } 11862 11863 // Retrieve start block root client ID, being careful to allow the falsey 11864 // empty string top-level root by explicitly testing against null. 11865 const rootClientId = getBlockRootClientId(state, startClientId); 11866 if (rootClientId === null) { 11867 return null; 11868 } 11869 const { 11870 order 11871 } = state.blocks; 11872 const orderSet = order.get(rootClientId); 11873 const index = orderSet.indexOf(startClientId); 11874 const nextIndex = index + 1 * modifier; 11875 11876 // Block was first in set and we're attempting to get previous. 11877 if (nextIndex < 0) { 11878 return null; 11879 } 11880 11881 // Block was last in set and we're attempting to get next. 11882 if (nextIndex === orderSet.length) { 11883 return null; 11884 } 11885 11886 // Assume incremented index is within the set. 11887 return orderSet[nextIndex]; 11888 } 11889 11890 /** 11891 * Returns the previous block's client ID from the given reference start ID. 11892 * Defaults start to the selected block. Returns null if there is no previous 11893 * block. 11894 * 11895 * @param {Object} state Editor state. 11896 * @param {?string} startClientId Optional client ID of block from which to 11897 * search. 11898 * 11899 * @return {?string} Adjacent block's client ID, or null if none exists. 11900 */ 11901 function getPreviousBlockClientId(state, startClientId) { 11902 return getAdjacentBlockClientId(state, startClientId, -1); 11903 } 11904 11905 /** 11906 * Returns the next block's client ID from the given reference start ID. 11907 * Defaults start to the selected block. Returns null if there is no next 11908 * block. 11909 * 11910 * @param {Object} state Editor state. 11911 * @param {?string} startClientId Optional client ID of block from which to 11912 * search. 11913 * 11914 * @return {?string} Adjacent block's client ID, or null if none exists. 11915 */ 11916 function getNextBlockClientId(state, startClientId) { 11917 return getAdjacentBlockClientId(state, startClientId, 1); 11918 } 11919 11920 /* eslint-disable jsdoc/valid-types */ 11921 /** 11922 * Returns the initial caret position for the selected block. 11923 * This position is to used to position the caret properly when the selected block changes. 11924 * If the current block is not a RichText, having initial position set to 0 means "focus block" 11925 * 11926 * @param {Object} state Global application state. 11927 * 11928 * @return {0|-1|null} Initial position. 11929 */ 11930 function getSelectedBlocksInitialCaretPosition(state) { 11931 /* eslint-enable jsdoc/valid-types */ 11932 return state.initialPosition; 11933 } 11934 11935 /** 11936 * Returns the current selection set of block client IDs (multiselection or single selection). 11937 * 11938 * @param {Object} state Editor state. 11939 * 11940 * @return {Array} Multi-selected block client IDs. 11941 */ 11942 const getSelectedBlockClientIds = (0,external_wp_data_namespaceObject.createSelector)(state => { 11943 const { 11944 selectionStart, 11945 selectionEnd 11946 } = state.selection; 11947 if (!selectionStart.clientId || !selectionEnd.clientId) { 11948 return selectors_EMPTY_ARRAY; 11949 } 11950 if (selectionStart.clientId === selectionEnd.clientId) { 11951 return [selectionStart.clientId]; 11952 } 11953 11954 // Retrieve root client ID to aid in retrieving relevant nested block 11955 // order, being careful to allow the falsey empty string top-level root 11956 // by explicitly testing against null. 11957 const rootClientId = getBlockRootClientId(state, selectionStart.clientId); 11958 if (rootClientId === null) { 11959 return selectors_EMPTY_ARRAY; 11960 } 11961 const blockOrder = getBlockOrder(state, rootClientId); 11962 const startIndex = blockOrder.indexOf(selectionStart.clientId); 11963 const endIndex = blockOrder.indexOf(selectionEnd.clientId); 11964 if (startIndex > endIndex) { 11965 return blockOrder.slice(endIndex, startIndex + 1); 11966 } 11967 return blockOrder.slice(startIndex, endIndex + 1); 11968 }, state => [state.blocks.order, state.selection.selectionStart.clientId, state.selection.selectionEnd.clientId]); 11969 11970 /** 11971 * Returns the current multi-selection set of block client IDs, or an empty 11972 * array if there is no multi-selection. 11973 * 11974 * @param {Object} state Editor state. 11975 * 11976 * @return {Array} Multi-selected block client IDs. 11977 */ 11978 function getMultiSelectedBlockClientIds(state) { 11979 const { 11980 selectionStart, 11981 selectionEnd 11982 } = state.selection; 11983 if (selectionStart.clientId === selectionEnd.clientId) { 11984 return selectors_EMPTY_ARRAY; 11985 } 11986 return getSelectedBlockClientIds(state); 11987 } 11988 11989 /** 11990 * Returns the current multi-selection set of blocks, or an empty array if 11991 * there is no multi-selection. 11992 * 11993 * @param {Object} state Editor state. 11994 * 11995 * @return {Array} Multi-selected block objects. 11996 */ 11997 const getMultiSelectedBlocks = (0,external_wp_data_namespaceObject.createSelector)(state => { 11998 const multiSelectedBlockClientIds = getMultiSelectedBlockClientIds(state); 11999 if (!multiSelectedBlockClientIds.length) { 12000 return selectors_EMPTY_ARRAY; 12001 } 12002 return multiSelectedBlockClientIds.map(clientId => getBlock(state, clientId)); 12003 }, state => [...getSelectedBlockClientIds.getDependants(state), state.blocks.byClientId, state.blocks.order, state.blocks.attributes]); 12004 12005 /** 12006 * Returns the client ID of the first block in the multi-selection set, or null 12007 * if there is no multi-selection. 12008 * 12009 * @param {Object} state Editor state. 12010 * 12011 * @return {?string} First block client ID in the multi-selection set. 12012 */ 12013 function getFirstMultiSelectedBlockClientId(state) { 12014 return getMultiSelectedBlockClientIds(state)[0] || null; 12015 } 12016 12017 /** 12018 * Returns the client ID of the last block in the multi-selection set, or null 12019 * if there is no multi-selection. 12020 * 12021 * @param {Object} state Editor state. 12022 * 12023 * @return {?string} Last block client ID in the multi-selection set. 12024 */ 12025 function getLastMultiSelectedBlockClientId(state) { 12026 const selectedClientIds = getMultiSelectedBlockClientIds(state); 12027 return selectedClientIds[selectedClientIds.length - 1] || null; 12028 } 12029 12030 /** 12031 * Returns true if a multi-selection exists, and the block corresponding to the 12032 * specified client ID is the first block of the multi-selection set, or false 12033 * otherwise. 12034 * 12035 * @param {Object} state Editor state. 12036 * @param {string} clientId Block client ID. 12037 * 12038 * @return {boolean} Whether block is first in multi-selection. 12039 */ 12040 function isFirstMultiSelectedBlock(state, clientId) { 12041 return getFirstMultiSelectedBlockClientId(state) === clientId; 12042 } 12043 12044 /** 12045 * Returns true if the client ID occurs within the block multi-selection, or 12046 * false otherwise. 12047 * 12048 * @param {Object} state Editor state. 12049 * @param {string} clientId Block client ID. 12050 * 12051 * @return {boolean} Whether block is in multi-selection set. 12052 */ 12053 function isBlockMultiSelected(state, clientId) { 12054 return getMultiSelectedBlockClientIds(state).indexOf(clientId) !== -1; 12055 } 12056 12057 /** 12058 * Returns true if an ancestor of the block is multi-selected, or false 12059 * otherwise. 12060 * 12061 * @param {Object} state Editor state. 12062 * @param {string} clientId Block client ID. 12063 * 12064 * @return {boolean} Whether an ancestor of the block is in multi-selection 12065 * set. 12066 */ 12067 const isAncestorMultiSelected = (0,external_wp_data_namespaceObject.createSelector)((state, clientId) => { 12068 let ancestorClientId = clientId; 12069 let isMultiSelected = false; 12070 while (ancestorClientId && !isMultiSelected) { 12071 ancestorClientId = getBlockRootClientId(state, ancestorClientId); 12072 isMultiSelected = isBlockMultiSelected(state, ancestorClientId); 12073 } 12074 return isMultiSelected; 12075 }, state => [state.blocks.order, state.selection.selectionStart.clientId, state.selection.selectionEnd.clientId]); 12076 12077 /** 12078 * Returns the client ID of the block which begins the multi-selection set, or 12079 * null if there is no multi-selection. 12080 * 12081 * This is not necessarily the first client ID in the selection. 12082 * 12083 * @see getFirstMultiSelectedBlockClientId 12084 * 12085 * @param {Object} state Editor state. 12086 * 12087 * @return {?string} Client ID of block beginning multi-selection. 12088 */ 12089 function getMultiSelectedBlocksStartClientId(state) { 12090 const { 12091 selectionStart, 12092 selectionEnd 12093 } = state.selection; 12094 if (selectionStart.clientId === selectionEnd.clientId) { 12095 return null; 12096 } 12097 return selectionStart.clientId || null; 12098 } 12099 12100 /** 12101 * Returns the client ID of the block which ends the multi-selection set, or 12102 * null if there is no multi-selection. 12103 * 12104 * This is not necessarily the last client ID in the selection. 12105 * 12106 * @see getLastMultiSelectedBlockClientId 12107 * 12108 * @param {Object} state Editor state. 12109 * 12110 * @return {?string} Client ID of block ending multi-selection. 12111 */ 12112 function getMultiSelectedBlocksEndClientId(state) { 12113 const { 12114 selectionStart, 12115 selectionEnd 12116 } = state.selection; 12117 if (selectionStart.clientId === selectionEnd.clientId) { 12118 return null; 12119 } 12120 return selectionEnd.clientId || null; 12121 } 12122 12123 /** 12124 * Returns true if the selection is not partial. 12125 * 12126 * @param {Object} state Editor state. 12127 * 12128 * @return {boolean} Whether the selection is mergeable. 12129 */ 12130 function __unstableIsFullySelected(state) { 12131 const selectionAnchor = getSelectionStart(state); 12132 const selectionFocus = getSelectionEnd(state); 12133 return !selectionAnchor.attributeKey && !selectionFocus.attributeKey && typeof selectionAnchor.offset === 'undefined' && typeof selectionFocus.offset === 'undefined'; 12134 } 12135 12136 /** 12137 * Returns true if the selection is collapsed. 12138 * 12139 * @param {Object} state Editor state. 12140 * 12141 * @return {boolean} Whether the selection is collapsed. 12142 */ 12143 function __unstableIsSelectionCollapsed(state) { 12144 const selectionAnchor = getSelectionStart(state); 12145 const selectionFocus = getSelectionEnd(state); 12146 return !!selectionAnchor && !!selectionFocus && selectionAnchor.clientId === selectionFocus.clientId && selectionAnchor.attributeKey === selectionFocus.attributeKey && selectionAnchor.offset === selectionFocus.offset; 12147 } 12148 function __unstableSelectionHasUnmergeableBlock(state) { 12149 return getSelectedBlockClientIds(state).some(clientId => { 12150 const blockName = getBlockName(state, clientId); 12151 const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName); 12152 return !blockType.merge; 12153 }); 12154 } 12155 12156 /** 12157 * Check whether the selection is mergeable. 12158 * 12159 * @param {Object} state Editor state. 12160 * @param {boolean} isForward Whether to merge forwards. 12161 * 12162 * @return {boolean} Whether the selection is mergeable. 12163 */ 12164 function __unstableIsSelectionMergeable(state, isForward) { 12165 const selectionAnchor = getSelectionStart(state); 12166 const selectionFocus = getSelectionEnd(state); 12167 12168 // It's not mergeable if the start and end are within the same block. 12169 if (selectionAnchor.clientId === selectionFocus.clientId) { 12170 return false; 12171 } 12172 12173 // It's not mergeable if there's no rich text selection. 12174 if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === 'undefined' || typeof selectionFocus.offset === 'undefined') { 12175 return false; 12176 } 12177 const anchorRootClientId = getBlockRootClientId(state, selectionAnchor.clientId); 12178 const focusRootClientId = getBlockRootClientId(state, selectionFocus.clientId); 12179 12180 // It's not mergeable if the selection doesn't start and end in the same 12181 // block list. Maybe in the future it should be allowed. 12182 if (anchorRootClientId !== focusRootClientId) { 12183 return false; 12184 } 12185 const blockOrder = getBlockOrder(state, anchorRootClientId); 12186 const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId); 12187 const focusIndex = blockOrder.indexOf(selectionFocus.clientId); 12188 12189 // Reassign selection start and end based on order. 12190 let selectionStart, selectionEnd; 12191 if (anchorIndex > focusIndex) { 12192 selectionStart = selectionFocus; 12193 selectionEnd = selectionAnchor; 12194 } else { 12195 selectionStart = selectionAnchor; 12196 selectionEnd = selectionFocus; 12197 } 12198 const targetBlockClientId = isForward ? selectionEnd.clientId : selectionStart.clientId; 12199 const blockToMergeClientId = isForward ? selectionStart.clientId : selectionEnd.clientId; 12200 const targetBlockName = getBlockName(state, targetBlockClientId); 12201 const targetBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(targetBlockName); 12202 if (!targetBlockType.merge) { 12203 return false; 12204 } 12205 const blockToMerge = getBlock(state, blockToMergeClientId); 12206 12207 // It's mergeable if the blocks are of the same type. 12208 if (blockToMerge.name === targetBlockName) { 12209 return true; 12210 } 12211 12212 // If the blocks are of a different type, try to transform the block being 12213 // merged into the same type of block. 12214 const blocksToMerge = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blockToMerge, targetBlockName); 12215 return blocksToMerge && blocksToMerge.length; 12216 } 12217 12218 /** 12219 * Get partial selected blocks with their content updated 12220 * based on the selection. 12221 * 12222 * @param {Object} state Editor state. 12223 * 12224 * @return {Object[]} Updated partial selected blocks. 12225 */ 12226 const __unstableGetSelectedBlocksWithPartialSelection = state => { 12227 const selectionAnchor = getSelectionStart(state); 12228 const selectionFocus = getSelectionEnd(state); 12229 if (selectionAnchor.clientId === selectionFocus.clientId) { 12230 return selectors_EMPTY_ARRAY; 12231 } 12232 12233 // Can't split if the selection is not set. 12234 if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === 'undefined' || typeof selectionFocus.offset === 'undefined') { 12235 return selectors_EMPTY_ARRAY; 12236 } 12237 const anchorRootClientId = getBlockRootClientId(state, selectionAnchor.clientId); 12238 const focusRootClientId = getBlockRootClientId(state, selectionFocus.clientId); 12239 12240 // It's not splittable if the selection doesn't start and end in the same 12241 // block list. Maybe in the future it should be allowed. 12242 if (anchorRootClientId !== focusRootClientId) { 12243 return selectors_EMPTY_ARRAY; 12244 } 12245 const blockOrder = getBlockOrder(state, anchorRootClientId); 12246 const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId); 12247 const focusIndex = blockOrder.indexOf(selectionFocus.clientId); 12248 12249 // Reassign selection start and end based on order. 12250 const [selectionStart, selectionEnd] = anchorIndex > focusIndex ? [selectionFocus, selectionAnchor] : [selectionAnchor, selectionFocus]; 12251 const blockA = getBlock(state, selectionStart.clientId); 12252 const blockB = getBlock(state, selectionEnd.clientId); 12253 const htmlA = blockA.attributes[selectionStart.attributeKey]; 12254 const htmlB = blockB.attributes[selectionEnd.attributeKey]; 12255 let valueA = (0,external_wp_richText_namespaceObject.create)({ 12256 html: htmlA 12257 }); 12258 let valueB = (0,external_wp_richText_namespaceObject.create)({ 12259 html: htmlB 12260 }); 12261 valueA = (0,external_wp_richText_namespaceObject.remove)(valueA, 0, selectionStart.offset); 12262 valueB = (0,external_wp_richText_namespaceObject.remove)(valueB, selectionEnd.offset, valueB.text.length); 12263 return [{ 12264 ...blockA, 12265 attributes: { 12266 ...blockA.attributes, 12267 [selectionStart.attributeKey]: (0,external_wp_richText_namespaceObject.toHTMLString)({ 12268 value: valueA 12269 }) 12270 } 12271 }, { 12272 ...blockB, 12273 attributes: { 12274 ...blockB.attributes, 12275 [selectionEnd.attributeKey]: (0,external_wp_richText_namespaceObject.toHTMLString)({ 12276 value: valueB 12277 }) 12278 } 12279 }]; 12280 }; 12281 12282 /** 12283 * Returns an array containing all block client IDs in the editor in the order 12284 * they appear. Optionally accepts a root client ID of the block list for which 12285 * the order should be returned, defaulting to the top-level block order. 12286 * 12287 * @param {Object} state Editor state. 12288 * @param {?string} rootClientId Optional root client ID of block list. 12289 * 12290 * @return {Array} Ordered client IDs of editor blocks. 12291 */ 12292 function getBlockOrder(state, rootClientId) { 12293 return state.blocks.order.get(rootClientId || '') || selectors_EMPTY_ARRAY; 12294 } 12295 12296 /** 12297 * Returns the index at which the block corresponding to the specified client 12298 * ID occurs within the block order, or `-1` if the block does not exist. 12299 * 12300 * @param {Object} state Editor state. 12301 * @param {string} clientId Block client ID. 12302 * 12303 * @return {number} Index at which block exists in order. 12304 */ 12305 function getBlockIndex(state, clientId) { 12306 const rootClientId = getBlockRootClientId(state, clientId); 12307 return getBlockOrder(state, rootClientId).indexOf(clientId); 12308 } 12309 12310 /** 12311 * Returns true if the block corresponding to the specified client ID is 12312 * currently selected and no multi-selection exists, or false otherwise. 12313 * 12314 * @param {Object} state Editor state. 12315 * @param {string} clientId Block client ID. 12316 * 12317 * @return {boolean} Whether block is selected and multi-selection exists. 12318 */ 12319 function isBlockSelected(state, clientId) { 12320 const { 12321 selectionStart, 12322 selectionEnd 12323 } = state.selection; 12324 if (selectionStart.clientId !== selectionEnd.clientId) { 12325 return false; 12326 } 12327 return selectionStart.clientId === clientId; 12328 } 12329 12330 /** 12331 * Returns true if one of the block's inner blocks is selected. 12332 * 12333 * @param {Object} state Editor state. 12334 * @param {string} clientId Block client ID. 12335 * @param {boolean} deep Perform a deep check. 12336 * 12337 * @return {boolean} Whether the block has an inner block selected 12338 */ 12339 function hasSelectedInnerBlock(state, clientId, deep = false) { 12340 const selectedBlockClientIds = getSelectedBlockClientIds(state); 12341 if (!selectedBlockClientIds.length) { 12342 return false; 12343 } 12344 if (deep) { 12345 return selectedBlockClientIds.some(id => 12346 // Pass true because we don't care about order and it's more 12347 // performant. 12348 getBlockParents(state, id, true).includes(clientId)); 12349 } 12350 return selectedBlockClientIds.some(id => getBlockRootClientId(state, id) === clientId); 12351 } 12352 12353 /** 12354 * Returns true if one of the block's inner blocks is dragged. 12355 * 12356 * @param {Object} state Editor state. 12357 * @param {string} clientId Block client ID. 12358 * @param {boolean} deep Perform a deep check. 12359 * 12360 * @return {boolean} Whether the block has an inner block dragged 12361 */ 12362 function hasDraggedInnerBlock(state, clientId, deep = false) { 12363 return getBlockOrder(state, clientId).some(innerClientId => isBlockBeingDragged(state, innerClientId) || deep && hasDraggedInnerBlock(state, innerClientId, deep)); 12364 } 12365 12366 /** 12367 * Returns true if the block corresponding to the specified client ID is 12368 * currently selected but isn't the last of the selected blocks. Here "last" 12369 * refers to the block sequence in the document, _not_ the sequence of 12370 * multi-selection, which is why `state.selectionEnd` isn't used. 12371 * 12372 * @param {Object} state Editor state. 12373 * @param {string} clientId Block client ID. 12374 * 12375 * @return {boolean} Whether block is selected and not the last in the 12376 * selection. 12377 */ 12378 function isBlockWithinSelection(state, clientId) { 12379 if (!clientId) { 12380 return false; 12381 } 12382 const clientIds = getMultiSelectedBlockClientIds(state); 12383 const index = clientIds.indexOf(clientId); 12384 return index > -1 && index < clientIds.length - 1; 12385 } 12386 12387 /** 12388 * Returns true if a multi-selection has been made, or false otherwise. 12389 * 12390 * @param {Object} state Editor state. 12391 * 12392 * @return {boolean} Whether multi-selection has been made. 12393 */ 12394 function hasMultiSelection(state) { 12395 const { 12396 selectionStart, 12397 selectionEnd 12398 } = state.selection; 12399 return selectionStart.clientId !== selectionEnd.clientId; 12400 } 12401 12402 /** 12403 * Whether in the process of multi-selecting or not. This flag is only true 12404 * while the multi-selection is being selected (by mouse move), and is false 12405 * once the multi-selection has been settled. 12406 * 12407 * @see hasMultiSelection 12408 * 12409 * @param {Object} state Global application state. 12410 * 12411 * @return {boolean} True if multi-selecting, false if not. 12412 */ 12413 function selectors_isMultiSelecting(state) { 12414 return state.isMultiSelecting; 12415 } 12416 12417 /** 12418 * Selector that returns if multi-selection is enabled or not. 12419 * 12420 * @param {Object} state Global application state. 12421 * 12422 * @return {boolean} True if it should be possible to multi-select blocks, false if multi-selection is disabled. 12423 */ 12424 function selectors_isSelectionEnabled(state) { 12425 return state.isSelectionEnabled; 12426 } 12427 12428 /** 12429 * Returns the block's editing mode, defaulting to "visual" if not explicitly 12430 * assigned. 12431 * 12432 * @param {Object} state Editor state. 12433 * @param {string} clientId Block client ID. 12434 * 12435 * @return {Object} Block editing mode. 12436 */ 12437 function getBlockMode(state, clientId) { 12438 return state.blocksMode[clientId] || 'visual'; 12439 } 12440 12441 /** 12442 * Returns true if the user is typing, or false otherwise. 12443 * 12444 * @param {Object} state Global application state. 12445 * 12446 * @return {boolean} Whether user is typing. 12447 */ 12448 function selectors_isTyping(state) { 12449 return state.isTyping; 12450 } 12451 12452 /** 12453 * Returns true if the user is dragging blocks, or false otherwise. 12454 * 12455 * @param {Object} state Global application state. 12456 * 12457 * @return {boolean} Whether user is dragging blocks. 12458 */ 12459 function isDraggingBlocks(state) { 12460 return !!state.draggedBlocks.length; 12461 } 12462 12463 /** 12464 * Returns the client ids of any blocks being directly dragged. 12465 * 12466 * This does not include children of a parent being dragged. 12467 * 12468 * @param {Object} state Global application state. 12469 * 12470 * @return {string[]} Array of dragged block client ids. 12471 */ 12472 function getDraggedBlockClientIds(state) { 12473 return state.draggedBlocks; 12474 } 12475 12476 /** 12477 * Returns whether the block is being dragged. 12478 * 12479 * Only returns true if the block is being directly dragged, 12480 * not if the block is a child of a parent being dragged. 12481 * See `isAncestorBeingDragged` for child blocks. 12482 * 12483 * @param {Object} state Global application state. 12484 * @param {string} clientId Client id for block to check. 12485 * 12486 * @return {boolean} Whether the block is being dragged. 12487 */ 12488 function isBlockBeingDragged(state, clientId) { 12489 return state.draggedBlocks.includes(clientId); 12490 } 12491 12492 /** 12493 * Returns whether a parent/ancestor of the block is being dragged. 12494 * 12495 * @param {Object} state Global application state. 12496 * @param {string} clientId Client id for block to check. 12497 * 12498 * @return {boolean} Whether the block's ancestor is being dragged. 12499 */ 12500 function isAncestorBeingDragged(state, clientId) { 12501 // Return early if no blocks are being dragged rather than 12502 // the more expensive check for parents. 12503 if (!isDraggingBlocks(state)) { 12504 return false; 12505 } 12506 const parents = getBlockParents(state, clientId); 12507 return parents.some(parentClientId => isBlockBeingDragged(state, parentClientId)); 12508 } 12509 12510 /** 12511 * Returns true if the caret is within formatted text, or false otherwise. 12512 * 12513 * @deprecated 12514 * 12515 * @return {boolean} Whether the caret is within formatted text. 12516 */ 12517 function isCaretWithinFormattedText() { 12518 external_wp_deprecated_default()('wp.data.select( "core/block-editor" ).isCaretWithinFormattedText', { 12519 since: '6.1', 12520 version: '6.3' 12521 }); 12522 return false; 12523 } 12524 12525 /** 12526 * Returns the insertion point, the index at which the new inserted block would 12527 * be placed. Defaults to the last index. 12528 * 12529 * @param {Object} state Editor state. 12530 * 12531 * @return {Object} Insertion point object with `rootClientId`, `index`. 12532 */ 12533 const getBlockInsertionPoint = (0,external_wp_data_namespaceObject.createSelector)(state => { 12534 let rootClientId, index; 12535 const { 12536 insertionPoint, 12537 selection: { 12538 selectionEnd 12539 } 12540 } = state; 12541 if (insertionPoint !== null) { 12542 return insertionPoint; 12543 } 12544 const { 12545 clientId 12546 } = selectionEnd; 12547 if (clientId) { 12548 rootClientId = getBlockRootClientId(state, clientId) || undefined; 12549 index = getBlockIndex(state, selectionEnd.clientId) + 1; 12550 } else { 12551 index = getBlockOrder(state).length; 12552 } 12553 return { 12554 rootClientId, 12555 index 12556 }; 12557 }, state => [state.insertionPoint, state.selection.selectionEnd.clientId, state.blocks.parents, state.blocks.order]); 12558 12559 /** 12560 * Returns true if we should show the block insertion point. 12561 * 12562 * @param {Object} state Global application state. 12563 * 12564 * @return {?boolean} Whether the insertion point is visible or not. 12565 */ 12566 function isBlockInsertionPointVisible(state) { 12567 return state.insertionPoint !== null; 12568 } 12569 12570 /** 12571 * Returns whether the blocks matches the template or not. 12572 * 12573 * @param {boolean} state 12574 * @return {?boolean} Whether the template is valid or not. 12575 */ 12576 function isValidTemplate(state) { 12577 return state.template.isValid; 12578 } 12579 12580 /** 12581 * Returns the defined block template 12582 * 12583 * @param {boolean} state 12584 * 12585 * @return {?Array} Block Template. 12586 */ 12587 function getTemplate(state) { 12588 return state.settings.template; 12589 } 12590 12591 /** 12592 * Returns the defined block template lock. Optionally accepts a root block 12593 * client ID as context, otherwise defaulting to the global context. 12594 * 12595 * @param {Object} state Editor state. 12596 * @param {?string} rootClientId Optional block root client ID. 12597 * 12598 * @return {string|false} Block Template Lock 12599 */ 12600 function getTemplateLock(state, rootClientId) { 12601 var _getBlockListSettings; 12602 if (!rootClientId) { 12603 var _state$settings$templ; 12604 return (_state$settings$templ = state.settings.templateLock) !== null && _state$settings$templ !== void 0 ? _state$settings$templ : false; 12605 } 12606 return (_getBlockListSettings = getBlockListSettings(state, rootClientId)?.templateLock) !== null && _getBlockListSettings !== void 0 ? _getBlockListSettings : false; 12607 } 12608 12609 /** 12610 * Determines if the given block type is allowed to be inserted into the block list. 12611 * This function is not exported and not memoized because using a memoized selector 12612 * inside another memoized selector is just a waste of time. 12613 * 12614 * @param {Object} state Editor state. 12615 * @param {string|Object} blockName The block type object, e.g., the response 12616 * from the block directory; or a string name of 12617 * an installed block type, e.g.' core/paragraph'. 12618 * @param {?string} rootClientId Optional root client ID of block list. 12619 * 12620 * @return {boolean} Whether the given block type is allowed to be inserted. 12621 */ 12622 const canInsertBlockTypeUnmemoized = (state, blockName, rootClientId = null) => { 12623 let blockType; 12624 if (blockName && 'object' === typeof blockName) { 12625 blockType = blockName; 12626 blockName = blockType.name; 12627 } else { 12628 blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName); 12629 } 12630 if (!blockType) { 12631 return false; 12632 } 12633 const { 12634 allowedBlockTypes 12635 } = getSettings(state); 12636 const isBlockAllowedInEditor = checkAllowList(allowedBlockTypes, blockName, true); 12637 if (!isBlockAllowedInEditor) { 12638 return false; 12639 } 12640 const isLocked = !!getTemplateLock(state, rootClientId); 12641 if (isLocked) { 12642 return false; 12643 } 12644 if (getBlockEditingMode(state, rootClientId !== null && rootClientId !== void 0 ? rootClientId : '') === 'disabled') { 12645 return false; 12646 } 12647 const parentBlockListSettings = getBlockListSettings(state, rootClientId); 12648 12649 // The parent block doesn't have settings indicating it doesn't support 12650 // inner blocks, return false. 12651 if (rootClientId && parentBlockListSettings === undefined) { 12652 return false; 12653 } 12654 const parentName = getBlockName(state, rootClientId); 12655 const parentBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(parentName); 12656 12657 // Look at the `blockType.allowedBlocks` field to determine whether this is an allowed child block. 12658 const parentAllowedChildBlocks = parentBlockType?.allowedBlocks; 12659 let hasParentAllowedBlock = checkAllowList(parentAllowedChildBlocks, blockName); 12660 12661 // The `allowedBlocks` block list setting can further limit which blocks are allowed children. 12662 if (hasParentAllowedBlock !== false) { 12663 const parentAllowedBlocks = parentBlockListSettings?.allowedBlocks; 12664 const hasParentListAllowedBlock = checkAllowList(parentAllowedBlocks, blockName); 12665 // Never downgrade the result from `true` to `null` 12666 if (hasParentListAllowedBlock !== null) { 12667 hasParentAllowedBlock = hasParentListAllowedBlock; 12668 } 12669 } 12670 const blockAllowedParentBlocks = blockType.parent; 12671 const hasBlockAllowedParent = checkAllowList(blockAllowedParentBlocks, parentName); 12672 let hasBlockAllowedAncestor = true; 12673 const blockAllowedAncestorBlocks = blockType.ancestor; 12674 if (blockAllowedAncestorBlocks) { 12675 const ancestors = [rootClientId, ...getBlockParents(state, rootClientId)]; 12676 hasBlockAllowedAncestor = ancestors.some(ancestorClientId => checkAllowList(blockAllowedAncestorBlocks, getBlockName(state, ancestorClientId))); 12677 } 12678 const canInsert = hasBlockAllowedAncestor && (hasParentAllowedBlock === null && hasBlockAllowedParent === null || hasParentAllowedBlock === true || hasBlockAllowedParent === true); 12679 if (!canInsert) { 12680 return canInsert; 12681 } 12682 12683 /** 12684 * This filter is an ad-hoc solution to prevent adding template parts inside post content. 12685 * Conceptually, having a filter inside a selector is bad pattern so this code will be 12686 * replaced by a declarative API that doesn't the following drawbacks: 12687 * 12688 * Filters are not reactive: Upon switching between "template mode" and non "template mode", 12689 * the filter and selector won't necessarily be executed again. For now, it doesn't matter much 12690 * because you can't switch between the two modes while the inserter stays open. 12691 * 12692 * Filters are global: Once they're defined, they will affect all editor instances and all registries. 12693 * An ideal API would only affect specific editor instances. 12694 */ 12695 return (0,external_wp_hooks_namespaceObject.applyFilters)('blockEditor.__unstableCanInsertBlockType', canInsert, blockType, rootClientId, { 12696 // Pass bound selectors of the current registry. If we're in a nested 12697 // context, the data will differ from the one selected from the root 12698 // registry. 12699 getBlock: getBlock.bind(null, state), 12700 getBlockParentsByBlockName: getBlockParentsByBlockName.bind(null, state) 12701 }); 12702 }; 12703 12704 /** 12705 * Determines if the given block type is allowed to be inserted into the block list. 12706 * 12707 * @param {Object} state Editor state. 12708 * @param {string} blockName The name of the block type, e.g.' core/paragraph'. 12709 * @param {?string} rootClientId Optional root client ID of block list. 12710 * 12711 * @return {boolean} Whether the given block type is allowed to be inserted. 12712 */ 12713 const canInsertBlockType = (0,external_wp_data_namespaceObject.createSelector)(canInsertBlockTypeUnmemoized, (state, blockName, rootClientId) => getInsertBlockTypeDependants(state, rootClientId)); 12714 12715 /** 12716 * Determines if the given blocks are allowed to be inserted into the block 12717 * list. 12718 * 12719 * @param {Object} state Editor state. 12720 * @param {string} clientIds The block client IDs to be inserted. 12721 * @param {?string} rootClientId Optional root client ID of block list. 12722 * 12723 * @return {boolean} Whether the given blocks are allowed to be inserted. 12724 */ 12725 function canInsertBlocks(state, clientIds, rootClientId = null) { 12726 return clientIds.every(id => canInsertBlockType(state, getBlockName(state, id), rootClientId)); 12727 } 12728 12729 /** 12730 * Determines if the given block is allowed to be deleted. 12731 * 12732 * @param {Object} state Editor state. 12733 * @param {string} clientId The block client Id. 12734 * 12735 * @return {boolean} Whether the given block is allowed to be removed. 12736 */ 12737 function canRemoveBlock(state, clientId) { 12738 const attributes = getBlockAttributes(state, clientId); 12739 if (attributes === null) { 12740 return true; 12741 } 12742 if (attributes.lock?.remove !== undefined) { 12743 return !attributes.lock.remove; 12744 } 12745 const rootClientId = getBlockRootClientId(state, clientId); 12746 if (getTemplateLock(state, rootClientId)) { 12747 return false; 12748 } 12749 return getBlockEditingMode(state, rootClientId) !== 'disabled'; 12750 } 12751 12752 /** 12753 * Determines if the given blocks are allowed to be removed. 12754 * 12755 * @param {Object} state Editor state. 12756 * @param {string} clientIds The block client IDs to be removed. 12757 * 12758 * @return {boolean} Whether the given blocks are allowed to be removed. 12759 */ 12760 function canRemoveBlocks(state, clientIds) { 12761 return clientIds.every(clientId => canRemoveBlock(state, clientId)); 12762 } 12763 12764 /** 12765 * Determines if the given block is allowed to be moved. 12766 * 12767 * @param {Object} state Editor state. 12768 * @param {string} clientId The block client Id. 12769 * 12770 * @return {boolean} Whether the given block is allowed to be moved. 12771 */ 12772 function canMoveBlock(state, clientId) { 12773 const attributes = getBlockAttributes(state, clientId); 12774 if (attributes === null) { 12775 return true; 12776 } 12777 if (attributes.lock?.move !== undefined) { 12778 return !attributes.lock.move; 12779 } 12780 const rootClientId = getBlockRootClientId(state, clientId); 12781 if (getTemplateLock(state, rootClientId) === 'all') { 12782 return false; 12783 } 12784 return getBlockEditingMode(state, rootClientId) !== 'disabled'; 12785 } 12786 12787 /** 12788 * Determines if the given blocks are allowed to be moved. 12789 * 12790 * @param {Object} state Editor state. 12791 * @param {string} clientIds The block client IDs to be moved. 12792 * 12793 * @return {boolean} Whether the given blocks are allowed to be moved. 12794 */ 12795 function canMoveBlocks(state, clientIds) { 12796 return clientIds.every(clientId => canMoveBlock(state, clientId)); 12797 } 12798 12799 /** 12800 * Determines if the given block is allowed to be edited. 12801 * 12802 * @param {Object} state Editor state. 12803 * @param {string} clientId The block client Id. 12804 * 12805 * @return {boolean} Whether the given block is allowed to be edited. 12806 */ 12807 function canEditBlock(state, clientId) { 12808 const attributes = getBlockAttributes(state, clientId); 12809 if (attributes === null) { 12810 return true; 12811 } 12812 const { 12813 lock 12814 } = attributes; 12815 12816 // When the edit is true, we cannot edit the block. 12817 return !lock?.edit; 12818 } 12819 12820 /** 12821 * Determines if the given block type can be locked/unlocked by a user. 12822 * 12823 * @param {Object} state Editor state. 12824 * @param {(string|Object)} nameOrType Block name or type object. 12825 * 12826 * @return {boolean} Whether a given block type can be locked/unlocked. 12827 */ 12828 function canLockBlockType(state, nameOrType) { 12829 if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, 'lock', true)) { 12830 return false; 12831 } 12832 12833 // Use block editor settings as the default value. 12834 return !!state.settings?.canLockBlocks; 12835 } 12836 12837 /** 12838 * Returns information about how recently and frequently a block has been inserted. 12839 * 12840 * @param {Object} state Global application state. 12841 * @param {string} id A string which identifies the insert, e.g. 'core/block/12' 12842 * 12843 * @return {?{ time: number, count: number }} An object containing `time` which is when the last 12844 * insert occurred as a UNIX epoch, and `count` which is 12845 * the number of inserts that have occurred. 12846 */ 12847 function getInsertUsage(state, id) { 12848 var _state$preferences$in; 12849 return (_state$preferences$in = state.preferences.insertUsage?.[id]) !== null && _state$preferences$in !== void 0 ? _state$preferences$in : null; 12850 } 12851 12852 /** 12853 * Returns whether we can show a block type in the inserter 12854 * 12855 * @param {Object} state Global State 12856 * @param {Object} blockType BlockType 12857 * @param {?string} rootClientId Optional root client ID of block list. 12858 * 12859 * @return {boolean} Whether the given block type is allowed to be shown in the inserter. 12860 */ 12861 const canIncludeBlockTypeInInserter = (state, blockType, rootClientId) => { 12862 if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'inserter', true)) { 12863 return false; 12864 } 12865 return canInsertBlockTypeUnmemoized(state, blockType.name, rootClientId); 12866 }; 12867 12868 /** 12869 * Return a function to be used to tranform a block variation to an inserter item 12870 * 12871 * @param {Object} state Global State 12872 * @param {Object} item Denormalized inserter item 12873 * @return {Function} Function to transform a block variation to inserter item 12874 */ 12875 const getItemFromVariation = (state, item) => variation => { 12876 const variationId = `$item.id}/$variation.name}`; 12877 const { 12878 time, 12879 count = 0 12880 } = getInsertUsage(state, variationId) || {}; 12881 return { 12882 ...item, 12883 id: variationId, 12884 icon: variation.icon || item.icon, 12885 title: variation.title || item.title, 12886 description: variation.description || item.description, 12887 category: variation.category || item.category, 12888 // If `example` is explicitly undefined for the variation, the preview will not be shown. 12889 example: variation.hasOwnProperty('example') ? variation.example : item.example, 12890 initialAttributes: { 12891 ...item.initialAttributes, 12892 ...variation.attributes 12893 }, 12894 innerBlocks: variation.innerBlocks, 12895 keywords: variation.keywords || item.keywords, 12896 frecency: calculateFrecency(time, count) 12897 }; 12898 }; 12899 12900 /** 12901 * Returns the calculated frecency. 12902 * 12903 * 'frecency' is a heuristic (https://en.wikipedia.org/wiki/Frecency) 12904 * that combines block usage frequenty and recency. 12905 * 12906 * @param {number} time When the last insert occurred as a UNIX epoch 12907 * @param {number} count The number of inserts that have occurred. 12908 * 12909 * @return {number} The calculated frecency. 12910 */ 12911 const calculateFrecency = (time, count) => { 12912 if (!time) { 12913 return count; 12914 } 12915 // The selector is cached, which means Date.now() is the last time that the 12916 // relevant state changed. This suits our needs. 12917 const duration = Date.now() - time; 12918 switch (true) { 12919 case duration < MILLISECONDS_PER_HOUR: 12920 return count * 4; 12921 case duration < MILLISECONDS_PER_DAY: 12922 return count * 2; 12923 case duration < MILLISECONDS_PER_WEEK: 12924 return count / 2; 12925 default: 12926 return count / 4; 12927 } 12928 }; 12929 12930 /** 12931 * Returns a function that accepts a block type and builds an item to be shown 12932 * in a specific context. It's used for building items for Inserter and available 12933 * block Transfroms list. 12934 * 12935 * @param {Object} state Editor state. 12936 * @param {Object} options Options object for handling the building of a block type. 12937 * @param {string} options.buildScope The scope for which the item is going to be used. 12938 * @return {Function} Function returns an item to be shown in a specific context (Inserter|Transforms list). 12939 */ 12940 const buildBlockTypeItem = (state, { 12941 buildScope = 'inserter' 12942 }) => blockType => { 12943 const id = blockType.name; 12944 let isDisabled = false; 12945 if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType.name, 'multiple', true)) { 12946 isDisabled = getBlocksByClientId(state, getClientIdsWithDescendants(state)).some(({ 12947 name 12948 }) => name === blockType.name); 12949 } 12950 const { 12951 time, 12952 count = 0 12953 } = getInsertUsage(state, id) || {}; 12954 const blockItemBase = { 12955 id, 12956 name: blockType.name, 12957 title: blockType.title, 12958 icon: blockType.icon, 12959 isDisabled, 12960 frecency: calculateFrecency(time, count) 12961 }; 12962 if (buildScope === 'transform') { 12963 return blockItemBase; 12964 } 12965 const inserterVariations = (0,external_wp_blocks_namespaceObject.getBlockVariations)(blockType.name, 'inserter'); 12966 return { 12967 ...blockItemBase, 12968 initialAttributes: {}, 12969 description: blockType.description, 12970 category: blockType.category, 12971 keywords: blockType.keywords, 12972 variations: inserterVariations, 12973 example: blockType.example, 12974 utility: 1 // Deprecated. 12975 }; 12976 }; 12977 12978 /** 12979 * Determines the items that appear in the inserter. Includes both static 12980 * items (e.g. a regular block type) and dynamic items (e.g. a reusable block). 12981 * 12982 * Each item object contains what's necessary to display a button in the 12983 * inserter and handle its selection. 12984 * 12985 * The 'frecency' property is a heuristic (https://en.wikipedia.org/wiki/Frecency) 12986 * that combines block usage frequenty and recency. 12987 * 12988 * Items are returned ordered descendingly by their 'utility' and 'frecency'. 12989 * 12990 * @param {Object} state Editor state. 12991 * @param {?string} rootClientId Optional root client ID of block list. 12992 * 12993 * @return {WPEditorInserterItem[]} Items that appear in inserter. 12994 * 12995 * @typedef {Object} WPEditorInserterItem 12996 * @property {string} id Unique identifier for the item. 12997 * @property {string} name The type of block to create. 12998 * @property {Object} initialAttributes Attributes to pass to the newly created block. 12999 * @property {string} title Title of the item, as it appears in the inserter. 13000 * @property {string} icon Dashicon for the item, as it appears in the inserter. 13001 * @property {string} category Block category that the item is associated with. 13002 * @property {string[]} keywords Keywords that can be searched to find this item. 13003 * @property {boolean} isDisabled Whether or not the user should be prevented from inserting 13004 * this item. 13005 * @property {number} frecency Heuristic that combines frequency and recency. 13006 */ 13007 const getInserterItems = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null, options = EMPTY_OBJECT) => { 13008 const buildReusableBlockInserterItem = reusableBlock => { 13009 const icon = !reusableBlock.wp_pattern_sync_status ? { 13010 src: library_symbol, 13011 foreground: 'var(--wp-block-synced-color)' 13012 } : library_symbol; 13013 const id = `core/block/$reusableBlock.id}`; 13014 const { 13015 time, 13016 count = 0 13017 } = getInsertUsage(state, id) || {}; 13018 const frecency = calculateFrecency(time, count); 13019 return { 13020 id, 13021 name: 'core/block', 13022 initialAttributes: { 13023 ref: reusableBlock.id 13024 }, 13025 title: reusableBlock.title?.raw, 13026 icon, 13027 category: 'reusable', 13028 keywords: ['reusable'], 13029 isDisabled: false, 13030 utility: 1, 13031 // Deprecated. 13032 frecency, 13033 content: reusableBlock.content?.raw, 13034 syncStatus: reusableBlock.wp_pattern_sync_status 13035 }; 13036 }; 13037 const syncedPatternInserterItems = canInsertBlockTypeUnmemoized(state, 'core/block', rootClientId) ? unlock(select(STORE_NAME)).getReusableBlocks().map(buildReusableBlockInserterItem) : []; 13038 const buildBlockTypeInserterItem = buildBlockTypeItem(state, { 13039 buildScope: 'inserter' 13040 }); 13041 let blockTypeInserterItems = (0,external_wp_blocks_namespaceObject.getBlockTypes)().filter(blockType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'inserter', true)).map(buildBlockTypeInserterItem); 13042 if (options[withRootClientIdOptionKey]) { 13043 blockTypeInserterItems = blockTypeInserterItems.reduce((accumulator, item) => { 13044 item.rootClientId = rootClientId !== null && rootClientId !== void 0 ? rootClientId : ''; 13045 while (!canInsertBlockTypeUnmemoized(state, item.name, item.rootClientId)) { 13046 if (!item.rootClientId) { 13047 let sectionRootClientId; 13048 try { 13049 sectionRootClientId = getSectionRootClientId(state); 13050 } catch (e) {} 13051 if (sectionRootClientId && canInsertBlockTypeUnmemoized(state, item.name, sectionRootClientId)) { 13052 item.rootClientId = sectionRootClientId; 13053 } else { 13054 delete item.rootClientId; 13055 } 13056 break; 13057 } else { 13058 const parentClientId = getBlockRootClientId(state, item.rootClientId); 13059 item.rootClientId = parentClientId; 13060 } 13061 } 13062 13063 // We could also add non insertable items and gray them out. 13064 if (item.hasOwnProperty('rootClientId')) { 13065 accumulator.push(item); 13066 } 13067 return accumulator; 13068 }, []); 13069 } else { 13070 blockTypeInserterItems = blockTypeInserterItems.filter(blockType => canIncludeBlockTypeInInserter(state, blockType, rootClientId)); 13071 } 13072 const items = blockTypeInserterItems.reduce((accumulator, item) => { 13073 const { 13074 variations = [] 13075 } = item; 13076 // Exclude any block type item that is to be replaced by a default variation. 13077 if (!variations.some(({ 13078 isDefault 13079 }) => isDefault)) { 13080 accumulator.push(item); 13081 } 13082 if (variations.length) { 13083 const variationMapper = getItemFromVariation(state, item); 13084 accumulator.push(...variations.map(variationMapper)); 13085 } 13086 return accumulator; 13087 }, []); 13088 13089 // Ensure core blocks are prioritized in the returned results, 13090 // because third party blocks can be registered earlier than 13091 // the core blocks (usually by using the `init` action), 13092 // thus affecting the display order. 13093 // We don't sort reusable blocks as they are handled differently. 13094 const groupByType = (blocks, block) => { 13095 const { 13096 core, 13097 noncore 13098 } = blocks; 13099 const type = block.name.startsWith('core/') ? core : noncore; 13100 type.push(block); 13101 return blocks; 13102 }; 13103 const { 13104 core: coreItems, 13105 noncore: nonCoreItems 13106 } = items.reduce(groupByType, { 13107 core: [], 13108 noncore: [] 13109 }); 13110 const sortedBlockTypes = [...coreItems, ...nonCoreItems]; 13111 return [...sortedBlockTypes, ...syncedPatternInserterItems]; 13112 }, (state, rootClientId) => [(0,external_wp_blocks_namespaceObject.getBlockTypes)(), unlock(select(STORE_NAME)).getReusableBlocks(), state.blocks.order, state.preferences.insertUsage, ...getInsertBlockTypeDependants(state, rootClientId)])); 13113 13114 /** 13115 * Determines the items that appear in the available block transforms list. 13116 * 13117 * Each item object contains what's necessary to display a menu item in the 13118 * transform list and handle its selection. 13119 * 13120 * The 'frecency' property is a heuristic (https://en.wikipedia.org/wiki/Frecency) 13121 * that combines block usage frequenty and recency. 13122 * 13123 * Items are returned ordered descendingly by their 'frecency'. 13124 * 13125 * @param {Object} state Editor state. 13126 * @param {Object|Object[]} blocks Block object or array objects. 13127 * @param {?string} rootClientId Optional root client ID of block list. 13128 * 13129 * @return {WPEditorTransformItem[]} Items that appear in inserter. 13130 * 13131 * @typedef {Object} WPEditorTransformItem 13132 * @property {string} id Unique identifier for the item. 13133 * @property {string} name The type of block to create. 13134 * @property {string} title Title of the item, as it appears in the inserter. 13135 * @property {string} icon Dashicon for the item, as it appears in the inserter. 13136 * @property {boolean} isDisabled Whether or not the user should be prevented from inserting 13137 * this item. 13138 * @property {number} frecency Heuristic that combines frequency and recency. 13139 */ 13140 const getBlockTransformItems = (0,external_wp_data_namespaceObject.createSelector)((state, blocks, rootClientId = null) => { 13141 const normalizedBlocks = Array.isArray(blocks) ? blocks : [blocks]; 13142 const buildBlockTypeTransformItem = buildBlockTypeItem(state, { 13143 buildScope: 'transform' 13144 }); 13145 const blockTypeTransformItems = (0,external_wp_blocks_namespaceObject.getBlockTypes)().filter(blockType => canIncludeBlockTypeInInserter(state, blockType, rootClientId)).map(buildBlockTypeTransformItem); 13146 const itemsByName = Object.fromEntries(Object.entries(blockTypeTransformItems).map(([, value]) => [value.name, value])); 13147 const possibleTransforms = (0,external_wp_blocks_namespaceObject.getPossibleBlockTransformations)(normalizedBlocks).reduce((accumulator, block) => { 13148 if (itemsByName[block?.name]) { 13149 accumulator.push(itemsByName[block.name]); 13150 } 13151 return accumulator; 13152 }, []); 13153 return orderBy(possibleTransforms, block => itemsByName[block.name].frecency, 'desc'); 13154 }, (state, blocks, rootClientId) => [(0,external_wp_blocks_namespaceObject.getBlockTypes)(), state.preferences.insertUsage, ...getInsertBlockTypeDependants(state, rootClientId)]); 13155 13156 /** 13157 * Determines whether there are items to show in the inserter. 13158 * 13159 * @param {Object} state Editor state. 13160 * @param {?string} rootClientId Optional root client ID of block list. 13161 * 13162 * @return {boolean} Items that appear in inserter. 13163 */ 13164 const hasInserterItems = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, rootClientId = null) => { 13165 const hasBlockType = (0,external_wp_blocks_namespaceObject.getBlockTypes)().some(blockType => canIncludeBlockTypeInInserter(state, blockType, rootClientId)); 13166 if (hasBlockType) { 13167 return true; 13168 } 13169 const hasReusableBlock = canInsertBlockTypeUnmemoized(state, 'core/block', rootClientId) && unlock(select(STORE_NAME)).getReusableBlocks().length > 0; 13170 return hasReusableBlock; 13171 }); 13172 13173 /** 13174 * Returns the list of allowed inserter blocks for inner blocks children. 13175 * 13176 * @param {Object} state Editor state. 13177 * @param {?string} rootClientId Optional root client ID of block list. 13178 * 13179 * @return {Array?} The list of allowed block types. 13180 */ 13181 const getAllowedBlocks = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null) => { 13182 if (!rootClientId) { 13183 return; 13184 } 13185 const blockTypes = (0,external_wp_blocks_namespaceObject.getBlockTypes)().filter(blockType => canIncludeBlockTypeInInserter(state, blockType, rootClientId)); 13186 const hasReusableBlock = canInsertBlockTypeUnmemoized(state, 'core/block', rootClientId) && unlock(select(STORE_NAME)).getReusableBlocks().length > 0; 13187 if (hasReusableBlock) { 13188 blockTypes.push('core/block'); 13189 } 13190 return blockTypes; 13191 }, (state, rootClientId) => [(0,external_wp_blocks_namespaceObject.getBlockTypes)(), unlock(select(STORE_NAME)).getReusableBlocks(), ...getInsertBlockTypeDependants(state, rootClientId)])); 13192 const __experimentalGetAllowedBlocks = (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null) => { 13193 external_wp_deprecated_default()('wp.data.select( "core/block-editor" ).__experimentalGetAllowedBlocks', { 13194 alternative: 'wp.data.select( "core/block-editor" ).getAllowedBlocks', 13195 since: '6.2', 13196 version: '6.4' 13197 }); 13198 return getAllowedBlocks(state, rootClientId); 13199 }, (state, rootClientId) => getAllowedBlocks.getDependants(state, rootClientId)); 13200 13201 /** 13202 * Returns the block to be directly inserted by the block appender. 13203 * 13204 * @param {Object} state Editor state. 13205 * @param {?string} rootClientId Optional root client ID of block list. 13206 * 13207 * @return {WPDirectInsertBlock|undefined} The block type to be directly inserted. 13208 * 13209 * @typedef {Object} WPDirectInsertBlock 13210 * @property {string} name The type of block. 13211 * @property {?Object} attributes Attributes to pass to the newly created block. 13212 * @property {?Array<string>} attributesToCopy Attributes to be copied from adjecent blocks when inserted. 13213 */ 13214 function getDirectInsertBlock(state, rootClientId = null) { 13215 var _state$blockListSetti; 13216 if (!rootClientId) { 13217 return; 13218 } 13219 const { 13220 defaultBlock, 13221 directInsert 13222 } = (_state$blockListSetti = state.blockListSettings[rootClientId]) !== null && _state$blockListSetti !== void 0 ? _state$blockListSetti : {}; 13223 if (!defaultBlock || !directInsert) { 13224 return; 13225 } 13226 return defaultBlock; 13227 } 13228 function __experimentalGetDirectInsertBlock(state, rootClientId = null) { 13229 external_wp_deprecated_default()('wp.data.select( "core/block-editor" ).__experimentalGetDirectInsertBlock', { 13230 alternative: 'wp.data.select( "core/block-editor" ).getDirectInsertBlock', 13231 since: '6.3', 13232 version: '6.4' 13233 }); 13234 return getDirectInsertBlock(state, rootClientId); 13235 } 13236 const __experimentalGetParsedPattern = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, patternName) => { 13237 const pattern = unlock(select(STORE_NAME)).getPatternBySlug(patternName); 13238 return pattern ? getParsedPattern(pattern) : null; 13239 }); 13240 const getAllowedPatternsDependants = select => (state, rootClientId) => [...getAllPatternsDependants(select)(state), ...getInsertBlockTypeDependants(state, rootClientId)]; 13241 const patternsWithParsedBlocks = new WeakMap(); 13242 function enhancePatternWithParsedBlocks(pattern) { 13243 let enhancedPattern = patternsWithParsedBlocks.get(pattern); 13244 if (!enhancedPattern) { 13245 enhancedPattern = { 13246 ...pattern, 13247 get blocks() { 13248 return getParsedPattern(pattern).blocks; 13249 } 13250 }; 13251 patternsWithParsedBlocks.set(pattern, enhancedPattern); 13252 } 13253 return enhancedPattern; 13254 } 13255 13256 /** 13257 * Returns the list of allowed patterns for inner blocks children. 13258 * 13259 * @param {Object} state Editor state. 13260 * @param {?string} rootClientId Optional target root client ID. 13261 * 13262 * @return {Array?} The list of allowed patterns. 13263 */ 13264 const __experimentalGetAllowedPatterns = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => { 13265 return (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null) => { 13266 const { 13267 getAllPatterns 13268 } = unlock(select(STORE_NAME)); 13269 const patterns = getAllPatterns(); 13270 const { 13271 allowedBlockTypes 13272 } = getSettings(state); 13273 const parsedPatterns = patterns.filter(({ 13274 inserter = true 13275 }) => !!inserter).map(enhancePatternWithParsedBlocks); 13276 const availableParsedPatterns = parsedPatterns.filter(pattern => checkAllowListRecursive(getGrammar(pattern), allowedBlockTypes)); 13277 const patternsAllowed = availableParsedPatterns.filter(pattern => getGrammar(pattern).every(({ 13278 blockName: name 13279 }) => canInsertBlockType(state, name, rootClientId))); 13280 return patternsAllowed; 13281 }, getAllowedPatternsDependants(select)); 13282 }); 13283 13284 /** 13285 * Returns the list of patterns based on their declared `blockTypes` 13286 * and a block's name. 13287 * Patterns can use `blockTypes` to integrate in work flows like 13288 * suggesting appropriate patterns in a Placeholder state(during insertion) 13289 * or blocks transformations. 13290 * 13291 * @param {Object} state Editor state. 13292 * @param {string|string[]} blockNames Block's name or array of block names to find matching pattens. 13293 * @param {?string} rootClientId Optional target root client ID. 13294 * 13295 * @return {Array} The list of matched block patterns based on declared `blockTypes` and block name. 13296 */ 13297 const getPatternsByBlockTypes = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, blockNames, rootClientId = null) => { 13298 if (!blockNames) { 13299 return selectors_EMPTY_ARRAY; 13300 } 13301 const patterns = select(STORE_NAME).__experimentalGetAllowedPatterns(rootClientId); 13302 const normalizedBlockNames = Array.isArray(blockNames) ? blockNames : [blockNames]; 13303 const filteredPatterns = patterns.filter(pattern => pattern?.blockTypes?.some?.(blockName => normalizedBlockNames.includes(blockName))); 13304 if (filteredPatterns.length === 0) { 13305 return selectors_EMPTY_ARRAY; 13306 } 13307 return filteredPatterns; 13308 }, (state, blockNames, rootClientId) => getAllowedPatternsDependants(select)(state, rootClientId))); 13309 const __experimentalGetPatternsByBlockTypes = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => { 13310 external_wp_deprecated_default()('wp.data.select( "core/block-editor" ).__experimentalGetPatternsByBlockTypes', { 13311 alternative: 'wp.data.select( "core/block-editor" ).getPatternsByBlockTypes', 13312 since: '6.2', 13313 version: '6.4' 13314 }); 13315 return select(STORE_NAME).getPatternsByBlockTypes; 13316 }); 13317 13318 /** 13319 * Determines the items that appear in the available pattern transforms list. 13320 * 13321 * For now we only handle blocks without InnerBlocks and take into account 13322 * the `role` property of blocks' attributes for the transformation. 13323 * 13324 * We return the first set of possible eligible block patterns, 13325 * by checking the `blockTypes` property. We still have to recurse through 13326 * block pattern's blocks and try to find matches from the selected blocks. 13327 * Now this happens in the consumer to avoid heavy operations in the selector. 13328 * 13329 * @param {Object} state Editor state. 13330 * @param {Object[]} blocks The selected blocks. 13331 * @param {?string} rootClientId Optional root client ID of block list. 13332 * 13333 * @return {WPBlockPattern[]} Items that are eligible for a pattern transformation. 13334 */ 13335 const __experimentalGetPatternTransformItems = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, blocks, rootClientId = null) => { 13336 if (!blocks) { 13337 return selectors_EMPTY_ARRAY; 13338 } 13339 /** 13340 * For now we only handle blocks without InnerBlocks and take into account 13341 * the `role` property of blocks' attributes for the transformation. 13342 * Note that the blocks have been retrieved through `getBlock`, which doesn't 13343 * return the inner blocks of an inner block controller, so we still need 13344 * to check for this case too. 13345 */ 13346 if (blocks.some(({ 13347 clientId, 13348 innerBlocks 13349 }) => innerBlocks.length || areInnerBlocksControlled(state, clientId))) { 13350 return selectors_EMPTY_ARRAY; 13351 } 13352 13353 // Create a Set of the selected block names that is used in patterns filtering. 13354 const selectedBlockNames = Array.from(new Set(blocks.map(({ 13355 name 13356 }) => name))); 13357 /** 13358 * Here we will return first set of possible eligible block patterns, 13359 * by checking the `blockTypes` property. We still have to recurse through 13360 * block pattern's blocks and try to find matches from the selected blocks. 13361 * Now this happens in the consumer to avoid heavy operations in the selector. 13362 */ 13363 return select(STORE_NAME).getPatternsByBlockTypes(selectedBlockNames, rootClientId); 13364 }, (state, blocks, rootClientId) => getAllowedPatternsDependants(select)(state, rootClientId))); 13365 13366 /** 13367 * Returns the Block List settings of a block, if any exist. 13368 * 13369 * @param {Object} state Editor state. 13370 * @param {?string} clientId Block client ID. 13371 * 13372 * @return {?Object} Block settings of the block if set. 13373 */ 13374 function getBlockListSettings(state, clientId) { 13375 return state.blockListSettings[clientId]; 13376 } 13377 13378 /** 13379 * Returns the editor settings. 13380 * 13381 * @param {Object} state Editor state. 13382 * 13383 * @return {Object} The editor settings object. 13384 */ 13385 function getSettings(state) { 13386 return state.settings; 13387 } 13388 13389 /** 13390 * Returns true if the most recent block change is be considered persistent, or 13391 * false otherwise. A persistent change is one committed by BlockEditorProvider 13392 * via its `onChange` callback, in addition to `onInput`. 13393 * 13394 * @param {Object} state Block editor state. 13395 * 13396 * @return {boolean} Whether the most recent block change was persistent. 13397 */ 13398 function isLastBlockChangePersistent(state) { 13399 return state.blocks.isPersistentChange; 13400 } 13401 13402 /** 13403 * Returns the block list settings for an array of blocks, if any exist. 13404 * 13405 * @param {Object} state Editor state. 13406 * @param {Array} clientIds Block client IDs. 13407 * 13408 * @return {Object} An object where the keys are client ids and the values are 13409 * a block list setting object. 13410 */ 13411 const __experimentalGetBlockListSettingsForBlocks = (0,external_wp_data_namespaceObject.createSelector)((state, clientIds = []) => { 13412 return clientIds.reduce((blockListSettingsForBlocks, clientId) => { 13413 if (!state.blockListSettings[clientId]) { 13414 return blockListSettingsForBlocks; 13415 } 13416 return { 13417 ...blockListSettingsForBlocks, 13418 [clientId]: state.blockListSettings[clientId] 13419 }; 13420 }, {}); 13421 }, state => [state.blockListSettings]); 13422 13423 /** 13424 * Returns the title of a given reusable block 13425 * 13426 * @param {Object} state Global application state. 13427 * @param {number|string} ref The shared block's ID. 13428 * 13429 * @return {string} The reusable block saved title. 13430 */ 13431 const __experimentalGetReusableBlockTitle = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, ref) => { 13432 external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__experimentalGetReusableBlockTitle", { 13433 since: '6.6', 13434 version: '6.8' 13435 }); 13436 const reusableBlock = unlock(select(STORE_NAME)).getReusableBlocks().find(block => block.id === ref); 13437 if (!reusableBlock) { 13438 return null; 13439 } 13440 return reusableBlock.title?.raw; 13441 }, () => [unlock(select(STORE_NAME)).getReusableBlocks()])); 13442 13443 /** 13444 * Returns true if the most recent block change is be considered ignored, or 13445 * false otherwise. An ignored change is one not to be committed by 13446 * BlockEditorProvider, neither via `onChange` nor `onInput`. 13447 * 13448 * @param {Object} state Block editor state. 13449 * 13450 * @return {boolean} Whether the most recent block change was ignored. 13451 */ 13452 function __unstableIsLastBlockChangeIgnored(state) { 13453 // TODO: Removal Plan: Changes incurred by RECEIVE_BLOCKS should not be 13454 // ignored if in-fact they result in a change in blocks state. The current 13455 // need to ignore changes not a result of user interaction should be 13456 // accounted for in the refactoring of reusable blocks as occurring within 13457 // their own separate block editor / state (#7119). 13458 return state.blocks.isIgnoredChange; 13459 } 13460 13461 /** 13462 * Returns the block attributes changed as a result of the last dispatched 13463 * action. 13464 * 13465 * @param {Object} state Block editor state. 13466 * 13467 * @return {Object<string,Object>} Subsets of block attributes changed, keyed 13468 * by block client ID. 13469 */ 13470 function __experimentalGetLastBlockAttributeChanges(state) { 13471 return state.lastBlockAttributesChange; 13472 } 13473 13474 /** 13475 * Returns whether the navigation mode is enabled. 13476 * 13477 * @param {Object} state Editor state. 13478 * 13479 * @return {boolean} Is navigation mode enabled. 13480 */ 13481 function isNavigationMode(state) { 13482 return state.editorMode === 'navigation'; 13483 } 13484 13485 /** 13486 * Returns the current editor mode. 13487 * 13488 * @param {Object} state Editor state. 13489 * 13490 * @return {string} the editor mode. 13491 */ 13492 function __unstableGetEditorMode(state) { 13493 return state.editorMode; 13494 } 13495 13496 /** 13497 * Returns whether block moving mode is enabled. 13498 * 13499 * @param {Object} state Editor state. 13500 * 13501 * @return {string} Client Id of moving block. 13502 */ 13503 function selectors_hasBlockMovingClientId(state) { 13504 return state.hasBlockMovingClientId; 13505 } 13506 13507 /** 13508 * Returns true if the last change was an automatic change, false otherwise. 13509 * 13510 * @param {Object} state Global application state. 13511 * 13512 * @return {boolean} Whether the last change was automatic. 13513 */ 13514 function didAutomaticChange(state) { 13515 return !!state.automaticChangeStatus; 13516 } 13517 13518 /** 13519 * Returns true if the current highlighted block matches the block clientId. 13520 * 13521 * @param {Object} state Global application state. 13522 * @param {string} clientId The block to check. 13523 * 13524 * @return {boolean} Whether the block is currently highlighted. 13525 */ 13526 function isBlockHighlighted(state, clientId) { 13527 return state.highlightedBlock === clientId; 13528 } 13529 13530 /** 13531 * Checks if a given block has controlled inner blocks. 13532 * 13533 * @param {Object} state Global application state. 13534 * @param {string} clientId The block to check. 13535 * 13536 * @return {boolean} True if the block has controlled inner blocks. 13537 */ 13538 function areInnerBlocksControlled(state, clientId) { 13539 return !!state.blocks.controlledInnerBlocks[clientId]; 13540 } 13541 13542 /** 13543 * Returns the clientId for the first 'active' block of a given array of block names. 13544 * A block is 'active' if it (or a child) is the selected block. 13545 * Returns the first match moving up the DOM from the selected block. 13546 * 13547 * @param {Object} state Global application state. 13548 * @param {string[]} validBlocksNames The names of block types to check for. 13549 * 13550 * @return {string} The matching block's clientId. 13551 */ 13552 const __experimentalGetActiveBlockIdByBlockNames = (0,external_wp_data_namespaceObject.createSelector)((state, validBlockNames) => { 13553 if (!validBlockNames.length) { 13554 return null; 13555 } 13556 // Check if selected block is a valid entity area. 13557 const selectedBlockClientId = getSelectedBlockClientId(state); 13558 if (validBlockNames.includes(getBlockName(state, selectedBlockClientId))) { 13559 return selectedBlockClientId; 13560 } 13561 // Check if first selected block is a child of a valid entity area. 13562 const multiSelectedBlockClientIds = getMultiSelectedBlockClientIds(state); 13563 const entityAreaParents = getBlockParentsByBlockName(state, selectedBlockClientId || multiSelectedBlockClientIds[0], validBlockNames); 13564 if (entityAreaParents) { 13565 // Last parent closest/most interior. 13566 return entityAreaParents[entityAreaParents.length - 1]; 13567 } 13568 return null; 13569 }, (state, validBlockNames) => [state.selection.selectionStart.clientId, state.selection.selectionEnd.clientId, validBlockNames]); 13570 13571 /** 13572 * Tells if the block with the passed clientId was just inserted. 13573 * 13574 * @param {Object} state Global application state. 13575 * @param {Object} clientId Client Id of the block. 13576 * @param {?string} source Optional insertion source of the block. 13577 * @return {boolean} True if the block matches the last block inserted from the specified source. 13578 */ 13579 function wasBlockJustInserted(state, clientId, source) { 13580 const { 13581 lastBlockInserted 13582 } = state; 13583 return lastBlockInserted.clientIds?.includes(clientId) && lastBlockInserted.source === source; 13584 } 13585 13586 /** 13587 * Tells if the block is visible on the canvas or not. 13588 * 13589 * @param {Object} state Global application state. 13590 * @param {Object} clientId Client Id of the block. 13591 * @return {boolean} True if the block is visible. 13592 */ 13593 function isBlockVisible(state, clientId) { 13594 var _state$blockVisibilit; 13595 return (_state$blockVisibilit = state.blockVisibility?.[clientId]) !== null && _state$blockVisibilit !== void 0 ? _state$blockVisibilit : true; 13596 } 13597 13598 /** 13599 * Returns the currently hovered block. 13600 * 13601 * @param {Object} state Global application state. 13602 * @return {Object} Client Id of the hovered block. 13603 */ 13604 function getHoveredBlockClientId(state) { 13605 return state.hoveredBlockClientId; 13606 } 13607 13608 /** 13609 * Returns the list of all hidden blocks. 13610 * 13611 * @param {Object} state Global application state. 13612 * @return {[string]} List of hidden blocks. 13613 */ 13614 const __unstableGetVisibleBlocks = (0,external_wp_data_namespaceObject.createSelector)(state => { 13615 const visibleBlocks = new Set(Object.keys(state.blockVisibility).filter(key => state.blockVisibility[key])); 13616 if (visibleBlocks.size === 0) { 13617 return EMPTY_SET; 13618 } 13619 return visibleBlocks; 13620 }, state => [state.blockVisibility]); 13621 function __unstableHasActiveBlockOverlayActive(state, clientId) { 13622 // Prevent overlay on blocks with a non-default editing mode. If the mdoe is 13623 // 'disabled' then the overlay is redundant since the block can't be 13624 // selected. If the mode is 'contentOnly' then the overlay is redundant 13625 // since there will be no controls to interact with once selected. 13626 if (getBlockEditingMode(state, clientId) !== 'default') { 13627 return false; 13628 } 13629 13630 // If the block editing is locked, the block overlay is always active. 13631 if (!canEditBlock(state, clientId)) { 13632 return true; 13633 } 13634 const editorMode = __unstableGetEditorMode(state); 13635 13636 // In zoom-out mode, the block overlay is always active for section level blocks. 13637 if (editorMode === 'zoom-out') { 13638 const sectionRootClientId = getSectionRootClientId(state); 13639 if (sectionRootClientId) { 13640 const sectionClientIds = getBlockOrder(state, sectionRootClientId); 13641 if (sectionClientIds?.includes(clientId)) { 13642 return true; 13643 } 13644 } else if (clientId && !getBlockRootClientId(state, clientId)) { 13645 return true; 13646 } 13647 } 13648 13649 // In navigation mode, the block overlay is active when the block is not 13650 // selected (and doesn't contain a selected child). The same behavior is 13651 // also enabled in all modes for blocks that have controlled children 13652 // (reusable block, template part, navigation), unless explicitly disabled 13653 // with `supports.__experimentalDisableBlockOverlay`. 13654 const blockSupportDisable = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(getBlockName(state, clientId), '__experimentalDisableBlockOverlay', false); 13655 const shouldEnableIfUnselected = editorMode === 'navigation' || (blockSupportDisable ? false : areInnerBlocksControlled(state, clientId)); 13656 return shouldEnableIfUnselected && !isBlockSelected(state, clientId) && !hasSelectedInnerBlock(state, clientId, true); 13657 } 13658 function __unstableIsWithinBlockOverlay(state, clientId) { 13659 let parent = state.blocks.parents.get(clientId); 13660 while (!!parent) { 13661 if (__unstableHasActiveBlockOverlayActive(state, parent)) { 13662 return true; 13663 } 13664 parent = state.blocks.parents.get(parent); 13665 } 13666 return false; 13667 } 13668 13669 /** 13670 * @typedef {import('../components/block-editing-mode').BlockEditingMode} BlockEditingMode 13671 */ 13672 13673 /** 13674 * Returns the block editing mode for a given block. 13675 * 13676 * The mode can be one of three options: 13677 * 13678 * - `'disabled'`: Prevents editing the block entirely, i.e. it cannot be 13679 * selected. 13680 * - `'contentOnly'`: Hides all non-content UI, e.g. auxiliary controls in the 13681 * toolbar, the block movers, block settings. 13682 * - `'default'`: Allows editing the block as normal. 13683 * 13684 * Blocks can set a mode using the `useBlockEditingMode` hook. 13685 * 13686 * The mode is inherited by all of the block's inner blocks, unless they have 13687 * their own mode. 13688 * 13689 * A template lock can also set a mode. If the template lock is `'contentOnly'`, 13690 * the block's mode is overridden to `'contentOnly'` if the block has a content 13691 * role attribute, or `'disabled'` otherwise. 13692 * 13693 * @see useBlockEditingMode 13694 * 13695 * @param {Object} state Global application state. 13696 * @param {string} clientId The block client ID, or `''` for the root container. 13697 * 13698 * @return {BlockEditingMode} The block editing mode. One of `'disabled'`, 13699 * `'contentOnly'`, or `'default'`. 13700 */ 13701 const getBlockEditingMode = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, clientId = '') => { 13702 // Some selectors that call this provide `null` as the default 13703 // rootClientId, but the default rootClientId is actually `''`. 13704 if (clientId === null) { 13705 clientId = ''; 13706 } 13707 13708 // In zoom-out mode, override the behavior set by 13709 // __unstableSetBlockEditingMode to only allow editing the top-level 13710 // sections. 13711 const editorMode = __unstableGetEditorMode(state); 13712 if (editorMode === 'zoom-out') { 13713 const sectionRootClientId = getSectionRootClientId(state); 13714 if (clientId === '' /* ROOT_CONTAINER_CLIENT_ID */) { 13715 return sectionRootClientId ? 'disabled' : 'contentOnly'; 13716 } 13717 if (clientId === sectionRootClientId) { 13718 return 'contentOnly'; 13719 } 13720 const sectionsClientIds = getBlockOrder(state, sectionRootClientId); 13721 13722 // Sections are always contentOnly. 13723 if (sectionsClientIds?.includes(clientId)) { 13724 return 'contentOnly'; 13725 } 13726 return 'disabled'; 13727 } 13728 const blockEditingMode = state.blockEditingModes.get(clientId); 13729 if (blockEditingMode) { 13730 return blockEditingMode; 13731 } 13732 if (!clientId) { 13733 return 'default'; 13734 } 13735 const rootClientId = getBlockRootClientId(state, clientId); 13736 const templateLock = getTemplateLock(state, rootClientId); 13737 if (templateLock === 'contentOnly') { 13738 const name = getBlockName(state, clientId); 13739 const { 13740 hasContentRoleAttribute 13741 } = unlock(select(external_wp_blocks_namespaceObject.store)); 13742 const isContent = hasContentRoleAttribute(name); 13743 return isContent ? 'contentOnly' : 'disabled'; 13744 } 13745 const parentMode = getBlockEditingMode(state, rootClientId); 13746 return parentMode === 'contentOnly' ? 'default' : parentMode; 13747 }); 13748 13749 /** 13750 * Indicates if a block is ungroupable. 13751 * A block is ungroupable if it is a single grouping block with inner blocks. 13752 * If a block has an `ungroup` transform, it is also ungroupable, without the 13753 * requirement of being the default grouping block. 13754 * Additionally a block can only be ungrouped if it has inner blocks and can 13755 * be removed. 13756 * 13757 * @param {Object} state Global application state. 13758 * @param {string} clientId Client Id of the block. If not passed the selected block's client id will be used. 13759 * @return {boolean} True if the block is ungroupable. 13760 */ 13761 const isUngroupable = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, clientId = '') => { 13762 const _clientId = clientId || getSelectedBlockClientId(state); 13763 if (!_clientId) { 13764 return false; 13765 } 13766 const { 13767 getGroupingBlockName 13768 } = select(external_wp_blocks_namespaceObject.store); 13769 const block = getBlock(state, _clientId); 13770 const groupingBlockName = getGroupingBlockName(); 13771 const _isUngroupable = block && (block.name === groupingBlockName || (0,external_wp_blocks_namespaceObject.getBlockType)(block.name)?.transforms?.ungroup) && !!block.innerBlocks.length; 13772 return _isUngroupable && canRemoveBlock(state, _clientId); 13773 }); 13774 13775 /** 13776 * Indicates if the provided blocks(by client ids) are groupable. 13777 * We need to have at least one block, have a grouping block name set and 13778 * be able to remove these blocks. 13779 * 13780 * @param {Object} state Global application state. 13781 * @param {string[]} clientIds Block client ids. If not passed the selected blocks client ids will be used. 13782 * @return {boolean} True if the blocks are groupable. 13783 */ 13784 const isGroupable = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, clientIds = selectors_EMPTY_ARRAY) => { 13785 const { 13786 getGroupingBlockName 13787 } = select(external_wp_blocks_namespaceObject.store); 13788 const groupingBlockName = getGroupingBlockName(); 13789 const _clientIds = clientIds?.length ? clientIds : getSelectedBlockClientIds(state); 13790 const rootClientId = _clientIds?.length ? getBlockRootClientId(state, _clientIds[0]) : undefined; 13791 const groupingBlockAvailable = canInsertBlockType(state, groupingBlockName, rootClientId); 13792 const _isGroupable = groupingBlockAvailable && _clientIds.length; 13793 return _isGroupable && canRemoveBlocks(state, _clientIds); 13794 }); 13795 13796 /** 13797 * DO-NOT-USE in production. 13798 * This selector is created for internal/experimental only usage and may be 13799 * removed anytime without any warning, causing breakage on any plugin or theme invoking it. 13800 * 13801 * @deprecated 13802 * 13803 * @param {Object} state Global application state. 13804 * @param {Object} clientId Client Id of the block. 13805 * 13806 * @return {?string} Client ID of the ancestor block that is content locking the block. 13807 */ 13808 const __unstableGetContentLockingParent = (state, clientId) => { 13809 external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__unstableGetContentLockingParent", { 13810 since: '6.1', 13811 version: '6.7' 13812 }); 13813 return getContentLockingParent(state, clientId); 13814 }; 13815 13816 /** 13817 * DO-NOT-USE in production. 13818 * This selector is created for internal/experimental only usage and may be 13819 * removed anytime without any warning, causing breakage on any plugin or theme invoking it. 13820 * 13821 * @deprecated 13822 * 13823 * @param {Object} state Global application state. 13824 */ 13825 function __unstableGetTemporarilyEditingAsBlocks(state) { 13826 external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__unstableGetTemporarilyEditingAsBlocks", { 13827 since: '6.1', 13828 version: '6.7' 13829 }); 13830 return getTemporarilyEditingAsBlocks(state); 13831 } 13832 13833 /** 13834 * DO-NOT-USE in production. 13835 * This selector is created for internal/experimental only usage and may be 13836 * removed anytime without any warning, causing breakage on any plugin or theme invoking it. 13837 * 13838 * @deprecated 13839 * 13840 * @param {Object} state Global application state. 13841 */ 13842 function __unstableGetTemporarilyEditingFocusModeToRevert(state) { 13843 external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__unstableGetTemporarilyEditingFocusModeToRevert", { 13844 since: '6.5', 13845 version: '6.7' 13846 }); 13847 return getTemporarilyEditingFocusModeToRevert(state); 13848 } 13849 13850 ;// ./node_modules/@wordpress/block-editor/build-module/store/private-actions.js 13851 /** 13852 * WordPress dependencies 13853 */ 13854 13855 13856 /** 13857 * Internal dependencies 13858 */ 13859 13860 13861 const castArray = maybeArray => Array.isArray(maybeArray) ? maybeArray : [maybeArray]; 13862 13863 /** 13864 * A list of private/experimental block editor settings that 13865 * should not become a part of the WordPress public API. 13866 * BlockEditorProvider will remove these settings from the 13867 * settings object it receives. 13868 * 13869 * @see https://github.com/WordPress/gutenberg/pull/46131 13870 */ 13871 const privateSettings = ['inserterMediaCategories', 'blockInspectorAnimation']; 13872 13873 /** 13874 * Action that updates the block editor settings and 13875 * conditionally preserves the experimental ones. 13876 * 13877 * @param {Object} settings Updated settings 13878 * @param {Object} options Options object. 13879 * @param {boolean} options.stripExperimentalSettings Whether to strip experimental settings. 13880 * @param {boolean} options.reset Whether to reset the settings. 13881 * @return {Object} Action object 13882 */ 13883 function __experimentalUpdateSettings(settings, { 13884 stripExperimentalSettings = false, 13885 reset = false 13886 } = {}) { 13887 let cleanSettings = settings; 13888 // There are no plugins in the mobile apps, so there is no 13889 // need to strip the experimental settings: 13890 if (stripExperimentalSettings && external_wp_element_namespaceObject.Platform.OS === 'web') { 13891 cleanSettings = {}; 13892 for (const key in settings) { 13893 if (!privateSettings.includes(key)) { 13894 cleanSettings[key] = settings[key]; 13895 } 13896 } 13897 } 13898 return { 13899 type: 'UPDATE_SETTINGS', 13900 settings: cleanSettings, 13901 reset 13902 }; 13903 } 13904 13905 /** 13906 * Hides the block interface (eg. toolbar, outline, etc.) 13907 * 13908 * @return {Object} Action object. 13909 */ 13910 function hideBlockInterface() { 13911 return { 13912 type: 'HIDE_BLOCK_INTERFACE' 13913 }; 13914 } 13915 13916 /** 13917 * Shows the block interface (eg. toolbar, outline, etc.) 13918 * 13919 * @return {Object} Action object. 13920 */ 13921 function showBlockInterface() { 13922 return { 13923 type: 'SHOW_BLOCK_INTERFACE' 13924 }; 13925 } 13926 13927 /** 13928 * Yields action objects used in signalling that the blocks corresponding to 13929 * the set of specified client IDs are to be removed. 13930 * 13931 * Compared to `removeBlocks`, this private interface exposes an additional 13932 * parameter; see `forceRemove`. 13933 * 13934 * @param {string|string[]} clientIds Client IDs of blocks to remove. 13935 * @param {boolean} selectPrevious True if the previous block 13936 * or the immediate parent 13937 * (if no previous block exists) 13938 * should be selected 13939 * when a block is removed. 13940 * @param {boolean} forceRemove Whether to force the operation, 13941 * bypassing any checks for certain 13942 * block types. 13943 */ 13944 const privateRemoveBlocks = (clientIds, selectPrevious = true, forceRemove = false) => ({ 13945 select, 13946 dispatch, 13947 registry 13948 }) => { 13949 if (!clientIds || !clientIds.length) { 13950 return; 13951 } 13952 clientIds = castArray(clientIds); 13953 const canRemoveBlocks = select.canRemoveBlocks(clientIds); 13954 if (!canRemoveBlocks) { 13955 return; 13956 } 13957 13958 // In certain editing contexts, we'd like to prevent accidental removal 13959 // of important blocks. For example, in the site editor, the Query Loop 13960 // block is deemed important. In such cases, we'll ask the user for 13961 // confirmation that they intended to remove such block(s). However, 13962 // the editor instance is responsible for presenting those confirmation 13963 // prompts to the user. Any instance opting into removal prompts must 13964 // register using `setBlockRemovalRules()`. 13965 // 13966 // @see https://github.com/WordPress/gutenberg/pull/51145 13967 const rules = !forceRemove && select.getBlockRemovalRules(); 13968 if (rules) { 13969 function flattenBlocks(blocks) { 13970 const result = []; 13971 const stack = [...blocks]; 13972 while (stack.length) { 13973 const { 13974 innerBlocks, 13975 ...block 13976 } = stack.shift(); 13977 stack.push(...innerBlocks); 13978 result.push(block); 13979 } 13980 return result; 13981 } 13982 const blockList = clientIds.map(select.getBlock); 13983 const flattenedBlocks = flattenBlocks(blockList); 13984 13985 // Find the first message and use it. 13986 let message; 13987 for (const rule of rules) { 13988 message = rule.callback(flattenedBlocks); 13989 if (message) { 13990 dispatch(displayBlockRemovalPrompt(clientIds, selectPrevious, message)); 13991 return; 13992 } 13993 } 13994 } 13995 if (selectPrevious) { 13996 dispatch.selectPreviousBlock(clientIds[0], selectPrevious); 13997 } 13998 13999 // We're batching these two actions because an extra `undo/redo` step can 14000 // be created, based on whether we insert a default block or not. 14001 registry.batch(() => { 14002 dispatch({ 14003 type: 'REMOVE_BLOCKS', 14004 clientIds 14005 }); 14006 // To avoid a focus loss when removing the last block, assure there is 14007 // always a default block if the last of the blocks have been removed. 14008 dispatch(ensureDefaultBlock()); 14009 }); 14010 }; 14011 14012 /** 14013 * Action which will insert a default block insert action if there 14014 * are no other blocks at the root of the editor. This action should be used 14015 * in actions which may result in no blocks remaining in the editor (removal, 14016 * replacement, etc). 14017 */ 14018 const ensureDefaultBlock = () => ({ 14019 select, 14020 dispatch 14021 }) => { 14022 // To avoid a focus loss when removing the last block, assure there is 14023 // always a default block if the last of the blocks have been removed. 14024 const count = select.getBlockCount(); 14025 if (count > 0) { 14026 return; 14027 } 14028 14029 // If there's an custom appender, don't insert default block. 14030 // We have to remember to manually move the focus elsewhere to 14031 // prevent it from being lost though. 14032 const { 14033 __unstableHasCustomAppender 14034 } = select.getSettings(); 14035 if (__unstableHasCustomAppender) { 14036 return; 14037 } 14038 dispatch.insertDefaultBlock(); 14039 }; 14040 14041 /** 14042 * Returns an action object used in signalling that a block removal prompt must 14043 * be displayed. 14044 * 14045 * Contrast with `setBlockRemovalRules`. 14046 * 14047 * @param {string|string[]} clientIds Client IDs of blocks to remove. 14048 * @param {boolean} selectPrevious True if the previous block or the 14049 * immediate parent (if no previous 14050 * block exists) should be selected 14051 * when a block is removed. 14052 * @param {string} message Message to display in the prompt. 14053 * 14054 * @return {Object} Action object. 14055 */ 14056 function displayBlockRemovalPrompt(clientIds, selectPrevious, message) { 14057 return { 14058 type: 'DISPLAY_BLOCK_REMOVAL_PROMPT', 14059 clientIds, 14060 selectPrevious, 14061 message 14062 }; 14063 } 14064 14065 /** 14066 * Returns an action object used in signalling that a block removal prompt must 14067 * be cleared, either be cause the user has confirmed or canceled the request 14068 * for removal. 14069 * 14070 * @return {Object} Action object. 14071 */ 14072 function clearBlockRemovalPrompt() { 14073 return { 14074 type: 'CLEAR_BLOCK_REMOVAL_PROMPT' 14075 }; 14076 } 14077 14078 /** 14079 * Returns an action object used to set up any rules that a block editor may 14080 * provide in order to prevent a user from accidentally removing certain 14081 * blocks. These rules are then used to display a confirmation prompt to the 14082 * user. For instance, in the Site Editor, the Query Loop block is important 14083 * enough to warrant such confirmation. 14084 * 14085 * IMPORTANT: Registering rules implicitly signals to the `privateRemoveBlocks` 14086 * action that the editor will be responsible for displaying block removal 14087 * prompts and confirming deletions. This action is meant to be used by 14088 * component `BlockRemovalWarningModal` only. 14089 * 14090 * The data is a record whose keys are block types (e.g. 'core/query') and 14091 * whose values are the explanation to be shown to users (e.g. 'Query Loop 14092 * displays a list of posts or pages.'). 14093 * 14094 * Contrast with `displayBlockRemovalPrompt`. 14095 * 14096 * @param {Record<string,string>|false} rules Block removal rules. 14097 * @return {Object} Action object. 14098 */ 14099 function setBlockRemovalRules(rules = false) { 14100 return { 14101 type: 'SET_BLOCK_REMOVAL_RULES', 14102 rules 14103 }; 14104 } 14105 14106 /** 14107 * Sets the client ID of the block settings menu that is currently open. 14108 * 14109 * @param {?string} clientId The block client ID. 14110 * @return {Object} Action object. 14111 */ 14112 function setOpenedBlockSettingsMenu(clientId) { 14113 return { 14114 type: 'SET_OPENED_BLOCK_SETTINGS_MENU', 14115 clientId 14116 }; 14117 } 14118 function setStyleOverride(id, style) { 14119 return { 14120 type: 'SET_STYLE_OVERRIDE', 14121 id, 14122 style 14123 }; 14124 } 14125 function deleteStyleOverride(id) { 14126 return { 14127 type: 'DELETE_STYLE_OVERRIDE', 14128 id 14129 }; 14130 } 14131 14132 /** 14133 * Action that sets the element that had focus when focus leaves the editor canvas. 14134 * 14135 * @param {Object} lastFocus The last focused element. 14136 * 14137 * 14138 * @return {Object} Action object. 14139 */ 14140 function setLastFocus(lastFocus = null) { 14141 return { 14142 type: 'LAST_FOCUS', 14143 lastFocus 14144 }; 14145 } 14146 14147 /** 14148 * Action that stops temporarily editing as blocks. 14149 * 14150 * @param {string} clientId The block's clientId. 14151 */ 14152 function stopEditingAsBlocks(clientId) { 14153 return ({ 14154 select, 14155 dispatch, 14156 registry 14157 }) => { 14158 const focusModeToRevert = unlock(registry.select(store)).getTemporarilyEditingFocusModeToRevert(); 14159 dispatch.__unstableMarkNextChangeAsNotPersistent(); 14160 dispatch.updateBlockAttributes(clientId, { 14161 templateLock: 'contentOnly' 14162 }); 14163 dispatch.updateBlockListSettings(clientId, { 14164 ...select.getBlockListSettings(clientId), 14165 templateLock: 'contentOnly' 14166 }); 14167 dispatch.updateSettings({ 14168 focusMode: focusModeToRevert 14169 }); 14170 dispatch.__unstableSetTemporarilyEditingAsBlocks(); 14171 }; 14172 } 14173 14174 /** 14175 * Returns an action object used in signalling that the user has begun to drag. 14176 * 14177 * @return {Object} Action object. 14178 */ 14179 function startDragging() { 14180 return { 14181 type: 'START_DRAGGING' 14182 }; 14183 } 14184 14185 /** 14186 * Returns an action object used in signalling that the user has stopped dragging. 14187 * 14188 * @return {Object} Action object. 14189 */ 14190 function stopDragging() { 14191 return { 14192 type: 'STOP_DRAGGING' 14193 }; 14194 } 14195 14196 /** 14197 * @param {string|null} clientId The block's clientId, or `null` to clear. 14198 * 14199 * @return {Object} Action object. 14200 */ 14201 function expandBlock(clientId) { 14202 return { 14203 type: 'SET_BLOCK_EXPANDED_IN_LIST_VIEW', 14204 clientId 14205 }; 14206 } 14207 14208 /** 14209 * Temporarily modify/unlock the content-only block for editions. 14210 * 14211 * @param {string} clientId The client id of the block. 14212 */ 14213 const modifyContentLockBlock = clientId => ({ 14214 select, 14215 dispatch 14216 }) => { 14217 dispatch.selectBlock(clientId); 14218 dispatch.__unstableMarkNextChangeAsNotPersistent(); 14219 dispatch.updateBlockAttributes(clientId, { 14220 templateLock: undefined 14221 }); 14222 dispatch.updateBlockListSettings(clientId, { 14223 ...select.getBlockListSettings(clientId), 14224 templateLock: false 14225 }); 14226 const focusModeToRevert = select.getSettings().focusMode; 14227 dispatch.updateSettings({ 14228 focusMode: true 14229 }); 14230 dispatch.__unstableSetTemporarilyEditingAsBlocks(clientId, focusModeToRevert); 14231 }; 14232 14233 /** 14234 * Sets the zoom level. 14235 * 14236 * @param {number} zoom the new zoom level 14237 * @return {Object} Action object. 14238 */ 14239 function setZoomLevel(zoom = 100) { 14240 return { 14241 type: 'SET_ZOOM_LEVEL', 14242 zoom 14243 }; 14244 } 14245 14246 /** 14247 * Resets the Zoom state. 14248 * @return {Object} Action object. 14249 */ 14250 function resetZoomLevel() { 14251 return { 14252 type: 'RESET_ZOOM_LEVEL' 14253 }; 14254 } 14255 14256 ;// external ["wp","a11y"] 14257 const external_wp_a11y_namespaceObject = window["wp"]["a11y"]; 14258 ;// external ["wp","notices"] 14259 const external_wp_notices_namespaceObject = window["wp"]["notices"]; 14260 ;// ./node_modules/@wordpress/block-editor/build-module/utils/selection.js 14261 /** 14262 * WordPress dependencies 14263 */ 14264 14265 14266 /** 14267 * A robust way to retain selection position through various 14268 * transforms is to insert a special character at the position and 14269 * then recover it. 14270 */ 14271 const START_OF_SELECTED_AREA = '\u0086'; 14272 14273 /** 14274 * Retrieve the block attribute that contains the selection position. 14275 * 14276 * @param {Object} blockAttributes Block attributes. 14277 * @return {string|void} The name of the block attribute that was previously selected. 14278 */ 14279 function retrieveSelectedAttribute(blockAttributes) { 14280 if (!blockAttributes) { 14281 return; 14282 } 14283 return Object.keys(blockAttributes).find(name => { 14284 const value = blockAttributes[name]; 14285 return (typeof value === 'string' || value instanceof external_wp_richText_namespaceObject.RichTextData) && 14286 // To do: refactor this to use rich text's selection instead, so we 14287 // no longer have to use on this hack inserting a special character. 14288 value.toString().indexOf(START_OF_SELECTED_AREA) !== -1; 14289 }); 14290 } 14291 function findRichTextAttributeKey(blockType) { 14292 for (const [key, value] of Object.entries(blockType.attributes)) { 14293 if (value.source === 'rich-text' || value.source === 'html') { 14294 return key; 14295 } 14296 } 14297 } 14298 14299 ;// ./node_modules/@wordpress/block-editor/build-module/store/actions.js 14300 /* eslint no-console: [ 'error', { allow: [ 'error', 'warn' ] } ] */ 14301 /** 14302 * WordPress dependencies 14303 */ 14304 14305 14306 14307 14308 14309 14310 14311 /** 14312 * Internal dependencies 14313 */ 14314 14315 14316 14317 /** @typedef {import('../components/use-on-block-drop/types').WPDropOperation} WPDropOperation */ 14318 14319 const actions_castArray = maybeArray => Array.isArray(maybeArray) ? maybeArray : [maybeArray]; 14320 14321 /** 14322 * Action that resets blocks state to the specified array of blocks, taking precedence 14323 * over any other content reflected as an edit in state. 14324 * 14325 * @param {Array} blocks Array of blocks. 14326 */ 14327 const resetBlocks = blocks => ({ 14328 dispatch 14329 }) => { 14330 dispatch({ 14331 type: 'RESET_BLOCKS', 14332 blocks 14333 }); 14334 dispatch(validateBlocksToTemplate(blocks)); 14335 }; 14336 14337 /** 14338 * Block validity is a function of blocks state (at the point of a 14339 * reset) and the template setting. As a compromise to its placement 14340 * across distinct parts of state, it is implemented here as a side 14341 * effect of the block reset action. 14342 * 14343 * @param {Array} blocks Array of blocks. 14344 */ 14345 const validateBlocksToTemplate = blocks => ({ 14346 select, 14347 dispatch 14348 }) => { 14349 const template = select.getTemplate(); 14350 const templateLock = select.getTemplateLock(); 14351 14352 // Unlocked templates are considered always valid because they act 14353 // as default values only. 14354 const isBlocksValidToTemplate = !template || templateLock !== 'all' || (0,external_wp_blocks_namespaceObject.doBlocksMatchTemplate)(blocks, template); 14355 14356 // Update if validity has changed. 14357 const isValidTemplate = select.isValidTemplate(); 14358 if (isBlocksValidToTemplate !== isValidTemplate) { 14359 dispatch.setTemplateValidity(isBlocksValidToTemplate); 14360 return isBlocksValidToTemplate; 14361 } 14362 }; 14363 14364 /** 14365 * A block selection object. 14366 * 14367 * @typedef {Object} WPBlockSelection 14368 * 14369 * @property {string} clientId A block client ID. 14370 * @property {string} attributeKey A block attribute key. 14371 * @property {number} offset An attribute value offset, based on the rich 14372 * text value. See `wp.richText.create`. 14373 */ 14374 14375 /** 14376 * A selection object. 14377 * 14378 * @typedef {Object} WPSelection 14379 * 14380 * @property {WPBlockSelection} start The selection start. 14381 * @property {WPBlockSelection} end The selection end. 14382 */ 14383 14384 /* eslint-disable jsdoc/valid-types */ 14385 /** 14386 * Returns an action object used in signalling that selection state should be 14387 * reset to the specified selection. 14388 * 14389 * @param {WPBlockSelection} selectionStart The selection start. 14390 * @param {WPBlockSelection} selectionEnd The selection end. 14391 * @param {0|-1|null} initialPosition Initial block position. 14392 * 14393 * @return {Object} Action object. 14394 */ 14395 function resetSelection(selectionStart, selectionEnd, initialPosition) { 14396 /* eslint-enable jsdoc/valid-types */ 14397 return { 14398 type: 'RESET_SELECTION', 14399 selectionStart, 14400 selectionEnd, 14401 initialPosition 14402 }; 14403 } 14404 14405 /** 14406 * Returns an action object used in signalling that blocks have been received. 14407 * Unlike resetBlocks, these should be appended to the existing known set, not 14408 * replacing. 14409 * 14410 * @deprecated 14411 * 14412 * @param {Object[]} blocks Array of block objects. 14413 * 14414 * @return {Object} Action object. 14415 */ 14416 function receiveBlocks(blocks) { 14417 external_wp_deprecated_default()('wp.data.dispatch( "core/block-editor" ).receiveBlocks', { 14418 since: '5.9', 14419 alternative: 'resetBlocks or insertBlocks' 14420 }); 14421 return { 14422 type: 'RECEIVE_BLOCKS', 14423 blocks 14424 }; 14425 } 14426 14427 /** 14428 * Action that updates attributes of multiple blocks with the specified client IDs. 14429 * 14430 * @param {string|string[]} clientIds Block client IDs. 14431 * @param {Object} attributes Block attributes to be merged. Should be keyed by clientIds if 14432 * uniqueByBlock is true. 14433 * @param {boolean} uniqueByBlock true if each block in clientIds array has a unique set of attributes 14434 * @return {Object} Action object. 14435 */ 14436 function updateBlockAttributes(clientIds, attributes, uniqueByBlock = false) { 14437 return { 14438 type: 'UPDATE_BLOCK_ATTRIBUTES', 14439 clientIds: actions_castArray(clientIds), 14440 attributes, 14441 uniqueByBlock 14442 }; 14443 } 14444 14445 /** 14446 * Action that updates the block with the specified client ID. 14447 * 14448 * @param {string} clientId Block client ID. 14449 * @param {Object} updates Block attributes to be merged. 14450 * 14451 * @return {Object} Action object. 14452 */ 14453 function updateBlock(clientId, updates) { 14454 return { 14455 type: 'UPDATE_BLOCK', 14456 clientId, 14457 updates 14458 }; 14459 } 14460 14461 /* eslint-disable jsdoc/valid-types */ 14462 /** 14463 * Returns an action object used in signalling that the block with the 14464 * specified client ID has been selected, optionally accepting a position 14465 * value reflecting its selection directionality. An initialPosition of -1 14466 * reflects a reverse selection. 14467 * 14468 * @param {string} clientId Block client ID. 14469 * @param {0|-1|null} initialPosition Optional initial position. Pass as -1 to 14470 * reflect reverse selection. 14471 * 14472 * @return {Object} Action object. 14473 */ 14474 function selectBlock(clientId, initialPosition = 0) { 14475 /* eslint-enable jsdoc/valid-types */ 14476 return { 14477 type: 'SELECT_BLOCK', 14478 initialPosition, 14479 clientId 14480 }; 14481 } 14482 14483 /** 14484 * Returns an action object used in signalling that the block with the 14485 * specified client ID has been hovered. 14486 * 14487 * @param {string} clientId Block client ID. 14488 * 14489 * @return {Object} Action object. 14490 */ 14491 function hoverBlock(clientId) { 14492 return { 14493 type: 'HOVER_BLOCK', 14494 clientId 14495 }; 14496 } 14497 14498 /** 14499 * Yields action objects used in signalling that the block preceding the given 14500 * clientId (or optionally, its first parent from bottom to top) 14501 * should be selected. 14502 * 14503 * @param {string} clientId Block client ID. 14504 * @param {boolean} fallbackToParent If true, select the first parent if there is no previous block. 14505 */ 14506 const selectPreviousBlock = (clientId, fallbackToParent = false) => ({ 14507 select, 14508 dispatch 14509 }) => { 14510 const previousBlockClientId = select.getPreviousBlockClientId(clientId); 14511 if (previousBlockClientId) { 14512 dispatch.selectBlock(previousBlockClientId, -1); 14513 } else if (fallbackToParent) { 14514 const firstParentClientId = select.getBlockRootClientId(clientId); 14515 if (firstParentClientId) { 14516 dispatch.selectBlock(firstParentClientId, -1); 14517 } 14518 } 14519 }; 14520 14521 /** 14522 * Yields action objects used in signalling that the block following the given 14523 * clientId should be selected. 14524 * 14525 * @param {string} clientId Block client ID. 14526 */ 14527 const selectNextBlock = clientId => ({ 14528 select, 14529 dispatch 14530 }) => { 14531 const nextBlockClientId = select.getNextBlockClientId(clientId); 14532 if (nextBlockClientId) { 14533 dispatch.selectBlock(nextBlockClientId); 14534 } 14535 }; 14536 14537 /** 14538 * Action that starts block multi-selection. 14539 * 14540 * @return {Object} Action object. 14541 */ 14542 function startMultiSelect() { 14543 return { 14544 type: 'START_MULTI_SELECT' 14545 }; 14546 } 14547 14548 /** 14549 * Action that stops block multi-selection. 14550 * 14551 * @return {Object} Action object. 14552 */ 14553 function stopMultiSelect() { 14554 return { 14555 type: 'STOP_MULTI_SELECT' 14556 }; 14557 } 14558 14559 /** 14560 * Action that changes block multi-selection. 14561 * 14562 * @param {string} start First block of the multi selection. 14563 * @param {string} end Last block of the multiselection. 14564 * @param {number|null} __experimentalInitialPosition Optional initial position. Pass as null to skip focus within editor canvas. 14565 */ 14566 const multiSelect = (start, end, __experimentalInitialPosition = 0) => ({ 14567 select, 14568 dispatch 14569 }) => { 14570 const startBlockRootClientId = select.getBlockRootClientId(start); 14571 const endBlockRootClientId = select.getBlockRootClientId(end); 14572 14573 // Only allow block multi-selections at the same level. 14574 if (startBlockRootClientId !== endBlockRootClientId) { 14575 return; 14576 } 14577 dispatch({ 14578 type: 'MULTI_SELECT', 14579 start, 14580 end, 14581 initialPosition: __experimentalInitialPosition 14582 }); 14583 const blockCount = select.getSelectedBlockCount(); 14584 (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: number of selected blocks */ 14585 (0,external_wp_i18n_namespaceObject._n)('%s block selected.', '%s blocks selected.', blockCount), blockCount), 'assertive'); 14586 }; 14587 14588 /** 14589 * Action that clears the block selection. 14590 * 14591 * @return {Object} Action object. 14592 */ 14593 function clearSelectedBlock() { 14594 return { 14595 type: 'CLEAR_SELECTED_BLOCK' 14596 }; 14597 } 14598 14599 /** 14600 * Action that enables or disables block selection. 14601 * 14602 * @param {boolean} [isSelectionEnabled=true] Whether block selection should 14603 * be enabled. 14604 * 14605 * @return {Object} Action object. 14606 */ 14607 function toggleSelection(isSelectionEnabled = true) { 14608 return { 14609 type: 'TOGGLE_SELECTION', 14610 isSelectionEnabled 14611 }; 14612 } 14613 14614 /* eslint-disable jsdoc/valid-types */ 14615 /** 14616 * Action that replaces given blocks with one or more replacement blocks. 14617 * 14618 * @param {(string|string[])} clientIds Block client ID(s) to replace. 14619 * @param {(Object|Object[])} blocks Replacement block(s). 14620 * @param {number} indexToSelect Index of replacement block to select. 14621 * @param {0|-1|null} initialPosition Index of caret after in the selected block after the operation. 14622 * @param {?Object} meta Optional Meta values to be passed to the action object. 14623 * 14624 * @return {Object} Action object. 14625 */ 14626 const replaceBlocks = (clientIds, blocks, indexToSelect, initialPosition = 0, meta) => ({ 14627 select, 14628 dispatch, 14629 registry 14630 }) => { 14631 /* eslint-enable jsdoc/valid-types */ 14632 clientIds = actions_castArray(clientIds); 14633 blocks = actions_castArray(blocks); 14634 const rootClientId = select.getBlockRootClientId(clientIds[0]); 14635 // Replace is valid if the new blocks can be inserted in the root block. 14636 for (let index = 0; index < blocks.length; index++) { 14637 const block = blocks[index]; 14638 const canInsertBlock = select.canInsertBlockType(block.name, rootClientId); 14639 if (!canInsertBlock) { 14640 return; 14641 } 14642 } 14643 // We're batching these two actions because an extra `undo/redo` step can 14644 // be created, based on whether we insert a default block or not. 14645 registry.batch(() => { 14646 dispatch({ 14647 type: 'REPLACE_BLOCKS', 14648 clientIds, 14649 blocks, 14650 time: Date.now(), 14651 indexToSelect, 14652 initialPosition, 14653 meta 14654 }); 14655 // To avoid a focus loss when removing the last block, assure there is 14656 // always a default block if the last of the blocks have been removed. 14657 dispatch.ensureDefaultBlock(); 14658 }); 14659 }; 14660 14661 /** 14662 * Action that replaces a single block with one or more replacement blocks. 14663 * 14664 * @param {(string|string[])} clientId Block client ID to replace. 14665 * @param {(Object|Object[])} block Replacement block(s). 14666 * 14667 * @return {Object} Action object. 14668 */ 14669 function replaceBlock(clientId, block) { 14670 return replaceBlocks(clientId, block); 14671 } 14672 14673 /** 14674 * Higher-order action creator which, given the action type to dispatch creates 14675 * an action creator for managing block movement. 14676 * 14677 * @param {string} type Action type to dispatch. 14678 * 14679 * @return {Function} Action creator. 14680 */ 14681 const createOnMove = type => (clientIds, rootClientId) => ({ 14682 select, 14683 dispatch 14684 }) => { 14685 // If one of the blocks is locked or the parent is locked, we cannot move any block. 14686 const canMoveBlocks = select.canMoveBlocks(clientIds); 14687 if (!canMoveBlocks) { 14688 return; 14689 } 14690 dispatch({ 14691 type, 14692 clientIds: actions_castArray(clientIds), 14693 rootClientId 14694 }); 14695 }; 14696 const moveBlocksDown = createOnMove('MOVE_BLOCKS_DOWN'); 14697 const moveBlocksUp = createOnMove('MOVE_BLOCKS_UP'); 14698 14699 /** 14700 * Action that moves given blocks to a new position. 14701 * 14702 * @param {?string} clientIds The client IDs of the blocks. 14703 * @param {?string} fromRootClientId Root client ID source. 14704 * @param {?string} toRootClientId Root client ID destination. 14705 * @param {number} index The index to move the blocks to. 14706 */ 14707 const moveBlocksToPosition = (clientIds, fromRootClientId = '', toRootClientId = '', index) => ({ 14708 select, 14709 dispatch 14710 }) => { 14711 const canMoveBlocks = select.canMoveBlocks(clientIds); 14712 14713 // If one of the blocks is locked or the parent is locked, we cannot move any block. 14714 if (!canMoveBlocks) { 14715 return; 14716 } 14717 14718 // If moving inside the same root block the move is always possible. 14719 if (fromRootClientId !== toRootClientId) { 14720 const canRemoveBlocks = select.canRemoveBlocks(clientIds); 14721 14722 // If we're moving to another block, it means we're deleting blocks from 14723 // the original block, so we need to check if removing is possible. 14724 if (!canRemoveBlocks) { 14725 return; 14726 } 14727 const canInsertBlocks = select.canInsertBlocks(clientIds, toRootClientId); 14728 14729 // If moving to other parent block, the move is possible if we can insert a block of the same type inside the new parent block. 14730 if (!canInsertBlocks) { 14731 return; 14732 } 14733 } 14734 dispatch({ 14735 type: 'MOVE_BLOCKS_TO_POSITION', 14736 fromRootClientId, 14737 toRootClientId, 14738 clientIds, 14739 index 14740 }); 14741 }; 14742 14743 /** 14744 * Action that moves given block to a new position. 14745 * 14746 * @param {?string} clientId The client ID of the block. 14747 * @param {?string} fromRootClientId Root client ID source. 14748 * @param {?string} toRootClientId Root client ID destination. 14749 * @param {number} index The index to move the block to. 14750 */ 14751 function moveBlockToPosition(clientId, fromRootClientId = '', toRootClientId = '', index) { 14752 return moveBlocksToPosition([clientId], fromRootClientId, toRootClientId, index); 14753 } 14754 14755 /** 14756 * Action that inserts a single block, optionally at a specific index respective a root block list. 14757 * 14758 * Only allowed blocks are inserted. The action may fail silently for blocks that are not allowed or if 14759 * a templateLock is active on the block list. 14760 * 14761 * @param {Object} block Block object to insert. 14762 * @param {?number} index Index at which block should be inserted. 14763 * @param {?string} rootClientId Optional root client ID of block list on which to insert. 14764 * @param {?boolean} updateSelection If true block selection will be updated. If false, block selection will not change. Defaults to true. 14765 * @param {?Object} meta Optional Meta values to be passed to the action object. 14766 * 14767 * @return {Object} Action object. 14768 */ 14769 function insertBlock(block, index, rootClientId, updateSelection, meta) { 14770 return insertBlocks([block], index, rootClientId, updateSelection, 0, meta); 14771 } 14772 14773 /* eslint-disable jsdoc/valid-types */ 14774 /** 14775 * Action that inserts an array of blocks, optionally at a specific index respective a root block list. 14776 * 14777 * Only allowed blocks are inserted. The action may fail silently for blocks that are not allowed or if 14778 * a templateLock is active on the block list. 14779 * 14780 * @param {Object[]} blocks Block objects to insert. 14781 * @param {?number} index Index at which block should be inserted. 14782 * @param {?string} rootClientId Optional root client ID of block list on which to insert. 14783 * @param {?boolean} updateSelection If true block selection will be updated. If false, block selection will not change. Defaults to true. 14784 * @param {0|-1|null} initialPosition Initial focus position. Setting it to null prevent focusing the inserted block. 14785 * @param {?Object} meta Optional Meta values to be passed to the action object. 14786 * 14787 * @return {Object} Action object. 14788 */ 14789 const insertBlocks = (blocks, index, rootClientId, updateSelection = true, initialPosition = 0, meta) => ({ 14790 select, 14791 dispatch 14792 }) => { 14793 /* eslint-enable jsdoc/valid-types */ 14794 if (initialPosition !== null && typeof initialPosition === 'object') { 14795 meta = initialPosition; 14796 initialPosition = 0; 14797 external_wp_deprecated_default()("meta argument in wp.data.dispatch('core/block-editor')", { 14798 since: '5.8', 14799 hint: 'The meta argument is now the 6th argument of the function' 14800 }); 14801 } 14802 blocks = actions_castArray(blocks); 14803 const allowedBlocks = []; 14804 for (const block of blocks) { 14805 const isValid = select.canInsertBlockType(block.name, rootClientId); 14806 if (isValid) { 14807 allowedBlocks.push(block); 14808 } 14809 } 14810 if (allowedBlocks.length) { 14811 dispatch({ 14812 type: 'INSERT_BLOCKS', 14813 blocks: allowedBlocks, 14814 index, 14815 rootClientId, 14816 time: Date.now(), 14817 updateSelection, 14818 initialPosition: updateSelection ? initialPosition : null, 14819 meta 14820 }); 14821 } 14822 }; 14823 14824 /** 14825 * Action that shows the insertion point. 14826 * 14827 * @param {?string} rootClientId Optional root client ID of block list on 14828 * which to insert. 14829 * @param {?number} index Index at which block should be inserted. 14830 * @param {?Object} __unstableOptions Additional options. 14831 * @property {boolean} __unstableWithInserter Whether or not to show an inserter button. 14832 * @property {WPDropOperation} operation The operation to perform when applied, 14833 * either 'insert' or 'replace' for now. 14834 * 14835 * @return {Object} Action object. 14836 */ 14837 function showInsertionPoint(rootClientId, index, __unstableOptions = {}) { 14838 const { 14839 __unstableWithInserter, 14840 operation, 14841 nearestSide 14842 } = __unstableOptions; 14843 return { 14844 type: 'SHOW_INSERTION_POINT', 14845 rootClientId, 14846 index, 14847 __unstableWithInserter, 14848 operation, 14849 nearestSide 14850 }; 14851 } 14852 /** 14853 * Action that hides the insertion point. 14854 */ 14855 const hideInsertionPoint = () => ({ 14856 select, 14857 dispatch 14858 }) => { 14859 if (!select.isBlockInsertionPointVisible()) { 14860 return; 14861 } 14862 dispatch({ 14863 type: 'HIDE_INSERTION_POINT' 14864 }); 14865 }; 14866 14867 /** 14868 * Action that resets the template validity. 14869 * 14870 * @param {boolean} isValid template validity flag. 14871 * 14872 * @return {Object} Action object. 14873 */ 14874 function setTemplateValidity(isValid) { 14875 return { 14876 type: 'SET_TEMPLATE_VALIDITY', 14877 isValid 14878 }; 14879 } 14880 14881 /** 14882 * Action that synchronizes the template with the list of blocks. 14883 * 14884 * @return {Object} Action object. 14885 */ 14886 const synchronizeTemplate = () => ({ 14887 select, 14888 dispatch 14889 }) => { 14890 dispatch({ 14891 type: 'SYNCHRONIZE_TEMPLATE' 14892 }); 14893 const blocks = select.getBlocks(); 14894 const template = select.getTemplate(); 14895 const updatedBlockList = (0,external_wp_blocks_namespaceObject.synchronizeBlocksWithTemplate)(blocks, template); 14896 dispatch.resetBlocks(updatedBlockList); 14897 }; 14898 14899 /** 14900 * Delete the current selection. 14901 * 14902 * @param {boolean} isForward 14903 */ 14904 const __unstableDeleteSelection = isForward => ({ 14905 registry, 14906 select, 14907 dispatch 14908 }) => { 14909 const selectionAnchor = select.getSelectionStart(); 14910 const selectionFocus = select.getSelectionEnd(); 14911 if (selectionAnchor.clientId === selectionFocus.clientId) { 14912 return; 14913 } 14914 14915 // It's not mergeable if there's no rich text selection. 14916 if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === 'undefined' || typeof selectionFocus.offset === 'undefined') { 14917 return false; 14918 } 14919 const anchorRootClientId = select.getBlockRootClientId(selectionAnchor.clientId); 14920 const focusRootClientId = select.getBlockRootClientId(selectionFocus.clientId); 14921 14922 // It's not mergeable if the selection doesn't start and end in the same 14923 // block list. Maybe in the future it should be allowed. 14924 if (anchorRootClientId !== focusRootClientId) { 14925 return; 14926 } 14927 const blockOrder = select.getBlockOrder(anchorRootClientId); 14928 const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId); 14929 const focusIndex = blockOrder.indexOf(selectionFocus.clientId); 14930 14931 // Reassign selection start and end based on order. 14932 let selectionStart, selectionEnd; 14933 if (anchorIndex > focusIndex) { 14934 selectionStart = selectionFocus; 14935 selectionEnd = selectionAnchor; 14936 } else { 14937 selectionStart = selectionAnchor; 14938 selectionEnd = selectionFocus; 14939 } 14940 const targetSelection = isForward ? selectionEnd : selectionStart; 14941 const targetBlock = select.getBlock(targetSelection.clientId); 14942 const targetBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(targetBlock.name); 14943 if (!targetBlockType.merge) { 14944 return; 14945 } 14946 const selectionA = selectionStart; 14947 const selectionB = selectionEnd; 14948 const blockA = select.getBlock(selectionA.clientId); 14949 const blockB = select.getBlock(selectionB.clientId); 14950 const htmlA = blockA.attributes[selectionA.attributeKey]; 14951 const htmlB = blockB.attributes[selectionB.attributeKey]; 14952 let valueA = (0,external_wp_richText_namespaceObject.create)({ 14953 html: htmlA 14954 }); 14955 let valueB = (0,external_wp_richText_namespaceObject.create)({ 14956 html: htmlB 14957 }); 14958 valueA = (0,external_wp_richText_namespaceObject.remove)(valueA, selectionA.offset, valueA.text.length); 14959 valueB = (0,external_wp_richText_namespaceObject.insert)(valueB, START_OF_SELECTED_AREA, 0, selectionB.offset); 14960 14961 // Clone the blocks so we don't manipulate the original. 14962 const cloneA = (0,external_wp_blocks_namespaceObject.cloneBlock)(blockA, { 14963 [selectionA.attributeKey]: (0,external_wp_richText_namespaceObject.toHTMLString)({ 14964 value: valueA 14965 }) 14966 }); 14967 const cloneB = (0,external_wp_blocks_namespaceObject.cloneBlock)(blockB, { 14968 [selectionB.attributeKey]: (0,external_wp_richText_namespaceObject.toHTMLString)({ 14969 value: valueB 14970 }) 14971 }); 14972 const followingBlock = isForward ? cloneA : cloneB; 14973 14974 // We can only merge blocks with similar types 14975 // thus, we transform the block to merge first 14976 const blocksWithTheSameType = blockA.name === blockB.name ? [followingBlock] : (0,external_wp_blocks_namespaceObject.switchToBlockType)(followingBlock, targetBlockType.name); 14977 14978 // If the block types can not match, do nothing 14979 if (!blocksWithTheSameType || !blocksWithTheSameType.length) { 14980 return; 14981 } 14982 let updatedAttributes; 14983 if (isForward) { 14984 const blockToMerge = blocksWithTheSameType.pop(); 14985 updatedAttributes = targetBlockType.merge(blockToMerge.attributes, cloneB.attributes); 14986 } else { 14987 const blockToMerge = blocksWithTheSameType.shift(); 14988 updatedAttributes = targetBlockType.merge(cloneA.attributes, blockToMerge.attributes); 14989 } 14990 const newAttributeKey = retrieveSelectedAttribute(updatedAttributes); 14991 const convertedHtml = updatedAttributes[newAttributeKey]; 14992 const convertedValue = (0,external_wp_richText_namespaceObject.create)({ 14993 html: convertedHtml 14994 }); 14995 const newOffset = convertedValue.text.indexOf(START_OF_SELECTED_AREA); 14996 const newValue = (0,external_wp_richText_namespaceObject.remove)(convertedValue, newOffset, newOffset + 1); 14997 const newHtml = (0,external_wp_richText_namespaceObject.toHTMLString)({ 14998 value: newValue 14999 }); 15000 updatedAttributes[newAttributeKey] = newHtml; 15001 const selectedBlockClientIds = select.getSelectedBlockClientIds(); 15002 const replacement = [...(isForward ? blocksWithTheSameType : []), { 15003 // Preserve the original client ID. 15004 ...targetBlock, 15005 attributes: { 15006 ...targetBlock.attributes, 15007 ...updatedAttributes 15008 } 15009 }, ...(isForward ? [] : blocksWithTheSameType)]; 15010 registry.batch(() => { 15011 dispatch.selectionChange(targetBlock.clientId, newAttributeKey, newOffset, newOffset); 15012 dispatch.replaceBlocks(selectedBlockClientIds, replacement, 0, 15013 // If we don't pass the `indexToSelect` it will default to the last block. 15014 select.getSelectedBlocksInitialCaretPosition()); 15015 }); 15016 }; 15017 15018 /** 15019 * Split the current selection. 15020 * @param {?Array} blocks 15021 */ 15022 const __unstableSplitSelection = (blocks = []) => ({ 15023 registry, 15024 select, 15025 dispatch 15026 }) => { 15027 const selectionAnchor = select.getSelectionStart(); 15028 const selectionFocus = select.getSelectionEnd(); 15029 const anchorRootClientId = select.getBlockRootClientId(selectionAnchor.clientId); 15030 const focusRootClientId = select.getBlockRootClientId(selectionFocus.clientId); 15031 15032 // It's not splittable if the selection doesn't start and end in the same 15033 // block list. Maybe in the future it should be allowed. 15034 if (anchorRootClientId !== focusRootClientId) { 15035 return; 15036 } 15037 const blockOrder = select.getBlockOrder(anchorRootClientId); 15038 const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId); 15039 const focusIndex = blockOrder.indexOf(selectionFocus.clientId); 15040 15041 // Reassign selection start and end based on order. 15042 let selectionStart, selectionEnd; 15043 if (anchorIndex > focusIndex) { 15044 selectionStart = selectionFocus; 15045 selectionEnd = selectionAnchor; 15046 } else { 15047 selectionStart = selectionAnchor; 15048 selectionEnd = selectionFocus; 15049 } 15050 const selectionA = selectionStart; 15051 const selectionB = selectionEnd; 15052 const blockA = select.getBlock(selectionA.clientId); 15053 const blockB = select.getBlock(selectionB.clientId); 15054 const blockAType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockA.name); 15055 const blockBType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockB.name); 15056 const attributeKeyA = typeof selectionA.attributeKey === 'string' ? selectionA.attributeKey : findRichTextAttributeKey(blockAType); 15057 const attributeKeyB = typeof selectionB.attributeKey === 'string' ? selectionB.attributeKey : findRichTextAttributeKey(blockBType); 15058 const blockAttributes = select.getBlockAttributes(selectionA.clientId); 15059 const bindings = blockAttributes?.metadata?.bindings; 15060 15061 // If the attribute is bound, don't split the selection and insert a new block instead. 15062 if (bindings?.[attributeKeyA]) { 15063 // Show warning if user tries to insert a block into another block with bindings. 15064 if (blocks.length) { 15065 const { 15066 createWarningNotice 15067 } = registry.dispatch(external_wp_notices_namespaceObject.store); 15068 createWarningNotice((0,external_wp_i18n_namespaceObject.__)("Blocks can't be inserted into other blocks with bindings"), { 15069 type: 'snackbar' 15070 }); 15071 return; 15072 } 15073 dispatch.insertAfterBlock(selectionA.clientId); 15074 return; 15075 } 15076 15077 // Can't split if the selection is not set. 15078 if (!attributeKeyA || !attributeKeyB || typeof selectionAnchor.offset === 'undefined' || typeof selectionFocus.offset === 'undefined') { 15079 return; 15080 } 15081 15082 // We can do some short-circuiting if the selection is collapsed. 15083 if (selectionA.clientId === selectionB.clientId && attributeKeyA === attributeKeyB && selectionA.offset === selectionB.offset) { 15084 // If an unmodified default block is selected, replace it. We don't 15085 // want to be converting into a default block. 15086 if (blocks.length) { 15087 if ((0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(blockA)) { 15088 dispatch.replaceBlocks([selectionA.clientId], blocks, blocks.length - 1, -1); 15089 return; 15090 } 15091 } 15092 15093 // If selection is at the start or end, we can simply insert an 15094 // empty block, provided this block has no inner blocks. 15095 else if (!select.getBlockOrder(selectionA.clientId).length) { 15096 function createEmpty() { 15097 const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)(); 15098 return select.canInsertBlockType(defaultBlockName, anchorRootClientId) ? (0,external_wp_blocks_namespaceObject.createBlock)(defaultBlockName) : (0,external_wp_blocks_namespaceObject.createBlock)(select.getBlockName(selectionA.clientId)); 15099 } 15100 const length = blockAttributes[attributeKeyA].length; 15101 if (selectionA.offset === 0 && length) { 15102 dispatch.insertBlocks([createEmpty()], select.getBlockIndex(selectionA.clientId), anchorRootClientId, false); 15103 return; 15104 } 15105 if (selectionA.offset === length) { 15106 dispatch.insertBlocks([createEmpty()], select.getBlockIndex(selectionA.clientId) + 1, anchorRootClientId); 15107 return; 15108 } 15109 } 15110 } 15111 const htmlA = blockA.attributes[attributeKeyA]; 15112 const htmlB = blockB.attributes[attributeKeyB]; 15113 let valueA = (0,external_wp_richText_namespaceObject.create)({ 15114 html: htmlA 15115 }); 15116 let valueB = (0,external_wp_richText_namespaceObject.create)({ 15117 html: htmlB 15118 }); 15119 valueA = (0,external_wp_richText_namespaceObject.remove)(valueA, selectionA.offset, valueA.text.length); 15120 valueB = (0,external_wp_richText_namespaceObject.remove)(valueB, 0, selectionB.offset); 15121 let head = { 15122 // Preserve the original client ID. 15123 ...blockA, 15124 // If both start and end are the same, should only copy innerBlocks 15125 // once. 15126 innerBlocks: blockA.clientId === blockB.clientId ? [] : blockA.innerBlocks, 15127 attributes: { 15128 ...blockA.attributes, 15129 [attributeKeyA]: (0,external_wp_richText_namespaceObject.toHTMLString)({ 15130 value: valueA 15131 }) 15132 } 15133 }; 15134 let tail = { 15135 ...blockB, 15136 // Only preserve the original client ID if the end is different. 15137 clientId: blockA.clientId === blockB.clientId ? (0,external_wp_blocks_namespaceObject.createBlock)(blockB.name).clientId : blockB.clientId, 15138 attributes: { 15139 ...blockB.attributes, 15140 [attributeKeyB]: (0,external_wp_richText_namespaceObject.toHTMLString)({ 15141 value: valueB 15142 }) 15143 } 15144 }; 15145 15146 // When splitting a block, attempt to convert the tail block to the 15147 // default block type. For example, when splitting a heading block, the 15148 // tail block will be converted to a paragraph block. Note that for 15149 // blocks such as a list item and button, this will be skipped because 15150 // the default block type cannot be inserted. 15151 const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)(); 15152 if ( 15153 // A block is only split when the selection is within the same 15154 // block. 15155 blockA.clientId === blockB.clientId && defaultBlockName && tail.name !== defaultBlockName && select.canInsertBlockType(defaultBlockName, anchorRootClientId)) { 15156 const switched = (0,external_wp_blocks_namespaceObject.switchToBlockType)(tail, defaultBlockName); 15157 if (switched?.length === 1) { 15158 tail = switched[0]; 15159 } 15160 } 15161 if (!blocks.length) { 15162 dispatch.replaceBlocks(select.getSelectedBlockClientIds(), [head, tail]); 15163 return; 15164 } 15165 let selection; 15166 const output = []; 15167 const clonedBlocks = [...blocks]; 15168 const firstBlock = clonedBlocks.shift(); 15169 const headType = (0,external_wp_blocks_namespaceObject.getBlockType)(head.name); 15170 const firstBlocks = headType.merge && firstBlock.name === headType.name ? [firstBlock] : (0,external_wp_blocks_namespaceObject.switchToBlockType)(firstBlock, headType.name); 15171 if (firstBlocks?.length) { 15172 const first = firstBlocks.shift(); 15173 head = { 15174 ...head, 15175 attributes: { 15176 ...head.attributes, 15177 ...headType.merge(head.attributes, first.attributes) 15178 } 15179 }; 15180 output.push(head); 15181 selection = { 15182 clientId: head.clientId, 15183 attributeKey: attributeKeyA, 15184 offset: (0,external_wp_richText_namespaceObject.create)({ 15185 html: head.attributes[attributeKeyA] 15186 }).text.length 15187 }; 15188 clonedBlocks.unshift(...firstBlocks); 15189 } else { 15190 if (!(0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(head)) { 15191 output.push(head); 15192 } 15193 output.push(firstBlock); 15194 } 15195 const lastBlock = clonedBlocks.pop(); 15196 const tailType = (0,external_wp_blocks_namespaceObject.getBlockType)(tail.name); 15197 if (clonedBlocks.length) { 15198 output.push(...clonedBlocks); 15199 } 15200 if (lastBlock) { 15201 const lastBlocks = tailType.merge && tailType.name === lastBlock.name ? [lastBlock] : (0,external_wp_blocks_namespaceObject.switchToBlockType)(lastBlock, tailType.name); 15202 if (lastBlocks?.length) { 15203 const last = lastBlocks.pop(); 15204 output.push({ 15205 ...tail, 15206 attributes: { 15207 ...tail.attributes, 15208 ...tailType.merge(last.attributes, tail.attributes) 15209 } 15210 }); 15211 output.push(...lastBlocks); 15212 selection = { 15213 clientId: tail.clientId, 15214 attributeKey: attributeKeyB, 15215 offset: (0,external_wp_richText_namespaceObject.create)({ 15216 html: last.attributes[attributeKeyB] 15217 }).text.length 15218 }; 15219 } else { 15220 output.push(lastBlock); 15221 if (!(0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(tail)) { 15222 output.push(tail); 15223 } 15224 } 15225 } else if (!(0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(tail)) { 15226 output.push(tail); 15227 } 15228 registry.batch(() => { 15229 dispatch.replaceBlocks(select.getSelectedBlockClientIds(), output, output.length - 1, 0); 15230 if (selection) { 15231 dispatch.selectionChange(selection.clientId, selection.attributeKey, selection.offset, selection.offset); 15232 } 15233 }); 15234 }; 15235 15236 /** 15237 * Expand the selection to cover the entire blocks, removing partial selection. 15238 */ 15239 const __unstableExpandSelection = () => ({ 15240 select, 15241 dispatch 15242 }) => { 15243 const selectionAnchor = select.getSelectionStart(); 15244 const selectionFocus = select.getSelectionEnd(); 15245 dispatch.selectionChange({ 15246 start: { 15247 clientId: selectionAnchor.clientId 15248 }, 15249 end: { 15250 clientId: selectionFocus.clientId 15251 } 15252 }); 15253 }; 15254 15255 /** 15256 * Action that merges two blocks. 15257 * 15258 * @param {string} firstBlockClientId Client ID of the first block to merge. 15259 * @param {string} secondBlockClientId Client ID of the second block to merge. 15260 */ 15261 const mergeBlocks = (firstBlockClientId, secondBlockClientId) => ({ 15262 registry, 15263 select, 15264 dispatch 15265 }) => { 15266 const clientIdA = firstBlockClientId; 15267 const clientIdB = secondBlockClientId; 15268 const blockA = select.getBlock(clientIdA); 15269 const blockAType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockA.name); 15270 if (!blockAType) { 15271 return; 15272 } 15273 const blockB = select.getBlock(clientIdB); 15274 if (!blockAType.merge && (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockA.name, '__experimentalOnMerge')) { 15275 // If there's no merge function defined, attempt merging inner 15276 // blocks. 15277 const blocksWithTheSameType = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blockB, blockAType.name); 15278 // Only focus the previous block if it's not mergeable. 15279 if (blocksWithTheSameType?.length !== 1) { 15280 dispatch.selectBlock(blockA.clientId); 15281 return; 15282 } 15283 const [blockWithSameType] = blocksWithTheSameType; 15284 if (blockWithSameType.innerBlocks.length < 1) { 15285 dispatch.selectBlock(blockA.clientId); 15286 return; 15287 } 15288 registry.batch(() => { 15289 dispatch.insertBlocks(blockWithSameType.innerBlocks, undefined, clientIdA); 15290 dispatch.removeBlock(clientIdB); 15291 dispatch.selectBlock(blockWithSameType.innerBlocks[0].clientId); 15292 15293 // Attempt to merge the next block if it's the same type and 15294 // same attributes. This is useful when merging a paragraph into 15295 // a list, and the next block is also a list. If we don't merge, 15296 // it looks like one list, but it's actually two lists. The same 15297 // applies to other blocks such as a group with the same 15298 // attributes. 15299 const nextBlockClientId = select.getNextBlockClientId(clientIdA); 15300 if (nextBlockClientId && select.getBlockName(clientIdA) === select.getBlockName(nextBlockClientId)) { 15301 const rootAttributes = select.getBlockAttributes(clientIdA); 15302 const previousRootAttributes = select.getBlockAttributes(nextBlockClientId); 15303 if (Object.keys(rootAttributes).every(key => rootAttributes[key] === previousRootAttributes[key])) { 15304 dispatch.moveBlocksToPosition(select.getBlockOrder(nextBlockClientId), nextBlockClientId, clientIdA); 15305 dispatch.removeBlock(nextBlockClientId, false); 15306 } 15307 } 15308 }); 15309 return; 15310 } 15311 if ((0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(blockA)) { 15312 dispatch.removeBlock(clientIdA, select.isBlockSelected(clientIdA)); 15313 return; 15314 } 15315 if ((0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(blockB)) { 15316 dispatch.removeBlock(clientIdB, select.isBlockSelected(clientIdB)); 15317 return; 15318 } 15319 if (!blockAType.merge) { 15320 dispatch.selectBlock(blockA.clientId); 15321 return; 15322 } 15323 const blockBType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockB.name); 15324 const { 15325 clientId, 15326 attributeKey, 15327 offset 15328 } = select.getSelectionStart(); 15329 const selectedBlockType = clientId === clientIdA ? blockAType : blockBType; 15330 const attributeDefinition = selectedBlockType.attributes[attributeKey]; 15331 const canRestoreTextSelection = (clientId === clientIdA || clientId === clientIdB) && attributeKey !== undefined && offset !== undefined && 15332 // We cannot restore text selection if the RichText identifier 15333 // is not a defined block attribute key. This can be the case if the 15334 // fallback intance ID is used to store selection (and no RichText 15335 // identifier is set), or when the identifier is wrong. 15336 !!attributeDefinition; 15337 if (!attributeDefinition) { 15338 if (typeof attributeKey === 'number') { 15339 window.console.error(`RichText needs an identifier prop that is the block attribute key of the attribute it controls. Its type is expected to be a string, but was $typeof attributeKey}`); 15340 } else { 15341 window.console.error('The RichText identifier prop does not match any attributes defined by the block.'); 15342 } 15343 } 15344 15345 // Clone the blocks so we don't insert the character in a "live" block. 15346 const cloneA = (0,external_wp_blocks_namespaceObject.cloneBlock)(blockA); 15347 const cloneB = (0,external_wp_blocks_namespaceObject.cloneBlock)(blockB); 15348 if (canRestoreTextSelection) { 15349 const selectedBlock = clientId === clientIdA ? cloneA : cloneB; 15350 const html = selectedBlock.attributes[attributeKey]; 15351 const value = (0,external_wp_richText_namespaceObject.insert)((0,external_wp_richText_namespaceObject.create)({ 15352 html 15353 }), START_OF_SELECTED_AREA, offset, offset); 15354 selectedBlock.attributes[attributeKey] = (0,external_wp_richText_namespaceObject.toHTMLString)({ 15355 value 15356 }); 15357 } 15358 15359 // We can only merge blocks with similar types 15360 // thus, we transform the block to merge first. 15361 const blocksWithTheSameType = blockA.name === blockB.name ? [cloneB] : (0,external_wp_blocks_namespaceObject.switchToBlockType)(cloneB, blockA.name); 15362 15363 // If the block types can not match, do nothing. 15364 if (!blocksWithTheSameType || !blocksWithTheSameType.length) { 15365 return; 15366 } 15367 15368 // Calling the merge to update the attributes and remove the block to be merged. 15369 const updatedAttributes = blockAType.merge(cloneA.attributes, blocksWithTheSameType[0].attributes); 15370 if (canRestoreTextSelection) { 15371 const newAttributeKey = retrieveSelectedAttribute(updatedAttributes); 15372 const convertedHtml = updatedAttributes[newAttributeKey]; 15373 const convertedValue = (0,external_wp_richText_namespaceObject.create)({ 15374 html: convertedHtml 15375 }); 15376 const newOffset = convertedValue.text.indexOf(START_OF_SELECTED_AREA); 15377 const newValue = (0,external_wp_richText_namespaceObject.remove)(convertedValue, newOffset, newOffset + 1); 15378 const newHtml = (0,external_wp_richText_namespaceObject.toHTMLString)({ 15379 value: newValue 15380 }); 15381 updatedAttributes[newAttributeKey] = newHtml; 15382 dispatch.selectionChange(blockA.clientId, newAttributeKey, newOffset, newOffset); 15383 } 15384 dispatch.replaceBlocks([blockA.clientId, blockB.clientId], [{ 15385 ...blockA, 15386 attributes: { 15387 ...blockA.attributes, 15388 ...updatedAttributes 15389 } 15390 }, ...blocksWithTheSameType.slice(1)], 0 // If we don't pass the `indexToSelect` it will default to the last block. 15391 ); 15392 }; 15393 15394 /** 15395 * Yields action objects used in signalling that the blocks corresponding to 15396 * the set of specified client IDs are to be removed. 15397 * 15398 * @param {string|string[]} clientIds Client IDs of blocks to remove. 15399 * @param {boolean} selectPrevious True if the previous block 15400 * or the immediate parent 15401 * (if no previous block exists) 15402 * should be selected 15403 * when a block is removed. 15404 */ 15405 const removeBlocks = (clientIds, selectPrevious = true) => privateRemoveBlocks(clientIds, selectPrevious); 15406 15407 /** 15408 * Returns an action object used in signalling that the block with the 15409 * specified client ID is to be removed. 15410 * 15411 * @param {string} clientId Client ID of block to remove. 15412 * @param {boolean} selectPrevious True if the previous block should be 15413 * selected when a block is removed. 15414 * 15415 * @return {Object} Action object. 15416 */ 15417 function removeBlock(clientId, selectPrevious) { 15418 return removeBlocks([clientId], selectPrevious); 15419 } 15420 15421 /* eslint-disable jsdoc/valid-types */ 15422 /** 15423 * Returns an action object used in signalling that the inner blocks with the 15424 * specified client ID should be replaced. 15425 * 15426 * @param {string} rootClientId Client ID of the block whose InnerBlocks will re replaced. 15427 * @param {Object[]} blocks Block objects to insert as new InnerBlocks 15428 * @param {?boolean} updateSelection If true block selection will be updated. If false, block selection will not change. Defaults to false. 15429 * @param {0|-1|null} initialPosition Initial block position. 15430 * @return {Object} Action object. 15431 */ 15432 function replaceInnerBlocks(rootClientId, blocks, updateSelection = false, initialPosition = 0) { 15433 /* eslint-enable jsdoc/valid-types */ 15434 return { 15435 type: 'REPLACE_INNER_BLOCKS', 15436 rootClientId, 15437 blocks, 15438 updateSelection, 15439 initialPosition: updateSelection ? initialPosition : null, 15440 time: Date.now() 15441 }; 15442 } 15443 15444 /** 15445 * Returns an action object used to toggle the block editing mode between 15446 * visual and HTML modes. 15447 * 15448 * @param {string} clientId Block client ID. 15449 * 15450 * @return {Object} Action object. 15451 */ 15452 function toggleBlockMode(clientId) { 15453 return { 15454 type: 'TOGGLE_BLOCK_MODE', 15455 clientId 15456 }; 15457 } 15458 15459 /** 15460 * Returns an action object used in signalling that the user has begun to type. 15461 * 15462 * @return {Object} Action object. 15463 */ 15464 function startTyping() { 15465 return { 15466 type: 'START_TYPING' 15467 }; 15468 } 15469 15470 /** 15471 * Returns an action object used in signalling that the user has stopped typing. 15472 * 15473 * @return {Object} Action object. 15474 */ 15475 function stopTyping() { 15476 return { 15477 type: 'STOP_TYPING' 15478 }; 15479 } 15480 15481 /** 15482 * Returns an action object used in signalling that the user has begun to drag blocks. 15483 * 15484 * @param {string[]} clientIds An array of client ids being dragged 15485 * 15486 * @return {Object} Action object. 15487 */ 15488 function startDraggingBlocks(clientIds = []) { 15489 return { 15490 type: 'START_DRAGGING_BLOCKS', 15491 clientIds 15492 }; 15493 } 15494 15495 /** 15496 * Returns an action object used in signalling that the user has stopped dragging blocks. 15497 * 15498 * @return {Object} Action object. 15499 */ 15500 function stopDraggingBlocks() { 15501 return { 15502 type: 'STOP_DRAGGING_BLOCKS' 15503 }; 15504 } 15505 15506 /** 15507 * Returns an action object used in signalling that the caret has entered formatted text. 15508 * 15509 * @deprecated 15510 * 15511 * @return {Object} Action object. 15512 */ 15513 function enterFormattedText() { 15514 external_wp_deprecated_default()('wp.data.dispatch( "core/block-editor" ).enterFormattedText', { 15515 since: '6.1', 15516 version: '6.3' 15517 }); 15518 return { 15519 type: 'DO_NOTHING' 15520 }; 15521 } 15522 15523 /** 15524 * Returns an action object used in signalling that the user caret has exited formatted text. 15525 * 15526 * @deprecated 15527 * 15528 * @return {Object} Action object. 15529 */ 15530 function exitFormattedText() { 15531 external_wp_deprecated_default()('wp.data.dispatch( "core/block-editor" ).exitFormattedText', { 15532 since: '6.1', 15533 version: '6.3' 15534 }); 15535 return { 15536 type: 'DO_NOTHING' 15537 }; 15538 } 15539 15540 /** 15541 * Action that changes the position of the user caret. 15542 * 15543 * @param {string|WPSelection} clientId The selected block client ID. 15544 * @param {string} attributeKey The selected block attribute key. 15545 * @param {number} startOffset The start offset. 15546 * @param {number} endOffset The end offset. 15547 * 15548 * @return {Object} Action object. 15549 */ 15550 function selectionChange(clientId, attributeKey, startOffset, endOffset) { 15551 if (typeof clientId === 'string') { 15552 return { 15553 type: 'SELECTION_CHANGE', 15554 clientId, 15555 attributeKey, 15556 startOffset, 15557 endOffset 15558 }; 15559 } 15560 return { 15561 type: 'SELECTION_CHANGE', 15562 ...clientId 15563 }; 15564 } 15565 15566 /** 15567 * Action that adds a new block of the default type to the block list. 15568 * 15569 * @param {?Object} attributes Optional attributes of the block to assign. 15570 * @param {?string} rootClientId Optional root client ID of block list on which 15571 * to append. 15572 * @param {?number} index Optional index where to insert the default block. 15573 */ 15574 const insertDefaultBlock = (attributes, rootClientId, index) => ({ 15575 dispatch 15576 }) => { 15577 // Abort if there is no default block type (if it has been unregistered). 15578 const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)(); 15579 if (!defaultBlockName) { 15580 return; 15581 } 15582 const block = (0,external_wp_blocks_namespaceObject.createBlock)(defaultBlockName, attributes); 15583 return dispatch.insertBlock(block, index, rootClientId); 15584 }; 15585 15586 /** 15587 * @typedef {Object< string, Object >} SettingsByClientId 15588 */ 15589 15590 /** 15591 * Action that changes the nested settings of the given block(s). 15592 * 15593 * @param {string | SettingsByClientId} clientId Client ID of the block whose 15594 * nested setting are being 15595 * received, or object of settings 15596 * by client ID. 15597 * @param {Object} settings Object with the new settings 15598 * for the nested block. 15599 * 15600 * @return {Object} Action object 15601 */ 15602 function updateBlockListSettings(clientId, settings) { 15603 return { 15604 type: 'UPDATE_BLOCK_LIST_SETTINGS', 15605 clientId, 15606 settings 15607 }; 15608 } 15609 15610 /** 15611 * Action that updates the block editor settings. 15612 * 15613 * @param {Object} settings Updated settings 15614 * 15615 * @return {Object} Action object 15616 */ 15617 function updateSettings(settings) { 15618 return __experimentalUpdateSettings(settings, { 15619 stripExperimentalSettings: true 15620 }); 15621 } 15622 15623 /** 15624 * Action that signals that a temporary reusable block has been saved 15625 * in order to switch its temporary id with the real id. 15626 * 15627 * @param {string} id Reusable block's id. 15628 * @param {string} updatedId Updated block's id. 15629 * 15630 * @return {Object} Action object. 15631 */ 15632 function __unstableSaveReusableBlock(id, updatedId) { 15633 return { 15634 type: 'SAVE_REUSABLE_BLOCK_SUCCESS', 15635 id, 15636 updatedId 15637 }; 15638 } 15639 15640 /** 15641 * Action that marks the last block change explicitly as persistent. 15642 * 15643 * @return {Object} Action object. 15644 */ 15645 function __unstableMarkLastChangeAsPersistent() { 15646 return { 15647 type: 'MARK_LAST_CHANGE_AS_PERSISTENT' 15648 }; 15649 } 15650 15651 /** 15652 * Action that signals that the next block change should be marked explicitly as not persistent. 15653 * 15654 * @return {Object} Action object. 15655 */ 15656 function __unstableMarkNextChangeAsNotPersistent() { 15657 return { 15658 type: 'MARK_NEXT_CHANGE_AS_NOT_PERSISTENT' 15659 }; 15660 } 15661 15662 /** 15663 * Action that marks the last block change as an automatic change, meaning it was not 15664 * performed by the user, and can be undone using the `Escape` and `Backspace` keys. 15665 * This action must be called after the change was made, and any actions that are a 15666 * consequence of it, so it is recommended to be called at the next idle period to ensure all 15667 * selection changes have been recorded. 15668 */ 15669 const __unstableMarkAutomaticChange = () => ({ 15670 dispatch 15671 }) => { 15672 dispatch({ 15673 type: 'MARK_AUTOMATIC_CHANGE' 15674 }); 15675 const { 15676 requestIdleCallback = cb => setTimeout(cb, 100) 15677 } = window; 15678 requestIdleCallback(() => { 15679 dispatch({ 15680 type: 'MARK_AUTOMATIC_CHANGE_FINAL' 15681 }); 15682 }); 15683 }; 15684 15685 /** 15686 * Action that enables or disables the navigation mode. 15687 * 15688 * @param {boolean} isNavigationMode Enable/Disable navigation mode. 15689 */ 15690 const setNavigationMode = (isNavigationMode = true) => ({ 15691 dispatch 15692 }) => { 15693 dispatch.__unstableSetEditorMode(isNavigationMode ? 'navigation' : 'edit'); 15694 }; 15695 15696 /** 15697 * Action that sets the editor mode 15698 * 15699 * @param {string} mode Editor mode 15700 */ 15701 const __unstableSetEditorMode = mode => ({ 15702 dispatch, 15703 select 15704 }) => { 15705 // When switching to zoom-out mode, we need to select the parent section 15706 if (mode === 'zoom-out') { 15707 const firstSelectedClientId = select.getBlockSelectionStart(); 15708 const sectionRootClientId = select.getSectionRootClientId(); 15709 if (firstSelectedClientId) { 15710 let sectionClientId; 15711 if (sectionRootClientId) { 15712 const sectionClientIds = select.getBlockOrder(sectionRootClientId); 15713 15714 // If the selected block is a section block, use it. 15715 if (sectionClientIds?.includes(firstSelectedClientId)) { 15716 sectionClientId = firstSelectedClientId; 15717 } else { 15718 // If the selected block is not a section block, find 15719 // the parent section that contains the selected block. 15720 sectionClientId = select.getBlockParents(firstSelectedClientId).find(parent => sectionClientIds.includes(parent)); 15721 } 15722 } else { 15723 sectionClientId = select.getBlockHierarchyRootClientId(firstSelectedClientId); 15724 } 15725 if (sectionClientId) { 15726 dispatch.selectBlock(sectionClientId); 15727 } else { 15728 dispatch.clearSelectedBlock(); 15729 } 15730 } 15731 } 15732 dispatch({ 15733 type: 'SET_EDITOR_MODE', 15734 mode 15735 }); 15736 if (mode === 'navigation') { 15737 (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('You are currently in navigation mode. Navigate blocks using the Tab key and Arrow keys. Use Left and Right Arrow keys to move between nesting levels. To exit navigation mode and edit the selected block, press Enter.')); 15738 } else if (mode === 'edit') { 15739 (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('You are currently in edit mode. To return to the navigation mode, press Escape.')); 15740 } else if (mode === 'zoom-out') { 15741 (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('You are currently in zoom-out mode.')); 15742 } 15743 }; 15744 15745 /** 15746 * Action that enables or disables the block moving mode. 15747 * 15748 * @param {string|null} hasBlockMovingClientId Enable/Disable block moving mode. 15749 */ 15750 const setBlockMovingClientId = (hasBlockMovingClientId = null) => ({ 15751 dispatch 15752 }) => { 15753 dispatch({ 15754 type: 'SET_BLOCK_MOVING_MODE', 15755 hasBlockMovingClientId 15756 }); 15757 if (hasBlockMovingClientId) { 15758 (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('Use the Tab key and Arrow keys to choose new block location. Use Left and Right Arrow keys to move between nesting levels. Once location is selected press Enter or Space to move the block.')); 15759 } 15760 }; 15761 15762 /** 15763 * Action that duplicates a list of blocks. 15764 * 15765 * @param {string[]} clientIds 15766 * @param {boolean} updateSelection 15767 */ 15768 const duplicateBlocks = (clientIds, updateSelection = true) => ({ 15769 select, 15770 dispatch 15771 }) => { 15772 if (!clientIds || !clientIds.length) { 15773 return; 15774 } 15775 15776 // Return early if blocks don't exist. 15777 const blocks = select.getBlocksByClientId(clientIds); 15778 if (blocks.some(block => !block)) { 15779 return; 15780 } 15781 15782 // Return early if blocks don't support multiple usage. 15783 const blockNames = blocks.map(block => block.name); 15784 if (blockNames.some(blockName => !(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, 'multiple', true))) { 15785 return; 15786 } 15787 const rootClientId = select.getBlockRootClientId(clientIds[0]); 15788 const clientIdsArray = actions_castArray(clientIds); 15789 const lastSelectedIndex = select.getBlockIndex(clientIdsArray[clientIdsArray.length - 1]); 15790 const clonedBlocks = blocks.map(block => (0,external_wp_blocks_namespaceObject.__experimentalCloneSanitizedBlock)(block)); 15791 dispatch.insertBlocks(clonedBlocks, lastSelectedIndex + 1, rootClientId, updateSelection); 15792 if (clonedBlocks.length > 1 && updateSelection) { 15793 dispatch.multiSelect(clonedBlocks[0].clientId, clonedBlocks[clonedBlocks.length - 1].clientId); 15794 } 15795 return clonedBlocks.map(block => block.clientId); 15796 }; 15797 15798 /** 15799 * Action that inserts a default block before a given block. 15800 * 15801 * @param {string} clientId 15802 */ 15803 const insertBeforeBlock = clientId => ({ 15804 select, 15805 dispatch 15806 }) => { 15807 if (!clientId) { 15808 return; 15809 } 15810 const rootClientId = select.getBlockRootClientId(clientId); 15811 const isLocked = select.getTemplateLock(rootClientId); 15812 if (isLocked) { 15813 return; 15814 } 15815 const blockIndex = select.getBlockIndex(clientId); 15816 const directInsertBlock = rootClientId ? select.getDirectInsertBlock(rootClientId) : null; 15817 if (!directInsertBlock) { 15818 return dispatch.insertDefaultBlock({}, rootClientId, blockIndex); 15819 } 15820 const copiedAttributes = {}; 15821 if (directInsertBlock.attributesToCopy) { 15822 const attributes = select.getBlockAttributes(clientId); 15823 directInsertBlock.attributesToCopy.forEach(key => { 15824 if (attributes[key]) { 15825 copiedAttributes[key] = attributes[key]; 15826 } 15827 }); 15828 } 15829 const block = (0,external_wp_blocks_namespaceObject.createBlock)(directInsertBlock.name, { 15830 ...directInsertBlock.attributes, 15831 ...copiedAttributes 15832 }); 15833 return dispatch.insertBlock(block, blockIndex, rootClientId); 15834 }; 15835 15836 /** 15837 * Action that inserts a default block after a given block. 15838 * 15839 * @param {string} clientId 15840 */ 15841 const insertAfterBlock = clientId => ({ 15842 select, 15843 dispatch 15844 }) => { 15845 if (!clientId) { 15846 return; 15847 } 15848 const rootClientId = select.getBlockRootClientId(clientId); 15849 const isLocked = select.getTemplateLock(rootClientId); 15850 if (isLocked) { 15851 return; 15852 } 15853 const blockIndex = select.getBlockIndex(clientId); 15854 const directInsertBlock = rootClientId ? select.getDirectInsertBlock(rootClientId) : null; 15855 if (!directInsertBlock) { 15856 return dispatch.insertDefaultBlock({}, rootClientId, blockIndex + 1); 15857 } 15858 const copiedAttributes = {}; 15859 if (directInsertBlock.attributesToCopy) { 15860 const attributes = select.getBlockAttributes(clientId); 15861 directInsertBlock.attributesToCopy.forEach(key => { 15862 if (attributes[key]) { 15863 copiedAttributes[key] = attributes[key]; 15864 } 15865 }); 15866 } 15867 const block = (0,external_wp_blocks_namespaceObject.createBlock)(directInsertBlock.name, { 15868 ...directInsertBlock.attributes, 15869 ...copiedAttributes 15870 }); 15871 return dispatch.insertBlock(block, blockIndex + 1, rootClientId); 15872 }; 15873 15874 /** 15875 * Action that toggles the highlighted block state. 15876 * 15877 * @param {string} clientId The block's clientId. 15878 * @param {boolean} isHighlighted The highlight state. 15879 */ 15880 function toggleBlockHighlight(clientId, isHighlighted) { 15881 return { 15882 type: 'TOGGLE_BLOCK_HIGHLIGHT', 15883 clientId, 15884 isHighlighted 15885 }; 15886 } 15887 15888 /** 15889 * Action that "flashes" the block with a given `clientId` by rhythmically highlighting it. 15890 * 15891 * @param {string} clientId Target block client ID. 15892 */ 15893 const flashBlock = clientId => async ({ 15894 dispatch 15895 }) => { 15896 dispatch(toggleBlockHighlight(clientId, true)); 15897 await new Promise(resolve => setTimeout(resolve, 150)); 15898 dispatch(toggleBlockHighlight(clientId, false)); 15899 }; 15900 15901 /** 15902 * Action that sets whether a block has controlled inner blocks. 15903 * 15904 * @param {string} clientId The block's clientId. 15905 * @param {boolean} hasControlledInnerBlocks True if the block's inner blocks are controlled. 15906 */ 15907 function setHasControlledInnerBlocks(clientId, hasControlledInnerBlocks) { 15908 return { 15909 type: 'SET_HAS_CONTROLLED_INNER_BLOCKS', 15910 hasControlledInnerBlocks, 15911 clientId 15912 }; 15913 } 15914 15915 /** 15916 * Action that sets whether given blocks are visible on the canvas. 15917 * 15918 * @param {Record<string,boolean>} updates For each block's clientId, its new visibility setting. 15919 */ 15920 function setBlockVisibility(updates) { 15921 return { 15922 type: 'SET_BLOCK_VISIBILITY', 15923 updates 15924 }; 15925 } 15926 15927 /** 15928 * Action that sets whether a block is being temporarily edited as blocks. 15929 * 15930 * DO-NOT-USE in production. 15931 * This action is created for internal/experimental only usage and may be 15932 * removed anytime without any warning, causing breakage on any plugin or theme invoking it. 15933 * 15934 * @param {?string} temporarilyEditingAsBlocks The block's clientId being temporarily edited as blocks. 15935 * @param {?string} focusModeToRevert The focus mode to revert after temporarily edit as blocks finishes. 15936 */ 15937 function __unstableSetTemporarilyEditingAsBlocks(temporarilyEditingAsBlocks, focusModeToRevert) { 15938 return { 15939 type: 'SET_TEMPORARILY_EDITING_AS_BLOCKS', 15940 temporarilyEditingAsBlocks, 15941 focusModeToRevert 15942 }; 15943 } 15944 15945 /** 15946 * Interface for inserter media requests. 15947 * 15948 * @typedef {Object} InserterMediaRequest 15949 * @property {number} per_page How many items to fetch per page. 15950 * @property {string} search The search term to use for filtering the results. 15951 */ 15952 15953 /** 15954 * Interface for inserter media responses. Any media resource should 15955 * map their response to this interface, in order to create the core 15956 * WordPress media blocks (image, video, audio). 15957 * 15958 * @typedef {Object} InserterMediaItem 15959 * @property {string} title The title of the media item. 15960 * @property {string} url The source url of the media item. 15961 * @property {string} [previewUrl] The preview source url of the media item to display in the media list. 15962 * @property {number} [id] The WordPress id of the media item. 15963 * @property {number|string} [sourceId] The id of the media item from external source. 15964 * @property {string} [alt] The alt text of the media item. 15965 * @property {string} [caption] The caption of the media item. 15966 */ 15967 15968 /** 15969 * Registers a new inserter media category. Once registered, the media category is 15970 * available in the inserter's media tab. 15971 * 15972 * The following interfaces are used: 15973 * 15974 * _Type Definition_ 15975 * 15976 * - _InserterMediaRequest_ `Object`: Interface for inserter media requests. 15977 * 15978 * _Properties_ 15979 * 15980 * - _per_page_ `number`: How many items to fetch per page. 15981 * - _search_ `string`: The search term to use for filtering the results. 15982 * 15983 * _Type Definition_ 15984 * 15985 * - _InserterMediaItem_ `Object`: Interface for inserter media responses. Any media resource should 15986 * map their response to this interface, in order to create the core 15987 * WordPress media blocks (image, video, audio). 15988 * 15989 * _Properties_ 15990 * 15991 * - _title_ `string`: The title of the media item. 15992 * - _url_ `string: The source url of the media item. 15993 * - _previewUrl_ `[string]`: The preview source url of the media item to display in the media list. 15994 * - _id_ `[number]`: The WordPress id of the media item. 15995 * - _sourceId_ `[number|string]`: The id of the media item from external source. 15996 * - _alt_ `[string]`: The alt text of the media item. 15997 * - _caption_ `[string]`: The caption of the media item. 15998 * 15999 * @param {InserterMediaCategory} category The inserter media category to register. 16000 * 16001 * @example 16002 * ```js 16003 * 16004 * wp.data.dispatch('core/block-editor').registerInserterMediaCategory( { 16005 * name: 'openverse', 16006 * labels: { 16007 * name: 'Openverse', 16008 * search_items: 'Search Openverse', 16009 * }, 16010 * mediaType: 'image', 16011 * async fetch( query = {} ) { 16012 * const defaultArgs = { 16013 * mature: false, 16014 * excluded_source: 'flickr,inaturalist,wikimedia', 16015 * license: 'pdm,cc0', 16016 * }; 16017 * const finalQuery = { ...query, ...defaultArgs }; 16018 * // Sometimes you might need to map the supported request params according to `InserterMediaRequest`. 16019 * // interface. In this example the `search` query param is named `q`. 16020 * const mapFromInserterMediaRequest = { 16021 * per_page: 'page_size', 16022 * search: 'q', 16023 * }; 16024 * const url = new URL( 'https://api.openverse.org/v1/images/' ); 16025 * Object.entries( finalQuery ).forEach( ( [ key, value ] ) => { 16026 * const queryKey = mapFromInserterMediaRequest[ key ] || key; 16027 * url.searchParams.set( queryKey, value ); 16028 * } ); 16029 * const response = await window.fetch( url, { 16030 * headers: { 16031 * 'User-Agent': 'WordPress/inserter-media-fetch', 16032 * }, 16033 * } ); 16034 * const jsonResponse = await response.json(); 16035 * const results = jsonResponse.results; 16036 * return results.map( ( result ) => ( { 16037 * ...result, 16038 * // If your response result includes an `id` prop that you want to access later, it should 16039 * // be mapped to `InserterMediaItem`'s `sourceId` prop. This can be useful if you provide 16040 * // a report URL getter. 16041 * // Additionally you should always clear the `id` value of your response results because 16042 * // it is used to identify WordPress media items. 16043 * sourceId: result.id, 16044 * id: undefined, 16045 * caption: result.caption, 16046 * previewUrl: result.thumbnail, 16047 * } ) ); 16048 * }, 16049 * getReportUrl: ( { sourceId } ) => 16050 * `https://wordpress.org/openverse/image/${ sourceId }/report/`, 16051 * isExternalResource: true, 16052 * } ); 16053 * ``` 16054 * 16055 * @typedef {Object} InserterMediaCategory Interface for inserter media category. 16056 * @property {string} name The name of the media category, that should be unique among all media categories. 16057 * @property {Object} labels Labels for the media category. 16058 * @property {string} labels.name General name of the media category. It's used in the inserter media items list. 16059 * @property {string} [labels.search_items='Search'] Label for searching items. Default is ‘Search Posts’ / ‘Search Pages’. 16060 * @property {('image'|'audio'|'video')} mediaType The media type of the media category. 16061 * @property {(InserterMediaRequest) => Promise<InserterMediaItem[]>} fetch The function to fetch media items for the category. 16062 * @property {(InserterMediaItem) => string} [getReportUrl] If the media category supports reporting media items, this function should return 16063 * the report url for the media item. It accepts the `InserterMediaItem` as an argument. 16064 * @property {boolean} [isExternalResource] If the media category is an external resource, this should be set to true. 16065 * This is used to avoid making a request to the external resource when the user 16066 */ 16067 const registerInserterMediaCategory = category => ({ 16068 select, 16069 dispatch 16070 }) => { 16071 if (!category || typeof category !== 'object') { 16072 console.error('Category should be an `InserterMediaCategory` object.'); 16073 return; 16074 } 16075 if (!category.name) { 16076 console.error('Category should have a `name` that should be unique among all media categories.'); 16077 return; 16078 } 16079 if (!category.labels?.name) { 16080 console.error('Category should have a `labels.name`.'); 16081 return; 16082 } 16083 if (!['image', 'audio', 'video'].includes(category.mediaType)) { 16084 console.error('Category should have `mediaType` property that is one of `image|audio|video`.'); 16085 return; 16086 } 16087 if (!category.fetch || typeof category.fetch !== 'function') { 16088 console.error('Category should have a `fetch` function defined with the following signature `(InserterMediaRequest) => Promise<InserterMediaItem[]>`.'); 16089 return; 16090 } 16091 const registeredInserterMediaCategories = select.getRegisteredInserterMediaCategories(); 16092 if (registeredInserterMediaCategories.some(({ 16093 name 16094 }) => name === category.name)) { 16095 console.error(`A category is already registered with the same name: "$category.name}".`); 16096 return; 16097 } 16098 if (registeredInserterMediaCategories.some(({ 16099 labels: { 16100 name 16101 } = {} 16102 }) => name === category.labels?.name)) { 16103 console.error(`A category is already registered with the same labels.name: "$category.labels.name}".`); 16104 return; 16105 } 16106 // `inserterMediaCategories` is a private block editor setting, which means it cannot 16107 // be updated through the public `updateSettings` action. We preserve this setting as 16108 // private, so extenders can only add new inserter media categories and don't have any 16109 // control over the core media categories. 16110 dispatch({ 16111 type: 'REGISTER_INSERTER_MEDIA_CATEGORY', 16112 category: { 16113 ...category, 16114 isExternalResource: true 16115 } 16116 }); 16117 }; 16118 16119 /** 16120 * @typedef {import('../components/block-editing-mode').BlockEditingMode} BlockEditingMode 16121 */ 16122 16123 /** 16124 * Sets the block editing mode for a given block. 16125 * 16126 * @see useBlockEditingMode 16127 * 16128 * @param {string} clientId The block client ID, or `''` for the root container. 16129 * @param {BlockEditingMode} mode The block editing mode. One of `'disabled'`, 16130 * `'contentOnly'`, or `'default'`. 16131 * 16132 * @return {Object} Action object. 16133 */ 16134 function setBlockEditingMode(clientId = '', mode) { 16135 return { 16136 type: 'SET_BLOCK_EDITING_MODE', 16137 clientId, 16138 mode 16139 }; 16140 } 16141 16142 /** 16143 * Clears the block editing mode for a given block. 16144 * 16145 * @see useBlockEditingMode 16146 * 16147 * @param {string} clientId The block client ID, or `''` for the root container. 16148 * 16149 * @return {Object} Action object. 16150 */ 16151 function unsetBlockEditingMode(clientId = '') { 16152 return { 16153 type: 'UNSET_BLOCK_EDITING_MODE', 16154 clientId 16155 }; 16156 } 16157 16158 ;// ./node_modules/@wordpress/block-editor/build-module/store/index.js 16159 /** 16160 * WordPress dependencies 16161 */ 16162 16163 16164 /** 16165 * Internal dependencies 16166 */ 16167 16168 16169 16170 16171 16172 16173 16174 16175 /** 16176 * Block editor data store configuration. 16177 * 16178 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#registerStore 16179 */ 16180 const storeConfig = { 16181 reducer: reducer, 16182 selectors: selectors_namespaceObject, 16183 actions: actions_namespaceObject 16184 }; 16185 16186 /** 16187 * Store definition for the block editor namespace. 16188 * 16189 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore 16190 */ 16191 const store = (0,external_wp_data_namespaceObject.createReduxStore)(STORE_NAME, { 16192 ...storeConfig, 16193 persist: ['preferences'] 16194 }); 16195 16196 // We will be able to use the `register` function once we switch 16197 // the "preferences" persistence to use the new preferences package. 16198 const registeredStore = (0,external_wp_data_namespaceObject.registerStore)(STORE_NAME, { 16199 ...storeConfig, 16200 persist: ['preferences'] 16201 }); 16202 unlock(registeredStore).registerPrivateActions(private_actions_namespaceObject); 16203 unlock(registeredStore).registerPrivateSelectors(private_selectors_namespaceObject); 16204 16205 // TODO: Remove once we switch to the `register` function (see above). 16206 // 16207 // Until then, private functions also need to be attached to the original 16208 // `store` descriptor in order to avoid unit tests failing, which could happen 16209 // when tests create new registries in which they register stores. 16210 // 16211 // @see https://github.com/WordPress/gutenberg/pull/51145#discussion_r1239999590 16212 unlock(store).registerPrivateActions(private_actions_namespaceObject); 16213 unlock(store).registerPrivateSelectors(private_selectors_namespaceObject); 16214 16215 ;// ./node_modules/@wordpress/block-editor/build-module/components/use-settings/index.js 16216 /** 16217 * WordPress dependencies 16218 */ 16219 16220 16221 16222 /** 16223 * Internal dependencies 16224 */ 16225 16226 16227 16228 16229 /** 16230 * Hook that retrieves the given settings for the block instance in use. 16231 * 16232 * It looks up the settings first in the block instance hierarchy. 16233 * If none are found, it'll look them up in the block editor settings. 16234 * 16235 * @param {string[]} paths The paths to the settings. 16236 * @return {any[]} Returns the values defined for the settings. 16237 * @example 16238 * ```js 16239 * const [ fixed, sticky ] = useSettings( 'position.fixed', 'position.sticky' ); 16240 * ``` 16241 */ 16242 function use_settings_useSettings(...paths) { 16243 const { 16244 clientId = null 16245 } = useBlockEditContext(); 16246 return (0,external_wp_data_namespaceObject.useSelect)(select => unlock(select(store)).getBlockSettings(clientId, ...paths), 16247 // eslint-disable-next-line react-hooks/exhaustive-deps 16248 [clientId, ...paths]); 16249 } 16250 16251 /** 16252 * Hook that retrieves the given setting for the block instance in use. 16253 * 16254 * It looks up the setting first in the block instance hierarchy. 16255 * If none is found, it'll look it up in the block editor settings. 16256 * 16257 * @deprecated 6.5.0 Use useSettings instead. 16258 * 16259 * @param {string} path The path to the setting. 16260 * @return {any} Returns the value defined for the setting. 16261 * @example 16262 * ```js 16263 * const isEnabled = useSetting( 'typography.dropCap' ); 16264 * ``` 16265 */ 16266 function useSetting(path) { 16267 external_wp_deprecated_default()('wp.blockEditor.useSetting', { 16268 since: '6.5', 16269 alternative: 'wp.blockEditor.useSettings', 16270 note: 'The new useSettings function can retrieve multiple settings at once, with better performance.' 16271 }); 16272 const [value] = use_settings_useSettings(path); 16273 return value; 16274 } 16275 16276 ;// external ["wp","styleEngine"] 16277 const external_wp_styleEngine_namespaceObject = window["wp"]["styleEngine"]; 16278 ;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/fluid-utils.js 16279 /** 16280 * The fluid utilities must match the backend equivalent. 16281 * See: gutenberg_get_typography_font_size_value() in lib/block-supports/typography.php 16282 * --------------------------------------------------------------- 16283 */ 16284 16285 // Defaults. 16286 const DEFAULT_MAXIMUM_VIEWPORT_WIDTH = '1600px'; 16287 const DEFAULT_MINIMUM_VIEWPORT_WIDTH = '320px'; 16288 const DEFAULT_SCALE_FACTOR = 1; 16289 const DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MIN = 0.25; 16290 const DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MAX = 0.75; 16291 const DEFAULT_MINIMUM_FONT_SIZE_LIMIT = '14px'; 16292 16293 /** 16294 * Computes a fluid font-size value that uses clamp(). A minimum and maximum 16295 * font size OR a single font size can be specified. 16296 * 16297 * If a single font size is specified, it is scaled up and down using a logarithmic scale. 16298 * 16299 * @example 16300 * ```js 16301 * // Calculate fluid font-size value from a minimum and maximum value. 16302 * const fontSize = getComputedFluidTypographyValue( { 16303 * minimumFontSize: '20px', 16304 * maximumFontSize: '45px' 16305 * } ); 16306 * // Calculate fluid font-size value from a single font size. 16307 * const fontSize = getComputedFluidTypographyValue( { 16308 * fontSize: '30px', 16309 * } ); 16310 * ``` 16311 * 16312 * @param {Object} args 16313 * @param {?string} args.minimumViewportWidth Minimum viewport size from which type will have fluidity. Optional if fontSize is specified. 16314 * @param {?string} args.maximumViewportWidth Maximum size up to which type will have fluidity. Optional if fontSize is specified. 16315 * @param {string|number} [args.fontSize] Size to derive maximumFontSize and minimumFontSize from, if necessary. Optional if minimumFontSize and maximumFontSize are specified. 16316 * @param {?string} args.maximumFontSize Maximum font size for any clamp() calculation. Optional. 16317 * @param {?string} args.minimumFontSize Minimum font size for any clamp() calculation. Optional. 16318 * @param {?number} args.scaleFactor A scale factor to determine how fast a font scales within boundaries. Optional. 16319 * @param {?string} args.minimumFontSizeLimit The smallest a calculated font size may be. Optional. 16320 * 16321 * @return {string|null} A font-size value using clamp(). 16322 */ 16323 function getComputedFluidTypographyValue({ 16324 minimumFontSize, 16325 maximumFontSize, 16326 fontSize, 16327 minimumViewportWidth = DEFAULT_MINIMUM_VIEWPORT_WIDTH, 16328 maximumViewportWidth = DEFAULT_MAXIMUM_VIEWPORT_WIDTH, 16329 scaleFactor = DEFAULT_SCALE_FACTOR, 16330 minimumFontSizeLimit 16331 }) { 16332 // Validate incoming settings and set defaults. 16333 minimumFontSizeLimit = !!getTypographyValueAndUnit(minimumFontSizeLimit) ? minimumFontSizeLimit : DEFAULT_MINIMUM_FONT_SIZE_LIMIT; 16334 16335 /* 16336 * Calculates missing minimumFontSize and maximumFontSize from 16337 * defaultFontSize if provided. 16338 */ 16339 if (fontSize) { 16340 // Parses default font size. 16341 const fontSizeParsed = getTypographyValueAndUnit(fontSize); 16342 16343 // Protect against invalid units. 16344 if (!fontSizeParsed?.unit) { 16345 return null; 16346 } 16347 16348 // Parses the minimum font size limit, so we can perform checks using it. 16349 const minimumFontSizeLimitParsed = getTypographyValueAndUnit(minimumFontSizeLimit, { 16350 coerceTo: fontSizeParsed.unit 16351 }); 16352 16353 // Don't enforce minimum font size if a font size has explicitly set a min and max value. 16354 if (!!minimumFontSizeLimitParsed?.value && !minimumFontSize && !maximumFontSize) { 16355 /* 16356 * If a minimum size was not passed to this function 16357 * and the user-defined font size is lower than $minimum_font_size_limit, 16358 * do not calculate a fluid value. 16359 */ 16360 if (fontSizeParsed?.value <= minimumFontSizeLimitParsed?.value) { 16361 return null; 16362 } 16363 } 16364 16365 // If no fluid max font size is available use the incoming value. 16366 if (!maximumFontSize) { 16367 maximumFontSize = `$fontSizeParsed.value}$fontSizeParsed.unit}`; 16368 } 16369 16370 /* 16371 * If no minimumFontSize is provided, create one using 16372 * the given font size multiplied by the min font size scale factor. 16373 */ 16374 if (!minimumFontSize) { 16375 const fontSizeValueInPx = fontSizeParsed.unit === 'px' ? fontSizeParsed.value : fontSizeParsed.value * 16; 16376 16377 /* 16378 * The scale factor is a multiplier that affects how quickly the curve will move towards the minimum, 16379 * that is, how quickly the size factor reaches 0 given increasing font size values. 16380 * For a - b * log2(), lower values of b will make the curve move towards the minimum faster. 16381 * The scale factor is constrained between min and max values. 16382 */ 16383 const minimumFontSizeFactor = Math.min(Math.max(1 - 0.075 * Math.log2(fontSizeValueInPx), DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MIN), DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MAX); 16384 16385 // Calculates the minimum font size. 16386 const calculatedMinimumFontSize = roundToPrecision(fontSizeParsed.value * minimumFontSizeFactor, 3); 16387 16388 // Only use calculated min font size if it's > $minimum_font_size_limit value. 16389 if (!!minimumFontSizeLimitParsed?.value && calculatedMinimumFontSize < minimumFontSizeLimitParsed?.value) { 16390 minimumFontSize = `$minimumFontSizeLimitParsed.value}$minimumFontSizeLimitParsed.unit}`; 16391 } else { 16392 minimumFontSize = `$calculatedMinimumFontSize}$fontSizeParsed.unit}`; 16393 } 16394 } 16395 } 16396 16397 // Grab the minimum font size and normalize it in order to use the value for calculations. 16398 const minimumFontSizeParsed = getTypographyValueAndUnit(minimumFontSize); 16399 16400 // We get a 'preferred' unit to keep units consistent when calculating, 16401 // otherwise the result will not be accurate. 16402 const fontSizeUnit = minimumFontSizeParsed?.unit || 'rem'; 16403 16404 // Grabs the maximum font size and normalize it in order to use the value for calculations. 16405 const maximumFontSizeParsed = getTypographyValueAndUnit(maximumFontSize, { 16406 coerceTo: fontSizeUnit 16407 }); 16408 16409 // Checks for mandatory min and max sizes, and protects against unsupported units. 16410 if (!minimumFontSizeParsed || !maximumFontSizeParsed) { 16411 return null; 16412 } 16413 16414 // Uses rem for accessible fluid target font scaling. 16415 const minimumFontSizeRem = getTypographyValueAndUnit(minimumFontSize, { 16416 coerceTo: 'rem' 16417 }); 16418 16419 // Viewport widths defined for fluid typography. Normalize units 16420 const maximumViewportWidthParsed = getTypographyValueAndUnit(maximumViewportWidth, { 16421 coerceTo: fontSizeUnit 16422 }); 16423 const minimumViewportWidthParsed = getTypographyValueAndUnit(minimumViewportWidth, { 16424 coerceTo: fontSizeUnit 16425 }); 16426 16427 // Protect against unsupported units. 16428 if (!maximumViewportWidthParsed || !minimumViewportWidthParsed || !minimumFontSizeRem) { 16429 return null; 16430 } 16431 16432 // Calculates the linear factor denominator. If it's 0, we cannot calculate a fluid value. 16433 const linearDenominator = maximumViewportWidthParsed.value - minimumViewportWidthParsed.value; 16434 if (!linearDenominator) { 16435 return null; 16436 } 16437 16438 // Build CSS rule. 16439 // Borrowed from https://websemantics.uk/tools/responsive-font-calculator/. 16440 const minViewportWidthOffsetValue = roundToPrecision(minimumViewportWidthParsed.value / 100, 3); 16441 const viewportWidthOffset = roundToPrecision(minViewportWidthOffsetValue, 3) + fontSizeUnit; 16442 const linearFactor = 100 * ((maximumFontSizeParsed.value - minimumFontSizeParsed.value) / linearDenominator); 16443 const linearFactorScaled = roundToPrecision((linearFactor || 1) * scaleFactor, 3); 16444 const fluidTargetFontSize = `$minimumFontSizeRem.value}$minimumFontSizeRem.unit} + ((1vw - $viewportWidthOffset}) * $linearFactorScaled})`; 16445 return `clamp($minimumFontSize}, $fluidTargetFontSize}, $maximumFontSize})`; 16446 } 16447 16448 /** 16449 * Internal method that checks a string for a unit and value and returns an array consisting of `'value'` and `'unit'`, e.g., [ '42', 'rem' ]. 16450 * A raw font size of `value + unit` is expected. If the value is an integer, it will convert to `value + 'px'`. 16451 * 16452 * @param {string|number} rawValue Raw size value from theme.json. 16453 * @param {Object|undefined} options Calculation options. 16454 * 16455 * @return {{ unit: string, value: number }|null} An object consisting of `'value'` and `'unit'` properties. 16456 */ 16457 function getTypographyValueAndUnit(rawValue, options = {}) { 16458 if (typeof rawValue !== 'string' && typeof rawValue !== 'number') { 16459 return null; 16460 } 16461 16462 // Converts numeric values to pixel values by default. 16463 if (isFinite(rawValue)) { 16464 rawValue = `$rawValue}px`; 16465 } 16466 const { 16467 coerceTo, 16468 rootSizeValue, 16469 acceptableUnits 16470 } = { 16471 coerceTo: '', 16472 // Default browser font size. Later we could inject some JS to compute this `getComputedStyle( document.querySelector( "html" ) ).fontSize`. 16473 rootSizeValue: 16, 16474 acceptableUnits: ['rem', 'px', 'em'], 16475 ...options 16476 }; 16477 const acceptableUnitsGroup = acceptableUnits?.join('|'); 16478 const regexUnits = new RegExp(`^(\\d*\\.?\\d+)($acceptableUnitsGroup}){1,1}$`); 16479 const matches = rawValue.match(regexUnits); 16480 16481 // We need a number value and a unit. 16482 if (!matches || matches.length < 3) { 16483 return null; 16484 } 16485 let [, value, unit] = matches; 16486 let returnValue = parseFloat(value); 16487 if ('px' === coerceTo && ('em' === unit || 'rem' === unit)) { 16488 returnValue = returnValue * rootSizeValue; 16489 unit = coerceTo; 16490 } 16491 if ('px' === unit && ('em' === coerceTo || 'rem' === coerceTo)) { 16492 returnValue = returnValue / rootSizeValue; 16493 unit = coerceTo; 16494 } 16495 16496 /* 16497 * No calculation is required if swapping between em and rem yet, 16498 * since we assume a root size value. Later we might like to differentiate between 16499 * :root font size (rem) and parent element font size (em) relativity. 16500 */ 16501 if (('em' === coerceTo || 'rem' === coerceTo) && ('em' === unit || 'rem' === unit)) { 16502 unit = coerceTo; 16503 } 16504 return { 16505 value: roundToPrecision(returnValue, 3), 16506 unit 16507 }; 16508 } 16509 16510 /** 16511 * Returns a value rounded to defined precision. 16512 * Returns `undefined` if the value is not a valid finite number. 16513 * 16514 * @param {number} value Raw value. 16515 * @param {number} digits The number of digits to appear after the decimal point 16516 * 16517 * @return {number|undefined} Value rounded to standard precision. 16518 */ 16519 function roundToPrecision(value, digits = 3) { 16520 const base = Math.pow(10, digits); 16521 return Number.isFinite(value) ? parseFloat(Math.round(value * base) / base) : undefined; 16522 } 16523 16524 ;// ./node_modules/@wordpress/block-editor/build-module/utils/format-font-style.js 16525 /** 16526 * WordPress dependencies 16527 */ 16528 16529 16530 /** 16531 * Formats font styles to human readable names. 16532 * 16533 * @param {string} fontStyle font style string 16534 * @return {Object} new object with formatted font style 16535 */ 16536 function formatFontStyle(fontStyle) { 16537 if (!fontStyle) { 16538 return {}; 16539 } 16540 if (typeof fontStyle === 'object') { 16541 return fontStyle; 16542 } 16543 let name; 16544 switch (fontStyle) { 16545 case 'normal': 16546 name = (0,external_wp_i18n_namespaceObject._x)('Regular', 'font style'); 16547 break; 16548 case 'italic': 16549 name = (0,external_wp_i18n_namespaceObject._x)('Italic', 'font style'); 16550 break; 16551 case 'oblique': 16552 name = (0,external_wp_i18n_namespaceObject._x)('Oblique', 'font style'); 16553 break; 16554 default: 16555 name = fontStyle; 16556 break; 16557 } 16558 return { 16559 name, 16560 value: fontStyle 16561 }; 16562 } 16563 16564 ;// ./node_modules/@wordpress/block-editor/build-module/utils/format-font-weight.js 16565 /** 16566 * WordPress dependencies 16567 */ 16568 16569 16570 /** 16571 * Formats font weights to human readable names. 16572 * 16573 * @param {string} fontWeight font weight string 16574 * @return {Object} new object with formatted font weight 16575 */ 16576 function formatFontWeight(fontWeight) { 16577 if (!fontWeight) { 16578 return {}; 16579 } 16580 if (typeof fontWeight === 'object') { 16581 return fontWeight; 16582 } 16583 let name; 16584 switch (fontWeight) { 16585 case 'normal': 16586 case '400': 16587 name = (0,external_wp_i18n_namespaceObject._x)('Regular', 'font weight'); 16588 break; 16589 case 'bold': 16590 case '700': 16591 name = (0,external_wp_i18n_namespaceObject._x)('Bold', 'font weight'); 16592 break; 16593 case '100': 16594 name = (0,external_wp_i18n_namespaceObject._x)('Thin', 'font weight'); 16595 break; 16596 case '200': 16597 name = (0,external_wp_i18n_namespaceObject._x)('Extra Light', 'font weight'); 16598 break; 16599 case '300': 16600 name = (0,external_wp_i18n_namespaceObject._x)('Light', 'font weight'); 16601 break; 16602 case '500': 16603 name = (0,external_wp_i18n_namespaceObject._x)('Medium', 'font weight'); 16604 break; 16605 case '600': 16606 name = (0,external_wp_i18n_namespaceObject._x)('Semi Bold', 'font weight'); 16607 break; 16608 case '800': 16609 name = (0,external_wp_i18n_namespaceObject._x)('Extra Bold', 'font weight'); 16610 break; 16611 case '900': 16612 name = (0,external_wp_i18n_namespaceObject._x)('Black', 'font weight'); 16613 break; 16614 case '1000': 16615 name = (0,external_wp_i18n_namespaceObject._x)('Extra Black', 'font weight'); 16616 break; 16617 default: 16618 name = fontWeight; 16619 break; 16620 } 16621 return { 16622 name, 16623 value: fontWeight 16624 }; 16625 } 16626 16627 ;// ./node_modules/@wordpress/block-editor/build-module/utils/get-font-styles-and-weights.js 16628 /** 16629 * WordPress dependencies 16630 */ 16631 16632 16633 /** 16634 * Internal dependencies 16635 */ 16636 16637 16638 const FONT_STYLES = [{ 16639 name: (0,external_wp_i18n_namespaceObject._x)('Regular', 'font style'), 16640 value: 'normal' 16641 }, { 16642 name: (0,external_wp_i18n_namespaceObject._x)('Italic', 'font style'), 16643 value: 'italic' 16644 }]; 16645 const FONT_WEIGHTS = [{ 16646 name: (0,external_wp_i18n_namespaceObject._x)('Thin', 'font weight'), 16647 value: '100' 16648 }, { 16649 name: (0,external_wp_i18n_namespaceObject._x)('Extra Light', 'font weight'), 16650 value: '200' 16651 }, { 16652 name: (0,external_wp_i18n_namespaceObject._x)('Light', 'font weight'), 16653 value: '300' 16654 }, { 16655 name: (0,external_wp_i18n_namespaceObject._x)('Regular', 'font weight'), 16656 value: '400' 16657 }, { 16658 name: (0,external_wp_i18n_namespaceObject._x)('Medium', 'font weight'), 16659 value: '500' 16660 }, { 16661 name: (0,external_wp_i18n_namespaceObject._x)('Semi Bold', 'font weight'), 16662 value: '600' 16663 }, { 16664 name: (0,external_wp_i18n_namespaceObject._x)('Bold', 'font weight'), 16665 value: '700' 16666 }, { 16667 name: (0,external_wp_i18n_namespaceObject._x)('Extra Bold', 'font weight'), 16668 value: '800' 16669 }, { 16670 name: (0,external_wp_i18n_namespaceObject._x)('Black', 'font weight'), 16671 value: '900' 16672 }, { 16673 name: (0,external_wp_i18n_namespaceObject._x)('Extra Black', 'font weight'), 16674 value: '1000' 16675 }]; 16676 16677 /** 16678 * Builds a list of font style and weight options based on font family faces. 16679 * Defaults to the standard font styles and weights if no font family faces are provided. 16680 * 16681 * @param {Array} fontFamilyFaces font family faces array 16682 * @return {Object} new object with combined and separated font style and weight properties 16683 */ 16684 function getFontStylesAndWeights(fontFamilyFaces) { 16685 let fontStyles = []; 16686 let fontWeights = []; 16687 const combinedStyleAndWeightOptions = []; 16688 const isSystemFont = !fontFamilyFaces || fontFamilyFaces?.length === 0; 16689 let isVariableFont = false; 16690 fontFamilyFaces?.forEach(face => { 16691 // Check for variable font by looking for a space in the font weight value. e.g. "100 900" 16692 if ('string' === typeof face.fontWeight && /\s/.test(face.fontWeight.trim())) { 16693 isVariableFont = true; 16694 16695 // Find font weight start and end values. 16696 let [startValue, endValue] = face.fontWeight.split(' '); 16697 startValue = parseInt(startValue.slice(0, 1)); 16698 if (endValue === '1000') { 16699 endValue = 10; 16700 } else { 16701 endValue = parseInt(endValue.slice(0, 1)); 16702 } 16703 16704 // Create font weight options for available variable weights. 16705 for (let i = startValue; i <= endValue; i++) { 16706 const fontWeightValue = `$i.toString()}00`; 16707 if (!fontWeights.some(weight => weight.value === fontWeightValue)) { 16708 fontWeights.push(formatFontWeight(fontWeightValue)); 16709 } 16710 } 16711 } 16712 16713 // Format font style and weight values. 16714 const fontWeight = formatFontWeight('number' === typeof face.fontWeight ? face.fontWeight.toString() : face.fontWeight); 16715 const fontStyle = formatFontStyle(face.fontStyle); 16716 16717 // Create font style and font weight lists without duplicates. 16718 if (fontStyle && Object.keys(fontStyle).length) { 16719 if (!fontStyles.some(style => style.value === fontStyle.value)) { 16720 fontStyles.push(fontStyle); 16721 } 16722 } 16723 if (fontWeight && Object.keys(fontWeight).length) { 16724 if (!fontWeights.some(weight => weight.value === fontWeight.value)) { 16725 if (!isVariableFont) { 16726 fontWeights.push(fontWeight); 16727 } 16728 } 16729 } 16730 }); 16731 16732 // If there is no font weight of 600 or above, then include faux bold as an option. 16733 if (!fontWeights.some(weight => weight.value >= '600')) { 16734 fontWeights.push({ 16735 name: (0,external_wp_i18n_namespaceObject._x)('Bold', 'font weight'), 16736 value: '700' 16737 }); 16738 } 16739 16740 // If there is no italic font style, then include faux italic as an option. 16741 if (!fontStyles.some(style => style.value === 'italic')) { 16742 fontStyles.push({ 16743 name: (0,external_wp_i18n_namespaceObject._x)('Italic', 'font style'), 16744 value: 'italic' 16745 }); 16746 } 16747 16748 // Use default font styles and weights for system fonts. 16749 if (isSystemFont) { 16750 fontStyles = FONT_STYLES; 16751 fontWeights = FONT_WEIGHTS; 16752 } 16753 16754 // Use default styles and weights if there are no available styles or weights from the provided font faces. 16755 fontStyles = fontStyles.length === 0 ? FONT_STYLES : fontStyles; 16756 fontWeights = fontWeights.length === 0 ? FONT_WEIGHTS : fontWeights; 16757 16758 // Generate combined font style and weight options for available fonts. 16759 fontStyles.forEach(({ 16760 name: styleName, 16761 value: styleValue 16762 }) => { 16763 fontWeights.forEach(({ 16764 name: weightName, 16765 value: weightValue 16766 }) => { 16767 const optionName = styleValue === 'normal' ? weightName : (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: 1: Font weight name. 2: Font style name. */ 16768 (0,external_wp_i18n_namespaceObject._x)('%1$s %2$s', 'font'), weightName, styleName); 16769 combinedStyleAndWeightOptions.push({ 16770 key: `$styleValue}-$weightValue}`, 16771 name: optionName, 16772 style: { 16773 fontStyle: styleValue, 16774 fontWeight: weightValue 16775 } 16776 }); 16777 }); 16778 }); 16779 return { 16780 fontStyles, 16781 fontWeights, 16782 combinedStyleAndWeightOptions, 16783 isSystemFont, 16784 isVariableFont 16785 }; 16786 } 16787 16788 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/typography-utils.js 16789 /** 16790 * The fluid utilities must match the backend equivalent. 16791 * See: gutenberg_get_typography_font_size_value() in lib/block-supports/typography.php 16792 * --------------------------------------------------------------- 16793 */ 16794 16795 /** 16796 * Internal dependencies 16797 */ 16798 16799 16800 16801 /** 16802 * @typedef {Object} FluidPreset 16803 * @property {string|undefined} max A maximum font size value. 16804 * @property {?string|undefined} min A minimum font size value. 16805 */ 16806 16807 /** 16808 * @typedef {Object} Preset 16809 * @property {?string|?number} size A default font size. 16810 * @property {string} name A font size name, displayed in the UI. 16811 * @property {string} slug A font size slug 16812 * @property {boolean|FluidPreset|undefined} fluid Specifies the minimum and maximum font size value of a fluid font size. 16813 */ 16814 16815 /** 16816 * @typedef {Object} TypographySettings 16817 * @property {?string} minViewportWidth Minimum viewport size from which type will have fluidity. Optional if size is specified. 16818 * @property {?string} maxViewportWidth Maximum size up to which type will have fluidity. Optional if size is specified. 16819 * @property {?number} scaleFactor A scale factor to determine how fast a font scales within boundaries. Optional. 16820 * @property {?number} minFontSizeFactor How much to scale defaultFontSize by to derive minimumFontSize. Optional. 16821 * @property {?string} minFontSize The smallest a calculated font size may be. Optional. 16822 */ 16823 16824 /** 16825 * Returns a font-size value based on a given font-size preset. 16826 * Takes into account fluid typography parameters and attempts to return a css formula depending on available, valid values. 16827 * 16828 * The Core PHP equivalent is wp_get_typography_font_size_value(). 16829 * 16830 * @param {Preset} preset 16831 * @param {Object} settings 16832 * @param {boolean|TypographySettings} settings.typography.fluid Whether fluid typography is enabled, and, optionally, fluid font size options. 16833 * @param {Object?} settings.typography.layout Layout options. 16834 * 16835 * @return {string|*} A font-size value or the value of preset.size. 16836 */ 16837 function getTypographyFontSizeValue(preset, settings) { 16838 const { 16839 size: defaultSize 16840 } = preset; 16841 16842 /* 16843 * Catch falsy values and 0/'0'. Fluid calculations cannot be performed on `0`. 16844 * Also return early when a preset font size explicitly disables fluid typography with `false`. 16845 */ 16846 if (!defaultSize || '0' === defaultSize || false === preset?.fluid) { 16847 return defaultSize; 16848 } 16849 16850 /* 16851 * Return early when fluid typography is disabled in the settings, and there 16852 * are no local settings to enable it for the individual preset. 16853 * 16854 * If this condition isn't met, either the settings or individual preset settings 16855 * have enabled fluid typography. 16856 */ 16857 if (!isFluidTypographyEnabled(settings?.typography) && !isFluidTypographyEnabled(preset)) { 16858 return defaultSize; 16859 } 16860 let fluidTypographySettings = getFluidTypographyOptionsFromSettings(settings); 16861 fluidTypographySettings = typeof fluidTypographySettings?.fluid === 'object' ? fluidTypographySettings?.fluid : {}; 16862 const fluidFontSizeValue = getComputedFluidTypographyValue({ 16863 minimumFontSize: preset?.fluid?.min, 16864 maximumFontSize: preset?.fluid?.max, 16865 fontSize: defaultSize, 16866 minimumFontSizeLimit: fluidTypographySettings?.minFontSize, 16867 maximumViewportWidth: fluidTypographySettings?.maxViewportWidth, 16868 minimumViewportWidth: fluidTypographySettings?.minViewportWidth 16869 }); 16870 if (!!fluidFontSizeValue) { 16871 return fluidFontSizeValue; 16872 } 16873 return defaultSize; 16874 } 16875 function isFluidTypographyEnabled(typographySettings) { 16876 const fluidSettings = typographySettings?.fluid; 16877 return true === fluidSettings || fluidSettings && typeof fluidSettings === 'object' && Object.keys(fluidSettings).length > 0; 16878 } 16879 16880 /** 16881 * Returns fluid typography settings from theme.json setting object. 16882 * 16883 * @param {Object} settings Theme.json settings 16884 * @param {Object} settings.typography Theme.json typography settings 16885 * @param {Object} settings.layout Theme.json layout settings 16886 * @return {TypographySettings} Fluid typography settings 16887 */ 16888 function getFluidTypographyOptionsFromSettings(settings) { 16889 const typographySettings = settings?.typography; 16890 const layoutSettings = settings?.layout; 16891 const defaultMaxViewportWidth = getTypographyValueAndUnit(layoutSettings?.wideSize) ? layoutSettings?.wideSize : null; 16892 return isFluidTypographyEnabled(typographySettings) && defaultMaxViewportWidth ? { 16893 fluid: { 16894 maxViewportWidth: defaultMaxViewportWidth, 16895 ...typographySettings.fluid 16896 } 16897 } : { 16898 fluid: typographySettings?.fluid 16899 }; 16900 } 16901 16902 /** 16903 * Returns an object of merged font families and the font faces from the selected font family 16904 * based on the theme.json settings object and the currently selected font family. 16905 * 16906 * @param {Object} settings Theme.json settings. 16907 * @param {string} selectedFontFamily Decoded font family string. 16908 * @return {Object} Merged font families and font faces from the selected font family. 16909 */ 16910 function getMergedFontFamiliesAndFontFamilyFaces(settings, selectedFontFamily) { 16911 var _fontFamilies$find$fo; 16912 const fontFamiliesFromSettings = settings?.typography?.fontFamilies; 16913 const fontFamilies = ['default', 'theme', 'custom'].flatMap(key => { 16914 var _fontFamiliesFromSett; 16915 return (_fontFamiliesFromSett = fontFamiliesFromSettings?.[key]) !== null && _fontFamiliesFromSett !== void 0 ? _fontFamiliesFromSett : []; 16916 }); 16917 const fontFamilyFaces = (_fontFamilies$find$fo = fontFamilies.find(family => family.fontFamily === selectedFontFamily)?.fontFace) !== null && _fontFamilies$find$fo !== void 0 ? _fontFamilies$find$fo : []; 16918 return { 16919 fontFamilies, 16920 fontFamilyFaces 16921 }; 16922 } 16923 16924 /** 16925 * Returns the nearest font weight value from the available font weight list based on the new font weight. 16926 * The nearest font weight is the one with the smallest difference from the new font weight. 16927 * 16928 * @param {Array} availableFontWeights Array of available font weights. 16929 * @param {string} newFontWeightValue New font weight value. 16930 * @return {string} Nearest font weight. 16931 */ 16932 function findNearestFontWeight(availableFontWeights, newFontWeightValue) { 16933 newFontWeightValue = 'number' === typeof newFontWeightValue ? newFontWeightValue.toString() : newFontWeightValue; 16934 if (!newFontWeightValue || typeof newFontWeightValue !== 'string') { 16935 return ''; 16936 } 16937 if (!availableFontWeights || availableFontWeights.length === 0) { 16938 return newFontWeightValue; 16939 } 16940 const nearestFontWeight = availableFontWeights?.reduce((nearest, { 16941 value: fw 16942 }) => { 16943 const currentDiff = Math.abs(parseInt(fw) - parseInt(newFontWeightValue)); 16944 const nearestDiff = Math.abs(parseInt(nearest) - parseInt(newFontWeightValue)); 16945 return currentDiff < nearestDiff ? fw : nearest; 16946 }, availableFontWeights[0]?.value); 16947 return nearestFontWeight; 16948 } 16949 16950 /** 16951 * Returns the nearest font style based on the new font style. 16952 * Defaults to an empty string if the new font style is not valid or available. 16953 * 16954 * @param {Array} availableFontStyles Array of available font weights. 16955 * @param {string} newFontStyleValue New font style value. 16956 * @return {string} Nearest font style or an empty string. 16957 */ 16958 function findNearestFontStyle(availableFontStyles, newFontStyleValue) { 16959 if (typeof newFontStyleValue !== 'string' || !newFontStyleValue) { 16960 return ''; 16961 } 16962 const validStyles = ['normal', 'italic', 'oblique']; 16963 if (!validStyles.includes(newFontStyleValue)) { 16964 return ''; 16965 } 16966 if (!availableFontStyles || availableFontStyles.length === 0 || availableFontStyles.find(style => style.value === newFontStyleValue)) { 16967 return newFontStyleValue; 16968 } 16969 if (newFontStyleValue === 'oblique' && !availableFontStyles.find(style => style.value === 'oblique')) { 16970 return 'italic'; 16971 } 16972 return ''; 16973 } 16974 16975 /** 16976 * Returns the nearest font style and weight based on the available font family faces and the new font style and weight. 16977 * 16978 * @param {Array} fontFamilyFaces Array of available font family faces. 16979 * @param {string} fontStyle New font style. Defaults to previous value. 16980 * @param {string} fontWeight New font weight. Defaults to previous value. 16981 * @return {Object} Nearest font style and font weight. 16982 */ 16983 function findNearestStyleAndWeight(fontFamilyFaces, fontStyle, fontWeight) { 16984 let nearestFontStyle = fontStyle; 16985 let nearestFontWeight = fontWeight; 16986 const { 16987 fontStyles, 16988 fontWeights, 16989 combinedStyleAndWeightOptions 16990 } = getFontStylesAndWeights(fontFamilyFaces); 16991 16992 // Check if the new font style and weight are available in the font family faces. 16993 const hasFontStyle = fontStyles?.some(({ 16994 value: fs 16995 }) => fs === fontStyle); 16996 const hasFontWeight = fontWeights?.some(({ 16997 value: fw 16998 }) => fw?.toString() === fontWeight?.toString()); 16999 if (!hasFontStyle) { 17000 /* 17001 * Default to italic if oblique is not available. 17002 * Or find the nearest font style based on the nearest font weight. 17003 */ 17004 nearestFontStyle = fontStyle ? findNearestFontStyle(fontStyles, fontStyle) : combinedStyleAndWeightOptions?.find(option => option.style.fontWeight === findNearestFontWeight(fontWeights, fontWeight))?.style?.fontStyle; 17005 } 17006 if (!hasFontWeight) { 17007 /* 17008 * Find the nearest font weight based on available weights. 17009 * Or find the nearest font weight based on the nearest font style. 17010 */ 17011 nearestFontWeight = fontWeight ? findNearestFontWeight(fontWeights, fontWeight) : combinedStyleAndWeightOptions?.find(option => option.style.fontStyle === (nearestFontStyle || fontStyle))?.style?.fontWeight; 17012 } 17013 return { 17014 nearestFontStyle, 17015 nearestFontWeight 17016 }; 17017 } 17018 17019 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/utils.js 17020 /** 17021 * External dependencies 17022 */ 17023 17024 17025 /** 17026 * WordPress dependencies 17027 */ 17028 17029 17030 17031 /** 17032 * Internal dependencies 17033 */ 17034 17035 17036 17037 /* Supporting data. */ 17038 const ROOT_BLOCK_SELECTOR = 'body'; 17039 const ROOT_CSS_PROPERTIES_SELECTOR = ':root'; 17040 const PRESET_METADATA = [{ 17041 path: ['color', 'palette'], 17042 valueKey: 'color', 17043 cssVarInfix: 'color', 17044 classes: [{ 17045 classSuffix: 'color', 17046 propertyName: 'color' 17047 }, { 17048 classSuffix: 'background-color', 17049 propertyName: 'background-color' 17050 }, { 17051 classSuffix: 'border-color', 17052 propertyName: 'border-color' 17053 }] 17054 }, { 17055 path: ['color', 'gradients'], 17056 valueKey: 'gradient', 17057 cssVarInfix: 'gradient', 17058 classes: [{ 17059 classSuffix: 'gradient-background', 17060 propertyName: 'background' 17061 }] 17062 }, { 17063 path: ['color', 'duotone'], 17064 valueKey: 'colors', 17065 cssVarInfix: 'duotone', 17066 valueFunc: ({ 17067 slug 17068 }) => `url( '#wp-duotone-$slug}' )`, 17069 classes: [] 17070 }, { 17071 path: ['shadow', 'presets'], 17072 valueKey: 'shadow', 17073 cssVarInfix: 'shadow', 17074 classes: [] 17075 }, { 17076 path: ['typography', 'fontSizes'], 17077 valueFunc: (preset, settings) => getTypographyFontSizeValue(preset, settings), 17078 valueKey: 'size', 17079 cssVarInfix: 'font-size', 17080 classes: [{ 17081 classSuffix: 'font-size', 17082 propertyName: 'font-size' 17083 }] 17084 }, { 17085 path: ['typography', 'fontFamilies'], 17086 valueKey: 'fontFamily', 17087 cssVarInfix: 'font-family', 17088 classes: [{ 17089 classSuffix: 'font-family', 17090 propertyName: 'font-family' 17091 }] 17092 }, { 17093 path: ['spacing', 'spacingSizes'], 17094 valueKey: 'size', 17095 cssVarInfix: 'spacing', 17096 valueFunc: ({ 17097 size 17098 }) => size, 17099 classes: [] 17100 }]; 17101 const STYLE_PATH_TO_CSS_VAR_INFIX = { 17102 'color.background': 'color', 17103 'color.text': 'color', 17104 'filter.duotone': 'duotone', 17105 'elements.link.color.text': 'color', 17106 'elements.link.:hover.color.text': 'color', 17107 'elements.link.typography.fontFamily': 'font-family', 17108 'elements.link.typography.fontSize': 'font-size', 17109 'elements.button.color.text': 'color', 17110 'elements.button.color.background': 'color', 17111 'elements.caption.color.text': 'color', 17112 'elements.button.typography.fontFamily': 'font-family', 17113 'elements.button.typography.fontSize': 'font-size', 17114 'elements.heading.color': 'color', 17115 'elements.heading.color.background': 'color', 17116 'elements.heading.typography.fontFamily': 'font-family', 17117 'elements.heading.gradient': 'gradient', 17118 'elements.heading.color.gradient': 'gradient', 17119 'elements.h1.color': 'color', 17120 'elements.h1.color.background': 'color', 17121 'elements.h1.typography.fontFamily': 'font-family', 17122 'elements.h1.color.gradient': 'gradient', 17123 'elements.h2.color': 'color', 17124 'elements.h2.color.background': 'color', 17125 'elements.h2.typography.fontFamily': 'font-family', 17126 'elements.h2.color.gradient': 'gradient', 17127 'elements.h3.color': 'color', 17128 'elements.h3.color.background': 'color', 17129 'elements.h3.typography.fontFamily': 'font-family', 17130 'elements.h3.color.gradient': 'gradient', 17131 'elements.h4.color': 'color', 17132 'elements.h4.color.background': 'color', 17133 'elements.h4.typography.fontFamily': 'font-family', 17134 'elements.h4.color.gradient': 'gradient', 17135 'elements.h5.color': 'color', 17136 'elements.h5.color.background': 'color', 17137 'elements.h5.typography.fontFamily': 'font-family', 17138 'elements.h5.color.gradient': 'gradient', 17139 'elements.h6.color': 'color', 17140 'elements.h6.color.background': 'color', 17141 'elements.h6.typography.fontFamily': 'font-family', 17142 'elements.h6.color.gradient': 'gradient', 17143 'color.gradient': 'gradient', 17144 shadow: 'shadow', 17145 'typography.fontSize': 'font-size', 17146 'typography.fontFamily': 'font-family' 17147 }; 17148 17149 // A static list of block attributes that store global style preset slugs. 17150 const STYLE_PATH_TO_PRESET_BLOCK_ATTRIBUTE = { 17151 'color.background': 'backgroundColor', 17152 'color.text': 'textColor', 17153 'color.gradient': 'gradient', 17154 'typography.fontSize': 'fontSize', 17155 'typography.fontFamily': 'fontFamily' 17156 }; 17157 function useToolsPanelDropdownMenuProps() { 17158 const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<'); 17159 return !isMobile ? { 17160 popoverProps: { 17161 placement: 'left-start', 17162 // For non-mobile, inner sidebar width (248px) - button width (24px) - border (1px) + padding (16px) + spacing (20px) 17163 offset: 259 17164 } 17165 } : {}; 17166 } 17167 function findInPresetsBy(features, blockName, presetPath, presetProperty, presetValueValue) { 17168 // Block presets take priority above root level presets. 17169 const orderedPresetsByOrigin = [getValueFromObjectPath(features, ['blocks', blockName, ...presetPath]), getValueFromObjectPath(features, presetPath)]; 17170 for (const presetByOrigin of orderedPresetsByOrigin) { 17171 if (presetByOrigin) { 17172 // Preset origins ordered by priority. 17173 const origins = ['custom', 'theme', 'default']; 17174 for (const origin of origins) { 17175 const presets = presetByOrigin[origin]; 17176 if (presets) { 17177 const presetObject = presets.find(preset => preset[presetProperty] === presetValueValue); 17178 if (presetObject) { 17179 if (presetProperty === 'slug') { 17180 return presetObject; 17181 } 17182 // If there is a highest priority preset with the same slug but different value the preset we found was overwritten and should be ignored. 17183 const highestPresetObjectWithSameSlug = findInPresetsBy(features, blockName, presetPath, 'slug', presetObject.slug); 17184 if (highestPresetObjectWithSameSlug[presetProperty] === presetObject[presetProperty]) { 17185 return presetObject; 17186 } 17187 return undefined; 17188 } 17189 } 17190 } 17191 } 17192 } 17193 } 17194 function getPresetVariableFromValue(features, blockName, variableStylePath, presetPropertyValue) { 17195 if (!presetPropertyValue) { 17196 return presetPropertyValue; 17197 } 17198 const cssVarInfix = STYLE_PATH_TO_CSS_VAR_INFIX[variableStylePath]; 17199 const metadata = PRESET_METADATA.find(data => data.cssVarInfix === cssVarInfix); 17200 if (!metadata) { 17201 // The property doesn't have preset data 17202 // so the value should be returned as it is. 17203 return presetPropertyValue; 17204 } 17205 const { 17206 valueKey, 17207 path 17208 } = metadata; 17209 const presetObject = findInPresetsBy(features, blockName, path, valueKey, presetPropertyValue); 17210 if (!presetObject) { 17211 // Value wasn't found in the presets, 17212 // so it must be a custom value. 17213 return presetPropertyValue; 17214 } 17215 return `var:preset|$cssVarInfix}|$presetObject.slug}`; 17216 } 17217 function getValueFromPresetVariable(features, blockName, variable, [presetType, slug]) { 17218 const metadata = PRESET_METADATA.find(data => data.cssVarInfix === presetType); 17219 if (!metadata) { 17220 return variable; 17221 } 17222 const presetObject = findInPresetsBy(features.settings, blockName, metadata.path, 'slug', slug); 17223 if (presetObject) { 17224 const { 17225 valueKey 17226 } = metadata; 17227 const result = presetObject[valueKey]; 17228 return getValueFromVariable(features, blockName, result); 17229 } 17230 return variable; 17231 } 17232 function getValueFromCustomVariable(features, blockName, variable, path) { 17233 var _getValueFromObjectPa; 17234 const result = (_getValueFromObjectPa = getValueFromObjectPath(features.settings, ['blocks', blockName, 'custom', ...path])) !== null && _getValueFromObjectPa !== void 0 ? _getValueFromObjectPa : getValueFromObjectPath(features.settings, ['custom', ...path]); 17235 if (!result) { 17236 return variable; 17237 } 17238 // A variable may reference another variable so we need recursion until we find the value. 17239 return getValueFromVariable(features, blockName, result); 17240 } 17241 17242 /** 17243 * Attempts to fetch the value of a theme.json CSS variable. 17244 * 17245 * @param {Object} features GlobalStylesContext config, e.g., user, base or merged. Represents the theme.json tree. 17246 * @param {string} blockName The name of a block as represented in the styles property. E.g., 'root' for root-level, and 'core/${blockName}' for blocks. 17247 * @param {string|*} variable An incoming style value. A CSS var value is expected, but it could be any value. 17248 * @return {string|*|{ref}} The value of the CSS var, if found. If not found, the passed variable argument. 17249 */ 17250 function getValueFromVariable(features, blockName, variable) { 17251 if (!variable || typeof variable !== 'string') { 17252 if (typeof variable?.ref === 'string') { 17253 variable = getValueFromObjectPath(features, variable.ref); 17254 // Presence of another ref indicates a reference to another dynamic value. 17255 // Pointing to another dynamic value is not supported. 17256 if (!variable || !!variable?.ref) { 17257 return variable; 17258 } 17259 } else { 17260 return variable; 17261 } 17262 } 17263 const USER_VALUE_PREFIX = 'var:'; 17264 const THEME_VALUE_PREFIX = 'var(--wp--'; 17265 const THEME_VALUE_SUFFIX = ')'; 17266 let parsedVar; 17267 if (variable.startsWith(USER_VALUE_PREFIX)) { 17268 parsedVar = variable.slice(USER_VALUE_PREFIX.length).split('|'); 17269 } else if (variable.startsWith(THEME_VALUE_PREFIX) && variable.endsWith(THEME_VALUE_SUFFIX)) { 17270 parsedVar = variable.slice(THEME_VALUE_PREFIX.length, -THEME_VALUE_SUFFIX.length).split('--'); 17271 } else { 17272 // We don't know how to parse the value: either is raw of uses complex CSS such as `calc(1px * var(--wp--variable) )` 17273 return variable; 17274 } 17275 const [type, ...path] = parsedVar; 17276 if (type === 'preset') { 17277 return getValueFromPresetVariable(features, blockName, variable, path); 17278 } 17279 if (type === 'custom') { 17280 return getValueFromCustomVariable(features, blockName, variable, path); 17281 } 17282 return variable; 17283 } 17284 17285 /** 17286 * Function that scopes a selector with another one. This works a bit like 17287 * SCSS nesting except the `&` operator isn't supported. 17288 * 17289 * @example 17290 * ```js 17291 * const scope = '.a, .b .c'; 17292 * const selector = '> .x, .y'; 17293 * const merged = scopeSelector( scope, selector ); 17294 * // merged is '.a > .x, .a .y, .b .c > .x, .b .c .y' 17295 * ``` 17296 * 17297 * @param {string} scope Selector to scope to. 17298 * @param {string} selector Original selector. 17299 * 17300 * @return {string} Scoped selector. 17301 */ 17302 function scopeSelector(scope, selector) { 17303 if (!scope || !selector) { 17304 return selector; 17305 } 17306 const scopes = scope.split(','); 17307 const selectors = selector.split(','); 17308 const selectorsScoped = []; 17309 scopes.forEach(outer => { 17310 selectors.forEach(inner => { 17311 selectorsScoped.push(`$outer.trim()} $inner.trim()}`); 17312 }); 17313 }); 17314 return selectorsScoped.join(', '); 17315 } 17316 17317 /** 17318 * Scopes a collection of selectors for features and subfeatures. 17319 * 17320 * @example 17321 * ```js 17322 * const scope = '.custom-scope'; 17323 * const selectors = { 17324 * color: '.wp-my-block p', 17325 * typography: { fontSize: '.wp-my-block caption' }, 17326 * }; 17327 * const result = scopeFeatureSelector( scope, selectors ); 17328 * // result is { 17329 * // color: '.custom-scope .wp-my-block p', 17330 * // typography: { fonSize: '.custom-scope .wp-my-block caption' }, 17331 * // } 17332 * ``` 17333 * 17334 * @param {string} scope Selector to scope collection of selectors with. 17335 * @param {Object} selectors Collection of feature selectors e.g. 17336 * 17337 * @return {Object|undefined} Scoped collection of feature selectors. 17338 */ 17339 function scopeFeatureSelectors(scope, selectors) { 17340 if (!scope || !selectors) { 17341 return; 17342 } 17343 const featureSelectors = {}; 17344 Object.entries(selectors).forEach(([feature, selector]) => { 17345 if (typeof selector === 'string') { 17346 featureSelectors[feature] = scopeSelector(scope, selector); 17347 } 17348 if (typeof selector === 'object') { 17349 featureSelectors[feature] = {}; 17350 Object.entries(selector).forEach(([subfeature, subfeatureSelector]) => { 17351 featureSelectors[feature][subfeature] = scopeSelector(scope, subfeatureSelector); 17352 }); 17353 } 17354 }); 17355 return featureSelectors; 17356 } 17357 17358 /** 17359 * Appends a sub-selector to an existing one. 17360 * 17361 * Given the compounded `selector` "h1, h2, h3" 17362 * and the `toAppend` selector ".some-class" the result will be 17363 * "h1.some-class, h2.some-class, h3.some-class". 17364 * 17365 * @param {string} selector Original selector. 17366 * @param {string} toAppend Selector to append. 17367 * 17368 * @return {string} The new selector. 17369 */ 17370 function appendToSelector(selector, toAppend) { 17371 if (!selector.includes(',')) { 17372 return selector + toAppend; 17373 } 17374 const selectors = selector.split(','); 17375 const newSelectors = selectors.map(sel => sel + toAppend); 17376 return newSelectors.join(','); 17377 } 17378 17379 /** 17380 * Compares global style variations according to their styles and settings properties. 17381 * 17382 * @example 17383 * ```js 17384 * const globalStyles = { styles: { typography: { fontSize: '10px' } }, settings: {} }; 17385 * const variation = { styles: { typography: { fontSize: '10000px' } }, settings: {} }; 17386 * const isEqual = areGlobalStyleConfigsEqual( globalStyles, variation ); 17387 * // false 17388 * ``` 17389 * 17390 * @param {Object} original A global styles object. 17391 * @param {Object} variation A global styles object. 17392 * 17393 * @return {boolean} Whether `original` and `variation` match. 17394 */ 17395 function areGlobalStyleConfigsEqual(original, variation) { 17396 if (typeof original !== 'object' || typeof variation !== 'object') { 17397 return original === variation; 17398 } 17399 return es6_default()(original?.styles, variation?.styles) && es6_default()(original?.settings, variation?.settings); 17400 } 17401 17402 /** 17403 * Generates the selector for a block style variation by creating the 17404 * appropriate CSS class and adding it to the ancestor portion of the block's 17405 * selector. 17406 * 17407 * For example, take the Button block which has a compound selector: 17408 * `.wp-block-button .wp-block-button__link`. With a variation named 'custom', 17409 * the class `.is-style-custom` should be added to the `.wp-block-button` 17410 * ancestor only. 17411 * 17412 * This function will take into account comma separated and complex selectors. 17413 * 17414 * @param {string} variation Name for the variation. 17415 * @param {string} blockSelector CSS selector for the block. 17416 * 17417 * @return {string} CSS selector for the block style variation. 17418 */ 17419 function getBlockStyleVariationSelector(variation, blockSelector) { 17420 const variationClass = `.is-style-$variation}`; 17421 if (!blockSelector) { 17422 return variationClass; 17423 } 17424 const ancestorRegex = /((?::\([^)]+\))?\s*)([^\s:]+)/; 17425 const addVariationClass = (_match, group1, group2) => { 17426 return group1 + group2 + variationClass; 17427 }; 17428 const result = blockSelector.split(',').map(part => part.replace(ancestorRegex, addVariationClass)); 17429 return result.join(','); 17430 } 17431 17432 /** 17433 * Looks up a theme file URI based on a relative path. 17434 * 17435 * @param {string} file A relative path. 17436 * @param {Array<Object>} themeFileURIs A collection of absolute theme file URIs and their corresponding file paths. 17437 * @return {string} A resolved theme file URI, if one is found in the themeFileURIs collection. 17438 */ 17439 function getResolvedThemeFilePath(file, themeFileURIs) { 17440 if (!file || !themeFileURIs || !Array.isArray(themeFileURIs)) { 17441 return file; 17442 } 17443 const uri = themeFileURIs.find(themeFileUri => themeFileUri?.name === file); 17444 if (!uri?.href) { 17445 return file; 17446 } 17447 return uri?.href; 17448 } 17449 17450 /** 17451 * Resolves ref values in theme JSON. 17452 * 17453 * @param {Object|string} ruleValue A block style value that may contain a reference to a theme.json value. 17454 * @param {Object} tree A theme.json object. 17455 * @return {*} The resolved value or incoming ruleValue. 17456 */ 17457 function getResolvedRefValue(ruleValue, tree) { 17458 if (!ruleValue || !tree) { 17459 return ruleValue; 17460 } 17461 17462 /* 17463 * Where the rule value is an object with a 'ref' property pointing 17464 * to a path, this converts that path into the value at that path. 17465 * For example: { "ref": "style.color.background" } => "#fff". 17466 */ 17467 if (typeof ruleValue !== 'string' && ruleValue?.ref) { 17468 const resolvedRuleValue = (0,external_wp_styleEngine_namespaceObject.getCSSValueFromRawStyle)(getValueFromObjectPath(tree, ruleValue.ref)); 17469 17470 /* 17471 * Presence of another ref indicates a reference to another dynamic value. 17472 * Pointing to another dynamic value is not supported. 17473 */ 17474 if (resolvedRuleValue?.ref) { 17475 return undefined; 17476 } 17477 if (resolvedRuleValue === undefined) { 17478 return ruleValue; 17479 } 17480 return resolvedRuleValue; 17481 } 17482 return ruleValue; 17483 } 17484 17485 /** 17486 * Resolves ref and relative path values in theme JSON. 17487 * 17488 * @param {Object|string} ruleValue A block style value that may contain a reference to a theme.json value. 17489 * @param {Object} tree A theme.json object. 17490 * @return {*} The resolved value or incoming ruleValue. 17491 */ 17492 function getResolvedValue(ruleValue, tree) { 17493 if (!ruleValue || !tree) { 17494 return ruleValue; 17495 } 17496 17497 // Resolve ref values. 17498 const resolvedValue = getResolvedRefValue(ruleValue, tree); 17499 17500 // Resolve relative paths. 17501 if (resolvedValue?.url) { 17502 resolvedValue.url = getResolvedThemeFilePath(resolvedValue.url, tree?._links?.['wp:theme-file']); 17503 } 17504 return resolvedValue; 17505 } 17506 17507 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/context.js 17508 /** 17509 * WordPress dependencies 17510 */ 17511 17512 const DEFAULT_GLOBAL_STYLES_CONTEXT = { 17513 user: {}, 17514 base: {}, 17515 merged: {}, 17516 setUserConfig: () => {} 17517 }; 17518 const GlobalStylesContext = (0,external_wp_element_namespaceObject.createContext)(DEFAULT_GLOBAL_STYLES_CONTEXT); 17519 17520 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/hooks.js 17521 /** 17522 * External dependencies 17523 */ 17524 17525 17526 /** 17527 * WordPress dependencies 17528 */ 17529 17530 17531 17532 17533 17534 /** 17535 * Internal dependencies 17536 */ 17537 17538 17539 17540 17541 const EMPTY_CONFIG = { 17542 settings: {}, 17543 styles: {} 17544 }; 17545 const VALID_SETTINGS = ['appearanceTools', 'useRootPaddingAwareAlignments', 'background.backgroundImage', 'background.backgroundRepeat', 'background.backgroundSize', 'background.backgroundPosition', 'border.color', 'border.radius', 'border.style', 'border.width', 'shadow.presets', 'shadow.defaultPresets', 'color.background', 'color.button', 'color.caption', 'color.custom', 'color.customDuotone', 'color.customGradient', 'color.defaultDuotone', 'color.defaultGradients', 'color.defaultPalette', 'color.duotone', 'color.gradients', 'color.heading', 'color.link', 'color.palette', 'color.text', 'custom', 'dimensions.aspectRatio', 'dimensions.minHeight', 'layout.contentSize', 'layout.definitions', 'layout.wideSize', 'lightbox.enabled', 'lightbox.allowEditing', 'position.fixed', 'position.sticky', 'spacing.customSpacingSize', 'spacing.defaultSpacingSizes', 'spacing.spacingSizes', 'spacing.spacingScale', 'spacing.blockGap', 'spacing.margin', 'spacing.padding', 'spacing.units', 'typography.fluid', 'typography.customFontSize', 'typography.defaultFontSizes', 'typography.dropCap', 'typography.fontFamilies', 'typography.fontSizes', 'typography.fontStyle', 'typography.fontWeight', 'typography.letterSpacing', 'typography.lineHeight', 'typography.textAlign', 'typography.textColumns', 'typography.textDecoration', 'typography.textTransform', 'typography.writingMode']; 17546 const useGlobalStylesReset = () => { 17547 const { 17548 user, 17549 setUserConfig 17550 } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext); 17551 const config = { 17552 settings: user.settings, 17553 styles: user.styles 17554 }; 17555 const canReset = !!config && !es6_default()(config, EMPTY_CONFIG); 17556 return [canReset, (0,external_wp_element_namespaceObject.useCallback)(() => setUserConfig(EMPTY_CONFIG), [setUserConfig])]; 17557 }; 17558 function useGlobalSetting(propertyPath, blockName, source = 'all') { 17559 const { 17560 setUserConfig, 17561 ...configs 17562 } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext); 17563 const appendedBlockPath = blockName ? '.blocks.' + blockName : ''; 17564 const appendedPropertyPath = propertyPath ? '.' + propertyPath : ''; 17565 const contextualPath = `settings$appendedBlockPath}$appendedPropertyPath}`; 17566 const globalPath = `settings$appendedPropertyPath}`; 17567 const sourceKey = source === 'all' ? 'merged' : source; 17568 const settingValue = (0,external_wp_element_namespaceObject.useMemo)(() => { 17569 const configToUse = configs[sourceKey]; 17570 if (!configToUse) { 17571 throw 'Unsupported source'; 17572 } 17573 if (propertyPath) { 17574 var _getValueFromObjectPa; 17575 return (_getValueFromObjectPa = getValueFromObjectPath(configToUse, contextualPath)) !== null && _getValueFromObjectPa !== void 0 ? _getValueFromObjectPa : getValueFromObjectPath(configToUse, globalPath); 17576 } 17577 let result = {}; 17578 VALID_SETTINGS.forEach(setting => { 17579 var _getValueFromObjectPa2; 17580 const value = (_getValueFromObjectPa2 = getValueFromObjectPath(configToUse, `settings$appendedBlockPath}.$setting}`)) !== null && _getValueFromObjectPa2 !== void 0 ? _getValueFromObjectPa2 : getValueFromObjectPath(configToUse, `settings.$setting}`); 17581 if (value !== undefined) { 17582 result = setImmutably(result, setting.split('.'), value); 17583 } 17584 }); 17585 return result; 17586 }, [configs, sourceKey, propertyPath, contextualPath, globalPath, appendedBlockPath]); 17587 const setSetting = newValue => { 17588 setUserConfig(currentConfig => setImmutably(currentConfig, contextualPath.split('.'), newValue)); 17589 }; 17590 return [settingValue, setSetting]; 17591 } 17592 function useGlobalStyle(path, blockName, source = 'all', { 17593 shouldDecodeEncode = true 17594 } = {}) { 17595 const { 17596 merged: mergedConfig, 17597 base: baseConfig, 17598 user: userConfig, 17599 setUserConfig 17600 } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext); 17601 const appendedPath = path ? '.' + path : ''; 17602 const finalPath = !blockName ? `styles$appendedPath}` : `styles.blocks.$blockName}$appendedPath}`; 17603 const setStyle = newValue => { 17604 setUserConfig(currentConfig => setImmutably(currentConfig, finalPath.split('.'), shouldDecodeEncode ? getPresetVariableFromValue(mergedConfig.settings, blockName, path, newValue) : newValue)); 17605 }; 17606 let rawResult, result; 17607 switch (source) { 17608 case 'all': 17609 rawResult = getValueFromObjectPath(mergedConfig, finalPath); 17610 result = shouldDecodeEncode ? getValueFromVariable(mergedConfig, blockName, rawResult) : rawResult; 17611 break; 17612 case 'user': 17613 rawResult = getValueFromObjectPath(userConfig, finalPath); 17614 result = shouldDecodeEncode ? getValueFromVariable(mergedConfig, blockName, rawResult) : rawResult; 17615 break; 17616 case 'base': 17617 rawResult = getValueFromObjectPath(baseConfig, finalPath); 17618 result = shouldDecodeEncode ? getValueFromVariable(baseConfig, blockName, rawResult) : rawResult; 17619 break; 17620 default: 17621 throw 'Unsupported source'; 17622 } 17623 return [result, setStyle]; 17624 } 17625 17626 /** 17627 * React hook that overrides a global settings object with block and element specific settings. 17628 * 17629 * @param {Object} parentSettings Settings object. 17630 * @param {blockName?} blockName Block name. 17631 * @param {element?} element Element name. 17632 * 17633 * @return {Object} Merge of settings and supports. 17634 */ 17635 function useSettingsForBlockElement(parentSettings, blockName, element) { 17636 const { 17637 supportedStyles, 17638 supports 17639 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 17640 return { 17641 supportedStyles: unlock(select(external_wp_blocks_namespaceObject.store)).getSupportedStyles(blockName, element), 17642 supports: select(external_wp_blocks_namespaceObject.store).getBlockType(blockName)?.supports 17643 }; 17644 }, [blockName, element]); 17645 return (0,external_wp_element_namespaceObject.useMemo)(() => { 17646 const updatedSettings = { 17647 ...parentSettings 17648 }; 17649 if (!supportedStyles.includes('fontSize')) { 17650 updatedSettings.typography = { 17651 ...updatedSettings.typography, 17652 fontSizes: {}, 17653 customFontSize: false, 17654 defaultFontSizes: false 17655 }; 17656 } 17657 if (!supportedStyles.includes('fontFamily')) { 17658 updatedSettings.typography = { 17659 ...updatedSettings.typography, 17660 fontFamilies: {} 17661 }; 17662 } 17663 updatedSettings.color = { 17664 ...updatedSettings.color, 17665 text: updatedSettings.color?.text && supportedStyles.includes('color'), 17666 background: updatedSettings.color?.background && (supportedStyles.includes('background') || supportedStyles.includes('backgroundColor')), 17667 button: updatedSettings.color?.button && supportedStyles.includes('buttonColor'), 17668 heading: updatedSettings.color?.heading && supportedStyles.includes('headingColor'), 17669 link: updatedSettings.color?.link && supportedStyles.includes('linkColor'), 17670 caption: updatedSettings.color?.caption && supportedStyles.includes('captionColor') 17671 }; 17672 17673 // Some blocks can enable background colors but disable gradients. 17674 if (!supportedStyles.includes('background')) { 17675 updatedSettings.color.gradients = []; 17676 updatedSettings.color.customGradient = false; 17677 } 17678 17679 // If filters are not supported by the block/element, disable duotone. 17680 if (!supportedStyles.includes('filter')) { 17681 updatedSettings.color.defaultDuotone = false; 17682 updatedSettings.color.customDuotone = false; 17683 } 17684 ['lineHeight', 'fontStyle', 'fontWeight', 'letterSpacing', 'textAlign', 'textTransform', 'textDecoration', 'writingMode'].forEach(key => { 17685 if (!supportedStyles.includes(key)) { 17686 updatedSettings.typography = { 17687 ...updatedSettings.typography, 17688 [key]: false 17689 }; 17690 } 17691 }); 17692 17693 // The column-count style is named text column to reduce confusion with 17694 // the columns block and manage expectations from the support. 17695 // See: https://github.com/WordPress/gutenberg/pull/33587 17696 if (!supportedStyles.includes('columnCount')) { 17697 updatedSettings.typography = { 17698 ...updatedSettings.typography, 17699 textColumns: false 17700 }; 17701 } 17702 ['contentSize', 'wideSize'].forEach(key => { 17703 if (!supportedStyles.includes(key)) { 17704 updatedSettings.layout = { 17705 ...updatedSettings.layout, 17706 [key]: false 17707 }; 17708 } 17709 }); 17710 ['padding', 'margin', 'blockGap'].forEach(key => { 17711 if (!supportedStyles.includes(key)) { 17712 updatedSettings.spacing = { 17713 ...updatedSettings.spacing, 17714 [key]: false 17715 }; 17716 } 17717 const sides = Array.isArray(supports?.spacing?.[key]) ? supports?.spacing?.[key] : supports?.spacing?.[key]?.sides; 17718 // Check if spacing type is supported before adding sides. 17719 if (sides?.length && updatedSettings.spacing?.[key]) { 17720 updatedSettings.spacing = { 17721 ...updatedSettings.spacing, 17722 [key]: { 17723 ...updatedSettings.spacing?.[key], 17724 sides 17725 } 17726 }; 17727 } 17728 }); 17729 ['aspectRatio', 'minHeight'].forEach(key => { 17730 if (!supportedStyles.includes(key)) { 17731 updatedSettings.dimensions = { 17732 ...updatedSettings.dimensions, 17733 [key]: false 17734 }; 17735 } 17736 }); 17737 ['radius', 'color', 'style', 'width'].forEach(key => { 17738 if (!supportedStyles.includes('border' + key.charAt(0).toUpperCase() + key.slice(1))) { 17739 updatedSettings.border = { 17740 ...updatedSettings.border, 17741 [key]: false 17742 }; 17743 } 17744 }); 17745 ['backgroundImage', 'backgroundSize'].forEach(key => { 17746 if (!supportedStyles.includes(key)) { 17747 updatedSettings.background = { 17748 ...updatedSettings.background, 17749 [key]: false 17750 }; 17751 } 17752 }); 17753 updatedSettings.shadow = supportedStyles.includes('shadow') ? updatedSettings.shadow : false; 17754 17755 // Text alignment is only available for blocks. 17756 if (element) { 17757 updatedSettings.typography.textAlign = false; 17758 } 17759 return updatedSettings; 17760 }, [parentSettings, supportedStyles, supports, element]); 17761 } 17762 function useColorsPerOrigin(settings) { 17763 const customColors = settings?.color?.palette?.custom; 17764 const themeColors = settings?.color?.palette?.theme; 17765 const defaultColors = settings?.color?.palette?.default; 17766 const shouldDisplayDefaultColors = settings?.color?.defaultPalette; 17767 return (0,external_wp_element_namespaceObject.useMemo)(() => { 17768 const result = []; 17769 if (themeColors && themeColors.length) { 17770 result.push({ 17771 name: (0,external_wp_i18n_namespaceObject._x)('Theme', 'Indicates this palette comes from the theme.'), 17772 colors: themeColors 17773 }); 17774 } 17775 if (shouldDisplayDefaultColors && defaultColors && defaultColors.length) { 17776 result.push({ 17777 name: (0,external_wp_i18n_namespaceObject._x)('Default', 'Indicates this palette comes from WordPress.'), 17778 colors: defaultColors 17779 }); 17780 } 17781 if (customColors && customColors.length) { 17782 result.push({ 17783 name: (0,external_wp_i18n_namespaceObject._x)('Custom', 'Indicates this palette is created by the user.'), 17784 colors: customColors 17785 }); 17786 } 17787 return result; 17788 }, [customColors, themeColors, defaultColors, shouldDisplayDefaultColors]); 17789 } 17790 function useGradientsPerOrigin(settings) { 17791 const customGradients = settings?.color?.gradients?.custom; 17792 const themeGradients = settings?.color?.gradients?.theme; 17793 const defaultGradients = settings?.color?.gradients?.default; 17794 const shouldDisplayDefaultGradients = settings?.color?.defaultGradients; 17795 return (0,external_wp_element_namespaceObject.useMemo)(() => { 17796 const result = []; 17797 if (themeGradients && themeGradients.length) { 17798 result.push({ 17799 name: (0,external_wp_i18n_namespaceObject._x)('Theme', 'Indicates this palette comes from the theme.'), 17800 gradients: themeGradients 17801 }); 17802 } 17803 if (shouldDisplayDefaultGradients && defaultGradients && defaultGradients.length) { 17804 result.push({ 17805 name: (0,external_wp_i18n_namespaceObject._x)('Default', 'Indicates this palette comes from WordPress.'), 17806 gradients: defaultGradients 17807 }); 17808 } 17809 if (customGradients && customGradients.length) { 17810 result.push({ 17811 name: (0,external_wp_i18n_namespaceObject._x)('Custom', 'Indicates this palette is created by the user.'), 17812 gradients: customGradients 17813 }); 17814 } 17815 return result; 17816 }, [customGradients, themeGradients, defaultGradients, shouldDisplayDefaultGradients]); 17817 } 17818 17819 ;// ./node_modules/clsx/dist/clsx.mjs 17820 function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f)}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}/* harmony default export */ const dist_clsx = (clsx); 17821 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/utils.js 17822 /** 17823 * WordPress dependencies 17824 */ 17825 17826 17827 17828 17829 17830 17831 /** 17832 * Internal dependencies 17833 */ 17834 17835 17836 17837 17838 17839 17840 /** 17841 * External dependencies 17842 */ 17843 17844 17845 /** 17846 * Removed falsy values from nested object. 17847 * 17848 * @param {*} object 17849 * @return {*} Object cleaned from falsy values 17850 */ 17851 17852 const utils_cleanEmptyObject = object => { 17853 if (object === null || typeof object !== 'object' || Array.isArray(object)) { 17854 return object; 17855 } 17856 const cleanedNestedObjects = Object.entries(object).map(([key, value]) => [key, utils_cleanEmptyObject(value)]).filter(([, value]) => value !== undefined); 17857 return !cleanedNestedObjects.length ? undefined : Object.fromEntries(cleanedNestedObjects); 17858 }; 17859 function transformStyles(activeSupports, migrationPaths, result, source, index, results) { 17860 // If there are no active supports return early. 17861 if (Object.values(activeSupports !== null && activeSupports !== void 0 ? activeSupports : {}).every(isActive => !isActive)) { 17862 return result; 17863 } 17864 // If the condition verifies we are probably in the presence of a wrapping transform 17865 // e.g: nesting paragraphs in a group or columns and in that case the styles should not be transformed. 17866 if (results.length === 1 && result.innerBlocks.length === source.length) { 17867 return result; 17868 } 17869 // For cases where we have a transform from one block to multiple blocks 17870 // or multiple blocks to one block we apply the styles of the first source block 17871 // to the result(s). 17872 let referenceBlockAttributes = source[0]?.attributes; 17873 // If we are in presence of transform between more than one block in the source 17874 // that has more than one block in the result 17875 // we apply the styles on source N to the result N, 17876 // if source N does not exists we do nothing. 17877 if (results.length > 1 && source.length > 1) { 17878 if (source[index]) { 17879 referenceBlockAttributes = source[index]?.attributes; 17880 } else { 17881 return result; 17882 } 17883 } 17884 let returnBlock = result; 17885 Object.entries(activeSupports).forEach(([support, isActive]) => { 17886 if (isActive) { 17887 migrationPaths[support].forEach(path => { 17888 const styleValue = getValueFromObjectPath(referenceBlockAttributes, path); 17889 if (styleValue) { 17890 returnBlock = { 17891 ...returnBlock, 17892 attributes: setImmutably(returnBlock.attributes, path, styleValue) 17893 }; 17894 } 17895 }); 17896 } 17897 }); 17898 return returnBlock; 17899 } 17900 17901 /** 17902 * Check whether serialization of specific block support feature or set should 17903 * be skipped. 17904 * 17905 * @param {string|Object} blockNameOrType Block name or block type object. 17906 * @param {string} featureSet Name of block support feature set. 17907 * @param {string} feature Name of the individual feature to check. 17908 * 17909 * @return {boolean} Whether serialization should occur. 17910 */ 17911 function shouldSkipSerialization(blockNameOrType, featureSet, feature) { 17912 const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockNameOrType, featureSet); 17913 const skipSerialization = support?.__experimentalSkipSerialization; 17914 if (Array.isArray(skipSerialization)) { 17915 return skipSerialization.includes(feature); 17916 } 17917 return skipSerialization; 17918 } 17919 const pendingStyleOverrides = new WeakMap(); 17920 17921 /** 17922 * Override a block editor settings style. Leave the ID blank to create a new 17923 * style. 17924 * 17925 * @param {Object} override Override object. 17926 * @param {?string} override.id Id of the style override, leave blank to create 17927 * a new style. 17928 * @param {string} override.css CSS to apply. 17929 */ 17930 function useStyleOverride({ 17931 id, 17932 css 17933 }) { 17934 return usePrivateStyleOverride({ 17935 id, 17936 css 17937 }); 17938 } 17939 function usePrivateStyleOverride({ 17940 id, 17941 css, 17942 assets, 17943 __unstableType, 17944 variation, 17945 clientId 17946 } = {}) { 17947 const { 17948 setStyleOverride, 17949 deleteStyleOverride 17950 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 17951 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 17952 const fallbackId = (0,external_wp_element_namespaceObject.useId)(); 17953 (0,external_wp_element_namespaceObject.useEffect)(() => { 17954 // Unmount if there is CSS and assets are empty. 17955 if (!css && !assets) { 17956 return; 17957 } 17958 const _id = id || fallbackId; 17959 const override = { 17960 id, 17961 css, 17962 assets, 17963 __unstableType, 17964 variation, 17965 clientId 17966 }; 17967 // Batch updates to style overrides to avoid triggering cascading renders 17968 // for each style override block included in a tree and optimize initial render. 17969 if (!pendingStyleOverrides.get(registry)) { 17970 pendingStyleOverrides.set(registry, []); 17971 } 17972 pendingStyleOverrides.get(registry).push([_id, override]); 17973 window.queueMicrotask(() => { 17974 if (pendingStyleOverrides.get(registry)?.length) { 17975 registry.batch(() => { 17976 pendingStyleOverrides.get(registry).forEach(args => { 17977 setStyleOverride(...args); 17978 }); 17979 pendingStyleOverrides.set(registry, []); 17980 }); 17981 } 17982 }); 17983 return () => { 17984 const isPending = pendingStyleOverrides.get(registry)?.find(([currentId]) => currentId === _id); 17985 if (isPending) { 17986 pendingStyleOverrides.set(registry, pendingStyleOverrides.get(registry).filter(([currentId]) => currentId !== _id)); 17987 } else { 17988 deleteStyleOverride(_id); 17989 } 17990 }; 17991 }, [id, css, clientId, assets, __unstableType, fallbackId, setStyleOverride, deleteStyleOverride, registry]); 17992 } 17993 17994 /** 17995 * Based on the block and its context, returns an object of all the block settings. 17996 * This object can be passed as a prop to all the Styles UI components 17997 * (TypographyPanel, DimensionsPanel...). 17998 * 17999 * @param {string} name Block name. 18000 * @param {*} parentLayout Parent layout. 18001 * 18002 * @return {Object} Settings object. 18003 */ 18004 function useBlockSettings(name, parentLayout) { 18005 const [backgroundImage, backgroundSize, customFontFamilies, defaultFontFamilies, themeFontFamilies, defaultFontSizesEnabled, customFontSizes, defaultFontSizes, themeFontSizes, customFontSize, fontStyle, fontWeight, lineHeight, textAlign, textColumns, textDecoration, writingMode, textTransform, letterSpacing, padding, margin, blockGap, defaultSpacingSizesEnabled, customSpacingSize, userSpacingSizes, defaultSpacingSizes, themeSpacingSizes, units, aspectRatio, minHeight, layout, borderColor, borderRadius, borderStyle, borderWidth, customColorsEnabled, customColors, customDuotone, themeColors, defaultColors, defaultPalette, defaultDuotone, userDuotonePalette, themeDuotonePalette, defaultDuotonePalette, userGradientPalette, themeGradientPalette, defaultGradientPalette, defaultGradients, areCustomGradientsEnabled, isBackgroundEnabled, isLinkEnabled, isTextEnabled, isHeadingEnabled, isButtonEnabled, shadow] = use_settings_useSettings('background.backgroundImage', 'background.backgroundSize', 'typography.fontFamilies.custom', 'typography.fontFamilies.default', 'typography.fontFamilies.theme', 'typography.defaultFontSizes', 'typography.fontSizes.custom', 'typography.fontSizes.default', 'typography.fontSizes.theme', 'typography.customFontSize', 'typography.fontStyle', 'typography.fontWeight', 'typography.lineHeight', 'typography.textAlign', 'typography.textColumns', 'typography.textDecoration', 'typography.writingMode', 'typography.textTransform', 'typography.letterSpacing', 'spacing.padding', 'spacing.margin', 'spacing.blockGap', 'spacing.defaultSpacingSizes', 'spacing.customSpacingSize', 'spacing.spacingSizes.custom', 'spacing.spacingSizes.default', 'spacing.spacingSizes.theme', 'spacing.units', 'dimensions.aspectRatio', 'dimensions.minHeight', 'layout', 'border.color', 'border.radius', 'border.style', 'border.width', 'color.custom', 'color.palette.custom', 'color.customDuotone', 'color.palette.theme', 'color.palette.default', 'color.defaultPalette', 'color.defaultDuotone', 'color.duotone.custom', 'color.duotone.theme', 'color.duotone.default', 'color.gradients.custom', 'color.gradients.theme', 'color.gradients.default', 'color.defaultGradients', 'color.customGradient', 'color.background', 'color.link', 'color.text', 'color.heading', 'color.button', 'shadow'); 18006 const rawSettings = (0,external_wp_element_namespaceObject.useMemo)(() => { 18007 return { 18008 background: { 18009 backgroundImage, 18010 backgroundSize 18011 }, 18012 color: { 18013 palette: { 18014 custom: customColors, 18015 theme: themeColors, 18016 default: defaultColors 18017 }, 18018 gradients: { 18019 custom: userGradientPalette, 18020 theme: themeGradientPalette, 18021 default: defaultGradientPalette 18022 }, 18023 duotone: { 18024 custom: userDuotonePalette, 18025 theme: themeDuotonePalette, 18026 default: defaultDuotonePalette 18027 }, 18028 defaultGradients, 18029 defaultPalette, 18030 defaultDuotone, 18031 custom: customColorsEnabled, 18032 customGradient: areCustomGradientsEnabled, 18033 customDuotone, 18034 background: isBackgroundEnabled, 18035 link: isLinkEnabled, 18036 heading: isHeadingEnabled, 18037 button: isButtonEnabled, 18038 text: isTextEnabled 18039 }, 18040 typography: { 18041 fontFamilies: { 18042 custom: customFontFamilies, 18043 default: defaultFontFamilies, 18044 theme: themeFontFamilies 18045 }, 18046 fontSizes: { 18047 custom: customFontSizes, 18048 default: defaultFontSizes, 18049 theme: themeFontSizes 18050 }, 18051 customFontSize, 18052 defaultFontSizes: defaultFontSizesEnabled, 18053 fontStyle, 18054 fontWeight, 18055 lineHeight, 18056 textAlign, 18057 textColumns, 18058 textDecoration, 18059 textTransform, 18060 letterSpacing, 18061 writingMode 18062 }, 18063 spacing: { 18064 spacingSizes: { 18065 custom: userSpacingSizes, 18066 default: defaultSpacingSizes, 18067 theme: themeSpacingSizes 18068 }, 18069 customSpacingSize, 18070 defaultSpacingSizes: defaultSpacingSizesEnabled, 18071 padding, 18072 margin, 18073 blockGap, 18074 units 18075 }, 18076 border: { 18077 color: borderColor, 18078 radius: borderRadius, 18079 style: borderStyle, 18080 width: borderWidth 18081 }, 18082 dimensions: { 18083 aspectRatio, 18084 minHeight 18085 }, 18086 layout, 18087 parentLayout, 18088 shadow 18089 }; 18090 }, [backgroundImage, backgroundSize, customFontFamilies, defaultFontFamilies, themeFontFamilies, defaultFontSizesEnabled, customFontSizes, defaultFontSizes, themeFontSizes, customFontSize, fontStyle, fontWeight, lineHeight, textAlign, textColumns, textDecoration, textTransform, letterSpacing, writingMode, padding, margin, blockGap, defaultSpacingSizesEnabled, customSpacingSize, userSpacingSizes, defaultSpacingSizes, themeSpacingSizes, units, aspectRatio, minHeight, layout, parentLayout, borderColor, borderRadius, borderStyle, borderWidth, customColorsEnabled, customColors, customDuotone, themeColors, defaultColors, defaultPalette, defaultDuotone, userDuotonePalette, themeDuotonePalette, defaultDuotonePalette, userGradientPalette, themeGradientPalette, defaultGradientPalette, defaultGradients, areCustomGradientsEnabled, isBackgroundEnabled, isLinkEnabled, isTextEnabled, isHeadingEnabled, isButtonEnabled, shadow]); 18091 return useSettingsForBlockElement(rawSettings, name); 18092 } 18093 function createBlockEditFilter(features) { 18094 // We don't want block controls to re-render when typing inside a block. 18095 // `memo` will prevent re-renders unless props change, so only pass the 18096 // needed props and not the whole attributes object. 18097 features = features.map(settings => { 18098 return { 18099 ...settings, 18100 Edit: (0,external_wp_element_namespaceObject.memo)(settings.edit) 18101 }; 18102 }); 18103 const withBlockEditHooks = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(OriginalBlockEdit => props => { 18104 const context = useBlockEditContext(); 18105 // CAUTION: code added before this line will be executed for all 18106 // blocks, not just those that support the feature! Code added 18107 // above this line should be carefully evaluated for its impact on 18108 // performance. 18109 return [...features.map((feature, i) => { 18110 const { 18111 Edit, 18112 hasSupport, 18113 attributeKeys = [], 18114 shareWithChildBlocks 18115 } = feature; 18116 const shouldDisplayControls = context[mayDisplayControlsKey] || context[mayDisplayParentControlsKey] && shareWithChildBlocks; 18117 if (!shouldDisplayControls || !hasSupport(props.name)) { 18118 return null; 18119 } 18120 const neededProps = {}; 18121 for (const key of attributeKeys) { 18122 if (props.attributes[key]) { 18123 neededProps[key] = props.attributes[key]; 18124 } 18125 } 18126 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Edit 18127 // We can use the index because the array length 18128 // is fixed per page load right now. 18129 , { 18130 name: props.name, 18131 isSelected: props.isSelected, 18132 clientId: props.clientId, 18133 setAttributes: props.setAttributes, 18134 __unstableParentLayout: props.__unstableParentLayout 18135 // This component is pure, so only pass needed 18136 // props!!! 18137 , 18138 ...neededProps 18139 }, i); 18140 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(OriginalBlockEdit, { 18141 ...props 18142 }, "edit")]; 18143 }, 'withBlockEditHooks'); 18144 (0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockEdit', 'core/editor/hooks', withBlockEditHooks); 18145 } 18146 function BlockProps({ 18147 index, 18148 useBlockProps, 18149 setAllWrapperProps, 18150 ...props 18151 }) { 18152 const wrapperProps = useBlockProps(props); 18153 const setWrapperProps = next => setAllWrapperProps(prev => { 18154 const nextAll = [...prev]; 18155 nextAll[index] = next; 18156 return nextAll; 18157 }); 18158 // Setting state after every render is fine because this component is 18159 // pure and will only re-render when needed props change. 18160 (0,external_wp_element_namespaceObject.useEffect)(() => { 18161 // We could shallow compare the props, but since this component only 18162 // changes when needed attributes change, the benefit is probably small. 18163 setWrapperProps(wrapperProps); 18164 return () => { 18165 setWrapperProps(undefined); 18166 }; 18167 }); 18168 return null; 18169 } 18170 const BlockPropsPure = (0,external_wp_element_namespaceObject.memo)(BlockProps); 18171 function createBlockListBlockFilter(features) { 18172 const withBlockListBlockHooks = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockListBlock => props => { 18173 const [allWrapperProps, setAllWrapperProps] = (0,external_wp_element_namespaceObject.useState)(Array(features.length).fill(undefined)); 18174 return [...features.map((feature, i) => { 18175 const { 18176 hasSupport, 18177 attributeKeys = [], 18178 useBlockProps, 18179 isMatch 18180 } = feature; 18181 const neededProps = {}; 18182 for (const key of attributeKeys) { 18183 if (props.attributes[key]) { 18184 neededProps[key] = props.attributes[key]; 18185 } 18186 } 18187 if ( 18188 // Skip rendering if none of the needed attributes are 18189 // set. 18190 !Object.keys(neededProps).length || !hasSupport(props.name) || isMatch && !isMatch(neededProps)) { 18191 return null; 18192 } 18193 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockPropsPure 18194 // We can use the index because the array length 18195 // is fixed per page load right now. 18196 , { 18197 index: i, 18198 useBlockProps: useBlockProps 18199 // This component is pure, so we must pass a stable 18200 // function reference. 18201 , 18202 setAllWrapperProps: setAllWrapperProps, 18203 name: props.name, 18204 clientId: props.clientId 18205 // This component is pure, so only pass needed 18206 // props!!! 18207 , 18208 ...neededProps 18209 }, i); 18210 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListBlock, { 18211 ...props, 18212 wrapperProps: allWrapperProps.filter(Boolean).reduce((acc, wrapperProps) => { 18213 return { 18214 ...acc, 18215 ...wrapperProps, 18216 className: dist_clsx(acc.className, wrapperProps.className), 18217 style: { 18218 ...acc.style, 18219 ...wrapperProps.style 18220 } 18221 }; 18222 }, props.wrapperProps || {}) 18223 }, "edit")]; 18224 }, 'withBlockListBlockHooks'); 18225 (0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockListBlock', 'core/editor/hooks', withBlockListBlockHooks); 18226 } 18227 function createBlockSaveFilter(features) { 18228 function extraPropsFromHooks(props, name, attributes) { 18229 return features.reduce((accu, feature) => { 18230 const { 18231 hasSupport, 18232 attributeKeys = [], 18233 addSaveProps 18234 } = feature; 18235 const neededAttributes = {}; 18236 for (const key of attributeKeys) { 18237 if (attributes[key]) { 18238 neededAttributes[key] = attributes[key]; 18239 } 18240 } 18241 if ( 18242 // Skip rendering if none of the needed attributes are 18243 // set. 18244 !Object.keys(neededAttributes).length || !hasSupport(name)) { 18245 return accu; 18246 } 18247 return addSaveProps(accu, name, neededAttributes); 18248 }, props); 18249 } 18250 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.getSaveContent.extraProps', 'core/editor/hooks', extraPropsFromHooks, 0); 18251 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.getSaveContent.extraProps', 'core/editor/hooks', props => { 18252 // Previously we had a filter deleting the className if it was an empty 18253 // string. That filter is no longer running, so now we need to delete it 18254 // here. 18255 if (props.hasOwnProperty('className') && !props.className) { 18256 delete props.className; 18257 } 18258 return props; 18259 }); 18260 } 18261 18262 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/compat.js 18263 /** 18264 * WordPress dependencies 18265 */ 18266 18267 18268 function migrateLightBlockWrapper(settings) { 18269 const { 18270 apiVersion = 1 18271 } = settings; 18272 if (apiVersion < 2 && (0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'lightBlockWrapper', false)) { 18273 settings.apiVersion = 2; 18274 } 18275 return settings; 18276 } 18277 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/compat/migrateLightBlockWrapper', migrateLightBlockWrapper); 18278 18279 ;// external ["wp","components"] 18280 const external_wp_components_namespaceObject = window["wp"]["components"]; 18281 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/groups.js 18282 /** 18283 * WordPress dependencies 18284 */ 18285 18286 const BlockControlsDefault = (0,external_wp_components_namespaceObject.createSlotFill)('BlockControls'); 18287 const BlockControlsBlock = (0,external_wp_components_namespaceObject.createSlotFill)('BlockControlsBlock'); 18288 const BlockControlsInline = (0,external_wp_components_namespaceObject.createSlotFill)('BlockFormatControls'); 18289 const BlockControlsOther = (0,external_wp_components_namespaceObject.createSlotFill)('BlockControlsOther'); 18290 const BlockControlsParent = (0,external_wp_components_namespaceObject.createSlotFill)('BlockControlsParent'); 18291 const groups = { 18292 default: BlockControlsDefault, 18293 block: BlockControlsBlock, 18294 inline: BlockControlsInline, 18295 other: BlockControlsOther, 18296 parent: BlockControlsParent 18297 }; 18298 /* harmony default export */ const block_controls_groups = (groups); 18299 18300 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/hook.js 18301 /** 18302 * WordPress dependencies 18303 */ 18304 18305 /** 18306 * Internal dependencies 18307 */ 18308 18309 18310 function useBlockControlsFill(group, shareWithChildBlocks) { 18311 const context = useBlockEditContext(); 18312 if (context[mayDisplayControlsKey]) { 18313 return block_controls_groups[group]?.Fill; 18314 } 18315 if (context[mayDisplayParentControlsKey] && shareWithChildBlocks) { 18316 return block_controls_groups.parent.Fill; 18317 } 18318 return null; 18319 } 18320 18321 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/fill.js 18322 /** 18323 * WordPress dependencies 18324 */ 18325 18326 18327 /** 18328 * Internal dependencies 18329 */ 18330 18331 18332 18333 18334 function BlockControlsFill({ 18335 group = 'default', 18336 controls, 18337 children, 18338 __experimentalShareWithChildBlocks = false 18339 }) { 18340 const Fill = useBlockControlsFill(group, __experimentalShareWithChildBlocks); 18341 if (!Fill) { 18342 return null; 18343 } 18344 const innerMarkup = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 18345 children: [group === 'default' && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, { 18346 controls: controls 18347 }), children] 18348 }); 18349 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalStyleProvider, { 18350 document: document, 18351 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Fill, { 18352 children: fillProps => { 18353 // `fillProps.forwardedContext` is an array of context provider entries, provided by slot, 18354 // that should wrap the fill markup. 18355 const { 18356 forwardedContext = [] 18357 } = fillProps; 18358 return forwardedContext.reduce((inner, [Provider, props]) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Provider, { 18359 ...props, 18360 children: inner 18361 }), innerMarkup); 18362 } 18363 }) 18364 }); 18365 } 18366 18367 ;// external ["wp","warning"] 18368 const external_wp_warning_namespaceObject = window["wp"]["warning"]; 18369 var external_wp_warning_default = /*#__PURE__*/__webpack_require__.n(external_wp_warning_namespaceObject); 18370 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/slot.js 18371 /** 18372 * WordPress dependencies 18373 */ 18374 18375 18376 18377 18378 /** 18379 * Internal dependencies 18380 */ 18381 18382 18383 18384 const { 18385 ComponentsContext 18386 } = unlock(external_wp_components_namespaceObject.privateApis); 18387 function BlockControlsSlot({ 18388 group = 'default', 18389 ...props 18390 }) { 18391 const toolbarState = (0,external_wp_element_namespaceObject.useContext)(external_wp_components_namespaceObject.__experimentalToolbarContext); 18392 const contextState = (0,external_wp_element_namespaceObject.useContext)(ComponentsContext); 18393 const fillProps = (0,external_wp_element_namespaceObject.useMemo)(() => ({ 18394 forwardedContext: [[external_wp_components_namespaceObject.__experimentalToolbarContext.Provider, { 18395 value: toolbarState 18396 }], [ComponentsContext.Provider, { 18397 value: contextState 18398 }]] 18399 }), [toolbarState, contextState]); 18400 const Slot = block_controls_groups[group]?.Slot; 18401 const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(Slot?.__unstableName); 18402 if (!Slot) { 18403 true ? external_wp_warning_default()(`Unknown BlockControls group "$group}" provided.`) : 0; 18404 return null; 18405 } 18406 if (!fills?.length) { 18407 return null; 18408 } 18409 const slot = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Slot, { 18410 ...props, 18411 bubblesVirtually: true, 18412 fillProps: fillProps 18413 }); 18414 if (group === 'default') { 18415 return slot; 18416 } 18417 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, { 18418 children: slot 18419 }); 18420 } 18421 18422 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/index.js 18423 /** 18424 * Internal dependencies 18425 */ 18426 18427 18428 18429 const BlockControls = BlockControlsFill; 18430 BlockControls.Slot = BlockControlsSlot; 18431 18432 // This is just here for backward compatibility. 18433 const BlockFormatControls = props => { 18434 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockControlsFill, { 18435 group: "inline", 18436 ...props 18437 }); 18438 }; 18439 BlockFormatControls.Slot = props => { 18440 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockControlsSlot, { 18441 group: "inline", 18442 ...props 18443 }); 18444 }; 18445 /* harmony default export */ const block_controls = (BlockControls); 18446 18447 ;// ./node_modules/@wordpress/icons/build-module/library/justify-left.js 18448 /** 18449 * WordPress dependencies 18450 */ 18451 18452 18453 const justifyLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 18454 xmlns: "http://www.w3.org/2000/svg", 18455 viewBox: "0 0 24 24", 18456 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18457 d: "M9 9v6h11V9H9zM4 20h1.5V4H4v16z" 18458 }) 18459 }); 18460 /* harmony default export */ const justify_left = (justifyLeft); 18461 18462 ;// ./node_modules/@wordpress/icons/build-module/library/justify-center.js 18463 /** 18464 * WordPress dependencies 18465 */ 18466 18467 18468 const justifyCenter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 18469 xmlns: "http://www.w3.org/2000/svg", 18470 viewBox: "0 0 24 24", 18471 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18472 d: "M12.5 15v5H11v-5H4V9h7V4h1.5v5h7v6h-7Z" 18473 }) 18474 }); 18475 /* harmony default export */ const justify_center = (justifyCenter); 18476 18477 ;// ./node_modules/@wordpress/icons/build-module/library/justify-right.js 18478 /** 18479 * WordPress dependencies 18480 */ 18481 18482 18483 const justifyRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 18484 xmlns: "http://www.w3.org/2000/svg", 18485 viewBox: "0 0 24 24", 18486 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18487 d: "M4 15h11V9H4v6zM18.5 4v16H20V4h-1.5z" 18488 }) 18489 }); 18490 /* harmony default export */ const justify_right = (justifyRight); 18491 18492 ;// ./node_modules/@wordpress/icons/build-module/library/justify-space-between.js 18493 /** 18494 * WordPress dependencies 18495 */ 18496 18497 18498 const justifySpaceBetween = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 18499 xmlns: "http://www.w3.org/2000/svg", 18500 viewBox: "0 0 24 24", 18501 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18502 d: "M9 15h6V9H9v6zm-5 5h1.5V4H4v16zM18.5 4v16H20V4h-1.5z" 18503 }) 18504 }); 18505 /* harmony default export */ const justify_space_between = (justifySpaceBetween); 18506 18507 ;// ./node_modules/@wordpress/icons/build-module/library/justify-stretch.js 18508 /** 18509 * WordPress dependencies 18510 */ 18511 18512 18513 const justifyStretch = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 18514 xmlns: "http://www.w3.org/2000/svg", 18515 viewBox: "0 0 24 24", 18516 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18517 d: "M4 4H5.5V20H4V4ZM7 10L17 10V14L7 14V10ZM20 4H18.5V20H20V4Z" 18518 }) 18519 }); 18520 /* harmony default export */ const justify_stretch = (justifyStretch); 18521 18522 ;// ./node_modules/@wordpress/icons/build-module/library/arrow-right.js 18523 /** 18524 * WordPress dependencies 18525 */ 18526 18527 18528 const arrowRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 18529 xmlns: "http://www.w3.org/2000/svg", 18530 viewBox: "0 0 24 24", 18531 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18532 d: "m14.5 6.5-1 1 3.7 3.7H4v1.6h13.2l-3.7 3.7 1 1 5.6-5.5z" 18533 }) 18534 }); 18535 /* harmony default export */ const arrow_right = (arrowRight); 18536 18537 ;// ./node_modules/@wordpress/icons/build-module/library/arrow-down.js 18538 /** 18539 * WordPress dependencies 18540 */ 18541 18542 18543 const arrowDown = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 18544 xmlns: "http://www.w3.org/2000/svg", 18545 viewBox: "0 0 24 24", 18546 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18547 d: "m16.5 13.5-3.7 3.7V4h-1.5v13.2l-3.8-3.7-1 1 5.5 5.6 5.5-5.6z" 18548 }) 18549 }); 18550 /* harmony default export */ const arrow_down = (arrowDown); 18551 18552 ;// ./node_modules/@wordpress/block-editor/build-module/layouts/definitions.js 18553 // Layout definitions keyed by layout type. 18554 // Provides a common definition of slugs, classnames, base styles, and spacing styles for each layout type. 18555 // If making changes or additions to layout definitions, be sure to update the corresponding PHP definitions in 18556 // `block-supports/layout.php` so that the server-side and client-side definitions match. 18557 const LAYOUT_DEFINITIONS = { 18558 default: { 18559 name: 'default', 18560 slug: 'flow', 18561 className: 'is-layout-flow', 18562 baseStyles: [{ 18563 selector: ' > .alignleft', 18564 rules: { 18565 float: 'left', 18566 'margin-inline-start': '0', 18567 'margin-inline-end': '2em' 18568 } 18569 }, { 18570 selector: ' > .alignright', 18571 rules: { 18572 float: 'right', 18573 'margin-inline-start': '2em', 18574 'margin-inline-end': '0' 18575 } 18576 }, { 18577 selector: ' > .aligncenter', 18578 rules: { 18579 'margin-left': 'auto !important', 18580 'margin-right': 'auto !important' 18581 } 18582 }], 18583 spacingStyles: [{ 18584 selector: ' > :first-child', 18585 rules: { 18586 'margin-block-start': '0' 18587 } 18588 }, { 18589 selector: ' > :last-child', 18590 rules: { 18591 'margin-block-end': '0' 18592 } 18593 }, { 18594 selector: ' > *', 18595 rules: { 18596 'margin-block-start': null, 18597 'margin-block-end': '0' 18598 } 18599 }] 18600 }, 18601 constrained: { 18602 name: 'constrained', 18603 slug: 'constrained', 18604 className: 'is-layout-constrained', 18605 baseStyles: [{ 18606 selector: ' > .alignleft', 18607 rules: { 18608 float: 'left', 18609 'margin-inline-start': '0', 18610 'margin-inline-end': '2em' 18611 } 18612 }, { 18613 selector: ' > .alignright', 18614 rules: { 18615 float: 'right', 18616 'margin-inline-start': '2em', 18617 'margin-inline-end': '0' 18618 } 18619 }, { 18620 selector: ' > .aligncenter', 18621 rules: { 18622 'margin-left': 'auto !important', 18623 'margin-right': 'auto !important' 18624 } 18625 }, { 18626 selector: ' > :where(:not(.alignleft):not(.alignright):not(.alignfull))', 18627 rules: { 18628 'max-width': 'var(--wp--style--global--content-size)', 18629 'margin-left': 'auto !important', 18630 'margin-right': 'auto !important' 18631 } 18632 }, { 18633 selector: ' > .alignwide', 18634 rules: { 18635 'max-width': 'var(--wp--style--global--wide-size)' 18636 } 18637 }], 18638 spacingStyles: [{ 18639 selector: ' > :first-child', 18640 rules: { 18641 'margin-block-start': '0' 18642 } 18643 }, { 18644 selector: ' > :last-child', 18645 rules: { 18646 'margin-block-end': '0' 18647 } 18648 }, { 18649 selector: ' > *', 18650 rules: { 18651 'margin-block-start': null, 18652 'margin-block-end': '0' 18653 } 18654 }] 18655 }, 18656 flex: { 18657 name: 'flex', 18658 slug: 'flex', 18659 className: 'is-layout-flex', 18660 displayMode: 'flex', 18661 baseStyles: [{ 18662 selector: '', 18663 rules: { 18664 'flex-wrap': 'wrap', 18665 'align-items': 'center' 18666 } 18667 }, { 18668 selector: ' > :is(*, div)', 18669 // :is(*, div) instead of just * increases the specificity by 001. 18670 rules: { 18671 margin: '0' 18672 } 18673 }], 18674 spacingStyles: [{ 18675 selector: '', 18676 rules: { 18677 gap: null 18678 } 18679 }] 18680 }, 18681 grid: { 18682 name: 'grid', 18683 slug: 'grid', 18684 className: 'is-layout-grid', 18685 displayMode: 'grid', 18686 baseStyles: [{ 18687 selector: ' > :is(*, div)', 18688 // :is(*, div) instead of just * increases the specificity by 001. 18689 rules: { 18690 margin: '0' 18691 } 18692 }], 18693 spacingStyles: [{ 18694 selector: '', 18695 rules: { 18696 gap: null 18697 } 18698 }] 18699 } 18700 }; 18701 18702 ;// ./node_modules/@wordpress/block-editor/build-module/layouts/utils.js 18703 /** 18704 * WordPress dependencies 18705 */ 18706 18707 18708 /** 18709 * Internal dependencies 18710 */ 18711 18712 18713 /** 18714 * Utility to generate the proper CSS selector for layout styles. 18715 * 18716 * @param {string} selectors CSS selector, also supports multiple comma-separated selectors. 18717 * @param {string} append The string to append. 18718 * 18719 * @return {string} - CSS selector. 18720 */ 18721 function appendSelectors(selectors, append = '') { 18722 return selectors.split(',').map(subselector => `$subselector}$append ? ` $append}` : ''}`).join(','); 18723 } 18724 18725 /** 18726 * Get generated blockGap CSS rules based on layout definitions provided in theme.json 18727 * Falsy values in the layout definition's spacingStyles rules will be swapped out 18728 * with the provided `blockGapValue`. 18729 * 18730 * @param {string} selector The CSS selector to target for the generated rules. 18731 * @param {Object} layoutDefinitions Layout definitions object. 18732 * @param {string} layoutType The layout type (e.g. `default` or `flex`). 18733 * @param {string} blockGapValue The current blockGap value to be applied. 18734 * @return {string} The generated CSS rules. 18735 */ 18736 function getBlockGapCSS(selector, layoutDefinitions = LAYOUT_DEFINITIONS, layoutType, blockGapValue) { 18737 let output = ''; 18738 if (layoutDefinitions?.[layoutType]?.spacingStyles?.length && blockGapValue) { 18739 layoutDefinitions[layoutType].spacingStyles.forEach(gapStyle => { 18740 output += `$appendSelectors(selector, gapStyle.selector.trim())} { `; 18741 output += Object.entries(gapStyle.rules).map(([cssProperty, value]) => `$cssProperty}: $value ? value : blockGapValue}`).join('; '); 18742 output += '; }'; 18743 }); 18744 } 18745 return output; 18746 } 18747 18748 /** 18749 * Helper method to assign contextual info to clarify 18750 * alignment settings. 18751 * 18752 * Besides checking if `contentSize` and `wideSize` have a 18753 * value, we now show this information only if their values 18754 * are not a `css var`. This needs to change when parsing 18755 * css variables land. 18756 * 18757 * @see https://github.com/WordPress/gutenberg/pull/34710#issuecomment-918000752 18758 * 18759 * @param {Object} layout The layout object. 18760 * @return {Object} An object with contextual info per alignment. 18761 */ 18762 function getAlignmentsInfo(layout) { 18763 const { 18764 contentSize, 18765 wideSize, 18766 type = 'default' 18767 } = layout; 18768 const alignmentInfo = {}; 18769 const sizeRegex = /^(?!0)\d+(px|em|rem|vw|vh|%|svw|lvw|dvw|svh|lvh|dvh|vi|svi|lvi|dvi|vb|svb|lvb|dvb|vmin|svmin|lvmin|dvmin|vmax|svmax|lvmax|dvmax)?$/i; 18770 if (sizeRegex.test(contentSize) && type === 'constrained') { 18771 // translators: %s: container size (i.e. 600px etc) 18772 alignmentInfo.none = (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)('Max %s wide'), contentSize); 18773 } 18774 if (sizeRegex.test(wideSize)) { 18775 // translators: %s: container size (i.e. 600px etc) 18776 alignmentInfo.wide = (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)('Max %s wide'), wideSize); 18777 } 18778 return alignmentInfo; 18779 } 18780 18781 ;// ./node_modules/@wordpress/icons/build-module/library/sides-all.js 18782 /** 18783 * WordPress dependencies 18784 */ 18785 18786 18787 const sidesAll = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 18788 xmlns: "http://www.w3.org/2000/svg", 18789 viewBox: "0 0 24 24", 18790 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18791 d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z" 18792 }) 18793 }); 18794 /* harmony default export */ const sides_all = (sidesAll); 18795 18796 ;// ./node_modules/@wordpress/icons/build-module/library/sides-horizontal.js 18797 /** 18798 * WordPress dependencies 18799 */ 18800 18801 18802 18803 const sidesHorizontal = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, { 18804 xmlns: "http://www.w3.org/2000/svg", 18805 viewBox: "0 0 24 24", 18806 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18807 d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z", 18808 style: { 18809 opacity: 0.25 18810 } 18811 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18812 d: "m4.5 7.5v9h1.5v-9z" 18813 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18814 d: "m18 7.5v9h1.5v-9z" 18815 })] 18816 }); 18817 /* harmony default export */ const sides_horizontal = (sidesHorizontal); 18818 18819 ;// ./node_modules/@wordpress/icons/build-module/library/sides-vertical.js 18820 /** 18821 * WordPress dependencies 18822 */ 18823 18824 18825 18826 const sidesVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, { 18827 xmlns: "http://www.w3.org/2000/svg", 18828 viewBox: "0 0 24 24", 18829 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18830 d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z", 18831 style: { 18832 opacity: 0.25 18833 } 18834 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18835 d: "m7.5 6h9v-1.5h-9z" 18836 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18837 d: "m7.5 19.5h9v-1.5h-9z" 18838 })] 18839 }); 18840 /* harmony default export */ const sides_vertical = (sidesVertical); 18841 18842 ;// ./node_modules/@wordpress/icons/build-module/library/sides-top.js 18843 /** 18844 * WordPress dependencies 18845 */ 18846 18847 18848 18849 const sidesTop = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, { 18850 xmlns: "http://www.w3.org/2000/svg", 18851 viewBox: "0 0 24 24", 18852 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18853 d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z", 18854 style: { 18855 opacity: 0.25 18856 } 18857 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18858 d: "m16.5 6h-9v-1.5h9z" 18859 })] 18860 }); 18861 /* harmony default export */ const sides_top = (sidesTop); 18862 18863 ;// ./node_modules/@wordpress/icons/build-module/library/sides-right.js 18864 /** 18865 * WordPress dependencies 18866 */ 18867 18868 18869 18870 const sidesRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, { 18871 xmlns: "http://www.w3.org/2000/svg", 18872 viewBox: "0 0 24 24", 18873 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18874 d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z", 18875 style: { 18876 opacity: 0.25 18877 } 18878 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18879 d: "m18 16.5v-9h1.5v9z" 18880 })] 18881 }); 18882 /* harmony default export */ const sides_right = (sidesRight); 18883 18884 ;// ./node_modules/@wordpress/icons/build-module/library/sides-bottom.js 18885 /** 18886 * WordPress dependencies 18887 */ 18888 18889 18890 18891 const sidesBottom = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, { 18892 xmlns: "http://www.w3.org/2000/svg", 18893 viewBox: "0 0 24 24", 18894 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18895 d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z", 18896 style: { 18897 opacity: 0.25 18898 } 18899 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18900 d: "m16.5 19.5h-9v-1.5h9z" 18901 })] 18902 }); 18903 /* harmony default export */ const sides_bottom = (sidesBottom); 18904 18905 ;// ./node_modules/@wordpress/icons/build-module/library/sides-left.js 18906 /** 18907 * WordPress dependencies 18908 */ 18909 18910 18911 18912 const sidesLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, { 18913 xmlns: "http://www.w3.org/2000/svg", 18914 viewBox: "0 0 24 24", 18915 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18916 d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z", 18917 style: { 18918 opacity: 0.25 18919 } 18920 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 18921 d: "m4.5 16.5v-9h1.5v9z" 18922 })] 18923 }); 18924 /* harmony default export */ const sides_left = (sidesLeft); 18925 18926 ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/utils.js 18927 /** 18928 * WordPress dependencies 18929 */ 18930 18931 18932 const RANGE_CONTROL_MAX_SIZE = 8; 18933 const ALL_SIDES = ['top', 'right', 'bottom', 'left']; 18934 const DEFAULT_VALUES = { 18935 top: undefined, 18936 right: undefined, 18937 bottom: undefined, 18938 left: undefined 18939 }; 18940 const ICONS = { 18941 custom: sides_all, 18942 axial: sides_all, 18943 horizontal: sides_horizontal, 18944 vertical: sides_vertical, 18945 top: sides_top, 18946 right: sides_right, 18947 bottom: sides_bottom, 18948 left: sides_left 18949 }; 18950 const LABELS = { 18951 default: (0,external_wp_i18n_namespaceObject.__)('Spacing control'), 18952 top: (0,external_wp_i18n_namespaceObject.__)('Top'), 18953 bottom: (0,external_wp_i18n_namespaceObject.__)('Bottom'), 18954 left: (0,external_wp_i18n_namespaceObject.__)('Left'), 18955 right: (0,external_wp_i18n_namespaceObject.__)('Right'), 18956 mixed: (0,external_wp_i18n_namespaceObject.__)('Mixed'), 18957 vertical: (0,external_wp_i18n_namespaceObject.__)('Vertical'), 18958 horizontal: (0,external_wp_i18n_namespaceObject.__)('Horizontal'), 18959 axial: (0,external_wp_i18n_namespaceObject.__)('Horizontal & vertical'), 18960 custom: (0,external_wp_i18n_namespaceObject.__)('Custom') 18961 }; 18962 const VIEWS = { 18963 axial: 'axial', 18964 top: 'top', 18965 right: 'right', 18966 bottom: 'bottom', 18967 left: 'left', 18968 custom: 'custom' 18969 }; 18970 18971 /** 18972 * Checks is given value is a spacing preset. 18973 * 18974 * @param {string} value Value to check 18975 * 18976 * @return {boolean} Return true if value is string in format var:preset|spacing|. 18977 */ 18978 function isValueSpacingPreset(value) { 18979 if (!value?.includes) { 18980 return false; 18981 } 18982 return value === '0' || value.includes('var:preset|spacing|'); 18983 } 18984 18985 /** 18986 * Converts a spacing preset into a custom value. 18987 * 18988 * @param {string} value Value to convert 18989 * @param {Array} spacingSizes Array of the current spacing preset objects 18990 * 18991 * @return {string} Mapping of the spacing preset to its equivalent custom value. 18992 */ 18993 function getCustomValueFromPreset(value, spacingSizes) { 18994 if (!isValueSpacingPreset(value)) { 18995 return value; 18996 } 18997 const slug = getSpacingPresetSlug(value); 18998 const spacingSize = spacingSizes.find(size => String(size.slug) === slug); 18999 return spacingSize?.size; 19000 } 19001 19002 /** 19003 * Converts a custom value to preset value if one can be found. 19004 * 19005 * Returns value as-is if no match is found. 19006 * 19007 * @param {string} value Value to convert 19008 * @param {Array} spacingSizes Array of the current spacing preset objects 19009 * 19010 * @return {string} The preset value if it can be found. 19011 */ 19012 function getPresetValueFromCustomValue(value, spacingSizes) { 19013 // Return value as-is if it is undefined or is already a preset, or '0'; 19014 if (!value || isValueSpacingPreset(value) || value === '0') { 19015 return value; 19016 } 19017 const spacingMatch = spacingSizes.find(size => String(size.size) === String(value)); 19018 if (spacingMatch?.slug) { 19019 return `var:preset|spacing|$spacingMatch.slug}`; 19020 } 19021 return value; 19022 } 19023 19024 /** 19025 * Converts a spacing preset into a custom value. 19026 * 19027 * @param {string} value Value to convert. 19028 * 19029 * @return {string | undefined} CSS var string for given spacing preset value. 19030 */ 19031 function getSpacingPresetCssVar(value) { 19032 if (!value) { 19033 return; 19034 } 19035 const slug = value.match(/var:preset\|spacing\|(.+)/); 19036 if (!slug) { 19037 return value; 19038 } 19039 return `var(--wp--preset--spacing--$slug[1]})`; 19040 } 19041 19042 /** 19043 * Returns the slug section of the given spacing preset string. 19044 * 19045 * @param {string} value Value to extract slug from. 19046 * 19047 * @return {string|undefined} The int value of the slug from given spacing preset. 19048 */ 19049 function getSpacingPresetSlug(value) { 19050 if (!value) { 19051 return; 19052 } 19053 if (value === '0' || value === 'default') { 19054 return value; 19055 } 19056 const slug = value.match(/var:preset\|spacing\|(.+)/); 19057 return slug ? slug[1] : undefined; 19058 } 19059 19060 /** 19061 * Converts spacing preset value into a Range component value . 19062 * 19063 * @param {string} presetValue Value to convert to Range value. 19064 * @param {Array} spacingSizes Array of current spacing preset value objects. 19065 * 19066 * @return {number} The int value for use in Range control. 19067 */ 19068 function getSliderValueFromPreset(presetValue, spacingSizes) { 19069 if (presetValue === undefined) { 19070 return 0; 19071 } 19072 const slug = parseFloat(presetValue, 10) === 0 ? '0' : getSpacingPresetSlug(presetValue); 19073 const sliderValue = spacingSizes.findIndex(spacingSize => { 19074 return String(spacingSize.slug) === slug; 19075 }); 19076 19077 // Returning NaN rather than undefined as undefined makes range control thumb sit in center 19078 return sliderValue !== -1 ? sliderValue : NaN; 19079 } 19080 19081 /** 19082 * Gets an items with the most occurrence within an array 19083 * https://stackoverflow.com/a/20762713 19084 * 19085 * @param {Array<any>} arr Array of items to check. 19086 * @return {any} The item with the most occurrences. 19087 */ 19088 function mode(arr) { 19089 return arr.sort((a, b) => arr.filter(v => v === a).length - arr.filter(v => v === b).length).pop(); 19090 } 19091 19092 /** 19093 * Gets the 'all' input value from values data. 19094 * 19095 * @param {Object} values Box spacing values 19096 * 19097 * @return {string} The most common value from all sides of box. 19098 */ 19099 function getAllRawValue(values = {}) { 19100 return mode(Object.values(values)); 19101 } 19102 19103 /** 19104 * Checks to determine if values are mixed. 19105 * 19106 * @param {Object} values Box values. 19107 * @param {Array} sides Sides that values relate to. 19108 * 19109 * @return {boolean} Whether values are mixed. 19110 */ 19111 function isValuesMixed(values = {}, sides = ALL_SIDES) { 19112 return Object.values(values).length >= 1 && Object.values(values).length < sides.length || new Set(Object.values(values)).size > 1; 19113 } 19114 19115 /** 19116 * Checks to determine if values are defined. 19117 * 19118 * @param {Object} values Box values. 19119 * 19120 * @return {boolean} Whether values are defined. 19121 */ 19122 function isValuesDefined(values) { 19123 if (values === undefined || values === null) { 19124 return false; 19125 } 19126 return Object.values(values).filter(value => !!value).length > 0; 19127 } 19128 19129 /** 19130 * Determines whether a particular axis has support. If no axis is 19131 * specified, this function checks if either axis is supported. 19132 * 19133 * @param {Array} sides Supported sides. 19134 * @param {string} axis Which axis to check. 19135 * 19136 * @return {boolean} Whether there is support for the specified axis or both axes. 19137 */ 19138 function hasAxisSupport(sides, axis) { 19139 if (!sides || !sides.length) { 19140 return false; 19141 } 19142 const hasHorizontalSupport = sides.includes('horizontal') || sides.includes('left') && sides.includes('right'); 19143 const hasVerticalSupport = sides.includes('vertical') || sides.includes('top') && sides.includes('bottom'); 19144 if (axis === 'horizontal') { 19145 return hasHorizontalSupport; 19146 } 19147 if (axis === 'vertical') { 19148 return hasVerticalSupport; 19149 } 19150 return hasHorizontalSupport || hasVerticalSupport; 19151 } 19152 19153 /** 19154 * Determines which menu options should be included in the SidePicker. 19155 * 19156 * @param {Array} sides Supported sides. 19157 * 19158 * @return {Object} Menu options with each option containing label & icon. 19159 */ 19160 function getSupportedMenuItems(sides) { 19161 if (!sides || !sides.length) { 19162 return {}; 19163 } 19164 const menuItems = {}; 19165 19166 // Determine the primary "side" menu options. 19167 const hasHorizontalSupport = hasAxisSupport(sides, 'horizontal'); 19168 const hasVerticalSupport = hasAxisSupport(sides, 'vertical'); 19169 if (hasHorizontalSupport && hasVerticalSupport) { 19170 menuItems.axial = { 19171 label: LABELS.axial, 19172 icon: ICONS.axial 19173 }; 19174 } else if (hasHorizontalSupport) { 19175 menuItems.axial = { 19176 label: LABELS.horizontal, 19177 icon: ICONS.horizontal 19178 }; 19179 } else if (hasVerticalSupport) { 19180 menuItems.axial = { 19181 label: LABELS.vertical, 19182 icon: ICONS.vertical 19183 }; 19184 } 19185 19186 // Track whether we have any individual sides so we can omit the custom 19187 // option if required. 19188 let numberOfIndividualSides = 0; 19189 ALL_SIDES.forEach(side => { 19190 if (sides.includes(side)) { 19191 numberOfIndividualSides += 1; 19192 menuItems[side] = { 19193 label: LABELS[side], 19194 icon: ICONS[side] 19195 }; 19196 } 19197 }); 19198 19199 // Add custom item if there are enough sides to warrant a separated view. 19200 if (numberOfIndividualSides > 1) { 19201 menuItems.custom = { 19202 label: LABELS.custom, 19203 icon: ICONS.custom 19204 }; 19205 } 19206 return menuItems; 19207 } 19208 19209 /** 19210 * Checks if the supported sides are balanced for each axis. 19211 * - Horizontal - both left and right sides are supported. 19212 * - Vertical - both top and bottom are supported. 19213 * 19214 * @param {Array} sides The supported sides which may be axes as well. 19215 * 19216 * @return {boolean} Whether or not the supported sides are balanced. 19217 */ 19218 function hasBalancedSidesSupport(sides = []) { 19219 const counts = { 19220 top: 0, 19221 right: 0, 19222 bottom: 0, 19223 left: 0 19224 }; 19225 sides.forEach(side => counts[side] += 1); 19226 return (counts.top + counts.bottom) % 2 === 0 && (counts.left + counts.right) % 2 === 0; 19227 } 19228 19229 /** 19230 * Determines which view the SpacingSizesControl should default to on its 19231 * first render; Axial, Custom, or Single side. 19232 * 19233 * @param {Object} values Current side values. 19234 * @param {Array} sides Supported sides. 19235 * 19236 * @return {string} View to display. 19237 */ 19238 function getInitialView(values = {}, sides) { 19239 const { 19240 top, 19241 right, 19242 bottom, 19243 left 19244 } = values; 19245 const sideValues = [top, right, bottom, left].filter(Boolean); 19246 19247 // Axial ( Horizontal & vertical ). 19248 // - Has axial side support 19249 // - Has axial side values which match 19250 // - Has no values and the supported sides are balanced 19251 const hasMatchingAxialValues = top === bottom && left === right && (!!top || !!left); 19252 const hasNoValuesAndBalancedSides = !sideValues.length && hasBalancedSidesSupport(sides); 19253 const hasOnlyAxialSides = sides?.includes('horizontal') && sides?.includes('vertical') && sides?.length === 2; 19254 if (hasAxisSupport(sides) && (hasMatchingAxialValues || hasNoValuesAndBalancedSides)) { 19255 return VIEWS.axial; 19256 } 19257 19258 // Only axial sides are supported and single value defined. 19259 // - Ensure the side returned is the first side that has a value. 19260 if (hasOnlyAxialSides && sideValues.length === 1) { 19261 let side; 19262 Object.entries(values).some(([key, value]) => { 19263 side = key; 19264 return value !== undefined; 19265 }); 19266 return side; 19267 } 19268 19269 // Only single side supported and no value defined. 19270 if (sides?.length === 1 && !sideValues.length) { 19271 return sides[0]; 19272 } 19273 19274 // Default to the Custom (separated sides) view. 19275 return VIEWS.custom; 19276 } 19277 19278 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/gap.js 19279 /** 19280 * Internal dependencies 19281 */ 19282 19283 19284 /** 19285 * Returns a BoxControl object value from a given blockGap style value. 19286 * The string check is for backwards compatibility before Gutenberg supported 19287 * split gap values (row and column) and the value was a string n + unit. 19288 * 19289 * @param {string? | Object?} blockGapValue A block gap string or axial object value, e.g., '10px' or { top: '10px', left: '10px'}. 19290 * @return {Object|null} A value to pass to the BoxControl component. 19291 */ 19292 function getGapBoxControlValueFromStyle(blockGapValue) { 19293 if (!blockGapValue) { 19294 return null; 19295 } 19296 const isValueString = typeof blockGapValue === 'string'; 19297 return { 19298 top: isValueString ? blockGapValue : blockGapValue?.top, 19299 left: isValueString ? blockGapValue : blockGapValue?.left 19300 }; 19301 } 19302 19303 /** 19304 * Returns a CSS value for the `gap` property from a given blockGap style. 19305 * 19306 * @param {string? | Object?} blockGapValue A block gap string or axial object value, e.g., '10px' or { top: '10px', left: '10px'}. 19307 * @param {string?} defaultValue A default gap value. 19308 * @return {string|null} The concatenated gap value (row and column). 19309 */ 19310 function getGapCSSValue(blockGapValue, defaultValue = '0') { 19311 const blockGapBoxControlValue = getGapBoxControlValueFromStyle(blockGapValue); 19312 if (!blockGapBoxControlValue) { 19313 return null; 19314 } 19315 const row = getSpacingPresetCssVar(blockGapBoxControlValue?.top) || defaultValue; 19316 const column = getSpacingPresetCssVar(blockGapBoxControlValue?.left) || defaultValue; 19317 return row === column ? row : `$row} $column}`; 19318 } 19319 19320 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-vertical-alignment-control/icons.js 19321 /** 19322 * WordPress dependencies 19323 */ 19324 19325 19326 const alignBottom = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, { 19327 xmlns: "http://www.w3.org/2000/svg", 19328 viewBox: "0 0 24 24", 19329 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, { 19330 d: "M15 4H9v11h6V4zM4 18.5V20h16v-1.5H4z" 19331 }) 19332 }); 19333 const alignCenter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, { 19334 xmlns: "http://www.w3.org/2000/svg", 19335 viewBox: "0 0 24 24", 19336 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, { 19337 d: "M20 11h-5V4H9v7H4v1.5h5V20h6v-7.5h5z" 19338 }) 19339 }); 19340 const alignTop = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, { 19341 xmlns: "http://www.w3.org/2000/svg", 19342 viewBox: "0 0 24 24", 19343 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, { 19344 d: "M9 20h6V9H9v11zM4 4v1.5h16V4H4z" 19345 }) 19346 }); 19347 const alignStretch = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, { 19348 xmlns: "http://www.w3.org/2000/svg", 19349 viewBox: "0 0 24 24", 19350 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, { 19351 d: "M4 4L20 4L20 5.5L4 5.5L4 4ZM10 7L14 7L14 17L10 17L10 7ZM20 18.5L4 18.5L4 20L20 20L20 18.5Z" 19352 }) 19353 }); 19354 const spaceBetween = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, { 19355 xmlns: "http://www.w3.org/2000/svg", 19356 viewBox: "0 0 24 24", 19357 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, { 19358 d: "M7 4H17V8L7 8V4ZM7 16L17 16V20L7 20V16ZM20 11.25H4V12.75H20V11.25Z" 19359 }) 19360 }); 19361 19362 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-vertical-alignment-control/ui.js 19363 /** 19364 * WordPress dependencies 19365 */ 19366 19367 19368 19369 /** 19370 * Internal dependencies 19371 */ 19372 19373 19374 const BLOCK_ALIGNMENTS_CONTROLS = { 19375 top: { 19376 icon: alignTop, 19377 title: (0,external_wp_i18n_namespaceObject._x)('Align top', 'Block vertical alignment setting') 19378 }, 19379 center: { 19380 icon: alignCenter, 19381 title: (0,external_wp_i18n_namespaceObject._x)('Align middle', 'Block vertical alignment setting') 19382 }, 19383 bottom: { 19384 icon: alignBottom, 19385 title: (0,external_wp_i18n_namespaceObject._x)('Align bottom', 'Block vertical alignment setting') 19386 }, 19387 stretch: { 19388 icon: alignStretch, 19389 title: (0,external_wp_i18n_namespaceObject._x)('Stretch to fill', 'Block vertical alignment setting') 19390 }, 19391 'space-between': { 19392 icon: spaceBetween, 19393 title: (0,external_wp_i18n_namespaceObject._x)('Space between', 'Block vertical alignment setting') 19394 } 19395 }; 19396 const DEFAULT_CONTROLS = ['top', 'center', 'bottom']; 19397 const DEFAULT_CONTROL = 'top'; 19398 function BlockVerticalAlignmentUI({ 19399 value, 19400 onChange, 19401 controls = DEFAULT_CONTROLS, 19402 isCollapsed = true, 19403 isToolbar 19404 }) { 19405 function applyOrUnset(align) { 19406 return () => onChange(value === align ? undefined : align); 19407 } 19408 const activeAlignment = BLOCK_ALIGNMENTS_CONTROLS[value]; 19409 const defaultAlignmentControl = BLOCK_ALIGNMENTS_CONTROLS[DEFAULT_CONTROL]; 19410 const UIComponent = isToolbar ? external_wp_components_namespaceObject.ToolbarGroup : external_wp_components_namespaceObject.ToolbarDropdownMenu; 19411 const extraProps = isToolbar ? { 19412 isCollapsed 19413 } : {}; 19414 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UIComponent, { 19415 icon: activeAlignment ? activeAlignment.icon : defaultAlignmentControl.icon, 19416 label: (0,external_wp_i18n_namespaceObject._x)('Change vertical alignment', 'Block vertical alignment setting label'), 19417 controls: controls.map(control => { 19418 return { 19419 ...BLOCK_ALIGNMENTS_CONTROLS[control], 19420 isActive: value === control, 19421 role: isCollapsed ? 'menuitemradio' : undefined, 19422 onClick: applyOrUnset(control) 19423 }; 19424 }), 19425 ...extraProps 19426 }); 19427 } 19428 19429 /** 19430 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-vertical-alignment-toolbar/README.md 19431 */ 19432 /* harmony default export */ const ui = (BlockVerticalAlignmentUI); 19433 19434 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-vertical-alignment-control/index.js 19435 /** 19436 * Internal dependencies 19437 */ 19438 19439 19440 const BlockVerticalAlignmentControl = props => { 19441 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ui, { 19442 ...props, 19443 isToolbar: false 19444 }); 19445 }; 19446 const BlockVerticalAlignmentToolbar = props => { 19447 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ui, { 19448 ...props, 19449 isToolbar: true 19450 }); 19451 }; 19452 19453 /** 19454 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-vertical-alignment-control/README.md 19455 */ 19456 19457 19458 ;// ./node_modules/@wordpress/block-editor/build-module/components/justify-content-control/ui.js 19459 /** 19460 * WordPress dependencies 19461 */ 19462 19463 19464 19465 19466 const icons = { 19467 left: justify_left, 19468 center: justify_center, 19469 right: justify_right, 19470 'space-between': justify_space_between, 19471 stretch: justify_stretch 19472 }; 19473 function JustifyContentUI({ 19474 allowedControls = ['left', 'center', 'right', 'space-between'], 19475 isCollapsed = true, 19476 onChange, 19477 value, 19478 popoverProps, 19479 isToolbar 19480 }) { 19481 // If the control is already selected we want a click 19482 // again on the control to deselect the item, so we 19483 // call onChange( undefined ) 19484 const handleClick = next => { 19485 if (next === value) { 19486 onChange(undefined); 19487 } else { 19488 onChange(next); 19489 } 19490 }; 19491 const icon = value ? icons[value] : icons.left; 19492 const allControls = [{ 19493 name: 'left', 19494 icon: justify_left, 19495 title: (0,external_wp_i18n_namespaceObject.__)('Justify items left'), 19496 isActive: 'left' === value, 19497 onClick: () => handleClick('left') 19498 }, { 19499 name: 'center', 19500 icon: justify_center, 19501 title: (0,external_wp_i18n_namespaceObject.__)('Justify items center'), 19502 isActive: 'center' === value, 19503 onClick: () => handleClick('center') 19504 }, { 19505 name: 'right', 19506 icon: justify_right, 19507 title: (0,external_wp_i18n_namespaceObject.__)('Justify items right'), 19508 isActive: 'right' === value, 19509 onClick: () => handleClick('right') 19510 }, { 19511 name: 'space-between', 19512 icon: justify_space_between, 19513 title: (0,external_wp_i18n_namespaceObject.__)('Space between items'), 19514 isActive: 'space-between' === value, 19515 onClick: () => handleClick('space-between') 19516 }, { 19517 name: 'stretch', 19518 icon: justify_stretch, 19519 title: (0,external_wp_i18n_namespaceObject.__)('Stretch items'), 19520 isActive: 'stretch' === value, 19521 onClick: () => handleClick('stretch') 19522 }]; 19523 const UIComponent = isToolbar ? external_wp_components_namespaceObject.ToolbarGroup : external_wp_components_namespaceObject.ToolbarDropdownMenu; 19524 const extraProps = isToolbar ? { 19525 isCollapsed 19526 } : {}; 19527 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UIComponent, { 19528 icon: icon, 19529 popoverProps: popoverProps, 19530 label: (0,external_wp_i18n_namespaceObject.__)('Change items justification'), 19531 controls: allControls.filter(elem => allowedControls.includes(elem.name)), 19532 ...extraProps 19533 }); 19534 } 19535 /* harmony default export */ const justify_content_control_ui = (JustifyContentUI); 19536 19537 ;// ./node_modules/@wordpress/block-editor/build-module/components/justify-content-control/index.js 19538 /** 19539 * Internal dependencies 19540 */ 19541 19542 19543 const JustifyContentControl = props => { 19544 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(justify_content_control_ui, { 19545 ...props, 19546 isToolbar: false 19547 }); 19548 }; 19549 const JustifyToolbar = props => { 19550 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(justify_content_control_ui, { 19551 ...props, 19552 isToolbar: true 19553 }); 19554 }; 19555 19556 /** 19557 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/justify-content-control/README.md 19558 */ 19559 19560 19561 ;// ./node_modules/@wordpress/block-editor/build-module/layouts/flex.js 19562 /** 19563 * WordPress dependencies 19564 */ 19565 19566 19567 19568 19569 /** 19570 * Internal dependencies 19571 */ 19572 19573 19574 19575 19576 19577 19578 // Used with the default, horizontal flex orientation. 19579 19580 19581 19582 const justifyContentMap = { 19583 left: 'flex-start', 19584 right: 'flex-end', 19585 center: 'center', 19586 'space-between': 'space-between' 19587 }; 19588 19589 // Used with the vertical (column) flex orientation. 19590 const alignItemsMap = { 19591 left: 'flex-start', 19592 right: 'flex-end', 19593 center: 'center', 19594 stretch: 'stretch' 19595 }; 19596 const verticalAlignmentMap = { 19597 top: 'flex-start', 19598 center: 'center', 19599 bottom: 'flex-end', 19600 stretch: 'stretch', 19601 'space-between': 'space-between' 19602 }; 19603 const flexWrapOptions = ['wrap', 'nowrap']; 19604 /* harmony default export */ const flex = ({ 19605 name: 'flex', 19606 label: (0,external_wp_i18n_namespaceObject.__)('Flex'), 19607 inspectorControls: function FlexLayoutInspectorControls({ 19608 layout = {}, 19609 onChange, 19610 layoutBlockSupport = {} 19611 }) { 19612 const { 19613 allowOrientation = true 19614 } = layoutBlockSupport; 19615 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 19616 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, { 19617 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 19618 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexLayoutJustifyContentControl, { 19619 layout: layout, 19620 onChange: onChange 19621 }) 19622 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 19623 children: allowOrientation && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(OrientationControl, { 19624 layout: layout, 19625 onChange: onChange 19626 }) 19627 })] 19628 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexWrapControl, { 19629 layout: layout, 19630 onChange: onChange 19631 })] 19632 }); 19633 }, 19634 toolBarControls: function FlexLayoutToolbarControls({ 19635 layout = {}, 19636 onChange, 19637 layoutBlockSupport 19638 }) { 19639 if (layoutBlockSupport?.allowSwitching) { 19640 return null; 19641 } 19642 const { 19643 allowVerticalAlignment = true 19644 } = layoutBlockSupport; 19645 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(block_controls, { 19646 group: "block", 19647 __experimentalShareWithChildBlocks: true, 19648 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexLayoutJustifyContentControl, { 19649 layout: layout, 19650 onChange: onChange, 19651 isToolbar: true 19652 }), allowVerticalAlignment && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexLayoutVerticalAlignmentControl, { 19653 layout: layout, 19654 onChange: onChange 19655 })] 19656 }); 19657 }, 19658 getLayoutStyle: function getLayoutStyle({ 19659 selector, 19660 layout, 19661 style, 19662 blockName, 19663 hasBlockGapSupport, 19664 layoutDefinitions = LAYOUT_DEFINITIONS 19665 }) { 19666 const { 19667 orientation = 'horizontal' 19668 } = layout; 19669 19670 // If a block's block.json skips serialization for spacing or spacing.blockGap, 19671 // don't apply the user-defined value to the styles. 19672 const blockGapValue = style?.spacing?.blockGap && !shouldSkipSerialization(blockName, 'spacing', 'blockGap') ? getGapCSSValue(style?.spacing?.blockGap, '0.5em') : undefined; 19673 const justifyContent = justifyContentMap[layout.justifyContent]; 19674 const flexWrap = flexWrapOptions.includes(layout.flexWrap) ? layout.flexWrap : 'wrap'; 19675 const verticalAlignment = verticalAlignmentMap[layout.verticalAlignment]; 19676 const alignItems = alignItemsMap[layout.justifyContent] || alignItemsMap.left; 19677 let output = ''; 19678 const rules = []; 19679 if (flexWrap && flexWrap !== 'wrap') { 19680 rules.push(`flex-wrap: $flexWrap}`); 19681 } 19682 if (orientation === 'horizontal') { 19683 if (verticalAlignment) { 19684 rules.push(`align-items: $verticalAlignment}`); 19685 } 19686 if (justifyContent) { 19687 rules.push(`justify-content: $justifyContent}`); 19688 } 19689 } else { 19690 if (verticalAlignment) { 19691 rules.push(`justify-content: $verticalAlignment}`); 19692 } 19693 rules.push('flex-direction: column'); 19694 rules.push(`align-items: $alignItems}`); 19695 } 19696 if (rules.length) { 19697 output = `$appendSelectors(selector)} { 19698 $rules.join('; ')}; 19699 }`; 19700 } 19701 19702 // Output blockGap styles based on rules contained in layout definitions in theme.json. 19703 if (hasBlockGapSupport && blockGapValue) { 19704 output += getBlockGapCSS(selector, layoutDefinitions, 'flex', blockGapValue); 19705 } 19706 return output; 19707 }, 19708 getOrientation(layout) { 19709 const { 19710 orientation = 'horizontal' 19711 } = layout; 19712 return orientation; 19713 }, 19714 getAlignments() { 19715 return []; 19716 } 19717 }); 19718 function FlexLayoutVerticalAlignmentControl({ 19719 layout, 19720 onChange 19721 }) { 19722 const { 19723 orientation = 'horizontal' 19724 } = layout; 19725 const defaultVerticalAlignment = orientation === 'horizontal' ? verticalAlignmentMap.center : verticalAlignmentMap.top; 19726 const { 19727 verticalAlignment = defaultVerticalAlignment 19728 } = layout; 19729 const onVerticalAlignmentChange = value => { 19730 onChange({ 19731 ...layout, 19732 verticalAlignment: value 19733 }); 19734 }; 19735 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockVerticalAlignmentControl, { 19736 onChange: onVerticalAlignmentChange, 19737 value: verticalAlignment, 19738 controls: orientation === 'horizontal' ? ['top', 'center', 'bottom', 'stretch'] : ['top', 'center', 'bottom', 'space-between'] 19739 }); 19740 } 19741 const POPOVER_PROPS = { 19742 placement: 'bottom-start' 19743 }; 19744 function FlexLayoutJustifyContentControl({ 19745 layout, 19746 onChange, 19747 isToolbar = false 19748 }) { 19749 const { 19750 justifyContent = 'left', 19751 orientation = 'horizontal' 19752 } = layout; 19753 const onJustificationChange = value => { 19754 onChange({ 19755 ...layout, 19756 justifyContent: value 19757 }); 19758 }; 19759 const allowedControls = ['left', 'center', 'right']; 19760 if (orientation === 'horizontal') { 19761 allowedControls.push('space-between'); 19762 } else { 19763 allowedControls.push('stretch'); 19764 } 19765 if (isToolbar) { 19766 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(JustifyContentControl, { 19767 allowedControls: allowedControls, 19768 value: justifyContent, 19769 onChange: onJustificationChange, 19770 popoverProps: POPOVER_PROPS 19771 }); 19772 } 19773 const justificationOptions = [{ 19774 value: 'left', 19775 icon: justify_left, 19776 label: (0,external_wp_i18n_namespaceObject.__)('Justify items left') 19777 }, { 19778 value: 'center', 19779 icon: justify_center, 19780 label: (0,external_wp_i18n_namespaceObject.__)('Justify items center') 19781 }, { 19782 value: 'right', 19783 icon: justify_right, 19784 label: (0,external_wp_i18n_namespaceObject.__)('Justify items right') 19785 }]; 19786 if (orientation === 'horizontal') { 19787 justificationOptions.push({ 19788 value: 'space-between', 19789 icon: justify_space_between, 19790 label: (0,external_wp_i18n_namespaceObject.__)('Space between items') 19791 }); 19792 } else { 19793 justificationOptions.push({ 19794 value: 'stretch', 19795 icon: justify_stretch, 19796 label: (0,external_wp_i18n_namespaceObject.__)('Stretch items') 19797 }); 19798 } 19799 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 19800 __next40pxDefaultSize: true, 19801 __nextHasNoMarginBottom: true, 19802 label: (0,external_wp_i18n_namespaceObject.__)('Justification'), 19803 value: justifyContent, 19804 onChange: onJustificationChange, 19805 className: "block-editor-hooks__flex-layout-justification-controls", 19806 children: justificationOptions.map(({ 19807 value, 19808 icon, 19809 label 19810 }) => { 19811 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, { 19812 value: value, 19813 icon: icon, 19814 label: label 19815 }, value); 19816 }) 19817 }); 19818 } 19819 function FlexWrapControl({ 19820 layout, 19821 onChange 19822 }) { 19823 const { 19824 flexWrap = 'wrap' 19825 } = layout; 19826 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, { 19827 __nextHasNoMarginBottom: true, 19828 label: (0,external_wp_i18n_namespaceObject.__)('Allow to wrap to multiple lines'), 19829 onChange: value => { 19830 onChange({ 19831 ...layout, 19832 flexWrap: value ? 'wrap' : 'nowrap' 19833 }); 19834 }, 19835 checked: flexWrap === 'wrap' 19836 }); 19837 } 19838 function OrientationControl({ 19839 layout, 19840 onChange 19841 }) { 19842 const { 19843 orientation = 'horizontal', 19844 verticalAlignment, 19845 justifyContent 19846 } = layout; 19847 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 19848 __next40pxDefaultSize: true, 19849 __nextHasNoMarginBottom: true, 19850 className: "block-editor-hooks__flex-layout-orientation-controls", 19851 label: (0,external_wp_i18n_namespaceObject.__)('Orientation'), 19852 value: orientation, 19853 onChange: value => { 19854 // Make sure the vertical alignment and justification are compatible with the new orientation. 19855 let newVerticalAlignment = verticalAlignment; 19856 let newJustification = justifyContent; 19857 if (value === 'horizontal') { 19858 if (verticalAlignment === 'space-between') { 19859 newVerticalAlignment = 'center'; 19860 } 19861 if (justifyContent === 'stretch') { 19862 newJustification = 'left'; 19863 } 19864 } else { 19865 if (verticalAlignment === 'stretch') { 19866 newVerticalAlignment = 'top'; 19867 } 19868 if (justifyContent === 'space-between') { 19869 newJustification = 'left'; 19870 } 19871 } 19872 return onChange({ 19873 ...layout, 19874 orientation: value, 19875 verticalAlignment: newVerticalAlignment, 19876 justifyContent: newJustification 19877 }); 19878 }, 19879 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, { 19880 icon: arrow_right, 19881 value: "horizontal", 19882 label: (0,external_wp_i18n_namespaceObject.__)('Horizontal') 19883 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, { 19884 icon: arrow_down, 19885 value: "vertical", 19886 label: (0,external_wp_i18n_namespaceObject.__)('Vertical') 19887 })] 19888 }); 19889 } 19890 19891 ;// ./node_modules/@wordpress/block-editor/build-module/layouts/flow.js 19892 /** 19893 * WordPress dependencies 19894 */ 19895 19896 19897 /** 19898 * Internal dependencies 19899 */ 19900 19901 19902 19903 19904 /* harmony default export */ const flow = ({ 19905 name: 'default', 19906 label: (0,external_wp_i18n_namespaceObject.__)('Flow'), 19907 inspectorControls: function DefaultLayoutInspectorControls() { 19908 return null; 19909 }, 19910 toolBarControls: function DefaultLayoutToolbarControls() { 19911 return null; 19912 }, 19913 getLayoutStyle: function getLayoutStyle({ 19914 selector, 19915 style, 19916 blockName, 19917 hasBlockGapSupport, 19918 layoutDefinitions = LAYOUT_DEFINITIONS 19919 }) { 19920 const blockGapStyleValue = getGapCSSValue(style?.spacing?.blockGap); 19921 19922 // If a block's block.json skips serialization for spacing or 19923 // spacing.blockGap, don't apply the user-defined value to the styles. 19924 let blockGapValue = ''; 19925 if (!shouldSkipSerialization(blockName, 'spacing', 'blockGap')) { 19926 // If an object is provided only use the 'top' value for this kind of gap. 19927 if (blockGapStyleValue?.top) { 19928 blockGapValue = getGapCSSValue(blockGapStyleValue?.top); 19929 } else if (typeof blockGapStyleValue === 'string') { 19930 blockGapValue = getGapCSSValue(blockGapStyleValue); 19931 } 19932 } 19933 let output = ''; 19934 19935 // Output blockGap styles based on rules contained in layout definitions in theme.json. 19936 if (hasBlockGapSupport && blockGapValue) { 19937 output += getBlockGapCSS(selector, layoutDefinitions, 'default', blockGapValue); 19938 } 19939 return output; 19940 }, 19941 getOrientation() { 19942 return 'vertical'; 19943 }, 19944 getAlignments(layout, isBlockBasedTheme) { 19945 const alignmentInfo = getAlignmentsInfo(layout); 19946 if (layout.alignments !== undefined) { 19947 if (!layout.alignments.includes('none')) { 19948 layout.alignments.unshift('none'); 19949 } 19950 return layout.alignments.map(alignment => ({ 19951 name: alignment, 19952 info: alignmentInfo[alignment] 19953 })); 19954 } 19955 const alignments = [{ 19956 name: 'left' 19957 }, { 19958 name: 'center' 19959 }, { 19960 name: 'right' 19961 }]; 19962 19963 // This is for backwards compatibility with hybrid themes. 19964 if (!isBlockBasedTheme) { 19965 const { 19966 contentSize, 19967 wideSize 19968 } = layout; 19969 if (contentSize) { 19970 alignments.unshift({ 19971 name: 'full' 19972 }); 19973 } 19974 if (wideSize) { 19975 alignments.unshift({ 19976 name: 'wide', 19977 info: alignmentInfo.wide 19978 }); 19979 } 19980 } 19981 alignments.unshift({ 19982 name: 'none', 19983 info: alignmentInfo.none 19984 }); 19985 return alignments; 19986 } 19987 }); 19988 19989 ;// ./node_modules/@wordpress/icons/build-module/icon/index.js 19990 /** 19991 * WordPress dependencies 19992 */ 19993 19994 19995 /** @typedef {{icon: JSX.Element, size?: number} & import('@wordpress/primitives').SVGProps} IconProps */ 19996 19997 /** 19998 * Return an SVG icon. 19999 * 20000 * @param {IconProps} props icon is the SVG component to render 20001 * size is a number specifiying the icon size in pixels 20002 * Other props will be passed to wrapped SVG component 20003 * @param {import('react').ForwardedRef<HTMLElement>} ref The forwarded ref to the SVG element. 20004 * 20005 * @return {JSX.Element} Icon component 20006 */ 20007 function Icon({ 20008 icon, 20009 size = 24, 20010 ...props 20011 }, ref) { 20012 return (0,external_wp_element_namespaceObject.cloneElement)(icon, { 20013 width: size, 20014 height: size, 20015 ...props, 20016 ref 20017 }); 20018 } 20019 /* harmony default export */ const build_module_icon = ((0,external_wp_element_namespaceObject.forwardRef)(Icon)); 20020 20021 ;// ./node_modules/@wordpress/icons/build-module/library/align-none.js 20022 /** 20023 * WordPress dependencies 20024 */ 20025 20026 20027 const alignNone = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 20028 xmlns: "http://www.w3.org/2000/svg", 20029 viewBox: "0 0 24 24", 20030 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 20031 d: "M19 5.5H5V4h14v1.5ZM19 20H5v-1.5h14V20ZM5 9h14v6H5V9Z" 20032 }) 20033 }); 20034 /* harmony default export */ const align_none = (alignNone); 20035 20036 ;// ./node_modules/@wordpress/icons/build-module/library/stretch-wide.js 20037 /** 20038 * WordPress dependencies 20039 */ 20040 20041 20042 const stretchWide = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 20043 xmlns: "http://www.w3.org/2000/svg", 20044 viewBox: "0 0 24 24", 20045 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 20046 d: "M16 5.5H8V4h8v1.5ZM16 20H8v-1.5h8V20ZM5 9h14v6H5V9Z" 20047 }) 20048 }); 20049 /* harmony default export */ const stretch_wide = (stretchWide); 20050 20051 ;// ./node_modules/@wordpress/block-editor/build-module/layouts/constrained.js 20052 /** 20053 * WordPress dependencies 20054 */ 20055 20056 20057 20058 20059 20060 /** 20061 * Internal dependencies 20062 */ 20063 20064 20065 20066 20067 20068 20069 20070 20071 20072 /* harmony default export */ const constrained = ({ 20073 name: 'constrained', 20074 label: (0,external_wp_i18n_namespaceObject.__)('Constrained'), 20075 inspectorControls: function DefaultLayoutInspectorControls({ 20076 layout, 20077 onChange, 20078 layoutBlockSupport = {} 20079 }) { 20080 const { 20081 wideSize, 20082 contentSize, 20083 justifyContent = 'center' 20084 } = layout; 20085 const { 20086 allowJustification = true, 20087 allowCustomContentAndWideSize = true 20088 } = layoutBlockSupport; 20089 const onJustificationChange = value => { 20090 onChange({ 20091 ...layout, 20092 justifyContent: value 20093 }); 20094 }; 20095 const justificationOptions = [{ 20096 value: 'left', 20097 icon: justify_left, 20098 label: (0,external_wp_i18n_namespaceObject.__)('Justify items left') 20099 }, { 20100 value: 'center', 20101 icon: justify_center, 20102 label: (0,external_wp_i18n_namespaceObject.__)('Justify items center') 20103 }, { 20104 value: 'right', 20105 icon: justify_right, 20106 label: (0,external_wp_i18n_namespaceObject.__)('Justify items right') 20107 }]; 20108 const [availableUnits] = use_settings_useSettings('spacing.units'); 20109 const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({ 20110 availableUnits: availableUnits || ['%', 'px', 'em', 'rem', 'vw'] 20111 }); 20112 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 20113 spacing: 4, 20114 className: "block-editor-hooks__layout-constrained", 20115 children: [allowCustomContentAndWideSize && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 20116 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 20117 __next40pxDefaultSize: true, 20118 label: (0,external_wp_i18n_namespaceObject.__)('Content width'), 20119 labelPosition: "top", 20120 value: contentSize || wideSize || '', 20121 onChange: nextWidth => { 20122 nextWidth = 0 > parseFloat(nextWidth) ? '0' : nextWidth; 20123 onChange({ 20124 ...layout, 20125 contentSize: nextWidth 20126 }); 20127 }, 20128 units: units, 20129 prefix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlPrefixWrapper, { 20130 variant: "icon", 20131 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 20132 icon: align_none 20133 }) 20134 }) 20135 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 20136 __next40pxDefaultSize: true, 20137 label: (0,external_wp_i18n_namespaceObject.__)('Wide width'), 20138 labelPosition: "top", 20139 value: wideSize || contentSize || '', 20140 onChange: nextWidth => { 20141 nextWidth = 0 > parseFloat(nextWidth) ? '0' : nextWidth; 20142 onChange({ 20143 ...layout, 20144 wideSize: nextWidth 20145 }); 20146 }, 20147 units: units, 20148 prefix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlPrefixWrapper, { 20149 variant: "icon", 20150 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 20151 icon: stretch_wide 20152 }) 20153 }) 20154 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 20155 className: "block-editor-hooks__layout-constrained-helptext", 20156 children: (0,external_wp_i18n_namespaceObject.__)('Customize the width for all elements that are assigned to the center or wide columns.') 20157 })] 20158 }), allowJustification && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 20159 __next40pxDefaultSize: true, 20160 __nextHasNoMarginBottom: true, 20161 label: (0,external_wp_i18n_namespaceObject.__)('Justification'), 20162 value: justifyContent, 20163 onChange: onJustificationChange, 20164 children: justificationOptions.map(({ 20165 value, 20166 icon, 20167 label 20168 }) => { 20169 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, { 20170 value: value, 20171 icon: icon, 20172 label: label 20173 }, value); 20174 }) 20175 })] 20176 }); 20177 }, 20178 toolBarControls: function DefaultLayoutToolbarControls({ 20179 layout = {}, 20180 onChange, 20181 layoutBlockSupport 20182 }) { 20183 const { 20184 allowJustification = true 20185 } = layoutBlockSupport; 20186 if (!allowJustification) { 20187 return null; 20188 } 20189 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, { 20190 group: "block", 20191 __experimentalShareWithChildBlocks: true, 20192 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultLayoutJustifyContentControl, { 20193 layout: layout, 20194 onChange: onChange 20195 }) 20196 }); 20197 }, 20198 getLayoutStyle: function getLayoutStyle({ 20199 selector, 20200 layout = {}, 20201 style, 20202 blockName, 20203 hasBlockGapSupport, 20204 layoutDefinitions = LAYOUT_DEFINITIONS 20205 }) { 20206 const { 20207 contentSize, 20208 wideSize, 20209 justifyContent 20210 } = layout; 20211 const blockGapStyleValue = getGapCSSValue(style?.spacing?.blockGap); 20212 20213 // If a block's block.json skips serialization for spacing or 20214 // spacing.blockGap, don't apply the user-defined value to the styles. 20215 let blockGapValue = ''; 20216 if (!shouldSkipSerialization(blockName, 'spacing', 'blockGap')) { 20217 // If an object is provided only use the 'top' value for this kind of gap. 20218 if (blockGapStyleValue?.top) { 20219 blockGapValue = getGapCSSValue(blockGapStyleValue?.top); 20220 } else if (typeof blockGapStyleValue === 'string') { 20221 blockGapValue = getGapCSSValue(blockGapStyleValue); 20222 } 20223 } 20224 const marginLeft = justifyContent === 'left' ? '0 !important' : 'auto !important'; 20225 const marginRight = justifyContent === 'right' ? '0 !important' : 'auto !important'; 20226 let output = !!contentSize || !!wideSize ? ` 20227 $appendSelectors(selector, '> :where(:not(.alignleft):not(.alignright):not(.alignfull))')} { 20228 max-width: $contentSize !== null && contentSize !== void 0 ? contentSize : wideSize}; 20229 margin-left: $marginLeft}; 20230 margin-right: $marginRight}; 20231 } 20232 $appendSelectors(selector, '> .alignwide')} { 20233 max-width: $wideSize !== null && wideSize !== void 0 ? wideSize : contentSize}; 20234 } 20235 $appendSelectors(selector, '> .alignfull')} { 20236 max-width: none; 20237 } 20238 ` : ''; 20239 if (justifyContent === 'left') { 20240 output += `$appendSelectors(selector, '> :where(:not(.alignleft):not(.alignright):not(.alignfull))')} 20241 { margin-left: $marginLeft}; }`; 20242 } else if (justifyContent === 'right') { 20243 output += `$appendSelectors(selector, '> :where(:not(.alignleft):not(.alignright):not(.alignfull))')} 20244 { margin-right: $marginRight}; }`; 20245 } 20246 20247 // If there is custom padding, add negative margins for alignfull blocks. 20248 if (style?.spacing?.padding) { 20249 // The style object might be storing a preset so we need to make sure we get a usable value. 20250 const paddingValues = (0,external_wp_styleEngine_namespaceObject.getCSSRules)(style); 20251 paddingValues.forEach(rule => { 20252 if (rule.key === 'paddingRight') { 20253 // Add unit if 0, to avoid calc(0 * -1) which is invalid. 20254 const paddingRightValue = rule.value === '0' ? '0px' : rule.value; 20255 output += ` 20256 $appendSelectors(selector, '> .alignfull')} { 20257 margin-right: calc($paddingRightValue} * -1); 20258 } 20259 `; 20260 } else if (rule.key === 'paddingLeft') { 20261 // Add unit if 0, to avoid calc(0 * -1) which is invalid. 20262 const paddingLeftValue = rule.value === '0' ? '0px' : rule.value; 20263 output += ` 20264 $appendSelectors(selector, '> .alignfull')} { 20265 margin-left: calc($paddingLeftValue} * -1); 20266 } 20267 `; 20268 } 20269 }); 20270 } 20271 20272 // Output blockGap styles based on rules contained in layout definitions in theme.json. 20273 if (hasBlockGapSupport && blockGapValue) { 20274 output += getBlockGapCSS(selector, layoutDefinitions, 'constrained', blockGapValue); 20275 } 20276 return output; 20277 }, 20278 getOrientation() { 20279 return 'vertical'; 20280 }, 20281 getAlignments(layout) { 20282 const alignmentInfo = getAlignmentsInfo(layout); 20283 if (layout.alignments !== undefined) { 20284 if (!layout.alignments.includes('none')) { 20285 layout.alignments.unshift('none'); 20286 } 20287 return layout.alignments.map(alignment => ({ 20288 name: alignment, 20289 info: alignmentInfo[alignment] 20290 })); 20291 } 20292 const { 20293 contentSize, 20294 wideSize 20295 } = layout; 20296 const alignments = [{ 20297 name: 'left' 20298 }, { 20299 name: 'center' 20300 }, { 20301 name: 'right' 20302 }]; 20303 if (contentSize) { 20304 alignments.unshift({ 20305 name: 'full' 20306 }); 20307 } 20308 if (wideSize) { 20309 alignments.unshift({ 20310 name: 'wide', 20311 info: alignmentInfo.wide 20312 }); 20313 } 20314 alignments.unshift({ 20315 name: 'none', 20316 info: alignmentInfo.none 20317 }); 20318 return alignments; 20319 } 20320 }); 20321 const constrained_POPOVER_PROPS = { 20322 placement: 'bottom-start' 20323 }; 20324 function DefaultLayoutJustifyContentControl({ 20325 layout, 20326 onChange 20327 }) { 20328 const { 20329 justifyContent = 'center' 20330 } = layout; 20331 const onJustificationChange = value => { 20332 onChange({ 20333 ...layout, 20334 justifyContent: value 20335 }); 20336 }; 20337 const allowedControls = ['left', 'center', 'right']; 20338 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(JustifyContentControl, { 20339 allowedControls: allowedControls, 20340 value: justifyContent, 20341 onChange: onJustificationChange, 20342 popoverProps: constrained_POPOVER_PROPS 20343 }); 20344 } 20345 20346 ;// ./node_modules/@wordpress/block-editor/build-module/layouts/grid.js 20347 /** 20348 * WordPress dependencies 20349 */ 20350 20351 20352 20353 20354 /** 20355 * Internal dependencies 20356 */ 20357 20358 20359 20360 20361 20362 20363 20364 const RANGE_CONTROL_MAX_VALUES = { 20365 px: 600, 20366 '%': 100, 20367 vw: 100, 20368 vh: 100, 20369 em: 38, 20370 rem: 38, 20371 svw: 100, 20372 lvw: 100, 20373 dvw: 100, 20374 svh: 100, 20375 lvh: 100, 20376 dvh: 100, 20377 vi: 100, 20378 svi: 100, 20379 lvi: 100, 20380 dvi: 100, 20381 vb: 100, 20382 svb: 100, 20383 lvb: 100, 20384 dvb: 100, 20385 vmin: 100, 20386 svmin: 100, 20387 lvmin: 100, 20388 dvmin: 100, 20389 vmax: 100, 20390 svmax: 100, 20391 lvmax: 100, 20392 dvmax: 100 20393 }; 20394 const units = [{ 20395 value: 'px', 20396 label: 'px', 20397 default: 0 20398 }, { 20399 value: 'rem', 20400 label: 'rem', 20401 default: 0 20402 }, { 20403 value: 'em', 20404 label: 'em', 20405 default: 0 20406 }]; 20407 /* harmony default export */ const grid = ({ 20408 name: 'grid', 20409 label: (0,external_wp_i18n_namespaceObject.__)('Grid'), 20410 inspectorControls: function GridLayoutInspectorControls({ 20411 layout = {}, 20412 onChange, 20413 layoutBlockSupport = {} 20414 }) { 20415 const { 20416 allowSizingOnChildren = false 20417 } = layoutBlockSupport; 20418 20419 // In the experiment we want to also show column control in Auto mode, and 20420 // the minimum width control in Manual mode. 20421 const showColumnsControl = window.__experimentalEnableGridInteractivity || !!layout?.columnCount; 20422 const showMinWidthControl = window.__experimentalEnableGridInteractivity || !layout?.columnCount; 20423 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 20424 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLayoutTypeControl, { 20425 layout: layout, 20426 onChange: onChange 20427 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 20428 spacing: 4, 20429 children: [showColumnsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLayoutColumnsAndRowsControl, { 20430 layout: layout, 20431 onChange: onChange, 20432 allowSizingOnChildren: allowSizingOnChildren 20433 }), showMinWidthControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLayoutMinimumWidthControl, { 20434 layout: layout, 20435 onChange: onChange 20436 })] 20437 })] 20438 }); 20439 }, 20440 toolBarControls: function GridLayoutToolbarControls() { 20441 return null; 20442 }, 20443 getLayoutStyle: function getLayoutStyle({ 20444 selector, 20445 layout, 20446 style, 20447 blockName, 20448 hasBlockGapSupport, 20449 layoutDefinitions = LAYOUT_DEFINITIONS 20450 }) { 20451 const { 20452 minimumColumnWidth = null, 20453 columnCount = null, 20454 rowCount = null 20455 } = layout; 20456 20457 // Check that the grid layout attributes are of the correct type, so that we don't accidentally 20458 // write code that stores a string attribute instead of a number. 20459 if (false) {} 20460 20461 // If a block's block.json skips serialization for spacing or spacing.blockGap, 20462 // don't apply the user-defined value to the styles. 20463 const blockGapValue = style?.spacing?.blockGap && !shouldSkipSerialization(blockName, 'spacing', 'blockGap') ? getGapCSSValue(style?.spacing?.blockGap, '0.5em') : undefined; 20464 let output = ''; 20465 const rules = []; 20466 if (minimumColumnWidth && columnCount > 0) { 20467 const maxValue = `max($minimumColumnWidth}, ( 100% - ($blockGapValue || '1.2rem'}*$columnCount - 1}) ) / $columnCount})`; 20468 rules.push(`grid-template-columns: repeat(auto-fill, minmax($maxValue}, 1fr))`, `container-type: inline-size`); 20469 if (rowCount) { 20470 rules.push(`grid-template-rows: repeat($rowCount}, minmax(1rem, auto))`); 20471 } 20472 } else if (columnCount) { 20473 rules.push(`grid-template-columns: repeat($columnCount}, minmax(0, 1fr))`); 20474 if (rowCount) { 20475 rules.push(`grid-template-rows: repeat($rowCount}, minmax(1rem, auto))`); 20476 } 20477 } else { 20478 rules.push(`grid-template-columns: repeat(auto-fill, minmax(min($minimumColumnWidth || '12rem'}, 100%), 1fr))`, 'container-type: inline-size'); 20479 } 20480 if (rules.length) { 20481 // Reason to disable: the extra line breaks added by prettier mess with the unit tests. 20482 // eslint-disable-next-line prettier/prettier 20483 output = `$appendSelectors(selector)} { $rules.join('; ')}; }`; 20484 } 20485 20486 // Output blockGap styles based on rules contained in layout definitions in theme.json. 20487 if (hasBlockGapSupport && blockGapValue) { 20488 output += getBlockGapCSS(selector, layoutDefinitions, 'grid', blockGapValue); 20489 } 20490 return output; 20491 }, 20492 getOrientation() { 20493 return 'horizontal'; 20494 }, 20495 getAlignments() { 20496 return []; 20497 } 20498 }); 20499 20500 // Enables setting minimum width of grid items. 20501 function GridLayoutMinimumWidthControl({ 20502 layout, 20503 onChange 20504 }) { 20505 const { 20506 minimumColumnWidth, 20507 columnCount, 20508 isManualPlacement 20509 } = layout; 20510 const defaultValue = isManualPlacement || columnCount ? null : '12rem'; 20511 const value = minimumColumnWidth || defaultValue; 20512 const [quantity, unit = 'rem'] = (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(value); 20513 const handleSliderChange = next => { 20514 onChange({ 20515 ...layout, 20516 minimumColumnWidth: [next, unit].join('') 20517 }); 20518 }; 20519 20520 // Mostly copied from HeightControl. 20521 const handleUnitChange = newUnit => { 20522 // Attempt to smooth over differences between currentUnit and newUnit. 20523 // This should slightly improve the experience of switching between unit types. 20524 let newValue; 20525 if (['em', 'rem'].includes(newUnit) && unit === 'px') { 20526 // Convert pixel value to an approximate of the new unit, assuming a root size of 16px. 20527 newValue = (quantity / 16).toFixed(2) + newUnit; 20528 } else if (['em', 'rem'].includes(unit) && newUnit === 'px') { 20529 // Convert to pixel value assuming a root size of 16px. 20530 newValue = Math.round(quantity * 16) + newUnit; 20531 } 20532 onChange({ 20533 ...layout, 20534 minimumColumnWidth: newValue 20535 }); 20536 }; 20537 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", { 20538 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, { 20539 as: "legend", 20540 children: (0,external_wp_i18n_namespaceObject.__)('Minimum column width') 20541 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, { 20542 gap: 4, 20543 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 20544 isBlock: true, 20545 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 20546 size: "__unstable-large", 20547 onChange: newValue => { 20548 onChange({ 20549 ...layout, 20550 minimumColumnWidth: newValue === '' ? undefined : newValue 20551 }); 20552 }, 20553 onUnitChange: handleUnitChange, 20554 value: value, 20555 units: units, 20556 min: 0, 20557 label: (0,external_wp_i18n_namespaceObject.__)('Minimum column width'), 20558 hideLabelFromVision: true 20559 }) 20560 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 20561 isBlock: true, 20562 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, { 20563 __next40pxDefaultSize: true, 20564 __nextHasNoMarginBottom: true, 20565 onChange: handleSliderChange, 20566 value: quantity || 0, 20567 min: 0, 20568 max: RANGE_CONTROL_MAX_VALUES[unit] || 600, 20569 withInputField: false, 20570 label: (0,external_wp_i18n_namespaceObject.__)('Minimum column width'), 20571 hideLabelFromVision: true 20572 }) 20573 })] 20574 })] 20575 }); 20576 } 20577 20578 // Enables setting number of grid columns 20579 function GridLayoutColumnsAndRowsControl({ 20580 layout, 20581 onChange, 20582 allowSizingOnChildren 20583 }) { 20584 // If the grid interactivity experiment is enabled, allow unsetting the column count. 20585 const defaultColumnCount = window.__experimentalEnableGridInteractivity ? undefined : 3; 20586 const { 20587 columnCount = defaultColumnCount, 20588 rowCount, 20589 isManualPlacement 20590 } = layout; 20591 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 20592 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", { 20593 children: [(!window.__experimentalEnableGridInteractivity || !isManualPlacement) && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, { 20594 as: "legend", 20595 children: (0,external_wp_i18n_namespaceObject.__)('Columns') 20596 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, { 20597 gap: 4, 20598 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 20599 isBlock: true, 20600 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, { 20601 size: "__unstable-large", 20602 onChange: value => { 20603 if (window.__experimentalEnableGridInteractivity) { 20604 // Allow unsetting the column count when in auto mode. 20605 const defaultNewColumnCount = isManualPlacement ? 1 : undefined; 20606 const newColumnCount = value === '' || value === '0' ? defaultNewColumnCount : parseInt(value, 10); 20607 onChange({ 20608 ...layout, 20609 columnCount: newColumnCount 20610 }); 20611 } else { 20612 // Don't allow unsetting the column count. 20613 const newColumnCount = value === '' || value === '0' ? 1 : parseInt(value, 10); 20614 onChange({ 20615 ...layout, 20616 columnCount: newColumnCount 20617 }); 20618 } 20619 }, 20620 value: columnCount, 20621 min: 1, 20622 label: (0,external_wp_i18n_namespaceObject.__)('Columns'), 20623 hideLabelFromVision: !window.__experimentalEnableGridInteractivity || !isManualPlacement 20624 }) 20625 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 20626 isBlock: true, 20627 children: window.__experimentalEnableGridInteractivity && allowSizingOnChildren && isManualPlacement ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, { 20628 size: "__unstable-large", 20629 onChange: value => { 20630 // Don't allow unsetting the row count. 20631 const newRowCount = value === '' || value === '0' ? 1 : parseInt(value, 10); 20632 onChange({ 20633 ...layout, 20634 rowCount: newRowCount 20635 }); 20636 }, 20637 value: rowCount, 20638 min: 1, 20639 label: (0,external_wp_i18n_namespaceObject.__)('Rows') 20640 }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, { 20641 __next40pxDefaultSize: true, 20642 __nextHasNoMarginBottom: true, 20643 value: columnCount !== null && columnCount !== void 0 ? columnCount : 1, 20644 onChange: value => onChange({ 20645 ...layout, 20646 columnCount: value === '' || value === '0' ? 1 : value 20647 }), 20648 min: 1, 20649 max: 16, 20650 withInputField: false, 20651 label: (0,external_wp_i18n_namespaceObject.__)('Columns'), 20652 hideLabelFromVision: true 20653 }) 20654 })] 20655 })] 20656 }) 20657 }); 20658 } 20659 20660 // Enables switching between grid types 20661 function GridLayoutTypeControl({ 20662 layout, 20663 onChange 20664 }) { 20665 const { 20666 columnCount, 20667 rowCount, 20668 minimumColumnWidth, 20669 isManualPlacement 20670 } = layout; 20671 20672 /** 20673 * When switching, temporarily save any custom values set on the 20674 * previous type so we can switch back without loss. 20675 */ 20676 const [tempColumnCount, setTempColumnCount] = (0,external_wp_element_namespaceObject.useState)(columnCount || 3); 20677 const [tempRowCount, setTempRowCount] = (0,external_wp_element_namespaceObject.useState)(rowCount); 20678 const [tempMinimumColumnWidth, setTempMinimumColumnWidth] = (0,external_wp_element_namespaceObject.useState)(minimumColumnWidth || '12rem'); 20679 const gridPlacement = isManualPlacement || !!columnCount && !window.__experimentalEnableGridInteractivity ? 'manual' : 'auto'; 20680 const onChangeType = value => { 20681 if (value === 'manual') { 20682 setTempMinimumColumnWidth(minimumColumnWidth || '12rem'); 20683 } else { 20684 setTempColumnCount(columnCount || 3); 20685 setTempRowCount(rowCount); 20686 } 20687 onChange({ 20688 ...layout, 20689 columnCount: value === 'manual' ? tempColumnCount : null, 20690 rowCount: value === 'manual' && window.__experimentalEnableGridInteractivity ? tempRowCount : undefined, 20691 isManualPlacement: value === 'manual' && window.__experimentalEnableGridInteractivity ? true : undefined, 20692 minimumColumnWidth: value === 'auto' ? tempMinimumColumnWidth : null 20693 }); 20694 }; 20695 const helpText = gridPlacement === 'manual' ? (0,external_wp_i18n_namespaceObject.__)('Grid items can be manually placed in any position on the grid.') : (0,external_wp_i18n_namespaceObject.__)('Grid items are placed automatically depending on their order.'); 20696 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 20697 __next40pxDefaultSize: true, 20698 __nextHasNoMarginBottom: true, 20699 label: (0,external_wp_i18n_namespaceObject.__)('Grid item position'), 20700 value: gridPlacement, 20701 onChange: onChangeType, 20702 isBlock: true, 20703 help: window.__experimentalEnableGridInteractivity ? helpText : undefined, 20704 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, { 20705 value: "auto", 20706 label: (0,external_wp_i18n_namespaceObject.__)('Auto') 20707 }, "auto"), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, { 20708 value: "manual", 20709 label: (0,external_wp_i18n_namespaceObject.__)('Manual') 20710 }, "manual")] 20711 }); 20712 } 20713 20714 ;// ./node_modules/@wordpress/block-editor/build-module/layouts/index.js 20715 /** 20716 * Internal dependencies 20717 */ 20718 20719 20720 20721 20722 const layoutTypes = [flow, flex, constrained, grid]; 20723 20724 /** 20725 * Retrieves a layout type by name. 20726 * 20727 * @param {string} name - The name of the layout type. 20728 * @return {Object} Layout type. 20729 */ 20730 function getLayoutType(name = 'default') { 20731 return layoutTypes.find(layoutType => layoutType.name === name); 20732 } 20733 20734 /** 20735 * Retrieves the available layout types. 20736 * 20737 * @return {Array} Layout types. 20738 */ 20739 function getLayoutTypes() { 20740 return layoutTypes; 20741 } 20742 20743 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/layout.js 20744 /** 20745 * WordPress dependencies 20746 */ 20747 20748 20749 /** 20750 * Internal dependencies 20751 */ 20752 20753 20754 20755 const defaultLayout = { 20756 type: 'default' 20757 }; 20758 const Layout = (0,external_wp_element_namespaceObject.createContext)(defaultLayout); 20759 20760 /** 20761 * Allows to define the layout. 20762 */ 20763 const LayoutProvider = Layout.Provider; 20764 20765 /** 20766 * React hook used to retrieve the layout config. 20767 */ 20768 function useLayout() { 20769 return (0,external_wp_element_namespaceObject.useContext)(Layout); 20770 } 20771 function LayoutStyle({ 20772 layout = {}, 20773 css, 20774 ...props 20775 }) { 20776 const layoutType = getLayoutType(layout.type); 20777 const [blockGapSupport] = use_settings_useSettings('spacing.blockGap'); 20778 const hasBlockGapSupport = blockGapSupport !== null; 20779 if (layoutType) { 20780 if (css) { 20781 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("style", { 20782 children: css 20783 }); 20784 } 20785 const layoutStyle = layoutType.getLayoutStyle?.({ 20786 hasBlockGapSupport, 20787 layout, 20788 ...props 20789 }); 20790 if (layoutStyle) { 20791 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("style", { 20792 children: layoutStyle 20793 }); 20794 } 20795 } 20796 return null; 20797 } 20798 20799 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-control/use-available-alignments.js 20800 /** 20801 * WordPress dependencies 20802 */ 20803 20804 20805 /** 20806 * Internal dependencies 20807 */ 20808 20809 20810 20811 const use_available_alignments_EMPTY_ARRAY = []; 20812 const use_available_alignments_DEFAULT_CONTROLS = ['none', 'left', 'center', 'right', 'wide', 'full']; 20813 const WIDE_CONTROLS = ['wide', 'full']; 20814 function useAvailableAlignments(controls = use_available_alignments_DEFAULT_CONTROLS) { 20815 // Always add the `none` option if not exists. 20816 if (!controls.includes('none')) { 20817 controls = ['none', ...controls]; 20818 } 20819 const isNoneOnly = controls.length === 1 && controls[0] === 'none'; 20820 const [wideControlsEnabled, themeSupportsLayout, isBlockBasedTheme] = (0,external_wp_data_namespaceObject.useSelect)(select => { 20821 var _settings$alignWide; 20822 // If `isNoneOnly` is true, we'll be returning early because there is 20823 // nothing to filter on an empty array. We won't need the info from 20824 // the `useSelect` but we must call it anyway because Rules of Hooks. 20825 // So the callback returns early to avoid block editor subscription. 20826 if (isNoneOnly) { 20827 return [false, false, false]; 20828 } 20829 const settings = select(store).getSettings(); 20830 return [(_settings$alignWide = settings.alignWide) !== null && _settings$alignWide !== void 0 ? _settings$alignWide : false, settings.supportsLayout, settings.__unstableIsBlockBasedTheme]; 20831 }, [isNoneOnly]); 20832 const layout = useLayout(); 20833 if (isNoneOnly) { 20834 return use_available_alignments_EMPTY_ARRAY; 20835 } 20836 const layoutType = getLayoutType(layout?.type); 20837 if (themeSupportsLayout) { 20838 const layoutAlignments = layoutType.getAlignments(layout, isBlockBasedTheme); 20839 const alignments = layoutAlignments.filter(alignment => controls.includes(alignment.name)); 20840 // While we treat `none` as an alignment, we shouldn't return it if no 20841 // other alignments exist. 20842 if (alignments.length === 1 && alignments[0].name === 'none') { 20843 return use_available_alignments_EMPTY_ARRAY; 20844 } 20845 return alignments; 20846 } 20847 20848 // Starting here, it's the fallback for themes not supporting the layout config. 20849 if (layoutType.name !== 'default' && layoutType.name !== 'constrained') { 20850 return use_available_alignments_EMPTY_ARRAY; 20851 } 20852 const alignments = controls.filter(control => { 20853 if (layout.alignments) { 20854 return layout.alignments.includes(control); 20855 } 20856 if (!wideControlsEnabled && WIDE_CONTROLS.includes(control)) { 20857 return false; 20858 } 20859 return use_available_alignments_DEFAULT_CONTROLS.includes(control); 20860 }).map(name => ({ 20861 name 20862 })); 20863 20864 // While we treat `none` as an alignment, we shouldn't return it if no 20865 // other alignments exist. 20866 if (alignments.length === 1 && alignments[0].name === 'none') { 20867 return use_available_alignments_EMPTY_ARRAY; 20868 } 20869 return alignments; 20870 } 20871 20872 ;// ./node_modules/@wordpress/icons/build-module/library/position-left.js 20873 /** 20874 * WordPress dependencies 20875 */ 20876 20877 20878 const positionLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 20879 xmlns: "http://www.w3.org/2000/svg", 20880 viewBox: "0 0 24 24", 20881 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 20882 d: "M5 5.5h8V4H5v1.5ZM5 20h8v-1.5H5V20ZM19 9H5v6h14V9Z" 20883 }) 20884 }); 20885 /* harmony default export */ const position_left = (positionLeft); 20886 20887 ;// ./node_modules/@wordpress/icons/build-module/library/position-center.js 20888 /** 20889 * WordPress dependencies 20890 */ 20891 20892 20893 const positionCenter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 20894 xmlns: "http://www.w3.org/2000/svg", 20895 viewBox: "0 0 24 24", 20896 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 20897 d: "M19 5.5H5V4h14v1.5ZM19 20H5v-1.5h14V20ZM7 9h10v6H7V9Z" 20898 }) 20899 }); 20900 /* harmony default export */ const position_center = (positionCenter); 20901 20902 ;// ./node_modules/@wordpress/icons/build-module/library/position-right.js 20903 /** 20904 * WordPress dependencies 20905 */ 20906 20907 20908 const positionRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 20909 xmlns: "http://www.w3.org/2000/svg", 20910 viewBox: "0 0 24 24", 20911 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 20912 d: "M19 5.5h-8V4h8v1.5ZM19 20h-8v-1.5h8V20ZM5 9h14v6H5V9Z" 20913 }) 20914 }); 20915 /* harmony default export */ const position_right = (positionRight); 20916 20917 ;// ./node_modules/@wordpress/icons/build-module/library/stretch-full-width.js 20918 /** 20919 * WordPress dependencies 20920 */ 20921 20922 20923 const stretchFullWidth = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 20924 xmlns: "http://www.w3.org/2000/svg", 20925 viewBox: "0 0 24 24", 20926 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 20927 d: "M5 4h14v11H5V4Zm11 16H8v-1.5h8V20Z" 20928 }) 20929 }); 20930 /* harmony default export */ const stretch_full_width = (stretchFullWidth); 20931 20932 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-control/constants.js 20933 /** 20934 * WordPress dependencies 20935 */ 20936 20937 20938 const constants_BLOCK_ALIGNMENTS_CONTROLS = { 20939 none: { 20940 icon: align_none, 20941 title: (0,external_wp_i18n_namespaceObject._x)('None', 'Alignment option') 20942 }, 20943 left: { 20944 icon: position_left, 20945 title: (0,external_wp_i18n_namespaceObject.__)('Align left') 20946 }, 20947 center: { 20948 icon: position_center, 20949 title: (0,external_wp_i18n_namespaceObject.__)('Align center') 20950 }, 20951 right: { 20952 icon: position_right, 20953 title: (0,external_wp_i18n_namespaceObject.__)('Align right') 20954 }, 20955 wide: { 20956 icon: stretch_wide, 20957 title: (0,external_wp_i18n_namespaceObject.__)('Wide width') 20958 }, 20959 full: { 20960 icon: stretch_full_width, 20961 title: (0,external_wp_i18n_namespaceObject.__)('Full width') 20962 } 20963 }; 20964 const constants_DEFAULT_CONTROL = 'none'; 20965 20966 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-control/ui.js 20967 /** 20968 * External dependencies 20969 */ 20970 20971 20972 /** 20973 * WordPress dependencies 20974 */ 20975 20976 20977 20978 /** 20979 * Internal dependencies 20980 */ 20981 20982 20983 20984 20985 function BlockAlignmentUI({ 20986 value, 20987 onChange, 20988 controls, 20989 isToolbar, 20990 isCollapsed = true 20991 }) { 20992 const enabledControls = useAvailableAlignments(controls); 20993 const hasEnabledControls = !!enabledControls.length; 20994 if (!hasEnabledControls) { 20995 return null; 20996 } 20997 function onChangeAlignment(align) { 20998 onChange([value, 'none'].includes(align) ? undefined : align); 20999 } 21000 const activeAlignmentControl = constants_BLOCK_ALIGNMENTS_CONTROLS[value]; 21001 const defaultAlignmentControl = constants_BLOCK_ALIGNMENTS_CONTROLS[constants_DEFAULT_CONTROL]; 21002 const UIComponent = isToolbar ? external_wp_components_namespaceObject.ToolbarGroup : external_wp_components_namespaceObject.ToolbarDropdownMenu; 21003 const commonProps = { 21004 icon: activeAlignmentControl ? activeAlignmentControl.icon : defaultAlignmentControl.icon, 21005 label: (0,external_wp_i18n_namespaceObject.__)('Align') 21006 }; 21007 const extraProps = isToolbar ? { 21008 isCollapsed, 21009 controls: enabledControls.map(({ 21010 name: controlName 21011 }) => { 21012 return { 21013 ...constants_BLOCK_ALIGNMENTS_CONTROLS[controlName], 21014 isActive: value === controlName || !value && controlName === 'none', 21015 role: isCollapsed ? 'menuitemradio' : undefined, 21016 onClick: () => onChangeAlignment(controlName) 21017 }; 21018 }) 21019 } : { 21020 toggleProps: { 21021 description: (0,external_wp_i18n_namespaceObject.__)('Change alignment') 21022 }, 21023 children: ({ 21024 onClose 21025 }) => { 21026 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 21027 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, { 21028 className: "block-editor-block-alignment-control__menu-group", 21029 children: enabledControls.map(({ 21030 name: controlName, 21031 info 21032 }) => { 21033 const { 21034 icon, 21035 title 21036 } = constants_BLOCK_ALIGNMENTS_CONTROLS[controlName]; 21037 // If no value is provided, mark as selected the `none` option. 21038 const isSelected = controlName === value || !value && controlName === 'none'; 21039 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 21040 icon: icon, 21041 iconPosition: "left", 21042 className: dist_clsx('components-dropdown-menu__menu-item', { 21043 'is-active': isSelected 21044 }), 21045 isSelected: isSelected, 21046 onClick: () => { 21047 onChangeAlignment(controlName); 21048 onClose(); 21049 }, 21050 role: "menuitemradio", 21051 info: info, 21052 children: title 21053 }, controlName); 21054 }) 21055 }) 21056 }); 21057 } 21058 }; 21059 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UIComponent, { 21060 ...commonProps, 21061 ...extraProps 21062 }); 21063 } 21064 /* harmony default export */ const block_alignment_control_ui = (BlockAlignmentUI); 21065 21066 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-control/index.js 21067 /** 21068 * Internal dependencies 21069 */ 21070 21071 21072 const BlockAlignmentControl = props => { 21073 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_alignment_control_ui, { 21074 ...props, 21075 isToolbar: false 21076 }); 21077 }; 21078 const BlockAlignmentToolbar = props => { 21079 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_alignment_control_ui, { 21080 ...props, 21081 isToolbar: true 21082 }); 21083 }; 21084 21085 /** 21086 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-alignment-control/README.md 21087 */ 21088 21089 21090 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-editing-mode/index.js 21091 /** 21092 * WordPress dependencies 21093 */ 21094 21095 21096 21097 /** 21098 * Internal dependencies 21099 */ 21100 21101 21102 21103 /** 21104 * @typedef {'disabled'|'contentOnly'|'default'} BlockEditingMode 21105 */ 21106 21107 /** 21108 * Allows a block to restrict the user interface that is displayed for editing 21109 * that block and its inner blocks. 21110 * 21111 * @example 21112 * ```js 21113 * function MyBlock( { attributes, setAttributes } ) { 21114 * useBlockEditingMode( 'disabled' ); 21115 * return <div { ...useBlockProps() }></div>; 21116 * } 21117 * ``` 21118 * 21119 * `mode` can be one of three options: 21120 * 21121 * - `'disabled'`: Prevents editing the block entirely, i.e. it cannot be 21122 * selected. 21123 * - `'contentOnly'`: Hides all non-content UI, e.g. auxiliary controls in the 21124 * toolbar, the block movers, block settings. 21125 * - `'default'`: Allows editing the block as normal. 21126 * 21127 * The mode is inherited by all of the block's inner blocks, unless they have 21128 * their own mode. 21129 * 21130 * If called outside of a block context, the mode is applied to all blocks. 21131 * 21132 * @param {?BlockEditingMode} mode The editing mode to apply. If undefined, the 21133 * current editing mode is not changed. 21134 * 21135 * @return {BlockEditingMode} The current editing mode. 21136 */ 21137 function useBlockEditingMode(mode) { 21138 const context = useBlockEditContext(); 21139 const { 21140 clientId = '' 21141 } = context; 21142 const { 21143 setBlockEditingMode, 21144 unsetBlockEditingMode 21145 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 21146 const globalBlockEditingMode = (0,external_wp_data_namespaceObject.useSelect)(select => 21147 // Avoid adding the subscription if not needed! 21148 clientId ? null : select(store).getBlockEditingMode(), [clientId]); 21149 (0,external_wp_element_namespaceObject.useEffect)(() => { 21150 if (mode) { 21151 setBlockEditingMode(clientId, mode); 21152 } 21153 return () => { 21154 if (mode) { 21155 unsetBlockEditingMode(clientId); 21156 } 21157 }; 21158 }, [clientId, mode, setBlockEditingMode, unsetBlockEditingMode]); 21159 return clientId ? context[blockEditingModeKey] : globalBlockEditingMode; 21160 } 21161 21162 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/align.js 21163 /** 21164 * External dependencies 21165 */ 21166 21167 21168 /** 21169 * WordPress dependencies 21170 */ 21171 21172 21173 21174 /** 21175 * Internal dependencies 21176 */ 21177 21178 21179 21180 21181 /** 21182 * An array which includes all possible valid alignments, 21183 * used to validate if an alignment is valid or not. 21184 * 21185 * @constant 21186 * @type {string[]} 21187 */ 21188 21189 const ALL_ALIGNMENTS = ['left', 'center', 'right', 'wide', 'full']; 21190 21191 /** 21192 * An array which includes all wide alignments. 21193 * In order for this alignments to be valid they need to be supported by the block, 21194 * and by the theme. 21195 * 21196 * @constant 21197 * @type {string[]} 21198 */ 21199 const WIDE_ALIGNMENTS = ['wide', 'full']; 21200 21201 /** 21202 * Returns the valid alignments. 21203 * Takes into consideration the aligns supported by a block, if the block supports wide controls or not and if theme supports wide controls or not. 21204 * Exported just for testing purposes, not exported outside the module. 21205 * 21206 * @param {?boolean|string[]} blockAlign Aligns supported by the block. 21207 * @param {?boolean} hasWideBlockSupport True if block supports wide alignments. And False otherwise. 21208 * @param {?boolean} hasWideEnabled True if theme supports wide alignments. And False otherwise. 21209 * 21210 * @return {string[]} Valid alignments. 21211 */ 21212 function getValidAlignments(blockAlign, hasWideBlockSupport = true, hasWideEnabled = true) { 21213 let validAlignments; 21214 if (Array.isArray(blockAlign)) { 21215 validAlignments = ALL_ALIGNMENTS.filter(value => blockAlign.includes(value)); 21216 } else if (blockAlign === true) { 21217 // `true` includes all alignments... 21218 validAlignments = [...ALL_ALIGNMENTS]; 21219 } else { 21220 validAlignments = []; 21221 } 21222 if (!hasWideEnabled || blockAlign === true && !hasWideBlockSupport) { 21223 return validAlignments.filter(alignment => !WIDE_ALIGNMENTS.includes(alignment)); 21224 } 21225 return validAlignments; 21226 } 21227 21228 /** 21229 * Filters registered block settings, extending attributes to include `align`. 21230 * 21231 * @param {Object} settings Original block settings. 21232 * 21233 * @return {Object} Filtered block settings. 21234 */ 21235 function addAttribute(settings) { 21236 var _settings$attributes$; 21237 // Allow blocks to specify their own attribute definition with default values if needed. 21238 if ('type' in ((_settings$attributes$ = settings.attributes?.align) !== null && _settings$attributes$ !== void 0 ? _settings$attributes$ : {})) { 21239 return settings; 21240 } 21241 if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'align')) { 21242 // Gracefully handle if settings.attributes is undefined. 21243 settings.attributes = { 21244 ...settings.attributes, 21245 align: { 21246 type: 'string', 21247 // Allow for '' since it is used by the `updateAlignment` function 21248 // in toolbar controls for special cases with defined default values. 21249 enum: [...ALL_ALIGNMENTS, ''] 21250 } 21251 }; 21252 } 21253 return settings; 21254 } 21255 function BlockEditAlignmentToolbarControlsPure({ 21256 name: blockName, 21257 align, 21258 setAttributes 21259 }) { 21260 // Compute the block valid alignments by taking into account, 21261 // if the theme supports wide alignments or not and the layout's 21262 // available alignments. We do that for conditionally rendering 21263 // Slot. 21264 const blockAllowedAlignments = getValidAlignments((0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, 'align'), (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, 'alignWide', true)); 21265 const validAlignments = useAvailableAlignments(blockAllowedAlignments).map(({ 21266 name 21267 }) => name); 21268 const blockEditingMode = useBlockEditingMode(); 21269 if (!validAlignments.length || blockEditingMode !== 'default') { 21270 return null; 21271 } 21272 const updateAlignment = nextAlign => { 21273 if (!nextAlign) { 21274 const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName); 21275 const blockDefaultAlign = blockType?.attributes?.align?.default; 21276 if (blockDefaultAlign) { 21277 nextAlign = ''; 21278 } 21279 } 21280 setAttributes({ 21281 align: nextAlign 21282 }); 21283 }; 21284 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, { 21285 group: "block", 21286 __experimentalShareWithChildBlocks: true, 21287 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockAlignmentControl, { 21288 value: align, 21289 onChange: updateAlignment, 21290 controls: validAlignments 21291 }) 21292 }); 21293 } 21294 /* harmony default export */ const align = ({ 21295 shareWithChildBlocks: true, 21296 edit: BlockEditAlignmentToolbarControlsPure, 21297 useBlockProps, 21298 addSaveProps: addAssignedAlign, 21299 attributeKeys: ['align'], 21300 hasSupport(name) { 21301 return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'align', false); 21302 } 21303 }); 21304 function useBlockProps({ 21305 name, 21306 align 21307 }) { 21308 const blockAllowedAlignments = getValidAlignments((0,external_wp_blocks_namespaceObject.getBlockSupport)(name, 'align'), (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'alignWide', true)); 21309 const validAlignments = useAvailableAlignments(blockAllowedAlignments); 21310 if (validAlignments.some(alignment => alignment.name === align)) { 21311 return { 21312 'data-align': align 21313 }; 21314 } 21315 return {}; 21316 } 21317 21318 /** 21319 * Override props assigned to save component to inject alignment class name if 21320 * block supports it. 21321 * 21322 * @param {Object} props Additional props applied to save element. 21323 * @param {Object} blockType Block type. 21324 * @param {Object} attributes Block attributes. 21325 * 21326 * @return {Object} Filtered props applied to save element. 21327 */ 21328 function addAssignedAlign(props, blockType, attributes) { 21329 const { 21330 align 21331 } = attributes; 21332 const blockAlign = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, 'align'); 21333 const hasWideBlockSupport = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'alignWide', true); 21334 21335 // Compute valid alignments without taking into account if 21336 // the theme supports wide alignments or not. 21337 // This way changing themes does not impact the block save. 21338 const isAlignValid = getValidAlignments(blockAlign, hasWideBlockSupport).includes(align); 21339 if (isAlignValid) { 21340 props.className = dist_clsx(`align$align}`, props.className); 21341 } 21342 return props; 21343 } 21344 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/editor/align/addAttribute', addAttribute); 21345 21346 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/groups.js 21347 /** 21348 * WordPress dependencies 21349 */ 21350 21351 const InspectorControlsDefault = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControls'); 21352 const InspectorControlsAdvanced = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorAdvancedControls'); 21353 const InspectorControlsBindings = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsBindings'); 21354 const InspectorControlsBackground = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsBackground'); 21355 const InspectorControlsBorder = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsBorder'); 21356 const InspectorControlsColor = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsColor'); 21357 const InspectorControlsFilter = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsFilter'); 21358 const InspectorControlsDimensions = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsDimensions'); 21359 const InspectorControlsPosition = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsPosition'); 21360 const InspectorControlsTypography = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsTypography'); 21361 const InspectorControlsListView = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsListView'); 21362 const InspectorControlsStyles = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsStyles'); 21363 const InspectorControlsEffects = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsEffects'); 21364 const groups_groups = { 21365 default: InspectorControlsDefault, 21366 advanced: InspectorControlsAdvanced, 21367 background: InspectorControlsBackground, 21368 bindings: InspectorControlsBindings, 21369 border: InspectorControlsBorder, 21370 color: InspectorControlsColor, 21371 dimensions: InspectorControlsDimensions, 21372 effects: InspectorControlsEffects, 21373 filter: InspectorControlsFilter, 21374 list: InspectorControlsListView, 21375 position: InspectorControlsPosition, 21376 settings: InspectorControlsDefault, 21377 // Alias for default. 21378 styles: InspectorControlsStyles, 21379 typography: InspectorControlsTypography 21380 }; 21381 /* harmony default export */ const inspector_controls_groups = (groups_groups); 21382 21383 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/fill.js 21384 /** 21385 * WordPress dependencies 21386 */ 21387 21388 21389 21390 21391 21392 /** 21393 * Internal dependencies 21394 */ 21395 21396 21397 21398 function InspectorControlsFill({ 21399 children, 21400 group = 'default', 21401 __experimentalGroup, 21402 resetAllFilter 21403 }) { 21404 if (__experimentalGroup) { 21405 external_wp_deprecated_default()('`__experimentalGroup` property in `InspectorControlsFill`', { 21406 since: '6.2', 21407 version: '6.4', 21408 alternative: '`group`' 21409 }); 21410 group = __experimentalGroup; 21411 } 21412 const context = useBlockEditContext(); 21413 const Fill = inspector_controls_groups[group]?.Fill; 21414 if (!Fill) { 21415 true ? external_wp_warning_default()(`Unknown InspectorControls group "$group}" provided.`) : 0; 21416 return null; 21417 } 21418 if (!context[mayDisplayControlsKey]) { 21419 return null; 21420 } 21421 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalStyleProvider, { 21422 document: document, 21423 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Fill, { 21424 children: fillProps => { 21425 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ToolsPanelInspectorControl, { 21426 fillProps: fillProps, 21427 children: children, 21428 resetAllFilter: resetAllFilter 21429 }); 21430 } 21431 }) 21432 }); 21433 } 21434 function RegisterResetAll({ 21435 resetAllFilter, 21436 children 21437 }) { 21438 const { 21439 registerResetAllFilter, 21440 deregisterResetAllFilter 21441 } = (0,external_wp_element_namespaceObject.useContext)(external_wp_components_namespaceObject.__experimentalToolsPanelContext); 21442 (0,external_wp_element_namespaceObject.useEffect)(() => { 21443 if (resetAllFilter && registerResetAllFilter && deregisterResetAllFilter) { 21444 registerResetAllFilter(resetAllFilter); 21445 return () => { 21446 deregisterResetAllFilter(resetAllFilter); 21447 }; 21448 } 21449 }, [resetAllFilter, registerResetAllFilter, deregisterResetAllFilter]); 21450 return children; 21451 } 21452 function ToolsPanelInspectorControl({ 21453 children, 21454 resetAllFilter, 21455 fillProps 21456 }) { 21457 // `fillProps.forwardedContext` is an array of context provider entries, provided by slot, 21458 // that should wrap the fill markup. 21459 const { 21460 forwardedContext = [] 21461 } = fillProps; 21462 21463 // Children passed to InspectorControlsFill will not have 21464 // access to any React Context whose Provider is part of 21465 // the InspectorControlsSlot tree. So we re-create the 21466 // Provider in this subtree. 21467 const innerMarkup = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RegisterResetAll, { 21468 resetAllFilter: resetAllFilter, 21469 children: children 21470 }); 21471 return forwardedContext.reduce((inner, [Provider, props]) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Provider, { 21472 ...props, 21473 children: inner 21474 }), innerMarkup); 21475 } 21476 21477 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/block-support-tools-panel.js 21478 /** 21479 * WordPress dependencies 21480 */ 21481 21482 21483 21484 21485 /** 21486 * Internal dependencies 21487 */ 21488 21489 21490 21491 21492 function BlockSupportToolsPanel({ 21493 children, 21494 group, 21495 label 21496 }) { 21497 const { 21498 updateBlockAttributes 21499 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 21500 const { 21501 getBlockAttributes, 21502 getMultiSelectedBlockClientIds, 21503 getSelectedBlockClientId, 21504 hasMultiSelection 21505 } = (0,external_wp_data_namespaceObject.useSelect)(store); 21506 const dropdownMenuProps = useToolsPanelDropdownMenuProps(); 21507 const panelId = getSelectedBlockClientId(); 21508 const resetAll = (0,external_wp_element_namespaceObject.useCallback)((resetFilters = []) => { 21509 const newAttributes = {}; 21510 const clientIds = hasMultiSelection() ? getMultiSelectedBlockClientIds() : [panelId]; 21511 clientIds.forEach(clientId => { 21512 const { 21513 style 21514 } = getBlockAttributes(clientId); 21515 let newBlockAttributes = { 21516 style 21517 }; 21518 resetFilters.forEach(resetFilter => { 21519 newBlockAttributes = { 21520 ...newBlockAttributes, 21521 ...resetFilter(newBlockAttributes) 21522 }; 21523 }); 21524 21525 // Enforce a cleaned style object. 21526 newBlockAttributes = { 21527 ...newBlockAttributes, 21528 style: utils_cleanEmptyObject(newBlockAttributes.style) 21529 }; 21530 newAttributes[clientId] = newBlockAttributes; 21531 }); 21532 updateBlockAttributes(clientIds, newAttributes, true); 21533 }, [getBlockAttributes, getMultiSelectedBlockClientIds, hasMultiSelection, panelId, updateBlockAttributes]); 21534 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, { 21535 className: `$group}-block-support-panel`, 21536 label: label, 21537 resetAll: resetAll, 21538 panelId: panelId, 21539 hasInnerWrapper: true, 21540 shouldRenderPlaceholderItems: true // Required to maintain fills ordering. 21541 , 21542 __experimentalFirstVisibleItemClass: "first", 21543 __experimentalLastVisibleItemClass: "last", 21544 dropdownMenuProps: dropdownMenuProps, 21545 children: children 21546 }, panelId); 21547 } 21548 21549 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/block-support-slot-container.js 21550 /** 21551 * WordPress dependencies 21552 */ 21553 21554 21555 21556 function BlockSupportSlotContainer({ 21557 Slot, 21558 fillProps, 21559 ...props 21560 }) { 21561 // Add the toolspanel context provider and value to existing fill props 21562 const toolsPanelContext = (0,external_wp_element_namespaceObject.useContext)(external_wp_components_namespaceObject.__experimentalToolsPanelContext); 21563 const computedFillProps = (0,external_wp_element_namespaceObject.useMemo)(() => { 21564 var _fillProps$forwardedC; 21565 return { 21566 ...(fillProps !== null && fillProps !== void 0 ? fillProps : {}), 21567 forwardedContext: [...((_fillProps$forwardedC = fillProps?.forwardedContext) !== null && _fillProps$forwardedC !== void 0 ? _fillProps$forwardedC : []), [external_wp_components_namespaceObject.__experimentalToolsPanelContext.Provider, { 21568 value: toolsPanelContext 21569 }]] 21570 }; 21571 }, [toolsPanelContext, fillProps]); 21572 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Slot, { 21573 ...props, 21574 fillProps: computedFillProps, 21575 bubblesVirtually: true 21576 }); 21577 } 21578 21579 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/slot.js 21580 /** 21581 * WordPress dependencies 21582 */ 21583 21584 21585 21586 21587 21588 /** 21589 * Internal dependencies 21590 */ 21591 21592 21593 21594 21595 function InspectorControlsSlot({ 21596 __experimentalGroup, 21597 group = 'default', 21598 label, 21599 fillProps, 21600 ...props 21601 }) { 21602 if (__experimentalGroup) { 21603 external_wp_deprecated_default()('`__experimentalGroup` property in `InspectorControlsSlot`', { 21604 since: '6.2', 21605 version: '6.4', 21606 alternative: '`group`' 21607 }); 21608 group = __experimentalGroup; 21609 } 21610 const Slot = inspector_controls_groups[group]?.Slot; 21611 const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(Slot?.__unstableName); 21612 const motionContextValue = (0,external_wp_element_namespaceObject.useContext)(external_wp_components_namespaceObject.__unstableMotionContext); 21613 const computedFillProps = (0,external_wp_element_namespaceObject.useMemo)(() => { 21614 var _fillProps$forwardedC; 21615 return { 21616 ...(fillProps !== null && fillProps !== void 0 ? fillProps : {}), 21617 forwardedContext: [...((_fillProps$forwardedC = fillProps?.forwardedContext) !== null && _fillProps$forwardedC !== void 0 ? _fillProps$forwardedC : []), [external_wp_components_namespaceObject.__unstableMotionContext.Provider, { 21618 value: motionContextValue 21619 }]] 21620 }; 21621 }, [motionContextValue, fillProps]); 21622 if (!Slot) { 21623 true ? external_wp_warning_default()(`Unknown InspectorControls group "$group}" provided.`) : 0; 21624 return null; 21625 } 21626 if (!fills?.length) { 21627 return null; 21628 } 21629 if (label) { 21630 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockSupportToolsPanel, { 21631 group: group, 21632 label: label, 21633 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockSupportSlotContainer, { 21634 ...props, 21635 fillProps: computedFillProps, 21636 Slot: Slot 21637 }) 21638 }); 21639 } 21640 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Slot, { 21641 ...props, 21642 fillProps: computedFillProps, 21643 bubblesVirtually: true 21644 }); 21645 } 21646 21647 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/index.js 21648 /** 21649 * Internal dependencies 21650 */ 21651 21652 21653 21654 const InspectorControls = InspectorControlsFill; 21655 InspectorControls.Slot = InspectorControlsSlot; 21656 21657 // This is just here for backward compatibility. 21658 const InspectorAdvancedControls = props => { 21659 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorControlsFill, { 21660 ...props, 21661 group: "advanced" 21662 }); 21663 }; 21664 InspectorAdvancedControls.Slot = props => { 21665 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorControlsSlot, { 21666 ...props, 21667 group: "advanced" 21668 }); 21669 }; 21670 InspectorAdvancedControls.slotName = 'InspectorAdvancedControls'; 21671 21672 /** 21673 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/inspector-controls/README.md 21674 */ 21675 /* harmony default export */ const inspector_controls = (InspectorControls); 21676 21677 ;// external ["wp","url"] 21678 const external_wp_url_namespaceObject = window["wp"]["url"]; 21679 ;// external ["wp","dom"] 21680 const external_wp_dom_namespaceObject = window["wp"]["dom"]; 21681 ;// external ["wp","blob"] 21682 const external_wp_blob_namespaceObject = window["wp"]["blob"]; 21683 ;// external ["wp","keycodes"] 21684 const external_wp_keycodes_namespaceObject = window["wp"]["keycodes"]; 21685 ;// ./node_modules/@wordpress/icons/build-module/library/media.js 21686 /** 21687 * WordPress dependencies 21688 */ 21689 21690 21691 21692 const media = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, { 21693 xmlns: "http://www.w3.org/2000/svg", 21694 viewBox: "0 0 24 24", 21695 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 21696 d: "m7 6.5 4 2.5-4 2.5z" 21697 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 21698 fillRule: "evenodd", 21699 clipRule: "evenodd", 21700 d: "m5 3c-1.10457 0-2 .89543-2 2v14c0 1.1046.89543 2 2 2h14c1.1046 0 2-.8954 2-2v-14c0-1.10457-.8954-2-2-2zm14 1.5h-14c-.27614 0-.5.22386-.5.5v10.7072l3.62953-2.6465c.25108-.1831.58905-.1924.84981-.0234l2.92666 1.8969 3.5712-3.4719c.2911-.2831.7545-.2831 1.0456 0l2.9772 2.8945v-9.3568c0-.27614-.2239-.5-.5-.5zm-14.5 14.5v-1.4364l4.09643-2.987 2.99567 1.9417c.2936.1903.6798.1523.9307-.0917l3.4772-3.3806 3.4772 3.3806.0228-.0234v2.5968c0 .2761-.2239.5-.5.5h-14c-.27614 0-.5-.2239-.5-.5z" 21701 })] 21702 }); 21703 /* harmony default export */ const library_media = (media); 21704 21705 ;// ./node_modules/@wordpress/icons/build-module/library/upload.js 21706 /** 21707 * WordPress dependencies 21708 */ 21709 21710 21711 const upload = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 21712 xmlns: "http://www.w3.org/2000/svg", 21713 viewBox: "0 0 24 24", 21714 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 21715 d: "M18.5 15v3.5H13V6.7l4.5 4.1 1-1.1-6.2-5.8-5.8 5.8 1 1.1 4-4v11.7h-6V15H4v5h16v-5z" 21716 }) 21717 }); 21718 /* harmony default export */ const library_upload = (upload); 21719 21720 ;// ./node_modules/@wordpress/icons/build-module/library/post-featured-image.js 21721 /** 21722 * WordPress dependencies 21723 */ 21724 21725 21726 const postFeaturedImage = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 21727 xmlns: "http://www.w3.org/2000/svg", 21728 viewBox: "0 0 24 24", 21729 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 21730 d: "M19 3H5c-.6 0-1 .4-1 1v7c0 .5.4 1 1 1h14c.5 0 1-.4 1-1V4c0-.6-.4-1-1-1zM5.5 10.5v-.4l1.8-1.3 1.3.8c.3.2.7.2.9-.1L11 8.1l2.4 2.4H5.5zm13 0h-2.9l-4-4c-.3-.3-.8-.3-1.1 0L8.9 8l-1.2-.8c-.3-.2-.6-.2-.9 0l-1.3 1V4.5h13v6zM4 20h9v-1.5H4V20zm0-4h16v-1.5H4V16z" 21731 }) 21732 }); 21733 /* harmony default export */ const post_featured_image = (postFeaturedImage); 21734 21735 ;// ./node_modules/@wordpress/block-editor/build-module/components/media-upload/index.js 21736 /** 21737 * WordPress dependencies 21738 */ 21739 21740 21741 /** 21742 * This is a placeholder for the media upload component necessary to make it possible to provide 21743 * an integration with the core blocks that handle media files. By default it renders nothing but 21744 * it provides a way to have it overridden with the `editor.MediaUpload` filter. 21745 * 21746 * @return {Component} The component to be rendered. 21747 */ 21748 const MediaUpload = () => null; 21749 21750 /** 21751 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/media-upload/README.md 21752 */ 21753 /* harmony default export */ const media_upload = ((0,external_wp_components_namespaceObject.withFilters)('editor.MediaUpload')(MediaUpload)); 21754 21755 ;// ./node_modules/@wordpress/block-editor/build-module/components/media-upload/check.js 21756 /** 21757 * WordPress dependencies 21758 */ 21759 21760 21761 /** 21762 * Internal dependencies 21763 */ 21764 21765 function MediaUploadCheck({ 21766 fallback = null, 21767 children 21768 }) { 21769 const hasUploadPermissions = (0,external_wp_data_namespaceObject.useSelect)(select => { 21770 const { 21771 getSettings 21772 } = select(store); 21773 return !!getSettings().mediaUpload; 21774 }, []); 21775 return hasUploadPermissions ? children : fallback; 21776 } 21777 21778 /** 21779 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/media-upload/README.md 21780 */ 21781 /* harmony default export */ const check = (MediaUploadCheck); 21782 21783 ;// external ["wp","isShallowEqual"] 21784 const external_wp_isShallowEqual_namespaceObject = window["wp"]["isShallowEqual"]; 21785 var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_namespaceObject); 21786 ;// external ["wp","preferences"] 21787 const external_wp_preferences_namespaceObject = window["wp"]["preferences"]; 21788 ;// ./node_modules/@wordpress/icons/build-module/library/keyboard-return.js 21789 /** 21790 * WordPress dependencies 21791 */ 21792 21793 21794 const keyboardReturn = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 21795 xmlns: "http://www.w3.org/2000/svg", 21796 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 21797 d: "m6.734 16.106 2.176-2.38-1.093-1.028-3.846 4.158 3.846 4.158 1.093-1.028-2.176-2.38h2.811c1.125 0 2.25.03 3.374 0 1.428-.001 3.362-.25 4.963-1.277 1.66-1.065 2.868-2.906 2.868-5.859 0-2.479-1.327-4.896-3.65-5.93-1.82-.813-3.044-.8-4.806-.788l-.567.002v1.5c.184 0 .368 0 .553-.002 1.82-.007 2.704-.014 4.21.657 1.854.827 2.76 2.657 2.76 4.561 0 2.472-.973 3.824-2.178 4.596-1.258.807-2.864 1.04-4.163 1.04h-.02c-1.115.03-2.229 0-3.344 0H6.734Z" 21798 }) 21799 }); 21800 /* harmony default export */ const keyboard_return = (keyboardReturn); 21801 21802 ;// ./node_modules/@wordpress/icons/build-module/library/chevron-left-small.js 21803 /** 21804 * WordPress dependencies 21805 */ 21806 21807 21808 const chevronLeftSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 21809 xmlns: "http://www.w3.org/2000/svg", 21810 viewBox: "0 0 24 24", 21811 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 21812 d: "m13.1 16-3.4-4 3.4-4 1.1 1-2.6 3 2.6 3-1.1 1z" 21813 }) 21814 }); 21815 /* harmony default export */ const chevron_left_small = (chevronLeftSmall); 21816 21817 ;// ./node_modules/@wordpress/icons/build-module/library/chevron-right-small.js 21818 /** 21819 * WordPress dependencies 21820 */ 21821 21822 21823 const chevronRightSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 21824 xmlns: "http://www.w3.org/2000/svg", 21825 viewBox: "0 0 24 24", 21826 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 21827 d: "M10.8622 8.04053L14.2805 12.0286L10.8622 16.0167L9.72327 15.0405L12.3049 12.0286L9.72327 9.01672L10.8622 8.04053Z" 21828 }) 21829 }); 21830 /* harmony default export */ const chevron_right_small = (chevronRightSmall); 21831 21832 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/settings-drawer.js 21833 /** 21834 * WordPress dependencies 21835 */ 21836 21837 21838 21839 21840 21841 21842 21843 21844 function LinkSettingsDrawer({ 21845 children, 21846 settingsOpen, 21847 setSettingsOpen 21848 }) { 21849 const prefersReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)(); 21850 const MaybeAnimatePresence = prefersReducedMotion ? external_wp_element_namespaceObject.Fragment : external_wp_components_namespaceObject.__unstableAnimatePresence; 21851 const MaybeMotionDiv = prefersReducedMotion ? 'div' : external_wp_components_namespaceObject.__unstableMotion.div; 21852 const id = (0,external_wp_compose_namespaceObject.useInstanceId)(LinkSettingsDrawer); 21853 const settingsDrawerId = `link-control-settings-drawer-$id}`; 21854 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 21855 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 21856 __next40pxDefaultSize: true, 21857 className: "block-editor-link-control__drawer-toggle", 21858 "aria-expanded": settingsOpen, 21859 onClick: () => setSettingsOpen(!settingsOpen), 21860 icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left_small : chevron_right_small, 21861 "aria-controls": settingsDrawerId, 21862 children: (0,external_wp_i18n_namespaceObject._x)('Advanced', 'Additional link settings') 21863 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MaybeAnimatePresence, { 21864 children: settingsOpen && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MaybeMotionDiv, { 21865 className: "block-editor-link-control__drawer", 21866 hidden: !settingsOpen, 21867 id: settingsDrawerId, 21868 initial: "collapsed", 21869 animate: "open", 21870 exit: "collapsed", 21871 variants: { 21872 open: { 21873 opacity: 1, 21874 height: 'auto' 21875 }, 21876 collapsed: { 21877 opacity: 0, 21878 height: 0 21879 } 21880 }, 21881 transition: { 21882 duration: 0.1 21883 }, 21884 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 21885 className: "block-editor-link-control__drawer-inner", 21886 children: children 21887 }) 21888 }) 21889 })] 21890 }); 21891 } 21892 /* harmony default export */ const settings_drawer = (LinkSettingsDrawer); 21893 21894 // EXTERNAL MODULE: external "React" 21895 var external_React_ = __webpack_require__(1609); 21896 ;// ./node_modules/@wordpress/block-editor/build-module/components/url-input/index.js 21897 /** 21898 * External dependencies 21899 */ 21900 21901 21902 /** 21903 * WordPress dependencies 21904 */ 21905 21906 21907 21908 21909 21910 21911 21912 21913 /** 21914 * Internal dependencies 21915 */ 21916 21917 21918 /** 21919 * Whether the argument is a function. 21920 * 21921 * @param {*} maybeFunc The argument to check. 21922 * @return {boolean} True if the argument is a function, false otherwise. 21923 */ 21924 21925 21926 21927 21928 function isFunction(maybeFunc) { 21929 return typeof maybeFunc === 'function'; 21930 } 21931 class URLInput extends external_wp_element_namespaceObject.Component { 21932 constructor(props) { 21933 super(props); 21934 this.onChange = this.onChange.bind(this); 21935 this.onFocus = this.onFocus.bind(this); 21936 this.onKeyDown = this.onKeyDown.bind(this); 21937 this.selectLink = this.selectLink.bind(this); 21938 this.handleOnClick = this.handleOnClick.bind(this); 21939 this.bindSuggestionNode = this.bindSuggestionNode.bind(this); 21940 this.autocompleteRef = props.autocompleteRef || (0,external_wp_element_namespaceObject.createRef)(); 21941 this.inputRef = (0,external_wp_element_namespaceObject.createRef)(); 21942 this.updateSuggestions = (0,external_wp_compose_namespaceObject.debounce)(this.updateSuggestions.bind(this), 200); 21943 this.suggestionNodes = []; 21944 this.suggestionsRequest = null; 21945 this.state = { 21946 suggestions: [], 21947 showSuggestions: false, 21948 suggestionsValue: null, 21949 selectedSuggestion: null, 21950 suggestionsListboxId: '', 21951 suggestionOptionIdPrefix: '' 21952 }; 21953 } 21954 componentDidUpdate(prevProps) { 21955 const { 21956 showSuggestions, 21957 selectedSuggestion 21958 } = this.state; 21959 const { 21960 value, 21961 __experimentalShowInitialSuggestions = false 21962 } = this.props; 21963 21964 // Only have to worry about scrolling selected suggestion into view 21965 // when already expanded. 21966 if (showSuggestions && selectedSuggestion !== null && this.suggestionNodes[selectedSuggestion]) { 21967 this.suggestionNodes[selectedSuggestion].scrollIntoView({ 21968 behavior: 'instant', 21969 block: 'nearest', 21970 inline: 'nearest' 21971 }); 21972 } 21973 21974 // Update suggestions when the value changes. 21975 if (prevProps.value !== value && !this.props.disableSuggestions) { 21976 if (value?.length) { 21977 // If the new value is not empty we need to update with suggestions for it. 21978 this.updateSuggestions(value); 21979 } else if (__experimentalShowInitialSuggestions) { 21980 // If the new value is empty and we can show initial suggestions, then show initial suggestions. 21981 this.updateSuggestions(); 21982 } 21983 } 21984 } 21985 componentDidMount() { 21986 if (this.shouldShowInitialSuggestions()) { 21987 this.updateSuggestions(); 21988 } 21989 } 21990 componentWillUnmount() { 21991 this.suggestionsRequest?.cancel?.(); 21992 this.suggestionsRequest = null; 21993 } 21994 bindSuggestionNode(index) { 21995 return ref => { 21996 this.suggestionNodes[index] = ref; 21997 }; 21998 } 21999 shouldShowInitialSuggestions() { 22000 const { 22001 __experimentalShowInitialSuggestions = false, 22002 value 22003 } = this.props; 22004 return __experimentalShowInitialSuggestions && !(value && value.length); 22005 } 22006 updateSuggestions(value = '') { 22007 const { 22008 __experimentalFetchLinkSuggestions: fetchLinkSuggestions, 22009 __experimentalHandleURLSuggestions: handleURLSuggestions 22010 } = this.props; 22011 if (!fetchLinkSuggestions) { 22012 return; 22013 } 22014 22015 // Initial suggestions may only show if there is no value 22016 // (note: this includes whitespace). 22017 const isInitialSuggestions = !value?.length; 22018 22019 // Trim only now we've determined whether or not it originally had a "length" 22020 // (even if that value was all whitespace). 22021 value = value.trim(); 22022 22023 // Allow a suggestions request if: 22024 // - there are at least 2 characters in the search input (except manual searches where 22025 // search input length is not required to trigger a fetch) 22026 // - this is a direct entry (eg: a URL) 22027 if (!isInitialSuggestions && (value.length < 2 || !handleURLSuggestions && (0,external_wp_url_namespaceObject.isURL)(value))) { 22028 this.suggestionsRequest?.cancel?.(); 22029 this.suggestionsRequest = null; 22030 this.setState({ 22031 suggestions: [], 22032 showSuggestions: false, 22033 suggestionsValue: value, 22034 selectedSuggestion: null, 22035 loading: false 22036 }); 22037 return; 22038 } 22039 this.setState({ 22040 selectedSuggestion: null, 22041 loading: true 22042 }); 22043 const request = fetchLinkSuggestions(value, { 22044 isInitialSuggestions 22045 }); 22046 request.then(suggestions => { 22047 // A fetch Promise doesn't have an abort option. It's mimicked by 22048 // comparing the request reference in on the instance, which is 22049 // reset or deleted on subsequent requests or unmounting. 22050 if (this.suggestionsRequest !== request) { 22051 return; 22052 } 22053 this.setState({ 22054 suggestions, 22055 suggestionsValue: value, 22056 loading: false, 22057 showSuggestions: !!suggestions.length 22058 }); 22059 if (!!suggestions.length) { 22060 this.props.debouncedSpeak((0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %d: number of results. */ 22061 (0,external_wp_i18n_namespaceObject._n)('%d result found, use up and down arrow keys to navigate.', '%d results found, use up and down arrow keys to navigate.', suggestions.length), suggestions.length), 'assertive'); 22062 } else { 22063 this.props.debouncedSpeak((0,external_wp_i18n_namespaceObject.__)('No results.'), 'assertive'); 22064 } 22065 }).catch(() => { 22066 if (this.suggestionsRequest !== request) { 22067 return; 22068 } 22069 this.setState({ 22070 loading: false 22071 }); 22072 }).finally(() => { 22073 // If this is the current promise then reset the reference 22074 // to allow for checking if a new request is made. 22075 if (this.suggestionsRequest === request) { 22076 this.suggestionsRequest = null; 22077 } 22078 }); 22079 22080 // Note that this assignment is handled *before* the async search request 22081 // as a Promise always resolves on the next tick of the event loop. 22082 this.suggestionsRequest = request; 22083 } 22084 onChange(newValue) { 22085 this.props.onChange(newValue); 22086 } 22087 onFocus() { 22088 const { 22089 suggestions 22090 } = this.state; 22091 const { 22092 disableSuggestions, 22093 value 22094 } = this.props; 22095 22096 // When opening the link editor, if there's a value present, we want to load the suggestions pane with the results for this input search value 22097 // Don't re-run the suggestions on focus if there are already suggestions present (prevents searching again when tabbing between the input and buttons) 22098 // or there is already a request in progress. 22099 if (value && !disableSuggestions && !(suggestions && suggestions.length) && this.suggestionsRequest === null) { 22100 // Ensure the suggestions are updated with the current input value. 22101 this.updateSuggestions(value); 22102 } 22103 } 22104 onKeyDown(event) { 22105 this.props.onKeyDown?.(event); 22106 const { 22107 showSuggestions, 22108 selectedSuggestion, 22109 suggestions, 22110 loading 22111 } = this.state; 22112 22113 // If the suggestions are not shown or loading, we shouldn't handle the arrow keys 22114 // We shouldn't preventDefault to allow block arrow keys navigation. 22115 if (!showSuggestions || !suggestions.length || loading) { 22116 // In the Windows version of Firefox the up and down arrows don't move the caret 22117 // within an input field like they do for Mac Firefox/Chrome/Safari. This causes 22118 // a form of focus trapping that is disruptive to the user experience. This disruption 22119 // only happens if the caret is not in the first or last position in the text input. 22120 // See: https://github.com/WordPress/gutenberg/issues/5693#issuecomment-436684747 22121 switch (event.keyCode) { 22122 // When UP is pressed, if the caret is at the start of the text, move it to the 0 22123 // position. 22124 case external_wp_keycodes_namespaceObject.UP: 22125 { 22126 if (0 !== event.target.selectionStart) { 22127 event.preventDefault(); 22128 22129 // Set the input caret to position 0. 22130 event.target.setSelectionRange(0, 0); 22131 } 22132 break; 22133 } 22134 // When DOWN is pressed, if the caret is not at the end of the text, move it to the 22135 // last position. 22136 case external_wp_keycodes_namespaceObject.DOWN: 22137 { 22138 if (this.props.value.length !== event.target.selectionStart) { 22139 event.preventDefault(); 22140 22141 // Set the input caret to the last position. 22142 event.target.setSelectionRange(this.props.value.length, this.props.value.length); 22143 } 22144 break; 22145 } 22146 22147 // Submitting while loading should trigger onSubmit. 22148 case external_wp_keycodes_namespaceObject.ENTER: 22149 { 22150 if (this.props.onSubmit) { 22151 event.preventDefault(); 22152 this.props.onSubmit(null, event); 22153 } 22154 break; 22155 } 22156 } 22157 return; 22158 } 22159 const suggestion = this.state.suggestions[this.state.selectedSuggestion]; 22160 switch (event.keyCode) { 22161 case external_wp_keycodes_namespaceObject.UP: 22162 { 22163 event.preventDefault(); 22164 const previousIndex = !selectedSuggestion ? suggestions.length - 1 : selectedSuggestion - 1; 22165 this.setState({ 22166 selectedSuggestion: previousIndex 22167 }); 22168 break; 22169 } 22170 case external_wp_keycodes_namespaceObject.DOWN: 22171 { 22172 event.preventDefault(); 22173 const nextIndex = selectedSuggestion === null || selectedSuggestion === suggestions.length - 1 ? 0 : selectedSuggestion + 1; 22174 this.setState({ 22175 selectedSuggestion: nextIndex 22176 }); 22177 break; 22178 } 22179 case external_wp_keycodes_namespaceObject.TAB: 22180 { 22181 if (this.state.selectedSuggestion !== null) { 22182 this.selectLink(suggestion); 22183 // Announce a link has been selected when tabbing away from the input field. 22184 this.props.speak((0,external_wp_i18n_namespaceObject.__)('Link selected.')); 22185 } 22186 break; 22187 } 22188 case external_wp_keycodes_namespaceObject.ENTER: 22189 { 22190 event.preventDefault(); 22191 if (this.state.selectedSuggestion !== null) { 22192 this.selectLink(suggestion); 22193 if (this.props.onSubmit) { 22194 this.props.onSubmit(suggestion, event); 22195 } 22196 } else if (this.props.onSubmit) { 22197 this.props.onSubmit(null, event); 22198 } 22199 break; 22200 } 22201 } 22202 } 22203 selectLink(suggestion) { 22204 this.props.onChange(suggestion.url, suggestion); 22205 this.setState({ 22206 selectedSuggestion: null, 22207 showSuggestions: false 22208 }); 22209 } 22210 handleOnClick(suggestion) { 22211 this.selectLink(suggestion); 22212 // Move focus to the input field when a link suggestion is clicked. 22213 this.inputRef.current.focus(); 22214 } 22215 static getDerivedStateFromProps({ 22216 value, 22217 instanceId, 22218 disableSuggestions, 22219 __experimentalShowInitialSuggestions = false 22220 }, { 22221 showSuggestions 22222 }) { 22223 let shouldShowSuggestions = showSuggestions; 22224 const hasValue = value && value.length; 22225 if (!__experimentalShowInitialSuggestions && !hasValue) { 22226 shouldShowSuggestions = false; 22227 } 22228 if (disableSuggestions === true) { 22229 shouldShowSuggestions = false; 22230 } 22231 return { 22232 showSuggestions: shouldShowSuggestions, 22233 suggestionsListboxId: `block-editor-url-input-suggestions-$instanceId}`, 22234 suggestionOptionIdPrefix: `block-editor-url-input-suggestion-$instanceId}` 22235 }; 22236 } 22237 render() { 22238 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 22239 children: [this.renderControl(), this.renderSuggestions()] 22240 }); 22241 } 22242 renderControl() { 22243 const { 22244 label = null, 22245 className, 22246 isFullWidth, 22247 instanceId, 22248 placeholder = (0,external_wp_i18n_namespaceObject.__)('Paste URL or type to search'), 22249 __experimentalRenderControl: renderControl, 22250 value = '', 22251 hideLabelFromVision = false 22252 } = this.props; 22253 const { 22254 loading, 22255 showSuggestions, 22256 selectedSuggestion, 22257 suggestionsListboxId, 22258 suggestionOptionIdPrefix 22259 } = this.state; 22260 const inputId = `url-input-control-$instanceId}`; 22261 const controlProps = { 22262 id: inputId, 22263 // Passes attribute to label for the for attribute 22264 label, 22265 className: dist_clsx('block-editor-url-input', className, { 22266 'is-full-width': isFullWidth 22267 }), 22268 hideLabelFromVision 22269 }; 22270 const inputProps = { 22271 id: inputId, 22272 value, 22273 required: true, 22274 type: 'text', 22275 onChange: this.onChange, 22276 onFocus: this.onFocus, 22277 placeholder, 22278 onKeyDown: this.onKeyDown, 22279 role: 'combobox', 22280 'aria-label': label ? undefined : (0,external_wp_i18n_namespaceObject.__)('URL'), 22281 // Ensure input always has an accessible label 22282 'aria-expanded': showSuggestions, 22283 'aria-autocomplete': 'list', 22284 'aria-owns': suggestionsListboxId, 22285 'aria-activedescendant': selectedSuggestion !== null ? `$suggestionOptionIdPrefix}-$selectedSuggestion}` : undefined, 22286 ref: this.inputRef, 22287 suffix: this.props.suffix 22288 }; 22289 if (renderControl) { 22290 return renderControl(controlProps, inputProps, loading); 22291 } 22292 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.BaseControl, { 22293 __nextHasNoMarginBottom: true, 22294 ...controlProps, 22295 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, { 22296 ...inputProps, 22297 __next40pxDefaultSize: true 22298 }), loading && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {})] 22299 }); 22300 } 22301 renderSuggestions() { 22302 const { 22303 className, 22304 __experimentalRenderSuggestions: renderSuggestions 22305 } = this.props; 22306 const { 22307 showSuggestions, 22308 suggestions, 22309 suggestionsValue, 22310 selectedSuggestion, 22311 suggestionsListboxId, 22312 suggestionOptionIdPrefix, 22313 loading 22314 } = this.state; 22315 if (!showSuggestions || suggestions.length === 0) { 22316 return null; 22317 } 22318 const suggestionsListProps = { 22319 id: suggestionsListboxId, 22320 ref: this.autocompleteRef, 22321 role: 'listbox' 22322 }; 22323 const buildSuggestionItemProps = (suggestion, index) => { 22324 return { 22325 role: 'option', 22326 tabIndex: '-1', 22327 id: `$suggestionOptionIdPrefix}-$index}`, 22328 ref: this.bindSuggestionNode(index), 22329 'aria-selected': index === selectedSuggestion ? true : undefined 22330 }; 22331 }; 22332 if (isFunction(renderSuggestions)) { 22333 return renderSuggestions({ 22334 suggestions, 22335 selectedSuggestion, 22336 suggestionsListProps, 22337 buildSuggestionItemProps, 22338 isLoading: loading, 22339 handleSuggestionClick: this.handleOnClick, 22340 isInitialSuggestions: !suggestionsValue?.length, 22341 currentInputValue: suggestionsValue 22342 }); 22343 } 22344 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, { 22345 placement: "bottom", 22346 focusOnMount: false, 22347 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 22348 ...suggestionsListProps, 22349 className: dist_clsx('block-editor-url-input__suggestions', `$className}__suggestions`), 22350 children: suggestions.map((suggestion, index) => /*#__PURE__*/(0,external_React_.createElement)(external_wp_components_namespaceObject.Button, { 22351 __next40pxDefaultSize: true, 22352 ...buildSuggestionItemProps(suggestion, index), 22353 key: suggestion.id, 22354 className: dist_clsx('block-editor-url-input__suggestion', { 22355 'is-selected': index === selectedSuggestion 22356 }), 22357 onClick: () => this.handleOnClick(suggestion) 22358 }, suggestion.title)) 22359 }) 22360 }); 22361 } 22362 } 22363 22364 /** 22365 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/url-input/README.md 22366 */ 22367 /* harmony default export */ const url_input = ((0,external_wp_compose_namespaceObject.compose)(external_wp_compose_namespaceObject.withSafeTimeout, external_wp_components_namespaceObject.withSpokenMessages, external_wp_compose_namespaceObject.withInstanceId, (0,external_wp_data_namespaceObject.withSelect)((select, props) => { 22368 // If a link suggestions handler is already provided then 22369 // bail. 22370 if (isFunction(props.__experimentalFetchLinkSuggestions)) { 22371 return; 22372 } 22373 const { 22374 getSettings 22375 } = select(store); 22376 return { 22377 __experimentalFetchLinkSuggestions: getSettings().__experimentalFetchLinkSuggestions 22378 }; 22379 }))(URLInput)); 22380 22381 ;// ./node_modules/@wordpress/icons/build-module/library/plus.js 22382 /** 22383 * WordPress dependencies 22384 */ 22385 22386 22387 const plus = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 22388 xmlns: "http://www.w3.org/2000/svg", 22389 viewBox: "0 0 24 24", 22390 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 22391 d: "M11 12.5V17.5H12.5V12.5H17.5V11H12.5V6H11V11H6V12.5H11Z" 22392 }) 22393 }); 22394 /* harmony default export */ const library_plus = (plus); 22395 22396 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/search-create-button.js 22397 /** 22398 * WordPress dependencies 22399 */ 22400 22401 22402 22403 22404 22405 const LinkControlSearchCreate = ({ 22406 searchTerm, 22407 onClick, 22408 itemProps, 22409 buttonText 22410 }) => { 22411 if (!searchTerm) { 22412 return null; 22413 } 22414 let text; 22415 if (buttonText) { 22416 text = typeof buttonText === 'function' ? buttonText(searchTerm) : buttonText; 22417 } else { 22418 text = (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: search term. */ 22419 (0,external_wp_i18n_namespaceObject.__)('Create: <mark>%s</mark>'), searchTerm), { 22420 mark: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("mark", {}) 22421 }); 22422 } 22423 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 22424 ...itemProps, 22425 iconPosition: "left", 22426 icon: library_plus, 22427 className: "block-editor-link-control__search-item", 22428 onClick: onClick, 22429 children: text 22430 }); 22431 }; 22432 /* harmony default export */ const search_create_button = (LinkControlSearchCreate); 22433 22434 ;// ./node_modules/@wordpress/icons/build-module/library/post-list.js 22435 /** 22436 * WordPress dependencies 22437 */ 22438 22439 22440 const postList = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 22441 viewBox: "0 0 24 24", 22442 xmlns: "http://www.w3.org/2000/svg", 22443 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 22444 d: "M18 5.5H6a.5.5 0 0 0-.5.5v12a.5.5 0 0 0 .5.5h12a.5.5 0 0 0 .5-.5V6a.5.5 0 0 0-.5-.5ZM6 4h12a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2Zm1 5h1.5v1.5H7V9Zm1.5 4.5H7V15h1.5v-1.5ZM10 9h7v1.5h-7V9Zm7 4.5h-7V15h7v-1.5Z" 22445 }) 22446 }); 22447 /* harmony default export */ const post_list = (postList); 22448 22449 ;// ./node_modules/@wordpress/icons/build-module/library/page.js 22450 /** 22451 * WordPress dependencies 22452 */ 22453 22454 22455 22456 const page = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, { 22457 xmlns: "http://www.w3.org/2000/svg", 22458 viewBox: "0 0 24 24", 22459 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 22460 d: "M15.5 7.5h-7V9h7V7.5Zm-7 3.5h7v1.5h-7V11Zm7 3.5h-7V16h7v-1.5Z" 22461 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 22462 d: "M17 4H7a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2ZM7 5.5h10a.5.5 0 0 1 .5.5v12a.5.5 0 0 1-.5.5H7a.5.5 0 0 1-.5-.5V6a.5.5 0 0 1 .5-.5Z" 22463 })] 22464 }); 22465 /* harmony default export */ const library_page = (page); 22466 22467 ;// ./node_modules/@wordpress/icons/build-module/library/tag.js 22468 /** 22469 * WordPress dependencies 22470 */ 22471 22472 22473 const tag = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 22474 xmlns: "http://www.w3.org/2000/svg", 22475 viewBox: "0 0 24 24", 22476 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 22477 d: "M4.75 4a.75.75 0 0 0-.75.75v7.826c0 .2.08.39.22.53l6.72 6.716a2.313 2.313 0 0 0 3.276-.001l5.61-5.611-.531-.53.532.528a2.315 2.315 0 0 0 0-3.264L13.104 4.22a.75.75 0 0 0-.53-.22H4.75ZM19 12.576a.815.815 0 0 1-.236.574l-5.61 5.611a.814.814 0 0 1-1.153 0L5.5 12.264V5.5h6.763l6.5 6.502a.816.816 0 0 1 .237.574ZM8.75 9.75a1 1 0 1 0 0-2 1 1 0 0 0 0 2Z" 22478 }) 22479 }); 22480 /* harmony default export */ const library_tag = (tag); 22481 22482 ;// ./node_modules/@wordpress/icons/build-module/library/category.js 22483 /** 22484 * WordPress dependencies 22485 */ 22486 22487 22488 const category = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 22489 viewBox: "0 0 24 24", 22490 xmlns: "http://www.w3.org/2000/svg", 22491 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 22492 d: "M6 5.5h3a.5.5 0 01.5.5v3a.5.5 0 01-.5.5H6a.5.5 0 01-.5-.5V6a.5.5 0 01.5-.5zM4 6a2 2 0 012-2h3a2 2 0 012 2v3a2 2 0 01-2 2H6a2 2 0 01-2-2V6zm11-.5h3a.5.5 0 01.5.5v3a.5.5 0 01-.5.5h-3a.5.5 0 01-.5-.5V6a.5.5 0 01.5-.5zM13 6a2 2 0 012-2h3a2 2 0 012 2v3a2 2 0 01-2 2h-3a2 2 0 01-2-2V6zm5 8.5h-3a.5.5 0 00-.5.5v3a.5.5 0 00.5.5h3a.5.5 0 00.5-.5v-3a.5.5 0 00-.5-.5zM15 13a2 2 0 00-2 2v3a2 2 0 002 2h3a2 2 0 002-2v-3a2 2 0 00-2-2h-3zm-9 1.5h3a.5.5 0 01.5.5v3a.5.5 0 01-.5.5H6a.5.5 0 01-.5-.5v-3a.5.5 0 01.5-.5zM4 15a2 2 0 012-2h3a2 2 0 012 2v3a2 2 0 01-2 2H6a2 2 0 01-2-2v-3z", 22493 fillRule: "evenodd", 22494 clipRule: "evenodd" 22495 }) 22496 }); 22497 /* harmony default export */ const library_category = (category); 22498 22499 ;// ./node_modules/@wordpress/icons/build-module/library/file.js 22500 /** 22501 * WordPress dependencies 22502 */ 22503 22504 22505 const file = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 22506 viewBox: "0 0 24 24", 22507 xmlns: "http://www.w3.org/2000/svg", 22508 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 22509 fillRule: "evenodd", 22510 clipRule: "evenodd", 22511 d: "M12.848 8a1 1 0 0 1-.914-.594l-.723-1.63a.5.5 0 0 0-.447-.276H5a.5.5 0 0 0-.5.5v11.5a.5.5 0 0 0 .5.5h14a.5.5 0 0 0 .5-.5v-9A.5.5 0 0 0 19 8h-6.152Zm.612-1.5a.5.5 0 0 1-.462-.31l-.445-1.084A2 2 0 0 0 10.763 4H5a2 2 0 0 0-2 2v11.5a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-9a2 2 0 0 0-2-2h-5.54Z" 22512 }) 22513 }); 22514 /* harmony default export */ const library_file = (file); 22515 22516 ;// ./node_modules/@wordpress/icons/build-module/library/globe.js 22517 /** 22518 * WordPress dependencies 22519 */ 22520 22521 22522 const globe = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 22523 xmlns: "http://www.w3.org/2000/svg", 22524 viewBox: "0 0 24 24", 22525 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 22526 d: "M12 3.3c-4.8 0-8.8 3.9-8.8 8.8 0 4.8 3.9 8.8 8.8 8.8 4.8 0 8.8-3.9 8.8-8.8s-4-8.8-8.8-8.8zm6.5 5.5h-2.6C15.4 7.3 14.8 6 14 5c2 .6 3.6 2 4.5 3.8zm.7 3.2c0 .6-.1 1.2-.2 1.8h-2.9c.1-.6.1-1.2.1-1.8s-.1-1.2-.1-1.8H19c.2.6.2 1.2.2 1.8zM12 18.7c-1-.7-1.8-1.9-2.3-3.5h4.6c-.5 1.6-1.3 2.9-2.3 3.5zm-2.6-4.9c-.1-.6-.1-1.1-.1-1.8 0-.6.1-1.2.1-1.8h5.2c.1.6.1 1.1.1 1.8s-.1 1.2-.1 1.8H9.4zM4.8 12c0-.6.1-1.2.2-1.8h2.9c-.1.6-.1 1.2-.1 1.8 0 .6.1 1.2.1 1.8H5c-.2-.6-.2-1.2-.2-1.8zM12 5.3c1 .7 1.8 1.9 2.3 3.5H9.7c.5-1.6 1.3-2.9 2.3-3.5zM10 5c-.8 1-1.4 2.3-1.8 3.8H5.5C6.4 7 8 5.6 10 5zM5.5 15.3h2.6c.4 1.5 1 2.8 1.8 3.7-1.8-.6-3.5-2-4.4-3.7zM14 19c.8-1 1.4-2.2 1.8-3.7h2.6C17.6 17 16 18.4 14 19z" 22527 }) 22528 }); 22529 /* harmony default export */ const library_globe = (globe); 22530 22531 ;// ./node_modules/@wordpress/icons/build-module/library/home.js 22532 /** 22533 * WordPress dependencies 22534 */ 22535 22536 22537 const home = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 22538 xmlns: "http://www.w3.org/2000/svg", 22539 viewBox: "0 0 24 24", 22540 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 22541 d: "M12 4L4 7.9V20h16V7.9L12 4zm6.5 14.5H14V13h-4v5.5H5.5V8.8L12 5.7l6.5 3.1v9.7z" 22542 }) 22543 }); 22544 /* harmony default export */ const library_home = (home); 22545 22546 ;// ./node_modules/@wordpress/icons/build-module/library/verse.js 22547 /** 22548 * WordPress dependencies 22549 */ 22550 22551 22552 const verse = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 22553 viewBox: "0 0 24 24", 22554 xmlns: "http://www.w3.org/2000/svg", 22555 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 22556 d: "M17.8 2l-.9.3c-.1 0-3.6 1-5.2 2.1C10 5.5 9.3 6.5 8.9 7.1c-.6.9-1.7 4.7-1.7 6.3l-.9 2.3c-.2.4 0 .8.4 1 .1 0 .2.1.3.1.3 0 .6-.2.7-.5l.6-1.5c.3 0 .7-.1 1.2-.2.7-.1 1.4-.3 2.2-.5.8-.2 1.6-.5 2.4-.8.7-.3 1.4-.7 1.9-1.2s.8-1.2 1-1.9c.2-.7.3-1.6.4-2.4.1-.8.1-1.7.2-2.5 0-.8.1-1.5.2-2.1V2zm-1.9 5.6c-.1.8-.2 1.5-.3 2.1-.2.6-.4 1-.6 1.3-.3.3-.8.6-1.4.9-.7.3-1.4.5-2.2.8-.6.2-1.3.3-1.8.4L15 7.5c.3-.3.6-.7 1-1.1 0 .4 0 .8-.1 1.2zM6 20h8v-1.5H6V20z" 22557 }) 22558 }); 22559 /* harmony default export */ const library_verse = (verse); 22560 22561 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/search-item.js 22562 /** 22563 * WordPress dependencies 22564 */ 22565 22566 22567 22568 22569 22570 22571 22572 const ICONS_MAP = { 22573 post: post_list, 22574 page: library_page, 22575 post_tag: library_tag, 22576 category: library_category, 22577 attachment: library_file 22578 }; 22579 function SearchItemIcon({ 22580 isURL, 22581 suggestion 22582 }) { 22583 let icon = null; 22584 if (isURL) { 22585 icon = library_globe; 22586 } else if (suggestion.type in ICONS_MAP) { 22587 icon = ICONS_MAP[suggestion.type]; 22588 if (suggestion.type === 'page') { 22589 if (suggestion.isFrontPage) { 22590 icon = library_home; 22591 } 22592 if (suggestion.isBlogHome) { 22593 icon = library_verse; 22594 } 22595 } 22596 } 22597 if (icon) { 22598 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 22599 className: "block-editor-link-control__search-item-icon", 22600 icon: icon 22601 }); 22602 } 22603 return null; 22604 } 22605 22606 /** 22607 * Adds a leading slash to a url if it doesn't already have one. 22608 * @param {string} url the url to add a leading slash to. 22609 * @return {string} the url with a leading slash. 22610 */ 22611 function addLeadingSlash(url) { 22612 const trimmedURL = url?.trim(); 22613 if (!trimmedURL?.length) { 22614 return url; 22615 } 22616 return url?.replace(/^\/?/, '/'); 22617 } 22618 function removeTrailingSlash(url) { 22619 const trimmedURL = url?.trim(); 22620 if (!trimmedURL?.length) { 22621 return url; 22622 } 22623 return url?.replace(/\/$/, ''); 22624 } 22625 const partialRight = (fn, ...partialArgs) => (...args) => fn(...args, ...partialArgs); 22626 const defaultTo = d => v => { 22627 return v === null || v === undefined || v !== v ? d : v; 22628 }; 22629 22630 /** 22631 * Prepares a URL for display in the UI. 22632 * - decodes the URL. 22633 * - filters it (removes protocol, www, etc.). 22634 * - truncates it if necessary. 22635 * - adds a leading slash. 22636 * @param {string} url the url. 22637 * @return {string} the processed url to display. 22638 */ 22639 function getURLForDisplay(url) { 22640 if (!url) { 22641 return url; 22642 } 22643 return (0,external_wp_compose_namespaceObject.pipe)(external_wp_url_namespaceObject.safeDecodeURI, external_wp_url_namespaceObject.getPath, defaultTo(''), partialRight(external_wp_url_namespaceObject.filterURLForDisplay, 24), removeTrailingSlash, addLeadingSlash)(url); 22644 } 22645 const LinkControlSearchItem = ({ 22646 itemProps, 22647 suggestion, 22648 searchTerm, 22649 onClick, 22650 isURL = false, 22651 shouldShowType = false 22652 }) => { 22653 const info = isURL ? (0,external_wp_i18n_namespaceObject.__)('Press ENTER to add this link') : getURLForDisplay(suggestion.url); 22654 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 22655 ...itemProps, 22656 info: info, 22657 iconPosition: "left", 22658 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SearchItemIcon, { 22659 suggestion: suggestion, 22660 isURL: isURL 22661 }), 22662 onClick: onClick, 22663 shortcut: shouldShowType && getVisualTypeName(suggestion), 22664 className: "block-editor-link-control__search-item", 22665 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextHighlight 22666 // The component expects a plain text string. 22667 , { 22668 text: (0,external_wp_dom_namespaceObject.__unstableStripHTML)(suggestion.title), 22669 highlight: searchTerm 22670 }) 22671 }); 22672 }; 22673 function getVisualTypeName(suggestion) { 22674 if (suggestion.isFrontPage) { 22675 return 'front page'; 22676 } 22677 if (suggestion.isBlogHome) { 22678 return 'blog home'; 22679 } 22680 22681 // Rename 'post_tag' to 'tag'. Ideally, the API would return the localised CPT or taxonomy label. 22682 return suggestion.type === 'post_tag' ? 'tag' : suggestion.type; 22683 } 22684 /* harmony default export */ const search_item = (LinkControlSearchItem); 22685 22686 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/constants.js 22687 /** 22688 * WordPress dependencies 22689 */ 22690 22691 22692 // Used as a unique identifier for the "Create" option within search results. 22693 // Used to help distinguish the "Create" suggestion within the search results in 22694 // order to handle it as a unique case. 22695 const CREATE_TYPE = '__CREATE__'; 22696 const TEL_TYPE = 'tel'; 22697 const URL_TYPE = 'link'; 22698 const MAILTO_TYPE = 'mailto'; 22699 const INTERNAL_TYPE = 'internal'; 22700 const LINK_ENTRY_TYPES = [URL_TYPE, MAILTO_TYPE, TEL_TYPE, INTERNAL_TYPE]; 22701 const DEFAULT_LINK_SETTINGS = [{ 22702 id: 'opensInNewTab', 22703 title: (0,external_wp_i18n_namespaceObject.__)('Open in new tab') 22704 }]; 22705 22706 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/search-results.js 22707 /** 22708 * WordPress dependencies 22709 */ 22710 22711 22712 22713 /** 22714 * External dependencies 22715 */ 22716 22717 22718 /** 22719 * Internal dependencies 22720 */ 22721 22722 22723 22724 22725 22726 function LinkControlSearchResults({ 22727 instanceId, 22728 withCreateSuggestion, 22729 currentInputValue, 22730 handleSuggestionClick, 22731 suggestionsListProps, 22732 buildSuggestionItemProps, 22733 suggestions, 22734 selectedSuggestion, 22735 isLoading, 22736 isInitialSuggestions, 22737 createSuggestionButtonText, 22738 suggestionsQuery 22739 }) { 22740 const resultsListClasses = dist_clsx('block-editor-link-control__search-results', { 22741 'is-loading': isLoading 22742 }); 22743 const isSingleDirectEntryResult = suggestions.length === 1 && LINK_ENTRY_TYPES.includes(suggestions[0].type); 22744 const shouldShowCreateSuggestion = withCreateSuggestion && !isSingleDirectEntryResult && !isInitialSuggestions; 22745 // If the query has a specified type, then we can skip showing them in the result. See #24839. 22746 const shouldShowSuggestionsTypes = !suggestionsQuery?.type; 22747 22748 // According to guidelines aria-label should be added if the label 22749 // itself is not visible. 22750 // See: https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles/listbox_role 22751 const searchResultsLabelId = `block-editor-link-control-search-results-label-$instanceId}`; 22752 const labelText = isInitialSuggestions ? (0,external_wp_i18n_namespaceObject.__)('Suggestions') : (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: search term. */ 22753 (0,external_wp_i18n_namespaceObject.__)('Search results for "%s"'), currentInputValue); 22754 const searchResultsLabel = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 22755 id: searchResultsLabelId, 22756 children: labelText 22757 }); 22758 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 22759 className: "block-editor-link-control__search-results-wrapper", 22760 children: [searchResultsLabel, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 22761 ...suggestionsListProps, 22762 className: resultsListClasses, 22763 "aria-labelledby": searchResultsLabelId, 22764 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, { 22765 children: suggestions.map((suggestion, index) => { 22766 if (shouldShowCreateSuggestion && CREATE_TYPE === suggestion.type) { 22767 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_create_button, { 22768 searchTerm: currentInputValue, 22769 buttonText: createSuggestionButtonText, 22770 onClick: () => handleSuggestionClick(suggestion) 22771 // Intentionally only using `type` here as 22772 // the constant is enough to uniquely 22773 // identify the single "CREATE" suggestion. 22774 , 22775 22776 itemProps: buildSuggestionItemProps(suggestion, index), 22777 isSelected: index === selectedSuggestion 22778 }, suggestion.type); 22779 } 22780 22781 // If we're not handling "Create" suggestions above then 22782 // we don't want them in the main results so exit early. 22783 if (CREATE_TYPE === suggestion.type) { 22784 return null; 22785 } 22786 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_item, { 22787 itemProps: buildSuggestionItemProps(suggestion, index), 22788 suggestion: suggestion, 22789 index: index, 22790 onClick: () => { 22791 handleSuggestionClick(suggestion); 22792 }, 22793 isSelected: index === selectedSuggestion, 22794 isURL: LINK_ENTRY_TYPES.includes(suggestion.type), 22795 searchTerm: currentInputValue, 22796 shouldShowType: shouldShowSuggestionsTypes, 22797 isFrontPage: suggestion?.isFrontPage, 22798 isBlogHome: suggestion?.isBlogHome 22799 }, `$suggestion.id}-$suggestion.type}`); 22800 }) 22801 }) 22802 })] 22803 }); 22804 } 22805 22806 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/is-url-like.js 22807 /** 22808 * WordPress dependencies 22809 */ 22810 22811 22812 /** 22813 * Determines whether a given value could be a URL. Note this does not 22814 * guarantee the value is a URL only that it looks like it might be one. For 22815 * example, just because a string has `www.` in it doesn't make it a URL, 22816 * but it does make it highly likely that it will be so in the context of 22817 * creating a link it makes sense to treat it like one. 22818 * 22819 * @param {string} val the candidate for being URL-like (or not). 22820 * 22821 * @return {boolean} whether or not the value is potentially a URL. 22822 */ 22823 function isURLLike(val) { 22824 const hasSpaces = val.includes(' '); 22825 if (hasSpaces) { 22826 return false; 22827 } 22828 const protocol = (0,external_wp_url_namespaceObject.getProtocol)(val); 22829 const protocolIsValid = (0,external_wp_url_namespaceObject.isValidProtocol)(protocol); 22830 const mayBeTLD = hasPossibleTLD(val); 22831 const isWWW = val?.startsWith('www.'); 22832 const isInternal = val?.startsWith('#') && (0,external_wp_url_namespaceObject.isValidFragment)(val); 22833 return protocolIsValid || isWWW || isInternal || mayBeTLD; 22834 } 22835 22836 /** 22837 * Checks if a given URL has a valid Top-Level Domain (TLD). 22838 * 22839 * @param {string} url - The URL to check. 22840 * @param {number} maxLength - The maximum length of the TLD. 22841 * @return {boolean} Returns true if the URL has a valid TLD, false otherwise. 22842 */ 22843 function hasPossibleTLD(url, maxLength = 6) { 22844 // Clean the URL by removing anything after the first occurrence of "?" or "#". 22845 const cleanedURL = url.split(/[?#]/)[0]; 22846 22847 // Regular expression explanation: 22848 // - (?<=\S) : Positive lookbehind assertion to ensure there is at least one non-whitespace character before the TLD 22849 // - \. : Matches a literal dot (.) 22850 // - [a-zA-Z_]{2,maxLength} : Matches 2 to maxLength letters or underscores, representing the TLD 22851 // - (?:\/|$) : Non-capturing group that matches either a forward slash (/) or the end of the string 22852 const regex = new RegExp(`(?<=\\S)\\.(?:[a-zA-Z_]{2,$maxLength}})(?:\\/|$)`); 22853 return regex.test(cleanedURL); 22854 } 22855 22856 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/use-search-handler.js 22857 /** 22858 * WordPress dependencies 22859 */ 22860 22861 22862 22863 22864 /** 22865 * Internal dependencies 22866 */ 22867 22868 22869 22870 const handleNoop = () => Promise.resolve([]); 22871 const handleDirectEntry = val => { 22872 let type = URL_TYPE; 22873 const protocol = (0,external_wp_url_namespaceObject.getProtocol)(val) || ''; 22874 if (protocol.includes('mailto')) { 22875 type = MAILTO_TYPE; 22876 } 22877 if (protocol.includes('tel')) { 22878 type = TEL_TYPE; 22879 } 22880 if (val?.startsWith('#')) { 22881 type = INTERNAL_TYPE; 22882 } 22883 return Promise.resolve([{ 22884 id: val, 22885 title: val, 22886 url: type === 'URL' ? (0,external_wp_url_namespaceObject.prependHTTP)(val) : val, 22887 type 22888 }]); 22889 }; 22890 const handleEntitySearch = async (val, suggestionsQuery, fetchSearchSuggestions, withCreateSuggestion, pageOnFront, pageForPosts) => { 22891 const { 22892 isInitialSuggestions 22893 } = suggestionsQuery; 22894 const results = await fetchSearchSuggestions(val, suggestionsQuery); 22895 22896 // Identify front page and update type to match. 22897 results.map(result => { 22898 if (Number(result.id) === pageOnFront) { 22899 result.isFrontPage = true; 22900 return result; 22901 } else if (Number(result.id) === pageForPosts) { 22902 result.isBlogHome = true; 22903 return result; 22904 } 22905 return result; 22906 }); 22907 22908 // If displaying initial suggestions just return plain results. 22909 if (isInitialSuggestions) { 22910 return results; 22911 } 22912 22913 // Here we append a faux suggestion to represent a "CREATE" option. This 22914 // is detected in the rendering of the search results and handled as a 22915 // special case. This is currently necessary because the suggestions 22916 // dropdown will only appear if there are valid suggestions and 22917 // therefore unless the create option is a suggestion it will not 22918 // display in scenarios where there are no results returned from the 22919 // API. In addition promoting CREATE to a first class suggestion affords 22920 // the a11y benefits afforded by `URLInput` to all suggestions (eg: 22921 // keyboard handling, ARIA roles...etc). 22922 // 22923 // Note also that the value of the `title` and `url` properties must correspond 22924 // to the text value of the `<input>`. This is because `title` is used 22925 // when creating the suggestion. Similarly `url` is used when using keyboard to select 22926 // the suggestion (the <form> `onSubmit` handler falls-back to `url`). 22927 return isURLLike(val) || !withCreateSuggestion ? results : results.concat({ 22928 // the `id` prop is intentionally ommitted here because it 22929 // is never exposed as part of the component's public API. 22930 // see: https://github.com/WordPress/gutenberg/pull/19775#discussion_r378931316. 22931 title: val, 22932 // Must match the existing `<input>`s text value. 22933 url: val, 22934 // Must match the existing `<input>`s text value. 22935 type: CREATE_TYPE 22936 }); 22937 }; 22938 function useSearchHandler(suggestionsQuery, allowDirectEntry, withCreateSuggestion) { 22939 const { 22940 fetchSearchSuggestions, 22941 pageOnFront, 22942 pageForPosts 22943 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 22944 const { 22945 getSettings 22946 } = select(store); 22947 return { 22948 pageOnFront: getSettings().pageOnFront, 22949 pageForPosts: getSettings().pageForPosts, 22950 fetchSearchSuggestions: getSettings().__experimentalFetchLinkSuggestions 22951 }; 22952 }, []); 22953 const directEntryHandler = allowDirectEntry ? handleDirectEntry : handleNoop; 22954 return (0,external_wp_element_namespaceObject.useCallback)((val, { 22955 isInitialSuggestions 22956 }) => { 22957 return isURLLike(val) ? directEntryHandler(val, { 22958 isInitialSuggestions 22959 }) : handleEntitySearch(val, { 22960 ...suggestionsQuery, 22961 isInitialSuggestions 22962 }, fetchSearchSuggestions, withCreateSuggestion, pageOnFront, pageForPosts); 22963 }, [directEntryHandler, fetchSearchSuggestions, pageOnFront, pageForPosts, suggestionsQuery, withCreateSuggestion]); 22964 } 22965 22966 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/search-input.js 22967 /** 22968 * WordPress dependencies 22969 */ 22970 22971 22972 22973 22974 /** 22975 * Internal dependencies 22976 */ 22977 22978 22979 22980 22981 22982 // Must be a function as otherwise URLInput will default 22983 // to the fetchLinkSuggestions passed in block editor settings 22984 // which will cause an unintended http request. 22985 22986 22987 const noopSearchHandler = () => Promise.resolve([]); 22988 const noop = () => {}; 22989 const LinkControlSearchInput = (0,external_wp_element_namespaceObject.forwardRef)(({ 22990 value, 22991 children, 22992 currentLink = {}, 22993 className = null, 22994 placeholder = null, 22995 withCreateSuggestion = false, 22996 onCreateSuggestion = noop, 22997 onChange = noop, 22998 onSelect = noop, 22999 showSuggestions = true, 23000 renderSuggestions = props => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkControlSearchResults, { 23001 ...props 23002 }), 23003 fetchSuggestions = null, 23004 allowDirectEntry = true, 23005 showInitialSuggestions = false, 23006 suggestionsQuery = {}, 23007 withURLSuggestion = true, 23008 createSuggestionButtonText, 23009 hideLabelFromVision = false, 23010 suffix 23011 }, ref) => { 23012 const genericSearchHandler = useSearchHandler(suggestionsQuery, allowDirectEntry, withCreateSuggestion, withURLSuggestion); 23013 const searchHandler = showSuggestions ? fetchSuggestions || genericSearchHandler : noopSearchHandler; 23014 const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(LinkControlSearchInput); 23015 const [focusedSuggestion, setFocusedSuggestion] = (0,external_wp_element_namespaceObject.useState)(); 23016 23017 /** 23018 * Handles the user moving between different suggestions. Does not handle 23019 * choosing an individual item. 23020 * 23021 * @param {string} selection the url of the selected suggestion. 23022 * @param {Object} suggestion the suggestion object. 23023 */ 23024 const onInputChange = (selection, suggestion) => { 23025 onChange(selection); 23026 setFocusedSuggestion(suggestion); 23027 }; 23028 const handleRenderSuggestions = props => renderSuggestions({ 23029 ...props, 23030 instanceId, 23031 withCreateSuggestion, 23032 createSuggestionButtonText, 23033 suggestionsQuery, 23034 handleSuggestionClick: suggestion => { 23035 if (props.handleSuggestionClick) { 23036 props.handleSuggestionClick(suggestion); 23037 } 23038 onSuggestionSelected(suggestion); 23039 } 23040 }); 23041 const onSuggestionSelected = async selectedSuggestion => { 23042 let suggestion = selectedSuggestion; 23043 if (CREATE_TYPE === selectedSuggestion.type) { 23044 // Create a new page and call onSelect with the output from the onCreateSuggestion callback. 23045 try { 23046 suggestion = await onCreateSuggestion(selectedSuggestion.title); 23047 if (suggestion?.url) { 23048 onSelect(suggestion); 23049 } 23050 } catch (e) {} 23051 return; 23052 } 23053 if (allowDirectEntry || suggestion && Object.keys(suggestion).length >= 1) { 23054 const { 23055 id, 23056 url, 23057 ...restLinkProps 23058 } = currentLink !== null && currentLink !== void 0 ? currentLink : {}; 23059 onSelect( 23060 // Some direct entries don't have types or IDs, and we still need to clear the previous ones. 23061 { 23062 ...restLinkProps, 23063 ...suggestion 23064 }, suggestion); 23065 } 23066 }; 23067 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 23068 className: "block-editor-link-control__search-input-container", 23069 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_input, { 23070 disableSuggestions: currentLink?.url === value, 23071 label: (0,external_wp_i18n_namespaceObject.__)('Link'), 23072 hideLabelFromVision: hideLabelFromVision, 23073 className: className, 23074 value: value, 23075 onChange: onInputChange, 23076 placeholder: placeholder !== null && placeholder !== void 0 ? placeholder : (0,external_wp_i18n_namespaceObject.__)('Search or type URL'), 23077 __experimentalRenderSuggestions: showSuggestions ? handleRenderSuggestions : null, 23078 __experimentalFetchLinkSuggestions: searchHandler, 23079 __experimentalHandleURLSuggestions: true, 23080 __experimentalShowInitialSuggestions: showInitialSuggestions, 23081 onSubmit: (suggestion, event) => { 23082 const hasSuggestion = suggestion || focusedSuggestion; 23083 23084 // If there is no suggestion and the value (ie: any manually entered URL) is empty 23085 // then don't allow submission otherwise we get empty links. 23086 if (!hasSuggestion && !value?.trim()?.length) { 23087 event.preventDefault(); 23088 } else { 23089 onSuggestionSelected(hasSuggestion || { 23090 url: value 23091 }); 23092 } 23093 }, 23094 ref: ref, 23095 suffix: suffix 23096 }), children] 23097 }); 23098 }); 23099 /* harmony default export */ const search_input = (LinkControlSearchInput); 23100 23101 ;// ./node_modules/@wordpress/icons/build-module/library/info.js 23102 /** 23103 * WordPress dependencies 23104 */ 23105 23106 23107 const info = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 23108 xmlns: "http://www.w3.org/2000/svg", 23109 viewBox: "0 0 24 24", 23110 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 23111 d: "M12 3.2c-4.8 0-8.8 3.9-8.8 8.8 0 4.8 3.9 8.8 8.8 8.8 4.8 0 8.8-3.9 8.8-8.8 0-4.8-4-8.8-8.8-8.8zm0 16c-4 0-7.2-3.3-7.2-7.2C4.8 8 8 4.8 12 4.8s7.2 3.3 7.2 7.2c0 4-3.2 7.2-7.2 7.2zM11 17h2v-6h-2v6zm0-8h2V7h-2v2z" 23112 }) 23113 }); 23114 /* harmony default export */ const library_info = (info); 23115 23116 ;// ./node_modules/@wordpress/icons/build-module/library/pencil.js 23117 /** 23118 * WordPress dependencies 23119 */ 23120 23121 23122 const pencil = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 23123 xmlns: "http://www.w3.org/2000/svg", 23124 viewBox: "0 0 24 24", 23125 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 23126 d: "m19 7-3-3-8.5 8.5-1 4 4-1L19 7Zm-7 11.5H5V20h7v-1.5Z" 23127 }) 23128 }); 23129 /* harmony default export */ const library_pencil = (pencil); 23130 23131 ;// ./node_modules/@wordpress/icons/build-module/library/edit.js 23132 /** 23133 * Internal dependencies 23134 */ 23135 23136 23137 /* harmony default export */ const edit = (library_pencil); 23138 23139 ;// ./node_modules/@wordpress/icons/build-module/library/link-off.js 23140 /** 23141 * WordPress dependencies 23142 */ 23143 23144 23145 const linkOff = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 23146 xmlns: "http://www.w3.org/2000/svg", 23147 viewBox: "0 0 24 24", 23148 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 23149 d: "M17.031 4.703 15.576 4l-1.56 3H14v.03l-2.324 4.47H9.5V13h1.396l-1.502 2.889h-.95a3.694 3.694 0 0 1 0-7.389H10V7H8.444a5.194 5.194 0 1 0 0 10.389h.17L7.5 19.53l1.416.719L15.049 8.5h.507a3.694 3.694 0 0 1 0 7.39H14v1.5h1.556a5.194 5.194 0 0 0 .273-10.383l1.202-2.304Z" 23150 }) 23151 }); 23152 /* harmony default export */ const link_off = (linkOff); 23153 23154 ;// ./node_modules/@wordpress/icons/build-module/library/copy-small.js 23155 /** 23156 * WordPress dependencies 23157 */ 23158 23159 23160 const copySmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 23161 xmlns: "http://www.w3.org/2000/svg", 23162 viewBox: "0 0 24 24", 23163 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 23164 fillRule: "evenodd", 23165 clipRule: "evenodd", 23166 d: "M5.625 5.5h9.75c.069 0 .125.056.125.125v9.75a.125.125 0 0 1-.125.125h-9.75a.125.125 0 0 1-.125-.125v-9.75c0-.069.056-.125.125-.125ZM4 5.625C4 4.728 4.728 4 5.625 4h9.75C16.273 4 17 4.728 17 5.625v9.75c0 .898-.727 1.625-1.625 1.625h-9.75A1.625 1.625 0 0 1 4 15.375v-9.75Zm14.5 11.656v-9H20v9C20 18.8 18.77 20 17.251 20H6.25v-1.5h11.001c.69 0 1.249-.528 1.249-1.219Z" 23167 }) 23168 }); 23169 /* harmony default export */ const copy_small = (copySmall); 23170 23171 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/viewer-slot.js 23172 /** 23173 * WordPress dependencies 23174 */ 23175 23176 const { 23177 Slot: ViewerSlot, 23178 Fill: ViewerFill 23179 } = (0,external_wp_components_namespaceObject.createSlotFill)('BlockEditorLinkControlViewer'); 23180 23181 /* harmony default export */ const viewer_slot = ((/* unused pure expression or super */ null && (ViewerSlot))); 23182 23183 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/use-rich-url-data.js 23184 /** 23185 * Internal dependencies 23186 */ 23187 23188 23189 /** 23190 * WordPress dependencies 23191 */ 23192 23193 23194 function use_rich_url_data_reducer(state, action) { 23195 switch (action.type) { 23196 case 'RESOLVED': 23197 return { 23198 ...state, 23199 isFetching: false, 23200 richData: action.richData 23201 }; 23202 case 'ERROR': 23203 return { 23204 ...state, 23205 isFetching: false, 23206 richData: null 23207 }; 23208 case 'LOADING': 23209 return { 23210 ...state, 23211 isFetching: true 23212 }; 23213 default: 23214 throw new Error(`Unexpected action type $action.type}`); 23215 } 23216 } 23217 function useRemoteUrlData(url) { 23218 const [state, dispatch] = (0,external_wp_element_namespaceObject.useReducer)(use_rich_url_data_reducer, { 23219 richData: null, 23220 isFetching: false 23221 }); 23222 const { 23223 fetchRichUrlData 23224 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 23225 const { 23226 getSettings 23227 } = select(store); 23228 return { 23229 fetchRichUrlData: getSettings().__experimentalFetchRichUrlData 23230 }; 23231 }, []); 23232 (0,external_wp_element_namespaceObject.useEffect)(() => { 23233 // Only make the request if we have an actual URL 23234 // and the fetching util is available. In some editors 23235 // there may not be such a util. 23236 if (url?.length && fetchRichUrlData && typeof AbortController !== 'undefined') { 23237 dispatch({ 23238 type: 'LOADING' 23239 }); 23240 const controller = new window.AbortController(); 23241 const signal = controller.signal; 23242 fetchRichUrlData(url, { 23243 signal 23244 }).then(urlData => { 23245 dispatch({ 23246 type: 'RESOLVED', 23247 richData: urlData 23248 }); 23249 }).catch(() => { 23250 // Avoid setting state on unmounted component 23251 if (!signal.aborted) { 23252 dispatch({ 23253 type: 'ERROR' 23254 }); 23255 } 23256 }); 23257 // Cleanup: when the URL changes the abort the current request. 23258 return () => { 23259 controller.abort(); 23260 }; 23261 } 23262 }, [url]); 23263 return state; 23264 } 23265 /* harmony default export */ const use_rich_url_data = (useRemoteUrlData); 23266 23267 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/link-preview.js 23268 /** 23269 * External dependencies 23270 */ 23271 23272 23273 /** 23274 * WordPress dependencies 23275 */ 23276 23277 23278 23279 23280 23281 23282 23283 23284 23285 23286 /** 23287 * Internal dependencies 23288 */ 23289 23290 23291 23292 /** 23293 * Filters the title for display. Removes the protocol and www prefix. 23294 * 23295 * @param {string} title The title to be filtered. 23296 * 23297 * @return {string} The filtered title. 23298 */ 23299 23300 23301 23302 function filterTitleForDisplay(title) { 23303 // Derived from `filterURLForDisplay` in `@wordpress/url`. 23304 return title.replace(/^[a-z\-.\+]+[0-9]*:(\/\/)?/i, '').replace(/^www\./i, ''); 23305 } 23306 function LinkPreview({ 23307 value, 23308 onEditClick, 23309 hasRichPreviews = false, 23310 hasUnlinkControl = false, 23311 onRemove 23312 }) { 23313 const showIconLabels = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_preferences_namespaceObject.store).get('core', 'showIconLabels'), []); 23314 23315 // Avoid fetching if rich previews are not desired. 23316 const showRichPreviews = hasRichPreviews ? value?.url : null; 23317 const { 23318 richData, 23319 isFetching 23320 } = use_rich_url_data(showRichPreviews); 23321 23322 // Rich data may be an empty object so test for that. 23323 const hasRichData = richData && Object.keys(richData).length; 23324 const displayURL = value && (0,external_wp_url_namespaceObject.filterURLForDisplay)((0,external_wp_url_namespaceObject.safeDecodeURI)(value.url), 24) || ''; 23325 23326 // url can be undefined if the href attribute is unset 23327 const isEmptyURL = !value?.url?.length; 23328 const displayTitle = !isEmptyURL && (0,external_wp_dom_namespaceObject.__unstableStripHTML)(richData?.title || value?.title || displayURL); 23329 const isUrlRedundant = !value?.url || filterTitleForDisplay(displayTitle) === displayURL; 23330 let icon; 23331 if (richData?.icon) { 23332 icon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("img", { 23333 src: richData?.icon, 23334 alt: "" 23335 }); 23336 } else if (isEmptyURL) { 23337 icon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 23338 icon: library_info, 23339 size: 32 23340 }); 23341 } else { 23342 icon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 23343 icon: library_globe 23344 }); 23345 } 23346 const { 23347 createNotice 23348 } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store); 23349 const ref = (0,external_wp_compose_namespaceObject.useCopyToClipboard)(value.url, () => { 23350 createNotice('info', (0,external_wp_i18n_namespaceObject.__)('Link copied to clipboard.'), { 23351 isDismissible: true, 23352 type: 'snackbar' 23353 }); 23354 }); 23355 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 23356 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Currently selected'), 23357 className: dist_clsx('block-editor-link-control__search-item', { 23358 'is-current': true, 23359 'is-rich': hasRichData, 23360 'is-fetching': !!isFetching, 23361 'is-preview': true, 23362 'is-error': isEmptyURL, 23363 'is-url-title': displayTitle === displayURL 23364 }), 23365 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 23366 className: "block-editor-link-control__search-item-top", 23367 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("span", { 23368 className: "block-editor-link-control__search-item-header", 23369 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 23370 className: dist_clsx('block-editor-link-control__search-item-icon', { 23371 'is-image': richData?.icon 23372 }), 23373 children: icon 23374 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 23375 className: "block-editor-link-control__search-item-details", 23376 children: !isEmptyURL ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 23377 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, { 23378 className: "block-editor-link-control__search-item-title", 23379 href: value.url, 23380 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, { 23381 numberOfLines: 1, 23382 children: displayTitle 23383 }) 23384 }), !isUrlRedundant && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 23385 className: "block-editor-link-control__search-item-info", 23386 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, { 23387 numberOfLines: 1, 23388 children: displayURL 23389 }) 23390 })] 23391 }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 23392 className: "block-editor-link-control__search-item-error-notice", 23393 children: (0,external_wp_i18n_namespaceObject.__)('Link is empty') 23394 }) 23395 })] 23396 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 23397 icon: edit, 23398 label: (0,external_wp_i18n_namespaceObject.__)('Edit link'), 23399 onClick: onEditClick, 23400 size: "compact" 23401 }), hasUnlinkControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 23402 icon: link_off, 23403 label: (0,external_wp_i18n_namespaceObject.__)('Remove link'), 23404 onClick: onRemove, 23405 size: "compact" 23406 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 23407 icon: copy_small, 23408 label: (0,external_wp_i18n_namespaceObject.sprintf)( 23409 // Translators: %s is a placeholder for the link URL and an optional colon, (if a Link URL is present). 23410 (0,external_wp_i18n_namespaceObject.__)('Copy link%s'), 23411 // Ends up looking like "Copy link: https://example.com". 23412 isEmptyURL || showIconLabels ? '' : ': ' + value.url), 23413 ref: ref, 23414 accessibleWhenDisabled: true, 23415 disabled: isEmptyURL, 23416 size: "compact" 23417 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ViewerSlot, { 23418 fillProps: value 23419 })] 23420 }) 23421 }); 23422 } 23423 23424 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/settings.js 23425 /** 23426 * WordPress dependencies 23427 */ 23428 23429 23430 23431 23432 const settings_noop = () => {}; 23433 const LinkControlSettings = ({ 23434 value, 23435 onChange = settings_noop, 23436 settings 23437 }) => { 23438 if (!settings || !settings.length) { 23439 return null; 23440 } 23441 const handleSettingChange = setting => newValue => { 23442 onChange({ 23443 ...value, 23444 [setting.id]: newValue 23445 }); 23446 }; 23447 const theSettings = settings.map(setting => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, { 23448 __nextHasNoMarginBottom: true, 23449 className: "block-editor-link-control__setting", 23450 label: setting.title, 23451 onChange: handleSettingChange(setting), 23452 checked: value ? !!value[setting.id] : false, 23453 help: setting?.help 23454 }, setting.id)); 23455 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", { 23456 className: "block-editor-link-control__settings", 23457 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 23458 as: "legend", 23459 children: (0,external_wp_i18n_namespaceObject.__)('Currently selected link settings') 23460 }), theSettings] 23461 }); 23462 }; 23463 /* harmony default export */ const link_control_settings = (LinkControlSettings); 23464 23465 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/use-create-page.js 23466 /** 23467 * WordPress dependencies 23468 */ 23469 23470 23471 function useCreatePage(handleCreatePage) { 23472 const cancelableCreateSuggestion = (0,external_wp_element_namespaceObject.useRef)(); 23473 const [isCreatingPage, setIsCreatingPage] = (0,external_wp_element_namespaceObject.useState)(false); 23474 const [errorMessage, setErrorMessage] = (0,external_wp_element_namespaceObject.useState)(null); 23475 const createPage = async function (suggestionTitle) { 23476 setIsCreatingPage(true); 23477 setErrorMessage(null); 23478 try { 23479 // Make cancellable in order that we can avoid setting State 23480 // if the component unmounts during the call to `createSuggestion` 23481 cancelableCreateSuggestion.current = makeCancelable( 23482 // Using Promise.resolve to allow createSuggestion to return a 23483 // non-Promise based value. 23484 Promise.resolve(handleCreatePage(suggestionTitle))); 23485 return await cancelableCreateSuggestion.current.promise; 23486 } catch (error) { 23487 if (error && error.isCanceled) { 23488 return; // bail if canceled to avoid setting state 23489 } 23490 setErrorMessage(error.message || (0,external_wp_i18n_namespaceObject.__)('An unknown error occurred during creation. Please try again.')); 23491 throw error; 23492 } finally { 23493 setIsCreatingPage(false); 23494 } 23495 }; 23496 23497 /** 23498 * Handles cancelling any pending Promises that have been made cancelable. 23499 */ 23500 (0,external_wp_element_namespaceObject.useEffect)(() => { 23501 return () => { 23502 // componentDidUnmount 23503 if (cancelableCreateSuggestion.current) { 23504 cancelableCreateSuggestion.current.cancel(); 23505 } 23506 }; 23507 }, []); 23508 return { 23509 createPage, 23510 isCreatingPage, 23511 errorMessage 23512 }; 23513 } 23514 23515 /** 23516 * Creates a wrapper around a promise which allows it to be programmatically 23517 * cancelled. 23518 * See: https://reactjs.org/blog/2015/12/16/ismounted-antipattern.html 23519 * 23520 * @param {Promise} promise the Promise to make cancelable 23521 */ 23522 const makeCancelable = promise => { 23523 let hasCanceled_ = false; 23524 const wrappedPromise = new Promise((resolve, reject) => { 23525 promise.then(val => hasCanceled_ ? reject({ 23526 isCanceled: true 23527 }) : resolve(val), error => hasCanceled_ ? reject({ 23528 isCanceled: true 23529 }) : reject(error)); 23530 }); 23531 return { 23532 promise: wrappedPromise, 23533 cancel() { 23534 hasCanceled_ = true; 23535 } 23536 }; 23537 }; 23538 23539 // EXTERNAL MODULE: ./node_modules/fast-deep-equal/index.js 23540 var fast_deep_equal = __webpack_require__(5215); 23541 var fast_deep_equal_default = /*#__PURE__*/__webpack_require__.n(fast_deep_equal); 23542 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/use-internal-value.js 23543 /** 23544 * WordPress dependencies 23545 */ 23546 23547 23548 /** 23549 * External dependencies 23550 */ 23551 23552 function useInternalValue(value) { 23553 const [internalValue, setInternalValue] = (0,external_wp_element_namespaceObject.useState)(value || {}); 23554 const [previousValue, setPreviousValue] = (0,external_wp_element_namespaceObject.useState)(value); 23555 23556 // If the value prop changes, update the internal state. 23557 // See: 23558 // - https://github.com/WordPress/gutenberg/pull/51387#issuecomment-1722927384. 23559 // - https://react.dev/reference/react/useState#storing-information-from-previous-renders. 23560 if (!fast_deep_equal_default()(value, previousValue)) { 23561 setPreviousValue(value); 23562 setInternalValue(value); 23563 } 23564 const setInternalURLInputValue = nextValue => { 23565 setInternalValue({ 23566 ...internalValue, 23567 url: nextValue 23568 }); 23569 }; 23570 const setInternalTextInputValue = nextValue => { 23571 setInternalValue({ 23572 ...internalValue, 23573 title: nextValue 23574 }); 23575 }; 23576 const createSetInternalSettingValueHandler = settingsKeys => nextValue => { 23577 // Only apply settings values which are defined in the settings prop. 23578 const settingsUpdates = Object.keys(nextValue).reduce((acc, key) => { 23579 if (settingsKeys.includes(key)) { 23580 acc[key] = nextValue[key]; 23581 } 23582 return acc; 23583 }, {}); 23584 setInternalValue({ 23585 ...internalValue, 23586 ...settingsUpdates 23587 }); 23588 }; 23589 return [internalValue, setInternalValue, setInternalURLInputValue, setInternalTextInputValue, createSetInternalSettingValueHandler]; 23590 } 23591 23592 ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/index.js 23593 /** 23594 * External dependencies 23595 */ 23596 23597 23598 /** 23599 * WordPress dependencies 23600 */ 23601 23602 23603 23604 23605 23606 23607 23608 23609 23610 23611 /** 23612 * Internal dependencies 23613 */ 23614 23615 23616 23617 23618 23619 23620 23621 23622 23623 /** 23624 * Default properties associated with a link control value. 23625 * 23626 * @typedef WPLinkControlDefaultValue 23627 * 23628 * @property {string} url Link URL. 23629 * @property {string=} title Link title. 23630 * @property {boolean=} opensInNewTab Whether link should open in a new browser 23631 * tab. This value is only assigned if not 23632 * providing a custom `settings` prop. 23633 */ 23634 23635 /* eslint-disable jsdoc/valid-types */ 23636 /** 23637 * Custom settings values associated with a link. 23638 * 23639 * @typedef {{[setting:string]:any}} WPLinkControlSettingsValue 23640 */ 23641 /* eslint-enable */ 23642 23643 /** 23644 * Custom settings values associated with a link. 23645 * 23646 * @typedef WPLinkControlSetting 23647 * 23648 * @property {string} id Identifier to use as property for setting value. 23649 * @property {string} title Human-readable label to show in user interface. 23650 */ 23651 23652 /** 23653 * Properties associated with a link control value, composed as a union of the 23654 * default properties and any custom settings values. 23655 * 23656 * @typedef {WPLinkControlDefaultValue&WPLinkControlSettingsValue} WPLinkControlValue 23657 */ 23658 23659 /** @typedef {(nextValue:WPLinkControlValue)=>void} WPLinkControlOnChangeProp */ 23660 23661 /** 23662 * Properties associated with a search suggestion used within the LinkControl. 23663 * 23664 * @typedef WPLinkControlSuggestion 23665 * 23666 * @property {string} id Identifier to use to uniquely identify the suggestion. 23667 * @property {string} type Identifies the type of the suggestion (eg: `post`, 23668 * `page`, `url`...etc) 23669 * @property {string} title Human-readable label to show in user interface. 23670 * @property {string} url A URL for the suggestion. 23671 */ 23672 23673 /** @typedef {(title:string)=>WPLinkControlSuggestion} WPLinkControlCreateSuggestionProp */ 23674 23675 /** 23676 * @typedef WPLinkControlProps 23677 * 23678 * @property {(WPLinkControlSetting[])=} settings An array of settings objects. Each object will used to 23679 * render a `ToggleControl` for that setting. 23680 * @property {boolean=} forceIsEditingLink If passed as either `true` or `false`, controls the 23681 * internal editing state of the component to respective 23682 * show or not show the URL input field. 23683 * @property {WPLinkControlValue=} value Current link value. 23684 * @property {WPLinkControlOnChangeProp=} onChange Value change handler, called with the updated value if 23685 * the user selects a new link or updates settings. 23686 * @property {boolean=} noDirectEntry Whether to allow turning a URL-like search query directly into a link. 23687 * @property {boolean=} showSuggestions Whether to present suggestions when typing the URL. 23688 * @property {boolean=} showInitialSuggestions Whether to present initial suggestions immediately. 23689 * @property {boolean=} withCreateSuggestion Whether to allow creation of link value from suggestion. 23690 * @property {Object=} suggestionsQuery Query parameters to pass along to wp.blockEditor.__experimentalFetchLinkSuggestions. 23691 * @property {boolean=} noURLSuggestion Whether to add a fallback suggestion which treats the search query as a URL. 23692 * @property {boolean=} hasTextControl Whether to add a text field to the UI to update the value.title. 23693 * @property {string|Function|undefined} createSuggestionButtonText The text to use in the button that calls createSuggestion. 23694 * @property {Function} renderControlBottom Optional controls to be rendered at the bottom of the component. 23695 */ 23696 23697 23698 23699 const link_control_noop = () => {}; 23700 const PREFERENCE_SCOPE = 'core/block-editor'; 23701 const PREFERENCE_KEY = 'linkControlSettingsDrawer'; 23702 23703 /** 23704 * Renders a link control. A link control is a controlled input which maintains 23705 * a value associated with a link (HTML anchor element) and relevant settings 23706 * for how that link is expected to behave. 23707 * 23708 * @param {WPLinkControlProps} props Component props. 23709 */ 23710 function LinkControl({ 23711 searchInputPlaceholder, 23712 value, 23713 settings = DEFAULT_LINK_SETTINGS, 23714 onChange = link_control_noop, 23715 onRemove, 23716 onCancel, 23717 noDirectEntry = false, 23718 showSuggestions = true, 23719 showInitialSuggestions, 23720 forceIsEditingLink, 23721 createSuggestion, 23722 withCreateSuggestion, 23723 inputValue: propInputValue = '', 23724 suggestionsQuery = {}, 23725 noURLSuggestion = false, 23726 createSuggestionButtonText, 23727 hasRichPreviews = false, 23728 hasTextControl = false, 23729 renderControlBottom = null 23730 }) { 23731 if (withCreateSuggestion === undefined && createSuggestion) { 23732 withCreateSuggestion = true; 23733 } 23734 const [settingsOpen, setSettingsOpen] = (0,external_wp_element_namespaceObject.useState)(false); 23735 const { 23736 advancedSettingsPreference 23737 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 23738 var _prefsStore$get; 23739 const prefsStore = select(external_wp_preferences_namespaceObject.store); 23740 return { 23741 advancedSettingsPreference: (_prefsStore$get = prefsStore.get(PREFERENCE_SCOPE, PREFERENCE_KEY)) !== null && _prefsStore$get !== void 0 ? _prefsStore$get : false 23742 }; 23743 }, []); 23744 const { 23745 set: setPreference 23746 } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_preferences_namespaceObject.store); 23747 23748 /** 23749 * Sets the open/closed state of the Advanced Settings Drawer, 23750 * optionlly persisting the state to the user's preferences. 23751 * 23752 * Note that Block Editor components can be consumed by non-WordPress 23753 * environments which may not have preferences setup. 23754 * Therefore a local state is also used as a fallback. 23755 * 23756 * @param {boolean} prefVal the open/closed state of the Advanced Settings Drawer. 23757 */ 23758 const setSettingsOpenWithPreference = prefVal => { 23759 if (setPreference) { 23760 setPreference(PREFERENCE_SCOPE, PREFERENCE_KEY, prefVal); 23761 } 23762 setSettingsOpen(prefVal); 23763 }; 23764 23765 // Block Editor components can be consumed by non-WordPress environments 23766 // which may not have these preferences setup. 23767 // Therefore a local state is used as a fallback. 23768 const isSettingsOpen = advancedSettingsPreference || settingsOpen; 23769 const isMountingRef = (0,external_wp_element_namespaceObject.useRef)(true); 23770 const wrapperNode = (0,external_wp_element_namespaceObject.useRef)(); 23771 const textInputRef = (0,external_wp_element_namespaceObject.useRef)(); 23772 const isEndingEditWithFocusRef = (0,external_wp_element_namespaceObject.useRef)(false); 23773 const settingsKeys = settings.map(({ 23774 id 23775 }) => id); 23776 const [internalControlValue, setInternalControlValue, setInternalURLInputValue, setInternalTextInputValue, createSetInternalSettingValueHandler] = useInternalValue(value); 23777 const valueHasChanges = value && !(0,external_wp_isShallowEqual_namespaceObject.isShallowEqualObjects)(internalControlValue, value); 23778 const [isEditingLink, setIsEditingLink] = (0,external_wp_element_namespaceObject.useState)(forceIsEditingLink !== undefined ? forceIsEditingLink : !value || !value.url); 23779 const { 23780 createPage, 23781 isCreatingPage, 23782 errorMessage 23783 } = useCreatePage(createSuggestion); 23784 (0,external_wp_element_namespaceObject.useEffect)(() => { 23785 if (forceIsEditingLink === undefined) { 23786 return; 23787 } 23788 setIsEditingLink(forceIsEditingLink); 23789 }, [forceIsEditingLink]); 23790 (0,external_wp_element_namespaceObject.useEffect)(() => { 23791 // We don't auto focus into the Link UI on mount 23792 // because otherwise using the keyboard to select text 23793 // *within* the link format is not possible. 23794 if (isMountingRef.current) { 23795 return; 23796 } 23797 23798 // Scenario - when: 23799 // - switching between editable and non editable LinkControl 23800 // - clicking on a link 23801 // ...then move focus to the *first* element to avoid focus loss 23802 // and to ensure focus is *within* the Link UI. 23803 const nextFocusTarget = external_wp_dom_namespaceObject.focus.focusable.find(wrapperNode.current)[0] || wrapperNode.current; 23804 nextFocusTarget.focus(); 23805 isEndingEditWithFocusRef.current = false; 23806 }, [isEditingLink, isCreatingPage]); 23807 23808 // The component mounting reference is maintained separately 23809 // to correctly reset values in `StrictMode`. 23810 (0,external_wp_element_namespaceObject.useEffect)(() => { 23811 isMountingRef.current = false; 23812 return () => { 23813 isMountingRef.current = true; 23814 }; 23815 }, []); 23816 const hasLinkValue = value?.url?.trim()?.length > 0; 23817 23818 /** 23819 * Cancels editing state and marks that focus may need to be restored after 23820 * the next render, if focus was within the wrapper when editing finished. 23821 */ 23822 const stopEditing = () => { 23823 isEndingEditWithFocusRef.current = !!wrapperNode.current?.contains(wrapperNode.current.ownerDocument.activeElement); 23824 setIsEditingLink(false); 23825 }; 23826 const handleSelectSuggestion = updatedValue => { 23827 // Suggestions may contains "settings" values (e.g. `opensInNewTab`) 23828 // which should not overide any existing settings values set by the 23829 // user. This filters out any settings values from the suggestion. 23830 const nonSettingsChanges = Object.keys(updatedValue).reduce((acc, key) => { 23831 if (!settingsKeys.includes(key)) { 23832 acc[key] = updatedValue[key]; 23833 } 23834 return acc; 23835 }, {}); 23836 onChange({ 23837 ...internalControlValue, 23838 ...nonSettingsChanges, 23839 // As title is not a setting, it must be manually applied 23840 // in such a way as to preserve the users changes over 23841 // any "title" value provided by the "suggestion". 23842 title: internalControlValue?.title || updatedValue?.title 23843 }); 23844 stopEditing(); 23845 }; 23846 const handleSubmit = () => { 23847 if (valueHasChanges) { 23848 // Submit the original value with new stored values applied 23849 // on top. URL is a special case as it may also be a prop. 23850 onChange({ 23851 ...value, 23852 ...internalControlValue, 23853 url: currentUrlInputValue 23854 }); 23855 } 23856 stopEditing(); 23857 }; 23858 const handleSubmitWithEnter = event => { 23859 const { 23860 keyCode 23861 } = event; 23862 if (keyCode === external_wp_keycodes_namespaceObject.ENTER && !currentInputIsEmpty // Disallow submitting empty values. 23863 ) { 23864 event.preventDefault(); 23865 handleSubmit(); 23866 } 23867 }; 23868 const resetInternalValues = () => { 23869 setInternalControlValue(value); 23870 }; 23871 const handleCancel = event => { 23872 event.preventDefault(); 23873 event.stopPropagation(); 23874 23875 // Ensure that any unsubmitted input changes are reset. 23876 resetInternalValues(); 23877 if (hasLinkValue) { 23878 // If there is a link then exist editing mode and show preview. 23879 stopEditing(); 23880 } else { 23881 // If there is no link value, then remove the link entirely. 23882 onRemove?.(); 23883 } 23884 onCancel?.(); 23885 }; 23886 const currentUrlInputValue = propInputValue || internalControlValue?.url || ''; 23887 const currentInputIsEmpty = !currentUrlInputValue?.trim()?.length; 23888 const shownUnlinkControl = onRemove && value && !isEditingLink && !isCreatingPage; 23889 const showActions = isEditingLink && hasLinkValue; 23890 23891 // Only show text control once a URL value has been committed 23892 // and it isn't just empty whitespace. 23893 // See https://github.com/WordPress/gutenberg/pull/33849/#issuecomment-932194927. 23894 const showTextControl = hasLinkValue && hasTextControl; 23895 const isEditing = (isEditingLink || !value) && !isCreatingPage; 23896 const isDisabled = !valueHasChanges || currentInputIsEmpty; 23897 const showSettings = !!settings?.length && isEditingLink && hasLinkValue; 23898 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 23899 tabIndex: -1, 23900 ref: wrapperNode, 23901 className: "block-editor-link-control", 23902 children: [isCreatingPage && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 23903 className: "block-editor-link-control__loading", 23904 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {}), " ", (0,external_wp_i18n_namespaceObject.__)('Creating'), "\u2026"] 23905 }), isEditing && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 23906 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 23907 className: dist_clsx({ 23908 'block-editor-link-control__search-input-wrapper': true, 23909 'has-text-control': showTextControl, 23910 'has-actions': showActions 23911 }), 23912 children: [showTextControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, { 23913 __nextHasNoMarginBottom: true, 23914 ref: textInputRef, 23915 className: "block-editor-link-control__field block-editor-link-control__text-content", 23916 label: (0,external_wp_i18n_namespaceObject.__)('Text'), 23917 value: internalControlValue?.title, 23918 onChange: setInternalTextInputValue, 23919 onKeyDown: handleSubmitWithEnter, 23920 __next40pxDefaultSize: true 23921 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_input, { 23922 currentLink: value, 23923 className: "block-editor-link-control__field block-editor-link-control__search-input", 23924 placeholder: searchInputPlaceholder, 23925 value: currentUrlInputValue, 23926 withCreateSuggestion: withCreateSuggestion, 23927 onCreateSuggestion: createPage, 23928 onChange: setInternalURLInputValue, 23929 onSelect: handleSelectSuggestion, 23930 showInitialSuggestions: showInitialSuggestions, 23931 allowDirectEntry: !noDirectEntry, 23932 showSuggestions: showSuggestions, 23933 suggestionsQuery: suggestionsQuery, 23934 withURLSuggestion: !noURLSuggestion, 23935 createSuggestionButtonText: createSuggestionButtonText, 23936 hideLabelFromVision: !showTextControl, 23937 suffix: showActions ? undefined : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlSuffixWrapper, { 23938 variant: "control", 23939 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 23940 onClick: isDisabled ? link_control_noop : handleSubmit, 23941 label: (0,external_wp_i18n_namespaceObject.__)('Submit'), 23942 icon: keyboard_return, 23943 className: "block-editor-link-control__search-submit", 23944 "aria-disabled": isDisabled, 23945 size: "small" 23946 }) 23947 }), 23948 props: true 23949 })] 23950 }), errorMessage && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Notice, { 23951 className: "block-editor-link-control__search-error", 23952 status: "error", 23953 isDismissible: false, 23954 children: errorMessage 23955 })] 23956 }), value && !isEditingLink && !isCreatingPage && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkPreview, { 23957 // force remount when URL changes to avoid race conditions for rich previews 23958 value: value, 23959 onEditClick: () => setIsEditingLink(true), 23960 hasRichPreviews: hasRichPreviews, 23961 hasUnlinkControl: shownUnlinkControl, 23962 onRemove: () => { 23963 onRemove(); 23964 setIsEditingLink(true); 23965 } 23966 }, value?.url), showSettings && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 23967 className: "block-editor-link-control__tools", 23968 children: !currentInputIsEmpty && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(settings_drawer, { 23969 settingsOpen: isSettingsOpen, 23970 setSettingsOpen: setSettingsOpenWithPreference, 23971 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(link_control_settings, { 23972 value: internalControlValue, 23973 settings: settings, 23974 onChange: createSetInternalSettingValueHandler(settingsKeys) 23975 }) 23976 }) 23977 }), showActions && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 23978 justify: "right", 23979 className: "block-editor-link-control__search-actions", 23980 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 23981 __next40pxDefaultSize: true, 23982 variant: "tertiary", 23983 onClick: handleCancel, 23984 children: (0,external_wp_i18n_namespaceObject.__)('Cancel') 23985 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 23986 __next40pxDefaultSize: true, 23987 variant: "primary", 23988 onClick: isDisabled ? link_control_noop : handleSubmit, 23989 className: "block-editor-link-control__search-submit", 23990 "aria-disabled": isDisabled, 23991 children: (0,external_wp_i18n_namespaceObject.__)('Save') 23992 })] 23993 }), !isCreatingPage && renderControlBottom && renderControlBottom()] 23994 }); 23995 } 23996 LinkControl.ViewerFill = ViewerFill; 23997 LinkControl.DEFAULT_LINK_SETTINGS = DEFAULT_LINK_SETTINGS; 23998 /* harmony default export */ const link_control = (LinkControl); 23999 24000 ;// ./node_modules/@wordpress/block-editor/build-module/components/media-replace-flow/index.js 24001 /** 24002 * External dependencies 24003 */ 24004 24005 24006 /** 24007 * WordPress dependencies 24008 */ 24009 24010 24011 24012 24013 24014 24015 24016 24017 24018 24019 24020 /** 24021 * Internal dependencies 24022 */ 24023 24024 24025 24026 24027 24028 24029 24030 const media_replace_flow_noop = () => {}; 24031 let uniqueId = 0; 24032 const MediaReplaceFlow = ({ 24033 mediaURL, 24034 mediaId, 24035 mediaIds, 24036 allowedTypes, 24037 accept, 24038 onError, 24039 onSelect, 24040 onSelectURL, 24041 onReset, 24042 onToggleFeaturedImage, 24043 useFeaturedImage, 24044 onFilesUpload = media_replace_flow_noop, 24045 name = (0,external_wp_i18n_namespaceObject.__)('Replace'), 24046 createNotice, 24047 removeNotice, 24048 children, 24049 multiple = false, 24050 addToGallery, 24051 handleUpload = true, 24052 popoverProps 24053 }) => { 24054 const mediaUpload = (0,external_wp_data_namespaceObject.useSelect)(select => { 24055 return select(store).getSettings().mediaUpload; 24056 }, []); 24057 const canUpload = !!mediaUpload; 24058 const editMediaButtonRef = (0,external_wp_element_namespaceObject.useRef)(); 24059 const errorNoticeID = `block-editor/media-replace-flow/error-notice/${++uniqueId}`; 24060 const onUploadError = message => { 24061 const safeMessage = (0,external_wp_dom_namespaceObject.__unstableStripHTML)(message); 24062 if (onError) { 24063 onError(safeMessage); 24064 return; 24065 } 24066 // We need to set a timeout for showing the notice 24067 // so that VoiceOver and possibly other screen readers 24068 // can announce the error after the toolbar button 24069 // regains focus once the upload dialog closes. 24070 // Otherwise VO simply skips over the notice and announces 24071 // the focused element and the open menu. 24072 setTimeout(() => { 24073 createNotice('error', safeMessage, { 24074 speak: true, 24075 id: errorNoticeID, 24076 isDismissible: true 24077 }); 24078 }, 1000); 24079 }; 24080 const selectMedia = (media, closeMenu) => { 24081 if (useFeaturedImage && onToggleFeaturedImage) { 24082 onToggleFeaturedImage(); 24083 } 24084 closeMenu(); 24085 // Calling `onSelect` after the state update since it might unmount the component. 24086 onSelect(media); 24087 (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('The media file has been replaced')); 24088 removeNotice(errorNoticeID); 24089 }; 24090 const uploadFiles = (event, closeMenu) => { 24091 const files = event.target.files; 24092 if (!handleUpload) { 24093 closeMenu(); 24094 return onSelect(files); 24095 } 24096 onFilesUpload(files); 24097 mediaUpload({ 24098 allowedTypes, 24099 filesList: files, 24100 onFileChange: ([media]) => { 24101 selectMedia(media, closeMenu); 24102 }, 24103 onError: onUploadError 24104 }); 24105 }; 24106 const openOnArrowDown = event => { 24107 if (event.keyCode === external_wp_keycodes_namespaceObject.DOWN) { 24108 event.preventDefault(); 24109 event.target.click(); 24110 } 24111 }; 24112 const onlyAllowsImages = () => { 24113 if (!allowedTypes || allowedTypes.length === 0) { 24114 return false; 24115 } 24116 return allowedTypes.every(allowedType => allowedType === 'image' || allowedType.startsWith('image/')); 24117 }; 24118 const gallery = multiple && onlyAllowsImages(); 24119 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 24120 popoverProps: popoverProps, 24121 contentClassName: "block-editor-media-replace-flow__options", 24122 renderToggle: ({ 24123 isOpen, 24124 onToggle 24125 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 24126 ref: editMediaButtonRef, 24127 "aria-expanded": isOpen, 24128 "aria-haspopup": "true", 24129 onClick: onToggle, 24130 onKeyDown: openOnArrowDown, 24131 children: name 24132 }), 24133 renderContent: ({ 24134 onClose 24135 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 24136 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.NavigableMenu, { 24137 className: "block-editor-media-replace-flow__media-upload-menu", 24138 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(check, { 24139 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_upload, { 24140 gallery: gallery, 24141 addToGallery: addToGallery, 24142 multiple: multiple, 24143 value: multiple ? mediaIds : mediaId, 24144 onSelect: media => selectMedia(media, onClose), 24145 allowedTypes: allowedTypes, 24146 render: ({ 24147 open 24148 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 24149 icon: library_media, 24150 onClick: open, 24151 children: (0,external_wp_i18n_namespaceObject.__)('Open Media Library') 24152 }) 24153 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FormFileUpload, { 24154 onChange: event => { 24155 uploadFiles(event, onClose); 24156 }, 24157 accept: accept, 24158 multiple: !!multiple, 24159 render: ({ 24160 openFileDialog 24161 }) => { 24162 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 24163 icon: library_upload, 24164 onClick: () => { 24165 openFileDialog(); 24166 }, 24167 children: (0,external_wp_i18n_namespaceObject.__)('Upload') 24168 }); 24169 } 24170 })] 24171 }), onToggleFeaturedImage && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 24172 icon: post_featured_image, 24173 onClick: onToggleFeaturedImage, 24174 isPressed: useFeaturedImage, 24175 children: (0,external_wp_i18n_namespaceObject.__)('Use featured image') 24176 }), mediaURL && onReset && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 24177 onClick: () => { 24178 onReset(); 24179 onClose(); 24180 }, 24181 children: (0,external_wp_i18n_namespaceObject.__)('Reset') 24182 }), typeof children === 'function' ? children({ 24183 onClose 24184 }) : children] 24185 }), onSelectURL && 24186 /*#__PURE__*/ 24187 // eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions 24188 (0,external_ReactJSXRuntime_namespaceObject.jsxs)("form", { 24189 className: dist_clsx('block-editor-media-flow__url-input', { 24190 'has-siblings': canUpload || onToggleFeaturedImage 24191 }), 24192 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 24193 className: "block-editor-media-replace-flow__image-url-label", 24194 children: (0,external_wp_i18n_namespaceObject.__)('Current media URL:') 24195 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(link_control, { 24196 value: { 24197 url: mediaURL 24198 }, 24199 settings: [], 24200 showSuggestions: false, 24201 onChange: ({ 24202 url 24203 }) => { 24204 onSelectURL(url); 24205 editMediaButtonRef.current.focus(); 24206 } 24207 })] 24208 })] 24209 }) 24210 }); 24211 }; 24212 24213 /** 24214 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/media-replace-flow/README.md 24215 */ 24216 /* harmony default export */ const media_replace_flow = ((0,external_wp_compose_namespaceObject.compose)([(0,external_wp_data_namespaceObject.withDispatch)(dispatch => { 24217 const { 24218 createNotice, 24219 removeNotice 24220 } = dispatch(external_wp_notices_namespaceObject.store); 24221 return { 24222 createNotice, 24223 removeNotice 24224 }; 24225 }), (0,external_wp_components_namespaceObject.withFilters)('editor.MediaReplaceFlow')])(MediaReplaceFlow)); 24226 24227 ;// ./node_modules/@wordpress/block-editor/build-module/components/background-image-control/index.js 24228 /** 24229 * External dependencies 24230 */ 24231 24232 24233 /** 24234 * WordPress dependencies 24235 */ 24236 24237 24238 24239 24240 24241 24242 24243 24244 24245 /** 24246 * Internal dependencies 24247 */ 24248 24249 24250 24251 24252 24253 24254 24255 24256 const IMAGE_BACKGROUND_TYPE = 'image'; 24257 const BACKGROUND_POPOVER_PROPS = { 24258 placement: 'left-start', 24259 offset: 36, 24260 shift: true, 24261 className: 'block-editor-global-styles-background-panel__popover' 24262 }; 24263 const background_image_control_noop = () => {}; 24264 24265 /** 24266 * Get the help text for the background size control. 24267 * 24268 * @param {string} value backgroundSize value. 24269 * @return {string} Translated help text. 24270 */ 24271 function backgroundSizeHelpText(value) { 24272 if (value === 'cover' || value === undefined) { 24273 return (0,external_wp_i18n_namespaceObject.__)('Image covers the space evenly.'); 24274 } 24275 if (value === 'contain') { 24276 return (0,external_wp_i18n_namespaceObject.__)('Image is contained without distortion.'); 24277 } 24278 return (0,external_wp_i18n_namespaceObject.__)('Image has a fixed width.'); 24279 } 24280 24281 /** 24282 * Converts decimal x and y coords from FocalPointPicker to percentage-based values 24283 * to use as backgroundPosition value. 24284 * 24285 * @param {{x?:number, y?:number}} value FocalPointPicker coords. 24286 * @return {string} backgroundPosition value. 24287 */ 24288 const coordsToBackgroundPosition = value => { 24289 if (!value || isNaN(value.x) && isNaN(value.y)) { 24290 return undefined; 24291 } 24292 const x = isNaN(value.x) ? 0.5 : value.x; 24293 const y = isNaN(value.y) ? 0.5 : value.y; 24294 return `$x * 100}% $y * 100}%`; 24295 }; 24296 24297 /** 24298 * Converts backgroundPosition value to x and y coords for FocalPointPicker. 24299 * 24300 * @param {string} value backgroundPosition value. 24301 * @return {{x?:number, y?:number}} FocalPointPicker coords. 24302 */ 24303 const backgroundPositionToCoords = value => { 24304 if (!value) { 24305 return { 24306 x: undefined, 24307 y: undefined 24308 }; 24309 } 24310 let [x, y] = value.split(' ').map(v => parseFloat(v) / 100); 24311 x = isNaN(x) ? undefined : x; 24312 y = isNaN(y) ? x : y; 24313 return { 24314 x, 24315 y 24316 }; 24317 }; 24318 function InspectorImagePreviewItem({ 24319 as = 'span', 24320 imgUrl, 24321 toggleProps = {}, 24322 filename, 24323 label, 24324 className, 24325 onToggleCallback = background_image_control_noop 24326 }) { 24327 (0,external_wp_element_namespaceObject.useEffect)(() => { 24328 if (typeof toggleProps?.isOpen !== 'undefined') { 24329 onToggleCallback(toggleProps?.isOpen); 24330 } 24331 }, [toggleProps?.isOpen, onToggleCallback]); 24332 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, { 24333 as: as, 24334 className: className, 24335 ...toggleProps, 24336 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 24337 justify: "flex-start", 24338 as: "span", 24339 className: "block-editor-global-styles-background-panel__inspector-preview-inner", 24340 children: [imgUrl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 24341 className: "block-editor-global-styles-background-panel__inspector-image-indicator-wrapper", 24342 "aria-hidden": true, 24343 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 24344 className: "block-editor-global-styles-background-panel__inspector-image-indicator", 24345 style: { 24346 backgroundImage: `url($imgUrl})` 24347 } 24348 }) 24349 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.FlexItem, { 24350 as: "span", 24351 style: imgUrl ? {} : { 24352 flexGrow: 1 24353 }, 24354 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, { 24355 numberOfLines: 1, 24356 className: "block-editor-global-styles-background-panel__inspector-media-replace-title", 24357 children: label 24358 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 24359 as: "span", 24360 children: imgUrl ? (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: file name */ 24361 (0,external_wp_i18n_namespaceObject.__)('Background image: %s'), filename || label) : (0,external_wp_i18n_namespaceObject.__)('No background image selected') 24362 })] 24363 })] 24364 }) 24365 }); 24366 } 24367 function BackgroundControlsPanel({ 24368 label, 24369 filename, 24370 url: imgUrl, 24371 children, 24372 onToggle: onToggleCallback = background_image_control_noop, 24373 hasImageValue 24374 }) { 24375 if (!hasImageValue) { 24376 return; 24377 } 24378 const imgLabel = label || (0,external_wp_url_namespaceObject.getFilename)(imgUrl) || (0,external_wp_i18n_namespaceObject.__)('Add background image'); 24379 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 24380 popoverProps: BACKGROUND_POPOVER_PROPS, 24381 renderToggle: ({ 24382 onToggle, 24383 isOpen 24384 }) => { 24385 const toggleProps = { 24386 onClick: onToggle, 24387 className: 'block-editor-global-styles-background-panel__dropdown-toggle', 24388 'aria-expanded': isOpen, 24389 'aria-label': (0,external_wp_i18n_namespaceObject.__)('Background size, position and repeat options.'), 24390 isOpen 24391 }; 24392 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorImagePreviewItem, { 24393 imgUrl: imgUrl, 24394 filename: filename, 24395 label: imgLabel, 24396 toggleProps: toggleProps, 24397 as: "button", 24398 onToggleCallback: onToggleCallback 24399 }); 24400 }, 24401 renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, { 24402 className: "block-editor-global-styles-background-panel__dropdown-content-wrapper", 24403 paddingSize: "medium", 24404 children: children 24405 }) 24406 }); 24407 } 24408 function LoadingSpinner() { 24409 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Placeholder, { 24410 className: "block-editor-global-styles-background-panel__loading", 24411 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {}) 24412 }); 24413 } 24414 function BackgroundImageControls({ 24415 onChange, 24416 style, 24417 inheritedValue, 24418 onRemoveImage = background_image_control_noop, 24419 onResetImage = background_image_control_noop, 24420 displayInPanel, 24421 defaultValues 24422 }) { 24423 const [isUploading, setIsUploading] = (0,external_wp_element_namespaceObject.useState)(false); 24424 const { 24425 getSettings 24426 } = (0,external_wp_data_namespaceObject.useSelect)(store); 24427 const { 24428 id, 24429 title, 24430 url 24431 } = style?.background?.backgroundImage || { 24432 ...inheritedValue?.background?.backgroundImage 24433 }; 24434 const replaceContainerRef = (0,external_wp_element_namespaceObject.useRef)(); 24435 const { 24436 createErrorNotice 24437 } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store); 24438 const onUploadError = message => { 24439 createErrorNotice(message, { 24440 type: 'snackbar' 24441 }); 24442 setIsUploading(false); 24443 }; 24444 const resetBackgroundImage = () => onChange(setImmutably(style, ['background', 'backgroundImage'], undefined)); 24445 const onSelectMedia = media => { 24446 if (!media || !media.url) { 24447 resetBackgroundImage(); 24448 setIsUploading(false); 24449 return; 24450 } 24451 if ((0,external_wp_blob_namespaceObject.isBlobURL)(media.url)) { 24452 setIsUploading(true); 24453 return; 24454 } 24455 24456 // For media selections originated from a file upload. 24457 if (media.media_type && media.media_type !== IMAGE_BACKGROUND_TYPE || !media.media_type && media.type && media.type !== IMAGE_BACKGROUND_TYPE) { 24458 onUploadError((0,external_wp_i18n_namespaceObject.__)('Only images can be used as a background image.')); 24459 return; 24460 } 24461 const sizeValue = style?.background?.backgroundSize || defaultValues?.backgroundSize; 24462 const positionValue = style?.background?.backgroundPosition; 24463 onChange(setImmutably(style, ['background'], { 24464 ...style?.background, 24465 backgroundImage: { 24466 url: media.url, 24467 id: media.id, 24468 source: 'file', 24469 title: media.title || undefined 24470 }, 24471 backgroundPosition: 24472 /* 24473 * A background image uploaded and set in the editor receives a default background position of '50% 0', 24474 * when the background image size is the equivalent of "Tile". 24475 * This is to increase the chance that the image's focus point is visible. 24476 * This is in-editor only to assist with the user experience. 24477 */ 24478 !positionValue && ('auto' === sizeValue || !sizeValue) ? '50% 0' : positionValue, 24479 backgroundSize: sizeValue 24480 })); 24481 setIsUploading(false); 24482 }; 24483 24484 // Drag and drop callback, restricting image to one. 24485 const onFilesDrop = filesList => { 24486 if (filesList?.length > 1) { 24487 onUploadError((0,external_wp_i18n_namespaceObject.__)('Only one image can be used as a background image.')); 24488 return; 24489 } 24490 getSettings().mediaUpload({ 24491 allowedTypes: [IMAGE_BACKGROUND_TYPE], 24492 filesList, 24493 onFileChange([image]) { 24494 onSelectMedia(image); 24495 }, 24496 onError: onUploadError 24497 }); 24498 }; 24499 const hasValue = hasBackgroundImageValue(style); 24500 const closeAndFocus = () => { 24501 const [toggleButton] = external_wp_dom_namespaceObject.focus.tabbable.find(replaceContainerRef.current); 24502 // Focus the toggle button and close the dropdown menu. 24503 // This ensures similar behaviour as to selecting an image, where the dropdown is 24504 // closed and focus is redirected to the dropdown toggle button. 24505 toggleButton?.focus(); 24506 toggleButton?.click(); 24507 }; 24508 const onRemove = () => onChange(setImmutably(style, ['background'], { 24509 backgroundImage: 'none' 24510 })); 24511 const canRemove = !hasValue && hasBackgroundImageValue(inheritedValue); 24512 const imgLabel = title || (0,external_wp_url_namespaceObject.getFilename)(url) || (0,external_wp_i18n_namespaceObject.__)('Add background image'); 24513 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 24514 ref: replaceContainerRef, 24515 className: "block-editor-global-styles-background-panel__image-tools-panel-item", 24516 children: [isUploading && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LoadingSpinner, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_replace_flow, { 24517 mediaId: id, 24518 mediaURL: url, 24519 allowedTypes: [IMAGE_BACKGROUND_TYPE], 24520 accept: "image/*", 24521 onSelect: onSelectMedia, 24522 popoverProps: { 24523 className: dist_clsx({ 24524 'block-editor-global-styles-background-panel__media-replace-popover': displayInPanel 24525 }) 24526 }, 24527 name: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorImagePreviewItem, { 24528 className: "block-editor-global-styles-background-panel__image-preview", 24529 imgUrl: url, 24530 filename: title, 24531 label: imgLabel 24532 }), 24533 variant: "secondary", 24534 onError: onUploadError, 24535 onReset: () => { 24536 closeAndFocus(); 24537 onResetImage(); 24538 }, 24539 children: canRemove && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 24540 onClick: () => { 24541 closeAndFocus(); 24542 onRemove(); 24543 onRemoveImage(); 24544 }, 24545 children: (0,external_wp_i18n_namespaceObject.__)('Remove') 24546 }) 24547 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropZone, { 24548 onFilesDrop: onFilesDrop, 24549 label: (0,external_wp_i18n_namespaceObject.__)('Drop to upload') 24550 })] 24551 }); 24552 } 24553 function BackgroundSizeControls({ 24554 onChange, 24555 style, 24556 inheritedValue, 24557 defaultValues 24558 }) { 24559 const sizeValue = style?.background?.backgroundSize || inheritedValue?.background?.backgroundSize; 24560 const repeatValue = style?.background?.backgroundRepeat || inheritedValue?.background?.backgroundRepeat; 24561 const imageValue = style?.background?.backgroundImage?.url || inheritedValue?.background?.backgroundImage?.url; 24562 const isUploadedImage = style?.background?.backgroundImage?.id; 24563 const positionValue = style?.background?.backgroundPosition || inheritedValue?.background?.backgroundPosition; 24564 const attachmentValue = style?.background?.backgroundAttachment || inheritedValue?.background?.backgroundAttachment; 24565 24566 /* 24567 * Set default values for uploaded images. 24568 * The default values are passed by the consumer. 24569 * Block-level controls may have different defaults to root-level controls. 24570 * A falsy value is treated by default as `auto` (Tile). 24571 */ 24572 let currentValueForToggle = !sizeValue && isUploadedImage ? defaultValues?.backgroundSize : sizeValue || 'auto'; 24573 /* 24574 * The incoming value could be a value + unit, e.g. '20px'. 24575 * In this case set the value to 'tile'. 24576 */ 24577 currentValueForToggle = !['cover', 'contain', 'auto'].includes(currentValueForToggle) ? 'auto' : currentValueForToggle; 24578 /* 24579 * If the current value is `cover` and the repeat value is `undefined`, then 24580 * the toggle should be unchecked as the default state. Otherwise, the toggle 24581 * should reflect the current repeat value. 24582 */ 24583 const repeatCheckedValue = !(repeatValue === 'no-repeat' || currentValueForToggle === 'cover' && repeatValue === undefined); 24584 const updateBackgroundSize = next => { 24585 // When switching to 'contain' toggle the repeat off. 24586 let nextRepeat = repeatValue; 24587 let nextPosition = positionValue; 24588 if (next === 'contain') { 24589 nextRepeat = 'no-repeat'; 24590 nextPosition = undefined; 24591 } 24592 if (next === 'cover') { 24593 nextRepeat = undefined; 24594 nextPosition = undefined; 24595 } 24596 if ((currentValueForToggle === 'cover' || currentValueForToggle === 'contain') && next === 'auto') { 24597 nextRepeat = undefined; 24598 /* 24599 * A background image uploaded and set in the editor (an image with a record id), 24600 * receives a default background position of '50% 0', 24601 * when the toggle switches to "Tile". This is to increase the chance that 24602 * the image's focus point is visible. 24603 * This is in-editor only to assist with the user experience. 24604 */ 24605 if (!!style?.background?.backgroundImage?.id) { 24606 nextPosition = '50% 0'; 24607 } 24608 } 24609 24610 /* 24611 * Next will be null when the input is cleared, 24612 * in which case the value should be 'auto'. 24613 */ 24614 if (!next && currentValueForToggle === 'auto') { 24615 next = 'auto'; 24616 } 24617 onChange(setImmutably(style, ['background'], { 24618 ...style?.background, 24619 backgroundPosition: nextPosition, 24620 backgroundRepeat: nextRepeat, 24621 backgroundSize: next 24622 })); 24623 }; 24624 const updateBackgroundPosition = next => { 24625 onChange(setImmutably(style, ['background', 'backgroundPosition'], coordsToBackgroundPosition(next))); 24626 }; 24627 const toggleIsRepeated = () => onChange(setImmutably(style, ['background', 'backgroundRepeat'], repeatCheckedValue === true ? 'no-repeat' : 'repeat')); 24628 const toggleScrollWithPage = () => onChange(setImmutably(style, ['background', 'backgroundAttachment'], attachmentValue === 'fixed' ? 'scroll' : 'fixed')); 24629 24630 // Set a default background position for non-site-wide, uploaded images with a size of 'contain'. 24631 const backgroundPositionValue = !positionValue && isUploadedImage && 'contain' === sizeValue ? defaultValues?.backgroundPosition : positionValue; 24632 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 24633 spacing: 3, 24634 className: "single-column", 24635 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FocalPointPicker, { 24636 __nextHasNoMarginBottom: true, 24637 label: (0,external_wp_i18n_namespaceObject.__)('Focal point'), 24638 url: imageValue, 24639 value: backgroundPositionToCoords(backgroundPositionValue), 24640 onChange: updateBackgroundPosition 24641 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, { 24642 __nextHasNoMarginBottom: true, 24643 label: (0,external_wp_i18n_namespaceObject.__)('Fixed background'), 24644 checked: attachmentValue === 'fixed', 24645 onChange: toggleScrollWithPage 24646 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 24647 __nextHasNoMarginBottom: true, 24648 size: "__unstable-large", 24649 label: (0,external_wp_i18n_namespaceObject.__)('Size'), 24650 value: currentValueForToggle, 24651 onChange: updateBackgroundSize, 24652 isBlock: true, 24653 help: backgroundSizeHelpText(sizeValue || defaultValues?.backgroundSize), 24654 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, { 24655 value: "cover", 24656 label: (0,external_wp_i18n_namespaceObject._x)('Cover', 'Size option for background image control') 24657 }, "cover"), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, { 24658 value: "contain", 24659 label: (0,external_wp_i18n_namespaceObject._x)('Contain', 'Size option for background image control') 24660 }, "contain"), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, { 24661 value: "auto", 24662 label: (0,external_wp_i18n_namespaceObject._x)('Tile', 'Size option for background image control') 24663 }, "tile")] 24664 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 24665 justify: "flex-start", 24666 spacing: 2, 24667 as: "span", 24668 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 24669 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Background image width'), 24670 onChange: updateBackgroundSize, 24671 value: sizeValue, 24672 size: "__unstable-large", 24673 __unstableInputWidth: "100px", 24674 min: 0, 24675 placeholder: (0,external_wp_i18n_namespaceObject.__)('Auto'), 24676 disabled: currentValueForToggle !== 'auto' || currentValueForToggle === undefined 24677 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, { 24678 __nextHasNoMarginBottom: true, 24679 label: (0,external_wp_i18n_namespaceObject.__)('Repeat'), 24680 checked: repeatCheckedValue, 24681 onChange: toggleIsRepeated, 24682 disabled: currentValueForToggle === 'cover' 24683 })] 24684 })] 24685 }); 24686 } 24687 function BackgroundImagePanel({ 24688 value, 24689 onChange, 24690 inheritedValue = value, 24691 settings, 24692 defaultValues = {} 24693 }) { 24694 /* 24695 * Resolve any inherited "ref" pointers. 24696 * Should the block editor need resolved, inherited values 24697 * across all controls, this could be abstracted into a hook, 24698 * e.g., useResolveGlobalStyle 24699 */ 24700 const { 24701 globalStyles, 24702 _links 24703 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 24704 const { 24705 getSettings 24706 } = select(store); 24707 const _settings = getSettings(); 24708 return { 24709 globalStyles: _settings[globalStylesDataKey], 24710 _links: _settings[globalStylesLinksDataKey] 24711 }; 24712 }, []); 24713 const resolvedInheritedValue = (0,external_wp_element_namespaceObject.useMemo)(() => { 24714 const resolvedValues = { 24715 background: {} 24716 }; 24717 if (!inheritedValue?.background) { 24718 return inheritedValue; 24719 } 24720 Object.entries(inheritedValue?.background).forEach(([key, backgroundValue]) => { 24721 resolvedValues.background[key] = getResolvedValue(backgroundValue, { 24722 styles: globalStyles, 24723 _links 24724 }); 24725 }); 24726 return resolvedValues; 24727 }, [globalStyles, _links, inheritedValue]); 24728 const resetBackground = () => onChange(setImmutably(value, ['background'], {})); 24729 const { 24730 title, 24731 url 24732 } = value?.background?.backgroundImage || { 24733 ...resolvedInheritedValue?.background?.backgroundImage 24734 }; 24735 const hasImageValue = hasBackgroundImageValue(value) || hasBackgroundImageValue(resolvedInheritedValue); 24736 const imageValue = value?.background?.backgroundImage || inheritedValue?.background?.backgroundImage; 24737 const shouldShowBackgroundImageControls = hasImageValue && 'none' !== imageValue && (settings?.background?.backgroundSize || settings?.background?.backgroundPosition || settings?.background?.backgroundRepeat); 24738 const [isDropDownOpen, setIsDropDownOpen] = (0,external_wp_element_namespaceObject.useState)(false); 24739 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 24740 className: dist_clsx('block-editor-global-styles-background-panel__inspector-media-replace-container', { 24741 'is-open': isDropDownOpen 24742 }), 24743 children: shouldShowBackgroundImageControls ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundControlsPanel, { 24744 label: title, 24745 filename: title, 24746 url: url, 24747 onToggle: setIsDropDownOpen, 24748 hasImageValue: hasImageValue, 24749 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 24750 spacing: 3, 24751 className: "single-column", 24752 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundImageControls, { 24753 onChange: onChange, 24754 style: value, 24755 inheritedValue: resolvedInheritedValue, 24756 displayInPanel: true, 24757 onResetImage: () => { 24758 setIsDropDownOpen(false); 24759 resetBackground(); 24760 }, 24761 onRemoveImage: () => setIsDropDownOpen(false), 24762 defaultValues: defaultValues 24763 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundSizeControls, { 24764 onChange: onChange, 24765 style: value, 24766 defaultValues: defaultValues, 24767 inheritedValue: resolvedInheritedValue 24768 })] 24769 }) 24770 }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundImageControls, { 24771 onChange: onChange, 24772 style: value, 24773 inheritedValue: resolvedInheritedValue, 24774 defaultValues: defaultValues, 24775 onResetImage: () => { 24776 setIsDropDownOpen(false); 24777 resetBackground(); 24778 }, 24779 onRemoveImage: () => setIsDropDownOpen(false) 24780 }) 24781 }); 24782 } 24783 24784 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/background-panel.js 24785 /** 24786 * WordPress dependencies 24787 */ 24788 24789 24790 /** 24791 * Internal dependencies 24792 */ 24793 24794 24795 24796 24797 24798 const background_panel_DEFAULT_CONTROLS = { 24799 backgroundImage: true 24800 }; 24801 24802 /** 24803 * Checks site settings to see if the background panel may be used. 24804 * `settings.background.backgroundSize` exists also, 24805 * but can only be used if settings?.background?.backgroundImage is `true`. 24806 * 24807 * @param {Object} settings Site settings 24808 * @return {boolean} Whether site settings has activated background panel. 24809 */ 24810 function useHasBackgroundPanel(settings) { 24811 return external_wp_element_namespaceObject.Platform.OS === 'web' && settings?.background?.backgroundImage; 24812 } 24813 24814 /** 24815 * Checks if there is a current value in the background size block support 24816 * attributes. Background size values include background size as well 24817 * as background position. 24818 * 24819 * @param {Object} style Style attribute. 24820 * @return {boolean} Whether the block has a background size value set. 24821 */ 24822 function hasBackgroundSizeValue(style) { 24823 return style?.background?.backgroundPosition !== undefined || style?.background?.backgroundSize !== undefined; 24824 } 24825 24826 /** 24827 * Checks if there is a current value in the background image block support 24828 * attributes. 24829 * 24830 * @param {Object} style Style attribute. 24831 * @return {boolean} Whether the block has a background image value set. 24832 */ 24833 function hasBackgroundImageValue(style) { 24834 return !!style?.background?.backgroundImage?.id || 24835 // Supports url() string values in theme.json. 24836 'string' === typeof style?.background?.backgroundImage || !!style?.background?.backgroundImage?.url; 24837 } 24838 function BackgroundToolsPanel({ 24839 resetAllFilter, 24840 onChange, 24841 value, 24842 panelId, 24843 children, 24844 headerLabel 24845 }) { 24846 const dropdownMenuProps = useToolsPanelDropdownMenuProps(); 24847 const resetAll = () => { 24848 const updatedValue = resetAllFilter(value); 24849 onChange(updatedValue); 24850 }; 24851 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, { 24852 label: headerLabel, 24853 resetAll: resetAll, 24854 panelId: panelId, 24855 dropdownMenuProps: dropdownMenuProps, 24856 children: children 24857 }); 24858 } 24859 function background_panel_BackgroundImagePanel({ 24860 as: Wrapper = BackgroundToolsPanel, 24861 value, 24862 onChange, 24863 inheritedValue, 24864 settings, 24865 panelId, 24866 defaultControls = background_panel_DEFAULT_CONTROLS, 24867 defaultValues = {}, 24868 headerLabel = (0,external_wp_i18n_namespaceObject.__)('Background image') 24869 }) { 24870 const showBackgroundImageControl = useHasBackgroundPanel(settings); 24871 const resetBackground = () => onChange(setImmutably(value, ['background'], {})); 24872 const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue => { 24873 return { 24874 ...previousValue, 24875 background: {} 24876 }; 24877 }, []); 24878 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Wrapper, { 24879 resetAllFilter: resetAllFilter, 24880 value: value, 24881 onChange: onChange, 24882 panelId: panelId, 24883 headerLabel: headerLabel, 24884 children: showBackgroundImageControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 24885 hasValue: () => !!value?.background, 24886 label: (0,external_wp_i18n_namespaceObject.__)('Image'), 24887 onDeselect: resetBackground, 24888 isShownByDefault: defaultControls.backgroundImage, 24889 panelId: panelId, 24890 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundImagePanel, { 24891 value: value, 24892 onChange: onChange, 24893 settings: settings, 24894 inheritedValue: inheritedValue, 24895 defaultControls: defaultControls, 24896 defaultValues: defaultValues 24897 }) 24898 }) 24899 }); 24900 } 24901 24902 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/background.js 24903 /** 24904 * WordPress dependencies 24905 */ 24906 24907 24908 24909 24910 /** 24911 * Internal dependencies 24912 */ 24913 24914 24915 24916 24917 24918 24919 const BACKGROUND_SUPPORT_KEY = 'background'; 24920 24921 // Initial control values. 24922 const BACKGROUND_BLOCK_DEFAULT_VALUES = { 24923 backgroundSize: 'cover', 24924 backgroundPosition: '50% 50%' // used only when backgroundSize is 'contain'. 24925 }; 24926 24927 /** 24928 * Determine whether there is block support for background. 24929 * 24930 * @param {string} blockName Block name. 24931 * @param {string} feature Background image feature to check for. 24932 * 24933 * @return {boolean} Whether there is support. 24934 */ 24935 function hasBackgroundSupport(blockName, feature = 'any') { 24936 const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, BACKGROUND_SUPPORT_KEY); 24937 if (support === true) { 24938 return true; 24939 } 24940 if (feature === 'any') { 24941 return !!support?.backgroundImage || !!support?.backgroundSize || !!support?.backgroundRepeat; 24942 } 24943 return !!support?.[feature]; 24944 } 24945 function setBackgroundStyleDefaults(backgroundStyle) { 24946 if (!backgroundStyle || !backgroundStyle?.backgroundImage?.url) { 24947 return; 24948 } 24949 let backgroundStylesWithDefaults; 24950 24951 // Set block background defaults. 24952 if (!backgroundStyle?.backgroundSize) { 24953 backgroundStylesWithDefaults = { 24954 backgroundSize: BACKGROUND_BLOCK_DEFAULT_VALUES.backgroundSize 24955 }; 24956 } 24957 if ('contain' === backgroundStyle?.backgroundSize && !backgroundStyle?.backgroundPosition) { 24958 backgroundStylesWithDefaults = { 24959 backgroundPosition: BACKGROUND_BLOCK_DEFAULT_VALUES.backgroundPosition 24960 }; 24961 } 24962 return backgroundStylesWithDefaults; 24963 } 24964 function background_useBlockProps({ 24965 name, 24966 style 24967 }) { 24968 if (!hasBackgroundSupport(name) || !style?.background?.backgroundImage) { 24969 return; 24970 } 24971 const backgroundStyles = setBackgroundStyleDefaults(style?.background); 24972 if (!backgroundStyles) { 24973 return; 24974 } 24975 return { 24976 style: { 24977 ...backgroundStyles 24978 } 24979 }; 24980 } 24981 24982 /** 24983 * Generates a CSS class name if an background image is set. 24984 * 24985 * @param {Object} style A block's style attribute. 24986 * 24987 * @return {string} CSS class name. 24988 */ 24989 function getBackgroundImageClasses(style) { 24990 return hasBackgroundImageValue(style) ? 'has-background' : ''; 24991 } 24992 function BackgroundInspectorControl({ 24993 children 24994 }) { 24995 const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes => { 24996 return { 24997 ...attributes, 24998 style: { 24999 ...attributes.style, 25000 background: undefined 25001 } 25002 }; 25003 }, []); 25004 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, { 25005 group: "background", 25006 resetAllFilter: resetAllFilter, 25007 children: children 25008 }); 25009 } 25010 function background_BackgroundImagePanel({ 25011 clientId, 25012 name, 25013 setAttributes, 25014 settings 25015 }) { 25016 const { 25017 style, 25018 inheritedValue 25019 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 25020 const { 25021 getBlockAttributes, 25022 getSettings 25023 } = select(store); 25024 const _settings = getSettings(); 25025 return { 25026 style: getBlockAttributes(clientId)?.style, 25027 /* 25028 * To ensure we pass down the right inherited values: 25029 * @TODO 1. Pass inherited value down to all block style controls, 25030 * See: packages/block-editor/src/hooks/style.js 25031 * @TODO 2. Add support for block style variations, 25032 * See implementation: packages/block-editor/src/hooks/block-style-variation.js 25033 */ 25034 inheritedValue: _settings[globalStylesDataKey]?.blocks?.[name] 25035 }; 25036 }, [clientId, name]); 25037 if (!useHasBackgroundPanel(settings) || !hasBackgroundSupport(name, 'backgroundImage')) { 25038 return null; 25039 } 25040 const onChange = newStyle => { 25041 setAttributes({ 25042 style: utils_cleanEmptyObject(newStyle) 25043 }); 25044 }; 25045 const updatedSettings = { 25046 ...settings, 25047 background: { 25048 ...settings.background, 25049 backgroundSize: settings?.background?.backgroundSize && hasBackgroundSupport(name, 'backgroundSize') 25050 } 25051 }; 25052 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(background_panel_BackgroundImagePanel, { 25053 inheritedValue: inheritedValue, 25054 as: BackgroundInspectorControl, 25055 panelId: clientId, 25056 defaultValues: BACKGROUND_BLOCK_DEFAULT_VALUES, 25057 settings: updatedSettings, 25058 onChange: onChange, 25059 value: style 25060 }); 25061 } 25062 /* harmony default export */ const background = ({ 25063 useBlockProps: background_useBlockProps, 25064 attributeKeys: ['style'], 25065 hasSupport: hasBackgroundSupport 25066 }); 25067 25068 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/lock.js 25069 /** 25070 * WordPress dependencies 25071 */ 25072 25073 25074 /** 25075 * Filters registered block settings, extending attributes to include `lock`. 25076 * 25077 * @param {Object} settings Original block settings. 25078 * 25079 * @return {Object} Filtered block settings. 25080 */ 25081 function lock_addAttribute(settings) { 25082 var _settings$attributes$; 25083 // Allow blocks to specify their own attribute definition with default values if needed. 25084 if ('type' in ((_settings$attributes$ = settings.attributes?.lock) !== null && _settings$attributes$ !== void 0 ? _settings$attributes$ : {})) { 25085 return settings; 25086 } 25087 // Gracefully handle if settings.attributes is undefined. 25088 settings.attributes = { 25089 ...settings.attributes, 25090 lock: { 25091 type: 'object' 25092 } 25093 }; 25094 return settings; 25095 } 25096 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/lock/addAttribute', lock_addAttribute); 25097 25098 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/anchor.js 25099 /** 25100 * WordPress dependencies 25101 */ 25102 25103 25104 25105 25106 25107 25108 /** 25109 * Internal dependencies 25110 */ 25111 25112 25113 25114 /** 25115 * Regular expression matching invalid anchor characters for replacement. 25116 * 25117 * @type {RegExp} 25118 */ 25119 25120 25121 25122 const ANCHOR_REGEX = /[\s#]/g; 25123 const ANCHOR_SCHEMA = { 25124 type: 'string', 25125 source: 'attribute', 25126 attribute: 'id', 25127 selector: '*' 25128 }; 25129 25130 /** 25131 * Filters registered block settings, extending attributes with anchor using ID 25132 * of the first node. 25133 * 25134 * @param {Object} settings Original block settings. 25135 * 25136 * @return {Object} Filtered block settings. 25137 */ 25138 function anchor_addAttribute(settings) { 25139 var _settings$attributes$; 25140 // Allow blocks to specify their own attribute definition with default values if needed. 25141 if ('type' in ((_settings$attributes$ = settings.attributes?.anchor) !== null && _settings$attributes$ !== void 0 ? _settings$attributes$ : {})) { 25142 return settings; 25143 } 25144 if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'anchor')) { 25145 // Gracefully handle if settings.attributes is undefined. 25146 settings.attributes = { 25147 ...settings.attributes, 25148 anchor: ANCHOR_SCHEMA 25149 }; 25150 } 25151 return settings; 25152 } 25153 function BlockEditAnchorControlPure({ 25154 anchor, 25155 setAttributes 25156 }) { 25157 const blockEditingMode = useBlockEditingMode(); 25158 if (blockEditingMode !== 'default') { 25159 return null; 25160 } 25161 const isWeb = external_wp_element_namespaceObject.Platform.OS === 'web'; 25162 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, { 25163 group: "advanced", 25164 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, { 25165 __nextHasNoMarginBottom: true, 25166 __next40pxDefaultSize: true, 25167 className: "html-anchor-control", 25168 label: (0,external_wp_i18n_namespaceObject.__)('HTML anchor'), 25169 help: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 25170 children: [(0,external_wp_i18n_namespaceObject.__)('Enter a word or two — without spaces — to make a unique web address just for this block, called an “anchor”. Then, you’ll be able to link directly to this section of your page.'), isWeb && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 25171 children: [' ', /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, { 25172 href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/documentation/article/page-jumps/'), 25173 children: (0,external_wp_i18n_namespaceObject.__)('Learn more about anchors') 25174 })] 25175 })] 25176 }), 25177 value: anchor || '', 25178 placeholder: !isWeb ? (0,external_wp_i18n_namespaceObject.__)('Add an anchor') : null, 25179 onChange: nextValue => { 25180 nextValue = nextValue.replace(ANCHOR_REGEX, '-'); 25181 setAttributes({ 25182 anchor: nextValue 25183 }); 25184 }, 25185 autoCapitalize: "none", 25186 autoComplete: "off" 25187 }) 25188 }); 25189 } 25190 /* harmony default export */ const hooks_anchor = ({ 25191 addSaveProps, 25192 edit: BlockEditAnchorControlPure, 25193 attributeKeys: ['anchor'], 25194 hasSupport(name) { 25195 return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'anchor'); 25196 } 25197 }); 25198 25199 /** 25200 * Override props assigned to save component to inject anchor ID, if block 25201 * supports anchor. This is only applied if the block's save result is an 25202 * element and not a markup string. 25203 * 25204 * @param {Object} extraProps Additional props applied to save element. 25205 * @param {Object} blockType Block type. 25206 * @param {Object} attributes Current block attributes. 25207 * 25208 * @return {Object} Filtered props applied to save element. 25209 */ 25210 function addSaveProps(extraProps, blockType, attributes) { 25211 if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'anchor')) { 25212 extraProps.id = attributes.anchor === '' ? null : attributes.anchor; 25213 } 25214 return extraProps; 25215 } 25216 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/anchor/attribute', anchor_addAttribute); 25217 25218 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/aria-label.js 25219 /** 25220 * WordPress dependencies 25221 */ 25222 25223 25224 const ARIA_LABEL_SCHEMA = { 25225 type: 'string', 25226 source: 'attribute', 25227 attribute: 'aria-label', 25228 selector: '*' 25229 }; 25230 25231 /** 25232 * Filters registered block settings, extending attributes with ariaLabel using aria-label 25233 * of the first node. 25234 * 25235 * @param {Object} settings Original block settings. 25236 * 25237 * @return {Object} Filtered block settings. 25238 */ 25239 function aria_label_addAttribute(settings) { 25240 // Allow blocks to specify their own attribute definition with default values if needed. 25241 if (settings?.attributes?.ariaLabel?.type) { 25242 return settings; 25243 } 25244 if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'ariaLabel')) { 25245 // Gracefully handle if settings.attributes is undefined. 25246 settings.attributes = { 25247 ...settings.attributes, 25248 ariaLabel: ARIA_LABEL_SCHEMA 25249 }; 25250 } 25251 return settings; 25252 } 25253 25254 /** 25255 * Override props assigned to save component to inject aria-label, if block 25256 * supports ariaLabel. This is only applied if the block's save result is an 25257 * element and not a markup string. 25258 * 25259 * @param {Object} extraProps Additional props applied to save element. 25260 * @param {Object} blockType Block type. 25261 * @param {Object} attributes Current block attributes. 25262 * 25263 * @return {Object} Filtered props applied to save element. 25264 */ 25265 function aria_label_addSaveProps(extraProps, blockType, attributes) { 25266 if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'ariaLabel')) { 25267 extraProps['aria-label'] = attributes.ariaLabel === '' ? null : attributes.ariaLabel; 25268 } 25269 return extraProps; 25270 } 25271 /* harmony default export */ const aria_label = ({ 25272 addSaveProps: aria_label_addSaveProps, 25273 attributeKeys: ['ariaLabel'], 25274 hasSupport(name) { 25275 return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'ariaLabel'); 25276 } 25277 }); 25278 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/ariaLabel/attribute', aria_label_addAttribute); 25279 25280 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/custom-class-name.js 25281 /** 25282 * External dependencies 25283 */ 25284 25285 25286 /** 25287 * WordPress dependencies 25288 */ 25289 25290 25291 25292 25293 25294 /** 25295 * Internal dependencies 25296 */ 25297 25298 25299 25300 /** 25301 * Filters registered block settings, extending attributes to include `className`. 25302 * 25303 * @param {Object} settings Original block settings. 25304 * 25305 * @return {Object} Filtered block settings. 25306 */ 25307 25308 function custom_class_name_addAttribute(settings) { 25309 if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'customClassName', true)) { 25310 // Gracefully handle if settings.attributes is undefined. 25311 settings.attributes = { 25312 ...settings.attributes, 25313 className: { 25314 type: 'string' 25315 } 25316 }; 25317 } 25318 return settings; 25319 } 25320 function CustomClassNameControlsPure({ 25321 className, 25322 setAttributes 25323 }) { 25324 const blockEditingMode = useBlockEditingMode(); 25325 if (blockEditingMode !== 'default') { 25326 return null; 25327 } 25328 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, { 25329 group: "advanced", 25330 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, { 25331 __nextHasNoMarginBottom: true, 25332 __next40pxDefaultSize: true, 25333 autoComplete: "off", 25334 label: (0,external_wp_i18n_namespaceObject.__)('Additional CSS class(es)'), 25335 value: className || '', 25336 onChange: nextValue => { 25337 setAttributes({ 25338 className: nextValue !== '' ? nextValue : undefined 25339 }); 25340 }, 25341 help: (0,external_wp_i18n_namespaceObject.__)('Separate multiple classes with spaces.') 25342 }) 25343 }); 25344 } 25345 /* harmony default export */ const custom_class_name = ({ 25346 edit: CustomClassNameControlsPure, 25347 addSaveProps: custom_class_name_addSaveProps, 25348 attributeKeys: ['className'], 25349 hasSupport(name) { 25350 return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'customClassName', true); 25351 } 25352 }); 25353 25354 /** 25355 * Override props assigned to save component to inject the className, if block 25356 * supports customClassName. This is only applied if the block's save result is an 25357 * element and not a markup string. 25358 * 25359 * @param {Object} extraProps Additional props applied to save element. 25360 * @param {Object} blockType Block type. 25361 * @param {Object} attributes Current block attributes. 25362 * 25363 * @return {Object} Filtered props applied to save element. 25364 */ 25365 function custom_class_name_addSaveProps(extraProps, blockType, attributes) { 25366 if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'customClassName', true) && attributes.className) { 25367 extraProps.className = dist_clsx(extraProps.className, attributes.className); 25368 } 25369 return extraProps; 25370 } 25371 function addTransforms(result, source, index, results) { 25372 if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(result.name, 'customClassName', true)) { 25373 return result; 25374 } 25375 25376 // If the condition verifies we are probably in the presence of a wrapping transform 25377 // e.g: nesting paragraphs in a group or columns and in that case the class should not be kept. 25378 if (results.length === 1 && result.innerBlocks.length === source.length) { 25379 return result; 25380 } 25381 25382 // If we are transforming one block to multiple blocks or multiple blocks to one block, 25383 // we ignore the class during the transform. 25384 if (results.length === 1 && source.length > 1 || results.length > 1 && source.length === 1) { 25385 return result; 25386 } 25387 25388 // If we are in presence of transform between one or more block in the source 25389 // that have one or more blocks in the result 25390 // we apply the class on source N to the result N, 25391 // if source N does not exists we do nothing. 25392 if (source[index]) { 25393 const originClassName = source[index]?.attributes.className; 25394 if (originClassName) { 25395 return { 25396 ...result, 25397 attributes: { 25398 ...result.attributes, 25399 className: originClassName 25400 } 25401 }; 25402 } 25403 } 25404 return result; 25405 } 25406 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/editor/custom-class-name/attribute', custom_class_name_addAttribute); 25407 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.switchToBlockType.transformedBlock', 'core/color/addTransforms', addTransforms); 25408 25409 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/generated-class-name.js 25410 /** 25411 * WordPress dependencies 25412 */ 25413 25414 25415 25416 /** 25417 * Override props assigned to save component to inject generated className if 25418 * block supports it. This is only applied if the block's save result is an 25419 * element and not a markup string. 25420 * 25421 * @param {Object} extraProps Additional props applied to save element. 25422 * @param {Object} blockType Block type. 25423 * 25424 * @return {Object} Filtered props applied to save element. 25425 */ 25426 function addGeneratedClassName(extraProps, blockType) { 25427 // Adding the generated className. 25428 if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'className', true)) { 25429 if (typeof extraProps.className === 'string') { 25430 // We have some extra classes and want to add the default classname 25431 // We use uniq to prevent duplicate classnames. 25432 25433 extraProps.className = [...new Set([(0,external_wp_blocks_namespaceObject.getBlockDefaultClassName)(blockType.name), ...extraProps.className.split(' ')])].join(' ').trim(); 25434 } else { 25435 // There is no string in the className variable, 25436 // so we just dump the default name in there. 25437 extraProps.className = (0,external_wp_blocks_namespaceObject.getBlockDefaultClassName)(blockType.name); 25438 } 25439 } 25440 return extraProps; 25441 } 25442 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.getSaveContent.extraProps', 'core/generated-class-name/save-props', addGeneratedClassName); 25443 25444 ;// ./node_modules/colord/index.mjs 25445 var colord_r={grad:.9,turn:360,rad:360/(2*Math.PI)},t=function(r){return"string"==typeof r?r.length>0:"number"==typeof r},n=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=Math.pow(10,t)),Math.round(n*r)/n+0},e=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=1),r>n?n:r>t?r:t},u=function(r){return(r=isFinite(r)?r%360:0)>0?r:r+360},a=function(r){return{r:e(r.r,0,255),g:e(r.g,0,255),b:e(r.b,0,255),a:e(r.a)}},o=function(r){return{r:n(r.r),g:n(r.g),b:n(r.b),a:n(r.a,3)}},i=/^#([0-9a-f]{3,8})$/i,s=function(r){var t=r.toString(16);return t.length<2?"0"+t:t},h=function(r){var t=r.r,n=r.g,e=r.b,u=r.a,a=Math.max(t,n,e),o=a-Math.min(t,n,e),i=o?a===t?(n-e)/o:a===n?2+(e-t)/o:4+(t-n)/o:0;return{h:60*(i<0?i+6:i),s:a?o/a*100:0,v:a/255*100,a:u}},b=function(r){var t=r.h,n=r.s,e=r.v,u=r.a;t=t/360*6,n/=100,e/=100;var a=Math.floor(t),o=e*(1-n),i=e*(1-(t-a)*n),s=e*(1-(1-t+a)*n),h=a%6;return{r:255*[e,i,o,o,s,e][h],g:255*[s,e,e,i,o,o][h],b:255*[o,o,s,e,e,i][h],a:u}},g=function(r){return{h:u(r.h),s:e(r.s,0,100),l:e(r.l,0,100),a:e(r.a)}},d=function(r){return{h:n(r.h),s:n(r.s),l:n(r.l),a:n(r.a,3)}},f=function(r){return b((n=(t=r).s,{h:t.h,s:(n*=((e=t.l)<50?e:100-e)/100)>0?2*n/(e+n)*100:0,v:e+n,a:t.a}));var t,n,e},c=function(r){return{h:(t=h(r)).h,s:(u=(200-(n=t.s))*(e=t.v)/100)>0&&u<200?n*e/100/(u<=100?u:200-u)*100:0,l:u/2,a:t.a};var t,n,e,u},l=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,p=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,v=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,m=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,y={string:[[function(r){var t=i.exec(r);return t?(r=t[1]).length<=4?{r:parseInt(r[0]+r[0],16),g:parseInt(r[1]+r[1],16),b:parseInt(r[2]+r[2],16),a:4===r.length?n(parseInt(r[3]+r[3],16)/255,2):1}:6===r.length||8===r.length?{r:parseInt(r.substr(0,2),16),g:parseInt(r.substr(2,2),16),b:parseInt(r.substr(4,2),16),a:8===r.length?n(parseInt(r.substr(6,2),16)/255,2):1}:null:null},"hex"],[function(r){var t=v.exec(r)||m.exec(r);return t?t[2]!==t[4]||t[4]!==t[6]?null:a({r:Number(t[1])/(t[2]?100/255:1),g:Number(t[3])/(t[4]?100/255:1),b:Number(t[5])/(t[6]?100/255:1),a:void 0===t[7]?1:Number(t[7])/(t[8]?100:1)}):null},"rgb"],[function(t){var n=l.exec(t)||p.exec(t);if(!n)return null;var e,u,a=g({h:(e=n[1],u=n[2],void 0===u&&(u="deg"),Number(e)*(colord_r[u]||1)),s:Number(n[3]),l:Number(n[4]),a:void 0===n[5]?1:Number(n[5])/(n[6]?100:1)});return f(a)},"hsl"]],object:[[function(r){var n=r.r,e=r.g,u=r.b,o=r.a,i=void 0===o?1:o;return t(n)&&t(e)&&t(u)?a({r:Number(n),g:Number(e),b:Number(u),a:Number(i)}):null},"rgb"],[function(r){var n=r.h,e=r.s,u=r.l,a=r.a,o=void 0===a?1:a;if(!t(n)||!t(e)||!t(u))return null;var i=g({h:Number(n),s:Number(e),l:Number(u),a:Number(o)});return f(i)},"hsl"],[function(r){var n=r.h,a=r.s,o=r.v,i=r.a,s=void 0===i?1:i;if(!t(n)||!t(a)||!t(o))return null;var h=function(r){return{h:u(r.h),s:e(r.s,0,100),v:e(r.v,0,100),a:e(r.a)}}({h:Number(n),s:Number(a),v:Number(o),a:Number(s)});return b(h)},"hsv"]]},N=function(r,t){for(var n=0;n<t.length;n++){var e=t[n][0](r);if(e)return[e,t[n][1]]}return[null,void 0]},x=function(r){return"string"==typeof r?N(r.trim(),y.string):"object"==typeof r&&null!==r?N(r,y.object):[null,void 0]},I=function(r){return x(r)[1]},M=function(r,t){var n=c(r);return{h:n.h,s:e(n.s+100*t,0,100),l:n.l,a:n.a}},H=function(r){return(299*r.r+587*r.g+114*r.b)/1e3/255},$=function(r,t){var n=c(r);return{h:n.h,s:n.s,l:e(n.l+100*t,0,100),a:n.a}},colord_j=function(){function r(r){this.parsed=x(r)[0],this.rgba=this.parsed||{r:0,g:0,b:0,a:1}}return r.prototype.isValid=function(){return null!==this.parsed},r.prototype.brightness=function(){return n(H(this.rgba),2)},r.prototype.isDark=function(){return H(this.rgba)<.5},r.prototype.isLight=function(){return H(this.rgba)>=.5},r.prototype.toHex=function(){return r=o(this.rgba),t=r.r,e=r.g,u=r.b,i=(a=r.a)<1?s(n(255*a)):"","#"+s(t)+s(e)+s(u)+i;var r,t,e,u,a,i},r.prototype.toRgb=function(){return o(this.rgba)},r.prototype.toRgbString=function(){return r=o(this.rgba),t=r.r,n=r.g,e=r.b,(u=r.a)<1?"rgba("+t+", "+n+", "+e+", "+u+")":"rgb("+t+", "+n+", "+e+")";var r,t,n,e,u},r.prototype.toHsl=function(){return d(c(this.rgba))},r.prototype.toHslString=function(){return r=d(c(this.rgba)),t=r.h,n=r.s,e=r.l,(u=r.a)<1?"hsla("+t+", "+n+"%, "+e+"%, "+u+")":"hsl("+t+", "+n+"%, "+e+"%)";var r,t,n,e,u},r.prototype.toHsv=function(){return r=h(this.rgba),{h:n(r.h),s:n(r.s),v:n(r.v),a:n(r.a,3)};var r},r.prototype.invert=function(){return w({r:255-(r=this.rgba).r,g:255-r.g,b:255-r.b,a:r.a});var r},r.prototype.saturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,r))},r.prototype.desaturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,-r))},r.prototype.grayscale=function(){return w(M(this.rgba,-1))},r.prototype.lighten=function(r){return void 0===r&&(r=.1),w($(this.rgba,r))},r.prototype.darken=function(r){return void 0===r&&(r=.1),w($(this.rgba,-r))},r.prototype.rotate=function(r){return void 0===r&&(r=15),this.hue(this.hue()+r)},r.prototype.alpha=function(r){return"number"==typeof r?w({r:(t=this.rgba).r,g:t.g,b:t.b,a:r}):n(this.rgba.a,3);var t},r.prototype.hue=function(r){var t=c(this.rgba);return"number"==typeof r?w({h:r,s:t.s,l:t.l,a:t.a}):n(t.h)},r.prototype.isEqual=function(r){return this.toHex()===w(r).toHex()},r}(),w=function(r){return r instanceof colord_j?r:new colord_j(r)},S=[],k=function(r){r.forEach(function(r){S.indexOf(r)<0&&(r(colord_j,y),S.push(r))})},E=function(){return new colord_j({r:255*Math.random(),g:255*Math.random(),b:255*Math.random()})}; 25446 25447 ;// ./node_modules/colord/plugins/names.mjs 25448 /* harmony default export */ function names(e,f){var a={white:"#ffffff",bisque:"#ffe4c4",blue:"#0000ff",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",antiquewhite:"#faebd7",aqua:"#00ffff",azure:"#f0ffff",whitesmoke:"#f5f5f5",papayawhip:"#ffefd5",plum:"#dda0dd",blanchedalmond:"#ffebcd",black:"#000000",gold:"#ffd700",goldenrod:"#daa520",gainsboro:"#dcdcdc",cornsilk:"#fff8dc",cornflowerblue:"#6495ed",burlywood:"#deb887",aquamarine:"#7fffd4",beige:"#f5f5dc",crimson:"#dc143c",cyan:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkkhaki:"#bdb76b",darkgray:"#a9a9a9",darkgreen:"#006400",darkgrey:"#a9a9a9",peachpuff:"#ffdab9",darkmagenta:"#8b008b",darkred:"#8b0000",darkorchid:"#9932cc",darkorange:"#ff8c00",darkslateblue:"#483d8b",gray:"#808080",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",deeppink:"#ff1493",deepskyblue:"#00bfff",wheat:"#f5deb3",firebrick:"#b22222",floralwhite:"#fffaf0",ghostwhite:"#f8f8ff",darkviolet:"#9400d3",magenta:"#ff00ff",green:"#008000",dodgerblue:"#1e90ff",grey:"#808080",honeydew:"#f0fff0",hotpink:"#ff69b4",blueviolet:"#8a2be2",forestgreen:"#228b22",lawngreen:"#7cfc00",indianred:"#cd5c5c",indigo:"#4b0082",fuchsia:"#ff00ff",brown:"#a52a2a",maroon:"#800000",mediumblue:"#0000cd",lightcoral:"#f08080",darkturquoise:"#00ced1",lightcyan:"#e0ffff",ivory:"#fffff0",lightyellow:"#ffffe0",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",linen:"#faf0e6",mediumaquamarine:"#66cdaa",lemonchiffon:"#fffacd",lime:"#00ff00",khaki:"#f0e68c",mediumseagreen:"#3cb371",limegreen:"#32cd32",mediumspringgreen:"#00fa9a",lightskyblue:"#87cefa",lightblue:"#add8e6",midnightblue:"#191970",lightpink:"#ffb6c1",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",mintcream:"#f5fffa",lightslategray:"#778899",lightslategrey:"#778899",navajowhite:"#ffdead",navy:"#000080",mediumvioletred:"#c71585",powderblue:"#b0e0e6",palegoldenrod:"#eee8aa",oldlace:"#fdf5e6",paleturquoise:"#afeeee",mediumturquoise:"#48d1cc",mediumorchid:"#ba55d3",rebeccapurple:"#663399",lightsteelblue:"#b0c4de",mediumslateblue:"#7b68ee",thistle:"#d8bfd8",tan:"#d2b48c",orchid:"#da70d6",mediumpurple:"#9370db",purple:"#800080",pink:"#ffc0cb",skyblue:"#87ceeb",springgreen:"#00ff7f",palegreen:"#98fb98",red:"#ff0000",yellow:"#ffff00",slateblue:"#6a5acd",lavenderblush:"#fff0f5",peru:"#cd853f",palevioletred:"#db7093",violet:"#ee82ee",teal:"#008080",slategray:"#708090",slategrey:"#708090",aliceblue:"#f0f8ff",darkseagreen:"#8fbc8f",darkolivegreen:"#556b2f",greenyellow:"#adff2f",seagreen:"#2e8b57",seashell:"#fff5ee",tomato:"#ff6347",silver:"#c0c0c0",sienna:"#a0522d",lavender:"#e6e6fa",lightgreen:"#90ee90",orange:"#ffa500",orangered:"#ff4500",steelblue:"#4682b4",royalblue:"#4169e1",turquoise:"#40e0d0",yellowgreen:"#9acd32",salmon:"#fa8072",saddlebrown:"#8b4513",sandybrown:"#f4a460",rosybrown:"#bc8f8f",darksalmon:"#e9967a",lightgoldenrodyellow:"#fafad2",snow:"#fffafa",lightgrey:"#d3d3d3",lightgray:"#d3d3d3",dimgray:"#696969",dimgrey:"#696969",olivedrab:"#6b8e23",olive:"#808000"},r={};for(var d in a)r[a[d]]=d;var l={};e.prototype.toName=function(f){if(!(this.rgba.a||this.rgba.r||this.rgba.g||this.rgba.b))return"transparent";var d,i,n=r[this.toHex()];if(n)return n;if(null==f?void 0:f.closest){var o=this.toRgb(),t=1/0,b="black";if(!l.length)for(var c in a)l[c]=new e(a[c]).toRgb();for(var g in a){var u=(d=o,i=l[g],Math.pow(d.r-i.r,2)+Math.pow(d.g-i.g,2)+Math.pow(d.b-i.b,2));u<t&&(t=u,b=g)}return b}};f.string.push([function(f){var r=f.toLowerCase(),d="transparent"===r?"#0000":a[r];return d?new e(d).toRgb():null},"name"])} 25449 25450 ;// ./node_modules/colord/plugins/a11y.mjs 25451 var a11y_o=function(o){var t=o/255;return t<.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)},a11y_t=function(t){return.2126*a11y_o(t.r)+.7152*a11y_o(t.g)+.0722*a11y_o(t.b)};/* harmony default export */ function a11y(o){o.prototype.luminance=function(){return o=a11y_t(this.rgba),void 0===(r=2)&&(r=0),void 0===n&&(n=Math.pow(10,r)),Math.round(n*o)/n+0;var o,r,n},o.prototype.contrast=function(r){void 0===r&&(r="#FFF");var n,a,i,e,v,u,d,c=r instanceof o?r:new o(r);return e=this.rgba,v=c.toRgb(),u=a11y_t(e),d=a11y_t(v),n=u>d?(u+.05)/(d+.05):(d+.05)/(u+.05),void 0===(a=2)&&(a=0),void 0===i&&(i=Math.pow(10,a)),Math.floor(i*n)/i+0},o.prototype.isReadable=function(o,t){return void 0===o&&(o="#FFF"),void 0===t&&(t={}),this.contrast(o)>=(e=void 0===(i=(r=t).size)?"normal":i,"AAA"===(a=void 0===(n=r.level)?"AA":n)&&"normal"===e?7:"AA"===a&&"large"===e?3:4.5);var r,n,a,i,e}} 25452 25453 ;// ./node_modules/@wordpress/block-editor/build-module/components/colors/utils.js 25454 /** 25455 * External dependencies 25456 */ 25457 25458 25459 25460 25461 /** 25462 * WordPress dependencies 25463 */ 25464 25465 25466 /** 25467 * Internal dependencies 25468 */ 25469 25470 k([names, a11y]); 25471 const { 25472 kebabCase 25473 } = unlock(external_wp_components_namespaceObject.privateApis); 25474 25475 /** 25476 * Provided an array of color objects as set by the theme or by the editor defaults, 25477 * and the values of the defined color or custom color returns a color object describing the color. 25478 * 25479 * @param {Array} colors Array of color objects as set by the theme or by the editor defaults. 25480 * @param {?string} definedColor A string containing the color slug. 25481 * @param {?string} customColor A string containing the customColor value. 25482 * 25483 * @return {?Object} If definedColor is passed and the name is found in colors, 25484 * the color object exactly as set by the theme or editor defaults is returned. 25485 * Otherwise, an object that just sets the color is defined. 25486 */ 25487 const getColorObjectByAttributeValues = (colors, definedColor, customColor) => { 25488 if (definedColor) { 25489 const colorObj = colors?.find(color => color.slug === definedColor); 25490 if (colorObj) { 25491 return colorObj; 25492 } 25493 } 25494 return { 25495 color: customColor 25496 }; 25497 }; 25498 25499 /** 25500 * Provided an array of color objects as set by the theme or by the editor defaults, and a color value returns the color object matching that value or undefined. 25501 * 25502 * @param {Array} colors Array of color objects as set by the theme or by the editor defaults. 25503 * @param {?string} colorValue A string containing the color value. 25504 * 25505 * @return {?Object} Color object included in the colors array whose color property equals colorValue. 25506 * Returns undefined if no color object matches this requirement. 25507 */ 25508 const getColorObjectByColorValue = (colors, colorValue) => { 25509 return colors?.find(color => color.color === colorValue); 25510 }; 25511 25512 /** 25513 * Returns a class based on the context a color is being used and its slug. 25514 * 25515 * @param {string} colorContextName Context/place where color is being used e.g: background, text etc... 25516 * @param {string} colorSlug Slug of the color. 25517 * 25518 * @return {?string} String with the class corresponding to the color in the provided context. 25519 * Returns undefined if either colorContextName or colorSlug are not provided. 25520 */ 25521 function getColorClassName(colorContextName, colorSlug) { 25522 if (!colorContextName || !colorSlug) { 25523 return undefined; 25524 } 25525 return `has-$kebabCase(colorSlug)}-$colorContextName}`; 25526 } 25527 25528 /** 25529 * Given an array of color objects and a color value returns the color value of the most readable color in the array. 25530 * 25531 * @param {Array} colors Array of color objects as set by the theme or by the editor defaults. 25532 * @param {?string} colorValue A string containing the color value. 25533 * 25534 * @return {string} String with the color value of the most readable color. 25535 */ 25536 function getMostReadableColor(colors, colorValue) { 25537 const colordColor = w(colorValue); 25538 const getColorContrast = ({ 25539 color 25540 }) => colordColor.contrast(color); 25541 const maxContrast = Math.max(...colors.map(getColorContrast)); 25542 return colors.find(color => getColorContrast(color) === maxContrast).color; 25543 } 25544 25545 ;// ./node_modules/@wordpress/block-editor/build-module/components/colors-gradients/use-multiple-origin-colors-and-gradients.js 25546 /** 25547 * WordPress dependencies 25548 */ 25549 25550 25551 25552 /** 25553 * Internal dependencies 25554 */ 25555 25556 25557 /** 25558 * Retrieves color and gradient related settings. 25559 * 25560 * The arrays for colors and gradients are made up of color palettes from each 25561 * origin i.e. "Core", "Theme", and "User". 25562 * 25563 * @return {Object} Color and gradient related settings. 25564 */ 25565 function useMultipleOriginColorsAndGradients() { 25566 const [enableCustomColors, customColors, themeColors, defaultColors, shouldDisplayDefaultColors, enableCustomGradients, customGradients, themeGradients, defaultGradients, shouldDisplayDefaultGradients] = use_settings_useSettings('color.custom', 'color.palette.custom', 'color.palette.theme', 'color.palette.default', 'color.defaultPalette', 'color.customGradient', 'color.gradients.custom', 'color.gradients.theme', 'color.gradients.default', 'color.defaultGradients'); 25567 const colorGradientSettings = { 25568 disableCustomColors: !enableCustomColors, 25569 disableCustomGradients: !enableCustomGradients 25570 }; 25571 colorGradientSettings.colors = (0,external_wp_element_namespaceObject.useMemo)(() => { 25572 const result = []; 25573 if (themeColors && themeColors.length) { 25574 result.push({ 25575 name: (0,external_wp_i18n_namespaceObject._x)('Theme', 'Indicates this palette comes from the theme.'), 25576 colors: themeColors 25577 }); 25578 } 25579 if (shouldDisplayDefaultColors && defaultColors && defaultColors.length) { 25580 result.push({ 25581 name: (0,external_wp_i18n_namespaceObject._x)('Default', 'Indicates this palette comes from WordPress.'), 25582 colors: defaultColors 25583 }); 25584 } 25585 if (customColors && customColors.length) { 25586 result.push({ 25587 name: (0,external_wp_i18n_namespaceObject._x)('Custom', 'Indicates this palette comes from the theme.'), 25588 colors: customColors 25589 }); 25590 } 25591 return result; 25592 }, [customColors, themeColors, defaultColors, shouldDisplayDefaultColors]); 25593 colorGradientSettings.gradients = (0,external_wp_element_namespaceObject.useMemo)(() => { 25594 const result = []; 25595 if (themeGradients && themeGradients.length) { 25596 result.push({ 25597 name: (0,external_wp_i18n_namespaceObject._x)('Theme', 'Indicates this palette comes from the theme.'), 25598 gradients: themeGradients 25599 }); 25600 } 25601 if (shouldDisplayDefaultGradients && defaultGradients && defaultGradients.length) { 25602 result.push({ 25603 name: (0,external_wp_i18n_namespaceObject._x)('Default', 'Indicates this palette comes from WordPress.'), 25604 gradients: defaultGradients 25605 }); 25606 } 25607 if (customGradients && customGradients.length) { 25608 result.push({ 25609 name: (0,external_wp_i18n_namespaceObject._x)('Custom', 'Indicates this palette is created by the user.'), 25610 gradients: customGradients 25611 }); 25612 } 25613 return result; 25614 }, [customGradients, themeGradients, defaultGradients, shouldDisplayDefaultGradients]); 25615 colorGradientSettings.hasColorsOrGradients = !!colorGradientSettings.colors.length || !!colorGradientSettings.gradients.length; 25616 return colorGradientSettings; 25617 } 25618 25619 ;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/utils.js 25620 /** 25621 * WordPress dependencies 25622 */ 25623 25624 25625 /** 25626 * Gets the (non-undefined) item with the highest occurrence within an array 25627 * Based in part on: https://stackoverflow.com/a/20762713 25628 * 25629 * Undefined values are always sorted to the end by `sort`, so this function 25630 * returns the first element, to always prioritize real values over undefined 25631 * values. 25632 * 25633 * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#description 25634 * 25635 * @param {Array<any>} inputArray Array of items to check. 25636 * @return {any} The item with the most occurrences. 25637 */ 25638 function utils_mode(inputArray) { 25639 const arr = [...inputArray]; 25640 return arr.sort((a, b) => inputArray.filter(v => v === b).length - inputArray.filter(v => v === a).length).shift(); 25641 } 25642 25643 /** 25644 * Returns the most common CSS unit from the current CSS unit selections. 25645 * 25646 * - If a single flat border radius is set, its unit will be used 25647 * - If individual corner selections, the most common of those will be used 25648 * - Failing any unit selections a default of 'px' is returned. 25649 * 25650 * @param {Object} selectedUnits Unit selections for flat radius & each corner. 25651 * @return {string} Most common CSS unit from current selections. Default: `px`. 25652 */ 25653 function getAllUnit(selectedUnits = {}) { 25654 const { 25655 flat, 25656 ...cornerUnits 25657 } = selectedUnits; 25658 return flat || utils_mode(Object.values(cornerUnits).filter(Boolean)) || 'px'; 25659 } 25660 25661 /** 25662 * Gets the 'all' input value and unit from values data. 25663 * 25664 * @param {Object|string} values Radius values. 25665 * @return {string} A value + unit for the 'all' input. 25666 */ 25667 function getAllValue(values = {}) { 25668 /** 25669 * Border radius support was originally a single pixel value. 25670 * 25671 * To maintain backwards compatibility treat this case as the all value. 25672 */ 25673 if (typeof values === 'string') { 25674 return values; 25675 } 25676 const parsedQuantitiesAndUnits = Object.values(values).map(value => (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(value)); 25677 const allValues = parsedQuantitiesAndUnits.map(value => { 25678 var _value$; 25679 return (_value$ = value[0]) !== null && _value$ !== void 0 ? _value$ : ''; 25680 }); 25681 const allUnits = parsedQuantitiesAndUnits.map(value => value[1]); 25682 const value = allValues.every(v => v === allValues[0]) ? allValues[0] : ''; 25683 const unit = utils_mode(allUnits); 25684 const allValue = value === 0 || value ? `$value}$unit}` : undefined; 25685 return allValue; 25686 } 25687 25688 /** 25689 * Checks to determine if values are mixed. 25690 * 25691 * @param {Object} values Radius values. 25692 * @return {boolean} Whether values are mixed. 25693 */ 25694 function hasMixedValues(values = {}) { 25695 const allValue = getAllValue(values); 25696 const isMixed = typeof values === 'string' ? false : isNaN(parseFloat(allValue)); 25697 return isMixed; 25698 } 25699 25700 /** 25701 * Checks to determine if values are defined. 25702 * 25703 * @param {Object} values Radius values. 25704 * @return {boolean} Whether values are mixed. 25705 */ 25706 function hasDefinedValues(values) { 25707 if (!values) { 25708 return false; 25709 } 25710 25711 // A string value represents a shorthand value. 25712 if (typeof values === 'string') { 25713 return true; 25714 } 25715 25716 // An object represents longhand border radius values, if any are set 25717 // flag values as being defined. 25718 const filteredValues = Object.values(values).filter(value => { 25719 return !!value || value === 0; 25720 }); 25721 return !!filteredValues.length; 25722 } 25723 25724 ;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/all-input-control.js 25725 /** 25726 * WordPress dependencies 25727 */ 25728 25729 25730 25731 /** 25732 * Internal dependencies 25733 */ 25734 25735 25736 function AllInputControl({ 25737 onChange, 25738 selectedUnits, 25739 setSelectedUnits, 25740 values, 25741 ...props 25742 }) { 25743 let allValue = getAllValue(values); 25744 if (allValue === undefined) { 25745 // If we don't have any value set the unit to any current selection 25746 // or the most common unit from the individual radii values. 25747 allValue = getAllUnit(selectedUnits); 25748 } 25749 const hasValues = hasDefinedValues(values); 25750 const isMixed = hasValues && hasMixedValues(values); 25751 const allPlaceholder = isMixed ? (0,external_wp_i18n_namespaceObject.__)('Mixed') : null; 25752 25753 // Filter out CSS-unit-only values to prevent invalid styles. 25754 const handleOnChange = next => { 25755 const isNumeric = !isNaN(parseFloat(next)); 25756 const nextValue = isNumeric ? next : undefined; 25757 onChange(nextValue); 25758 }; 25759 25760 // Store current unit selection for use as fallback for individual 25761 // radii controls. 25762 const handleOnUnitChange = unit => { 25763 setSelectedUnits({ 25764 topLeft: unit, 25765 topRight: unit, 25766 bottomLeft: unit, 25767 bottomRight: unit 25768 }); 25769 }; 25770 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 25771 ...props, 25772 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Border radius'), 25773 disableUnits: isMixed, 25774 isOnly: true, 25775 value: allValue, 25776 onChange: handleOnChange, 25777 onUnitChange: handleOnUnitChange, 25778 placeholder: allPlaceholder, 25779 size: "__unstable-large" 25780 }); 25781 } 25782 25783 ;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/input-controls.js 25784 /** 25785 * WordPress dependencies 25786 */ 25787 25788 25789 25790 const CORNERS = { 25791 topLeft: (0,external_wp_i18n_namespaceObject.__)('Top left'), 25792 topRight: (0,external_wp_i18n_namespaceObject.__)('Top right'), 25793 bottomLeft: (0,external_wp_i18n_namespaceObject.__)('Bottom left'), 25794 bottomRight: (0,external_wp_i18n_namespaceObject.__)('Bottom right') 25795 }; 25796 function BoxInputControls({ 25797 onChange, 25798 selectedUnits, 25799 setSelectedUnits, 25800 values: valuesProp, 25801 ...props 25802 }) { 25803 const createHandleOnChange = corner => next => { 25804 if (!onChange) { 25805 return; 25806 } 25807 25808 // Filter out CSS-unit-only values to prevent invalid styles. 25809 const isNumeric = !isNaN(parseFloat(next)); 25810 const nextValue = isNumeric ? next : undefined; 25811 onChange({ 25812 ...values, 25813 [corner]: nextValue 25814 }); 25815 }; 25816 const createHandleOnUnitChange = side => next => { 25817 const newUnits = { 25818 ...selectedUnits 25819 }; 25820 newUnits[side] = next; 25821 setSelectedUnits(newUnits); 25822 }; 25823 25824 // For shorthand style & backwards compatibility, handle flat string value. 25825 const values = typeof valuesProp !== 'string' ? valuesProp : { 25826 topLeft: valuesProp, 25827 topRight: valuesProp, 25828 bottomLeft: valuesProp, 25829 bottomRight: valuesProp 25830 }; 25831 25832 // Controls are wrapped in tooltips as visible labels aren't desired here. 25833 // Tooltip rendering also requires the UnitControl to be wrapped. See: 25834 // https://github.com/WordPress/gutenberg/pull/24966#issuecomment-685875026 25835 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 25836 className: "components-border-radius-control__input-controls-wrapper", 25837 children: Object.entries(CORNERS).map(([corner, label]) => { 25838 const [parsedQuantity, parsedUnit] = (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values[corner]); 25839 const computedUnit = values[corner] ? parsedUnit : selectedUnits[corner] || selectedUnits.flat; 25840 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, { 25841 text: label, 25842 placement: "top", 25843 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 25844 className: "components-border-radius-control__tooltip-wrapper", 25845 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 25846 ...props, 25847 "aria-label": label, 25848 value: [parsedQuantity, computedUnit].join(''), 25849 onChange: createHandleOnChange(corner), 25850 onUnitChange: createHandleOnUnitChange(corner), 25851 size: "__unstable-large" 25852 }) 25853 }) 25854 }, corner); 25855 }) 25856 }); 25857 } 25858 25859 ;// ./node_modules/@wordpress/icons/build-module/library/link.js 25860 /** 25861 * WordPress dependencies 25862 */ 25863 25864 25865 const link_link = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 25866 xmlns: "http://www.w3.org/2000/svg", 25867 viewBox: "0 0 24 24", 25868 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 25869 d: "M10 17.389H8.444A5.194 5.194 0 1 1 8.444 7H10v1.5H8.444a3.694 3.694 0 0 0 0 7.389H10v1.5ZM14 7h1.556a5.194 5.194 0 0 1 0 10.39H14v-1.5h1.556a3.694 3.694 0 0 0 0-7.39H14V7Zm-4.5 6h5v-1.5h-5V13Z" 25870 }) 25871 }); 25872 /* harmony default export */ const library_link = (link_link); 25873 25874 ;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/linked-button.js 25875 /** 25876 * WordPress dependencies 25877 */ 25878 25879 25880 25881 25882 function LinkedButton({ 25883 isLinked, 25884 ...props 25885 }) { 25886 const label = isLinked ? (0,external_wp_i18n_namespaceObject.__)('Unlink radii') : (0,external_wp_i18n_namespaceObject.__)('Link radii'); 25887 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, { 25888 text: label, 25889 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 25890 ...props, 25891 className: "component-border-radius-control__linked-button", 25892 size: "small", 25893 icon: isLinked ? library_link : link_off, 25894 iconSize: 24, 25895 "aria-label": label 25896 }) 25897 }); 25898 } 25899 25900 ;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/index.js 25901 /** 25902 * WordPress dependencies 25903 */ 25904 25905 25906 25907 25908 /** 25909 * Internal dependencies 25910 */ 25911 25912 25913 25914 25915 25916 25917 25918 25919 const border_radius_control_DEFAULT_VALUES = { 25920 topLeft: undefined, 25921 topRight: undefined, 25922 bottomLeft: undefined, 25923 bottomRight: undefined 25924 }; 25925 const MIN_BORDER_RADIUS_VALUE = 0; 25926 const MAX_BORDER_RADIUS_VALUES = { 25927 px: 100, 25928 em: 20, 25929 rem: 20 25930 }; 25931 25932 /** 25933 * Control to display border radius options. 25934 * 25935 * @param {Object} props Component props. 25936 * @param {Function} props.onChange Callback to handle onChange. 25937 * @param {Object} props.values Border radius values. 25938 * 25939 * @return {Element} Custom border radius control. 25940 */ 25941 function BorderRadiusControl({ 25942 onChange, 25943 values 25944 }) { 25945 const [isLinked, setIsLinked] = (0,external_wp_element_namespaceObject.useState)(!hasDefinedValues(values) || !hasMixedValues(values)); 25946 25947 // Tracking selected units via internal state allows filtering of CSS unit 25948 // only values from being saved while maintaining preexisting unit selection 25949 // behaviour. Filtering CSS unit only values prevents invalid style values. 25950 const [selectedUnits, setSelectedUnits] = (0,external_wp_element_namespaceObject.useState)({ 25951 flat: typeof values === 'string' ? (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values)[1] : undefined, 25952 topLeft: (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values?.topLeft)[1], 25953 topRight: (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values?.topRight)[1], 25954 bottomLeft: (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values?.bottomLeft)[1], 25955 bottomRight: (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values?.bottomRight)[1] 25956 }); 25957 const [availableUnits] = use_settings_useSettings('spacing.units'); 25958 const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({ 25959 availableUnits: availableUnits || ['px', 'em', 'rem'] 25960 }); 25961 const unit = getAllUnit(selectedUnits); 25962 const unitConfig = units && units.find(item => item.value === unit); 25963 const step = unitConfig?.step || 1; 25964 const [allValue] = (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(getAllValue(values)); 25965 const toggleLinked = () => setIsLinked(!isLinked); 25966 const handleSliderChange = next => { 25967 onChange(next !== undefined ? `$next}$unit}` : undefined); 25968 }; 25969 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", { 25970 className: "components-border-radius-control", 25971 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, { 25972 as: "legend", 25973 children: (0,external_wp_i18n_namespaceObject.__)('Radius') 25974 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 25975 className: "components-border-radius-control__wrapper", 25976 children: [isLinked ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 25977 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AllInputControl, { 25978 className: "components-border-radius-control__unit-control", 25979 values: values, 25980 min: MIN_BORDER_RADIUS_VALUE, 25981 onChange: onChange, 25982 selectedUnits: selectedUnits, 25983 setSelectedUnits: setSelectedUnits, 25984 units: units 25985 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, { 25986 __next40pxDefaultSize: true, 25987 label: (0,external_wp_i18n_namespaceObject.__)('Border radius'), 25988 hideLabelFromVision: true, 25989 className: "components-border-radius-control__range-control", 25990 value: allValue !== null && allValue !== void 0 ? allValue : '', 25991 min: MIN_BORDER_RADIUS_VALUE, 25992 max: MAX_BORDER_RADIUS_VALUES[unit], 25993 initialPosition: 0, 25994 withInputField: false, 25995 onChange: handleSliderChange, 25996 step: step, 25997 __nextHasNoMarginBottom: true 25998 })] 25999 }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BoxInputControls, { 26000 min: MIN_BORDER_RADIUS_VALUE, 26001 onChange: onChange, 26002 selectedUnits: selectedUnits, 26003 setSelectedUnits: setSelectedUnits, 26004 values: values || border_radius_control_DEFAULT_VALUES, 26005 units: units 26006 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkedButton, { 26007 onClick: toggleLinked, 26008 isLinked: isLinked 26009 })] 26010 })] 26011 }); 26012 } 26013 26014 ;// ./node_modules/@wordpress/icons/build-module/library/check.js 26015 /** 26016 * WordPress dependencies 26017 */ 26018 26019 26020 const check_check = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 26021 xmlns: "http://www.w3.org/2000/svg", 26022 viewBox: "0 0 24 24", 26023 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 26024 d: "M16.7 7.1l-6.3 8.5-3.3-2.5-.9 1.2 4.5 3.4L17.9 8z" 26025 }) 26026 }); 26027 /* harmony default export */ const library_check = (check_check); 26028 26029 ;// ./node_modules/@wordpress/icons/build-module/library/shadow.js 26030 /** 26031 * WordPress dependencies 26032 */ 26033 26034 26035 const shadow = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 26036 viewBox: "0 0 24 24", 26037 xmlns: "http://www.w3.org/2000/svg", 26038 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 26039 d: "M12 8c-2.2 0-4 1.8-4 4s1.8 4 4 4 4-1.8 4-4-1.8-4-4-4zm0 6.5c-1.4 0-2.5-1.1-2.5-2.5s1.1-2.5 2.5-2.5 2.5 1.1 2.5 2.5-1.1 2.5-2.5 2.5zM12.8 3h-1.5v3h1.5V3zm-1.6 18h1.5v-3h-1.5v3zm6.8-9.8v1.5h3v-1.5h-3zm-12 0H3v1.5h3v-1.5zm9.7 5.6 2.1 2.1 1.1-1.1-2.1-2.1-1.1 1.1zM8.3 7.2 6.2 5.1 5.1 6.2l2.1 2.1 1.1-1.1zM5.1 17.8l1.1 1.1 2.1-2.1-1.1-1.1-2.1 2.1zM18.9 6.2l-1.1-1.1-2.1 2.1 1.1 1.1 2.1-2.1z" 26040 }) 26041 }); 26042 /* harmony default export */ const library_shadow = (shadow); 26043 26044 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/shadow-panel-components.js 26045 /** 26046 * WordPress dependencies 26047 */ 26048 26049 26050 26051 26052 26053 /** 26054 * External dependencies 26055 */ 26056 26057 26058 /** 26059 * Shared reference to an empty array for cases where it is important to avoid 26060 * returning a new array reference on every invocation. 26061 * 26062 * @type {Array} 26063 */ 26064 26065 26066 const shadow_panel_components_EMPTY_ARRAY = []; 26067 function ShadowPopoverContainer({ 26068 shadow, 26069 onShadowChange, 26070 settings 26071 }) { 26072 const shadows = useShadowPresets(settings); 26073 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 26074 className: "block-editor-global-styles__shadow-popover-container", 26075 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 26076 spacing: 4, 26077 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, { 26078 level: 5, 26079 children: (0,external_wp_i18n_namespaceObject.__)('Drop shadow') 26080 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ShadowPresets, { 26081 presets: shadows, 26082 activeShadow: shadow, 26083 onSelect: onShadowChange 26084 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 26085 className: "block-editor-global-styles__clear-shadow", 26086 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 26087 __next40pxDefaultSize: true, 26088 variant: "tertiary", 26089 onClick: () => onShadowChange(undefined), 26090 children: (0,external_wp_i18n_namespaceObject.__)('Clear') 26091 }) 26092 })] 26093 }) 26094 }); 26095 } 26096 function ShadowPresets({ 26097 presets, 26098 activeShadow, 26099 onSelect 26100 }) { 26101 return !presets ? null : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, { 26102 role: "listbox", 26103 className: "block-editor-global-styles__shadow__list", 26104 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Drop shadows'), 26105 children: presets.map(({ 26106 name, 26107 slug, 26108 shadow 26109 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ShadowIndicator, { 26110 label: name, 26111 isActive: shadow === activeShadow, 26112 type: slug === 'unset' ? 'unset' : 'preset', 26113 onSelect: () => onSelect(shadow === activeShadow ? undefined : shadow), 26114 shadow: shadow 26115 }, slug)) 26116 }); 26117 } 26118 function ShadowIndicator({ 26119 type, 26120 label, 26121 isActive, 26122 onSelect, 26123 shadow 26124 }) { 26125 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, { 26126 text: label, 26127 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite.Item, { 26128 role: "option", 26129 "aria-label": label, 26130 "aria-selected": isActive, 26131 className: dist_clsx('block-editor-global-styles__shadow__item', { 26132 'is-active': isActive 26133 }), 26134 render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("button", { 26135 className: dist_clsx('block-editor-global-styles__shadow-indicator', { 26136 unset: type === 'unset' 26137 }), 26138 onClick: onSelect, 26139 style: { 26140 boxShadow: shadow 26141 }, 26142 "aria-label": label, 26143 children: isActive && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 26144 icon: library_check 26145 }) 26146 }) 26147 }) 26148 }); 26149 } 26150 function ShadowPopover({ 26151 shadow, 26152 onShadowChange, 26153 settings 26154 }) { 26155 const popoverProps = { 26156 placement: 'left-start', 26157 offset: 36, 26158 shift: true 26159 }; 26160 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 26161 popoverProps: popoverProps, 26162 className: "block-editor-global-styles__shadow-dropdown", 26163 renderToggle: renderShadowToggle(), 26164 renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, { 26165 paddingSize: "medium", 26166 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ShadowPopoverContainer, { 26167 shadow: shadow, 26168 onShadowChange: onShadowChange, 26169 settings: settings 26170 }) 26171 }) 26172 }); 26173 } 26174 function renderShadowToggle() { 26175 return ({ 26176 onToggle, 26177 isOpen 26178 }) => { 26179 const toggleProps = { 26180 onClick: onToggle, 26181 className: dist_clsx({ 26182 'is-open': isOpen 26183 }), 26184 'aria-expanded': isOpen 26185 }; 26186 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 26187 __next40pxDefaultSize: true, 26188 ...toggleProps, 26189 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 26190 justify: "flex-start", 26191 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 26192 className: "block-editor-global-styles__toggle-icon", 26193 icon: library_shadow, 26194 size: 24 26195 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 26196 children: (0,external_wp_i18n_namespaceObject.__)('Drop shadow') 26197 })] 26198 }) 26199 }); 26200 }; 26201 } 26202 function useShadowPresets(settings) { 26203 return (0,external_wp_element_namespaceObject.useMemo)(() => { 26204 var _settings$shadow$pres; 26205 if (!settings?.shadow) { 26206 return shadow_panel_components_EMPTY_ARRAY; 26207 } 26208 const defaultPresetsEnabled = settings?.shadow?.defaultPresets; 26209 const { 26210 default: defaultShadows, 26211 theme: themeShadows, 26212 custom: customShadows 26213 } = (_settings$shadow$pres = settings?.shadow?.presets) !== null && _settings$shadow$pres !== void 0 ? _settings$shadow$pres : {}; 26214 const unsetShadow = { 26215 name: (0,external_wp_i18n_namespaceObject.__)('Unset'), 26216 slug: 'unset', 26217 shadow: 'none' 26218 }; 26219 const shadowPresets = [...(defaultPresetsEnabled && defaultShadows || shadow_panel_components_EMPTY_ARRAY), ...(themeShadows || shadow_panel_components_EMPTY_ARRAY), ...(customShadows || shadow_panel_components_EMPTY_ARRAY)]; 26220 if (shadowPresets.length) { 26221 shadowPresets.unshift(unsetShadow); 26222 } 26223 return shadowPresets; 26224 }, [settings]); 26225 } 26226 26227 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/border-panel.js 26228 /** 26229 * WordPress dependencies 26230 */ 26231 26232 26233 26234 26235 /** 26236 * Internal dependencies 26237 */ 26238 26239 26240 26241 26242 26243 26244 26245 26246 function useHasBorderPanel(settings) { 26247 const controls = Object.values(useHasBorderPanelControls(settings)); 26248 return controls.some(Boolean); 26249 } 26250 function useHasBorderPanelControls(settings) { 26251 const controls = { 26252 hasBorderColor: useHasBorderColorControl(settings), 26253 hasBorderRadius: useHasBorderRadiusControl(settings), 26254 hasBorderStyle: useHasBorderStyleControl(settings), 26255 hasBorderWidth: useHasBorderWidthControl(settings), 26256 hasShadow: useHasShadowControl(settings) 26257 }; 26258 return controls; 26259 } 26260 function useHasBorderColorControl(settings) { 26261 return settings?.border?.color; 26262 } 26263 function useHasBorderRadiusControl(settings) { 26264 return settings?.border?.radius; 26265 } 26266 function useHasBorderStyleControl(settings) { 26267 return settings?.border?.style; 26268 } 26269 function useHasBorderWidthControl(settings) { 26270 return settings?.border?.width; 26271 } 26272 function useHasShadowControl(settings) { 26273 const shadows = useShadowPresets(settings); 26274 return !!settings?.shadow && shadows.length > 0; 26275 } 26276 function BorderToolsPanel({ 26277 resetAllFilter, 26278 onChange, 26279 value, 26280 panelId, 26281 children, 26282 label 26283 }) { 26284 const dropdownMenuProps = useToolsPanelDropdownMenuProps(); 26285 const resetAll = () => { 26286 const updatedValue = resetAllFilter(value); 26287 onChange(updatedValue); 26288 }; 26289 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, { 26290 label: label, 26291 resetAll: resetAll, 26292 panelId: panelId, 26293 dropdownMenuProps: dropdownMenuProps, 26294 children: children 26295 }); 26296 } 26297 const border_panel_DEFAULT_CONTROLS = { 26298 radius: true, 26299 color: true, 26300 width: true, 26301 shadow: true 26302 }; 26303 function BorderPanel({ 26304 as: Wrapper = BorderToolsPanel, 26305 value, 26306 onChange, 26307 inheritedValue = value, 26308 settings, 26309 panelId, 26310 name, 26311 defaultControls = border_panel_DEFAULT_CONTROLS 26312 }) { 26313 var _settings$shadow$pres, _ref, _ref2, _shadowPresets$custom; 26314 const colors = useColorsPerOrigin(settings); 26315 const decodeValue = (0,external_wp_element_namespaceObject.useCallback)(rawValue => getValueFromVariable({ 26316 settings 26317 }, '', rawValue), [settings]); 26318 const encodeColorValue = colorValue => { 26319 const allColors = colors.flatMap(({ 26320 colors: originColors 26321 }) => originColors); 26322 const colorObject = allColors.find(({ 26323 color 26324 }) => color === colorValue); 26325 return colorObject ? 'var:preset|color|' + colorObject.slug : colorValue; 26326 }; 26327 const border = (0,external_wp_element_namespaceObject.useMemo)(() => { 26328 if ((0,external_wp_components_namespaceObject.__experimentalHasSplitBorders)(inheritedValue?.border)) { 26329 const borderValue = { 26330 ...inheritedValue?.border 26331 }; 26332 ['top', 'right', 'bottom', 'left'].forEach(side => { 26333 borderValue[side] = { 26334 ...borderValue[side], 26335 color: decodeValue(borderValue[side]?.color) 26336 }; 26337 }); 26338 return borderValue; 26339 } 26340 return { 26341 ...inheritedValue?.border, 26342 color: inheritedValue?.border?.color ? decodeValue(inheritedValue?.border?.color) : undefined 26343 }; 26344 }, [inheritedValue?.border, decodeValue]); 26345 const setBorder = newBorder => onChange({ 26346 ...value, 26347 border: newBorder 26348 }); 26349 const showBorderColor = useHasBorderColorControl(settings); 26350 const showBorderStyle = useHasBorderStyleControl(settings); 26351 const showBorderWidth = useHasBorderWidthControl(settings); 26352 26353 // Border radius. 26354 const showBorderRadius = useHasBorderRadiusControl(settings); 26355 const borderRadiusValues = decodeValue(border?.radius); 26356 const setBorderRadius = newBorderRadius => setBorder({ 26357 ...border, 26358 radius: newBorderRadius 26359 }); 26360 const hasBorderRadius = () => { 26361 const borderValues = value?.border?.radius; 26362 if (typeof borderValues === 'object') { 26363 return Object.entries(borderValues).some(Boolean); 26364 } 26365 return !!borderValues; 26366 }; 26367 const hasShadowControl = useHasShadowControl(settings); 26368 26369 // Shadow 26370 const shadow = decodeValue(inheritedValue?.shadow); 26371 const shadowPresets = (_settings$shadow$pres = settings?.shadow?.presets) !== null && _settings$shadow$pres !== void 0 ? _settings$shadow$pres : {}; 26372 const mergedShadowPresets = (_ref = (_ref2 = (_shadowPresets$custom = shadowPresets.custom) !== null && _shadowPresets$custom !== void 0 ? _shadowPresets$custom : shadowPresets.theme) !== null && _ref2 !== void 0 ? _ref2 : shadowPresets.default) !== null && _ref !== void 0 ? _ref : []; 26373 const setShadow = newValue => { 26374 const slug = mergedShadowPresets?.find(({ 26375 shadow: shadowName 26376 }) => shadowName === newValue)?.slug; 26377 onChange(setImmutably(value, ['shadow'], slug ? `var:preset|shadow|$slug}` : newValue || undefined)); 26378 }; 26379 const hasShadow = () => !!value?.shadow; 26380 const resetShadow = () => setShadow(undefined); 26381 const resetBorder = () => { 26382 if (hasBorderRadius()) { 26383 return setBorder({ 26384 radius: value?.border?.radius 26385 }); 26386 } 26387 setBorder(undefined); 26388 }; 26389 const onBorderChange = newBorder => { 26390 // Ensure we have a visible border style when a border width or 26391 // color is being selected. 26392 const updatedBorder = { 26393 ...newBorder 26394 }; 26395 if ((0,external_wp_components_namespaceObject.__experimentalHasSplitBorders)(updatedBorder)) { 26396 ['top', 'right', 'bottom', 'left'].forEach(side => { 26397 if (updatedBorder[side]) { 26398 updatedBorder[side] = { 26399 ...updatedBorder[side], 26400 color: encodeColorValue(updatedBorder[side]?.color) 26401 }; 26402 } 26403 }); 26404 } else if (updatedBorder) { 26405 updatedBorder.color = encodeColorValue(updatedBorder.color); 26406 } 26407 26408 // As radius is maintained separately to color, style, and width 26409 // maintain its value. Undefined values here will be cleaned when 26410 // global styles are saved. 26411 setBorder({ 26412 radius: border?.radius, 26413 ...updatedBorder 26414 }); 26415 }; 26416 const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue => { 26417 return { 26418 ...previousValue, 26419 border: undefined, 26420 shadow: undefined 26421 }; 26422 }, []); 26423 const showBorderByDefault = defaultControls?.color || defaultControls?.width; 26424 const hasBorderControl = showBorderColor || showBorderStyle || showBorderWidth || showBorderRadius; 26425 const label = useBorderPanelLabel({ 26426 blockName: name, 26427 hasShadowControl, 26428 hasBorderControl 26429 }); 26430 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, { 26431 resetAllFilter: resetAllFilter, 26432 value: value, 26433 onChange: onChange, 26434 panelId: panelId, 26435 label: label, 26436 children: [(showBorderWidth || showBorderColor) && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 26437 hasValue: () => (0,external_wp_components_namespaceObject.__experimentalIsDefinedBorder)(value?.border), 26438 label: (0,external_wp_i18n_namespaceObject.__)('Border'), 26439 onDeselect: () => resetBorder(), 26440 isShownByDefault: showBorderByDefault, 26441 panelId: panelId, 26442 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalBorderBoxControl, { 26443 colors: colors, 26444 enableAlpha: true, 26445 enableStyle: showBorderStyle, 26446 onChange: onBorderChange, 26447 popoverOffset: 40, 26448 popoverPlacement: "left-start", 26449 value: border, 26450 __experimentalIsRenderedInSidebar: true, 26451 size: "__unstable-large", 26452 hideLabelFromVision: !hasShadowControl, 26453 label: (0,external_wp_i18n_namespaceObject.__)('Border') 26454 }) 26455 }), showBorderRadius && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 26456 hasValue: hasBorderRadius, 26457 label: (0,external_wp_i18n_namespaceObject.__)('Radius'), 26458 onDeselect: () => setBorderRadius(undefined), 26459 isShownByDefault: defaultControls.radius, 26460 panelId: panelId, 26461 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BorderRadiusControl, { 26462 values: borderRadiusValues, 26463 onChange: newValue => { 26464 setBorderRadius(newValue || undefined); 26465 } 26466 }) 26467 }), hasShadowControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 26468 label: (0,external_wp_i18n_namespaceObject.__)('Shadow'), 26469 hasValue: hasShadow, 26470 onDeselect: resetShadow, 26471 isShownByDefault: defaultControls.shadow, 26472 panelId: panelId, 26473 children: [hasBorderControl ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, { 26474 as: "legend", 26475 children: (0,external_wp_i18n_namespaceObject.__)('Shadow') 26476 }) : null, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, { 26477 isBordered: true, 26478 isSeparated: true, 26479 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ShadowPopover, { 26480 shadow: shadow, 26481 onShadowChange: setShadow, 26482 settings: settings 26483 }) 26484 })] 26485 })] 26486 }); 26487 } 26488 26489 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/border.js 26490 /** 26491 * External dependencies 26492 */ 26493 26494 26495 /** 26496 * WordPress dependencies 26497 */ 26498 26499 26500 26501 26502 26503 26504 /** 26505 * Internal dependencies 26506 */ 26507 26508 26509 26510 26511 26512 26513 26514 26515 const BORDER_SUPPORT_KEY = '__experimentalBorder'; 26516 const SHADOW_SUPPORT_KEY = 'shadow'; 26517 const getColorByProperty = (colors, property, value) => { 26518 let matchedColor; 26519 colors.some(origin => origin.colors.some(color => { 26520 if (color[property] === value) { 26521 matchedColor = color; 26522 return true; 26523 } 26524 return false; 26525 })); 26526 return matchedColor; 26527 }; 26528 const getMultiOriginColor = ({ 26529 colors, 26530 namedColor, 26531 customColor 26532 }) => { 26533 // Search each origin (default, theme, or user) for matching color by name. 26534 if (namedColor) { 26535 const colorObject = getColorByProperty(colors, 'slug', namedColor); 26536 if (colorObject) { 26537 return colorObject; 26538 } 26539 } 26540 26541 // Skip if no custom color or matching named color. 26542 if (!customColor) { 26543 return { 26544 color: undefined 26545 }; 26546 } 26547 26548 // Attempt to find color via custom color value or build new object. 26549 const colorObject = getColorByProperty(colors, 'color', customColor); 26550 return colorObject ? colorObject : { 26551 color: customColor 26552 }; 26553 }; 26554 function getColorSlugFromVariable(value) { 26555 const namedColor = /var:preset\|color\|(.+)/.exec(value); 26556 if (namedColor && namedColor[1]) { 26557 return namedColor[1]; 26558 } 26559 return null; 26560 } 26561 function styleToAttributes(style) { 26562 if ((0,external_wp_components_namespaceObject.__experimentalHasSplitBorders)(style?.border)) { 26563 return { 26564 style, 26565 borderColor: undefined 26566 }; 26567 } 26568 const borderColorValue = style?.border?.color; 26569 const borderColorSlug = borderColorValue?.startsWith('var:preset|color|') ? borderColorValue.substring('var:preset|color|'.length) : undefined; 26570 const updatedStyle = { 26571 ...style 26572 }; 26573 updatedStyle.border = { 26574 ...updatedStyle.border, 26575 color: borderColorSlug ? undefined : borderColorValue 26576 }; 26577 return { 26578 style: utils_cleanEmptyObject(updatedStyle), 26579 borderColor: borderColorSlug 26580 }; 26581 } 26582 function attributesToStyle(attributes) { 26583 if ((0,external_wp_components_namespaceObject.__experimentalHasSplitBorders)(attributes.style?.border)) { 26584 return attributes.style; 26585 } 26586 return { 26587 ...attributes.style, 26588 border: { 26589 ...attributes.style?.border, 26590 color: attributes.borderColor ? 'var:preset|color|' + attributes.borderColor : attributes.style?.border?.color 26591 } 26592 }; 26593 } 26594 function BordersInspectorControl({ 26595 label, 26596 children, 26597 resetAllFilter 26598 }) { 26599 const attributesResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes => { 26600 const existingStyle = attributesToStyle(attributes); 26601 const updatedStyle = resetAllFilter(existingStyle); 26602 return { 26603 ...attributes, 26604 ...styleToAttributes(updatedStyle) 26605 }; 26606 }, [resetAllFilter]); 26607 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, { 26608 group: "border", 26609 resetAllFilter: attributesResetAllFilter, 26610 label: label, 26611 children: children 26612 }); 26613 } 26614 function border_BorderPanel({ 26615 clientId, 26616 name, 26617 setAttributes, 26618 settings 26619 }) { 26620 const isEnabled = useHasBorderPanel(settings); 26621 function selector(select) { 26622 const { 26623 style, 26624 borderColor 26625 } = select(store).getBlockAttributes(clientId) || {}; 26626 return { 26627 style, 26628 borderColor 26629 }; 26630 } 26631 const { 26632 style, 26633 borderColor 26634 } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId]); 26635 const value = (0,external_wp_element_namespaceObject.useMemo)(() => { 26636 return attributesToStyle({ 26637 style, 26638 borderColor 26639 }); 26640 }, [style, borderColor]); 26641 const onChange = newStyle => { 26642 setAttributes(styleToAttributes(newStyle)); 26643 }; 26644 if (!isEnabled) { 26645 return null; 26646 } 26647 const defaultControls = { 26648 ...(0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [BORDER_SUPPORT_KEY, '__experimentalDefaultControls']), 26649 ...(0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [SHADOW_SUPPORT_KEY, '__experimentalDefaultControls']) 26650 }; 26651 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BorderPanel, { 26652 as: BordersInspectorControl, 26653 panelId: clientId, 26654 settings: settings, 26655 value: value, 26656 onChange: onChange, 26657 defaultControls: defaultControls 26658 }); 26659 } 26660 26661 /** 26662 * Determine whether there is block support for border properties. 26663 * 26664 * @param {string} blockName Block name. 26665 * @param {string} feature Border feature to check support for. 26666 * 26667 * @return {boolean} Whether there is support. 26668 */ 26669 function hasBorderSupport(blockName, feature = 'any') { 26670 if (external_wp_element_namespaceObject.Platform.OS !== 'web') { 26671 return false; 26672 } 26673 const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, BORDER_SUPPORT_KEY); 26674 if (support === true) { 26675 return true; 26676 } 26677 if (feature === 'any') { 26678 return !!(support?.color || support?.radius || support?.width || support?.style); 26679 } 26680 return !!support?.[feature]; 26681 } 26682 26683 /** 26684 * Determine whether there is block support for shadow properties. 26685 * 26686 * @param {string} blockName Block name. 26687 * 26688 * @return {boolean} Whether there is support. 26689 */ 26690 function hasShadowSupport(blockName) { 26691 return hasBlockSupport(blockName, SHADOW_SUPPORT_KEY); 26692 } 26693 function useBorderPanelLabel({ 26694 blockName, 26695 hasBorderControl, 26696 hasShadowControl 26697 } = {}) { 26698 const settings = useBlockSettings(blockName); 26699 const controls = useHasBorderPanelControls(settings); 26700 if (!hasBorderControl && !hasShadowControl && blockName) { 26701 hasBorderControl = controls?.hasBorderColor || controls?.hasBorderStyle || controls?.hasBorderWidth || controls?.hasBorderRadius; 26702 hasShadowControl = controls?.hasShadow; 26703 } 26704 if (hasBorderControl && hasShadowControl) { 26705 return (0,external_wp_i18n_namespaceObject.__)('Border & Shadow'); 26706 } 26707 if (hasShadowControl) { 26708 return (0,external_wp_i18n_namespaceObject.__)('Shadow'); 26709 } 26710 return (0,external_wp_i18n_namespaceObject.__)('Border'); 26711 } 26712 26713 /** 26714 * Returns a new style object where the specified border attribute has been 26715 * removed. 26716 * 26717 * @param {Object} style Styles from block attributes. 26718 * @param {string} attribute The border style attribute to clear. 26719 * 26720 * @return {Object} Style object with the specified attribute removed. 26721 */ 26722 function removeBorderAttribute(style, attribute) { 26723 return cleanEmptyObject({ 26724 ...style, 26725 border: { 26726 ...style?.border, 26727 [attribute]: undefined 26728 } 26729 }); 26730 } 26731 26732 /** 26733 * Filters registered block settings, extending attributes to include 26734 * `borderColor` if needed. 26735 * 26736 * @param {Object} settings Original block settings. 26737 * 26738 * @return {Object} Updated block settings. 26739 */ 26740 function addAttributes(settings) { 26741 if (!hasBorderSupport(settings, 'color')) { 26742 return settings; 26743 } 26744 26745 // Allow blocks to specify default value if needed. 26746 if (settings.attributes.borderColor) { 26747 return settings; 26748 } 26749 26750 // Add new borderColor attribute to block settings. 26751 return { 26752 ...settings, 26753 attributes: { 26754 ...settings.attributes, 26755 borderColor: { 26756 type: 'string' 26757 } 26758 } 26759 }; 26760 } 26761 26762 /** 26763 * Override props assigned to save component to inject border color. 26764 * 26765 * @param {Object} props Additional props applied to save element. 26766 * @param {Object|string} blockNameOrType Block type definition. 26767 * @param {Object} attributes Block's attributes. 26768 * 26769 * @return {Object} Filtered props to apply to save element. 26770 */ 26771 function border_addSaveProps(props, blockNameOrType, attributes) { 26772 if (!hasBorderSupport(blockNameOrType, 'color') || shouldSkipSerialization(blockNameOrType, BORDER_SUPPORT_KEY, 'color')) { 26773 return props; 26774 } 26775 const borderClasses = getBorderClasses(attributes); 26776 const newClassName = dist_clsx(props.className, borderClasses); 26777 26778 // If we are clearing the last of the previous classes in `className` 26779 // set it to `undefined` to avoid rendering empty DOM attributes. 26780 props.className = newClassName ? newClassName : undefined; 26781 return props; 26782 } 26783 26784 /** 26785 * Generates a CSS class name consisting of all the applicable border color 26786 * classes given the current block attributes. 26787 * 26788 * @param {Object} attributes Block's attributes. 26789 * 26790 * @return {string} CSS class name. 26791 */ 26792 function getBorderClasses(attributes) { 26793 const { 26794 borderColor, 26795 style 26796 } = attributes; 26797 const borderColorClass = getColorClassName('border-color', borderColor); 26798 return dist_clsx({ 26799 'has-border-color': borderColor || style?.border?.color, 26800 [borderColorClass]: !!borderColorClass 26801 }); 26802 } 26803 function border_useBlockProps({ 26804 name, 26805 borderColor, 26806 style 26807 }) { 26808 const { 26809 colors 26810 } = useMultipleOriginColorsAndGradients(); 26811 if (!hasBorderSupport(name, 'color') || shouldSkipSerialization(name, BORDER_SUPPORT_KEY, 'color')) { 26812 return {}; 26813 } 26814 const { 26815 color: borderColorValue 26816 } = getMultiOriginColor({ 26817 colors, 26818 namedColor: borderColor 26819 }); 26820 const { 26821 color: borderTopColor 26822 } = getMultiOriginColor({ 26823 colors, 26824 namedColor: getColorSlugFromVariable(style?.border?.top?.color) 26825 }); 26826 const { 26827 color: borderRightColor 26828 } = getMultiOriginColor({ 26829 colors, 26830 namedColor: getColorSlugFromVariable(style?.border?.right?.color) 26831 }); 26832 const { 26833 color: borderBottomColor 26834 } = getMultiOriginColor({ 26835 colors, 26836 namedColor: getColorSlugFromVariable(style?.border?.bottom?.color) 26837 }); 26838 const { 26839 color: borderLeftColor 26840 } = getMultiOriginColor({ 26841 colors, 26842 namedColor: getColorSlugFromVariable(style?.border?.left?.color) 26843 }); 26844 const extraStyles = { 26845 borderTopColor: borderTopColor || borderColorValue, 26846 borderRightColor: borderRightColor || borderColorValue, 26847 borderBottomColor: borderBottomColor || borderColorValue, 26848 borderLeftColor: borderLeftColor || borderColorValue 26849 }; 26850 return border_addSaveProps({ 26851 style: utils_cleanEmptyObject(extraStyles) || {} 26852 }, name, { 26853 borderColor, 26854 style 26855 }); 26856 } 26857 /* harmony default export */ const border = ({ 26858 useBlockProps: border_useBlockProps, 26859 addSaveProps: border_addSaveProps, 26860 attributeKeys: ['borderColor', 'style'], 26861 hasSupport(name) { 26862 return hasBorderSupport(name, 'color'); 26863 } 26864 }); 26865 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/border/addAttributes', addAttributes); 26866 26867 ;// ./node_modules/@wordpress/block-editor/build-module/components/gradients/use-gradient.js 26868 /** 26869 * WordPress dependencies 26870 */ 26871 26872 26873 26874 /** 26875 * Internal dependencies 26876 */ 26877 26878 26879 26880 function __experimentalGetGradientClass(gradientSlug) { 26881 if (!gradientSlug) { 26882 return undefined; 26883 } 26884 return `has-$gradientSlug}-gradient-background`; 26885 } 26886 26887 /** 26888 * Retrieves the gradient value per slug. 26889 * 26890 * @param {Array} gradients Gradient Palette 26891 * @param {string} slug Gradient slug 26892 * 26893 * @return {string} Gradient value. 26894 */ 26895 function getGradientValueBySlug(gradients, slug) { 26896 const gradient = gradients?.find(g => g.slug === slug); 26897 return gradient && gradient.gradient; 26898 } 26899 function __experimentalGetGradientObjectByGradientValue(gradients, value) { 26900 const gradient = gradients?.find(g => g.gradient === value); 26901 return gradient; 26902 } 26903 26904 /** 26905 * Retrieves the gradient slug per slug. 26906 * 26907 * @param {Array} gradients Gradient Palette 26908 * @param {string} value Gradient value 26909 * @return {string} Gradient slug. 26910 */ 26911 function getGradientSlugByValue(gradients, value) { 26912 const gradient = __experimentalGetGradientObjectByGradientValue(gradients, value); 26913 return gradient && gradient.slug; 26914 } 26915 function __experimentalUseGradient({ 26916 gradientAttribute = 'gradient', 26917 customGradientAttribute = 'customGradient' 26918 } = {}) { 26919 const { 26920 clientId 26921 } = useBlockEditContext(); 26922 const [userGradientPalette, themeGradientPalette, defaultGradientPalette] = use_settings_useSettings('color.gradients.custom', 'color.gradients.theme', 'color.gradients.default'); 26923 const allGradients = (0,external_wp_element_namespaceObject.useMemo)(() => [...(userGradientPalette || []), ...(themeGradientPalette || []), ...(defaultGradientPalette || [])], [userGradientPalette, themeGradientPalette, defaultGradientPalette]); 26924 const { 26925 gradient, 26926 customGradient 26927 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 26928 const { 26929 getBlockAttributes 26930 } = select(store); 26931 const attributes = getBlockAttributes(clientId) || {}; 26932 return { 26933 customGradient: attributes[customGradientAttribute], 26934 gradient: attributes[gradientAttribute] 26935 }; 26936 }, [clientId, gradientAttribute, customGradientAttribute]); 26937 const { 26938 updateBlockAttributes 26939 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 26940 const setGradient = (0,external_wp_element_namespaceObject.useCallback)(newGradientValue => { 26941 const slug = getGradientSlugByValue(allGradients, newGradientValue); 26942 if (slug) { 26943 updateBlockAttributes(clientId, { 26944 [gradientAttribute]: slug, 26945 [customGradientAttribute]: undefined 26946 }); 26947 return; 26948 } 26949 updateBlockAttributes(clientId, { 26950 [gradientAttribute]: undefined, 26951 [customGradientAttribute]: newGradientValue 26952 }); 26953 }, [allGradients, clientId, updateBlockAttributes]); 26954 const gradientClass = __experimentalGetGradientClass(gradient); 26955 let gradientValue; 26956 if (gradient) { 26957 gradientValue = getGradientValueBySlug(allGradients, gradient); 26958 } else { 26959 gradientValue = customGradient; 26960 } 26961 return { 26962 gradientClass, 26963 gradientValue, 26964 setGradient 26965 }; 26966 } 26967 26968 ;// ./node_modules/@wordpress/block-editor/build-module/components/colors-gradients/control.js 26969 /** 26970 * External dependencies 26971 */ 26972 26973 26974 /** 26975 * WordPress dependencies 26976 */ 26977 26978 26979 26980 /** 26981 * Internal dependencies 26982 */ 26983 26984 26985 26986 26987 const { 26988 Tabs 26989 } = unlock(external_wp_components_namespaceObject.privateApis); 26990 const colorsAndGradientKeys = ['colors', 'disableCustomColors', 'gradients', 'disableCustomGradients']; 26991 const TAB_IDS = { 26992 color: 'color', 26993 gradient: 'gradient' 26994 }; 26995 function ColorGradientControlInner({ 26996 colors, 26997 gradients, 26998 disableCustomColors, 26999 disableCustomGradients, 27000 __experimentalIsRenderedInSidebar, 27001 className, 27002 label, 27003 onColorChange, 27004 onGradientChange, 27005 colorValue, 27006 gradientValue, 27007 clearable, 27008 showTitle = true, 27009 enableAlpha, 27010 headingLevel 27011 }) { 27012 const canChooseAColor = onColorChange && (colors && colors.length > 0 || !disableCustomColors); 27013 const canChooseAGradient = onGradientChange && (gradients && gradients.length > 0 || !disableCustomGradients); 27014 if (!canChooseAColor && !canChooseAGradient) { 27015 return null; 27016 } 27017 const tabPanels = { 27018 [TAB_IDS.color]: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorPalette, { 27019 value: colorValue, 27020 onChange: canChooseAGradient ? newColor => { 27021 onColorChange(newColor); 27022 onGradientChange(); 27023 } : onColorChange, 27024 colors, 27025 disableCustomColors, 27026 __experimentalIsRenderedInSidebar: __experimentalIsRenderedInSidebar, 27027 clearable: clearable, 27028 enableAlpha: enableAlpha, 27029 headingLevel: headingLevel 27030 }), 27031 [TAB_IDS.gradient]: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.GradientPicker, { 27032 value: gradientValue, 27033 onChange: canChooseAColor ? newGradient => { 27034 onGradientChange(newGradient); 27035 onColorChange(); 27036 } : onGradientChange, 27037 gradients, 27038 disableCustomGradients, 27039 __experimentalIsRenderedInSidebar: __experimentalIsRenderedInSidebar, 27040 clearable: clearable, 27041 headingLevel: headingLevel 27042 }) 27043 }; 27044 const renderPanelType = type => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 27045 className: "block-editor-color-gradient-control__panel", 27046 children: tabPanels[type] 27047 }); 27048 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl, { 27049 __nextHasNoMarginBottom: true, 27050 className: dist_clsx('block-editor-color-gradient-control', className), 27051 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("fieldset", { 27052 className: "block-editor-color-gradient-control__fieldset", 27053 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 27054 spacing: 1, 27055 children: [showTitle && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("legend", { 27056 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 27057 className: "block-editor-color-gradient-control__color-indicator", 27058 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, { 27059 children: label 27060 }) 27061 }) 27062 }), canChooseAColor && canChooseAGradient && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 27063 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Tabs, { 27064 defaultTabId: gradientValue ? TAB_IDS.gradient : !!canChooseAColor && TAB_IDS.color, 27065 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Tabs.TabList, { 27066 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tabs.Tab, { 27067 tabId: TAB_IDS.color, 27068 children: (0,external_wp_i18n_namespaceObject.__)('Color') 27069 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tabs.Tab, { 27070 tabId: TAB_IDS.gradient, 27071 children: (0,external_wp_i18n_namespaceObject.__)('Gradient') 27072 })] 27073 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tabs.TabPanel, { 27074 tabId: TAB_IDS.color, 27075 className: "block-editor-color-gradient-control__panel", 27076 focusable: false, 27077 children: tabPanels.color 27078 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tabs.TabPanel, { 27079 tabId: TAB_IDS.gradient, 27080 className: "block-editor-color-gradient-control__panel", 27081 focusable: false, 27082 children: tabPanels.gradient 27083 })] 27084 }) 27085 }), !canChooseAGradient && renderPanelType(TAB_IDS.color), !canChooseAColor && renderPanelType(TAB_IDS.gradient)] 27086 }) 27087 }) 27088 }); 27089 } 27090 function ColorGradientControlSelect(props) { 27091 const [colors, gradients, customColors, customGradients] = use_settings_useSettings('color.palette', 'color.gradients', 'color.custom', 'color.customGradient'); 27092 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorGradientControlInner, { 27093 colors: colors, 27094 gradients: gradients, 27095 disableCustomColors: !customColors, 27096 disableCustomGradients: !customGradients, 27097 ...props 27098 }); 27099 } 27100 function ColorGradientControl(props) { 27101 if (colorsAndGradientKeys.every(key => props.hasOwnProperty(key))) { 27102 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorGradientControlInner, { 27103 ...props 27104 }); 27105 } 27106 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorGradientControlSelect, { 27107 ...props 27108 }); 27109 } 27110 /* harmony default export */ const control = (ColorGradientControl); 27111 27112 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/color-panel.js 27113 /** 27114 * External dependencies 27115 */ 27116 27117 27118 /** 27119 * WordPress dependencies 27120 */ 27121 27122 27123 27124 27125 /** 27126 * Internal dependencies 27127 */ 27128 27129 27130 27131 27132 27133 27134 27135 function useHasColorPanel(settings) { 27136 const hasTextPanel = useHasTextPanel(settings); 27137 const hasBackgroundPanel = useHasBackgroundColorPanel(settings); 27138 const hasLinkPanel = useHasLinkPanel(settings); 27139 const hasHeadingPanel = useHasHeadingPanel(settings); 27140 const hasButtonPanel = useHasButtonPanel(settings); 27141 const hasCaptionPanel = useHasCaptionPanel(settings); 27142 return hasTextPanel || hasBackgroundPanel || hasLinkPanel || hasHeadingPanel || hasButtonPanel || hasCaptionPanel; 27143 } 27144 function useHasTextPanel(settings) { 27145 const colors = useColorsPerOrigin(settings); 27146 return settings?.color?.text && (colors?.length > 0 || settings?.color?.custom); 27147 } 27148 function useHasLinkPanel(settings) { 27149 const colors = useColorsPerOrigin(settings); 27150 return settings?.color?.link && (colors?.length > 0 || settings?.color?.custom); 27151 } 27152 function useHasCaptionPanel(settings) { 27153 const colors = useColorsPerOrigin(settings); 27154 return settings?.color?.caption && (colors?.length > 0 || settings?.color?.custom); 27155 } 27156 function useHasHeadingPanel(settings) { 27157 const colors = useColorsPerOrigin(settings); 27158 const gradients = useGradientsPerOrigin(settings); 27159 return settings?.color?.heading && (colors?.length > 0 || settings?.color?.custom || gradients?.length > 0 || settings?.color?.customGradient); 27160 } 27161 function useHasButtonPanel(settings) { 27162 const colors = useColorsPerOrigin(settings); 27163 const gradients = useGradientsPerOrigin(settings); 27164 return settings?.color?.button && (colors?.length > 0 || settings?.color?.custom || gradients?.length > 0 || settings?.color?.customGradient); 27165 } 27166 function useHasBackgroundColorPanel(settings) { 27167 const colors = useColorsPerOrigin(settings); 27168 const gradients = useGradientsPerOrigin(settings); 27169 return settings?.color?.background && (colors?.length > 0 || settings?.color?.custom || gradients?.length > 0 || settings?.color?.customGradient); 27170 } 27171 function ColorToolsPanel({ 27172 resetAllFilter, 27173 onChange, 27174 value, 27175 panelId, 27176 children 27177 }) { 27178 const dropdownMenuProps = useToolsPanelDropdownMenuProps(); 27179 const resetAll = () => { 27180 const updatedValue = resetAllFilter(value); 27181 onChange(updatedValue); 27182 }; 27183 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, { 27184 label: (0,external_wp_i18n_namespaceObject.__)('Elements'), 27185 resetAll: resetAll, 27186 panelId: panelId, 27187 hasInnerWrapper: true, 27188 headingLevel: 3, 27189 className: "color-block-support-panel", 27190 __experimentalFirstVisibleItemClass: "first", 27191 __experimentalLastVisibleItemClass: "last", 27192 dropdownMenuProps: dropdownMenuProps, 27193 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 27194 className: "color-block-support-panel__inner-wrapper", 27195 children: children 27196 }) 27197 }); 27198 } 27199 const color_panel_DEFAULT_CONTROLS = { 27200 text: true, 27201 background: true, 27202 link: true, 27203 heading: true, 27204 button: true, 27205 caption: true 27206 }; 27207 const popoverProps = { 27208 placement: 'left-start', 27209 offset: 36, 27210 shift: true 27211 }; 27212 const { 27213 Tabs: color_panel_Tabs 27214 } = unlock(external_wp_components_namespaceObject.privateApis); 27215 const LabeledColorIndicators = ({ 27216 indicators, 27217 label 27218 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 27219 justify: "flex-start", 27220 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalZStack, { 27221 isLayered: false, 27222 offset: -8, 27223 children: indicators.map((indicator, index) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Flex, { 27224 expanded: false, 27225 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorIndicator, { 27226 colorValue: indicator 27227 }) 27228 }, index)) 27229 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 27230 className: "block-editor-panel-color-gradient-settings__color-name", 27231 title: label, 27232 children: label 27233 })] 27234 }); 27235 function ColorPanelTab({ 27236 isGradient, 27237 inheritedValue, 27238 userValue, 27239 setValue, 27240 colorGradientControlSettings 27241 }) { 27242 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(control, { 27243 ...colorGradientControlSettings, 27244 showTitle: false, 27245 enableAlpha: true, 27246 __experimentalIsRenderedInSidebar: true, 27247 colorValue: isGradient ? undefined : inheritedValue, 27248 gradientValue: isGradient ? inheritedValue : undefined, 27249 onColorChange: isGradient ? undefined : setValue, 27250 onGradientChange: isGradient ? setValue : undefined, 27251 clearable: inheritedValue === userValue, 27252 headingLevel: 3 27253 }); 27254 } 27255 function ColorPanelDropdown({ 27256 label, 27257 hasValue, 27258 resetValue, 27259 isShownByDefault, 27260 indicators, 27261 tabs, 27262 colorGradientControlSettings, 27263 panelId 27264 }) { 27265 var _tabs$; 27266 const currentTab = tabs.find(tab => tab.userValue !== undefined); 27267 const { 27268 key: firstTabKey, 27269 ...firstTab 27270 } = (_tabs$ = tabs[0]) !== null && _tabs$ !== void 0 ? _tabs$ : {}; 27271 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 27272 className: "block-editor-tools-panel-color-gradient-settings__item", 27273 hasValue: hasValue, 27274 label: label, 27275 onDeselect: resetValue, 27276 isShownByDefault: isShownByDefault, 27277 panelId: panelId, 27278 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 27279 popoverProps: popoverProps, 27280 className: "block-editor-tools-panel-color-gradient-settings__dropdown", 27281 renderToggle: ({ 27282 onToggle, 27283 isOpen 27284 }) => { 27285 const toggleProps = { 27286 onClick: onToggle, 27287 className: dist_clsx('block-editor-panel-color-gradient-settings__dropdown', { 27288 'is-open': isOpen 27289 }), 27290 'aria-expanded': isOpen, 27291 'aria-label': (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s is the type of color property, e.g., "background" */ 27292 (0,external_wp_i18n_namespaceObject.__)('Color %s styles'), label) 27293 }; 27294 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 27295 __next40pxDefaultSize: true, 27296 ...toggleProps, 27297 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LabeledColorIndicators, { 27298 indicators: indicators, 27299 label: label 27300 }) 27301 }); 27302 }, 27303 renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, { 27304 paddingSize: "none", 27305 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 27306 className: "block-editor-panel-color-gradient-settings__dropdown-content", 27307 children: [tabs.length === 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPanelTab, { 27308 ...firstTab, 27309 colorGradientControlSettings: colorGradientControlSettings 27310 }, firstTabKey), tabs.length > 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(color_panel_Tabs, { 27311 defaultTabId: currentTab?.key, 27312 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(color_panel_Tabs.TabList, { 27313 children: tabs.map(tab => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(color_panel_Tabs.Tab, { 27314 tabId: tab.key, 27315 children: tab.label 27316 }, tab.key)) 27317 }), tabs.map(tab => { 27318 const { 27319 key: tabKey, 27320 ...restTabProps 27321 } = tab; 27322 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(color_panel_Tabs.TabPanel, { 27323 tabId: tabKey, 27324 focusable: false, 27325 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPanelTab, { 27326 ...restTabProps, 27327 colorGradientControlSettings: colorGradientControlSettings 27328 }, tabKey) 27329 }, tabKey); 27330 })] 27331 })] 27332 }) 27333 }) 27334 }) 27335 }); 27336 } 27337 function ColorPanel({ 27338 as: Wrapper = ColorToolsPanel, 27339 value, 27340 onChange, 27341 inheritedValue = value, 27342 settings, 27343 panelId, 27344 defaultControls = color_panel_DEFAULT_CONTROLS, 27345 children 27346 }) { 27347 const colors = useColorsPerOrigin(settings); 27348 const gradients = useGradientsPerOrigin(settings); 27349 const areCustomSolidsEnabled = settings?.color?.custom; 27350 const areCustomGradientsEnabled = settings?.color?.customGradient; 27351 const hasSolidColors = colors.length > 0 || areCustomSolidsEnabled; 27352 const hasGradientColors = gradients.length > 0 || areCustomGradientsEnabled; 27353 const decodeValue = rawValue => getValueFromVariable({ 27354 settings 27355 }, '', rawValue); 27356 const encodeColorValue = colorValue => { 27357 const allColors = colors.flatMap(({ 27358 colors: originColors 27359 }) => originColors); 27360 const colorObject = allColors.find(({ 27361 color 27362 }) => color === colorValue); 27363 return colorObject ? 'var:preset|color|' + colorObject.slug : colorValue; 27364 }; 27365 const encodeGradientValue = gradientValue => { 27366 const allGradients = gradients.flatMap(({ 27367 gradients: originGradients 27368 }) => originGradients); 27369 const gradientObject = allGradients.find(({ 27370 gradient 27371 }) => gradient === gradientValue); 27372 return gradientObject ? 'var:preset|gradient|' + gradientObject.slug : gradientValue; 27373 }; 27374 27375 // BackgroundColor 27376 const showBackgroundPanel = useHasBackgroundColorPanel(settings); 27377 const backgroundColor = decodeValue(inheritedValue?.color?.background); 27378 const userBackgroundColor = decodeValue(value?.color?.background); 27379 const gradient = decodeValue(inheritedValue?.color?.gradient); 27380 const userGradient = decodeValue(value?.color?.gradient); 27381 const hasBackground = () => !!userBackgroundColor || !!userGradient; 27382 const setBackgroundColor = newColor => { 27383 const newValue = setImmutably(value, ['color', 'background'], encodeColorValue(newColor)); 27384 newValue.color.gradient = undefined; 27385 onChange(newValue); 27386 }; 27387 const setGradient = newGradient => { 27388 const newValue = setImmutably(value, ['color', 'gradient'], encodeGradientValue(newGradient)); 27389 newValue.color.background = undefined; 27390 onChange(newValue); 27391 }; 27392 const resetBackground = () => { 27393 const newValue = setImmutably(value, ['color', 'background'], undefined); 27394 newValue.color.gradient = undefined; 27395 onChange(newValue); 27396 }; 27397 27398 // Links 27399 const showLinkPanel = useHasLinkPanel(settings); 27400 const linkColor = decodeValue(inheritedValue?.elements?.link?.color?.text); 27401 const userLinkColor = decodeValue(value?.elements?.link?.color?.text); 27402 const setLinkColor = newColor => { 27403 onChange(setImmutably(value, ['elements', 'link', 'color', 'text'], encodeColorValue(newColor))); 27404 }; 27405 const hoverLinkColor = decodeValue(inheritedValue?.elements?.link?.[':hover']?.color?.text); 27406 const userHoverLinkColor = decodeValue(value?.elements?.link?.[':hover']?.color?.text); 27407 const setHoverLinkColor = newColor => { 27408 onChange(setImmutably(value, ['elements', 'link', ':hover', 'color', 'text'], encodeColorValue(newColor))); 27409 }; 27410 const hasLink = () => !!userLinkColor || !!userHoverLinkColor; 27411 const resetLink = () => { 27412 let newValue = setImmutably(value, ['elements', 'link', ':hover', 'color', 'text'], undefined); 27413 newValue = setImmutably(newValue, ['elements', 'link', 'color', 'text'], undefined); 27414 onChange(newValue); 27415 }; 27416 27417 // Text Color 27418 const showTextPanel = useHasTextPanel(settings); 27419 const textColor = decodeValue(inheritedValue?.color?.text); 27420 const userTextColor = decodeValue(value?.color?.text); 27421 const hasTextColor = () => !!userTextColor; 27422 const setTextColor = newColor => { 27423 let changedObject = setImmutably(value, ['color', 'text'], encodeColorValue(newColor)); 27424 if (textColor === linkColor) { 27425 changedObject = setImmutably(changedObject, ['elements', 'link', 'color', 'text'], encodeColorValue(newColor)); 27426 } 27427 onChange(changedObject); 27428 }; 27429 const resetTextColor = () => setTextColor(undefined); 27430 27431 // Elements 27432 const elements = [{ 27433 name: 'caption', 27434 label: (0,external_wp_i18n_namespaceObject.__)('Captions'), 27435 showPanel: useHasCaptionPanel(settings) 27436 }, { 27437 name: 'button', 27438 label: (0,external_wp_i18n_namespaceObject.__)('Button'), 27439 showPanel: useHasButtonPanel(settings) 27440 }, { 27441 name: 'heading', 27442 label: (0,external_wp_i18n_namespaceObject.__)('Heading'), 27443 showPanel: useHasHeadingPanel(settings) 27444 }, { 27445 name: 'h1', 27446 label: (0,external_wp_i18n_namespaceObject.__)('H1'), 27447 showPanel: useHasHeadingPanel(settings) 27448 }, { 27449 name: 'h2', 27450 label: (0,external_wp_i18n_namespaceObject.__)('H2'), 27451 showPanel: useHasHeadingPanel(settings) 27452 }, { 27453 name: 'h3', 27454 label: (0,external_wp_i18n_namespaceObject.__)('H3'), 27455 showPanel: useHasHeadingPanel(settings) 27456 }, { 27457 name: 'h4', 27458 label: (0,external_wp_i18n_namespaceObject.__)('H4'), 27459 showPanel: useHasHeadingPanel(settings) 27460 }, { 27461 name: 'h5', 27462 label: (0,external_wp_i18n_namespaceObject.__)('H5'), 27463 showPanel: useHasHeadingPanel(settings) 27464 }, { 27465 name: 'h6', 27466 label: (0,external_wp_i18n_namespaceObject.__)('H6'), 27467 showPanel: useHasHeadingPanel(settings) 27468 }]; 27469 const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue => { 27470 return { 27471 ...previousValue, 27472 color: undefined, 27473 elements: { 27474 ...previousValue?.elements, 27475 link: { 27476 ...previousValue?.elements?.link, 27477 color: undefined, 27478 ':hover': { 27479 color: undefined 27480 } 27481 }, 27482 ...elements.reduce((acc, element) => { 27483 return { 27484 ...acc, 27485 [element.name]: { 27486 ...previousValue?.elements?.[element.name], 27487 color: undefined 27488 } 27489 }; 27490 }, {}) 27491 } 27492 }; 27493 }, []); 27494 const items = [showTextPanel && { 27495 key: 'text', 27496 label: (0,external_wp_i18n_namespaceObject.__)('Text'), 27497 hasValue: hasTextColor, 27498 resetValue: resetTextColor, 27499 isShownByDefault: defaultControls.text, 27500 indicators: [textColor], 27501 tabs: [{ 27502 key: 'text', 27503 label: (0,external_wp_i18n_namespaceObject.__)('Text'), 27504 inheritedValue: textColor, 27505 setValue: setTextColor, 27506 userValue: userTextColor 27507 }] 27508 }, showBackgroundPanel && { 27509 key: 'background', 27510 label: (0,external_wp_i18n_namespaceObject.__)('Background'), 27511 hasValue: hasBackground, 27512 resetValue: resetBackground, 27513 isShownByDefault: defaultControls.background, 27514 indicators: [gradient !== null && gradient !== void 0 ? gradient : backgroundColor], 27515 tabs: [hasSolidColors && { 27516 key: 'background', 27517 label: (0,external_wp_i18n_namespaceObject.__)('Color'), 27518 inheritedValue: backgroundColor, 27519 setValue: setBackgroundColor, 27520 userValue: userBackgroundColor 27521 }, hasGradientColors && { 27522 key: 'gradient', 27523 label: (0,external_wp_i18n_namespaceObject.__)('Gradient'), 27524 inheritedValue: gradient, 27525 setValue: setGradient, 27526 userValue: userGradient, 27527 isGradient: true 27528 }].filter(Boolean) 27529 }, showLinkPanel && { 27530 key: 'link', 27531 label: (0,external_wp_i18n_namespaceObject.__)('Link'), 27532 hasValue: hasLink, 27533 resetValue: resetLink, 27534 isShownByDefault: defaultControls.link, 27535 indicators: [linkColor, hoverLinkColor], 27536 tabs: [{ 27537 key: 'link', 27538 label: (0,external_wp_i18n_namespaceObject.__)('Default'), 27539 inheritedValue: linkColor, 27540 setValue: setLinkColor, 27541 userValue: userLinkColor 27542 }, { 27543 key: 'hover', 27544 label: (0,external_wp_i18n_namespaceObject.__)('Hover'), 27545 inheritedValue: hoverLinkColor, 27546 setValue: setHoverLinkColor, 27547 userValue: userHoverLinkColor 27548 }] 27549 }].filter(Boolean); 27550 elements.forEach(({ 27551 name, 27552 label, 27553 showPanel 27554 }) => { 27555 if (!showPanel) { 27556 return; 27557 } 27558 const elementBackgroundColor = decodeValue(inheritedValue?.elements?.[name]?.color?.background); 27559 const elementGradient = decodeValue(inheritedValue?.elements?.[name]?.color?.gradient); 27560 const elementTextColor = decodeValue(inheritedValue?.elements?.[name]?.color?.text); 27561 const elementBackgroundUserColor = decodeValue(value?.elements?.[name]?.color?.background); 27562 const elementGradientUserColor = decodeValue(value?.elements?.[name]?.color?.gradient); 27563 const elementTextUserColor = decodeValue(value?.elements?.[name]?.color?.text); 27564 const hasElement = () => !!(elementTextUserColor || elementBackgroundUserColor || elementGradientUserColor); 27565 const resetElement = () => { 27566 const newValue = setImmutably(value, ['elements', name, 'color', 'background'], undefined); 27567 newValue.elements[name].color.gradient = undefined; 27568 newValue.elements[name].color.text = undefined; 27569 onChange(newValue); 27570 }; 27571 const setElementTextColor = newTextColor => { 27572 onChange(setImmutably(value, ['elements', name, 'color', 'text'], encodeColorValue(newTextColor))); 27573 }; 27574 const setElementBackgroundColor = newBackgroundColor => { 27575 const newValue = setImmutably(value, ['elements', name, 'color', 'background'], encodeColorValue(newBackgroundColor)); 27576 newValue.elements[name].color.gradient = undefined; 27577 onChange(newValue); 27578 }; 27579 const setElementGradient = newGradient => { 27580 const newValue = setImmutably(value, ['elements', name, 'color', 'gradient'], encodeGradientValue(newGradient)); 27581 newValue.elements[name].color.background = undefined; 27582 onChange(newValue); 27583 }; 27584 const supportsTextColor = true; 27585 // Background color is not supported for `caption` 27586 // as there isn't yet a way to set padding for the element. 27587 const supportsBackground = name !== 'caption'; 27588 items.push({ 27589 key: name, 27590 label, 27591 hasValue: hasElement, 27592 resetValue: resetElement, 27593 isShownByDefault: defaultControls[name], 27594 indicators: supportsTextColor && supportsBackground ? [elementTextColor, elementGradient !== null && elementGradient !== void 0 ? elementGradient : elementBackgroundColor] : [supportsTextColor ? elementTextColor : elementGradient !== null && elementGradient !== void 0 ? elementGradient : elementBackgroundColor], 27595 tabs: [hasSolidColors && supportsTextColor && { 27596 key: 'text', 27597 label: (0,external_wp_i18n_namespaceObject.__)('Text'), 27598 inheritedValue: elementTextColor, 27599 setValue: setElementTextColor, 27600 userValue: elementTextUserColor 27601 }, hasSolidColors && supportsBackground && { 27602 key: 'background', 27603 label: (0,external_wp_i18n_namespaceObject.__)('Background'), 27604 inheritedValue: elementBackgroundColor, 27605 setValue: setElementBackgroundColor, 27606 userValue: elementBackgroundUserColor 27607 }, hasGradientColors && supportsBackground && { 27608 key: 'gradient', 27609 label: (0,external_wp_i18n_namespaceObject.__)('Gradient'), 27610 inheritedValue: elementGradient, 27611 setValue: setElementGradient, 27612 userValue: elementGradientUserColor, 27613 isGradient: true 27614 }].filter(Boolean) 27615 }); 27616 }); 27617 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, { 27618 resetAllFilter: resetAllFilter, 27619 value: value, 27620 onChange: onChange, 27621 panelId: panelId, 27622 children: [items.map(item => { 27623 const { 27624 key, 27625 ...restItem 27626 } = item; 27627 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPanelDropdown, { 27628 ...restItem, 27629 colorGradientControlSettings: { 27630 colors, 27631 disableCustomColors: !areCustomSolidsEnabled, 27632 gradients, 27633 disableCustomGradients: !areCustomGradientsEnabled 27634 }, 27635 panelId: panelId 27636 }, key); 27637 }), children] 27638 }); 27639 } 27640 27641 ;// ./node_modules/@wordpress/block-editor/build-module/components/contrast-checker/index.js 27642 /** 27643 * External dependencies 27644 */ 27645 27646 27647 27648 27649 /** 27650 * WordPress dependencies 27651 */ 27652 27653 27654 27655 27656 k([names, a11y]); 27657 function ContrastChecker({ 27658 backgroundColor, 27659 fallbackBackgroundColor, 27660 fallbackTextColor, 27661 fallbackLinkColor, 27662 fontSize, 27663 // Font size value in pixels. 27664 isLargeText, 27665 textColor, 27666 linkColor, 27667 enableAlphaChecker = false 27668 }) { 27669 const currentBackgroundColor = backgroundColor || fallbackBackgroundColor; 27670 27671 // Must have a background color. 27672 if (!currentBackgroundColor) { 27673 return null; 27674 } 27675 const currentTextColor = textColor || fallbackTextColor; 27676 const currentLinkColor = linkColor || fallbackLinkColor; 27677 27678 // Must have at least one text color. 27679 if (!currentTextColor && !currentLinkColor) { 27680 return null; 27681 } 27682 const textColors = [{ 27683 color: currentTextColor, 27684 description: (0,external_wp_i18n_namespaceObject.__)('text color') 27685 }, { 27686 color: currentLinkColor, 27687 description: (0,external_wp_i18n_namespaceObject.__)('link color') 27688 }]; 27689 const colordBackgroundColor = w(currentBackgroundColor); 27690 const backgroundColorHasTransparency = colordBackgroundColor.alpha() < 1; 27691 const backgroundColorBrightness = colordBackgroundColor.brightness(); 27692 const isReadableOptions = { 27693 level: 'AA', 27694 size: isLargeText || isLargeText !== false && fontSize >= 24 ? 'large' : 'small' 27695 }; 27696 let message = ''; 27697 let speakMessage = ''; 27698 for (const item of textColors) { 27699 // If there is no color, go no further. 27700 if (!item.color) { 27701 continue; 27702 } 27703 const colordTextColor = w(item.color); 27704 const isColordTextReadable = colordTextColor.isReadable(colordBackgroundColor, isReadableOptions); 27705 const textHasTransparency = colordTextColor.alpha() < 1; 27706 27707 // If the contrast is not readable. 27708 if (!isColordTextReadable) { 27709 // Don't show the message if the background or text is transparent. 27710 if (backgroundColorHasTransparency || textHasTransparency) { 27711 continue; 27712 } 27713 message = backgroundColorBrightness < colordTextColor.brightness() ? (0,external_wp_i18n_namespaceObject.sprintf)( 27714 // translators: %s is a type of text color, e.g., "text color" or "link color". 27715 (0,external_wp_i18n_namespaceObject.__)('This color combination may be hard for people to read. Try using a darker background color and/or a brighter %s.'), item.description) : (0,external_wp_i18n_namespaceObject.sprintf)( 27716 // translators: %s is a type of text color, e.g., "text color" or "link color". 27717 (0,external_wp_i18n_namespaceObject.__)('This color combination may be hard for people to read. Try using a brighter background color and/or a darker %s.'), item.description); 27718 speakMessage = (0,external_wp_i18n_namespaceObject.__)('This color combination may be hard for people to read.'); 27719 // Break from the loop when we have a contrast warning. 27720 // These messages take priority over the transparency warning. 27721 break; 27722 } 27723 27724 // If there is no contrast warning and the text is transparent, 27725 // show the transparent warning if alpha check is enabled. 27726 if (textHasTransparency && enableAlphaChecker) { 27727 message = (0,external_wp_i18n_namespaceObject.__)('Transparent text may be hard for people to read.'); 27728 speakMessage = (0,external_wp_i18n_namespaceObject.__)('Transparent text may be hard for people to read.'); 27729 } 27730 } 27731 if (!message) { 27732 return null; 27733 } 27734 27735 // Note: The `Notice` component can speak messages via its `spokenMessage` 27736 // prop, but the contrast checker requires granular control over when the 27737 // announcements are made. Notably, the message will be re-announced if a 27738 // new color combination is selected and the contrast is still insufficient. 27739 (0,external_wp_a11y_namespaceObject.speak)(speakMessage); 27740 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 27741 className: "block-editor-contrast-checker", 27742 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Notice, { 27743 spokenMessage: null, 27744 status: "warning", 27745 isDismissible: false, 27746 children: message 27747 }) 27748 }); 27749 } 27750 27751 /** 27752 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/contrast-checker/README.md 27753 */ 27754 /* harmony default export */ const contrast_checker = (ContrastChecker); 27755 27756 ;// ./node_modules/@wordpress/block-editor/build-module/components/provider/block-refs-provider.js 27757 /** 27758 * WordPress dependencies 27759 */ 27760 27761 27762 27763 const BlockRefs = (0,external_wp_element_namespaceObject.createContext)({ 27764 refsMap: (0,external_wp_compose_namespaceObject.observableMap)() 27765 }); 27766 function BlockRefsProvider({ 27767 children 27768 }) { 27769 const value = (0,external_wp_element_namespaceObject.useMemo)(() => ({ 27770 refsMap: (0,external_wp_compose_namespaceObject.observableMap)() 27771 }), []); 27772 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockRefs.Provider, { 27773 value: value, 27774 children: children 27775 }); 27776 } 27777 27778 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-block-refs.js 27779 /** 27780 * WordPress dependencies 27781 */ 27782 27783 27784 27785 /** 27786 * Internal dependencies 27787 */ 27788 27789 27790 /** @typedef {import('@wordpress/element').RefCallback} RefCallback */ 27791 /** @typedef {import('@wordpress/element').Ref} Ref */ 27792 27793 /** 27794 * Provides a ref to the BlockRefs context. 27795 * 27796 * @param {string} clientId The client ID of the element ref. 27797 * 27798 * @return {RefCallback} Ref callback. 27799 */ 27800 function useBlockRefProvider(clientId) { 27801 const { 27802 refsMap 27803 } = (0,external_wp_element_namespaceObject.useContext)(BlockRefs); 27804 return (0,external_wp_compose_namespaceObject.useRefEffect)(element => { 27805 refsMap.set(clientId, element); 27806 return () => refsMap.delete(clientId); 27807 }, [clientId]); 27808 } 27809 function assignRef(ref, value) { 27810 if (typeof ref === 'function') { 27811 ref(value); 27812 } else if (ref) { 27813 ref.current = value; 27814 } 27815 } 27816 27817 /** 27818 * Tracks the DOM element for the block identified by `clientId` and assigns it to the `ref` 27819 * whenever it changes. 27820 * 27821 * @param {string} clientId The client ID to track. 27822 * @param {Ref} ref The ref object/callback to assign to. 27823 */ 27824 function useBlockElementRef(clientId, ref) { 27825 const { 27826 refsMap 27827 } = (0,external_wp_element_namespaceObject.useContext)(BlockRefs); 27828 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 27829 assignRef(ref, refsMap.get(clientId)); 27830 const unsubscribe = refsMap.subscribe(clientId, () => assignRef(ref, refsMap.get(clientId))); 27831 return () => { 27832 unsubscribe(); 27833 assignRef(ref, null); 27834 }; 27835 }, [refsMap, clientId, ref]); 27836 } 27837 27838 /** 27839 * Return the element for a given client ID. Updates whenever the element 27840 * changes, becomes available, or disappears. 27841 * 27842 * @param {string} clientId The client ID to an element for. 27843 * 27844 * @return {Element|null} The block's wrapper element. 27845 */ 27846 function useBlockElement(clientId) { 27847 const [blockElement, setBlockElement] = (0,external_wp_element_namespaceObject.useState)(null); 27848 useBlockElementRef(clientId, setBlockElement); 27849 return blockElement; 27850 } 27851 27852 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/contrast-checker.js 27853 /** 27854 * WordPress dependencies 27855 */ 27856 27857 27858 /** 27859 * Internal dependencies 27860 */ 27861 27862 27863 27864 function getComputedStyle(node) { 27865 return node.ownerDocument.defaultView.getComputedStyle(node); 27866 } 27867 function BlockColorContrastChecker({ 27868 clientId 27869 }) { 27870 const [detectedBackgroundColor, setDetectedBackgroundColor] = (0,external_wp_element_namespaceObject.useState)(); 27871 const [detectedColor, setDetectedColor] = (0,external_wp_element_namespaceObject.useState)(); 27872 const [detectedLinkColor, setDetectedLinkColor] = (0,external_wp_element_namespaceObject.useState)(); 27873 const blockEl = useBlockElement(clientId); 27874 27875 // There are so many things that can change the color of a block 27876 // So we perform this check on every render. 27877 // eslint-disable-next-line react-hooks/exhaustive-deps 27878 (0,external_wp_element_namespaceObject.useEffect)(() => { 27879 if (!blockEl) { 27880 return; 27881 } 27882 setDetectedColor(getComputedStyle(blockEl).color); 27883 const firstLinkElement = blockEl.querySelector('a'); 27884 if (firstLinkElement && !!firstLinkElement.innerText) { 27885 setDetectedLinkColor(getComputedStyle(firstLinkElement).color); 27886 } 27887 let backgroundColorNode = blockEl; 27888 let backgroundColor = getComputedStyle(backgroundColorNode).backgroundColor; 27889 while (backgroundColor === 'rgba(0, 0, 0, 0)' && backgroundColorNode.parentNode && backgroundColorNode.parentNode.nodeType === backgroundColorNode.parentNode.ELEMENT_NODE) { 27890 backgroundColorNode = backgroundColorNode.parentNode; 27891 backgroundColor = getComputedStyle(backgroundColorNode).backgroundColor; 27892 } 27893 setDetectedBackgroundColor(backgroundColor); 27894 }, [blockEl]); 27895 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(contrast_checker, { 27896 backgroundColor: detectedBackgroundColor, 27897 textColor: detectedColor, 27898 enableAlphaChecker: true, 27899 linkColor: detectedLinkColor 27900 }); 27901 } 27902 27903 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/color.js 27904 /** 27905 * External dependencies 27906 */ 27907 27908 27909 /** 27910 * WordPress dependencies 27911 */ 27912 27913 27914 27915 27916 27917 /** 27918 * Internal dependencies 27919 */ 27920 27921 27922 27923 27924 27925 27926 27927 27928 27929 27930 const COLOR_SUPPORT_KEY = 'color'; 27931 const hasColorSupport = blockNameOrType => { 27932 const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockNameOrType, COLOR_SUPPORT_KEY); 27933 return colorSupport && (colorSupport.link === true || colorSupport.gradient === true || colorSupport.background !== false || colorSupport.text !== false); 27934 }; 27935 const hasLinkColorSupport = blockType => { 27936 if (external_wp_element_namespaceObject.Platform.OS !== 'web') { 27937 return false; 27938 } 27939 const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, COLOR_SUPPORT_KEY); 27940 return colorSupport !== null && typeof colorSupport === 'object' && !!colorSupport.link; 27941 }; 27942 const hasGradientSupport = blockNameOrType => { 27943 const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockNameOrType, COLOR_SUPPORT_KEY); 27944 return colorSupport !== null && typeof colorSupport === 'object' && !!colorSupport.gradients; 27945 }; 27946 const hasBackgroundColorSupport = blockType => { 27947 const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, COLOR_SUPPORT_KEY); 27948 return colorSupport && colorSupport.background !== false; 27949 }; 27950 const hasTextColorSupport = blockType => { 27951 const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, COLOR_SUPPORT_KEY); 27952 return colorSupport && colorSupport.text !== false; 27953 }; 27954 27955 /** 27956 * Filters registered block settings, extending attributes to include 27957 * `backgroundColor` and `textColor` attribute. 27958 * 27959 * @param {Object} settings Original block settings. 27960 * 27961 * @return {Object} Filtered block settings. 27962 */ 27963 function color_addAttributes(settings) { 27964 if (!hasColorSupport(settings)) { 27965 return settings; 27966 } 27967 27968 // Allow blocks to specify their own attribute definition with default values if needed. 27969 if (!settings.attributes.backgroundColor) { 27970 Object.assign(settings.attributes, { 27971 backgroundColor: { 27972 type: 'string' 27973 } 27974 }); 27975 } 27976 if (!settings.attributes.textColor) { 27977 Object.assign(settings.attributes, { 27978 textColor: { 27979 type: 'string' 27980 } 27981 }); 27982 } 27983 if (hasGradientSupport(settings) && !settings.attributes.gradient) { 27984 Object.assign(settings.attributes, { 27985 gradient: { 27986 type: 'string' 27987 } 27988 }); 27989 } 27990 return settings; 27991 } 27992 27993 /** 27994 * Override props assigned to save component to inject colors classnames. 27995 * 27996 * @param {Object} props Additional props applied to save element. 27997 * @param {Object|string} blockNameOrType Block type. 27998 * @param {Object} attributes Block attributes. 27999 * 28000 * @return {Object} Filtered props applied to save element. 28001 */ 28002 function color_addSaveProps(props, blockNameOrType, attributes) { 28003 if (!hasColorSupport(blockNameOrType) || shouldSkipSerialization(blockNameOrType, COLOR_SUPPORT_KEY)) { 28004 return props; 28005 } 28006 const hasGradient = hasGradientSupport(blockNameOrType); 28007 28008 // I'd have preferred to avoid the "style" attribute usage here 28009 const { 28010 backgroundColor, 28011 textColor, 28012 gradient, 28013 style 28014 } = attributes; 28015 const shouldSerialize = feature => !shouldSkipSerialization(blockNameOrType, COLOR_SUPPORT_KEY, feature); 28016 28017 // Primary color classes must come before the `has-text-color`, 28018 // `has-background` and `has-link-color` classes to maintain backwards 28019 // compatibility and avoid block invalidations. 28020 const textClass = shouldSerialize('text') ? getColorClassName('color', textColor) : undefined; 28021 const gradientClass = shouldSerialize('gradients') ? __experimentalGetGradientClass(gradient) : undefined; 28022 const backgroundClass = shouldSerialize('background') ? getColorClassName('background-color', backgroundColor) : undefined; 28023 const serializeHasBackground = shouldSerialize('background') || shouldSerialize('gradients'); 28024 const hasBackground = backgroundColor || style?.color?.background || hasGradient && (gradient || style?.color?.gradient); 28025 const newClassName = dist_clsx(props.className, textClass, gradientClass, { 28026 // Don't apply the background class if there's a custom gradient. 28027 [backgroundClass]: (!hasGradient || !style?.color?.gradient) && !!backgroundClass, 28028 'has-text-color': shouldSerialize('text') && (textColor || style?.color?.text), 28029 'has-background': serializeHasBackground && hasBackground, 28030 'has-link-color': shouldSerialize('link') && style?.elements?.link?.color 28031 }); 28032 props.className = newClassName ? newClassName : undefined; 28033 return props; 28034 } 28035 function color_styleToAttributes(style) { 28036 const textColorValue = style?.color?.text; 28037 const textColorSlug = textColorValue?.startsWith('var:preset|color|') ? textColorValue.substring('var:preset|color|'.length) : undefined; 28038 const backgroundColorValue = style?.color?.background; 28039 const backgroundColorSlug = backgroundColorValue?.startsWith('var:preset|color|') ? backgroundColorValue.substring('var:preset|color|'.length) : undefined; 28040 const gradientValue = style?.color?.gradient; 28041 const gradientSlug = gradientValue?.startsWith('var:preset|gradient|') ? gradientValue.substring('var:preset|gradient|'.length) : undefined; 28042 const updatedStyle = { 28043 ...style 28044 }; 28045 updatedStyle.color = { 28046 ...updatedStyle.color, 28047 text: textColorSlug ? undefined : textColorValue, 28048 background: backgroundColorSlug ? undefined : backgroundColorValue, 28049 gradient: gradientSlug ? undefined : gradientValue 28050 }; 28051 return { 28052 style: utils_cleanEmptyObject(updatedStyle), 28053 textColor: textColorSlug, 28054 backgroundColor: backgroundColorSlug, 28055 gradient: gradientSlug 28056 }; 28057 } 28058 function color_attributesToStyle(attributes) { 28059 return { 28060 ...attributes.style, 28061 color: { 28062 ...attributes.style?.color, 28063 text: attributes.textColor ? 'var:preset|color|' + attributes.textColor : attributes.style?.color?.text, 28064 background: attributes.backgroundColor ? 'var:preset|color|' + attributes.backgroundColor : attributes.style?.color?.background, 28065 gradient: attributes.gradient ? 'var:preset|gradient|' + attributes.gradient : attributes.style?.color?.gradient 28066 } 28067 }; 28068 } 28069 function ColorInspectorControl({ 28070 children, 28071 resetAllFilter 28072 }) { 28073 const attributesResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes => { 28074 const existingStyle = color_attributesToStyle(attributes); 28075 const updatedStyle = resetAllFilter(existingStyle); 28076 return { 28077 ...attributes, 28078 ...color_styleToAttributes(updatedStyle) 28079 }; 28080 }, [resetAllFilter]); 28081 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, { 28082 group: "color", 28083 resetAllFilter: attributesResetAllFilter, 28084 children: children 28085 }); 28086 } 28087 function ColorEdit({ 28088 clientId, 28089 name, 28090 setAttributes, 28091 settings 28092 }) { 28093 const isEnabled = useHasColorPanel(settings); 28094 function selector(select) { 28095 const { 28096 style, 28097 textColor, 28098 backgroundColor, 28099 gradient 28100 } = select(store).getBlockAttributes(clientId) || {}; 28101 return { 28102 style, 28103 textColor, 28104 backgroundColor, 28105 gradient 28106 }; 28107 } 28108 const { 28109 style, 28110 textColor, 28111 backgroundColor, 28112 gradient 28113 } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId]); 28114 const value = (0,external_wp_element_namespaceObject.useMemo)(() => { 28115 return color_attributesToStyle({ 28116 style, 28117 textColor, 28118 backgroundColor, 28119 gradient 28120 }); 28121 }, [style, textColor, backgroundColor, gradient]); 28122 const onChange = newStyle => { 28123 setAttributes(color_styleToAttributes(newStyle)); 28124 }; 28125 if (!isEnabled) { 28126 return null; 28127 } 28128 const defaultControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [COLOR_SUPPORT_KEY, '__experimentalDefaultControls']); 28129 const enableContrastChecking = external_wp_element_namespaceObject.Platform.OS === 'web' && !value?.color?.gradient && (settings?.color?.text || settings?.color?.link) && 28130 // Contrast checking is enabled by default. 28131 // Deactivating it requires `enableContrastChecker` to have 28132 // an explicit value of `false`. 28133 false !== (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [COLOR_SUPPORT_KEY, 'enableContrastChecker']); 28134 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPanel, { 28135 as: ColorInspectorControl, 28136 panelId: clientId, 28137 settings: settings, 28138 value: value, 28139 onChange: onChange, 28140 defaultControls: defaultControls, 28141 enableContrastChecker: false !== (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [COLOR_SUPPORT_KEY, 'enableContrastChecker']), 28142 children: enableContrastChecking && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockColorContrastChecker, { 28143 clientId: clientId 28144 }) 28145 }); 28146 } 28147 function color_useBlockProps({ 28148 name, 28149 backgroundColor, 28150 textColor, 28151 gradient, 28152 style 28153 }) { 28154 const [userPalette, themePalette, defaultPalette] = use_settings_useSettings('color.palette.custom', 'color.palette.theme', 'color.palette.default'); 28155 const colors = (0,external_wp_element_namespaceObject.useMemo)(() => [...(userPalette || []), ...(themePalette || []), ...(defaultPalette || [])], [userPalette, themePalette, defaultPalette]); 28156 if (!hasColorSupport(name) || shouldSkipSerialization(name, COLOR_SUPPORT_KEY)) { 28157 return {}; 28158 } 28159 const extraStyles = {}; 28160 if (textColor && !shouldSkipSerialization(name, COLOR_SUPPORT_KEY, 'text')) { 28161 extraStyles.color = getColorObjectByAttributeValues(colors, textColor)?.color; 28162 } 28163 if (backgroundColor && !shouldSkipSerialization(name, COLOR_SUPPORT_KEY, 'background')) { 28164 extraStyles.backgroundColor = getColorObjectByAttributeValues(colors, backgroundColor)?.color; 28165 } 28166 const saveProps = color_addSaveProps({ 28167 style: extraStyles 28168 }, name, { 28169 textColor, 28170 backgroundColor, 28171 gradient, 28172 style 28173 }); 28174 const hasBackgroundValue = backgroundColor || style?.color?.background || gradient || style?.color?.gradient; 28175 return { 28176 ...saveProps, 28177 className: dist_clsx(saveProps.className, 28178 // Add background image classes in the editor, if not already handled by background color values. 28179 !hasBackgroundValue && getBackgroundImageClasses(style)) 28180 }; 28181 } 28182 /* harmony default export */ const color = ({ 28183 useBlockProps: color_useBlockProps, 28184 addSaveProps: color_addSaveProps, 28185 attributeKeys: ['backgroundColor', 'textColor', 'gradient', 'style'], 28186 hasSupport: hasColorSupport 28187 }); 28188 const MIGRATION_PATHS = { 28189 linkColor: [['style', 'elements', 'link', 'color', 'text']], 28190 textColor: [['textColor'], ['style', 'color', 'text']], 28191 backgroundColor: [['backgroundColor'], ['style', 'color', 'background']], 28192 gradient: [['gradient'], ['style', 'color', 'gradient']] 28193 }; 28194 function color_addTransforms(result, source, index, results) { 28195 const destinationBlockType = result.name; 28196 const activeSupports = { 28197 linkColor: hasLinkColorSupport(destinationBlockType), 28198 textColor: hasTextColorSupport(destinationBlockType), 28199 backgroundColor: hasBackgroundColorSupport(destinationBlockType), 28200 gradient: hasGradientSupport(destinationBlockType) 28201 }; 28202 return transformStyles(activeSupports, MIGRATION_PATHS, result, source, index, results); 28203 } 28204 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/color/addAttribute', color_addAttributes); 28205 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.switchToBlockType.transformedBlock', 'core/color/addTransforms', color_addTransforms); 28206 28207 ;// ./node_modules/@wordpress/block-editor/build-module/components/font-family/index.js 28208 /** 28209 * WordPress dependencies 28210 */ 28211 28212 28213 28214 28215 /** 28216 * Internal dependencies 28217 */ 28218 28219 28220 function FontFamilyControl({ 28221 /** Start opting into the larger default height that will become the default size in a future version. */ 28222 __next40pxDefaultSize = false, 28223 /** Start opting into the new margin-free styles that will become the default in a future version. */ 28224 __nextHasNoMarginBottom = false, 28225 value = '', 28226 onChange, 28227 fontFamilies, 28228 ...props 28229 }) { 28230 const [blockLevelFontFamilies] = use_settings_useSettings('typography.fontFamilies'); 28231 if (!fontFamilies) { 28232 fontFamilies = blockLevelFontFamilies; 28233 } 28234 if (!fontFamilies || fontFamilies.length === 0) { 28235 return null; 28236 } 28237 const options = [{ 28238 value: '', 28239 label: (0,external_wp_i18n_namespaceObject.__)('Default') 28240 }, ...fontFamilies.map(({ 28241 fontFamily, 28242 name 28243 }) => { 28244 return { 28245 value: fontFamily, 28246 label: name || fontFamily 28247 }; 28248 })]; 28249 if (!__nextHasNoMarginBottom) { 28250 external_wp_deprecated_default()('Bottom margin styles for wp.blockEditor.FontFamilyControl', { 28251 since: '6.7', 28252 version: '7.0', 28253 hint: 'Set the `__nextHasNoMarginBottom` prop to true to start opting into the new styles, which will become the default in a future version' 28254 }); 28255 } 28256 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SelectControl, { 28257 __next40pxDefaultSize: __next40pxDefaultSize, 28258 __nextHasNoMarginBottom: __nextHasNoMarginBottom, 28259 label: (0,external_wp_i18n_namespaceObject.__)('Font'), 28260 options: options, 28261 value: value, 28262 onChange: onChange, 28263 labelPosition: "top", 28264 ...props 28265 }); 28266 } 28267 28268 ;// ./node_modules/@wordpress/block-editor/build-module/components/font-appearance-control/index.js 28269 /** 28270 * WordPress dependencies 28271 */ 28272 28273 28274 28275 28276 /** 28277 * Internal dependencies 28278 */ 28279 28280 28281 /** 28282 * Adjusts font appearance field label in case either font styles or weights 28283 * are disabled. 28284 * 28285 * @param {boolean} hasFontStyles Whether font styles are enabled and present. 28286 * @param {boolean} hasFontWeights Whether font weights are enabled and present. 28287 * @return {string} A label representing what font appearance is being edited. 28288 */ 28289 28290 const getFontAppearanceLabel = (hasFontStyles, hasFontWeights) => { 28291 if (!hasFontStyles) { 28292 return (0,external_wp_i18n_namespaceObject.__)('Font weight'); 28293 } 28294 if (!hasFontWeights) { 28295 return (0,external_wp_i18n_namespaceObject.__)('Font style'); 28296 } 28297 return (0,external_wp_i18n_namespaceObject.__)('Appearance'); 28298 }; 28299 28300 /** 28301 * Control to display font style and weight options of the active font. 28302 * 28303 * @param {Object} props Component props. 28304 * 28305 * @return {Element} Font appearance control. 28306 */ 28307 function FontAppearanceControl(props) { 28308 const { 28309 /** Start opting into the larger default height that will become the default size in a future version. */ 28310 __next40pxDefaultSize = false, 28311 onChange, 28312 hasFontStyles = true, 28313 hasFontWeights = true, 28314 fontFamilyFaces, 28315 value: { 28316 fontStyle, 28317 fontWeight 28318 }, 28319 ...otherProps 28320 } = props; 28321 const hasStylesOrWeights = hasFontStyles || hasFontWeights; 28322 const label = getFontAppearanceLabel(hasFontStyles, hasFontWeights); 28323 const defaultOption = { 28324 key: 'default', 28325 name: (0,external_wp_i18n_namespaceObject.__)('Default'), 28326 style: { 28327 fontStyle: undefined, 28328 fontWeight: undefined 28329 } 28330 }; 28331 const { 28332 fontStyles, 28333 fontWeights, 28334 combinedStyleAndWeightOptions 28335 } = getFontStylesAndWeights(fontFamilyFaces); 28336 28337 // Generates select options for combined font styles and weights. 28338 const combineOptions = () => { 28339 const combinedOptions = [defaultOption]; 28340 if (combinedStyleAndWeightOptions) { 28341 combinedOptions.push(...combinedStyleAndWeightOptions); 28342 } 28343 return combinedOptions; 28344 }; 28345 28346 // Generates select options for font styles only. 28347 const styleOptions = () => { 28348 const combinedOptions = [defaultOption]; 28349 fontStyles.forEach(({ 28350 name, 28351 value 28352 }) => { 28353 combinedOptions.push({ 28354 key: value, 28355 name, 28356 style: { 28357 fontStyle: value, 28358 fontWeight: undefined 28359 } 28360 }); 28361 }); 28362 return combinedOptions; 28363 }; 28364 28365 // Generates select options for font weights only. 28366 const weightOptions = () => { 28367 const combinedOptions = [defaultOption]; 28368 fontWeights.forEach(({ 28369 name, 28370 value 28371 }) => { 28372 combinedOptions.push({ 28373 key: value, 28374 name, 28375 style: { 28376 fontStyle: undefined, 28377 fontWeight: value 28378 } 28379 }); 28380 }); 28381 return combinedOptions; 28382 }; 28383 28384 // Map font styles and weights to select options. 28385 const selectOptions = (0,external_wp_element_namespaceObject.useMemo)(() => { 28386 // Display combined available font style and weight options. 28387 if (hasFontStyles && hasFontWeights) { 28388 return combineOptions(); 28389 } 28390 28391 // Display only font style options or font weight options. 28392 return hasFontStyles ? styleOptions() : weightOptions(); 28393 }, [props.options, fontStyles, fontWeights, combinedStyleAndWeightOptions]); 28394 28395 // Find current selection by comparing font style & weight against options, 28396 // and fall back to the Default option if there is no matching option. 28397 const currentSelection = selectOptions.find(option => option.style.fontStyle === fontStyle && option.style.fontWeight === fontWeight) || selectOptions[0]; 28398 28399 // Adjusts screen reader description based on styles or weights. 28400 const getDescribedBy = () => { 28401 if (!currentSelection) { 28402 return (0,external_wp_i18n_namespaceObject.__)('No selected font appearance'); 28403 } 28404 if (!hasFontStyles) { 28405 return (0,external_wp_i18n_namespaceObject.sprintf)( 28406 // translators: %s: Currently selected font weight. 28407 (0,external_wp_i18n_namespaceObject.__)('Currently selected font weight: %s'), currentSelection.name); 28408 } 28409 if (!hasFontWeights) { 28410 return (0,external_wp_i18n_namespaceObject.sprintf)( 28411 // translators: %s: Currently selected font style. 28412 (0,external_wp_i18n_namespaceObject.__)('Currently selected font style: %s'), currentSelection.name); 28413 } 28414 return (0,external_wp_i18n_namespaceObject.sprintf)( 28415 // translators: %s: Currently selected font appearance. 28416 (0,external_wp_i18n_namespaceObject.__)('Currently selected font appearance: %s'), currentSelection.name); 28417 }; 28418 return hasStylesOrWeights && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, { 28419 ...otherProps, 28420 className: "components-font-appearance-control", 28421 __next40pxDefaultSize: __next40pxDefaultSize, 28422 label: label, 28423 describedBy: getDescribedBy(), 28424 options: selectOptions, 28425 value: currentSelection, 28426 onChange: ({ 28427 selectedItem 28428 }) => onChange(selectedItem.style) 28429 }); 28430 } 28431 28432 ;// ./node_modules/@wordpress/block-editor/build-module/components/line-height-control/utils.js 28433 const BASE_DEFAULT_VALUE = 1.5; 28434 const STEP = 0.01; 28435 /** 28436 * A spin factor of 10 allows the spin controls to increment/decrement by 0.1. 28437 * e.g. A line-height value of 1.55 will increment to 1.65. 28438 */ 28439 const SPIN_FACTOR = 10; 28440 /** 28441 * There are varying value types within LineHeightControl: 28442 * 28443 * {undefined} Initial value. No changes from the user. 28444 * {string} Input value. Value consumed/outputted by the input. Empty would be ''. 28445 * {number} Block attribute type. Input value needs to be converted for attribute setting. 28446 * 28447 * Note: If the value is undefined, the input requires it to be an empty string ('') 28448 * in order to be considered "controlled" by props (rather than internal state). 28449 */ 28450 const RESET_VALUE = ''; 28451 28452 /** 28453 * Determines if the lineHeight attribute has been properly defined. 28454 * 28455 * @param {any} lineHeight The value to check. 28456 * 28457 * @return {boolean} Whether the lineHeight attribute is valid. 28458 */ 28459 function isLineHeightDefined(lineHeight) { 28460 return lineHeight !== undefined && lineHeight !== RESET_VALUE; 28461 } 28462 28463 ;// ./node_modules/@wordpress/block-editor/build-module/components/line-height-control/index.js 28464 /** 28465 * WordPress dependencies 28466 */ 28467 28468 28469 28470 /** 28471 * Internal dependencies 28472 */ 28473 28474 28475 const line_height_control_LineHeightControl = ({ 28476 /** Start opting into the larger default height that will become the default size in a future version. */ 28477 __next40pxDefaultSize = false, 28478 value: lineHeight, 28479 onChange, 28480 __unstableInputWidth = '60px', 28481 ...otherProps 28482 }) => { 28483 const isDefined = isLineHeightDefined(lineHeight); 28484 const adjustNextValue = (nextValue, wasTypedOrPasted) => { 28485 // Set the next value without modification if lineHeight has been defined. 28486 if (isDefined) { 28487 return nextValue; 28488 } 28489 28490 /** 28491 * The following logic handles the initial spin up/down action 28492 * (from an undefined value state) so that the next values are better suited for 28493 * line-height rendering. For example, the first spin up should immediately 28494 * go to 1.6, rather than the normally expected 0.1. 28495 * 28496 * Spin up/down actions can be triggered by keydowns of the up/down arrow keys, 28497 * dragging the input or by clicking the spin buttons. 28498 */ 28499 const spin = STEP * SPIN_FACTOR; 28500 switch (`$nextValue}`) { 28501 case `$spin}`: 28502 // Increment by spin value. 28503 return BASE_DEFAULT_VALUE + spin; 28504 case '0': 28505 { 28506 // This means the user explicitly input '0', rather than using the 28507 // spin down action from an undefined value state. 28508 if (wasTypedOrPasted) { 28509 return nextValue; 28510 } 28511 // Decrement by spin value. 28512 return BASE_DEFAULT_VALUE - spin; 28513 } 28514 case '': 28515 return BASE_DEFAULT_VALUE; 28516 default: 28517 return nextValue; 28518 } 28519 }; 28520 const stateReducer = (state, action) => { 28521 // Be careful when changing this — cross-browser behavior of the 28522 // `inputType` field in `input` events are inconsistent. 28523 // For example, Firefox emits an input event with inputType="insertReplacementText" 28524 // on spin button clicks, while other browsers do not even emit an input event. 28525 const wasTypedOrPasted = ['insertText', 'insertFromPaste'].includes(action.payload.event.nativeEvent?.inputType); 28526 const value = adjustNextValue(state.value, wasTypedOrPasted); 28527 return { 28528 ...state, 28529 value 28530 }; 28531 }; 28532 const value = isDefined ? lineHeight : RESET_VALUE; 28533 const handleOnChange = (nextValue, { 28534 event 28535 }) => { 28536 if (nextValue === '') { 28537 onChange(); 28538 return; 28539 } 28540 if (event.type === 'click') { 28541 onChange(adjustNextValue(`$nextValue}`, false)); 28542 return; 28543 } 28544 onChange(`$nextValue}`); 28545 }; 28546 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 28547 className: "block-editor-line-height-control", 28548 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, { 28549 ...otherProps, 28550 __next40pxDefaultSize: __next40pxDefaultSize, 28551 __unstableInputWidth: __unstableInputWidth, 28552 __unstableStateReducer: stateReducer, 28553 onChange: handleOnChange, 28554 label: (0,external_wp_i18n_namespaceObject.__)('Line height'), 28555 placeholder: BASE_DEFAULT_VALUE, 28556 step: STEP, 28557 spinFactor: SPIN_FACTOR, 28558 value: value, 28559 min: 0, 28560 spinControls: "custom" 28561 }) 28562 }); 28563 }; 28564 28565 /** 28566 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/line-height-control/README.md 28567 */ 28568 /* harmony default export */ const line_height_control = (line_height_control_LineHeightControl); 28569 28570 ;// ./node_modules/@wordpress/block-editor/build-module/components/letter-spacing-control/index.js 28571 /** 28572 * WordPress dependencies 28573 */ 28574 28575 28576 28577 /** 28578 * Internal dependencies 28579 */ 28580 28581 28582 /** 28583 * Control for letter-spacing. 28584 * 28585 * @param {Object} props Component props. 28586 * @param {boolean} props.__next40pxDefaultSize Start opting into the larger default height that will become the default size in a future version. 28587 * @param {string} props.value Currently selected letter-spacing. 28588 * @param {Function} props.onChange Handles change in letter-spacing selection. 28589 * @param {string|number|undefined} props.__unstableInputWidth Input width to pass through to inner UnitControl. Should be a valid CSS value. 28590 * 28591 * @return {Element} Letter-spacing control. 28592 */ 28593 28594 function LetterSpacingControl({ 28595 __next40pxDefaultSize = false, 28596 value, 28597 onChange, 28598 __unstableInputWidth = '60px', 28599 ...otherProps 28600 }) { 28601 const [availableUnits] = use_settings_useSettings('spacing.units'); 28602 const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({ 28603 availableUnits: availableUnits || ['px', 'em', 'rem'], 28604 defaultValues: { 28605 px: 2, 28606 em: 0.2, 28607 rem: 0.2 28608 } 28609 }); 28610 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 28611 __next40pxDefaultSize: __next40pxDefaultSize, 28612 ...otherProps, 28613 label: (0,external_wp_i18n_namespaceObject.__)('Letter spacing'), 28614 value: value, 28615 __unstableInputWidth: __unstableInputWidth, 28616 units: units, 28617 onChange: onChange 28618 }); 28619 } 28620 28621 ;// ./node_modules/@wordpress/icons/build-module/library/align-left.js 28622 /** 28623 * WordPress dependencies 28624 */ 28625 28626 28627 const alignLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 28628 xmlns: "http://www.w3.org/2000/svg", 28629 viewBox: "0 0 24 24", 28630 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 28631 d: "M13 5.5H4V4h9v1.5Zm7 7H4V11h16v1.5Zm-7 7H4V18h9v1.5Z" 28632 }) 28633 }); 28634 /* harmony default export */ const align_left = (alignLeft); 28635 28636 ;// ./node_modules/@wordpress/icons/build-module/library/align-center.js 28637 /** 28638 * WordPress dependencies 28639 */ 28640 28641 28642 const align_center_alignCenter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 28643 xmlns: "http://www.w3.org/2000/svg", 28644 viewBox: "0 0 24 24", 28645 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 28646 d: "M7.5 5.5h9V4h-9v1.5Zm-3.5 7h16V11H4v1.5Zm3.5 7h9V18h-9v1.5Z" 28647 }) 28648 }); 28649 /* harmony default export */ const align_center = (align_center_alignCenter); 28650 28651 ;// ./node_modules/@wordpress/icons/build-module/library/align-right.js 28652 /** 28653 * WordPress dependencies 28654 */ 28655 28656 28657 const alignRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 28658 xmlns: "http://www.w3.org/2000/svg", 28659 viewBox: "0 0 24 24", 28660 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 28661 d: "M11.111 5.5H20V4h-8.889v1.5ZM4 12.5h16V11H4v1.5Zm7.111 7H20V18h-8.889v1.5Z" 28662 }) 28663 }); 28664 /* harmony default export */ const align_right = (alignRight); 28665 28666 ;// ./node_modules/@wordpress/icons/build-module/library/align-justify.js 28667 /** 28668 * WordPress dependencies 28669 */ 28670 28671 28672 const alignJustify = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 28673 xmlns: "http://www.w3.org/2000/svg", 28674 viewBox: "0 0 24 24", 28675 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 28676 d: "M4 12.8h16v-1.5H4v1.5zm0 7h12.4v-1.5H4v1.5zM4 4.3v1.5h16V4.3H4z" 28677 }) 28678 }); 28679 /* harmony default export */ const align_justify = (alignJustify); 28680 28681 ;// ./node_modules/@wordpress/block-editor/build-module/components/text-alignment-control/index.js 28682 /** 28683 * External dependencies 28684 */ 28685 28686 28687 /** 28688 * WordPress dependencies 28689 */ 28690 28691 28692 28693 28694 28695 const TEXT_ALIGNMENT_OPTIONS = [{ 28696 label: (0,external_wp_i18n_namespaceObject.__)('Align text left'), 28697 value: 'left', 28698 icon: align_left 28699 }, { 28700 label: (0,external_wp_i18n_namespaceObject.__)('Align text center'), 28701 value: 'center', 28702 icon: align_center 28703 }, { 28704 label: (0,external_wp_i18n_namespaceObject.__)('Align text right'), 28705 value: 'right', 28706 icon: align_right 28707 }, { 28708 label: (0,external_wp_i18n_namespaceObject.__)('Justify text'), 28709 value: 'justify', 28710 icon: align_justify 28711 }]; 28712 const DEFAULT_OPTIONS = ['left', 'center', 'right']; 28713 28714 /** 28715 * Control to facilitate text alignment selections. 28716 * 28717 * @param {Object} props Component props. 28718 * @param {string} props.className Class name to add to the control. 28719 * @param {string} props.value Currently selected text alignment. 28720 * @param {Function} props.onChange Handles change in text alignment selection. 28721 * @param {string[]} props.options Array of text alignment options to display. 28722 * 28723 * @return {Element} Text alignment control. 28724 */ 28725 function TextAlignmentControl({ 28726 className, 28727 value, 28728 onChange, 28729 options = DEFAULT_OPTIONS 28730 }) { 28731 const validOptions = (0,external_wp_element_namespaceObject.useMemo)(() => TEXT_ALIGNMENT_OPTIONS.filter(option => options.includes(option.value)), [options]); 28732 if (!validOptions.length) { 28733 return null; 28734 } 28735 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 28736 isDeselectable: true, 28737 __nextHasNoMarginBottom: true, 28738 __next40pxDefaultSize: true, 28739 label: (0,external_wp_i18n_namespaceObject.__)('Text alignment'), 28740 className: dist_clsx('block-editor-text-alignment-control', className), 28741 value: value, 28742 onChange: newValue => { 28743 onChange(newValue === value ? undefined : newValue); 28744 }, 28745 children: validOptions.map(option => { 28746 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, { 28747 value: option.value, 28748 icon: option.icon, 28749 label: option.label 28750 }, option.value); 28751 }) 28752 }); 28753 } 28754 28755 ;// ./node_modules/@wordpress/icons/build-module/library/reset.js 28756 /** 28757 * WordPress dependencies 28758 */ 28759 28760 28761 const reset_reset = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 28762 xmlns: "http://www.w3.org/2000/svg", 28763 viewBox: "0 0 24 24", 28764 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 28765 d: "M7 11.5h10V13H7z" 28766 }) 28767 }); 28768 /* harmony default export */ const library_reset = (reset_reset); 28769 28770 ;// ./node_modules/@wordpress/icons/build-module/library/format-uppercase.js 28771 /** 28772 * WordPress dependencies 28773 */ 28774 28775 28776 const formatUppercase = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 28777 xmlns: "http://www.w3.org/2000/svg", 28778 viewBox: "0 0 24 24", 28779 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 28780 d: "M6.1 6.8L2.1 18h1.6l1.1-3h4.3l1.1 3h1.6l-4-11.2H6.1zm-.8 6.8L7 8.9l1.7 4.7H5.3zm15.1-.7c-.4-.5-.9-.8-1.6-1 .4-.2.7-.5.8-.9.2-.4.3-.9.3-1.4 0-.9-.3-1.6-.8-2-.6-.5-1.3-.7-2.4-.7h-3.5V18h4.2c1.1 0 2-.3 2.6-.8.6-.6 1-1.4 1-2.4-.1-.8-.3-1.4-.6-1.9zm-5.7-4.7h1.8c.6 0 1.1.1 1.4.4.3.2.5.7.5 1.3 0 .6-.2 1.1-.5 1.3-.3.2-.8.4-1.4.4h-1.8V8.2zm4 8c-.4.3-.9.5-1.5.5h-2.6v-3.8h2.6c1.4 0 2 .6 2 1.9.1.6-.1 1-.5 1.4z" 28781 }) 28782 }); 28783 /* harmony default export */ const format_uppercase = (formatUppercase); 28784 28785 ;// ./node_modules/@wordpress/icons/build-module/library/format-lowercase.js 28786 /** 28787 * WordPress dependencies 28788 */ 28789 28790 28791 const formatLowercase = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 28792 xmlns: "http://www.w3.org/2000/svg", 28793 viewBox: "0 0 24 24", 28794 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 28795 d: "M11 16.8c-.1-.1-.2-.3-.3-.5v-2.6c0-.9-.1-1.7-.3-2.2-.2-.5-.5-.9-.9-1.2-.4-.2-.9-.3-1.6-.3-.5 0-1 .1-1.5.2s-.9.3-1.2.6l.2 1.2c.4-.3.7-.4 1.1-.5.3-.1.7-.2 1-.2.6 0 1 .1 1.3.4.3.2.4.7.4 1.4-1.2 0-2.3.2-3.3.7s-1.4 1.1-1.4 2.1c0 .7.2 1.2.7 1.6.4.4 1 .6 1.8.6.9 0 1.7-.4 2.4-1.2.1.3.2.5.4.7.1.2.3.3.6.4.3.1.6.1 1.1.1h.1l.2-1.2h-.1c-.4.1-.6 0-.7-.1zM9.2 16c-.2.3-.5.6-.9.8-.3.1-.7.2-1.1.2-.4 0-.7-.1-.9-.3-.2-.2-.3-.5-.3-.9 0-.6.2-1 .7-1.3.5-.3 1.3-.4 2.5-.5v2zm10.6-3.9c-.3-.6-.7-1.1-1.2-1.5-.6-.4-1.2-.6-1.9-.6-.5 0-.9.1-1.4.3-.4.2-.8.5-1.1.8V6h-1.4v12h1.3l.2-1c.2.4.6.6 1 .8.4.2.9.3 1.4.3.7 0 1.2-.2 1.8-.5.5-.4 1-.9 1.3-1.5.3-.6.5-1.3.5-2.1-.1-.6-.2-1.3-.5-1.9zm-1.7 4c-.4.5-.9.8-1.6.8s-1.2-.2-1.7-.7c-.4-.5-.7-1.2-.7-2.1 0-.9.2-1.6.7-2.1.4-.5 1-.7 1.7-.7s1.2.3 1.6.8c.4.5.6 1.2.6 2s-.2 1.4-.6 2z" 28796 }) 28797 }); 28798 /* harmony default export */ const format_lowercase = (formatLowercase); 28799 28800 ;// ./node_modules/@wordpress/icons/build-module/library/format-capitalize.js 28801 /** 28802 * WordPress dependencies 28803 */ 28804 28805 28806 const formatCapitalize = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 28807 xmlns: "http://www.w3.org/2000/svg", 28808 viewBox: "0 0 24 24", 28809 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 28810 d: "M7.1 6.8L3.1 18h1.6l1.1-3h4.3l1.1 3h1.6l-4-11.2H7.1zm-.8 6.8L8 8.9l1.7 4.7H6.3zm14.5-1.5c-.3-.6-.7-1.1-1.2-1.5-.6-.4-1.2-.6-1.9-.6-.5 0-.9.1-1.4.3-.4.2-.8.5-1.1.8V6h-1.4v12h1.3l.2-1c.2.4.6.6 1 .8.4.2.9.3 1.4.3.7 0 1.2-.2 1.8-.5.5-.4 1-.9 1.3-1.5.3-.6.5-1.3.5-2.1-.1-.6-.2-1.3-.5-1.9zm-1.7 4c-.4.5-.9.8-1.6.8s-1.2-.2-1.7-.7c-.4-.5-.7-1.2-.7-2.1 0-.9.2-1.6.7-2.1.4-.5 1-.7 1.7-.7s1.2.3 1.6.8c.4.5.6 1.2.6 2 .1.8-.2 1.4-.6 2z" 28811 }) 28812 }); 28813 /* harmony default export */ const format_capitalize = (formatCapitalize); 28814 28815 ;// ./node_modules/@wordpress/block-editor/build-module/components/text-transform-control/index.js 28816 /** 28817 * External dependencies 28818 */ 28819 28820 28821 /** 28822 * WordPress dependencies 28823 */ 28824 28825 28826 28827 28828 const TEXT_TRANSFORMS = [{ 28829 label: (0,external_wp_i18n_namespaceObject.__)('None'), 28830 value: 'none', 28831 icon: library_reset 28832 }, { 28833 label: (0,external_wp_i18n_namespaceObject.__)('Uppercase'), 28834 value: 'uppercase', 28835 icon: format_uppercase 28836 }, { 28837 label: (0,external_wp_i18n_namespaceObject.__)('Lowercase'), 28838 value: 'lowercase', 28839 icon: format_lowercase 28840 }, { 28841 label: (0,external_wp_i18n_namespaceObject.__)('Capitalize'), 28842 value: 'capitalize', 28843 icon: format_capitalize 28844 }]; 28845 28846 /** 28847 * Control to facilitate text transform selections. 28848 * 28849 * @param {Object} props Component props. 28850 * @param {string} props.className Class name to add to the control. 28851 * @param {string} props.value Currently selected text transform. 28852 * @param {Function} props.onChange Handles change in text transform selection. 28853 * 28854 * @return {Element} Text transform control. 28855 */ 28856 function TextTransformControl({ 28857 className, 28858 value, 28859 onChange 28860 }) { 28861 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 28862 isDeselectable: true, 28863 __nextHasNoMarginBottom: true, 28864 __next40pxDefaultSize: true, 28865 label: (0,external_wp_i18n_namespaceObject.__)('Letter case'), 28866 className: dist_clsx('block-editor-text-transform-control', className), 28867 value: value, 28868 onChange: newValue => { 28869 onChange(newValue === value ? undefined : newValue); 28870 }, 28871 children: TEXT_TRANSFORMS.map(option => { 28872 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, { 28873 value: option.value, 28874 icon: option.icon, 28875 label: option.label 28876 }, option.value); 28877 }) 28878 }); 28879 } 28880 28881 ;// ./node_modules/@wordpress/icons/build-module/library/format-underline.js 28882 /** 28883 * WordPress dependencies 28884 */ 28885 28886 28887 const formatUnderline = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 28888 xmlns: "http://www.w3.org/2000/svg", 28889 viewBox: "0 0 24 24", 28890 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 28891 d: "M7 18v1h10v-1H7zm5-2c1.5 0 2.6-.4 3.4-1.2.8-.8 1.1-2 1.1-3.5V5H15v5.8c0 1.2-.2 2.1-.6 2.8-.4.7-1.2 1-2.4 1s-2-.3-2.4-1c-.4-.7-.6-1.6-.6-2.8V5H7.5v6.2c0 1.5.4 2.7 1.1 3.5.8.9 1.9 1.3 3.4 1.3z" 28892 }) 28893 }); 28894 /* harmony default export */ const format_underline = (formatUnderline); 28895 28896 ;// ./node_modules/@wordpress/icons/build-module/library/format-strikethrough.js 28897 /** 28898 * WordPress dependencies 28899 */ 28900 28901 28902 const formatStrikethrough = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 28903 xmlns: "http://www.w3.org/2000/svg", 28904 viewBox: "0 0 24 24", 28905 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 28906 d: "M9.1 9v-.5c0-.6.2-1.1.7-1.4.5-.3 1.2-.5 2-.5.7 0 1.4.1 2.1.3.7.2 1.4.5 2.1.9l.2-1.9c-.6-.3-1.2-.5-1.9-.7-.8-.1-1.6-.2-2.4-.2-1.5 0-2.7.3-3.6 1-.8.7-1.2 1.5-1.2 2.6V9h2zM20 12H4v1h8.3c.3.1.6.2.8.3.5.2.9.5 1.1.8.3.3.4.7.4 1.2 0 .7-.2 1.1-.8 1.5-.5.3-1.2.5-2.1.5-.8 0-1.6-.1-2.4-.3-.8-.2-1.5-.5-2.2-.8L7 18.1c.5.2 1.2.4 2 .6.8.2 1.6.3 2.4.3 1.7 0 3-.3 3.9-1 .9-.7 1.3-1.6 1.3-2.8 0-.9-.2-1.7-.7-2.2H20v-1z" 28907 }) 28908 }); 28909 /* harmony default export */ const format_strikethrough = (formatStrikethrough); 28910 28911 ;// ./node_modules/@wordpress/block-editor/build-module/components/text-decoration-control/index.js 28912 /** 28913 * External dependencies 28914 */ 28915 28916 28917 /** 28918 * WordPress dependencies 28919 */ 28920 28921 28922 28923 28924 const TEXT_DECORATIONS = [{ 28925 label: (0,external_wp_i18n_namespaceObject.__)('None'), 28926 value: 'none', 28927 icon: library_reset 28928 }, { 28929 label: (0,external_wp_i18n_namespaceObject.__)('Underline'), 28930 value: 'underline', 28931 icon: format_underline 28932 }, { 28933 label: (0,external_wp_i18n_namespaceObject.__)('Strikethrough'), 28934 value: 'line-through', 28935 icon: format_strikethrough 28936 }]; 28937 28938 /** 28939 * Control to facilitate text decoration selections. 28940 * 28941 * @param {Object} props Component props. 28942 * @param {string} props.value Currently selected text decoration. 28943 * @param {Function} props.onChange Handles change in text decoration selection. 28944 * @param {string} props.className Additional class name to apply. 28945 * 28946 * @return {Element} Text decoration control. 28947 */ 28948 function TextDecorationControl({ 28949 value, 28950 onChange, 28951 className 28952 }) { 28953 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 28954 isDeselectable: true, 28955 __nextHasNoMarginBottom: true, 28956 __next40pxDefaultSize: true, 28957 label: (0,external_wp_i18n_namespaceObject.__)('Decoration'), 28958 className: dist_clsx('block-editor-text-decoration-control', className), 28959 value: value, 28960 onChange: newValue => { 28961 onChange(newValue === value ? undefined : newValue); 28962 }, 28963 children: TEXT_DECORATIONS.map(option => { 28964 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, { 28965 value: option.value, 28966 icon: option.icon, 28967 label: option.label 28968 }, option.value); 28969 }) 28970 }); 28971 } 28972 28973 ;// ./node_modules/@wordpress/icons/build-module/library/text-horizontal.js 28974 /** 28975 * WordPress dependencies 28976 */ 28977 28978 28979 const textHorizontal = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 28980 xmlns: "http://www.w3.org/2000/svg", 28981 viewBox: "0 0 24 24", 28982 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 28983 d: "M8.2 14.4h3.9L13 17h1.7L11 6.5H9.3L5.6 17h1.7l.9-2.6zm2-5.5 1.4 4H8.8l1.4-4zm7.4 7.5-1.3.8.8 1.4H5.5V20h14.3l-2.2-3.6z" 28984 }) 28985 }); 28986 /* harmony default export */ const text_horizontal = (textHorizontal); 28987 28988 ;// ./node_modules/@wordpress/icons/build-module/library/text-vertical.js 28989 /** 28990 * WordPress dependencies 28991 */ 28992 28993 28994 const textVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 28995 xmlns: "http://www.w3.org/2000/svg", 28996 viewBox: "0 0 24 24", 28997 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 28998 d: "M7 5.6v1.7l2.6.9v3.9L7 13v1.7L17.5 11V9.3L7 5.6zm4.2 6V8.8l4 1.4-4 1.4zm-5.7 5.6V5.5H4v14.3l3.6-2.2-.8-1.3-1.3.9z" 28999 }) 29000 }); 29001 /* harmony default export */ const text_vertical = (textVertical); 29002 29003 ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-mode-control/index.js 29004 /** 29005 * External dependencies 29006 */ 29007 29008 29009 /** 29010 * WordPress dependencies 29011 */ 29012 29013 29014 29015 29016 const WRITING_MODES = [{ 29017 label: (0,external_wp_i18n_namespaceObject.__)('Horizontal'), 29018 value: 'horizontal-tb', 29019 icon: text_horizontal 29020 }, { 29021 label: (0,external_wp_i18n_namespaceObject.__)('Vertical'), 29022 value: (0,external_wp_i18n_namespaceObject.isRTL)() ? 'vertical-lr' : 'vertical-rl', 29023 icon: text_vertical 29024 }]; 29025 29026 /** 29027 * Control to facilitate writing mode selections. 29028 * 29029 * @param {Object} props Component props. 29030 * @param {string} props.className Class name to add to the control. 29031 * @param {string} props.value Currently selected writing mode. 29032 * @param {Function} props.onChange Handles change in the writing mode selection. 29033 * 29034 * @return {Element} Writing Mode control. 29035 */ 29036 function WritingModeControl({ 29037 className, 29038 value, 29039 onChange 29040 }) { 29041 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 29042 isDeselectable: true, 29043 __nextHasNoMarginBottom: true, 29044 __next40pxDefaultSize: true, 29045 label: (0,external_wp_i18n_namespaceObject.__)('Orientation'), 29046 className: dist_clsx('block-editor-writing-mode-control', className), 29047 value: value, 29048 onChange: newValue => { 29049 onChange(newValue === value ? undefined : newValue); 29050 }, 29051 children: WRITING_MODES.map(option => { 29052 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, { 29053 value: option.value, 29054 icon: option.icon, 29055 label: option.label 29056 }, option.value); 29057 }) 29058 }); 29059 } 29060 29061 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/typography-panel.js 29062 /** 29063 * WordPress dependencies 29064 */ 29065 29066 29067 29068 29069 /** 29070 * Internal dependencies 29071 */ 29072 29073 29074 29075 29076 29077 29078 29079 29080 29081 29082 29083 29084 29085 const MIN_TEXT_COLUMNS = 1; 29086 const MAX_TEXT_COLUMNS = 6; 29087 function useHasTypographyPanel(settings) { 29088 const hasFontFamily = useHasFontFamilyControl(settings); 29089 const hasLineHeight = useHasLineHeightControl(settings); 29090 const hasFontAppearance = useHasAppearanceControl(settings); 29091 const hasLetterSpacing = useHasLetterSpacingControl(settings); 29092 const hasTextAlign = useHasTextAlignmentControl(settings); 29093 const hasTextTransform = useHasTextTransformControl(settings); 29094 const hasTextDecoration = useHasTextDecorationControl(settings); 29095 const hasWritingMode = useHasWritingModeControl(settings); 29096 const hasTextColumns = useHasTextColumnsControl(settings); 29097 const hasFontSize = useHasFontSizeControl(settings); 29098 return hasFontFamily || hasLineHeight || hasFontAppearance || hasLetterSpacing || hasTextAlign || hasTextTransform || hasFontSize || hasTextDecoration || hasWritingMode || hasTextColumns; 29099 } 29100 function useHasFontSizeControl(settings) { 29101 return settings?.typography?.defaultFontSizes !== false && settings?.typography?.fontSizes?.default?.length || settings?.typography?.fontSizes?.theme?.length || settings?.typography?.fontSizes?.custom?.length || settings?.typography?.customFontSize; 29102 } 29103 function useHasFontFamilyControl(settings) { 29104 return ['default', 'theme', 'custom'].some(key => settings?.typography?.fontFamilies?.[key]?.length); 29105 } 29106 function useHasLineHeightControl(settings) { 29107 return settings?.typography?.lineHeight; 29108 } 29109 function useHasAppearanceControl(settings) { 29110 return settings?.typography?.fontStyle || settings?.typography?.fontWeight; 29111 } 29112 function useAppearanceControlLabel(settings) { 29113 if (!settings?.typography?.fontStyle) { 29114 return (0,external_wp_i18n_namespaceObject.__)('Font weight'); 29115 } 29116 if (!settings?.typography?.fontWeight) { 29117 return (0,external_wp_i18n_namespaceObject.__)('Font style'); 29118 } 29119 return (0,external_wp_i18n_namespaceObject.__)('Appearance'); 29120 } 29121 function useHasLetterSpacingControl(settings) { 29122 return settings?.typography?.letterSpacing; 29123 } 29124 function useHasTextTransformControl(settings) { 29125 return settings?.typography?.textTransform; 29126 } 29127 function useHasTextAlignmentControl(settings) { 29128 return settings?.typography?.textAlign; 29129 } 29130 function useHasTextDecorationControl(settings) { 29131 return settings?.typography?.textDecoration; 29132 } 29133 function useHasWritingModeControl(settings) { 29134 return settings?.typography?.writingMode; 29135 } 29136 function useHasTextColumnsControl(settings) { 29137 return settings?.typography?.textColumns; 29138 } 29139 29140 /** 29141 * Concatenate all the font sizes into a single list for the font size picker. 29142 * 29143 * @param {Object} settings The global styles settings. 29144 * 29145 * @return {Array} The merged font sizes. 29146 */ 29147 function getMergedFontSizes(settings) { 29148 var _fontSizes$custom, _fontSizes$theme, _fontSizes$default; 29149 const fontSizes = settings?.typography?.fontSizes; 29150 const defaultFontSizesEnabled = !!settings?.typography?.defaultFontSizes; 29151 return [...((_fontSizes$custom = fontSizes?.custom) !== null && _fontSizes$custom !== void 0 ? _fontSizes$custom : []), ...((_fontSizes$theme = fontSizes?.theme) !== null && _fontSizes$theme !== void 0 ? _fontSizes$theme : []), ...(defaultFontSizesEnabled ? (_fontSizes$default = fontSizes?.default) !== null && _fontSizes$default !== void 0 ? _fontSizes$default : [] : [])]; 29152 } 29153 function TypographyToolsPanel({ 29154 resetAllFilter, 29155 onChange, 29156 value, 29157 panelId, 29158 children 29159 }) { 29160 const dropdownMenuProps = useToolsPanelDropdownMenuProps(); 29161 const resetAll = () => { 29162 const updatedValue = resetAllFilter(value); 29163 onChange(updatedValue); 29164 }; 29165 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, { 29166 label: (0,external_wp_i18n_namespaceObject.__)('Typography'), 29167 resetAll: resetAll, 29168 panelId: panelId, 29169 dropdownMenuProps: dropdownMenuProps, 29170 children: children 29171 }); 29172 } 29173 const typography_panel_DEFAULT_CONTROLS = { 29174 fontFamily: true, 29175 fontSize: true, 29176 fontAppearance: true, 29177 lineHeight: true, 29178 letterSpacing: true, 29179 textAlign: true, 29180 textTransform: true, 29181 textDecoration: true, 29182 writingMode: true, 29183 textColumns: true 29184 }; 29185 function TypographyPanel({ 29186 as: Wrapper = TypographyToolsPanel, 29187 value, 29188 onChange, 29189 inheritedValue = value, 29190 settings, 29191 panelId, 29192 defaultControls = typography_panel_DEFAULT_CONTROLS 29193 }) { 29194 const decodeValue = rawValue => getValueFromVariable({ 29195 settings 29196 }, '', rawValue); 29197 29198 // Font Family 29199 const hasFontFamilyEnabled = useHasFontFamilyControl(settings); 29200 const fontFamily = decodeValue(inheritedValue?.typography?.fontFamily); 29201 const { 29202 fontFamilies, 29203 fontFamilyFaces 29204 } = (0,external_wp_element_namespaceObject.useMemo)(() => { 29205 return getMergedFontFamiliesAndFontFamilyFaces(settings, fontFamily); 29206 }, [settings, fontFamily]); 29207 const setFontFamily = newValue => { 29208 const slug = fontFamilies?.find(({ 29209 fontFamily: f 29210 }) => f === newValue)?.slug; 29211 onChange(setImmutably(value, ['typography', 'fontFamily'], slug ? `var:preset|font-family|$slug}` : newValue || undefined)); 29212 }; 29213 const hasFontFamily = () => !!value?.typography?.fontFamily; 29214 const resetFontFamily = () => setFontFamily(undefined); 29215 29216 // Font Size 29217 const hasFontSizeEnabled = useHasFontSizeControl(settings); 29218 const disableCustomFontSizes = !settings?.typography?.customFontSize; 29219 const mergedFontSizes = getMergedFontSizes(settings); 29220 const fontSize = decodeValue(inheritedValue?.typography?.fontSize); 29221 const setFontSize = (newValue, metadata) => { 29222 const actualValue = !!metadata?.slug ? `var:preset|font-size|$metadata?.slug}` : newValue; 29223 onChange(setImmutably(value, ['typography', 'fontSize'], actualValue || undefined)); 29224 }; 29225 const hasFontSize = () => !!value?.typography?.fontSize; 29226 const resetFontSize = () => setFontSize(undefined); 29227 29228 // Appearance 29229 const hasAppearanceControl = useHasAppearanceControl(settings); 29230 const appearanceControlLabel = useAppearanceControlLabel(settings); 29231 const hasFontStyles = settings?.typography?.fontStyle; 29232 const hasFontWeights = settings?.typography?.fontWeight; 29233 const fontStyle = decodeValue(inheritedValue?.typography?.fontStyle); 29234 const fontWeight = decodeValue(inheritedValue?.typography?.fontWeight); 29235 const { 29236 nearestFontStyle, 29237 nearestFontWeight 29238 } = findNearestStyleAndWeight(fontFamilyFaces, fontStyle, fontWeight); 29239 const setFontAppearance = (0,external_wp_element_namespaceObject.useCallback)(({ 29240 fontStyle: newFontStyle, 29241 fontWeight: newFontWeight 29242 }) => { 29243 // Only update the font style and weight if they have changed. 29244 if (newFontStyle !== fontStyle || newFontWeight !== fontWeight) { 29245 onChange({ 29246 ...value, 29247 typography: { 29248 ...value?.typography, 29249 fontStyle: newFontStyle || undefined, 29250 fontWeight: newFontWeight || undefined 29251 } 29252 }); 29253 } 29254 }, [fontStyle, fontWeight, onChange, value]); 29255 const hasFontAppearance = () => !!value?.typography?.fontStyle || !!value?.typography?.fontWeight; 29256 const resetFontAppearance = (0,external_wp_element_namespaceObject.useCallback)(() => { 29257 setFontAppearance({}); 29258 }, [setFontAppearance]); 29259 29260 // Check if previous font style and weight values are available in the new font family. 29261 (0,external_wp_element_namespaceObject.useEffect)(() => { 29262 if (nearestFontStyle && nearestFontWeight) { 29263 setFontAppearance({ 29264 fontStyle: nearestFontStyle, 29265 fontWeight: nearestFontWeight 29266 }); 29267 } else { 29268 // Reset font appearance if there are no available styles or weights. 29269 resetFontAppearance(); 29270 } 29271 }, [nearestFontStyle, nearestFontWeight, resetFontAppearance, setFontAppearance]); 29272 29273 // Line Height 29274 const hasLineHeightEnabled = useHasLineHeightControl(settings); 29275 const lineHeight = decodeValue(inheritedValue?.typography?.lineHeight); 29276 const setLineHeight = newValue => { 29277 onChange(setImmutably(value, ['typography', 'lineHeight'], newValue || undefined)); 29278 }; 29279 const hasLineHeight = () => value?.typography?.lineHeight !== undefined; 29280 const resetLineHeight = () => setLineHeight(undefined); 29281 29282 // Letter Spacing 29283 const hasLetterSpacingControl = useHasLetterSpacingControl(settings); 29284 const letterSpacing = decodeValue(inheritedValue?.typography?.letterSpacing); 29285 const setLetterSpacing = newValue => { 29286 onChange(setImmutably(value, ['typography', 'letterSpacing'], newValue || undefined)); 29287 }; 29288 const hasLetterSpacing = () => !!value?.typography?.letterSpacing; 29289 const resetLetterSpacing = () => setLetterSpacing(undefined); 29290 29291 // Text Columns 29292 const hasTextColumnsControl = useHasTextColumnsControl(settings); 29293 const textColumns = decodeValue(inheritedValue?.typography?.textColumns); 29294 const setTextColumns = newValue => { 29295 onChange(setImmutably(value, ['typography', 'textColumns'], newValue || undefined)); 29296 }; 29297 const hasTextColumns = () => !!value?.typography?.textColumns; 29298 const resetTextColumns = () => setTextColumns(undefined); 29299 29300 // Text Transform 29301 const hasTextTransformControl = useHasTextTransformControl(settings); 29302 const textTransform = decodeValue(inheritedValue?.typography?.textTransform); 29303 const setTextTransform = newValue => { 29304 onChange(setImmutably(value, ['typography', 'textTransform'], newValue || undefined)); 29305 }; 29306 const hasTextTransform = () => !!value?.typography?.textTransform; 29307 const resetTextTransform = () => setTextTransform(undefined); 29308 29309 // Text Decoration 29310 const hasTextDecorationControl = useHasTextDecorationControl(settings); 29311 const textDecoration = decodeValue(inheritedValue?.typography?.textDecoration); 29312 const setTextDecoration = newValue => { 29313 onChange(setImmutably(value, ['typography', 'textDecoration'], newValue || undefined)); 29314 }; 29315 const hasTextDecoration = () => !!value?.typography?.textDecoration; 29316 const resetTextDecoration = () => setTextDecoration(undefined); 29317 29318 // Text Orientation 29319 const hasWritingModeControl = useHasWritingModeControl(settings); 29320 const writingMode = decodeValue(inheritedValue?.typography?.writingMode); 29321 const setWritingMode = newValue => { 29322 onChange(setImmutably(value, ['typography', 'writingMode'], newValue || undefined)); 29323 }; 29324 const hasWritingMode = () => !!value?.typography?.writingMode; 29325 const resetWritingMode = () => setWritingMode(undefined); 29326 29327 // Text Alignment 29328 const hasTextAlignmentControl = useHasTextAlignmentControl(settings); 29329 const textAlign = decodeValue(inheritedValue?.typography?.textAlign); 29330 const setTextAlign = newValue => { 29331 onChange(setImmutably(value, ['typography', 'textAlign'], newValue || undefined)); 29332 }; 29333 const hasTextAlign = () => !!value?.typography?.textAlign; 29334 const resetTextAlign = () => setTextAlign(undefined); 29335 const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue => { 29336 return { 29337 ...previousValue, 29338 typography: {} 29339 }; 29340 }, []); 29341 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, { 29342 resetAllFilter: resetAllFilter, 29343 value: value, 29344 onChange: onChange, 29345 panelId: panelId, 29346 children: [hasFontFamilyEnabled && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 29347 label: (0,external_wp_i18n_namespaceObject.__)('Font'), 29348 hasValue: hasFontFamily, 29349 onDeselect: resetFontFamily, 29350 isShownByDefault: defaultControls.fontFamily, 29351 panelId: panelId, 29352 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FontFamilyControl, { 29353 fontFamilies: fontFamilies, 29354 value: fontFamily, 29355 onChange: setFontFamily, 29356 size: "__unstable-large", 29357 __nextHasNoMarginBottom: true 29358 }) 29359 }), hasFontSizeEnabled && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 29360 label: (0,external_wp_i18n_namespaceObject.__)('Size'), 29361 hasValue: hasFontSize, 29362 onDeselect: resetFontSize, 29363 isShownByDefault: defaultControls.fontSize, 29364 panelId: panelId, 29365 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FontSizePicker, { 29366 value: fontSize, 29367 onChange: setFontSize, 29368 fontSizes: mergedFontSizes, 29369 disableCustomFontSizes: disableCustomFontSizes, 29370 withReset: false, 29371 withSlider: true, 29372 size: "__unstable-large" 29373 }) 29374 }), hasAppearanceControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 29375 className: "single-column", 29376 label: appearanceControlLabel, 29377 hasValue: hasFontAppearance, 29378 onDeselect: resetFontAppearance, 29379 isShownByDefault: defaultControls.fontAppearance, 29380 panelId: panelId, 29381 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FontAppearanceControl, { 29382 value: { 29383 fontStyle, 29384 fontWeight 29385 }, 29386 onChange: setFontAppearance, 29387 hasFontStyles: hasFontStyles, 29388 hasFontWeights: hasFontWeights, 29389 fontFamilyFaces: fontFamilyFaces, 29390 size: "__unstable-large" 29391 }) 29392 }), hasLineHeightEnabled && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 29393 className: "single-column", 29394 label: (0,external_wp_i18n_namespaceObject.__)('Line height'), 29395 hasValue: hasLineHeight, 29396 onDeselect: resetLineHeight, 29397 isShownByDefault: defaultControls.lineHeight, 29398 panelId: panelId, 29399 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(line_height_control, { 29400 __unstableInputWidth: "auto", 29401 value: lineHeight, 29402 onChange: setLineHeight, 29403 size: "__unstable-large" 29404 }) 29405 }), hasLetterSpacingControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 29406 className: "single-column", 29407 label: (0,external_wp_i18n_namespaceObject.__)('Letter spacing'), 29408 hasValue: hasLetterSpacing, 29409 onDeselect: resetLetterSpacing, 29410 isShownByDefault: defaultControls.letterSpacing, 29411 panelId: panelId, 29412 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LetterSpacingControl, { 29413 value: letterSpacing, 29414 onChange: setLetterSpacing, 29415 size: "__unstable-large", 29416 __unstableInputWidth: "auto" 29417 }) 29418 }), hasTextColumnsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 29419 className: "single-column", 29420 label: (0,external_wp_i18n_namespaceObject.__)('Columns'), 29421 hasValue: hasTextColumns, 29422 onDeselect: resetTextColumns, 29423 isShownByDefault: defaultControls.textColumns, 29424 panelId: panelId, 29425 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, { 29426 label: (0,external_wp_i18n_namespaceObject.__)('Columns'), 29427 max: MAX_TEXT_COLUMNS, 29428 min: MIN_TEXT_COLUMNS, 29429 onChange: setTextColumns, 29430 size: "__unstable-large", 29431 spinControls: "custom", 29432 value: textColumns, 29433 initialPosition: 1 29434 }) 29435 }), hasTextDecorationControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 29436 className: "single-column", 29437 label: (0,external_wp_i18n_namespaceObject.__)('Decoration'), 29438 hasValue: hasTextDecoration, 29439 onDeselect: resetTextDecoration, 29440 isShownByDefault: defaultControls.textDecoration, 29441 panelId: panelId, 29442 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TextDecorationControl, { 29443 value: textDecoration, 29444 onChange: setTextDecoration, 29445 size: "__unstable-large", 29446 __unstableInputWidth: "auto" 29447 }) 29448 }), hasWritingModeControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 29449 className: "single-column", 29450 label: (0,external_wp_i18n_namespaceObject.__)('Orientation'), 29451 hasValue: hasWritingMode, 29452 onDeselect: resetWritingMode, 29453 isShownByDefault: defaultControls.writingMode, 29454 panelId: panelId, 29455 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WritingModeControl, { 29456 value: writingMode, 29457 onChange: setWritingMode, 29458 size: "__unstable-large", 29459 __nextHasNoMarginBottom: true 29460 }) 29461 }), hasTextTransformControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 29462 label: (0,external_wp_i18n_namespaceObject.__)('Letter case'), 29463 hasValue: hasTextTransform, 29464 onDeselect: resetTextTransform, 29465 isShownByDefault: defaultControls.textTransform, 29466 panelId: panelId, 29467 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TextTransformControl, { 29468 value: textTransform, 29469 onChange: setTextTransform, 29470 showNone: true, 29471 isBlock: true, 29472 size: "__unstable-large", 29473 __nextHasNoMarginBottom: true 29474 }) 29475 }), hasTextAlignmentControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 29476 label: (0,external_wp_i18n_namespaceObject.__)('Text alignment'), 29477 hasValue: hasTextAlign, 29478 onDeselect: resetTextAlign, 29479 isShownByDefault: defaultControls.textAlign, 29480 panelId: panelId, 29481 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TextAlignmentControl, { 29482 value: textAlign, 29483 onChange: setTextAlign, 29484 size: "__unstable-large", 29485 __nextHasNoMarginBottom: true 29486 }) 29487 })] 29488 }); 29489 } 29490 29491 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/line-height.js 29492 /** 29493 * WordPress dependencies 29494 */ 29495 29496 29497 /** 29498 * Internal dependencies 29499 */ 29500 29501 29502 29503 29504 const LINE_HEIGHT_SUPPORT_KEY = 'typography.lineHeight'; 29505 29506 /** 29507 * Inspector control panel containing the line height related configuration 29508 * 29509 * @param {Object} props 29510 * 29511 * @return {Element} Line height edit element. 29512 */ 29513 function LineHeightEdit(props) { 29514 const { 29515 attributes: { 29516 style 29517 }, 29518 setAttributes 29519 } = props; 29520 const onChange = newLineHeightValue => { 29521 const newStyle = { 29522 ...style, 29523 typography: { 29524 ...style?.typography, 29525 lineHeight: newLineHeightValue 29526 } 29527 }; 29528 setAttributes({ 29529 style: cleanEmptyObject(newStyle) 29530 }); 29531 }; 29532 return /*#__PURE__*/_jsx(LineHeightControl, { 29533 __unstableInputWidth: "100%", 29534 value: style?.typography?.lineHeight, 29535 onChange: onChange, 29536 size: "__unstable-large" 29537 }); 29538 } 29539 29540 /** 29541 * Custom hook that checks if line-height settings have been disabled. 29542 * 29543 * @param {string} name The name of the block. 29544 * @return {boolean} Whether setting is disabled. 29545 */ 29546 function useIsLineHeightDisabled({ 29547 name: blockName 29548 } = {}) { 29549 const [isEnabled] = useSettings('typography.lineHeight'); 29550 return !isEnabled || !hasBlockSupport(blockName, LINE_HEIGHT_SUPPORT_KEY); 29551 } 29552 29553 ;// external ["wp","tokenList"] 29554 const external_wp_tokenList_namespaceObject = window["wp"]["tokenList"]; 29555 var external_wp_tokenList_default = /*#__PURE__*/__webpack_require__.n(external_wp_tokenList_namespaceObject); 29556 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/font-family.js 29557 /** 29558 * WordPress dependencies 29559 */ 29560 29561 29562 29563 29564 29565 /** 29566 * Internal dependencies 29567 */ 29568 29569 29570 29571 const FONT_FAMILY_SUPPORT_KEY = 'typography.__experimentalFontFamily'; 29572 const { 29573 kebabCase: font_family_kebabCase 29574 } = unlock(external_wp_components_namespaceObject.privateApis); 29575 29576 /** 29577 * Filters registered block settings, extending attributes to include 29578 * the `fontFamily` attribute. 29579 * 29580 * @param {Object} settings Original block settings 29581 * @return {Object} Filtered block settings 29582 */ 29583 function font_family_addAttributes(settings) { 29584 if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, FONT_FAMILY_SUPPORT_KEY)) { 29585 return settings; 29586 } 29587 29588 // Allow blocks to specify a default value if needed. 29589 if (!settings.attributes.fontFamily) { 29590 Object.assign(settings.attributes, { 29591 fontFamily: { 29592 type: 'string' 29593 } 29594 }); 29595 } 29596 return settings; 29597 } 29598 29599 /** 29600 * Override props assigned to save component to inject font family. 29601 * 29602 * @param {Object} props Additional props applied to save element 29603 * @param {Object} blockType Block type 29604 * @param {Object} attributes Block attributes 29605 * @return {Object} Filtered props applied to save element 29606 */ 29607 function font_family_addSaveProps(props, blockType, attributes) { 29608 if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, FONT_FAMILY_SUPPORT_KEY)) { 29609 return props; 29610 } 29611 if (shouldSkipSerialization(blockType, TYPOGRAPHY_SUPPORT_KEY, 'fontFamily')) { 29612 return props; 29613 } 29614 if (!attributes?.fontFamily) { 29615 return props; 29616 } 29617 29618 // Use TokenList to dedupe classes. 29619 const classes = new (external_wp_tokenList_default())(props.className); 29620 classes.add(`has-$font_family_kebabCase(attributes?.fontFamily)}-font-family`); 29621 const newClassName = classes.value; 29622 props.className = newClassName ? newClassName : undefined; 29623 return props; 29624 } 29625 function font_family_useBlockProps({ 29626 name, 29627 fontFamily 29628 }) { 29629 return font_family_addSaveProps({}, name, { 29630 fontFamily 29631 }); 29632 } 29633 /* harmony default export */ const font_family = ({ 29634 useBlockProps: font_family_useBlockProps, 29635 addSaveProps: font_family_addSaveProps, 29636 attributeKeys: ['fontFamily'], 29637 hasSupport(name) { 29638 return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, FONT_FAMILY_SUPPORT_KEY); 29639 } 29640 }); 29641 29642 /** 29643 * Resets the font family block support attribute. This can be used when 29644 * disabling the font family support controls for a block via a progressive 29645 * discovery panel. 29646 * 29647 * @param {Object} props Block props. 29648 * @param {Object} props.setAttributes Function to set block's attributes. 29649 */ 29650 function resetFontFamily({ 29651 setAttributes 29652 }) { 29653 setAttributes({ 29654 fontFamily: undefined 29655 }); 29656 } 29657 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/fontFamily/addAttribute', font_family_addAttributes); 29658 29659 ;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/utils.js 29660 /** 29661 * WordPress dependencies 29662 */ 29663 29664 29665 /** 29666 * Internal dependencies 29667 */ 29668 29669 const { 29670 kebabCase: utils_kebabCase 29671 } = unlock(external_wp_components_namespaceObject.privateApis); 29672 29673 /** 29674 * Returns the font size object based on an array of named font sizes and the namedFontSize and customFontSize values. 29675 * If namedFontSize is undefined or not found in fontSizes an object with just the size value based on customFontSize is returned. 29676 * 29677 * @param {Array} fontSizes Array of font size objects containing at least the "name" and "size" values as properties. 29678 * @param {?string} fontSizeAttribute Content of the font size attribute (slug). 29679 * @param {?number} customFontSizeAttribute Contents of the custom font size attribute (value). 29680 * 29681 * @return {?Object} If fontSizeAttribute is set and an equal slug is found in fontSizes it returns the font size object for that slug. 29682 * Otherwise, an object with just the size value based on customFontSize is returned. 29683 */ 29684 const utils_getFontSize = (fontSizes, fontSizeAttribute, customFontSizeAttribute) => { 29685 if (fontSizeAttribute) { 29686 const fontSizeObject = fontSizes?.find(({ 29687 slug 29688 }) => slug === fontSizeAttribute); 29689 if (fontSizeObject) { 29690 return fontSizeObject; 29691 } 29692 } 29693 return { 29694 size: customFontSizeAttribute 29695 }; 29696 }; 29697 29698 /** 29699 * Returns the corresponding font size object for a given value. 29700 * 29701 * @param {Array} fontSizes Array of font size objects. 29702 * @param {number} value Font size value. 29703 * 29704 * @return {Object} Font size object. 29705 */ 29706 function utils_getFontSizeObjectByValue(fontSizes, value) { 29707 const fontSizeObject = fontSizes?.find(({ 29708 size 29709 }) => size === value); 29710 if (fontSizeObject) { 29711 return fontSizeObject; 29712 } 29713 return { 29714 size: value 29715 }; 29716 } 29717 29718 /** 29719 * Returns a class based on fontSizeName. 29720 * 29721 * @param {string} fontSizeSlug Slug of the fontSize. 29722 * 29723 * @return {string | undefined} String with the class corresponding to the fontSize passed. 29724 * The class is generated by appending 'has-' followed by fontSizeSlug in kebabCase and ending with '-font-size'. 29725 */ 29726 function getFontSizeClass(fontSizeSlug) { 29727 if (!fontSizeSlug) { 29728 return; 29729 } 29730 return `has-$utils_kebabCase(fontSizeSlug)}-font-size`; 29731 } 29732 29733 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/font-size.js 29734 /** 29735 * WordPress dependencies 29736 */ 29737 29738 29739 29740 29741 /** 29742 * Internal dependencies 29743 */ 29744 29745 29746 29747 29748 29749 29750 const FONT_SIZE_SUPPORT_KEY = 'typography.fontSize'; 29751 29752 /** 29753 * Filters registered block settings, extending attributes to include 29754 * `fontSize` and `fontWeight` attributes. 29755 * 29756 * @param {Object} settings Original block settings. 29757 * 29758 * @return {Object} Filtered block settings. 29759 */ 29760 function font_size_addAttributes(settings) { 29761 if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, FONT_SIZE_SUPPORT_KEY)) { 29762 return settings; 29763 } 29764 29765 // Allow blocks to specify a default value if needed. 29766 if (!settings.attributes.fontSize) { 29767 Object.assign(settings.attributes, { 29768 fontSize: { 29769 type: 'string' 29770 } 29771 }); 29772 } 29773 return settings; 29774 } 29775 29776 /** 29777 * Override props assigned to save component to inject font size. 29778 * 29779 * @param {Object} props Additional props applied to save element. 29780 * @param {Object} blockNameOrType Block type. 29781 * @param {Object} attributes Block attributes. 29782 * 29783 * @return {Object} Filtered props applied to save element. 29784 */ 29785 function font_size_addSaveProps(props, blockNameOrType, attributes) { 29786 if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockNameOrType, FONT_SIZE_SUPPORT_KEY)) { 29787 return props; 29788 } 29789 if (shouldSkipSerialization(blockNameOrType, TYPOGRAPHY_SUPPORT_KEY, 'fontSize')) { 29790 return props; 29791 } 29792 29793 // Use TokenList to dedupe classes. 29794 const classes = new (external_wp_tokenList_default())(props.className); 29795 classes.add(getFontSizeClass(attributes.fontSize)); 29796 const newClassName = classes.value; 29797 props.className = newClassName ? newClassName : undefined; 29798 return props; 29799 } 29800 29801 /** 29802 * Inspector control panel containing the font size related configuration 29803 * 29804 * @param {Object} props 29805 * 29806 * @return {Element} Font size edit element. 29807 */ 29808 function FontSizeEdit(props) { 29809 const { 29810 attributes: { 29811 fontSize, 29812 style 29813 }, 29814 setAttributes 29815 } = props; 29816 const [fontSizes] = useSettings('typography.fontSizes'); 29817 const onChange = value => { 29818 const fontSizeSlug = getFontSizeObjectByValue(fontSizes, value).slug; 29819 setAttributes({ 29820 style: cleanEmptyObject({ 29821 ...style, 29822 typography: { 29823 ...style?.typography, 29824 fontSize: fontSizeSlug ? undefined : value 29825 } 29826 }), 29827 fontSize: fontSizeSlug 29828 }); 29829 }; 29830 const fontSizeObject = getFontSize(fontSizes, fontSize, style?.typography?.fontSize); 29831 const fontSizeValue = fontSizeObject?.size || style?.typography?.fontSize || fontSize; 29832 return /*#__PURE__*/_jsx(FontSizePicker, { 29833 onChange: onChange, 29834 value: fontSizeValue, 29835 withReset: false, 29836 withSlider: true, 29837 size: "__unstable-large" 29838 }); 29839 } 29840 29841 /** 29842 * Custom hook that checks if font-size settings have been disabled. 29843 * 29844 * @param {string} name The name of the block. 29845 * @return {boolean} Whether setting is disabled. 29846 */ 29847 function useIsFontSizeDisabled({ 29848 name: blockName 29849 } = {}) { 29850 const [fontSizes] = useSettings('typography.fontSizes'); 29851 const hasFontSizes = !!fontSizes?.length; 29852 return !hasBlockSupport(blockName, FONT_SIZE_SUPPORT_KEY) || !hasFontSizes; 29853 } 29854 function font_size_useBlockProps({ 29855 name, 29856 fontSize, 29857 style 29858 }) { 29859 const [fontSizes, fluidTypographySettings, layoutSettings] = use_settings_useSettings('typography.fontSizes', 'typography.fluid', 'layout'); 29860 29861 /* 29862 * Only add inline styles if the block supports font sizes, 29863 * doesn't skip serialization of font sizes, 29864 * and has either a custom font size or a preset font size. 29865 */ 29866 if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, FONT_SIZE_SUPPORT_KEY) || shouldSkipSerialization(name, TYPOGRAPHY_SUPPORT_KEY, 'fontSize') || !fontSize && !style?.typography?.fontSize) { 29867 return; 29868 } 29869 let props; 29870 if (style?.typography?.fontSize) { 29871 props = { 29872 style: { 29873 fontSize: getTypographyFontSizeValue({ 29874 size: style.typography.fontSize 29875 }, { 29876 typography: { 29877 fluid: fluidTypographySettings 29878 }, 29879 layout: layoutSettings 29880 }) 29881 } 29882 }; 29883 } 29884 if (fontSize) { 29885 props = { 29886 style: { 29887 fontSize: utils_getFontSize(fontSizes, fontSize, style?.typography?.fontSize).size 29888 } 29889 }; 29890 } 29891 if (!props) { 29892 return; 29893 } 29894 return font_size_addSaveProps(props, name, { 29895 fontSize 29896 }); 29897 } 29898 /* harmony default export */ const font_size = ({ 29899 useBlockProps: font_size_useBlockProps, 29900 addSaveProps: font_size_addSaveProps, 29901 attributeKeys: ['fontSize', 'style'], 29902 hasSupport(name) { 29903 return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, FONT_SIZE_SUPPORT_KEY); 29904 } 29905 }); 29906 const font_size_MIGRATION_PATHS = { 29907 fontSize: [['fontSize'], ['style', 'typography', 'fontSize']] 29908 }; 29909 function font_size_addTransforms(result, source, index, results) { 29910 const destinationBlockType = result.name; 29911 const activeSupports = { 29912 fontSize: (0,external_wp_blocks_namespaceObject.hasBlockSupport)(destinationBlockType, FONT_SIZE_SUPPORT_KEY) 29913 }; 29914 return transformStyles(activeSupports, font_size_MIGRATION_PATHS, result, source, index, results); 29915 } 29916 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/font/addAttribute', font_size_addAttributes); 29917 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.switchToBlockType.transformedBlock', 'core/font-size/addTransforms', font_size_addTransforms); 29918 29919 ;// ./node_modules/@wordpress/block-editor/build-module/components/alignment-control/ui.js 29920 /** 29921 * WordPress dependencies 29922 */ 29923 29924 29925 29926 29927 const DEFAULT_ALIGNMENT_CONTROLS = [{ 29928 icon: align_left, 29929 title: (0,external_wp_i18n_namespaceObject.__)('Align text left'), 29930 align: 'left' 29931 }, { 29932 icon: align_center, 29933 title: (0,external_wp_i18n_namespaceObject.__)('Align text center'), 29934 align: 'center' 29935 }, { 29936 icon: align_right, 29937 title: (0,external_wp_i18n_namespaceObject.__)('Align text right'), 29938 align: 'right' 29939 }]; 29940 const ui_POPOVER_PROPS = { 29941 placement: 'bottom-start' 29942 }; 29943 function AlignmentUI({ 29944 value, 29945 onChange, 29946 alignmentControls = DEFAULT_ALIGNMENT_CONTROLS, 29947 label = (0,external_wp_i18n_namespaceObject.__)('Align text'), 29948 description = (0,external_wp_i18n_namespaceObject.__)('Change text alignment'), 29949 isCollapsed = true, 29950 isToolbar 29951 }) { 29952 function applyOrUnset(align) { 29953 return () => onChange(value === align ? undefined : align); 29954 } 29955 const activeAlignment = alignmentControls.find(control => control.align === value); 29956 function setIcon() { 29957 if (activeAlignment) { 29958 return activeAlignment.icon; 29959 } 29960 return (0,external_wp_i18n_namespaceObject.isRTL)() ? align_right : align_left; 29961 } 29962 const UIComponent = isToolbar ? external_wp_components_namespaceObject.ToolbarGroup : external_wp_components_namespaceObject.ToolbarDropdownMenu; 29963 const extraProps = isToolbar ? { 29964 isCollapsed 29965 } : { 29966 toggleProps: { 29967 description 29968 }, 29969 popoverProps: ui_POPOVER_PROPS 29970 }; 29971 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UIComponent, { 29972 icon: setIcon(), 29973 label: label, 29974 controls: alignmentControls.map(control => { 29975 const { 29976 align 29977 } = control; 29978 const isActive = value === align; 29979 return { 29980 ...control, 29981 isActive, 29982 role: isCollapsed ? 'menuitemradio' : undefined, 29983 onClick: applyOrUnset(align) 29984 }; 29985 }), 29986 ...extraProps 29987 }); 29988 } 29989 /* harmony default export */ const alignment_control_ui = (AlignmentUI); 29990 29991 ;// ./node_modules/@wordpress/block-editor/build-module/components/alignment-control/index.js 29992 /** 29993 * Internal dependencies 29994 */ 29995 29996 29997 const AlignmentControl = props => { 29998 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(alignment_control_ui, { 29999 ...props, 30000 isToolbar: false 30001 }); 30002 }; 30003 const AlignmentToolbar = props => { 30004 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(alignment_control_ui, { 30005 ...props, 30006 isToolbar: true 30007 }); 30008 }; 30009 30010 /** 30011 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/alignment-control/README.md 30012 */ 30013 30014 30015 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/text-align.js 30016 /** 30017 * External dependencies 30018 */ 30019 30020 30021 /** 30022 * WordPress dependencies 30023 */ 30024 30025 30026 30027 30028 /** 30029 * Internal dependencies 30030 */ 30031 30032 30033 30034 30035 30036 const TEXT_ALIGN_SUPPORT_KEY = 'typography.textAlign'; 30037 const text_align_TEXT_ALIGNMENT_OPTIONS = [{ 30038 icon: align_left, 30039 title: (0,external_wp_i18n_namespaceObject.__)('Align text left'), 30040 align: 'left' 30041 }, { 30042 icon: align_center, 30043 title: (0,external_wp_i18n_namespaceObject.__)('Align text center'), 30044 align: 'center' 30045 }, { 30046 icon: align_right, 30047 title: (0,external_wp_i18n_namespaceObject.__)('Align text right'), 30048 align: 'right' 30049 }]; 30050 const VALID_TEXT_ALIGNMENTS = ['left', 'center', 'right']; 30051 const NO_TEXT_ALIGNMENTS = []; 30052 30053 /** 30054 * Returns the valid text alignments. 30055 * Takes into consideration the text aligns supported by a block. 30056 * Exported just for testing purposes, not exported outside the module. 30057 * 30058 * @param {?boolean|string[]} blockTextAlign Text aligns supported by the block. 30059 * 30060 * @return {string[]} Valid text alignments. 30061 */ 30062 function getValidTextAlignments(blockTextAlign) { 30063 if (Array.isArray(blockTextAlign)) { 30064 return VALID_TEXT_ALIGNMENTS.filter(textAlign => blockTextAlign.includes(textAlign)); 30065 } 30066 return blockTextAlign === true ? VALID_TEXT_ALIGNMENTS : NO_TEXT_ALIGNMENTS; 30067 } 30068 function BlockEditTextAlignmentToolbarControlsPure({ 30069 style, 30070 name: blockName, 30071 setAttributes 30072 }) { 30073 const settings = useBlockSettings(blockName); 30074 const hasTextAlignControl = settings?.typography?.textAlign; 30075 const blockEditingMode = useBlockEditingMode(); 30076 if (!hasTextAlignControl || blockEditingMode !== 'default') { 30077 return null; 30078 } 30079 const validTextAlignments = getValidTextAlignments((0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, TEXT_ALIGN_SUPPORT_KEY)); 30080 if (!validTextAlignments.length) { 30081 return null; 30082 } 30083 const textAlignmentControls = text_align_TEXT_ALIGNMENT_OPTIONS.filter(control => validTextAlignments.includes(control.align)); 30084 const onChange = newTextAlignValue => { 30085 const newStyle = { 30086 ...style, 30087 typography: { 30088 ...style?.typography, 30089 textAlign: newTextAlignValue 30090 } 30091 }; 30092 setAttributes({ 30093 style: utils_cleanEmptyObject(newStyle) 30094 }); 30095 }; 30096 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, { 30097 group: "block", 30098 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AlignmentControl, { 30099 value: style?.typography?.textAlign, 30100 onChange: onChange, 30101 alignmentControls: textAlignmentControls 30102 }) 30103 }); 30104 } 30105 /* harmony default export */ const text_align = ({ 30106 edit: BlockEditTextAlignmentToolbarControlsPure, 30107 useBlockProps: text_align_useBlockProps, 30108 addSaveProps: addAssignedTextAlign, 30109 attributeKeys: ['style'], 30110 hasSupport(name) { 30111 return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, TEXT_ALIGN_SUPPORT_KEY, false); 30112 } 30113 }); 30114 function text_align_useBlockProps({ 30115 name, 30116 style 30117 }) { 30118 if (!style?.typography?.textAlign) { 30119 return null; 30120 } 30121 const validTextAlignments = getValidTextAlignments((0,external_wp_blocks_namespaceObject.getBlockSupport)(name, TEXT_ALIGN_SUPPORT_KEY)); 30122 if (!validTextAlignments.length) { 30123 return null; 30124 } 30125 if (shouldSkipSerialization(name, TYPOGRAPHY_SUPPORT_KEY, 'textAlign')) { 30126 return null; 30127 } 30128 const textAlign = style.typography.textAlign; 30129 const className = dist_clsx({ 30130 [`has-text-align-$textAlign}`]: textAlign 30131 }); 30132 return { 30133 className 30134 }; 30135 } 30136 30137 /** 30138 * Override props assigned to save component to inject text alignment class 30139 * name if block supports it. 30140 * 30141 * @param {Object} props Additional props applied to save element. 30142 * @param {Object} blockType Block type. 30143 * @param {Object} attributes Block attributes. 30144 * 30145 * @return {Object} Filtered props applied to save element. 30146 */ 30147 function addAssignedTextAlign(props, blockType, attributes) { 30148 if (!attributes?.style?.typography?.textAlign) { 30149 return props; 30150 } 30151 const { 30152 textAlign 30153 } = attributes.style.typography; 30154 const blockTextAlign = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, TEXT_ALIGN_SUPPORT_KEY); 30155 const isTextAlignValid = getValidTextAlignments(blockTextAlign).includes(textAlign); 30156 if (isTextAlignValid && !shouldSkipSerialization(blockType, TYPOGRAPHY_SUPPORT_KEY, 'textAlign')) { 30157 props.className = dist_clsx(`has-text-align-$textAlign}`, props.className); 30158 } 30159 return props; 30160 } 30161 30162 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/typography.js 30163 /** 30164 * WordPress dependencies 30165 */ 30166 30167 30168 30169 30170 /** 30171 * Internal dependencies 30172 */ 30173 30174 30175 30176 30177 30178 30179 30180 30181 30182 function omit(object, keys) { 30183 return Object.fromEntries(Object.entries(object).filter(([key]) => !keys.includes(key))); 30184 } 30185 const LETTER_SPACING_SUPPORT_KEY = 'typography.__experimentalLetterSpacing'; 30186 const TEXT_TRANSFORM_SUPPORT_KEY = 'typography.__experimentalTextTransform'; 30187 const TEXT_DECORATION_SUPPORT_KEY = 'typography.__experimentalTextDecoration'; 30188 const TEXT_COLUMNS_SUPPORT_KEY = 'typography.textColumns'; 30189 const FONT_STYLE_SUPPORT_KEY = 'typography.__experimentalFontStyle'; 30190 const FONT_WEIGHT_SUPPORT_KEY = 'typography.__experimentalFontWeight'; 30191 const WRITING_MODE_SUPPORT_KEY = 'typography.__experimentalWritingMode'; 30192 const TYPOGRAPHY_SUPPORT_KEY = 'typography'; 30193 const TYPOGRAPHY_SUPPORT_KEYS = [LINE_HEIGHT_SUPPORT_KEY, FONT_SIZE_SUPPORT_KEY, FONT_STYLE_SUPPORT_KEY, FONT_WEIGHT_SUPPORT_KEY, FONT_FAMILY_SUPPORT_KEY, TEXT_ALIGN_SUPPORT_KEY, TEXT_COLUMNS_SUPPORT_KEY, TEXT_DECORATION_SUPPORT_KEY, WRITING_MODE_SUPPORT_KEY, TEXT_TRANSFORM_SUPPORT_KEY, LETTER_SPACING_SUPPORT_KEY]; 30194 function typography_styleToAttributes(style) { 30195 const updatedStyle = { 30196 ...omit(style, ['fontFamily']) 30197 }; 30198 const fontSizeValue = style?.typography?.fontSize; 30199 const fontFamilyValue = style?.typography?.fontFamily; 30200 const fontSizeSlug = fontSizeValue?.startsWith('var:preset|font-size|') ? fontSizeValue.substring('var:preset|font-size|'.length) : undefined; 30201 const fontFamilySlug = fontFamilyValue?.startsWith('var:preset|font-family|') ? fontFamilyValue.substring('var:preset|font-family|'.length) : undefined; 30202 updatedStyle.typography = { 30203 ...omit(updatedStyle.typography, ['fontFamily']), 30204 fontSize: fontSizeSlug ? undefined : fontSizeValue 30205 }; 30206 return { 30207 style: utils_cleanEmptyObject(updatedStyle), 30208 fontFamily: fontFamilySlug, 30209 fontSize: fontSizeSlug 30210 }; 30211 } 30212 function typography_attributesToStyle(attributes) { 30213 return { 30214 ...attributes.style, 30215 typography: { 30216 ...attributes.style?.typography, 30217 fontFamily: attributes.fontFamily ? 'var:preset|font-family|' + attributes.fontFamily : undefined, 30218 fontSize: attributes.fontSize ? 'var:preset|font-size|' + attributes.fontSize : attributes.style?.typography?.fontSize 30219 } 30220 }; 30221 } 30222 function TypographyInspectorControl({ 30223 children, 30224 resetAllFilter 30225 }) { 30226 const attributesResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes => { 30227 const existingStyle = typography_attributesToStyle(attributes); 30228 const updatedStyle = resetAllFilter(existingStyle); 30229 return { 30230 ...attributes, 30231 ...typography_styleToAttributes(updatedStyle) 30232 }; 30233 }, [resetAllFilter]); 30234 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, { 30235 group: "typography", 30236 resetAllFilter: attributesResetAllFilter, 30237 children: children 30238 }); 30239 } 30240 function typography_TypographyPanel({ 30241 clientId, 30242 name, 30243 setAttributes, 30244 settings 30245 }) { 30246 function selector(select) { 30247 const { 30248 style, 30249 fontFamily, 30250 fontSize 30251 } = select(store).getBlockAttributes(clientId) || {}; 30252 return { 30253 style, 30254 fontFamily, 30255 fontSize 30256 }; 30257 } 30258 const { 30259 style, 30260 fontFamily, 30261 fontSize 30262 } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId]); 30263 const isEnabled = useHasTypographyPanel(settings); 30264 const value = (0,external_wp_element_namespaceObject.useMemo)(() => typography_attributesToStyle({ 30265 style, 30266 fontFamily, 30267 fontSize 30268 }), [style, fontSize, fontFamily]); 30269 const onChange = newStyle => { 30270 setAttributes(typography_styleToAttributes(newStyle)); 30271 }; 30272 if (!isEnabled) { 30273 return null; 30274 } 30275 const defaultControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [TYPOGRAPHY_SUPPORT_KEY, '__experimentalDefaultControls']); 30276 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TypographyPanel, { 30277 as: TypographyInspectorControl, 30278 panelId: clientId, 30279 settings: settings, 30280 value: value, 30281 onChange: onChange, 30282 defaultControls: defaultControls 30283 }); 30284 } 30285 const hasTypographySupport = blockName => { 30286 return TYPOGRAPHY_SUPPORT_KEYS.some(key => hasBlockSupport(blockName, key)); 30287 }; 30288 30289 ;// ./node_modules/@wordpress/icons/build-module/library/settings.js 30290 /** 30291 * WordPress dependencies 30292 */ 30293 30294 30295 30296 const settings_settings = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, { 30297 xmlns: "http://www.w3.org/2000/svg", 30298 viewBox: "0 0 24 24", 30299 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 30300 d: "m19 7.5h-7.628c-.3089-.87389-1.1423-1.5-2.122-1.5-.97966 0-1.81309.62611-2.12197 1.5h-2.12803v1.5h2.12803c.30888.87389 1.14231 1.5 2.12197 1.5.9797 0 1.8131-.62611 2.122-1.5h7.628z" 30301 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 30302 d: "m19 15h-2.128c-.3089-.8739-1.1423-1.5-2.122-1.5s-1.8131.6261-2.122 1.5h-7.628v1.5h7.628c.3089.8739 1.1423 1.5 2.122 1.5s1.8131-.6261 2.122-1.5h2.128z" 30303 })] 30304 }); 30305 /* harmony default export */ const library_settings = (settings_settings); 30306 30307 ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/input-controls/spacing-input-control.js 30308 /** 30309 * WordPress dependencies 30310 */ 30311 30312 30313 30314 30315 30316 30317 30318 /** 30319 * Internal dependencies 30320 */ 30321 30322 30323 30324 30325 30326 30327 const CUSTOM_VALUE_SETTINGS = { 30328 px: { 30329 max: 300, 30330 steps: 1 30331 }, 30332 '%': { 30333 max: 100, 30334 steps: 1 30335 }, 30336 vw: { 30337 max: 100, 30338 steps: 1 30339 }, 30340 vh: { 30341 max: 100, 30342 steps: 1 30343 }, 30344 em: { 30345 max: 10, 30346 steps: 0.1 30347 }, 30348 rm: { 30349 max: 10, 30350 steps: 0.1 30351 }, 30352 svw: { 30353 max: 100, 30354 steps: 1 30355 }, 30356 lvw: { 30357 max: 100, 30358 steps: 1 30359 }, 30360 dvw: { 30361 max: 100, 30362 steps: 1 30363 }, 30364 svh: { 30365 max: 100, 30366 steps: 1 30367 }, 30368 lvh: { 30369 max: 100, 30370 steps: 1 30371 }, 30372 dvh: { 30373 max: 100, 30374 steps: 1 30375 }, 30376 vi: { 30377 max: 100, 30378 steps: 1 30379 }, 30380 svi: { 30381 max: 100, 30382 steps: 1 30383 }, 30384 lvi: { 30385 max: 100, 30386 steps: 1 30387 }, 30388 dvi: { 30389 max: 100, 30390 steps: 1 30391 }, 30392 vb: { 30393 max: 100, 30394 steps: 1 30395 }, 30396 svb: { 30397 max: 100, 30398 steps: 1 30399 }, 30400 lvb: { 30401 max: 100, 30402 steps: 1 30403 }, 30404 dvb: { 30405 max: 100, 30406 steps: 1 30407 }, 30408 vmin: { 30409 max: 100, 30410 steps: 1 30411 }, 30412 svmin: { 30413 max: 100, 30414 steps: 1 30415 }, 30416 lvmin: { 30417 max: 100, 30418 steps: 1 30419 }, 30420 dvmin: { 30421 max: 100, 30422 steps: 1 30423 }, 30424 vmax: { 30425 max: 100, 30426 steps: 1 30427 }, 30428 svmax: { 30429 max: 100, 30430 steps: 1 30431 }, 30432 lvmax: { 30433 max: 100, 30434 steps: 1 30435 }, 30436 dvmax: { 30437 max: 100, 30438 steps: 1 30439 } 30440 }; 30441 function SpacingInputControl({ 30442 icon, 30443 isMixed = false, 30444 minimumCustomValue, 30445 onChange, 30446 onMouseOut, 30447 onMouseOver, 30448 showSideInLabel = true, 30449 side, 30450 spacingSizes, 30451 type, 30452 value 30453 }) { 30454 var _CUSTOM_VALUE_SETTING, _CUSTOM_VALUE_SETTING2; 30455 // Treat value as a preset value if the passed in value matches the value of one of the spacingSizes. 30456 value = getPresetValueFromCustomValue(value, spacingSizes); 30457 let selectListSizes = spacingSizes; 30458 const showRangeControl = spacingSizes.length <= RANGE_CONTROL_MAX_SIZE; 30459 const disableCustomSpacingSizes = (0,external_wp_data_namespaceObject.useSelect)(select => { 30460 const editorSettings = select(store).getSettings(); 30461 return editorSettings?.disableCustomSpacingSizes; 30462 }); 30463 const [showCustomValueControl, setShowCustomValueControl] = (0,external_wp_element_namespaceObject.useState)(!disableCustomSpacingSizes && value !== undefined && !isValueSpacingPreset(value)); 30464 const [minValue, setMinValue] = (0,external_wp_element_namespaceObject.useState)(minimumCustomValue); 30465 const previousValue = (0,external_wp_compose_namespaceObject.usePrevious)(value); 30466 if (!!value && previousValue !== value && !isValueSpacingPreset(value) && showCustomValueControl !== true) { 30467 setShowCustomValueControl(true); 30468 } 30469 const [availableUnits] = use_settings_useSettings('spacing.units'); 30470 const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({ 30471 availableUnits: availableUnits || ['px', 'em', 'rem'] 30472 }); 30473 let currentValue = null; 30474 const showCustomValueInSelectList = !showRangeControl && !showCustomValueControl && value !== undefined && (!isValueSpacingPreset(value) || isValueSpacingPreset(value) && isMixed); 30475 if (showCustomValueInSelectList) { 30476 selectListSizes = [...spacingSizes, { 30477 name: !isMixed ? 30478 // translators: %s: A custom measurement, e.g. a number followed by a unit like 12px. 30479 (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)('Custom (%s)'), value) : (0,external_wp_i18n_namespaceObject.__)('Mixed'), 30480 slug: 'custom', 30481 size: value 30482 }]; 30483 currentValue = selectListSizes.length - 1; 30484 } else if (!isMixed) { 30485 currentValue = !showCustomValueControl ? getSliderValueFromPreset(value, spacingSizes) : getCustomValueFromPreset(value, spacingSizes); 30486 } 30487 const selectedUnit = (0,external_wp_element_namespaceObject.useMemo)(() => (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(currentValue), [currentValue])[1] || units[0]?.value; 30488 const setInitialValue = () => { 30489 if (value === undefined) { 30490 onChange('0'); 30491 } 30492 }; 30493 const customTooltipContent = newValue => value === undefined ? undefined : spacingSizes[newValue]?.name; 30494 const customRangeValue = parseFloat(currentValue, 10); 30495 const getNewCustomValue = newSize => { 30496 const isNumeric = !isNaN(parseFloat(newSize)); 30497 const nextValue = isNumeric ? newSize : undefined; 30498 return nextValue; 30499 }; 30500 const getNewPresetValue = (newSize, controlType) => { 30501 const size = parseInt(newSize, 10); 30502 if (controlType === 'selectList') { 30503 if (size === 0) { 30504 return undefined; 30505 } 30506 if (size === 1) { 30507 return '0'; 30508 } 30509 } else if (size === 0) { 30510 return '0'; 30511 } 30512 return `var:preset|spacing|$spacingSizes[newSize]?.slug}`; 30513 }; 30514 const handleCustomValueSliderChange = next => { 30515 onChange([next, selectedUnit].join('')); 30516 }; 30517 const allPlaceholder = isMixed ? (0,external_wp_i18n_namespaceObject.__)('Mixed') : null; 30518 const options = selectListSizes.map((size, index) => ({ 30519 key: index, 30520 name: size.name 30521 })); 30522 const marks = spacingSizes.slice(1, spacingSizes.length - 1).map((_newValue, index) => ({ 30523 value: index + 1, 30524 label: undefined 30525 })); 30526 const sideLabel = ALL_SIDES.includes(side) && showSideInLabel ? LABELS[side] : ''; 30527 const typeLabel = showSideInLabel ? type?.toLowerCase() : type; 30528 const ariaLabel = (0,external_wp_i18n_namespaceObject.sprintf)( 30529 // translators: 1: The side of the block being modified (top, bottom, left etc.). 2. Type of spacing being modified (padding, margin, etc). 30530 (0,external_wp_i18n_namespaceObject._x)('%1$s %2$s', 'spacing'), sideLabel, typeLabel).trim(); 30531 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 30532 className: "spacing-sizes-control__wrapper", 30533 children: [icon && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, { 30534 className: "spacing-sizes-control__icon", 30535 icon: icon, 30536 size: 24 30537 }), showCustomValueControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 30538 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 30539 onMouseOver: onMouseOver, 30540 onMouseOut: onMouseOut, 30541 onFocus: onMouseOver, 30542 onBlur: onMouseOut, 30543 onChange: newSize => onChange(getNewCustomValue(newSize)), 30544 value: currentValue, 30545 units: units, 30546 min: minValue, 30547 placeholder: allPlaceholder, 30548 disableUnits: isMixed, 30549 label: ariaLabel, 30550 hideLabelFromVision: true, 30551 className: "spacing-sizes-control__custom-value-input", 30552 size: "__unstable-large", 30553 onDragStart: () => { 30554 if (value?.charAt(0) === '-') { 30555 setMinValue(0); 30556 } 30557 }, 30558 onDrag: () => { 30559 if (value?.charAt(0) === '-') { 30560 setMinValue(0); 30561 } 30562 }, 30563 onDragEnd: () => { 30564 setMinValue(minimumCustomValue); 30565 } 30566 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, { 30567 __next40pxDefaultSize: true, 30568 onMouseOver: onMouseOver, 30569 onMouseOut: onMouseOut, 30570 onFocus: onMouseOver, 30571 onBlur: onMouseOut, 30572 value: customRangeValue, 30573 min: 0, 30574 max: (_CUSTOM_VALUE_SETTING = CUSTOM_VALUE_SETTINGS[selectedUnit]?.max) !== null && _CUSTOM_VALUE_SETTING !== void 0 ? _CUSTOM_VALUE_SETTING : 10, 30575 step: (_CUSTOM_VALUE_SETTING2 = CUSTOM_VALUE_SETTINGS[selectedUnit]?.steps) !== null && _CUSTOM_VALUE_SETTING2 !== void 0 ? _CUSTOM_VALUE_SETTING2 : 0.1, 30576 withInputField: false, 30577 onChange: handleCustomValueSliderChange, 30578 className: "spacing-sizes-control__custom-value-range", 30579 __nextHasNoMarginBottom: true, 30580 label: ariaLabel, 30581 hideLabelFromVision: true 30582 })] 30583 }), showRangeControl && !showCustomValueControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, { 30584 __next40pxDefaultSize: true, 30585 onMouseOver: onMouseOver, 30586 onMouseOut: onMouseOut, 30587 className: "spacing-sizes-control__range-control", 30588 value: currentValue, 30589 onChange: newSize => onChange(getNewPresetValue(newSize)), 30590 onMouseDown: event => { 30591 // If mouse down is near start of range set initial value to 0, which 30592 // prevents the user have to drag right then left to get 0 setting. 30593 if (event?.nativeEvent?.offsetX < 35) { 30594 setInitialValue(); 30595 } 30596 }, 30597 withInputField: false, 30598 "aria-valuenow": currentValue, 30599 "aria-valuetext": spacingSizes[currentValue]?.name, 30600 renderTooltipContent: customTooltipContent, 30601 min: 0, 30602 max: spacingSizes.length - 1, 30603 marks: marks, 30604 label: ariaLabel, 30605 hideLabelFromVision: true, 30606 __nextHasNoMarginBottom: true, 30607 onFocus: onMouseOver, 30608 onBlur: onMouseOut 30609 }), !showRangeControl && !showCustomValueControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, { 30610 className: "spacing-sizes-control__custom-select-control", 30611 value: 30612 // passing empty string as a fallback to continue using the 30613 // component in controlled mode 30614 options.find(option => option.key === currentValue) || '', 30615 onChange: selection => { 30616 onChange(getNewPresetValue(selection.selectedItem.key, 'selectList')); 30617 }, 30618 options: options, 30619 label: ariaLabel, 30620 hideLabelFromVision: true, 30621 size: "__unstable-large", 30622 onMouseOver: onMouseOver, 30623 onMouseOut: onMouseOut, 30624 onFocus: onMouseOver, 30625 onBlur: onMouseOut 30626 }), !disableCustomSpacingSizes && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 30627 label: showCustomValueControl ? (0,external_wp_i18n_namespaceObject.__)('Use size preset') : (0,external_wp_i18n_namespaceObject.__)('Set custom size'), 30628 icon: library_settings, 30629 onClick: () => { 30630 setShowCustomValueControl(!showCustomValueControl); 30631 }, 30632 isPressed: showCustomValueControl, 30633 size: "small", 30634 className: "spacing-sizes-control__custom-toggle", 30635 iconSize: 24 30636 })] 30637 }); 30638 } 30639 30640 ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/input-controls/axial.js 30641 /** 30642 * Internal dependencies 30643 */ 30644 30645 30646 30647 30648 const groupedSides = ['vertical', 'horizontal']; 30649 function AxialInputControls({ 30650 minimumCustomValue, 30651 onChange, 30652 onMouseOut, 30653 onMouseOver, 30654 sides, 30655 spacingSizes, 30656 type, 30657 values 30658 }) { 30659 const createHandleOnChange = side => next => { 30660 if (!onChange) { 30661 return; 30662 } 30663 30664 // Encode the existing value into the preset value if the passed in value matches the value of one of the spacingSizes. 30665 const nextValues = { 30666 ...Object.keys(values).reduce((acc, key) => { 30667 acc[key] = getPresetValueFromCustomValue(values[key], spacingSizes); 30668 return acc; 30669 }, {}) 30670 }; 30671 if (side === 'vertical') { 30672 nextValues.top = next; 30673 nextValues.bottom = next; 30674 } 30675 if (side === 'horizontal') { 30676 nextValues.left = next; 30677 nextValues.right = next; 30678 } 30679 onChange(nextValues); 30680 }; 30681 30682 // Filter sides if custom configuration provided, maintaining default order. 30683 const filteredSides = sides?.length ? groupedSides.filter(side => hasAxisSupport(sides, side)) : groupedSides; 30684 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 30685 children: filteredSides.map(side => { 30686 const axisValue = side === 'vertical' ? values.top : values.left; 30687 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingInputControl, { 30688 icon: ICONS[side], 30689 label: LABELS[side], 30690 minimumCustomValue: minimumCustomValue, 30691 onChange: createHandleOnChange(side), 30692 onMouseOut: onMouseOut, 30693 onMouseOver: onMouseOver, 30694 side: side, 30695 spacingSizes: spacingSizes, 30696 type: type, 30697 value: axisValue, 30698 withInputField: false 30699 }, `spacing-sizes-control-$side}`); 30700 }) 30701 }); 30702 } 30703 30704 ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/input-controls/separated.js 30705 /** 30706 * Internal dependencies 30707 */ 30708 30709 30710 30711 30712 function SeparatedInputControls({ 30713 minimumCustomValue, 30714 onChange, 30715 onMouseOut, 30716 onMouseOver, 30717 sides, 30718 spacingSizes, 30719 type, 30720 values 30721 }) { 30722 // Filter sides if custom configuration provided, maintaining default order. 30723 const filteredSides = sides?.length ? ALL_SIDES.filter(side => sides.includes(side)) : ALL_SIDES; 30724 const createHandleOnChange = side => next => { 30725 // Encode the existing value into the preset value if the passed in value matches the value of one of the spacingSizes. 30726 const nextValues = { 30727 ...Object.keys(values).reduce((acc, key) => { 30728 acc[key] = getPresetValueFromCustomValue(values[key], spacingSizes); 30729 return acc; 30730 }, {}) 30731 }; 30732 nextValues[side] = next; 30733 onChange(nextValues); 30734 }; 30735 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 30736 children: filteredSides.map(side => { 30737 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingInputControl, { 30738 icon: ICONS[side], 30739 label: LABELS[side], 30740 minimumCustomValue: minimumCustomValue, 30741 onChange: createHandleOnChange(side), 30742 onMouseOut: onMouseOut, 30743 onMouseOver: onMouseOver, 30744 side: side, 30745 spacingSizes: spacingSizes, 30746 type: type, 30747 value: values[side], 30748 withInputField: false 30749 }, `spacing-sizes-control-$side}`); 30750 }) 30751 }); 30752 } 30753 30754 ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/input-controls/single.js 30755 /** 30756 * Internal dependencies 30757 */ 30758 30759 30760 30761 function SingleInputControl({ 30762 minimumCustomValue, 30763 onChange, 30764 onMouseOut, 30765 onMouseOver, 30766 showSideInLabel, 30767 side, 30768 spacingSizes, 30769 type, 30770 values 30771 }) { 30772 const createHandleOnChange = currentSide => next => { 30773 // Encode the existing value into the preset value if the passed in value matches the value of one of the spacingSizes. 30774 const nextValues = { 30775 ...Object.keys(values).reduce((acc, key) => { 30776 acc[key] = getPresetValueFromCustomValue(values[key], spacingSizes); 30777 return acc; 30778 }, {}) 30779 }; 30780 nextValues[currentSide] = next; 30781 onChange(nextValues); 30782 }; 30783 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingInputControl, { 30784 label: LABELS[side], 30785 minimumCustomValue: minimumCustomValue, 30786 onChange: createHandleOnChange(side), 30787 onMouseOut: onMouseOut, 30788 onMouseOver: onMouseOver, 30789 showSideInLabel: showSideInLabel, 30790 side: side, 30791 spacingSizes: spacingSizes, 30792 type: type, 30793 value: values[side], 30794 withInputField: false 30795 }); 30796 } 30797 30798 ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/linked-button.js 30799 /** 30800 * WordPress dependencies 30801 */ 30802 30803 30804 30805 30806 function linked_button_LinkedButton({ 30807 isLinked, 30808 ...props 30809 }) { 30810 const label = isLinked ? (0,external_wp_i18n_namespaceObject.__)('Unlink sides') : (0,external_wp_i18n_namespaceObject.__)('Link sides'); 30811 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, { 30812 text: label, 30813 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 30814 ...props, 30815 size: "small", 30816 icon: isLinked ? library_link : link_off, 30817 iconSize: 24, 30818 "aria-label": label 30819 }) 30820 }); 30821 } 30822 30823 ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/hooks/use-spacing-sizes.js 30824 /** 30825 * WordPress dependencies 30826 */ 30827 30828 30829 30830 /** 30831 * Internal dependencies 30832 */ 30833 30834 30835 const use_spacing_sizes_EMPTY_ARRAY = []; 30836 const compare = new Intl.Collator('und', { 30837 numeric: true 30838 }).compare; 30839 function useSpacingSizes() { 30840 const [customSpacingSizes, themeSpacingSizes, defaultSpacingSizes, defaultSpacingSizesEnabled] = use_settings_useSettings('spacing.spacingSizes.custom', 'spacing.spacingSizes.theme', 'spacing.spacingSizes.default', 'spacing.defaultSpacingSizes'); 30841 const customSizes = customSpacingSizes !== null && customSpacingSizes !== void 0 ? customSpacingSizes : use_spacing_sizes_EMPTY_ARRAY; 30842 const themeSizes = themeSpacingSizes !== null && themeSpacingSizes !== void 0 ? themeSpacingSizes : use_spacing_sizes_EMPTY_ARRAY; 30843 const defaultSizes = defaultSpacingSizes && defaultSpacingSizesEnabled !== false ? defaultSpacingSizes : use_spacing_sizes_EMPTY_ARRAY; 30844 return (0,external_wp_element_namespaceObject.useMemo)(() => { 30845 const sizes = [{ 30846 name: (0,external_wp_i18n_namespaceObject.__)('None'), 30847 slug: '0', 30848 size: 0 30849 }, ...customSizes, ...themeSizes, ...defaultSizes]; 30850 30851 // Using numeric slugs opts-in to sorting by slug. 30852 if (sizes.every(({ 30853 slug 30854 }) => /^[0-9]/.test(slug))) { 30855 sizes.sort((a, b) => compare(a.slug, b.slug)); 30856 } 30857 return sizes.length > RANGE_CONTROL_MAX_SIZE ? [{ 30858 name: (0,external_wp_i18n_namespaceObject.__)('Default'), 30859 slug: 'default', 30860 size: undefined 30861 }, ...sizes] : sizes; 30862 }, [customSizes, themeSizes, defaultSizes]); 30863 } 30864 30865 ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/index.js 30866 /** 30867 * WordPress dependencies 30868 */ 30869 30870 30871 30872 30873 /** 30874 * Internal dependencies 30875 */ 30876 30877 30878 30879 30880 30881 30882 30883 30884 function SpacingSizesControl({ 30885 inputProps, 30886 label: labelProp, 30887 minimumCustomValue = 0, 30888 onChange, 30889 onMouseOut, 30890 onMouseOver, 30891 showSideInLabel = true, 30892 sides = ALL_SIDES, 30893 useSelect, 30894 values 30895 }) { 30896 const spacingSizes = useSpacingSizes(); 30897 const inputValues = values || DEFAULT_VALUES; 30898 const hasOneSide = sides?.length === 1; 30899 const hasOnlyAxialSides = sides?.includes('horizontal') && sides?.includes('vertical') && sides?.length === 2; 30900 const [view, setView] = (0,external_wp_element_namespaceObject.useState)(getInitialView(inputValues, sides)); 30901 const toggleLinked = () => { 30902 setView(view === VIEWS.axial ? VIEWS.custom : VIEWS.axial); 30903 }; 30904 const handleOnChange = nextValue => { 30905 const newValues = { 30906 ...values, 30907 ...nextValue 30908 }; 30909 onChange(newValues); 30910 }; 30911 const inputControlProps = { 30912 ...inputProps, 30913 minimumCustomValue, 30914 onChange: handleOnChange, 30915 onMouseOut, 30916 onMouseOver, 30917 sides, 30918 spacingSizes, 30919 type: labelProp, 30920 useSelect, 30921 values: inputValues 30922 }; 30923 const renderControls = () => { 30924 if (view === VIEWS.axial) { 30925 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AxialInputControls, { 30926 ...inputControlProps 30927 }); 30928 } 30929 if (view === VIEWS.custom) { 30930 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SeparatedInputControls, { 30931 ...inputControlProps 30932 }); 30933 } 30934 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SingleInputControl, { 30935 side: view, 30936 ...inputControlProps, 30937 showSideInLabel: showSideInLabel 30938 }); 30939 }; 30940 const sideLabel = ALL_SIDES.includes(view) && showSideInLabel ? LABELS[view] : ''; 30941 const label = (0,external_wp_i18n_namespaceObject.sprintf)( 30942 // translators: 1: The side of the block being modified (top, bottom, left etc.). 2. Type of spacing being modified (padding, margin, etc). 30943 (0,external_wp_i18n_namespaceObject._x)('%1$s %2$s', 'spacing'), labelProp, sideLabel).trim(); 30944 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", { 30945 className: "spacing-sizes-control", 30946 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 30947 className: "spacing-sizes-control__header", 30948 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, { 30949 as: "legend", 30950 className: "spacing-sizes-control__label", 30951 children: label 30952 }), !hasOneSide && !hasOnlyAxialSides && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(linked_button_LinkedButton, { 30953 label: labelProp, 30954 onClick: toggleLinked, 30955 isLinked: view === VIEWS.axial 30956 })] 30957 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalVStack, { 30958 spacing: 0.5, 30959 children: renderControls() 30960 })] 30961 }); 30962 } 30963 30964 ;// ./node_modules/@wordpress/block-editor/build-module/components/height-control/index.js 30965 /** 30966 * WordPress dependencies 30967 */ 30968 30969 30970 30971 30972 /** 30973 * Internal dependencies 30974 */ 30975 30976 30977 30978 const RANGE_CONTROL_CUSTOM_SETTINGS = { 30979 px: { 30980 max: 1000, 30981 step: 1 30982 }, 30983 '%': { 30984 max: 100, 30985 step: 1 30986 }, 30987 vw: { 30988 max: 100, 30989 step: 1 30990 }, 30991 vh: { 30992 max: 100, 30993 step: 1 30994 }, 30995 em: { 30996 max: 50, 30997 step: 0.1 30998 }, 30999 rem: { 31000 max: 50, 31001 step: 0.1 31002 }, 31003 svw: { 31004 max: 100, 31005 step: 1 31006 }, 31007 lvw: { 31008 max: 100, 31009 step: 1 31010 }, 31011 dvw: { 31012 max: 100, 31013 step: 1 31014 }, 31015 svh: { 31016 max: 100, 31017 step: 1 31018 }, 31019 lvh: { 31020 max: 100, 31021 step: 1 31022 }, 31023 dvh: { 31024 max: 100, 31025 step: 1 31026 }, 31027 vi: { 31028 max: 100, 31029 step: 1 31030 }, 31031 svi: { 31032 max: 100, 31033 step: 1 31034 }, 31035 lvi: { 31036 max: 100, 31037 step: 1 31038 }, 31039 dvi: { 31040 max: 100, 31041 step: 1 31042 }, 31043 vb: { 31044 max: 100, 31045 step: 1 31046 }, 31047 svb: { 31048 max: 100, 31049 step: 1 31050 }, 31051 lvb: { 31052 max: 100, 31053 step: 1 31054 }, 31055 dvb: { 31056 max: 100, 31057 step: 1 31058 }, 31059 vmin: { 31060 max: 100, 31061 step: 1 31062 }, 31063 svmin: { 31064 max: 100, 31065 step: 1 31066 }, 31067 lvmin: { 31068 max: 100, 31069 step: 1 31070 }, 31071 dvmin: { 31072 max: 100, 31073 step: 1 31074 }, 31075 vmax: { 31076 max: 100, 31077 step: 1 31078 }, 31079 svmax: { 31080 max: 100, 31081 step: 1 31082 }, 31083 lvmax: { 31084 max: 100, 31085 step: 1 31086 }, 31087 dvmax: { 31088 max: 100, 31089 step: 1 31090 } 31091 }; 31092 31093 /** 31094 * HeightControl renders a linked unit control and range control for adjusting the height of a block. 31095 * 31096 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/height-control/README.md 31097 * 31098 * @param {Object} props 31099 * @param {?string} props.label A label for the control. 31100 * @param {( value: string ) => void } props.onChange Called when the height changes. 31101 * @param {string} props.value The current height value. 31102 * 31103 * @return {Component} The component to be rendered. 31104 */ 31105 function HeightControl({ 31106 label = (0,external_wp_i18n_namespaceObject.__)('Height'), 31107 onChange, 31108 value 31109 }) { 31110 var _RANGE_CONTROL_CUSTOM, _RANGE_CONTROL_CUSTOM2; 31111 const customRangeValue = parseFloat(value); 31112 const [availableUnits] = use_settings_useSettings('spacing.units'); 31113 const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({ 31114 availableUnits: availableUnits || ['%', 'px', 'em', 'rem', 'vh', 'vw'] 31115 }); 31116 const selectedUnit = (0,external_wp_element_namespaceObject.useMemo)(() => (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(value), [value])[1] || units[0]?.value || 'px'; 31117 const handleSliderChange = next => { 31118 onChange([next, selectedUnit].join('')); 31119 }; 31120 const handleUnitChange = newUnit => { 31121 // Attempt to smooth over differences between currentUnit and newUnit. 31122 // This should slightly improve the experience of switching between unit types. 31123 const [currentValue, currentUnit] = (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(value); 31124 if (['em', 'rem'].includes(newUnit) && currentUnit === 'px') { 31125 // Convert pixel value to an approximate of the new unit, assuming a root size of 16px. 31126 onChange((currentValue / 16).toFixed(2) + newUnit); 31127 } else if (['em', 'rem'].includes(currentUnit) && newUnit === 'px') { 31128 // Convert to pixel value assuming a root size of 16px. 31129 onChange(Math.round(currentValue * 16) + newUnit); 31130 } else if (['%', 'vw', 'svw', 'lvw', 'dvw', 'vh', 'svh', 'lvh', 'dvh', 'vi', 'svi', 'lvi', 'dvi', 'vb', 'svb', 'lvb', 'dvb', 'vmin', 'svmin', 'lvmin', 'dvmin', 'vmax', 'svmax', 'lvmax', 'dvmax'].includes(newUnit) && currentValue > 100) { 31131 // When converting to `%` or viewport-relative units, cap the new value at 100. 31132 onChange(100 + newUnit); 31133 } 31134 }; 31135 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", { 31136 className: "block-editor-height-control", 31137 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, { 31138 as: "legend", 31139 children: label 31140 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, { 31141 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 31142 isBlock: true, 31143 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 31144 value: value, 31145 units: units, 31146 onChange: onChange, 31147 onUnitChange: handleUnitChange, 31148 min: 0, 31149 size: "__unstable-large", 31150 label: label, 31151 hideLabelFromVision: true 31152 }) 31153 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 31154 isBlock: true, 31155 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, { 31156 marginX: 2, 31157 marginBottom: 0, 31158 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, { 31159 __next40pxDefaultSize: true, 31160 value: customRangeValue, 31161 min: 0, 31162 max: (_RANGE_CONTROL_CUSTOM = RANGE_CONTROL_CUSTOM_SETTINGS[selectedUnit]?.max) !== null && _RANGE_CONTROL_CUSTOM !== void 0 ? _RANGE_CONTROL_CUSTOM : 100, 31163 step: (_RANGE_CONTROL_CUSTOM2 = RANGE_CONTROL_CUSTOM_SETTINGS[selectedUnit]?.step) !== null && _RANGE_CONTROL_CUSTOM2 !== void 0 ? _RANGE_CONTROL_CUSTOM2 : 0.1, 31164 withInputField: false, 31165 onChange: handleSliderChange, 31166 __nextHasNoMarginBottom: true, 31167 label: label, 31168 hideLabelFromVision: true 31169 }) 31170 }) 31171 })] 31172 })] 31173 }); 31174 } 31175 31176 ;// ./node_modules/@wordpress/block-editor/build-module/components/grid/use-get-number-of-blocks-before-cell.js 31177 /** 31178 * WordPress dependencies 31179 */ 31180 31181 31182 /** 31183 * Internal dependencies 31184 */ 31185 31186 function useGetNumberOfBlocksBeforeCell(gridClientId, numColumns) { 31187 const { 31188 getBlockOrder, 31189 getBlockAttributes 31190 } = (0,external_wp_data_namespaceObject.useSelect)(store); 31191 const getNumberOfBlocksBeforeCell = (column, row) => { 31192 const targetIndex = (row - 1) * numColumns + column - 1; 31193 let count = 0; 31194 for (const clientId of getBlockOrder(gridClientId)) { 31195 var _getBlockAttributes$s; 31196 const { 31197 columnStart, 31198 rowStart 31199 } = (_getBlockAttributes$s = getBlockAttributes(clientId).style?.layout) !== null && _getBlockAttributes$s !== void 0 ? _getBlockAttributes$s : {}; 31200 const cellIndex = (rowStart - 1) * numColumns + columnStart - 1; 31201 if (cellIndex < targetIndex) { 31202 count++; 31203 } 31204 } 31205 return count; 31206 }; 31207 return getNumberOfBlocksBeforeCell; 31208 } 31209 31210 ;// ./node_modules/@wordpress/block-editor/build-module/components/child-layout-control/index.js 31211 /** 31212 * WordPress dependencies 31213 */ 31214 31215 31216 31217 31218 31219 /** 31220 * Internal dependencies 31221 */ 31222 31223 31224 31225 31226 31227 function helpText(selfStretch, parentLayout) { 31228 const { 31229 orientation = 'horizontal' 31230 } = parentLayout; 31231 if (selfStretch === 'fill') { 31232 return (0,external_wp_i18n_namespaceObject.__)('Stretch to fill available space.'); 31233 } 31234 if (selfStretch === 'fixed' && orientation === 'horizontal') { 31235 return (0,external_wp_i18n_namespaceObject.__)('Specify a fixed width.'); 31236 } else if (selfStretch === 'fixed') { 31237 return (0,external_wp_i18n_namespaceObject.__)('Specify a fixed height.'); 31238 } 31239 return (0,external_wp_i18n_namespaceObject.__)('Fit contents.'); 31240 } 31241 31242 /** 31243 * Form to edit the child layout value. 31244 * 31245 * @param {Object} props Props. 31246 * @param {Object} props.value The child layout value. 31247 * @param {Function} props.onChange Function to update the child layout value. 31248 * @param {Object} props.parentLayout The parent layout value. 31249 * 31250 * @param {boolean} props.isShownByDefault 31251 * @param {string} props.panelId 31252 * @return {Element} child layout edit element. 31253 */ 31254 function ChildLayoutControl({ 31255 value: childLayout = {}, 31256 onChange, 31257 parentLayout, 31258 isShownByDefault, 31259 panelId 31260 }) { 31261 const { 31262 type: parentType, 31263 default: { 31264 type: defaultParentType = 'default' 31265 } = {} 31266 } = parentLayout !== null && parentLayout !== void 0 ? parentLayout : {}; 31267 const parentLayoutType = parentType || defaultParentType; 31268 if (parentLayoutType === 'flex') { 31269 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexControls, { 31270 childLayout: childLayout, 31271 onChange: onChange, 31272 parentLayout: parentLayout, 31273 isShownByDefault: isShownByDefault, 31274 panelId: panelId 31275 }); 31276 } else if (parentLayoutType === 'grid') { 31277 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridControls, { 31278 childLayout: childLayout, 31279 onChange: onChange, 31280 parentLayout: parentLayout, 31281 isShownByDefault: isShownByDefault, 31282 panelId: panelId 31283 }); 31284 } 31285 return null; 31286 } 31287 function FlexControls({ 31288 childLayout, 31289 onChange, 31290 parentLayout, 31291 isShownByDefault, 31292 panelId 31293 }) { 31294 const { 31295 selfStretch, 31296 flexSize 31297 } = childLayout; 31298 const { 31299 orientation = 'horizontal' 31300 } = parentLayout !== null && parentLayout !== void 0 ? parentLayout : {}; 31301 const hasFlexValue = () => !!selfStretch; 31302 const flexResetLabel = orientation === 'horizontal' ? (0,external_wp_i18n_namespaceObject.__)('Width') : (0,external_wp_i18n_namespaceObject.__)('Height'); 31303 const resetFlex = () => { 31304 onChange({ 31305 selfStretch: undefined, 31306 flexSize: undefined 31307 }); 31308 }; 31309 (0,external_wp_element_namespaceObject.useEffect)(() => { 31310 if (selfStretch === 'fixed' && !flexSize) { 31311 onChange({ 31312 ...childLayout, 31313 selfStretch: 'fit' 31314 }); 31315 } 31316 }, []); 31317 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 31318 as: external_wp_components_namespaceObject.__experimentalToolsPanelItem, 31319 spacing: 2, 31320 hasValue: hasFlexValue, 31321 label: flexResetLabel, 31322 onDeselect: resetFlex, 31323 isShownByDefault: isShownByDefault, 31324 panelId: panelId, 31325 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 31326 __nextHasNoMarginBottom: true, 31327 size: "__unstable-large", 31328 label: childLayoutOrientation(parentLayout), 31329 value: selfStretch || 'fit', 31330 help: helpText(selfStretch, parentLayout), 31331 onChange: value => { 31332 const newFlexSize = value !== 'fixed' ? null : flexSize; 31333 onChange({ 31334 selfStretch: value, 31335 flexSize: newFlexSize 31336 }); 31337 }, 31338 isBlock: true, 31339 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, { 31340 value: "fit", 31341 label: (0,external_wp_i18n_namespaceObject._x)('Fit', 'Intrinsic block width in flex layout') 31342 }, "fit"), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, { 31343 value: "fill", 31344 label: (0,external_wp_i18n_namespaceObject._x)('Grow', 'Block with expanding width in flex layout') 31345 }, "fill"), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, { 31346 value: "fixed", 31347 label: (0,external_wp_i18n_namespaceObject._x)('Fixed', 'Block with fixed width in flex layout') 31348 }, "fixed")] 31349 }), selfStretch === 'fixed' && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 31350 size: "__unstable-large", 31351 onChange: value => { 31352 onChange({ 31353 selfStretch, 31354 flexSize: value 31355 }); 31356 }, 31357 value: flexSize, 31358 label: flexResetLabel, 31359 hideLabelFromVision: true 31360 })] 31361 }); 31362 } 31363 function childLayoutOrientation(parentLayout) { 31364 const { 31365 orientation = 'horizontal' 31366 } = parentLayout; 31367 return orientation === 'horizontal' ? (0,external_wp_i18n_namespaceObject.__)('Width') : (0,external_wp_i18n_namespaceObject.__)('Height'); 31368 } 31369 function GridControls({ 31370 childLayout, 31371 onChange, 31372 parentLayout, 31373 isShownByDefault, 31374 panelId 31375 }) { 31376 const { 31377 columnStart, 31378 rowStart, 31379 columnSpan, 31380 rowSpan 31381 } = childLayout; 31382 const { 31383 columnCount = 3, 31384 rowCount 31385 } = parentLayout !== null && parentLayout !== void 0 ? parentLayout : {}; 31386 const rootClientId = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getBlockRootClientId(panelId)); 31387 const { 31388 moveBlocksToPosition, 31389 __unstableMarkNextChangeAsNotPersistent 31390 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 31391 const getNumberOfBlocksBeforeCell = useGetNumberOfBlocksBeforeCell(rootClientId, columnCount); 31392 const hasStartValue = () => !!columnStart || !!rowStart; 31393 const hasSpanValue = () => !!columnSpan || !!rowSpan; 31394 const resetGridStarts = () => { 31395 onChange({ 31396 columnStart: undefined, 31397 rowStart: undefined 31398 }); 31399 }; 31400 const resetGridSpans = () => { 31401 onChange({ 31402 columnSpan: undefined, 31403 rowSpan: undefined 31404 }); 31405 }; 31406 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 31407 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 31408 as: external_wp_components_namespaceObject.__experimentalToolsPanelItem, 31409 hasValue: hasSpanValue, 31410 label: (0,external_wp_i18n_namespaceObject.__)('Grid span'), 31411 onDeselect: resetGridSpans, 31412 isShownByDefault: isShownByDefault, 31413 panelId: panelId, 31414 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, { 31415 size: "__unstable-large", 31416 label: (0,external_wp_i18n_namespaceObject.__)('Column span'), 31417 type: "number", 31418 onChange: value => { 31419 // Don't allow unsetting. 31420 const newColumnSpan = value === '' ? 1 : parseInt(value, 10); 31421 onChange({ 31422 columnStart, 31423 rowStart, 31424 rowSpan, 31425 columnSpan: newColumnSpan 31426 }); 31427 }, 31428 value: columnSpan !== null && columnSpan !== void 0 ? columnSpan : 1, 31429 min: 1 31430 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, { 31431 size: "__unstable-large", 31432 label: (0,external_wp_i18n_namespaceObject.__)('Row span'), 31433 type: "number", 31434 onChange: value => { 31435 // Don't allow unsetting. 31436 const newRowSpan = value === '' ? 1 : parseInt(value, 10); 31437 onChange({ 31438 columnStart, 31439 rowStart, 31440 columnSpan, 31441 rowSpan: newRowSpan 31442 }); 31443 }, 31444 value: rowSpan !== null && rowSpan !== void 0 ? rowSpan : 1, 31445 min: 1 31446 })] 31447 }), window.__experimentalEnableGridInteractivity && columnCount && 31448 /*#__PURE__*/ 31449 // Use Flex with an explicit width on the FlexItem instead of HStack to 31450 // work around an issue in webkit where inputs with a max attribute are 31451 // sized incorrectly. 31452 (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, { 31453 as: external_wp_components_namespaceObject.__experimentalToolsPanelItem, 31454 hasValue: hasStartValue, 31455 label: (0,external_wp_i18n_namespaceObject.__)('Grid placement'), 31456 onDeselect: resetGridStarts, 31457 isShownByDefault: false, 31458 panelId: panelId, 31459 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 31460 style: { 31461 width: '50%' 31462 }, 31463 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, { 31464 size: "__unstable-large", 31465 label: (0,external_wp_i18n_namespaceObject.__)('Column'), 31466 type: "number", 31467 onChange: value => { 31468 // Don't allow unsetting. 31469 const newColumnStart = value === '' ? 1 : parseInt(value, 10); 31470 onChange({ 31471 columnStart: newColumnStart, 31472 rowStart, 31473 columnSpan, 31474 rowSpan 31475 }); 31476 __unstableMarkNextChangeAsNotPersistent(); 31477 moveBlocksToPosition([panelId], rootClientId, rootClientId, getNumberOfBlocksBeforeCell(newColumnStart, rowStart)); 31478 }, 31479 value: columnStart !== null && columnStart !== void 0 ? columnStart : 1, 31480 min: 1, 31481 max: columnCount ? columnCount - (columnSpan !== null && columnSpan !== void 0 ? columnSpan : 1) + 1 : undefined 31482 }) 31483 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 31484 style: { 31485 width: '50%' 31486 }, 31487 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, { 31488 size: "__unstable-large", 31489 label: (0,external_wp_i18n_namespaceObject.__)('Row'), 31490 type: "number", 31491 onChange: value => { 31492 // Don't allow unsetting. 31493 const newRowStart = value === '' ? 1 : parseInt(value, 10); 31494 onChange({ 31495 columnStart, 31496 rowStart: newRowStart, 31497 columnSpan, 31498 rowSpan 31499 }); 31500 __unstableMarkNextChangeAsNotPersistent(); 31501 moveBlocksToPosition([panelId], rootClientId, rootClientId, getNumberOfBlocksBeforeCell(columnStart, newRowStart)); 31502 }, 31503 value: rowStart !== null && rowStart !== void 0 ? rowStart : 1, 31504 min: 1, 31505 max: rowCount ? rowCount - (rowSpan !== null && rowSpan !== void 0 ? rowSpan : 1) + 1 : undefined 31506 }) 31507 })] 31508 })] 31509 }); 31510 } 31511 31512 ;// ./node_modules/@wordpress/block-editor/build-module/components/dimensions-tool/aspect-ratio-tool.js 31513 /** 31514 * WordPress dependencies 31515 */ 31516 31517 31518 /** 31519 * Internal dependencies 31520 */ 31521 31522 31523 /** 31524 * @typedef {import('@wordpress/components/build-types/select-control/types').SelectControlProps} SelectControlProps 31525 */ 31526 31527 /** 31528 * @callback AspectRatioToolPropsOnChange 31529 * @param {string} [value] New aspect ratio value. 31530 * @return {void} No return. 31531 */ 31532 31533 /** 31534 * @typedef {Object} AspectRatioToolProps 31535 * @property {string} [panelId] ID of the panel this tool is associated with. 31536 * @property {string} [value] Current aspect ratio value. 31537 * @property {AspectRatioToolPropsOnChange} [onChange] Callback to update the aspect ratio value. 31538 * @property {SelectControlProps[]} [options] Aspect ratio options. 31539 * @property {string} [defaultValue] Default aspect ratio value. 31540 * @property {boolean} [isShownByDefault] Whether the tool is shown by default. 31541 */ 31542 31543 function AspectRatioTool({ 31544 panelId, 31545 value, 31546 onChange = () => {}, 31547 options, 31548 defaultValue = 'auto', 31549 hasValue, 31550 isShownByDefault = true 31551 }) { 31552 // Match the CSS default so if the value is used directly in CSS it will look correct in the control. 31553 const displayValue = value !== null && value !== void 0 ? value : 'auto'; 31554 const [defaultRatios, themeRatios, showDefaultRatios] = use_settings_useSettings('dimensions.aspectRatios.default', 'dimensions.aspectRatios.theme', 'dimensions.defaultAspectRatios'); 31555 const themeOptions = themeRatios?.map(({ 31556 name, 31557 ratio 31558 }) => ({ 31559 label: name, 31560 value: ratio 31561 })); 31562 const defaultOptions = defaultRatios?.map(({ 31563 name, 31564 ratio 31565 }) => ({ 31566 label: name, 31567 value: ratio 31568 })); 31569 const aspectRatioOptions = [{ 31570 label: (0,external_wp_i18n_namespaceObject._x)('Original', 'Aspect ratio option for dimensions control'), 31571 value: 'auto' 31572 }, ...(showDefaultRatios ? defaultOptions : []), ...(themeOptions ? themeOptions : []), { 31573 label: (0,external_wp_i18n_namespaceObject._x)('Custom', 'Aspect ratio option for dimensions control'), 31574 value: 'custom', 31575 disabled: true, 31576 hidden: true 31577 }]; 31578 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 31579 hasValue: hasValue ? hasValue : () => displayValue !== defaultValue, 31580 label: (0,external_wp_i18n_namespaceObject.__)('Aspect ratio'), 31581 onDeselect: () => onChange(undefined), 31582 isShownByDefault: isShownByDefault, 31583 panelId: panelId, 31584 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SelectControl, { 31585 label: (0,external_wp_i18n_namespaceObject.__)('Aspect ratio'), 31586 value: displayValue, 31587 options: options !== null && options !== void 0 ? options : aspectRatioOptions, 31588 onChange: onChange, 31589 size: "__unstable-large", 31590 __nextHasNoMarginBottom: true 31591 }) 31592 }); 31593 } 31594 31595 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/dimensions-panel.js 31596 /** 31597 * External dependencies 31598 */ 31599 31600 31601 /** 31602 * WordPress dependencies 31603 */ 31604 31605 31606 31607 31608 31609 /** 31610 * Internal dependencies 31611 */ 31612 31613 31614 31615 31616 31617 31618 31619 31620 31621 const AXIAL_SIDES = ['horizontal', 'vertical']; 31622 function useHasDimensionsPanel(settings) { 31623 const hasContentSize = useHasContentSize(settings); 31624 const hasWideSize = useHasWideSize(settings); 31625 const hasPadding = useHasPadding(settings); 31626 const hasMargin = useHasMargin(settings); 31627 const hasGap = useHasGap(settings); 31628 const hasMinHeight = useHasMinHeight(settings); 31629 const hasAspectRatio = useHasAspectRatio(settings); 31630 const hasChildLayout = useHasChildLayout(settings); 31631 return external_wp_element_namespaceObject.Platform.OS === 'web' && (hasContentSize || hasWideSize || hasPadding || hasMargin || hasGap || hasMinHeight || hasAspectRatio || hasChildLayout); 31632 } 31633 function useHasContentSize(settings) { 31634 return settings?.layout?.contentSize; 31635 } 31636 function useHasWideSize(settings) { 31637 return settings?.layout?.wideSize; 31638 } 31639 function useHasPadding(settings) { 31640 return settings?.spacing?.padding; 31641 } 31642 function useHasMargin(settings) { 31643 return settings?.spacing?.margin; 31644 } 31645 function useHasGap(settings) { 31646 return settings?.spacing?.blockGap; 31647 } 31648 function useHasMinHeight(settings) { 31649 return settings?.dimensions?.minHeight; 31650 } 31651 function useHasAspectRatio(settings) { 31652 return settings?.dimensions?.aspectRatio; 31653 } 31654 function useHasChildLayout(settings) { 31655 var _settings$parentLayou; 31656 const { 31657 type: parentLayoutType = 'default', 31658 default: { 31659 type: defaultParentLayoutType = 'default' 31660 } = {}, 31661 allowSizingOnChildren = false 31662 } = (_settings$parentLayou = settings?.parentLayout) !== null && _settings$parentLayou !== void 0 ? _settings$parentLayou : {}; 31663 const support = (defaultParentLayoutType === 'flex' || parentLayoutType === 'flex' || defaultParentLayoutType === 'grid' || parentLayoutType === 'grid') && allowSizingOnChildren; 31664 return !!settings?.layout && support; 31665 } 31666 function useHasSpacingPresets(settings) { 31667 const { 31668 defaultSpacingSizes, 31669 spacingSizes 31670 } = settings?.spacing || {}; 31671 return defaultSpacingSizes !== false && spacingSizes?.default?.length > 0 || spacingSizes?.theme?.length > 0 || spacingSizes?.custom?.length > 0; 31672 } 31673 function filterValuesBySides(values, sides) { 31674 // If no custom side configuration, all sides are opted into by default. 31675 // Without any values, we have nothing to filter either. 31676 if (!sides || !values) { 31677 return values; 31678 } 31679 31680 // Only include sides opted into within filtered values. 31681 const filteredValues = {}; 31682 sides.forEach(side => { 31683 if (side === 'vertical') { 31684 filteredValues.top = values.top; 31685 filteredValues.bottom = values.bottom; 31686 } 31687 if (side === 'horizontal') { 31688 filteredValues.left = values.left; 31689 filteredValues.right = values.right; 31690 } 31691 filteredValues[side] = values?.[side]; 31692 }); 31693 return filteredValues; 31694 } 31695 function splitStyleValue(value) { 31696 // Check for shorthand value (a string value). 31697 if (value && typeof value === 'string') { 31698 // Convert to value for individual sides for BoxControl. 31699 return { 31700 top: value, 31701 right: value, 31702 bottom: value, 31703 left: value 31704 }; 31705 } 31706 return value; 31707 } 31708 function splitGapValue(value) { 31709 // Check for shorthand value (a string value). 31710 if (value && typeof value === 'string') { 31711 // If the value is a string, treat it as a single side (top) for the spacing controls. 31712 return { 31713 top: value 31714 }; 31715 } 31716 if (value) { 31717 return { 31718 ...value, 31719 right: value?.left, 31720 bottom: value?.top 31721 }; 31722 } 31723 return value; 31724 } 31725 function DimensionsToolsPanel({ 31726 resetAllFilter, 31727 onChange, 31728 value, 31729 panelId, 31730 children 31731 }) { 31732 const dropdownMenuProps = useToolsPanelDropdownMenuProps(); 31733 const resetAll = () => { 31734 const updatedValue = resetAllFilter(value); 31735 onChange(updatedValue); 31736 }; 31737 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, { 31738 label: (0,external_wp_i18n_namespaceObject.__)('Dimensions'), 31739 resetAll: resetAll, 31740 panelId: panelId, 31741 dropdownMenuProps: dropdownMenuProps, 31742 children: children 31743 }); 31744 } 31745 const dimensions_panel_DEFAULT_CONTROLS = { 31746 contentSize: true, 31747 wideSize: true, 31748 padding: true, 31749 margin: true, 31750 blockGap: true, 31751 minHeight: true, 31752 aspectRatio: true, 31753 childLayout: true 31754 }; 31755 function DimensionsPanel({ 31756 as: Wrapper = DimensionsToolsPanel, 31757 value, 31758 onChange, 31759 inheritedValue = value, 31760 settings, 31761 panelId, 31762 defaultControls = dimensions_panel_DEFAULT_CONTROLS, 31763 onVisualize = () => {}, 31764 // Special case because the layout controls are not part of the dimensions panel 31765 // in global styles but not in block inspector. 31766 includeLayoutControls = false 31767 }) { 31768 var _defaultControls$cont, _defaultControls$wide, _defaultControls$padd, _defaultControls$marg, _defaultControls$bloc, _defaultControls$chil, _defaultControls$minH, _defaultControls$aspe; 31769 const { 31770 dimensions, 31771 spacing 31772 } = settings; 31773 const decodeValue = rawValue => { 31774 if (rawValue && typeof rawValue === 'object') { 31775 return Object.keys(rawValue).reduce((acc, key) => { 31776 acc[key] = getValueFromVariable({ 31777 settings: { 31778 dimensions, 31779 spacing 31780 } 31781 }, '', rawValue[key]); 31782 return acc; 31783 }, {}); 31784 } 31785 return getValueFromVariable({ 31786 settings: { 31787 dimensions, 31788 spacing 31789 } 31790 }, '', rawValue); 31791 }; 31792 const showSpacingPresetsControl = useHasSpacingPresets(settings); 31793 const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({ 31794 availableUnits: settings?.spacing?.units || ['%', 'px', 'em', 'rem', 'vw'] 31795 }); 31796 31797 //Minimum Margin Value 31798 const minimumMargin = -Infinity; 31799 const [minMarginValue, setMinMarginValue] = (0,external_wp_element_namespaceObject.useState)(minimumMargin); 31800 31801 // Content Width 31802 const showContentSizeControl = useHasContentSize(settings) && includeLayoutControls; 31803 const contentSizeValue = decodeValue(inheritedValue?.layout?.contentSize); 31804 const setContentSizeValue = newValue => { 31805 onChange(setImmutably(value, ['layout', 'contentSize'], newValue || undefined)); 31806 }; 31807 const hasUserSetContentSizeValue = () => !!value?.layout?.contentSize; 31808 const resetContentSizeValue = () => setContentSizeValue(undefined); 31809 31810 // Wide Width 31811 const showWideSizeControl = useHasWideSize(settings) && includeLayoutControls; 31812 const wideSizeValue = decodeValue(inheritedValue?.layout?.wideSize); 31813 const setWideSizeValue = newValue => { 31814 onChange(setImmutably(value, ['layout', 'wideSize'], newValue || undefined)); 31815 }; 31816 const hasUserSetWideSizeValue = () => !!value?.layout?.wideSize; 31817 const resetWideSizeValue = () => setWideSizeValue(undefined); 31818 31819 // Padding 31820 const showPaddingControl = useHasPadding(settings); 31821 const rawPadding = decodeValue(inheritedValue?.spacing?.padding); 31822 const paddingValues = splitStyleValue(rawPadding); 31823 const paddingSides = Array.isArray(settings?.spacing?.padding) ? settings?.spacing?.padding : settings?.spacing?.padding?.sides; 31824 const isAxialPadding = paddingSides && paddingSides.some(side => AXIAL_SIDES.includes(side)); 31825 const setPaddingValues = newPaddingValues => { 31826 const padding = filterValuesBySides(newPaddingValues, paddingSides); 31827 onChange(setImmutably(value, ['spacing', 'padding'], padding)); 31828 }; 31829 const hasPaddingValue = () => !!value?.spacing?.padding && Object.keys(value?.spacing?.padding).length; 31830 const resetPaddingValue = () => setPaddingValues(undefined); 31831 const onMouseOverPadding = () => onVisualize('padding'); 31832 31833 // Margin 31834 const showMarginControl = useHasMargin(settings); 31835 const rawMargin = decodeValue(inheritedValue?.spacing?.margin); 31836 const marginValues = splitStyleValue(rawMargin); 31837 const marginSides = Array.isArray(settings?.spacing?.margin) ? settings?.spacing?.margin : settings?.spacing?.margin?.sides; 31838 const isAxialMargin = marginSides && marginSides.some(side => AXIAL_SIDES.includes(side)); 31839 const setMarginValues = newMarginValues => { 31840 const margin = filterValuesBySides(newMarginValues, marginSides); 31841 onChange(setImmutably(value, ['spacing', 'margin'], margin)); 31842 }; 31843 const hasMarginValue = () => !!value?.spacing?.margin && Object.keys(value?.spacing?.margin).length; 31844 const resetMarginValue = () => setMarginValues(undefined); 31845 const onMouseOverMargin = () => onVisualize('margin'); 31846 31847 // Block Gap 31848 const showGapControl = useHasGap(settings); 31849 const gapValue = decodeValue(inheritedValue?.spacing?.blockGap); 31850 const gapValues = splitGapValue(gapValue); 31851 const gapSides = Array.isArray(settings?.spacing?.blockGap) ? settings?.spacing?.blockGap : settings?.spacing?.blockGap?.sides; 31852 const isAxialGap = gapSides && gapSides.some(side => AXIAL_SIDES.includes(side)); 31853 const setGapValue = newGapValue => { 31854 onChange(setImmutably(value, ['spacing', 'blockGap'], newGapValue)); 31855 }; 31856 const setGapValues = nextBoxGapValue => { 31857 if (!nextBoxGapValue) { 31858 setGapValue(null); 31859 } 31860 // If axial gap is not enabled, treat the 'top' value as the shorthand gap value. 31861 if (!isAxialGap && nextBoxGapValue?.hasOwnProperty('top')) { 31862 setGapValue(nextBoxGapValue.top); 31863 } else { 31864 setGapValue({ 31865 top: nextBoxGapValue?.top, 31866 left: nextBoxGapValue?.left 31867 }); 31868 } 31869 }; 31870 const resetGapValue = () => setGapValue(undefined); 31871 const hasGapValue = () => !!value?.spacing?.blockGap; 31872 31873 // Min Height 31874 const showMinHeightControl = useHasMinHeight(settings); 31875 const minHeightValue = decodeValue(inheritedValue?.dimensions?.minHeight); 31876 const setMinHeightValue = newValue => { 31877 const tempValue = setImmutably(value, ['dimensions', 'minHeight'], newValue); 31878 // Apply min-height, while removing any applied aspect ratio. 31879 onChange(setImmutably(tempValue, ['dimensions', 'aspectRatio'], undefined)); 31880 }; 31881 const resetMinHeightValue = () => { 31882 setMinHeightValue(undefined); 31883 }; 31884 const hasMinHeightValue = () => !!value?.dimensions?.minHeight; 31885 31886 // Aspect Ratio 31887 const showAspectRatioControl = useHasAspectRatio(settings); 31888 const aspectRatioValue = decodeValue(inheritedValue?.dimensions?.aspectRatio); 31889 const setAspectRatioValue = newValue => { 31890 const tempValue = setImmutably(value, ['dimensions', 'aspectRatio'], newValue); 31891 // Apply aspect-ratio, while removing any applied min-height. 31892 onChange(setImmutably(tempValue, ['dimensions', 'minHeight'], undefined)); 31893 }; 31894 const hasAspectRatioValue = () => !!value?.dimensions?.aspectRatio; 31895 31896 // Child Layout 31897 const showChildLayoutControl = useHasChildLayout(settings); 31898 const childLayout = inheritedValue?.layout; 31899 const setChildLayout = newChildLayout => { 31900 onChange({ 31901 ...value, 31902 layout: { 31903 ...newChildLayout 31904 } 31905 }); 31906 }; 31907 const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue => { 31908 return { 31909 ...previousValue, 31910 layout: utils_cleanEmptyObject({ 31911 ...previousValue?.layout, 31912 contentSize: undefined, 31913 wideSize: undefined, 31914 selfStretch: undefined, 31915 flexSize: undefined, 31916 columnStart: undefined, 31917 rowStart: undefined, 31918 columnSpan: undefined, 31919 rowSpan: undefined 31920 }), 31921 spacing: { 31922 ...previousValue?.spacing, 31923 padding: undefined, 31924 margin: undefined, 31925 blockGap: undefined 31926 }, 31927 dimensions: { 31928 ...previousValue?.dimensions, 31929 minHeight: undefined, 31930 aspectRatio: undefined 31931 } 31932 }; 31933 }, []); 31934 const onMouseLeaveControls = () => onVisualize(false); 31935 const inputProps = { 31936 min: minMarginValue, 31937 onDragStart: () => { 31938 //Reset to 0 in case the value was negative. 31939 setMinMarginValue(0); 31940 }, 31941 onDragEnd: () => { 31942 setMinMarginValue(minimumMargin); 31943 } 31944 }; 31945 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, { 31946 resetAllFilter: resetAllFilter, 31947 value: value, 31948 onChange: onChange, 31949 panelId: panelId, 31950 children: [(showContentSizeControl || showWideSizeControl) && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 31951 className: "span-columns", 31952 children: (0,external_wp_i18n_namespaceObject.__)('Set the width of the main content area.') 31953 }), showContentSizeControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 31954 label: (0,external_wp_i18n_namespaceObject.__)('Content width'), 31955 hasValue: hasUserSetContentSizeValue, 31956 onDeselect: resetContentSizeValue, 31957 isShownByDefault: (_defaultControls$cont = defaultControls.contentSize) !== null && _defaultControls$cont !== void 0 ? _defaultControls$cont : dimensions_panel_DEFAULT_CONTROLS.contentSize, 31958 panelId: panelId, 31959 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 31960 __next40pxDefaultSize: true, 31961 label: (0,external_wp_i18n_namespaceObject.__)('Content width'), 31962 labelPosition: "top", 31963 value: contentSizeValue || '', 31964 onChange: nextContentSize => { 31965 setContentSizeValue(nextContentSize); 31966 }, 31967 units: units, 31968 prefix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlPrefixWrapper, { 31969 variant: "icon", 31970 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 31971 icon: align_none 31972 }) 31973 }) 31974 }) 31975 }), showWideSizeControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 31976 label: (0,external_wp_i18n_namespaceObject.__)('Wide width'), 31977 hasValue: hasUserSetWideSizeValue, 31978 onDeselect: resetWideSizeValue, 31979 isShownByDefault: (_defaultControls$wide = defaultControls.wideSize) !== null && _defaultControls$wide !== void 0 ? _defaultControls$wide : dimensions_panel_DEFAULT_CONTROLS.wideSize, 31980 panelId: panelId, 31981 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 31982 __next40pxDefaultSize: true, 31983 label: (0,external_wp_i18n_namespaceObject.__)('Wide width'), 31984 labelPosition: "top", 31985 value: wideSizeValue || '', 31986 onChange: nextWideSize => { 31987 setWideSizeValue(nextWideSize); 31988 }, 31989 units: units, 31990 prefix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlPrefixWrapper, { 31991 variant: "icon", 31992 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 31993 icon: stretch_wide 31994 }) 31995 }) 31996 }) 31997 }), showPaddingControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 31998 hasValue: hasPaddingValue, 31999 label: (0,external_wp_i18n_namespaceObject.__)('Padding'), 32000 onDeselect: resetPaddingValue, 32001 isShownByDefault: (_defaultControls$padd = defaultControls.padding) !== null && _defaultControls$padd !== void 0 ? _defaultControls$padd : dimensions_panel_DEFAULT_CONTROLS.padding, 32002 className: dist_clsx({ 32003 'tools-panel-item-spacing': showSpacingPresetsControl 32004 }), 32005 panelId: panelId, 32006 children: [!showSpacingPresetsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalBoxControl, { 32007 __next40pxDefaultSize: true, 32008 values: paddingValues, 32009 onChange: setPaddingValues, 32010 label: (0,external_wp_i18n_namespaceObject.__)('Padding'), 32011 sides: paddingSides, 32012 units: units, 32013 allowReset: false, 32014 splitOnAxis: isAxialPadding, 32015 onMouseOver: onMouseOverPadding, 32016 onMouseOut: onMouseLeaveControls 32017 }), showSpacingPresetsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingSizesControl, { 32018 values: paddingValues, 32019 onChange: setPaddingValues, 32020 label: (0,external_wp_i18n_namespaceObject.__)('Padding'), 32021 sides: paddingSides, 32022 units: units, 32023 allowReset: false, 32024 onMouseOver: onMouseOverPadding, 32025 onMouseOut: onMouseLeaveControls 32026 })] 32027 }), showMarginControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 32028 hasValue: hasMarginValue, 32029 label: (0,external_wp_i18n_namespaceObject.__)('Margin'), 32030 onDeselect: resetMarginValue, 32031 isShownByDefault: (_defaultControls$marg = defaultControls.margin) !== null && _defaultControls$marg !== void 0 ? _defaultControls$marg : dimensions_panel_DEFAULT_CONTROLS.margin, 32032 className: dist_clsx({ 32033 'tools-panel-item-spacing': showSpacingPresetsControl 32034 }), 32035 panelId: panelId, 32036 children: [!showSpacingPresetsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalBoxControl, { 32037 __next40pxDefaultSize: true, 32038 values: marginValues, 32039 onChange: setMarginValues, 32040 inputProps: inputProps, 32041 label: (0,external_wp_i18n_namespaceObject.__)('Margin'), 32042 sides: marginSides, 32043 units: units, 32044 allowReset: false, 32045 splitOnAxis: isAxialMargin, 32046 onMouseOver: onMouseOverMargin, 32047 onMouseOut: onMouseLeaveControls 32048 }), showSpacingPresetsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingSizesControl, { 32049 values: marginValues, 32050 onChange: setMarginValues, 32051 minimumCustomValue: -Infinity, 32052 label: (0,external_wp_i18n_namespaceObject.__)('Margin'), 32053 sides: marginSides, 32054 units: units, 32055 allowReset: false, 32056 onMouseOver: onMouseOverMargin, 32057 onMouseOut: onMouseLeaveControls 32058 })] 32059 }), showGapControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 32060 hasValue: hasGapValue, 32061 label: (0,external_wp_i18n_namespaceObject.__)('Block spacing'), 32062 onDeselect: resetGapValue, 32063 isShownByDefault: (_defaultControls$bloc = defaultControls.blockGap) !== null && _defaultControls$bloc !== void 0 ? _defaultControls$bloc : dimensions_panel_DEFAULT_CONTROLS.blockGap, 32064 className: dist_clsx({ 32065 'tools-panel-item-spacing': showSpacingPresetsControl, 32066 'single-column': 32067 // If UnitControl is used, should be single-column. 32068 !showSpacingPresetsControl && !isAxialGap 32069 }), 32070 panelId: panelId, 32071 children: [!showSpacingPresetsControl && (isAxialGap ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalBoxControl, { 32072 __next40pxDefaultSize: true, 32073 label: (0,external_wp_i18n_namespaceObject.__)('Block spacing'), 32074 min: 0, 32075 onChange: setGapValues, 32076 units: units, 32077 sides: gapSides, 32078 values: gapValues, 32079 allowReset: false, 32080 splitOnAxis: isAxialGap 32081 }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 32082 __next40pxDefaultSize: true, 32083 label: (0,external_wp_i18n_namespaceObject.__)('Block spacing'), 32084 min: 0, 32085 onChange: setGapValue, 32086 units: units, 32087 value: gapValue 32088 })), showSpacingPresetsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingSizesControl, { 32089 label: (0,external_wp_i18n_namespaceObject.__)('Block spacing'), 32090 min: 0, 32091 onChange: setGapValues, 32092 showSideInLabel: false, 32093 sides: isAxialGap ? gapSides : ['top'] // Use 'top' as the shorthand property in non-axial configurations. 32094 , 32095 values: gapValues, 32096 allowReset: false 32097 })] 32098 }), showChildLayoutControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ChildLayoutControl, { 32099 value: childLayout, 32100 onChange: setChildLayout, 32101 parentLayout: settings?.parentLayout, 32102 panelId: panelId, 32103 isShownByDefault: (_defaultControls$chil = defaultControls.childLayout) !== null && _defaultControls$chil !== void 0 ? _defaultControls$chil : dimensions_panel_DEFAULT_CONTROLS.childLayout 32104 }), showMinHeightControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 32105 hasValue: hasMinHeightValue, 32106 label: (0,external_wp_i18n_namespaceObject.__)('Minimum height'), 32107 onDeselect: resetMinHeightValue, 32108 isShownByDefault: (_defaultControls$minH = defaultControls.minHeight) !== null && _defaultControls$minH !== void 0 ? _defaultControls$minH : dimensions_panel_DEFAULT_CONTROLS.minHeight, 32109 panelId: panelId, 32110 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(HeightControl, { 32111 label: (0,external_wp_i18n_namespaceObject.__)('Minimum height'), 32112 value: minHeightValue, 32113 onChange: setMinHeightValue 32114 }) 32115 }), showAspectRatioControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioTool, { 32116 hasValue: hasAspectRatioValue, 32117 value: aspectRatioValue, 32118 onChange: setAspectRatioValue, 32119 panelId: panelId, 32120 isShownByDefault: (_defaultControls$aspe = defaultControls.aspectRatio) !== null && _defaultControls$aspe !== void 0 ? _defaultControls$aspe : dimensions_panel_DEFAULT_CONTROLS.aspectRatio 32121 })] 32122 }); 32123 } 32124 32125 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/use-popover-scroll.js 32126 /** 32127 * WordPress dependencies 32128 */ 32129 32130 32131 /** 32132 * Allow scrolling "through" popovers over the canvas. This is only called for 32133 * as long as the pointer is over a popover. Do not use React events because it 32134 * will bubble through portals. 32135 * 32136 * @param {Object} scrollableRef 32137 */ 32138 function usePopoverScroll(scrollableRef) { 32139 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 32140 if (!scrollableRef) { 32141 return; 32142 } 32143 function onWheel(event) { 32144 const { 32145 deltaX, 32146 deltaY 32147 } = event; 32148 scrollableRef.current.scrollBy(deltaX, deltaY); 32149 } 32150 // Tell the browser that we do not call event.preventDefault 32151 // See https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#improving_scrolling_performance_with_passive_listeners 32152 const options = { 32153 passive: true 32154 }; 32155 node.addEventListener('wheel', onWheel, options); 32156 return () => { 32157 node.removeEventListener('wheel', onWheel, options); 32158 }; 32159 }, [scrollableRef]); 32160 } 32161 /* harmony default export */ const use_popover_scroll = (usePopoverScroll); 32162 32163 ;// ./node_modules/@wordpress/block-editor/build-module/utils/dom.js 32164 const BLOCK_SELECTOR = '.block-editor-block-list__block'; 32165 const APPENDER_SELECTOR = '.block-list-appender'; 32166 const BLOCK_APPENDER_CLASS = '.block-editor-button-block-appender'; 32167 32168 /** 32169 * Returns true if two elements are contained within the same block. 32170 * 32171 * @param {Element} a First element. 32172 * @param {Element} b Second element. 32173 * 32174 * @return {boolean} Whether elements are in the same block. 32175 */ 32176 function isInSameBlock(a, b) { 32177 return a.closest(BLOCK_SELECTOR) === b.closest(BLOCK_SELECTOR); 32178 } 32179 32180 /** 32181 * Returns true if an element is considered part of the block and not its inner 32182 * blocks or appender. 32183 * 32184 * @param {Element} blockElement Block container element. 32185 * @param {Element} element Element. 32186 * 32187 * @return {boolean} Whether an element is considered part of the block and not 32188 * its inner blocks or appender. 32189 */ 32190 function isInsideRootBlock(blockElement, element) { 32191 const parentBlock = element.closest([BLOCK_SELECTOR, APPENDER_SELECTOR, BLOCK_APPENDER_CLASS].join(',')); 32192 return parentBlock === blockElement; 32193 } 32194 32195 /** 32196 * Finds the block client ID given any DOM node inside the block. 32197 * 32198 * @param {Node?} node DOM node. 32199 * 32200 * @return {string|undefined} Client ID or undefined if the node is not part of 32201 * a block. 32202 */ 32203 function getBlockClientId(node) { 32204 while (node && node.nodeType !== node.ELEMENT_NODE) { 32205 node = node.parentNode; 32206 } 32207 if (!node) { 32208 return; 32209 } 32210 const elementNode = /** @type {Element} */node; 32211 const blockNode = elementNode.closest(BLOCK_SELECTOR); 32212 if (!blockNode) { 32213 return; 32214 } 32215 return blockNode.id.slice('block-'.length); 32216 } 32217 32218 /** 32219 * Calculates the union of two rectangles. 32220 * 32221 * @param {DOMRect} rect1 First rectangle. 32222 * @param {DOMRect} rect2 Second rectangle. 32223 * @return {DOMRect} Union of the two rectangles. 32224 */ 32225 function rectUnion(rect1, rect2) { 32226 const left = Math.min(rect1.left, rect2.left); 32227 const right = Math.max(rect1.right, rect2.right); 32228 const bottom = Math.max(rect1.bottom, rect2.bottom); 32229 const top = Math.min(rect1.top, rect2.top); 32230 return new window.DOMRectReadOnly(left, top, right - left, bottom - top); 32231 } 32232 32233 /** 32234 * Returns whether an element is visible. 32235 * 32236 * @param {Element} element Element. 32237 * @return {boolean} Whether the element is visible. 32238 */ 32239 function isElementVisible(element) { 32240 const viewport = element.ownerDocument.defaultView; 32241 if (!viewport) { 32242 return false; 32243 } 32244 32245 // Check for <VisuallyHidden> component. 32246 if (element.classList.contains('components-visually-hidden')) { 32247 return false; 32248 } 32249 const bounds = element.getBoundingClientRect(); 32250 if (bounds.width === 0 || bounds.height === 0) { 32251 return false; 32252 } 32253 32254 // Older browsers, e.g. Safari < 17.4 may not support the `checkVisibility` method. 32255 if (element.checkVisibility) { 32256 return element.checkVisibility?.({ 32257 opacityProperty: true, 32258 contentVisibilityAuto: true, 32259 visibilityProperty: true 32260 }); 32261 } 32262 const style = viewport.getComputedStyle(element); 32263 if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') { 32264 return false; 32265 } 32266 return true; 32267 } 32268 32269 /** 32270 * Checks if the element is scrollable. 32271 * 32272 * @param {Element} element Element. 32273 * @return {boolean} True if the element is scrollable. 32274 */ 32275 function isScrollable(element) { 32276 const style = window.getComputedStyle(element); 32277 return style.overflowX === 'auto' || style.overflowX === 'scroll' || style.overflowY === 'auto' || style.overflowY === 'scroll'; 32278 } 32279 const WITH_OVERFLOW_ELEMENT_BLOCKS = ['core/navigation']; 32280 /** 32281 * Returns the bounding rectangle of an element, with special handling for blocks 32282 * that have visible overflowing children (defined in WITH_OVERFLOW_ELEMENT_BLOCKS). 32283 * 32284 * For blocks like Navigation that can have overflowing elements (e.g. submenus), 32285 * this function calculates the combined bounds of both the parent and its visible 32286 * children. The returned rect may extend beyond the viewport. 32287 * The returned rect represents the full extent of the element and its visible 32288 * children, which may extend beyond the viewport. 32289 * 32290 * @param {Element} element Element. 32291 * @return {DOMRect} Bounding client rect of the element and its visible children. 32292 */ 32293 function getElementBounds(element) { 32294 const viewport = element.ownerDocument.defaultView; 32295 if (!viewport) { 32296 return new window.DOMRectReadOnly(); 32297 } 32298 let bounds = element.getBoundingClientRect(); 32299 const dataType = element.getAttribute('data-type'); 32300 32301 /* 32302 * For blocks with overflowing elements (like Navigation), include the bounds 32303 * of visible children that extend beyond the parent container. 32304 */ 32305 if (dataType && WITH_OVERFLOW_ELEMENT_BLOCKS.includes(dataType)) { 32306 const stack = [element]; 32307 let currentElement; 32308 while (currentElement = stack.pop()) { 32309 // Children won’t affect bounds unless the element is not scrollable. 32310 if (!isScrollable(currentElement)) { 32311 for (const child of currentElement.children) { 32312 if (isElementVisible(child)) { 32313 const childBounds = child.getBoundingClientRect(); 32314 bounds = rectUnion(bounds, childBounds); 32315 stack.push(child); 32316 } 32317 } 32318 } 32319 } 32320 } 32321 32322 /* 32323 * Take into account the outer horizontal limits of the container in which 32324 * an element is supposed to be "visible". For example, if an element is 32325 * positioned -10px to the left of the window x value (0), this function 32326 * discounts the negative overhang because it's not visible and therefore 32327 * not to be counted in the visibility calculations. Top and bottom values 32328 * are not accounted for to accommodate vertical scroll. 32329 */ 32330 const left = Math.max(bounds.left, 0); 32331 const right = Math.min(bounds.right, viewport.innerWidth); 32332 bounds = new window.DOMRectReadOnly(left, bounds.top, right - left, bounds.height); 32333 return bounds; 32334 } 32335 32336 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/index.js 32337 /** 32338 * External dependencies 32339 */ 32340 32341 32342 /** 32343 * WordPress dependencies 32344 */ 32345 32346 32347 32348 32349 /** 32350 * Internal dependencies 32351 */ 32352 32353 32354 32355 32356 const MAX_POPOVER_RECOMPUTE_COUNTER = Number.MAX_SAFE_INTEGER; 32357 function BlockPopover({ 32358 clientId, 32359 bottomClientId, 32360 children, 32361 __unstablePopoverSlot, 32362 __unstableContentRef, 32363 shift = true, 32364 ...props 32365 }, ref) { 32366 const selectedElement = useBlockElement(clientId); 32367 const lastSelectedElement = useBlockElement(bottomClientId !== null && bottomClientId !== void 0 ? bottomClientId : clientId); 32368 const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, use_popover_scroll(__unstableContentRef)]); 32369 const [popoverDimensionsRecomputeCounter, forceRecomputePopoverDimensions] = (0,external_wp_element_namespaceObject.useReducer)( 32370 // Module is there to make sure that the counter doesn't overflow. 32371 s => (s + 1) % MAX_POPOVER_RECOMPUTE_COUNTER, 0); 32372 32373 // When blocks are moved up/down, they are animated to their new position by 32374 // updating the `transform` property manually (i.e. without using CSS 32375 // transitions or animations). The animation, which can also scroll the block 32376 // editor, can sometimes cause the position of the Popover to get out of sync. 32377 // A MutationObserver is therefore used to make sure that changes to the 32378 // selectedElement's attribute (i.e. `transform`) can be tracked and used to 32379 // trigger the Popover to rerender. 32380 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 32381 if (!selectedElement) { 32382 return; 32383 } 32384 const observer = new window.MutationObserver(forceRecomputePopoverDimensions); 32385 observer.observe(selectedElement, { 32386 attributes: true 32387 }); 32388 return () => { 32389 observer.disconnect(); 32390 }; 32391 }, [selectedElement]); 32392 const popoverAnchor = (0,external_wp_element_namespaceObject.useMemo)(() => { 32393 if ( 32394 // popoverDimensionsRecomputeCounter is by definition always equal or greater 32395 // than 0. This check is only there to satisfy the correctness of the 32396 // exhaustive-deps rule for the `useMemo` hook. 32397 popoverDimensionsRecomputeCounter < 0 || !selectedElement || bottomClientId && !lastSelectedElement) { 32398 return undefined; 32399 } 32400 return { 32401 getBoundingClientRect() { 32402 return lastSelectedElement ? rectUnion(getElementBounds(selectedElement), getElementBounds(lastSelectedElement)) : getElementBounds(selectedElement); 32403 }, 32404 contextElement: selectedElement 32405 }; 32406 }, [popoverDimensionsRecomputeCounter, selectedElement, bottomClientId, lastSelectedElement]); 32407 if (!selectedElement || bottomClientId && !lastSelectedElement) { 32408 return null; 32409 } 32410 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, { 32411 ref: mergedRefs, 32412 animate: false, 32413 focusOnMount: false, 32414 anchor: popoverAnchor 32415 // Render in the old slot if needed for backward compatibility, 32416 // otherwise render in place (not in the default popover slot). 32417 , 32418 __unstableSlotName: __unstablePopoverSlot, 32419 inline: !__unstablePopoverSlot, 32420 placement: "top-start", 32421 resize: false, 32422 flip: false, 32423 shift: shift, 32424 ...props, 32425 className: dist_clsx('block-editor-block-popover', props.className), 32426 variant: "unstyled", 32427 children: children 32428 }); 32429 } 32430 const PrivateBlockPopover = (0,external_wp_element_namespaceObject.forwardRef)(BlockPopover); 32431 const PublicBlockPopover = ({ 32432 clientId, 32433 bottomClientId, 32434 children, 32435 ...props 32436 }, ref) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockPopover, { 32437 ...props, 32438 bottomClientId: bottomClientId, 32439 clientId: clientId, 32440 __unstableContentRef: undefined, 32441 __unstablePopoverSlot: undefined, 32442 ref: ref, 32443 children: children 32444 }); 32445 32446 /** 32447 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-popover/README.md 32448 */ 32449 /* harmony default export */ const block_popover = ((0,external_wp_element_namespaceObject.forwardRef)(PublicBlockPopover)); 32450 32451 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/cover.js 32452 /** 32453 * WordPress dependencies 32454 */ 32455 32456 32457 /** 32458 * Internal dependencies 32459 */ 32460 32461 32462 32463 function BlockPopoverCover({ 32464 clientId, 32465 bottomClientId, 32466 children, 32467 shift = false, 32468 additionalStyles, 32469 ...props 32470 }, ref) { 32471 var _bottomClientId; 32472 (_bottomClientId = bottomClientId) !== null && _bottomClientId !== void 0 ? _bottomClientId : bottomClientId = clientId; 32473 const selectedElement = useBlockElement(clientId); 32474 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockPopover, { 32475 ref: ref, 32476 clientId: clientId, 32477 bottomClientId: bottomClientId, 32478 shift: shift, 32479 ...props, 32480 children: selectedElement && clientId === bottomClientId ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CoverContainer, { 32481 selectedElement: selectedElement, 32482 additionalStyles: additionalStyles, 32483 children: children 32484 }) : children 32485 }); 32486 } 32487 function CoverContainer({ 32488 selectedElement, 32489 additionalStyles = {}, 32490 children 32491 }) { 32492 const [width, setWidth] = (0,external_wp_element_namespaceObject.useState)(selectedElement.offsetWidth); 32493 const [height, setHeight] = (0,external_wp_element_namespaceObject.useState)(selectedElement.offsetHeight); 32494 (0,external_wp_element_namespaceObject.useEffect)(() => { 32495 const observer = new window.ResizeObserver(() => { 32496 setWidth(selectedElement.offsetWidth); 32497 setHeight(selectedElement.offsetHeight); 32498 }); 32499 observer.observe(selectedElement, { 32500 box: 'border-box' 32501 }); 32502 return () => observer.disconnect(); 32503 }, [selectedElement]); 32504 const style = (0,external_wp_element_namespaceObject.useMemo)(() => { 32505 return { 32506 position: 'absolute', 32507 width, 32508 height, 32509 ...additionalStyles 32510 }; 32511 }, [width, height, additionalStyles]); 32512 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 32513 style: style, 32514 children: children 32515 }); 32516 } 32517 /* harmony default export */ const cover = ((0,external_wp_element_namespaceObject.forwardRef)(BlockPopoverCover)); 32518 32519 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/spacing-visualizer.js 32520 /** 32521 * WordPress dependencies 32522 */ 32523 32524 32525 32526 /** 32527 * Internal dependencies 32528 */ 32529 32530 32531 32532 function SpacingVisualizer({ 32533 clientId, 32534 value, 32535 computeStyle, 32536 forceShow 32537 }) { 32538 const blockElement = useBlockElement(clientId); 32539 const [style, updateStyle] = (0,external_wp_element_namespaceObject.useReducer)(() => computeStyle(blockElement)); 32540 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 32541 if (!blockElement) { 32542 return; 32543 } 32544 // It's not sufficient to read the computed spacing value when value.spacing changes as 32545 // useEffect may run before the browser recomputes CSS. We therefore combine 32546 // useLayoutEffect and two rAF calls to ensure that we read the spacing after the current 32547 // paint but before the next paint. 32548 // See https://github.com/WordPress/gutenberg/pull/59227. 32549 window.requestAnimationFrame(() => window.requestAnimationFrame(updateStyle)); 32550 }, [blockElement, value]); 32551 const previousValueRef = (0,external_wp_element_namespaceObject.useRef)(value); 32552 const [isActive, setIsActive] = (0,external_wp_element_namespaceObject.useState)(false); 32553 (0,external_wp_element_namespaceObject.useEffect)(() => { 32554 if (external_wp_isShallowEqual_default()(value, previousValueRef.current) || forceShow) { 32555 return; 32556 } 32557 setIsActive(true); 32558 previousValueRef.current = value; 32559 const timeout = setTimeout(() => { 32560 setIsActive(false); 32561 }, 400); 32562 return () => { 32563 setIsActive(false); 32564 clearTimeout(timeout); 32565 }; 32566 }, [value, forceShow]); 32567 if (!isActive && !forceShow) { 32568 return null; 32569 } 32570 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, { 32571 clientId: clientId, 32572 __unstablePopoverSlot: "block-toolbar", 32573 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 32574 className: "block-editor__spacing-visualizer", 32575 style: style 32576 }) 32577 }); 32578 } 32579 function getComputedCSS(element, property) { 32580 return element.ownerDocument.defaultView.getComputedStyle(element).getPropertyValue(property); 32581 } 32582 function MarginVisualizer({ 32583 clientId, 32584 value, 32585 forceShow 32586 }) { 32587 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingVisualizer, { 32588 clientId: clientId, 32589 value: value?.spacing?.margin, 32590 computeStyle: blockElement => { 32591 const top = getComputedCSS(blockElement, 'margin-top'); 32592 const right = getComputedCSS(blockElement, 'margin-right'); 32593 const bottom = getComputedCSS(blockElement, 'margin-bottom'); 32594 const left = getComputedCSS(blockElement, 'margin-left'); 32595 return { 32596 borderTopWidth: top, 32597 borderRightWidth: right, 32598 borderBottomWidth: bottom, 32599 borderLeftWidth: left, 32600 top: top ? `-$top}` : 0, 32601 right: right ? `-$right}` : 0, 32602 bottom: bottom ? `-$bottom}` : 0, 32603 left: left ? `-$left}` : 0 32604 }; 32605 }, 32606 forceShow: forceShow 32607 }); 32608 } 32609 function PaddingVisualizer({ 32610 clientId, 32611 value, 32612 forceShow 32613 }) { 32614 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingVisualizer, { 32615 clientId: clientId, 32616 value: value?.spacing?.padding, 32617 computeStyle: blockElement => ({ 32618 borderTopWidth: getComputedCSS(blockElement, 'padding-top'), 32619 borderRightWidth: getComputedCSS(blockElement, 'padding-right'), 32620 borderBottomWidth: getComputedCSS(blockElement, 'padding-bottom'), 32621 borderLeftWidth: getComputedCSS(blockElement, 'padding-left') 32622 }), 32623 forceShow: forceShow 32624 }); 32625 } 32626 32627 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/dimensions.js 32628 /** 32629 * External dependencies 32630 */ 32631 32632 32633 /** 32634 * WordPress dependencies 32635 */ 32636 32637 32638 32639 32640 32641 /** 32642 * Internal dependencies 32643 */ 32644 32645 32646 32647 32648 32649 32650 32651 32652 32653 const DIMENSIONS_SUPPORT_KEY = 'dimensions'; 32654 const SPACING_SUPPORT_KEY = 'spacing'; 32655 const dimensions_ALL_SIDES = (/* unused pure expression or super */ null && (['top', 'right', 'bottom', 'left'])); 32656 const dimensions_AXIAL_SIDES = (/* unused pure expression or super */ null && (['vertical', 'horizontal'])); 32657 function useVisualizer() { 32658 const [property, setProperty] = (0,external_wp_element_namespaceObject.useState)(false); 32659 const { 32660 hideBlockInterface, 32661 showBlockInterface 32662 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 32663 (0,external_wp_element_namespaceObject.useEffect)(() => { 32664 if (!property) { 32665 showBlockInterface(); 32666 } else { 32667 hideBlockInterface(); 32668 } 32669 }, [property, showBlockInterface, hideBlockInterface]); 32670 return [property, setProperty]; 32671 } 32672 function DimensionsInspectorControl({ 32673 children, 32674 resetAllFilter 32675 }) { 32676 const attributesResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes => { 32677 const existingStyle = attributes.style; 32678 const updatedStyle = resetAllFilter(existingStyle); 32679 return { 32680 ...attributes, 32681 style: updatedStyle 32682 }; 32683 }, [resetAllFilter]); 32684 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, { 32685 group: "dimensions", 32686 resetAllFilter: attributesResetAllFilter, 32687 children: children 32688 }); 32689 } 32690 function dimensions_DimensionsPanel({ 32691 clientId, 32692 name, 32693 setAttributes, 32694 settings 32695 }) { 32696 const isEnabled = useHasDimensionsPanel(settings); 32697 const value = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getBlockAttributes(clientId)?.style, [clientId]); 32698 const [visualizedProperty, setVisualizedProperty] = useVisualizer(); 32699 const onChange = newStyle => { 32700 setAttributes({ 32701 style: utils_cleanEmptyObject(newStyle) 32702 }); 32703 }; 32704 if (!isEnabled) { 32705 return null; 32706 } 32707 const defaultDimensionsControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [DIMENSIONS_SUPPORT_KEY, '__experimentalDefaultControls']); 32708 const defaultSpacingControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [SPACING_SUPPORT_KEY, '__experimentalDefaultControls']); 32709 const defaultControls = { 32710 ...defaultDimensionsControls, 32711 ...defaultSpacingControls 32712 }; 32713 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 32714 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DimensionsPanel, { 32715 as: DimensionsInspectorControl, 32716 panelId: clientId, 32717 settings: settings, 32718 value: value, 32719 onChange: onChange, 32720 defaultControls: defaultControls, 32721 onVisualize: setVisualizedProperty 32722 }), !!settings?.spacing?.padding && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PaddingVisualizer, { 32723 forceShow: visualizedProperty === 'padding', 32724 clientId: clientId, 32725 value: value 32726 }), !!settings?.spacing?.margin && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MarginVisualizer, { 32727 forceShow: visualizedProperty === 'margin', 32728 clientId: clientId, 32729 value: value 32730 })] 32731 }); 32732 } 32733 32734 /** 32735 * Determine whether there is block support for dimensions. 32736 * 32737 * @param {string} blockName Block name. 32738 * @param {string} feature Background image feature to check for. 32739 * 32740 * @return {boolean} Whether there is support. 32741 */ 32742 function hasDimensionsSupport(blockName, feature = 'any') { 32743 if (external_wp_element_namespaceObject.Platform.OS !== 'web') { 32744 return false; 32745 } 32746 const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, DIMENSIONS_SUPPORT_KEY); 32747 if (support === true) { 32748 return true; 32749 } 32750 if (feature === 'any') { 32751 return !!(support?.aspectRatio || !!support?.minHeight); 32752 } 32753 return !!support?.[feature]; 32754 } 32755 /* harmony default export */ const dimensions = ({ 32756 useBlockProps: dimensions_useBlockProps, 32757 attributeKeys: ['minHeight', 'style'], 32758 hasSupport(name) { 32759 return hasDimensionsSupport(name, 'aspectRatio'); 32760 } 32761 }); 32762 function dimensions_useBlockProps({ 32763 name, 32764 minHeight, 32765 style 32766 }) { 32767 if (!hasDimensionsSupport(name, 'aspectRatio') || shouldSkipSerialization(name, DIMENSIONS_SUPPORT_KEY, 'aspectRatio')) { 32768 return {}; 32769 } 32770 const className = dist_clsx({ 32771 'has-aspect-ratio': !!style?.dimensions?.aspectRatio 32772 }); 32773 32774 // Allow dimensions-based inline style overrides to override any global styles rules that 32775 // might be set for the block, and therefore affect the display of the aspect ratio. 32776 const inlineStyleOverrides = {}; 32777 32778 // Apply rules to unset incompatible styles. 32779 // Note that a set `aspectRatio` will win out if both an aspect ratio and a minHeight are set. 32780 // This is because the aspect ratio is a newer block support, so (in theory) any aspect ratio 32781 // that is set should be intentional and should override any existing minHeight. The Cover block 32782 // and dimensions controls have logic that will manually clear the aspect ratio if a minHeight 32783 // is set. 32784 if (style?.dimensions?.aspectRatio) { 32785 // To ensure the aspect ratio does not get overridden by `minHeight` unset any existing rule. 32786 inlineStyleOverrides.minHeight = 'unset'; 32787 } else if (minHeight || style?.dimensions?.minHeight) { 32788 // To ensure the minHeight does not get overridden by `aspectRatio` unset any existing rule. 32789 inlineStyleOverrides.aspectRatio = 'unset'; 32790 } 32791 return { 32792 className, 32793 style: inlineStyleOverrides 32794 }; 32795 } 32796 32797 /** 32798 * @deprecated 32799 */ 32800 function useCustomSides() { 32801 external_wp_deprecated_default()('wp.blockEditor.__experimentalUseCustomSides', { 32802 since: '6.3', 32803 version: '6.4' 32804 }); 32805 } 32806 32807 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/style.js 32808 /** 32809 * WordPress dependencies 32810 */ 32811 32812 32813 32814 32815 32816 32817 /** 32818 * Internal dependencies 32819 */ 32820 32821 32822 32823 32824 32825 32826 32827 32828 32829 32830 32831 const styleSupportKeys = [...TYPOGRAPHY_SUPPORT_KEYS, BORDER_SUPPORT_KEY, COLOR_SUPPORT_KEY, DIMENSIONS_SUPPORT_KEY, BACKGROUND_SUPPORT_KEY, SPACING_SUPPORT_KEY, SHADOW_SUPPORT_KEY]; 32832 const hasStyleSupport = nameOrType => styleSupportKeys.some(key => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, key)); 32833 32834 /** 32835 * Returns the inline styles to add depending on the style object 32836 * 32837 * @param {Object} styles Styles configuration. 32838 * 32839 * @return {Object} Flattened CSS variables declaration. 32840 */ 32841 function getInlineStyles(styles = {}) { 32842 const output = {}; 32843 // The goal is to move everything to server side generated engine styles 32844 // This is temporary as we absorb more and more styles into the engine. 32845 (0,external_wp_styleEngine_namespaceObject.getCSSRules)(styles).forEach(rule => { 32846 output[rule.key] = rule.value; 32847 }); 32848 return output; 32849 } 32850 32851 /** 32852 * Filters registered block settings, extending attributes to include `style` attribute. 32853 * 32854 * @param {Object} settings Original block settings. 32855 * 32856 * @return {Object} Filtered block settings. 32857 */ 32858 function style_addAttribute(settings) { 32859 if (!hasStyleSupport(settings)) { 32860 return settings; 32861 } 32862 32863 // Allow blocks to specify their own attribute definition with default values if needed. 32864 if (!settings.attributes.style) { 32865 Object.assign(settings.attributes, { 32866 style: { 32867 type: 'object' 32868 } 32869 }); 32870 } 32871 return settings; 32872 } 32873 32874 /** 32875 * A dictionary of paths to flag skipping block support serialization as the key, 32876 * with values providing the style paths to be omitted from serialization. 32877 * 32878 * @constant 32879 * @type {Record<string, string[]>} 32880 */ 32881 const skipSerializationPathsEdit = { 32882 [`$BORDER_SUPPORT_KEY}.__experimentalSkipSerialization`]: ['border'], 32883 [`$COLOR_SUPPORT_KEY}.__experimentalSkipSerialization`]: [COLOR_SUPPORT_KEY], 32884 [`$TYPOGRAPHY_SUPPORT_KEY}.__experimentalSkipSerialization`]: [TYPOGRAPHY_SUPPORT_KEY], 32885 [`$DIMENSIONS_SUPPORT_KEY}.__experimentalSkipSerialization`]: [DIMENSIONS_SUPPORT_KEY], 32886 [`$SPACING_SUPPORT_KEY}.__experimentalSkipSerialization`]: [SPACING_SUPPORT_KEY], 32887 [`$SHADOW_SUPPORT_KEY}.__experimentalSkipSerialization`]: [SHADOW_SUPPORT_KEY] 32888 }; 32889 32890 /** 32891 * A dictionary of paths to flag skipping block support serialization as the key, 32892 * with values providing the style paths to be omitted from serialization. 32893 * 32894 * Extends the Edit skip paths to enable skipping additional paths in just 32895 * the Save component. This allows a block support to be serialized within the 32896 * editor, while using an alternate approach, such as server-side rendering, when 32897 * the support is saved. 32898 * 32899 * @constant 32900 * @type {Record<string, string[]>} 32901 */ 32902 const skipSerializationPathsSave = { 32903 ...skipSerializationPathsEdit, 32904 [`$DIMENSIONS_SUPPORT_KEY}.aspectRatio`]: [`$DIMENSIONS_SUPPORT_KEY}.aspectRatio`], 32905 // Skip serialization of aspect ratio in save mode. 32906 [`$BACKGROUND_SUPPORT_KEY}`]: [BACKGROUND_SUPPORT_KEY] // Skip serialization of background support in save mode. 32907 }; 32908 const skipSerializationPathsSaveChecks = { 32909 [`$DIMENSIONS_SUPPORT_KEY}.aspectRatio`]: true, 32910 [`$BACKGROUND_SUPPORT_KEY}`]: true 32911 }; 32912 32913 /** 32914 * A dictionary used to normalize feature names between support flags, style 32915 * object properties and __experimentSkipSerialization configuration arrays. 32916 * 32917 * This allows not having to provide a migration for a support flag and possible 32918 * backwards compatibility bridges, while still achieving consistency between 32919 * the support flag and the skip serialization array. 32920 * 32921 * @constant 32922 * @type {Record<string, string>} 32923 */ 32924 const renamedFeatures = { 32925 gradients: 'gradient' 32926 }; 32927 32928 /** 32929 * A utility function used to remove one or more paths from a style object. 32930 * Works in a way similar to Lodash's `omit()`. See unit tests and examples below. 32931 * 32932 * It supports a single string path: 32933 * 32934 * ``` 32935 * omitStyle( { color: 'red' }, 'color' ); // {} 32936 * ``` 32937 * 32938 * or an array of paths: 32939 * 32940 * ``` 32941 * omitStyle( { color: 'red', background: '#fff' }, [ 'color', 'background' ] ); // {} 32942 * ``` 32943 * 32944 * It also allows you to specify paths at multiple levels in a string. 32945 * 32946 * ``` 32947 * omitStyle( { typography: { textDecoration: 'underline' } }, 'typography.textDecoration' ); // {} 32948 * ``` 32949 * 32950 * You can remove multiple paths at the same time: 32951 * 32952 * ``` 32953 * omitStyle( 32954 * { 32955 * typography: { 32956 * textDecoration: 'underline', 32957 * textTransform: 'uppercase', 32958 * } 32959 * }, 32960 * [ 32961 * 'typography.textDecoration', 32962 * 'typography.textTransform', 32963 * ] 32964 * ); 32965 * // {} 32966 * ``` 32967 * 32968 * You can also specify nested paths as arrays: 32969 * 32970 * ``` 32971 * omitStyle( 32972 * { 32973 * typography: { 32974 * textDecoration: 'underline', 32975 * textTransform: 'uppercase', 32976 * } 32977 * }, 32978 * [ 32979 * [ 'typography', 'textDecoration' ], 32980 * [ 'typography', 'textTransform' ], 32981 * ] 32982 * ); 32983 * // {} 32984 * ``` 32985 * 32986 * With regards to nesting of styles, infinite depth is supported: 32987 * 32988 * ``` 32989 * omitStyle( 32990 * { 32991 * border: { 32992 * radius: { 32993 * topLeft: '10px', 32994 * topRight: '0.5rem', 32995 * } 32996 * } 32997 * }, 32998 * [ 32999 * [ 'border', 'radius', 'topRight' ], 33000 * ] 33001 * ); 33002 * // { border: { radius: { topLeft: '10px' } } } 33003 * ``` 33004 * 33005 * The third argument, `preserveReference`, defines how to treat the input style object. 33006 * It is mostly necessary to properly handle mutation when recursively handling the style object. 33007 * Defaulting to `false`, this will always create a new object, avoiding to mutate `style`. 33008 * However, when recursing, we change that value to `true` in order to work with a single copy 33009 * of the original style object. 33010 * 33011 * @see https://lodash.com/docs/4.17.15#omit 33012 * 33013 * @param {Object} style Styles object. 33014 * @param {Array|string} paths Paths to remove. 33015 * @param {boolean} preserveReference True to mutate the `style` object, false otherwise. 33016 * @return {Object} Styles object with the specified paths removed. 33017 */ 33018 function omitStyle(style, paths, preserveReference = false) { 33019 if (!style) { 33020 return style; 33021 } 33022 let newStyle = style; 33023 if (!preserveReference) { 33024 newStyle = JSON.parse(JSON.stringify(style)); 33025 } 33026 if (!Array.isArray(paths)) { 33027 paths = [paths]; 33028 } 33029 paths.forEach(path => { 33030 if (!Array.isArray(path)) { 33031 path = path.split('.'); 33032 } 33033 if (path.length > 1) { 33034 const [firstSubpath, ...restPath] = path; 33035 omitStyle(newStyle[firstSubpath], [restPath], true); 33036 } else if (path.length === 1) { 33037 delete newStyle[path[0]]; 33038 } 33039 }); 33040 return newStyle; 33041 } 33042 33043 /** 33044 * Override props assigned to save component to inject the CSS variables definition. 33045 * 33046 * @param {Object} props Additional props applied to save element. 33047 * @param {Object|string} blockNameOrType Block type. 33048 * @param {Object} attributes Block attributes. 33049 * @param {?Record<string, string[]>} skipPaths An object of keys and paths to skip serialization. 33050 * 33051 * @return {Object} Filtered props applied to save element. 33052 */ 33053 function style_addSaveProps(props, blockNameOrType, attributes, skipPaths = skipSerializationPathsSave) { 33054 if (!hasStyleSupport(blockNameOrType)) { 33055 return props; 33056 } 33057 let { 33058 style 33059 } = attributes; 33060 Object.entries(skipPaths).forEach(([indicator, path]) => { 33061 const skipSerialization = skipSerializationPathsSaveChecks[indicator] || (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockNameOrType, indicator); 33062 if (skipSerialization === true) { 33063 style = omitStyle(style, path); 33064 } 33065 if (Array.isArray(skipSerialization)) { 33066 skipSerialization.forEach(featureName => { 33067 const feature = renamedFeatures[featureName] || featureName; 33068 style = omitStyle(style, [[...path, feature]]); 33069 }); 33070 } 33071 }); 33072 props.style = { 33073 ...getInlineStyles(style), 33074 ...props.style 33075 }; 33076 return props; 33077 } 33078 function BlockStyleControls({ 33079 clientId, 33080 name, 33081 setAttributes, 33082 __unstableParentLayout 33083 }) { 33084 const settings = useBlockSettings(name, __unstableParentLayout); 33085 const blockEditingMode = useBlockEditingMode(); 33086 const passedProps = { 33087 clientId, 33088 name, 33089 setAttributes, 33090 settings: { 33091 ...settings, 33092 typography: { 33093 ...settings.typography, 33094 // The text alignment UI for individual blocks is rendered in 33095 // the block toolbar, so disable it here. 33096 textAlign: false 33097 } 33098 } 33099 }; 33100 if (blockEditingMode !== 'default') { 33101 return null; 33102 } 33103 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 33104 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorEdit, { 33105 ...passedProps 33106 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(background_BackgroundImagePanel, { 33107 ...passedProps 33108 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(typography_TypographyPanel, { 33109 ...passedProps 33110 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(border_BorderPanel, { 33111 ...passedProps 33112 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(dimensions_DimensionsPanel, { 33113 ...passedProps 33114 })] 33115 }); 33116 } 33117 /* harmony default export */ const style = ({ 33118 edit: BlockStyleControls, 33119 hasSupport: hasStyleSupport, 33120 addSaveProps: style_addSaveProps, 33121 attributeKeys: ['style'], 33122 useBlockProps: style_useBlockProps 33123 }); 33124 33125 // Defines which element types are supported, including their hover styles or 33126 // any other elements that have been included under a single element type 33127 // e.g. heading and h1-h6. 33128 const elementTypes = [{ 33129 elementType: 'button' 33130 }, { 33131 elementType: 'link', 33132 pseudo: [':hover'] 33133 }, { 33134 elementType: 'heading', 33135 elements: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] 33136 }]; 33137 function style_useBlockProps({ 33138 name, 33139 style 33140 }) { 33141 const blockElementsContainerIdentifier = `wp-elements-${(0,external_wp_compose_namespaceObject.useInstanceId)(style_useBlockProps)}`; 33142 const baseElementSelector = `.$blockElementsContainerIdentifier}`; 33143 const blockElementStyles = style?.elements; 33144 const styles = (0,external_wp_element_namespaceObject.useMemo)(() => { 33145 if (!blockElementStyles) { 33146 return; 33147 } 33148 const elementCSSRules = []; 33149 elementTypes.forEach(({ 33150 elementType, 33151 pseudo, 33152 elements 33153 }) => { 33154 const skipSerialization = shouldSkipSerialization(name, COLOR_SUPPORT_KEY, elementType); 33155 if (skipSerialization) { 33156 return; 33157 } 33158 const elementStyles = blockElementStyles?.[elementType]; 33159 33160 // Process primary element type styles. 33161 if (elementStyles) { 33162 const selector = scopeSelector(baseElementSelector, external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[elementType]); 33163 elementCSSRules.push((0,external_wp_styleEngine_namespaceObject.compileCSS)(elementStyles, { 33164 selector 33165 })); 33166 33167 // Process any interactive states for the element type. 33168 if (pseudo) { 33169 pseudo.forEach(pseudoSelector => { 33170 if (elementStyles[pseudoSelector]) { 33171 elementCSSRules.push((0,external_wp_styleEngine_namespaceObject.compileCSS)(elementStyles[pseudoSelector], { 33172 selector: scopeSelector(baseElementSelector, `$external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[elementType]}$pseudoSelector}`) 33173 })); 33174 } 33175 }); 33176 } 33177 } 33178 33179 // Process related elements e.g. h1-h6 for headings 33180 if (elements) { 33181 elements.forEach(element => { 33182 if (blockElementStyles[element]) { 33183 elementCSSRules.push((0,external_wp_styleEngine_namespaceObject.compileCSS)(blockElementStyles[element], { 33184 selector: scopeSelector(baseElementSelector, external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[element]) 33185 })); 33186 } 33187 }); 33188 } 33189 }); 33190 return elementCSSRules.length > 0 ? elementCSSRules.join('') : undefined; 33191 }, [baseElementSelector, blockElementStyles, name]); 33192 useStyleOverride({ 33193 css: styles 33194 }); 33195 return style_addSaveProps({ 33196 className: blockElementsContainerIdentifier 33197 }, name, { 33198 style 33199 }, skipSerializationPathsEdit); 33200 } 33201 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/style/addAttribute', style_addAttribute); 33202 33203 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/settings.js 33204 /** 33205 * WordPress dependencies 33206 */ 33207 33208 33209 const hasSettingsSupport = blockType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, '__experimentalSettings', false); 33210 function settings_addAttribute(settings) { 33211 if (!hasSettingsSupport(settings)) { 33212 return settings; 33213 } 33214 33215 // Allow blocks to specify their own attribute definition with default values if needed. 33216 if (!settings?.attributes?.settings) { 33217 settings.attributes = { 33218 ...settings.attributes, 33219 settings: { 33220 type: 'object' 33221 } 33222 }; 33223 } 33224 return settings; 33225 } 33226 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/settings/addAttribute', settings_addAttribute); 33227 33228 ;// ./node_modules/@wordpress/icons/build-module/library/filter.js 33229 /** 33230 * WordPress dependencies 33231 */ 33232 33233 33234 const filter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 33235 xmlns: "http://www.w3.org/2000/svg", 33236 viewBox: "0 0 24 24", 33237 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 33238 d: "M12 4 4 19h16L12 4zm0 3.2 5.5 10.3H12V7.2z" 33239 }) 33240 }); 33241 /* harmony default export */ const library_filter = (filter); 33242 33243 ;// ./node_modules/@wordpress/block-editor/build-module/components/duotone-control/index.js 33244 /** 33245 * WordPress dependencies 33246 */ 33247 33248 33249 33250 33251 33252 33253 33254 function DuotoneControl({ 33255 id: idProp, 33256 colorPalette, 33257 duotonePalette, 33258 disableCustomColors, 33259 disableCustomDuotone, 33260 value, 33261 onChange 33262 }) { 33263 let toolbarIcon; 33264 if (value === 'unset') { 33265 toolbarIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorIndicator, { 33266 className: "block-editor-duotone-control__unset-indicator" 33267 }); 33268 } else if (value) { 33269 toolbarIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DuotoneSwatch, { 33270 values: value 33271 }); 33272 } else { 33273 toolbarIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 33274 icon: library_filter 33275 }); 33276 } 33277 const actionLabel = (0,external_wp_i18n_namespaceObject.__)('Apply duotone filter'); 33278 const id = (0,external_wp_compose_namespaceObject.useInstanceId)(DuotoneControl, 'duotone-control', idProp); 33279 const descriptionId = `$id}__description`; 33280 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 33281 popoverProps: { 33282 className: 'block-editor-duotone-control__popover', 33283 headerTitle: (0,external_wp_i18n_namespaceObject.__)('Duotone') 33284 }, 33285 renderToggle: ({ 33286 isOpen, 33287 onToggle 33288 }) => { 33289 const openOnArrowDown = event => { 33290 if (!isOpen && event.keyCode === external_wp_keycodes_namespaceObject.DOWN) { 33291 event.preventDefault(); 33292 onToggle(); 33293 } 33294 }; 33295 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 33296 showTooltip: true, 33297 onClick: onToggle, 33298 "aria-haspopup": "true", 33299 "aria-expanded": isOpen, 33300 onKeyDown: openOnArrowDown, 33301 label: actionLabel, 33302 icon: toolbarIcon 33303 }); 33304 }, 33305 renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, { 33306 label: (0,external_wp_i18n_namespaceObject.__)('Duotone'), 33307 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 33308 children: (0,external_wp_i18n_namespaceObject.__)('Create a two-tone color effect without losing your original image.') 33309 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DuotonePicker, { 33310 "aria-label": actionLabel, 33311 "aria-describedby": descriptionId, 33312 colorPalette: colorPalette, 33313 duotonePalette: duotonePalette, 33314 disableCustomColors: disableCustomColors, 33315 disableCustomDuotone: disableCustomDuotone, 33316 value: value, 33317 onChange: onChange 33318 })] 33319 }) 33320 }); 33321 } 33322 /* harmony default export */ const duotone_control = (DuotoneControl); 33323 33324 ;// ./node_modules/@wordpress/block-editor/build-module/components/duotone/utils.js 33325 /** 33326 * External dependencies 33327 */ 33328 33329 33330 /** 33331 * Convert a list of colors to an object of R, G, and B values. 33332 * 33333 * @param {string[]} colors Array of RBG color strings. 33334 * 33335 * @return {Object} R, G, and B values. 33336 */ 33337 function getValuesFromColors(colors = []) { 33338 const values = { 33339 r: [], 33340 g: [], 33341 b: [], 33342 a: [] 33343 }; 33344 colors.forEach(color => { 33345 const rgbColor = w(color).toRgb(); 33346 values.r.push(rgbColor.r / 255); 33347 values.g.push(rgbColor.g / 255); 33348 values.b.push(rgbColor.b / 255); 33349 values.a.push(rgbColor.a); 33350 }); 33351 return values; 33352 } 33353 33354 /** 33355 * Stylesheet for disabling a global styles duotone filter. 33356 * 33357 * @param {string} selector Selector to disable the filter for. 33358 * 33359 * @return {string} Filter none style. 33360 */ 33361 function getDuotoneUnsetStylesheet(selector) { 33362 return `$selector}{filter:none}`; 33363 } 33364 33365 /** 33366 * SVG and stylesheet needed for rendering the duotone filter. 33367 * 33368 * @param {string} selector Selector to apply the filter to. 33369 * @param {string} id Unique id for this duotone filter. 33370 * 33371 * @return {string} Duotone filter style. 33372 */ 33373 function getDuotoneStylesheet(selector, id) { 33374 return `$selector}{filter:url(#$id})}`; 33375 } 33376 33377 /** 33378 * The SVG part of the duotone filter. 33379 * 33380 * @param {string} id Unique id for this duotone filter. 33381 * @param {string[]} colors Color strings from dark to light. 33382 * 33383 * @return {string} Duotone SVG. 33384 */ 33385 function getDuotoneFilter(id, colors) { 33386 const values = getValuesFromColors(colors); 33387 return ` 33388 <svg 33389 xmlns:xlink="http://www.w3.org/1999/xlink" 33390 viewBox="0 0 0 0" 33391 width="0" 33392 height="0" 33393 focusable="false" 33394 role="none" 33395 aria-hidden="true" 33396 style="visibility: hidden; position: absolute; left: -9999px; overflow: hidden;" 33397 > 33398 <defs> 33399 <filter id="$id}"> 33400 <!-- 33401 Use sRGB instead of linearRGB so transparency looks correct. 33402 Use perceptual brightness to convert to grayscale. 33403 --> 33404 <feColorMatrix color-interpolation-filters="sRGB" type="matrix" values=" .299 .587 .114 0 0 .299 .587 .114 0 0 .299 .587 .114 0 0 .299 .587 .114 0 0 "></feColorMatrix> 33405 <!-- Use sRGB instead of linearRGB to be consistent with how CSS gradients work. --> 33406 <feComponentTransfer color-interpolation-filters="sRGB"> 33407 <feFuncR type="table" tableValues="$values.r.join(' ')}"></feFuncR> 33408 <feFuncG type="table" tableValues="$values.g.join(' ')}"></feFuncG> 33409 <feFuncB type="table" tableValues="$values.b.join(' ')}"></feFuncB> 33410 <feFuncA type="table" tableValues="$values.a.join(' ')}"></feFuncA> 33411 </feComponentTransfer> 33412 <!-- Re-mask the image with the original transparency since the feColorMatrix above loses that information. --> 33413 <feComposite in2="SourceGraphic" operator="in"></feComposite> 33414 </filter> 33415 </defs> 33416 </svg>`; 33417 } 33418 33419 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/get-block-css-selector.js 33420 /** 33421 * Internal dependencies 33422 */ 33423 33424 33425 33426 /** 33427 * Determine the CSS selector for the block type and target provided, returning 33428 * it if available. 33429 * 33430 * @param {import('@wordpress/blocks').Block} blockType The block's type. 33431 * @param {string|string[]} target The desired selector's target e.g. `root`, delimited string, or array path. 33432 * @param {Object} options Options object. 33433 * @param {boolean} options.fallback Whether or not to fallback to broader selector. 33434 * 33435 * @return {?string} The CSS selector or `null` if no selector available. 33436 */ 33437 function getBlockCSSSelector(blockType, target = 'root', options = {}) { 33438 if (!target) { 33439 return null; 33440 } 33441 const { 33442 fallback = false 33443 } = options; 33444 const { 33445 name, 33446 selectors, 33447 supports 33448 } = blockType; 33449 const hasSelectors = selectors && Object.keys(selectors).length > 0; 33450 const path = Array.isArray(target) ? target.join('.') : target; 33451 33452 // Root selector. 33453 33454 // Calculated before returning as it can be used as a fallback for feature 33455 // selectors later on. 33456 let rootSelector = null; 33457 if (hasSelectors && selectors.root) { 33458 // Use the selectors API if available. 33459 rootSelector = selectors?.root; 33460 } else if (supports?.__experimentalSelector) { 33461 // Use the old experimental selector supports property if set. 33462 rootSelector = supports.__experimentalSelector; 33463 } else { 33464 // If no root selector found, generate default block class selector. 33465 rootSelector = '.wp-block-' + name.replace('core/', '').replace('/', '-'); 33466 } 33467 33468 // Return selector if it's the root target we are looking for. 33469 if (path === 'root') { 33470 return rootSelector; 33471 } 33472 33473 // If target is not `root` or `duotone` we have a feature or subfeature 33474 // as the target. If the target is a string convert to an array. 33475 const pathArray = Array.isArray(target) ? target : target.split('.'); 33476 33477 // Feature selectors ( may fallback to root selector ); 33478 if (pathArray.length === 1) { 33479 const fallbackSelector = fallback ? rootSelector : null; 33480 33481 // Prefer the selectors API if available. 33482 if (hasSelectors) { 33483 // Get selector from either `feature.root` or shorthand path. 33484 const featureSelector = getValueFromObjectPath(selectors, `$path}.root`, null) || getValueFromObjectPath(selectors, path, null); 33485 33486 // Return feature selector if found or any available fallback. 33487 return featureSelector || fallbackSelector; 33488 } 33489 33490 // Try getting old experimental supports selector value. 33491 const featureSelector = getValueFromObjectPath(supports, `$path}.__experimentalSelector`, null); 33492 33493 // If nothing to work with, provide fallback selector if available. 33494 if (!featureSelector) { 33495 return fallbackSelector; 33496 } 33497 33498 // Scope the feature selector by the block's root selector. 33499 return scopeSelector(rootSelector, featureSelector); 33500 } 33501 33502 // Subfeature selector. 33503 // This may fallback either to parent feature or root selector. 33504 let subfeatureSelector; 33505 33506 // Use selectors API if available. 33507 if (hasSelectors) { 33508 subfeatureSelector = getValueFromObjectPath(selectors, path, null); 33509 } 33510 33511 // Only return if we have a subfeature selector. 33512 if (subfeatureSelector) { 33513 return subfeatureSelector; 33514 } 33515 33516 // To this point we don't have a subfeature selector. If a fallback has been 33517 // requested, remove subfeature from target path and return results of a 33518 // call for the parent feature's selector. 33519 if (fallback) { 33520 return getBlockCSSSelector(blockType, pathArray[0], options); 33521 } 33522 33523 // We tried. 33524 return null; 33525 } 33526 33527 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/filters-panel.js 33528 /** 33529 * External dependencies 33530 */ 33531 33532 33533 /** 33534 * WordPress dependencies 33535 */ 33536 33537 33538 33539 33540 /** 33541 * Internal dependencies 33542 */ 33543 33544 33545 33546 33547 const filters_panel_EMPTY_ARRAY = []; 33548 function useMultiOriginColorPresets(settings, { 33549 presetSetting, 33550 defaultSetting 33551 }) { 33552 const disableDefault = !settings?.color?.[defaultSetting]; 33553 const userPresets = settings?.color?.[presetSetting]?.custom || filters_panel_EMPTY_ARRAY; 33554 const themePresets = settings?.color?.[presetSetting]?.theme || filters_panel_EMPTY_ARRAY; 33555 const defaultPresets = settings?.color?.[presetSetting]?.default || filters_panel_EMPTY_ARRAY; 33556 return (0,external_wp_element_namespaceObject.useMemo)(() => [...userPresets, ...themePresets, ...(disableDefault ? filters_panel_EMPTY_ARRAY : defaultPresets)], [disableDefault, userPresets, themePresets, defaultPresets]); 33557 } 33558 function useHasFiltersPanel(settings) { 33559 return useHasDuotoneControl(settings); 33560 } 33561 function useHasDuotoneControl(settings) { 33562 return settings.color.customDuotone || settings.color.defaultDuotone || settings.color.duotone.length > 0; 33563 } 33564 function FiltersToolsPanel({ 33565 resetAllFilter, 33566 onChange, 33567 value, 33568 panelId, 33569 children 33570 }) { 33571 const dropdownMenuProps = useToolsPanelDropdownMenuProps(); 33572 const resetAll = () => { 33573 const updatedValue = resetAllFilter(value); 33574 onChange(updatedValue); 33575 }; 33576 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, { 33577 label: (0,external_wp_i18n_namespaceObject._x)('Filters', 'Name for applying graphical effects'), 33578 resetAll: resetAll, 33579 panelId: panelId, 33580 dropdownMenuProps: dropdownMenuProps, 33581 children: children 33582 }); 33583 } 33584 const filters_panel_DEFAULT_CONTROLS = { 33585 duotone: true 33586 }; 33587 const filters_panel_popoverProps = { 33588 placement: 'left-start', 33589 offset: 36, 33590 shift: true, 33591 className: 'block-editor-duotone-control__popover', 33592 headerTitle: (0,external_wp_i18n_namespaceObject.__)('Duotone') 33593 }; 33594 const LabeledColorIndicator = ({ 33595 indicator, 33596 label 33597 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 33598 justify: "flex-start", 33599 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalZStack, { 33600 isLayered: false, 33601 offset: -8, 33602 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Flex, { 33603 expanded: false, 33604 children: indicator === 'unset' || !indicator ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorIndicator, { 33605 className: "block-editor-duotone-control__unset-indicator" 33606 }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DuotoneSwatch, { 33607 values: indicator 33608 }) 33609 }) 33610 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 33611 title: label, 33612 children: label 33613 })] 33614 }); 33615 function FiltersPanel({ 33616 as: Wrapper = FiltersToolsPanel, 33617 value, 33618 onChange, 33619 inheritedValue = value, 33620 settings, 33621 panelId, 33622 defaultControls = filters_panel_DEFAULT_CONTROLS 33623 }) { 33624 const decodeValue = rawValue => getValueFromVariable({ 33625 settings 33626 }, '', rawValue); 33627 33628 // Duotone 33629 const hasDuotoneEnabled = useHasDuotoneControl(settings); 33630 const duotonePalette = useMultiOriginColorPresets(settings, { 33631 presetSetting: 'duotone', 33632 defaultSetting: 'defaultDuotone' 33633 }); 33634 const colorPalette = useMultiOriginColorPresets(settings, { 33635 presetSetting: 'palette', 33636 defaultSetting: 'defaultPalette' 33637 }); 33638 const duotone = decodeValue(inheritedValue?.filter?.duotone); 33639 const setDuotone = newValue => { 33640 const duotonePreset = duotonePalette.find(({ 33641 colors 33642 }) => { 33643 return colors === newValue; 33644 }); 33645 const settedValue = duotonePreset ? `var:preset|duotone|$duotonePreset.slug}` : newValue; 33646 onChange(setImmutably(value, ['filter', 'duotone'], settedValue)); 33647 }; 33648 const hasDuotone = () => !!value?.filter?.duotone; 33649 const resetDuotone = () => setDuotone(undefined); 33650 const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue => { 33651 return { 33652 ...previousValue, 33653 filter: { 33654 ...previousValue.filter, 33655 duotone: undefined 33656 } 33657 }; 33658 }, []); 33659 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Wrapper, { 33660 resetAllFilter: resetAllFilter, 33661 value: value, 33662 onChange: onChange, 33663 panelId: panelId, 33664 children: hasDuotoneEnabled && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 33665 label: (0,external_wp_i18n_namespaceObject.__)('Duotone'), 33666 hasValue: hasDuotone, 33667 onDeselect: resetDuotone, 33668 isShownByDefault: defaultControls.duotone, 33669 panelId: panelId, 33670 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 33671 popoverProps: filters_panel_popoverProps, 33672 className: "block-editor-global-styles-filters-panel__dropdown", 33673 renderToggle: ({ 33674 onToggle, 33675 isOpen 33676 }) => { 33677 const toggleProps = { 33678 onClick: onToggle, 33679 className: dist_clsx({ 33680 'is-open': isOpen 33681 }), 33682 'aria-expanded': isOpen 33683 }; 33684 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, { 33685 isBordered: true, 33686 isSeparated: true, 33687 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 33688 __next40pxDefaultSize: true, 33689 ...toggleProps, 33690 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LabeledColorIndicator, { 33691 indicator: duotone, 33692 label: (0,external_wp_i18n_namespaceObject.__)('Duotone') 33693 }) 33694 }) 33695 }); 33696 }, 33697 renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, { 33698 paddingSize: "small", 33699 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, { 33700 label: (0,external_wp_i18n_namespaceObject.__)('Duotone'), 33701 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 33702 children: (0,external_wp_i18n_namespaceObject.__)('Create a two-tone color effect without losing your original image.') 33703 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DuotonePicker, { 33704 colorPalette: colorPalette, 33705 duotonePalette: duotonePalette 33706 // TODO: Re-enable both when custom colors are supported for block-level styles. 33707 , 33708 disableCustomColors: true, 33709 disableCustomDuotone: true, 33710 value: duotone, 33711 onChange: setDuotone 33712 })] 33713 }) 33714 }) 33715 }) 33716 }) 33717 }); 33718 } 33719 33720 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/duotone.js 33721 /** 33722 * External dependencies 33723 */ 33724 33725 33726 33727 /** 33728 * WordPress dependencies 33729 */ 33730 33731 33732 33733 33734 33735 /** 33736 * Internal dependencies 33737 */ 33738 33739 33740 33741 33742 33743 33744 33745 33746 33747 33748 33749 const duotone_EMPTY_ARRAY = []; 33750 33751 // Safari does not always update the duotone filter when the duotone colors 33752 // are changed. This browser check is later used to force a re-render of the block 33753 // element to ensure the duotone filter is updated. The check is included at the 33754 // root of this file as it only needs to be run once per page load. 33755 const isSafari = window?.navigator.userAgent && window.navigator.userAgent.includes('Safari') && !window.navigator.userAgent.includes('Chrome') && !window.navigator.userAgent.includes('Chromium'); 33756 k([names]); 33757 function useMultiOriginPresets({ 33758 presetSetting, 33759 defaultSetting 33760 }) { 33761 const [enableDefault, userPresets, themePresets, defaultPresets] = use_settings_useSettings(defaultSetting, `$presetSetting}.custom`, `$presetSetting}.theme`, `$presetSetting}.default`); 33762 return (0,external_wp_element_namespaceObject.useMemo)(() => [...(userPresets || duotone_EMPTY_ARRAY), ...(themePresets || duotone_EMPTY_ARRAY), ...(enableDefault && defaultPresets || duotone_EMPTY_ARRAY)], [enableDefault, userPresets, themePresets, defaultPresets]); 33763 } 33764 function getColorsFromDuotonePreset(duotone, duotonePalette) { 33765 if (!duotone) { 33766 return; 33767 } 33768 const preset = duotonePalette?.find(({ 33769 slug 33770 }) => { 33771 return duotone === `var:preset|duotone|$slug}`; 33772 }); 33773 return preset ? preset.colors : undefined; 33774 } 33775 function getDuotonePresetFromColors(colors, duotonePalette) { 33776 if (!colors || !Array.isArray(colors)) { 33777 return; 33778 } 33779 const preset = duotonePalette?.find(duotonePreset => { 33780 return duotonePreset?.colors?.every((val, index) => val === colors[index]); 33781 }); 33782 return preset ? `var:preset|duotone|$preset.slug}` : undefined; 33783 } 33784 function DuotonePanelPure({ 33785 style, 33786 setAttributes, 33787 name 33788 }) { 33789 const duotoneStyle = style?.color?.duotone; 33790 const settings = useBlockSettings(name); 33791 const blockEditingMode = useBlockEditingMode(); 33792 const duotonePalette = useMultiOriginPresets({ 33793 presetSetting: 'color.duotone', 33794 defaultSetting: 'color.defaultDuotone' 33795 }); 33796 const colorPalette = useMultiOriginPresets({ 33797 presetSetting: 'color.palette', 33798 defaultSetting: 'color.defaultPalette' 33799 }); 33800 const [enableCustomColors, enableCustomDuotone] = use_settings_useSettings('color.custom', 'color.customDuotone'); 33801 const disableCustomColors = !enableCustomColors; 33802 const disableCustomDuotone = !enableCustomDuotone || colorPalette?.length === 0 && disableCustomColors; 33803 if (duotonePalette?.length === 0 && disableCustomDuotone) { 33804 return null; 33805 } 33806 if (blockEditingMode !== 'default') { 33807 return null; 33808 } 33809 const duotonePresetOrColors = !Array.isArray(duotoneStyle) ? getColorsFromDuotonePreset(duotoneStyle, duotonePalette) : duotoneStyle; 33810 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 33811 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, { 33812 group: "filter", 33813 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FiltersPanel, { 33814 value: { 33815 filter: { 33816 duotone: duotonePresetOrColors 33817 } 33818 }, 33819 onChange: newDuotone => { 33820 const newStyle = { 33821 ...style, 33822 color: { 33823 ...newDuotone?.filter 33824 } 33825 }; 33826 setAttributes({ 33827 style: newStyle 33828 }); 33829 }, 33830 settings: settings 33831 }) 33832 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, { 33833 group: "block", 33834 __experimentalShareWithChildBlocks: true, 33835 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(duotone_control, { 33836 duotonePalette: duotonePalette, 33837 colorPalette: colorPalette, 33838 disableCustomDuotone: disableCustomDuotone, 33839 disableCustomColors: disableCustomColors, 33840 value: duotonePresetOrColors, 33841 onChange: newDuotone => { 33842 const maybePreset = getDuotonePresetFromColors(newDuotone, duotonePalette); 33843 const newStyle = { 33844 ...style, 33845 color: { 33846 ...style?.color, 33847 duotone: maybePreset !== null && maybePreset !== void 0 ? maybePreset : newDuotone // use preset or fallback to custom colors. 33848 } 33849 }; 33850 setAttributes({ 33851 style: newStyle 33852 }); 33853 }, 33854 settings: settings 33855 }) 33856 })] 33857 }); 33858 } 33859 /* harmony default export */ const duotone = ({ 33860 shareWithChildBlocks: true, 33861 edit: DuotonePanelPure, 33862 useBlockProps: duotone_useBlockProps, 33863 attributeKeys: ['style'], 33864 hasSupport(name) { 33865 return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'filter.duotone'); 33866 } 33867 }); 33868 33869 /** 33870 * Filters registered block settings, extending attributes to include 33871 * the `duotone` attribute. 33872 * 33873 * @param {Object} settings Original block settings. 33874 * 33875 * @return {Object} Filtered block settings. 33876 */ 33877 function addDuotoneAttributes(settings) { 33878 // Previous `color.__experimentalDuotone` support flag is migrated via 33879 // block_type_metadata_settings filter in `lib/block-supports/duotone.php`. 33880 if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'filter.duotone')) { 33881 return settings; 33882 } 33883 33884 // Allow blocks to specify their own attribute definition with default 33885 // values if needed. 33886 if (!settings.attributes.style) { 33887 Object.assign(settings.attributes, { 33888 style: { 33889 type: 'object' 33890 } 33891 }); 33892 } 33893 return settings; 33894 } 33895 function useDuotoneStyles({ 33896 clientId, 33897 id: filterId, 33898 selector: duotoneSelector, 33899 attribute: duotoneAttr 33900 }) { 33901 const duotonePalette = useMultiOriginPresets({ 33902 presetSetting: 'color.duotone', 33903 defaultSetting: 'color.defaultDuotone' 33904 }); 33905 33906 // Possible values for duotone attribute: 33907 // 1. Array of colors - e.g. ['#000000', '#ffffff']. 33908 // 2. Variable for an existing Duotone preset - e.g. 'var:preset|duotone|green-blue' or 'var(--wp--preset--duotone--green-blue)'' 33909 // 3. A CSS string - e.g. 'unset' to remove globally applied duotone. 33910 const isCustom = Array.isArray(duotoneAttr); 33911 const duotonePreset = isCustom ? undefined : getColorsFromDuotonePreset(duotoneAttr, duotonePalette); 33912 const isPreset = typeof duotoneAttr === 'string' && duotonePreset; 33913 const isCSS = typeof duotoneAttr === 'string' && !isPreset; 33914 33915 // Match the structure of WP_Duotone_Gutenberg::render_duotone_support() in PHP. 33916 let colors = null; 33917 if (isPreset) { 33918 // Array of colors. 33919 colors = duotonePreset; 33920 } else if (isCSS) { 33921 // CSS filter property string (e.g. 'unset'). 33922 colors = duotoneAttr; 33923 } else if (isCustom) { 33924 // Array of colors. 33925 colors = duotoneAttr; 33926 } 33927 33928 // Build the CSS selectors to which the filter will be applied. 33929 const selectors = duotoneSelector.split(','); 33930 const selectorsScoped = selectors.map(selectorPart => { 33931 // Assuming the selector part is a subclass selector (not a tag name) 33932 // so we can prepend the filter id class. If we want to support elements 33933 // such as `img` or namespaces, we'll need to add a case for that here. 33934 return `.$filterId}$selectorPart.trim()}`; 33935 }); 33936 const selector = selectorsScoped.join(', '); 33937 const isValidFilter = Array.isArray(colors) || colors === 'unset'; 33938 usePrivateStyleOverride(isValidFilter ? { 33939 css: colors !== 'unset' ? getDuotoneStylesheet(selector, filterId) : getDuotoneUnsetStylesheet(selector), 33940 __unstableType: 'presets' 33941 } : undefined); 33942 usePrivateStyleOverride(isValidFilter ? { 33943 assets: colors !== 'unset' ? getDuotoneFilter(filterId, colors) : '', 33944 __unstableType: 'svgs' 33945 } : undefined); 33946 const blockElement = useBlockElement(clientId); 33947 (0,external_wp_element_namespaceObject.useEffect)(() => { 33948 if (!isValidFilter) { 33949 return; 33950 } 33951 33952 // Safari does not always update the duotone filter when the duotone 33953 // colors are changed. When using Safari, force the block element to be 33954 // repainted by the browser to ensure any changes are reflected 33955 // visually. This logic matches that used on the site frontend in 33956 // `block-supports/duotone.php`. 33957 if (blockElement && isSafari) { 33958 const display = blockElement.style.display; 33959 // Switch to `inline-block` to force a repaint. In the editor, 33960 // `inline-block` is used instead of `none` to ensure that scroll 33961 // position is not affected, as `none` results in the editor 33962 // scrolling to the top of the block. 33963 blockElement.style.display = 'inline-block'; 33964 // Simply accessing el.offsetHeight flushes layout and style changes 33965 // in WebKit without having to wait for setTimeout. 33966 // eslint-disable-next-line no-unused-expressions 33967 blockElement.offsetHeight; 33968 blockElement.style.display = display; 33969 } 33970 // `colors` must be a dependency so this effect runs when the colors 33971 // change in Safari. 33972 }, [isValidFilter, blockElement, colors]); 33973 } 33974 function duotone_useBlockProps({ 33975 clientId, 33976 name, 33977 style 33978 }) { 33979 const id = (0,external_wp_compose_namespaceObject.useInstanceId)(duotone_useBlockProps); 33980 const selector = (0,external_wp_element_namespaceObject.useMemo)(() => { 33981 const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name); 33982 if (blockType) { 33983 // Backwards compatibility for `supports.color.__experimentalDuotone` 33984 // is provided via the `block_type_metadata_settings` filter. If 33985 // `supports.filter.duotone` has not been set and the 33986 // experimental property has been, the experimental property 33987 // value is copied into `supports.filter.duotone`. 33988 const duotoneSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, 'filter.duotone', false); 33989 if (!duotoneSupport) { 33990 return null; 33991 } 33992 33993 // If the experimental duotone support was set, that value is 33994 // to be treated as a selector and requires scoping. 33995 const experimentalDuotone = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, 'color.__experimentalDuotone', false); 33996 if (experimentalDuotone) { 33997 const rootSelector = getBlockCSSSelector(blockType); 33998 return typeof experimentalDuotone === 'string' ? scopeSelector(rootSelector, experimentalDuotone) : rootSelector; 33999 } 34000 34001 // Regular filter.duotone support uses filter.duotone selectors with fallbacks. 34002 return getBlockCSSSelector(blockType, 'filter.duotone', { 34003 fallback: true 34004 }); 34005 } 34006 }, [name]); 34007 const attribute = style?.color?.duotone; 34008 const filterClass = `wp-duotone-$id}`; 34009 const shouldRender = selector && attribute; 34010 useDuotoneStyles({ 34011 clientId, 34012 id: filterClass, 34013 selector, 34014 attribute 34015 }); 34016 return { 34017 className: shouldRender ? filterClass : '' 34018 }; 34019 } 34020 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/editor/duotone/add-attributes', addDuotoneAttributes); 34021 34022 ;// ./node_modules/@wordpress/block-editor/build-module/components/use-block-display-information/index.js 34023 /** 34024 * WordPress dependencies 34025 */ 34026 34027 34028 34029 34030 /** 34031 * Internal dependencies 34032 */ 34033 34034 34035 /** @typedef {import('@wordpress/blocks').WPIcon} WPIcon */ 34036 34037 /** 34038 * Contains basic block's information for display reasons. 34039 * 34040 * @typedef {Object} WPBlockDisplayInformation 34041 * 34042 * @property {boolean} isSynced True if is a reusable block or template part 34043 * @property {string} title Human-readable block type label. 34044 * @property {WPIcon} icon Block type icon. 34045 * @property {string} description A detailed block type description. 34046 * @property {string} anchor HTML anchor. 34047 * @property {name} name A custom, human readable name for the block. 34048 */ 34049 34050 /** 34051 * Get the display label for a block's position type. 34052 * 34053 * @param {Object} attributes Block attributes. 34054 * @return {string} The position type label. 34055 */ 34056 function getPositionTypeLabel(attributes) { 34057 const positionType = attributes?.style?.position?.type; 34058 if (positionType === 'sticky') { 34059 return (0,external_wp_i18n_namespaceObject.__)('Sticky'); 34060 } 34061 if (positionType === 'fixed') { 34062 return (0,external_wp_i18n_namespaceObject.__)('Fixed'); 34063 } 34064 return null; 34065 } 34066 34067 /** 34068 * Hook used to try to find a matching block variation and return 34069 * the appropriate information for display reasons. In order to 34070 * to try to find a match we need to things: 34071 * 1. Block's client id to extract it's current attributes. 34072 * 2. A block variation should have set `isActive` prop to a proper function. 34073 * 34074 * If for any reason a block variation match cannot be found, 34075 * the returned information come from the Block Type. 34076 * If no blockType is found with the provided clientId, returns null. 34077 * 34078 * @param {string} clientId Block's client id. 34079 * @return {?WPBlockDisplayInformation} Block's display information, or `null` when the block or its type not found. 34080 */ 34081 34082 function useBlockDisplayInformation(clientId) { 34083 return (0,external_wp_data_namespaceObject.useSelect)(select => { 34084 if (!clientId) { 34085 return null; 34086 } 34087 const { 34088 getBlockName, 34089 getBlockAttributes 34090 } = select(store); 34091 const { 34092 getBlockType, 34093 getActiveBlockVariation 34094 } = select(external_wp_blocks_namespaceObject.store); 34095 const blockName = getBlockName(clientId); 34096 const blockType = getBlockType(blockName); 34097 if (!blockType) { 34098 return null; 34099 } 34100 const attributes = getBlockAttributes(clientId); 34101 const match = getActiveBlockVariation(blockName, attributes); 34102 const isSynced = (0,external_wp_blocks_namespaceObject.isReusableBlock)(blockType) || (0,external_wp_blocks_namespaceObject.isTemplatePart)(blockType); 34103 const syncedTitle = isSynced ? (0,external_wp_blocks_namespaceObject.__experimentalGetBlockLabel)(blockType, attributes) : undefined; 34104 const title = syncedTitle || blockType.title; 34105 const positionLabel = getPositionTypeLabel(attributes); 34106 const blockTypeInfo = { 34107 isSynced, 34108 title, 34109 icon: blockType.icon, 34110 description: blockType.description, 34111 anchor: attributes?.anchor, 34112 positionLabel, 34113 positionType: attributes?.style?.position?.type, 34114 name: attributes?.metadata?.name 34115 }; 34116 if (!match) { 34117 return blockTypeInfo; 34118 } 34119 return { 34120 isSynced, 34121 title: match.title || blockType.title, 34122 icon: match.icon || blockType.icon, 34123 description: match.description || blockType.description, 34124 anchor: attributes?.anchor, 34125 positionLabel, 34126 positionType: attributes?.style?.position?.type, 34127 name: attributes?.metadata?.name 34128 }; 34129 }, [clientId]); 34130 } 34131 34132 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/position.js 34133 /** 34134 * External dependencies 34135 */ 34136 34137 34138 /** 34139 * WordPress dependencies 34140 */ 34141 34142 34143 34144 34145 34146 34147 34148 /** 34149 * Internal dependencies 34150 */ 34151 34152 34153 34154 34155 34156 34157 const POSITION_SUPPORT_KEY = 'position'; 34158 const DEFAULT_OPTION = { 34159 key: 'default', 34160 value: '', 34161 name: (0,external_wp_i18n_namespaceObject.__)('Default') 34162 }; 34163 const STICKY_OPTION = { 34164 key: 'sticky', 34165 value: 'sticky', 34166 name: (0,external_wp_i18n_namespaceObject._x)('Sticky', 'Name for the value of the CSS position property'), 34167 hint: (0,external_wp_i18n_namespaceObject.__)('The block will stick to the top of the window instead of scrolling.') 34168 }; 34169 const FIXED_OPTION = { 34170 key: 'fixed', 34171 value: 'fixed', 34172 name: (0,external_wp_i18n_namespaceObject._x)('Fixed', 'Name for the value of the CSS position property'), 34173 hint: (0,external_wp_i18n_namespaceObject.__)('The block will not move when the page is scrolled.') 34174 }; 34175 const POSITION_SIDES = ['top', 'right', 'bottom', 'left']; 34176 const VALID_POSITION_TYPES = ['sticky', 'fixed']; 34177 34178 /** 34179 * Get calculated position CSS. 34180 * 34181 * @param {Object} props Component props. 34182 * @param {string} props.selector Selector to use. 34183 * @param {Object} props.style Style object. 34184 * @return {string} The generated CSS rules. 34185 */ 34186 function getPositionCSS({ 34187 selector, 34188 style 34189 }) { 34190 let output = ''; 34191 const { 34192 type: positionType 34193 } = style?.position || {}; 34194 if (!VALID_POSITION_TYPES.includes(positionType)) { 34195 return output; 34196 } 34197 output += `$selector} {`; 34198 output += `position: $positionType};`; 34199 POSITION_SIDES.forEach(side => { 34200 if (style?.position?.[side] !== undefined) { 34201 output += `$side}: $style.position[side]};`; 34202 } 34203 }); 34204 if (positionType === 'sticky' || positionType === 'fixed') { 34205 // TODO: Replace hard-coded z-index value with a z-index preset approach in theme.json. 34206 output += `z-index: 10`; 34207 } 34208 output += `}`; 34209 return output; 34210 } 34211 34212 /** 34213 * Determines if there is sticky position support. 34214 * 34215 * @param {string|Object} blockType Block name or Block Type object. 34216 * 34217 * @return {boolean} Whether there is support. 34218 */ 34219 function hasStickyPositionSupport(blockType) { 34220 const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, POSITION_SUPPORT_KEY); 34221 return !!(true === support || support?.sticky); 34222 } 34223 34224 /** 34225 * Determines if there is fixed position support. 34226 * 34227 * @param {string|Object} blockType Block name or Block Type object. 34228 * 34229 * @return {boolean} Whether there is support. 34230 */ 34231 function hasFixedPositionSupport(blockType) { 34232 const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, POSITION_SUPPORT_KEY); 34233 return !!(true === support || support?.fixed); 34234 } 34235 34236 /** 34237 * Determines if there is position support. 34238 * 34239 * @param {string|Object} blockType Block name or Block Type object. 34240 * 34241 * @return {boolean} Whether there is support. 34242 */ 34243 function hasPositionSupport(blockType) { 34244 const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, POSITION_SUPPORT_KEY); 34245 return !!support; 34246 } 34247 34248 /** 34249 * Checks if there is a current value in the position block support attributes. 34250 * 34251 * @param {Object} props Block props. 34252 * @return {boolean} Whether or not the block has a position value set. 34253 */ 34254 function hasPositionValue(props) { 34255 return props.attributes.style?.position?.type !== undefined; 34256 } 34257 34258 /** 34259 * Checks if the block is currently set to a sticky or fixed position. 34260 * This check is helpful for determining how to position block toolbars or other elements. 34261 * 34262 * @param {Object} attributes Block attributes. 34263 * @return {boolean} Whether or not the block is set to a sticky or fixed position. 34264 */ 34265 function hasStickyOrFixedPositionValue(attributes) { 34266 const positionType = attributes?.style?.position?.type; 34267 return positionType === 'sticky' || positionType === 'fixed'; 34268 } 34269 34270 /** 34271 * Resets the position block support attributes. This can be used when disabling 34272 * the position support controls for a block via a `ToolsPanel`. 34273 * 34274 * @param {Object} props Block props. 34275 * @param {Object} props.attributes Block's attributes. 34276 * @param {Object} props.setAttributes Function to set block's attributes. 34277 */ 34278 function resetPosition({ 34279 attributes = {}, 34280 setAttributes 34281 }) { 34282 const { 34283 style = {} 34284 } = attributes; 34285 setAttributes({ 34286 style: cleanEmptyObject({ 34287 ...style, 34288 position: { 34289 ...style?.position, 34290 type: undefined, 34291 top: undefined, 34292 right: undefined, 34293 bottom: undefined, 34294 left: undefined 34295 } 34296 }) 34297 }); 34298 } 34299 34300 /** 34301 * Custom hook that checks if position settings have been disabled. 34302 * 34303 * @param {string} name The name of the block. 34304 * 34305 * @return {boolean} Whether padding setting is disabled. 34306 */ 34307 function useIsPositionDisabled({ 34308 name: blockName 34309 } = {}) { 34310 const [allowFixed, allowSticky] = use_settings_useSettings('position.fixed', 'position.sticky'); 34311 const isDisabled = !allowFixed && !allowSticky; 34312 return !hasPositionSupport(blockName) || isDisabled; 34313 } 34314 34315 /* 34316 * Position controls rendered in an inspector control panel. 34317 * 34318 * @param {Object} props 34319 * 34320 * @return {Element} Position panel. 34321 */ 34322 function PositionPanelPure({ 34323 style = {}, 34324 clientId, 34325 name: blockName, 34326 setAttributes 34327 }) { 34328 const allowFixed = hasFixedPositionSupport(blockName); 34329 const allowSticky = hasStickyPositionSupport(blockName); 34330 const value = style?.position?.type; 34331 const { 34332 firstParentClientId 34333 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 34334 const { 34335 getBlockParents 34336 } = select(store); 34337 const parents = getBlockParents(clientId); 34338 return { 34339 firstParentClientId: parents[parents.length - 1] 34340 }; 34341 }, [clientId]); 34342 const blockInformation = useBlockDisplayInformation(firstParentClientId); 34343 const stickyHelpText = allowSticky && value === STICKY_OPTION.value && blockInformation ? (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: the name of the parent block. */ 34344 (0,external_wp_i18n_namespaceObject.__)('The block will stick to the scrollable area of the parent %s block.'), blockInformation.title) : null; 34345 const options = (0,external_wp_element_namespaceObject.useMemo)(() => { 34346 const availableOptions = [DEFAULT_OPTION]; 34347 // Display options if they are allowed, or if a block already has a valid value set. 34348 // This allows for a block to be switched off from a position type that is not allowed. 34349 if (allowSticky || value === STICKY_OPTION.value) { 34350 availableOptions.push(STICKY_OPTION); 34351 } 34352 if (allowFixed || value === FIXED_OPTION.value) { 34353 availableOptions.push(FIXED_OPTION); 34354 } 34355 return availableOptions; 34356 }, [allowFixed, allowSticky, value]); 34357 const onChangeType = next => { 34358 // For now, use a hard-coded `0px` value for the position. 34359 // `0px` is preferred over `0` as it can be used in `calc()` functions. 34360 // In the future, it could be useful to allow for an offset value. 34361 const placementValue = '0px'; 34362 const newStyle = { 34363 ...style, 34364 position: { 34365 ...style?.position, 34366 type: next, 34367 top: next === 'sticky' || next === 'fixed' ? placementValue : undefined 34368 } 34369 }; 34370 setAttributes({ 34371 style: utils_cleanEmptyObject(newStyle) 34372 }); 34373 }; 34374 const selectedOption = value ? options.find(option => option.value === value) || DEFAULT_OPTION : DEFAULT_OPTION; 34375 34376 // Only display position controls if there is at least one option to choose from. 34377 return external_wp_element_namespaceObject.Platform.select({ 34378 web: options.length > 1 ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, { 34379 group: "position", 34380 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl, { 34381 __nextHasNoMarginBottom: true, 34382 help: stickyHelpText, 34383 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, { 34384 __next40pxDefaultSize: true, 34385 label: (0,external_wp_i18n_namespaceObject.__)('Position'), 34386 hideLabelFromVision: true, 34387 describedBy: (0,external_wp_i18n_namespaceObject.sprintf)( 34388 // translators: %s: Currently selected position. 34389 (0,external_wp_i18n_namespaceObject.__)('Currently selected position: %s'), selectedOption.name), 34390 options: options, 34391 value: selectedOption, 34392 onChange: ({ 34393 selectedItem 34394 }) => { 34395 onChangeType(selectedItem.value); 34396 }, 34397 size: "__unstable-large" 34398 }) 34399 }) 34400 }) : null, 34401 native: null 34402 }); 34403 } 34404 /* harmony default export */ const position = ({ 34405 edit: function Edit(props) { 34406 const isPositionDisabled = useIsPositionDisabled(props); 34407 if (isPositionDisabled) { 34408 return null; 34409 } 34410 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PositionPanelPure, { 34411 ...props 34412 }); 34413 }, 34414 useBlockProps: position_useBlockProps, 34415 attributeKeys: ['style'], 34416 hasSupport(name) { 34417 return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, POSITION_SUPPORT_KEY); 34418 } 34419 }); 34420 function position_useBlockProps({ 34421 name, 34422 style 34423 }) { 34424 const hasPositionBlockSupport = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, POSITION_SUPPORT_KEY); 34425 const isPositionDisabled = useIsPositionDisabled({ 34426 name 34427 }); 34428 const allowPositionStyles = hasPositionBlockSupport && !isPositionDisabled; 34429 const id = (0,external_wp_compose_namespaceObject.useInstanceId)(position_useBlockProps); 34430 34431 // Higher specificity to override defaults in editor UI. 34432 const positionSelector = `.wp-container-$id}.wp-container-$id}`; 34433 34434 // Get CSS string for the current position values. 34435 let css; 34436 if (allowPositionStyles) { 34437 css = getPositionCSS({ 34438 selector: positionSelector, 34439 style 34440 }) || ''; 34441 } 34442 34443 // Attach a `wp-container-` id-based class name. 34444 const className = dist_clsx({ 34445 [`wp-container-$id}`]: allowPositionStyles && !!css, 34446 // Only attach a container class if there is generated CSS to be attached. 34447 [`is-position-$style?.position?.type}`]: allowPositionStyles && !!css && !!style?.position?.type 34448 }); 34449 useStyleOverride({ 34450 css 34451 }); 34452 return { 34453 className 34454 }; 34455 } 34456 34457 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/use-global-styles-output.js 34458 /** 34459 * WordPress dependencies 34460 */ 34461 34462 34463 34464 34465 34466 34467 /** 34468 * Internal dependencies 34469 */ 34470 34471 34472 34473 34474 34475 34476 34477 34478 34479 34480 34481 34482 34483 // Elements that rely on class names in their selectors. 34484 const ELEMENT_CLASS_NAMES = { 34485 button: 'wp-element-button', 34486 caption: 'wp-element-caption' 34487 }; 34488 34489 // List of block support features that can have their related styles 34490 // generated under their own feature level selector rather than the block's. 34491 const BLOCK_SUPPORT_FEATURE_LEVEL_SELECTORS = { 34492 __experimentalBorder: 'border', 34493 color: 'color', 34494 spacing: 'spacing', 34495 typography: 'typography' 34496 }; 34497 const { 34498 kebabCase: use_global_styles_output_kebabCase 34499 } = unlock(external_wp_components_namespaceObject.privateApis); 34500 34501 /** 34502 * Transform given preset tree into a set of style declarations. 34503 * 34504 * @param {Object} blockPresets 34505 * @param {Object} mergedSettings Merged theme.json settings. 34506 * 34507 * @return {Array<Object>} An array of style declarations. 34508 */ 34509 function getPresetsDeclarations(blockPresets = {}, mergedSettings) { 34510 return PRESET_METADATA.reduce((declarations, { 34511 path, 34512 valueKey, 34513 valueFunc, 34514 cssVarInfix 34515 }) => { 34516 const presetByOrigin = getValueFromObjectPath(blockPresets, path, []); 34517 ['default', 'theme', 'custom'].forEach(origin => { 34518 if (presetByOrigin[origin]) { 34519 presetByOrigin[origin].forEach(value => { 34520 if (valueKey && !valueFunc) { 34521 declarations.push(`--wp--preset--$cssVarInfix}--$use_global_styles_output_kebabCase(value.slug)}: $value[valueKey]}`); 34522 } else if (valueFunc && typeof valueFunc === 'function') { 34523 declarations.push(`--wp--preset--$cssVarInfix}--$use_global_styles_output_kebabCase(value.slug)}: $valueFunc(value, mergedSettings)}`); 34524 } 34525 }); 34526 } 34527 }); 34528 return declarations; 34529 }, []); 34530 } 34531 34532 /** 34533 * Transform given preset tree into a set of preset class declarations. 34534 * 34535 * @param {?string} blockSelector 34536 * @param {Object} blockPresets 34537 * @return {string} CSS declarations for the preset classes. 34538 */ 34539 function getPresetsClasses(blockSelector = '*', blockPresets = {}) { 34540 return PRESET_METADATA.reduce((declarations, { 34541 path, 34542 cssVarInfix, 34543 classes 34544 }) => { 34545 if (!classes) { 34546 return declarations; 34547 } 34548 const presetByOrigin = getValueFromObjectPath(blockPresets, path, []); 34549 ['default', 'theme', 'custom'].forEach(origin => { 34550 if (presetByOrigin[origin]) { 34551 presetByOrigin[origin].forEach(({ 34552 slug 34553 }) => { 34554 classes.forEach(({ 34555 classSuffix, 34556 propertyName 34557 }) => { 34558 const classSelectorToUse = `.has-$use_global_styles_output_kebabCase(slug)}-$classSuffix}`; 34559 const selectorToUse = blockSelector.split(',') // Selector can be "h1, h2, h3" 34560 .map(selector => `$selector}$classSelectorToUse}`).join(','); 34561 const value = `var(--wp--preset--$cssVarInfix}--$use_global_styles_output_kebabCase(slug)})`; 34562 declarations += `$selectorToUse}{$propertyName}: $value} !important;}`; 34563 }); 34564 }); 34565 } 34566 }); 34567 return declarations; 34568 }, ''); 34569 } 34570 function getPresetsSvgFilters(blockPresets = {}) { 34571 return PRESET_METADATA.filter( 34572 // Duotone are the only type of filters for now. 34573 metadata => metadata.path.at(-1) === 'duotone').flatMap(metadata => { 34574 const presetByOrigin = getValueFromObjectPath(blockPresets, metadata.path, {}); 34575 return ['default', 'theme'].filter(origin => presetByOrigin[origin]).flatMap(origin => presetByOrigin[origin].map(preset => getDuotoneFilter(`wp-duotone-$preset.slug}`, preset.colors))).join(''); 34576 }); 34577 } 34578 function flattenTree(input = {}, prefix, token) { 34579 let result = []; 34580 Object.keys(input).forEach(key => { 34581 const newKey = prefix + use_global_styles_output_kebabCase(key.replace('/', '-')); 34582 const newLeaf = input[key]; 34583 if (newLeaf instanceof Object) { 34584 const newPrefix = newKey + token; 34585 result = [...result, ...flattenTree(newLeaf, newPrefix, token)]; 34586 } else { 34587 result.push(`$newKey}: $newLeaf}`); 34588 } 34589 }); 34590 return result; 34591 } 34592 34593 /** 34594 * Gets variation selector string from feature selector. 34595 * 34596 * @param {string} featureSelector The feature selector. 34597 * 34598 * @param {string} styleVariationSelector The style variation selector. 34599 * @return {string} Combined selector string. 34600 */ 34601 function concatFeatureVariationSelectorString(featureSelector, styleVariationSelector) { 34602 const featureSelectors = featureSelector.split(','); 34603 const combinedSelectors = []; 34604 featureSelectors.forEach(selector => { 34605 combinedSelectors.push(`$styleVariationSelector.trim()}$selector.trim()}`); 34606 }); 34607 return combinedSelectors.join(', '); 34608 } 34609 34610 /** 34611 * Generate style declarations for a block's custom feature and subfeature 34612 * selectors. 34613 * 34614 * NOTE: The passed `styles` object will be mutated by this function. 34615 * 34616 * @param {Object} selectors Custom selectors object for a block. 34617 * @param {Object} styles A block's styles object. 34618 * 34619 * @return {Object} Style declarations. 34620 */ 34621 const getFeatureDeclarations = (selectors, styles) => { 34622 const declarations = {}; 34623 Object.entries(selectors).forEach(([feature, selector]) => { 34624 // We're only processing features/subfeatures that have styles. 34625 if (feature === 'root' || !styles?.[feature]) { 34626 return; 34627 } 34628 const isShorthand = typeof selector === 'string'; 34629 34630 // If we have a selector object instead of shorthand process it. 34631 if (!isShorthand) { 34632 Object.entries(selector).forEach(([subfeature, subfeatureSelector]) => { 34633 // Don't process root feature selector yet or any 34634 // subfeature that doesn't have a style. 34635 if (subfeature === 'root' || !styles?.[feature][subfeature]) { 34636 return; 34637 } 34638 34639 // Create a temporary styles object and build 34640 // declarations for subfeature. 34641 const subfeatureStyles = { 34642 [feature]: { 34643 [subfeature]: styles[feature][subfeature] 34644 } 34645 }; 34646 const newDeclarations = getStylesDeclarations(subfeatureStyles); 34647 34648 // Merge new declarations in with any others that 34649 // share the same selector. 34650 declarations[subfeatureSelector] = [...(declarations[subfeatureSelector] || []), ...newDeclarations]; 34651 34652 // Remove the subfeature's style now it will be 34653 // included under its own selector not the block's. 34654 delete styles[feature][subfeature]; 34655 }); 34656 } 34657 34658 // Now subfeatures have been processed and removed, we can 34659 // process root, or shorthand, feature selectors. 34660 if (isShorthand || selector.root) { 34661 const featureSelector = isShorthand ? selector : selector.root; 34662 34663 // Create temporary style object and build declarations for feature. 34664 const featureStyles = { 34665 [feature]: styles[feature] 34666 }; 34667 const newDeclarations = getStylesDeclarations(featureStyles); 34668 34669 // Merge new declarations with any others that share the selector. 34670 declarations[featureSelector] = [...(declarations[featureSelector] || []), ...newDeclarations]; 34671 34672 // Remove the feature from the block's styles now as it will be 34673 // included under its own selector not the block's. 34674 delete styles[feature]; 34675 } 34676 }); 34677 return declarations; 34678 }; 34679 34680 /** 34681 * Transform given style tree into a set of style declarations. 34682 * 34683 * @param {Object} blockStyles Block styles. 34684 * 34685 * @param {string} selector The selector these declarations should attach to. 34686 * 34687 * @param {boolean} useRootPaddingAlign Whether to use CSS custom properties in root selector. 34688 * 34689 * @param {Object} tree A theme.json tree containing layout definitions. 34690 * 34691 * @param {boolean} disableRootPadding Whether to force disable the root padding styles. 34692 * @return {Array} An array of style declarations. 34693 */ 34694 function getStylesDeclarations(blockStyles = {}, selector = '', useRootPaddingAlign, tree = {}, disableRootPadding = false) { 34695 const isRoot = ROOT_BLOCK_SELECTOR === selector; 34696 const output = Object.entries(external_wp_blocks_namespaceObject.__EXPERIMENTAL_STYLE_PROPERTY).reduce((declarations, [key, { 34697 value, 34698 properties, 34699 useEngine, 34700 rootOnly 34701 }]) => { 34702 if (rootOnly && !isRoot) { 34703 return declarations; 34704 } 34705 const pathToValue = value; 34706 if (pathToValue[0] === 'elements' || useEngine) { 34707 return declarations; 34708 } 34709 const styleValue = getValueFromObjectPath(blockStyles, pathToValue); 34710 34711 // Root-level padding styles don't currently support strings with CSS shorthand values. 34712 // This may change: https://github.com/WordPress/gutenberg/issues/40132. 34713 if (key === '--wp--style--root--padding' && (typeof styleValue === 'string' || !useRootPaddingAlign)) { 34714 return declarations; 34715 } 34716 if (properties && typeof styleValue !== 'string') { 34717 Object.entries(properties).forEach(entry => { 34718 const [name, prop] = entry; 34719 if (!getValueFromObjectPath(styleValue, [prop], false)) { 34720 // Do not create a declaration 34721 // for sub-properties that don't have any value. 34722 return; 34723 } 34724 const cssProperty = name.startsWith('--') ? name : use_global_styles_output_kebabCase(name); 34725 declarations.push(`$cssProperty}: ${(0,external_wp_styleEngine_namespaceObject.getCSSValueFromRawStyle)(getValueFromObjectPath(styleValue, [prop]))}`); 34726 }); 34727 } else if (getValueFromObjectPath(blockStyles, pathToValue, false)) { 34728 const cssProperty = key.startsWith('--') ? key : use_global_styles_output_kebabCase(key); 34729 declarations.push(`$cssProperty}: ${(0,external_wp_styleEngine_namespaceObject.getCSSValueFromRawStyle)(getValueFromObjectPath(blockStyles, pathToValue))}`); 34730 } 34731 return declarations; 34732 }, []); 34733 34734 /* 34735 * Preprocess background image values. 34736 * 34737 * Note: As we absorb more and more styles into the engine, we could simplify this function. 34738 * A refactor is for the style engine to handle ref resolution (and possibly defaults) 34739 * via a public util used internally and externally. Theme.json tree and defaults could be passed 34740 * as options. 34741 */ 34742 if (!!blockStyles.background) { 34743 /* 34744 * Resolve dynamic values before they are compiled by the style engine, 34745 * which doesn't (yet) resolve dynamic values. 34746 */ 34747 if (blockStyles.background?.backgroundImage) { 34748 blockStyles.background.backgroundImage = getResolvedValue(blockStyles.background.backgroundImage, tree); 34749 } 34750 34751 /* 34752 * Set default values for block background styles. 34753 * Top-level styles are an exception as they are applied to the body. 34754 */ 34755 if (!isRoot && !!blockStyles.background?.backgroundImage?.id) { 34756 blockStyles = { 34757 ...blockStyles, 34758 background: { 34759 ...blockStyles.background, 34760 ...setBackgroundStyleDefaults(blockStyles.background) 34761 } 34762 }; 34763 } 34764 } 34765 const extraRules = (0,external_wp_styleEngine_namespaceObject.getCSSRules)(blockStyles); 34766 extraRules.forEach(rule => { 34767 // Don't output padding properties if padding variables are set or if we're not editing a full template. 34768 if (isRoot && (useRootPaddingAlign || disableRootPadding) && rule.key.startsWith('padding')) { 34769 return; 34770 } 34771 const cssProperty = rule.key.startsWith('--') ? rule.key : use_global_styles_output_kebabCase(rule.key); 34772 let ruleValue = getResolvedValue(rule.value, tree, null); 34773 34774 // Calculate fluid typography rules where available. 34775 if (cssProperty === 'font-size') { 34776 /* 34777 * getTypographyFontSizeValue() will check 34778 * if fluid typography has been activated and also 34779 * whether the incoming value can be converted to a fluid value. 34780 * Values that already have a "clamp()" function will not pass the test, 34781 * and therefore the original $value will be returned. 34782 */ 34783 ruleValue = getTypographyFontSizeValue({ 34784 size: ruleValue 34785 }, tree?.settings); 34786 } 34787 34788 // For aspect ratio to work, other dimensions rules (and Cover block defaults) must be unset. 34789 // This ensures that a fixed height does not override the aspect ratio. 34790 if (cssProperty === 'aspect-ratio') { 34791 output.push('min-height: unset'); 34792 } 34793 output.push(`$cssProperty}: $ruleValue}`); 34794 }); 34795 return output; 34796 } 34797 34798 /** 34799 * Get generated CSS for layout styles by looking up layout definitions provided 34800 * in theme.json, and outputting common layout styles, and specific blockGap values. 34801 * 34802 * @param {Object} props 34803 * @param {Object} props.layoutDefinitions Layout definitions, keyed by layout type. 34804 * @param {Object} props.style A style object containing spacing values. 34805 * @param {string} props.selector Selector used to group together layout styling rules. 34806 * @param {boolean} props.hasBlockGapSupport Whether or not the theme opts-in to blockGap support. 34807 * @param {boolean} props.hasFallbackGapSupport Whether or not the theme allows fallback gap styles. 34808 * @param {?string} props.fallbackGapValue An optional fallback gap value if no real gap value is available. 34809 * @return {string} Generated CSS rules for the layout styles. 34810 */ 34811 function getLayoutStyles({ 34812 layoutDefinitions = LAYOUT_DEFINITIONS, 34813 style, 34814 selector, 34815 hasBlockGapSupport, 34816 hasFallbackGapSupport, 34817 fallbackGapValue 34818 }) { 34819 let ruleset = ''; 34820 let gapValue = hasBlockGapSupport ? getGapCSSValue(style?.spacing?.blockGap) : ''; 34821 34822 // Ensure a fallback gap value for the root layout definitions, 34823 // and use a fallback value if one is provided for the current block. 34824 if (hasFallbackGapSupport) { 34825 if (selector === ROOT_BLOCK_SELECTOR) { 34826 gapValue = !gapValue ? '0.5em' : gapValue; 34827 } else if (!hasBlockGapSupport && fallbackGapValue) { 34828 gapValue = fallbackGapValue; 34829 } 34830 } 34831 if (gapValue && layoutDefinitions) { 34832 Object.values(layoutDefinitions).forEach(({ 34833 className, 34834 name, 34835 spacingStyles 34836 }) => { 34837 // Allow outputting fallback gap styles for flex layout type when block gap support isn't available. 34838 if (!hasBlockGapSupport && 'flex' !== name && 'grid' !== name) { 34839 return; 34840 } 34841 if (spacingStyles?.length) { 34842 spacingStyles.forEach(spacingStyle => { 34843 const declarations = []; 34844 if (spacingStyle.rules) { 34845 Object.entries(spacingStyle.rules).forEach(([cssProperty, cssValue]) => { 34846 declarations.push(`$cssProperty}: $cssValue ? cssValue : gapValue}`); 34847 }); 34848 } 34849 if (declarations.length) { 34850 let combinedSelector = ''; 34851 if (!hasBlockGapSupport) { 34852 // For fallback gap styles, use lower specificity, to ensure styles do not unintentionally override theme styles. 34853 combinedSelector = selector === ROOT_BLOCK_SELECTOR ? `:where(.$className}$spacingStyle?.selector || ''})` : `:where($selector}.$className}$spacingStyle?.selector || ''})`; 34854 } else { 34855 combinedSelector = selector === ROOT_BLOCK_SELECTOR ? `:root :where(.$className})$spacingStyle?.selector || ''}` : `:root :where($selector}-$className})$spacingStyle?.selector || ''}`; 34856 } 34857 ruleset += `$combinedSelector} { $declarations.join('; ')}; }`; 34858 } 34859 }); 34860 } 34861 }); 34862 // For backwards compatibility, ensure the legacy block gap CSS variable is still available. 34863 if (selector === ROOT_BLOCK_SELECTOR && hasBlockGapSupport) { 34864 ruleset += `$ROOT_CSS_PROPERTIES_SELECTOR} { --wp--style--block-gap: $gapValue}; }`; 34865 } 34866 } 34867 34868 // Output base styles 34869 if (selector === ROOT_BLOCK_SELECTOR && layoutDefinitions) { 34870 const validDisplayModes = ['block', 'flex', 'grid']; 34871 Object.values(layoutDefinitions).forEach(({ 34872 className, 34873 displayMode, 34874 baseStyles 34875 }) => { 34876 if (displayMode && validDisplayModes.includes(displayMode)) { 34877 ruleset += `$selector} .$className} { display:$displayMode}; }`; 34878 } 34879 if (baseStyles?.length) { 34880 baseStyles.forEach(baseStyle => { 34881 const declarations = []; 34882 if (baseStyle.rules) { 34883 Object.entries(baseStyle.rules).forEach(([cssProperty, cssValue]) => { 34884 declarations.push(`$cssProperty}: $cssValue}`); 34885 }); 34886 } 34887 if (declarations.length) { 34888 const combinedSelector = `.$className}$baseStyle?.selector || ''}`; 34889 ruleset += `$combinedSelector} { $declarations.join('; ')}; }`; 34890 } 34891 }); 34892 } 34893 }); 34894 } 34895 return ruleset; 34896 } 34897 const STYLE_KEYS = ['border', 'color', 'dimensions', 'spacing', 'typography', 'filter', 'outline', 'shadow', 'background']; 34898 function pickStyleKeys(treeToPickFrom) { 34899 if (!treeToPickFrom) { 34900 return {}; 34901 } 34902 const entries = Object.entries(treeToPickFrom); 34903 const pickedEntries = entries.filter(([key]) => STYLE_KEYS.includes(key)); 34904 // clone the style objects so that `getFeatureDeclarations` can remove consumed keys from it 34905 const clonedEntries = pickedEntries.map(([key, style]) => [key, JSON.parse(JSON.stringify(style))]); 34906 return Object.fromEntries(clonedEntries); 34907 } 34908 const getNodesWithStyles = (tree, blockSelectors) => { 34909 var _tree$styles$blocks; 34910 const nodes = []; 34911 if (!tree?.styles) { 34912 return nodes; 34913 } 34914 34915 // Top-level. 34916 const styles = pickStyleKeys(tree.styles); 34917 if (styles) { 34918 nodes.push({ 34919 styles, 34920 selector: ROOT_BLOCK_SELECTOR, 34921 // Root selector (body) styles should not be wrapped in `:root where()` to keep 34922 // specificity at (0,0,1) and maintain backwards compatibility. 34923 skipSelectorWrapper: true 34924 }); 34925 } 34926 Object.entries(external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS).forEach(([name, selector]) => { 34927 if (tree.styles?.elements?.[name]) { 34928 nodes.push({ 34929 styles: tree.styles?.elements?.[name], 34930 selector, 34931 // Top level elements that don't use a class name should not receive the 34932 // `:root :where()` wrapper to maintain backwards compatibility. 34933 skipSelectorWrapper: !ELEMENT_CLASS_NAMES[name] 34934 }); 34935 } 34936 }); 34937 34938 // Iterate over blocks: they can have styles & elements. 34939 Object.entries((_tree$styles$blocks = tree.styles?.blocks) !== null && _tree$styles$blocks !== void 0 ? _tree$styles$blocks : {}).forEach(([blockName, node]) => { 34940 var _node$elements; 34941 const blockStyles = pickStyleKeys(node); 34942 if (node?.variations) { 34943 const variations = {}; 34944 Object.entries(node.variations).forEach(([variationName, variation]) => { 34945 var _variation$elements, _variation$blocks; 34946 variations[variationName] = pickStyleKeys(variation); 34947 if (variation?.css) { 34948 variations[variationName].css = variation.css; 34949 } 34950 const variationSelector = blockSelectors[blockName]?.styleVariationSelectors?.[variationName]; 34951 34952 // Process the variation's inner element styles. 34953 // This comes before the inner block styles so the 34954 // element styles within the block type styles take 34955 // precedence over these. 34956 Object.entries((_variation$elements = variation?.elements) !== null && _variation$elements !== void 0 ? _variation$elements : {}).forEach(([element, elementStyles]) => { 34957 if (elementStyles && external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[element]) { 34958 nodes.push({ 34959 styles: elementStyles, 34960 selector: scopeSelector(variationSelector, external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[element]) 34961 }); 34962 } 34963 }); 34964 34965 // Process the variations inner block type styles. 34966 Object.entries((_variation$blocks = variation?.blocks) !== null && _variation$blocks !== void 0 ? _variation$blocks : {}).forEach(([variationBlockName, variationBlockStyles]) => { 34967 var _variationBlockStyles; 34968 const variationBlockSelector = scopeSelector(variationSelector, blockSelectors[variationBlockName]?.selector); 34969 const variationDuotoneSelector = scopeSelector(variationSelector, blockSelectors[variationBlockName]?.duotoneSelector); 34970 const variationFeatureSelectors = scopeFeatureSelectors(variationSelector, blockSelectors[variationBlockName]?.featureSelectors); 34971 const variationBlockStyleNodes = pickStyleKeys(variationBlockStyles); 34972 if (variationBlockStyles?.css) { 34973 variationBlockStyleNodes.css = variationBlockStyles.css; 34974 } 34975 nodes.push({ 34976 selector: variationBlockSelector, 34977 duotoneSelector: variationDuotoneSelector, 34978 featureSelectors: variationFeatureSelectors, 34979 fallbackGapValue: blockSelectors[variationBlockName]?.fallbackGapValue, 34980 hasLayoutSupport: blockSelectors[variationBlockName]?.hasLayoutSupport, 34981 styles: variationBlockStyleNodes 34982 }); 34983 34984 // Process element styles for the inner blocks 34985 // of the variation. 34986 Object.entries((_variationBlockStyles = variationBlockStyles.elements) !== null && _variationBlockStyles !== void 0 ? _variationBlockStyles : {}).forEach(([variationBlockElement, variationBlockElementStyles]) => { 34987 if (variationBlockElementStyles && external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[variationBlockElement]) { 34988 nodes.push({ 34989 styles: variationBlockElementStyles, 34990 selector: scopeSelector(variationBlockSelector, external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[variationBlockElement]) 34991 }); 34992 } 34993 }); 34994 }); 34995 }); 34996 blockStyles.variations = variations; 34997 } 34998 if (blockSelectors?.[blockName]?.selector) { 34999 nodes.push({ 35000 duotoneSelector: blockSelectors[blockName].duotoneSelector, 35001 fallbackGapValue: blockSelectors[blockName].fallbackGapValue, 35002 hasLayoutSupport: blockSelectors[blockName].hasLayoutSupport, 35003 selector: blockSelectors[blockName].selector, 35004 styles: blockStyles, 35005 featureSelectors: blockSelectors[blockName].featureSelectors, 35006 styleVariationSelectors: blockSelectors[blockName].styleVariationSelectors 35007 }); 35008 } 35009 Object.entries((_node$elements = node?.elements) !== null && _node$elements !== void 0 ? _node$elements : {}).forEach(([elementName, value]) => { 35010 if (value && blockSelectors?.[blockName] && external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[elementName]) { 35011 nodes.push({ 35012 styles: value, 35013 selector: blockSelectors[blockName]?.selector.split(',').map(sel => { 35014 const elementSelectors = external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[elementName].split(','); 35015 return elementSelectors.map(elementSelector => sel + ' ' + elementSelector); 35016 }).join(',') 35017 }); 35018 } 35019 }); 35020 }); 35021 return nodes; 35022 }; 35023 const getNodesWithSettings = (tree, blockSelectors) => { 35024 var _tree$settings$blocks; 35025 const nodes = []; 35026 if (!tree?.settings) { 35027 return nodes; 35028 } 35029 const pickPresets = treeToPickFrom => { 35030 let presets = {}; 35031 PRESET_METADATA.forEach(({ 35032 path 35033 }) => { 35034 const value = getValueFromObjectPath(treeToPickFrom, path, false); 35035 if (value !== false) { 35036 presets = setImmutably(presets, path, value); 35037 } 35038 }); 35039 return presets; 35040 }; 35041 35042 // Top-level. 35043 const presets = pickPresets(tree.settings); 35044 const custom = tree.settings?.custom; 35045 if (Object.keys(presets).length > 0 || custom) { 35046 nodes.push({ 35047 presets, 35048 custom, 35049 selector: ROOT_CSS_PROPERTIES_SELECTOR 35050 }); 35051 } 35052 35053 // Blocks. 35054 Object.entries((_tree$settings$blocks = tree.settings?.blocks) !== null && _tree$settings$blocks !== void 0 ? _tree$settings$blocks : {}).forEach(([blockName, node]) => { 35055 const blockPresets = pickPresets(node); 35056 const blockCustom = node.custom; 35057 if (Object.keys(blockPresets).length > 0 || blockCustom) { 35058 nodes.push({ 35059 presets: blockPresets, 35060 custom: blockCustom, 35061 selector: blockSelectors[blockName]?.selector 35062 }); 35063 } 35064 }); 35065 return nodes; 35066 }; 35067 const toCustomProperties = (tree, blockSelectors) => { 35068 const settings = getNodesWithSettings(tree, blockSelectors); 35069 let ruleset = ''; 35070 settings.forEach(({ 35071 presets, 35072 custom, 35073 selector 35074 }) => { 35075 const declarations = getPresetsDeclarations(presets, tree?.settings); 35076 const customProps = flattenTree(custom, '--wp--custom--', '--'); 35077 if (customProps.length > 0) { 35078 declarations.push(...customProps); 35079 } 35080 if (declarations.length > 0) { 35081 ruleset += `$selector}{$declarations.join(';')};}`; 35082 } 35083 }); 35084 return ruleset; 35085 }; 35086 const toStyles = (tree, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles = false, disableRootPadding = false, styleOptions = undefined) => { 35087 // These allow opting out of certain sets of styles. 35088 const options = { 35089 blockGap: true, 35090 blockStyles: true, 35091 layoutStyles: true, 35092 marginReset: true, 35093 presets: true, 35094 rootPadding: true, 35095 variationStyles: false, 35096 ...styleOptions 35097 }; 35098 const nodesWithStyles = getNodesWithStyles(tree, blockSelectors); 35099 const nodesWithSettings = getNodesWithSettings(tree, blockSelectors); 35100 const useRootPaddingAlign = tree?.settings?.useRootPaddingAwareAlignments; 35101 const { 35102 contentSize, 35103 wideSize 35104 } = tree?.settings?.layout || {}; 35105 const hasBodyStyles = options.marginReset || options.rootPadding || options.layoutStyles; 35106 let ruleset = ''; 35107 if (options.presets && (contentSize || wideSize)) { 35108 ruleset += `$ROOT_CSS_PROPERTIES_SELECTOR} {`; 35109 ruleset = contentSize ? ruleset + ` --wp--style--global--content-size: $contentSize};` : ruleset; 35110 ruleset = wideSize ? ruleset + ` --wp--style--global--wide-size: $wideSize};` : ruleset; 35111 ruleset += '}'; 35112 } 35113 if (hasBodyStyles) { 35114 /* 35115 * Reset default browser margin on the body element. 35116 * This is set on the body selector **before** generating the ruleset 35117 * from the `theme.json`. This is to ensure that if the `theme.json` declares 35118 * `margin` in its `spacing` declaration for the `body` element then these 35119 * user-generated values take precedence in the CSS cascade. 35120 * @link https://github.com/WordPress/gutenberg/issues/36147. 35121 */ 35122 ruleset += ':where(body) {margin: 0;'; 35123 35124 // Root padding styles should be output for full templates, patterns and template parts. 35125 if (options.rootPadding && useRootPaddingAlign) { 35126 /* 35127 * These rules reproduce the ones from https://github.com/WordPress/gutenberg/blob/79103f124925d1f457f627e154f52a56228ed5ad/lib/class-wp-theme-json-gutenberg.php#L2508 35128 * almost exactly, but for the selectors that target block wrappers in the front end. This code only runs in the editor, so it doesn't need those selectors. 35129 */ 35130 ruleset += `padding-right: 0; padding-left: 0; padding-top: var(--wp--style--root--padding-top); padding-bottom: var(--wp--style--root--padding-bottom) } 35131 .has-global-padding { padding-right: var(--wp--style--root--padding-right); padding-left: var(--wp--style--root--padding-left); } 35132 .has-global-padding > .alignfull { margin-right: calc(var(--wp--style--root--padding-right) * -1); margin-left: calc(var(--wp--style--root--padding-left) * -1); } 35133 .has-global-padding :where(:not(.alignfull.is-layout-flow) > .has-global-padding:not(.wp-block-block, .alignfull)) { padding-right: 0; padding-left: 0; } 35134 .has-global-padding :where(:not(.alignfull.is-layout-flow) > .has-global-padding:not(.wp-block-block, .alignfull)) > .alignfull { margin-left: 0; margin-right: 0; 35135 `; 35136 } 35137 ruleset += '}'; 35138 } 35139 if (options.blockStyles) { 35140 nodesWithStyles.forEach(({ 35141 selector, 35142 duotoneSelector, 35143 styles, 35144 fallbackGapValue, 35145 hasLayoutSupport, 35146 featureSelectors, 35147 styleVariationSelectors, 35148 skipSelectorWrapper 35149 }) => { 35150 // Process styles for block support features with custom feature level 35151 // CSS selectors set. 35152 if (featureSelectors) { 35153 const featureDeclarations = getFeatureDeclarations(featureSelectors, styles); 35154 Object.entries(featureDeclarations).forEach(([cssSelector, declarations]) => { 35155 if (declarations.length) { 35156 const rules = declarations.join(';'); 35157 ruleset += `:root :where($cssSelector}){$rules};}`; 35158 } 35159 }); 35160 } 35161 35162 // Process duotone styles. 35163 if (duotoneSelector) { 35164 const duotoneStyles = {}; 35165 if (styles?.filter) { 35166 duotoneStyles.filter = styles.filter; 35167 delete styles.filter; 35168 } 35169 const duotoneDeclarations = getStylesDeclarations(duotoneStyles); 35170 if (duotoneDeclarations.length) { 35171 ruleset += `$duotoneSelector}{$duotoneDeclarations.join(';')};}`; 35172 } 35173 } 35174 35175 // Process blockGap and layout styles. 35176 if (!disableLayoutStyles && (ROOT_BLOCK_SELECTOR === selector || hasLayoutSupport)) { 35177 ruleset += getLayoutStyles({ 35178 style: styles, 35179 selector, 35180 hasBlockGapSupport, 35181 hasFallbackGapSupport, 35182 fallbackGapValue 35183 }); 35184 } 35185 35186 // Process the remaining block styles (they use either normal block class or __experimentalSelector). 35187 const styleDeclarations = getStylesDeclarations(styles, selector, useRootPaddingAlign, tree, disableRootPadding); 35188 if (styleDeclarations?.length) { 35189 const generalSelector = skipSelectorWrapper ? selector : `:root :where($selector})`; 35190 ruleset += `$generalSelector}{$styleDeclarations.join(';')};}`; 35191 } 35192 if (styles?.css) { 35193 ruleset += processCSSNesting(styles.css, `:root :where($selector})`); 35194 } 35195 if (options.variationStyles && styleVariationSelectors) { 35196 Object.entries(styleVariationSelectors).forEach(([styleVariationName, styleVariationSelector]) => { 35197 const styleVariations = styles?.variations?.[styleVariationName]; 35198 if (styleVariations) { 35199 // If the block uses any custom selectors for block support, add those first. 35200 if (featureSelectors) { 35201 const featureDeclarations = getFeatureDeclarations(featureSelectors, styleVariations); 35202 Object.entries(featureDeclarations).forEach(([baseSelector, declarations]) => { 35203 if (declarations.length) { 35204 const cssSelector = concatFeatureVariationSelectorString(baseSelector, styleVariationSelector); 35205 const rules = declarations.join(';'); 35206 ruleset += `:root :where($cssSelector}){$rules};}`; 35207 } 35208 }); 35209 } 35210 35211 // Otherwise add regular selectors. 35212 const styleVariationDeclarations = getStylesDeclarations(styleVariations, styleVariationSelector, useRootPaddingAlign, tree); 35213 if (styleVariationDeclarations.length) { 35214 ruleset += `:root :where($styleVariationSelector}){$styleVariationDeclarations.join(';')};}`; 35215 } 35216 if (styleVariations?.css) { 35217 ruleset += processCSSNesting(styleVariations.css, `:root :where($styleVariationSelector})`); 35218 } 35219 } 35220 }); 35221 } 35222 35223 // Check for pseudo selector in `styles` and handle separately. 35224 const pseudoSelectorStyles = Object.entries(styles).filter(([key]) => key.startsWith(':')); 35225 if (pseudoSelectorStyles?.length) { 35226 pseudoSelectorStyles.forEach(([pseudoKey, pseudoStyle]) => { 35227 const pseudoDeclarations = getStylesDeclarations(pseudoStyle); 35228 if (!pseudoDeclarations?.length) { 35229 return; 35230 } 35231 35232 // `selector` may be provided in a form 35233 // where block level selectors have sub element 35234 // selectors appended to them as a comma separated 35235 // string. 35236 // e.g. `h1 a,h2 a,h3 a,h4 a,h5 a,h6 a`; 35237 // Split and append pseudo selector to create 35238 // the proper rules to target the elements. 35239 const _selector = selector.split(',').map(sel => sel + pseudoKey).join(','); 35240 35241 // As pseudo classes such as :hover, :focus etc. have class-level 35242 // specificity, they must use the `:root :where()` wrapper. This. 35243 // caps the specificity at `0-1-0` to allow proper nesting of variations 35244 // and block type element styles. 35245 const pseudoRule = `:root :where($_selector}){$pseudoDeclarations.join(';')};}`; 35246 ruleset += pseudoRule; 35247 }); 35248 } 35249 }); 35250 } 35251 if (options.layoutStyles) { 35252 /* Add alignment / layout styles */ 35253 ruleset = ruleset + '.wp-site-blocks > .alignleft { float: left; margin-right: 2em; }'; 35254 ruleset = ruleset + '.wp-site-blocks > .alignright { float: right; margin-left: 2em; }'; 35255 ruleset = ruleset + '.wp-site-blocks > .aligncenter { justify-content: center; margin-left: auto; margin-right: auto; }'; 35256 } 35257 if (options.blockGap && hasBlockGapSupport) { 35258 // Use fallback of `0.5em` just in case, however if there is blockGap support, there should nearly always be a real value. 35259 const gapValue = getGapCSSValue(tree?.styles?.spacing?.blockGap) || '0.5em'; 35260 ruleset = ruleset + `:root :where(.wp-site-blocks) > * { margin-block-start: $gapValue}; margin-block-end: 0; }`; 35261 ruleset = ruleset + ':root :where(.wp-site-blocks) > :first-child { margin-block-start: 0; }'; 35262 ruleset = ruleset + ':root :where(.wp-site-blocks) > :last-child { margin-block-end: 0; }'; 35263 } 35264 if (options.presets) { 35265 nodesWithSettings.forEach(({ 35266 selector, 35267 presets 35268 }) => { 35269 if (ROOT_BLOCK_SELECTOR === selector || ROOT_CSS_PROPERTIES_SELECTOR === selector) { 35270 // Do not add extra specificity for top-level classes. 35271 selector = ''; 35272 } 35273 const classes = getPresetsClasses(selector, presets); 35274 if (classes.length > 0) { 35275 ruleset += classes; 35276 } 35277 }); 35278 } 35279 return ruleset; 35280 }; 35281 function toSvgFilters(tree, blockSelectors) { 35282 const nodesWithSettings = getNodesWithSettings(tree, blockSelectors); 35283 return nodesWithSettings.flatMap(({ 35284 presets 35285 }) => { 35286 return getPresetsSvgFilters(presets); 35287 }); 35288 } 35289 const getSelectorsConfig = (blockType, rootSelector) => { 35290 if (blockType?.selectors && Object.keys(blockType.selectors).length > 0) { 35291 return blockType.selectors; 35292 } 35293 const config = { 35294 root: rootSelector 35295 }; 35296 Object.entries(BLOCK_SUPPORT_FEATURE_LEVEL_SELECTORS).forEach(([featureKey, featureName]) => { 35297 const featureSelector = getBlockCSSSelector(blockType, featureKey); 35298 if (featureSelector) { 35299 config[featureName] = featureSelector; 35300 } 35301 }); 35302 return config; 35303 }; 35304 const getBlockSelectors = (blockTypes, getBlockStyles, variationInstanceId) => { 35305 const result = {}; 35306 blockTypes.forEach(blockType => { 35307 const name = blockType.name; 35308 const selector = getBlockCSSSelector(blockType); 35309 let duotoneSelector = getBlockCSSSelector(blockType, 'filter.duotone'); 35310 35311 // Keep backwards compatibility for support.color.__experimentalDuotone. 35312 if (!duotoneSelector) { 35313 const rootSelector = getBlockCSSSelector(blockType); 35314 const duotoneSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, 'color.__experimentalDuotone', false); 35315 duotoneSelector = duotoneSupport && scopeSelector(rootSelector, duotoneSupport); 35316 } 35317 const hasLayoutSupport = !!blockType?.supports?.layout || !!blockType?.supports?.__experimentalLayout; 35318 const fallbackGapValue = blockType?.supports?.spacing?.blockGap?.__experimentalDefault; 35319 const blockStyleVariations = getBlockStyles(name); 35320 const styleVariationSelectors = {}; 35321 blockStyleVariations?.forEach(variation => { 35322 const variationSuffix = variationInstanceId ? `-$variationInstanceId}` : ''; 35323 const variationName = `$variation.name}$variationSuffix}`; 35324 const styleVariationSelector = getBlockStyleVariationSelector(variationName, selector); 35325 styleVariationSelectors[variationName] = styleVariationSelector; 35326 }); 35327 35328 // For each block support feature add any custom selectors. 35329 const featureSelectors = getSelectorsConfig(blockType, selector); 35330 result[name] = { 35331 duotoneSelector, 35332 fallbackGapValue, 35333 featureSelectors: Object.keys(featureSelectors).length ? featureSelectors : undefined, 35334 hasLayoutSupport, 35335 name, 35336 selector, 35337 styleVariationSelectors: blockStyleVariations?.length ? styleVariationSelectors : undefined 35338 }; 35339 }); 35340 return result; 35341 }; 35342 35343 /** 35344 * If there is a separator block whose color is defined in theme.json via background, 35345 * update the separator color to the same value by using border color. 35346 * 35347 * @param {Object} config Theme.json configuration file object. 35348 * @return {Object} configTheme.json configuration file object updated. 35349 */ 35350 function updateConfigWithSeparator(config) { 35351 const needsSeparatorStyleUpdate = config.styles?.blocks?.['core/separator'] && config.styles?.blocks?.['core/separator'].color?.background && !config.styles?.blocks?.['core/separator'].color?.text && !config.styles?.blocks?.['core/separator'].border?.color; 35352 if (needsSeparatorStyleUpdate) { 35353 return { 35354 ...config, 35355 styles: { 35356 ...config.styles, 35357 blocks: { 35358 ...config.styles.blocks, 35359 'core/separator': { 35360 ...config.styles.blocks['core/separator'], 35361 color: { 35362 ...config.styles.blocks['core/separator'].color, 35363 text: config.styles?.blocks['core/separator'].color.background 35364 } 35365 } 35366 } 35367 } 35368 }; 35369 } 35370 return config; 35371 } 35372 function processCSSNesting(css, blockSelector) { 35373 let processedCSS = ''; 35374 if (!css || css.trim() === '') { 35375 return processedCSS; 35376 } 35377 35378 // Split CSS nested rules. 35379 const parts = css.split('&'); 35380 parts.forEach(part => { 35381 if (!part || part.trim() === '') { 35382 return; 35383 } 35384 const isRootCss = !part.includes('{'); 35385 if (isRootCss) { 35386 // If the part doesn't contain braces, it applies to the root level. 35387 processedCSS += `:root :where($blockSelector}){$part.trim()}}`; 35388 } else { 35389 // If the part contains braces, it's a nested CSS rule. 35390 const splittedPart = part.replace('}', '').split('{'); 35391 if (splittedPart.length !== 2) { 35392 return; 35393 } 35394 const [nestedSelector, cssValue] = splittedPart; 35395 35396 // Handle pseudo elements such as ::before, ::after, etc. Regex will also 35397 // capture any leading combinator such as >, +, or ~, as well as spaces. 35398 // This allows pseudo elements as descendants e.g. `.parent ::before`. 35399 const matches = nestedSelector.match(/([>+~\s]*::[a-zA-Z-]+)/); 35400 const pseudoPart = matches ? matches[1] : ''; 35401 const withoutPseudoElement = matches ? nestedSelector.replace(pseudoPart, '').trim() : nestedSelector.trim(); 35402 let combinedSelector; 35403 if (withoutPseudoElement === '') { 35404 // Only contained a pseudo element to use the block selector to form 35405 // the final `:root :where()` selector. 35406 combinedSelector = blockSelector; 35407 } else { 35408 // If the nested selector is a descendant of the block scope it with the 35409 // block selector. Otherwise append it to the block selector. 35410 combinedSelector = nestedSelector.startsWith(' ') ? scopeSelector(blockSelector, withoutPseudoElement) : appendToSelector(blockSelector, withoutPseudoElement); 35411 } 35412 35413 // Build final rule, re-adding any pseudo element outside the `:where()` 35414 // to maintain valid CSS selector. 35415 processedCSS += `:root :where($combinedSelector})$pseudoPart}{$cssValue.trim()}}`; 35416 } 35417 }); 35418 return processedCSS; 35419 } 35420 35421 /** 35422 * Returns the global styles output using a global styles configuration. 35423 * If wishing to generate global styles and settings based on the 35424 * global styles config loaded in the editor context, use `useGlobalStylesOutput()`. 35425 * The use case for a custom config is to generate bespoke styles 35426 * and settings for previews, or other out-of-editor experiences. 35427 * 35428 * @param {Object} mergedConfig Global styles configuration. 35429 * @param {boolean} disableRootPadding Disable root padding styles. 35430 * 35431 * @return {Array} Array of stylesheets and settings. 35432 */ 35433 function useGlobalStylesOutputWithConfig(mergedConfig = {}, disableRootPadding) { 35434 const [blockGap] = useGlobalSetting('spacing.blockGap'); 35435 const hasBlockGapSupport = blockGap !== null; 35436 const hasFallbackGapSupport = !hasBlockGapSupport; // This setting isn't useful yet: it exists as a placeholder for a future explicit fallback styles support. 35437 const disableLayoutStyles = (0,external_wp_data_namespaceObject.useSelect)(select => { 35438 const { 35439 getSettings 35440 } = select(store); 35441 return !!getSettings().disableLayoutStyles; 35442 }); 35443 const { 35444 getBlockStyles 35445 } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store); 35446 return (0,external_wp_element_namespaceObject.useMemo)(() => { 35447 var _updatedConfig$styles; 35448 if (!mergedConfig?.styles || !mergedConfig?.settings) { 35449 return []; 35450 } 35451 const updatedConfig = updateConfigWithSeparator(mergedConfig); 35452 const blockSelectors = getBlockSelectors((0,external_wp_blocks_namespaceObject.getBlockTypes)(), getBlockStyles); 35453 const customProperties = toCustomProperties(updatedConfig, blockSelectors); 35454 const globalStyles = toStyles(updatedConfig, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles, disableRootPadding); 35455 const svgs = toSvgFilters(updatedConfig, blockSelectors); 35456 const styles = [{ 35457 css: customProperties, 35458 isGlobalStyles: true 35459 }, { 35460 css: globalStyles, 35461 isGlobalStyles: true 35462 }, 35463 // Load custom CSS in own stylesheet so that any invalid CSS entered in the input won't break all the global styles in the editor. 35464 { 35465 css: (_updatedConfig$styles = updatedConfig.styles.css) !== null && _updatedConfig$styles !== void 0 ? _updatedConfig$styles : '', 35466 isGlobalStyles: true 35467 }, { 35468 assets: svgs, 35469 __unstableType: 'svg', 35470 isGlobalStyles: true 35471 }]; 35472 35473 // Loop through the blocks to check if there are custom CSS values. 35474 // If there are, get the block selector and push the selector together with 35475 // the CSS value to the 'stylesheets' array. 35476 (0,external_wp_blocks_namespaceObject.getBlockTypes)().forEach(blockType => { 35477 if (updatedConfig.styles.blocks[blockType.name]?.css) { 35478 const selector = blockSelectors[blockType.name].selector; 35479 styles.push({ 35480 css: processCSSNesting(updatedConfig.styles.blocks[blockType.name]?.css, selector), 35481 isGlobalStyles: true 35482 }); 35483 } 35484 }); 35485 return [styles, updatedConfig.settings]; 35486 }, [hasBlockGapSupport, hasFallbackGapSupport, mergedConfig, disableLayoutStyles, disableRootPadding, getBlockStyles]); 35487 } 35488 35489 /** 35490 * Returns the global styles output based on the current state of global styles config loaded in the editor context. 35491 * 35492 * @param {boolean} disableRootPadding Disable root padding styles. 35493 * 35494 * @return {Array} Array of stylesheets and settings. 35495 */ 35496 function useGlobalStylesOutput(disableRootPadding = false) { 35497 const { 35498 merged: mergedConfig 35499 } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext); 35500 return useGlobalStylesOutputWithConfig(mergedConfig, disableRootPadding); 35501 } 35502 35503 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/block-style-variation.js 35504 /** 35505 * WordPress dependencies 35506 */ 35507 35508 35509 35510 35511 /** 35512 * Internal dependencies 35513 */ 35514 35515 35516 35517 35518 35519 35520 35521 35522 const VARIATION_PREFIX = 'is-style-'; 35523 function getVariationMatches(className) { 35524 if (!className) { 35525 return []; 35526 } 35527 return className.split(/\s+/).reduce((matches, name) => { 35528 if (name.startsWith(VARIATION_PREFIX)) { 35529 const match = name.slice(VARIATION_PREFIX.length); 35530 if (match !== 'default') { 35531 matches.push(match); 35532 } 35533 } 35534 return matches; 35535 }, []); 35536 } 35537 35538 /** 35539 * Get the first block style variation that has been registered from the class string. 35540 * 35541 * @param {string} className CSS class string for a block. 35542 * @param {Array} registeredStyles Currently registered block styles. 35543 * 35544 * @return {string|null} The name of the first registered variation. 35545 */ 35546 function getVariationNameFromClass(className, registeredStyles = []) { 35547 // The global flag affects how capturing groups work in JS. So the regex 35548 // below will only return full CSS classes not just the variation name. 35549 const matches = getVariationMatches(className); 35550 if (!matches) { 35551 return null; 35552 } 35553 for (const variation of matches) { 35554 if (registeredStyles.some(style => style.name === variation)) { 35555 return variation; 35556 } 35557 } 35558 return null; 35559 } 35560 35561 // A helper component to apply a style override using the useStyleOverride hook. 35562 function OverrideStyles({ 35563 override 35564 }) { 35565 usePrivateStyleOverride(override); 35566 } 35567 35568 /** 35569 * This component is used to generate new block style variation overrides 35570 * based on an incoming theme config. If a matching style is found in the config, 35571 * a new override is created and returned. The overrides can be used in conjunction with 35572 * useStyleOverride to apply the new styles to the editor. Its use is 35573 * subject to change. 35574 * 35575 * @param {Object} props Props. 35576 * @param {Object} props.config A global styles object, containing settings and styles. 35577 * @return {JSX.Element|undefined} An array of new block variation overrides. 35578 */ 35579 function __unstableBlockStyleVariationOverridesWithConfig({ 35580 config 35581 }) { 35582 const { 35583 getBlockStyles, 35584 overrides 35585 } = (0,external_wp_data_namespaceObject.useSelect)(select => ({ 35586 getBlockStyles: select(external_wp_blocks_namespaceObject.store).getBlockStyles, 35587 overrides: unlock(select(store)).getStyleOverrides() 35588 }), []); 35589 const { 35590 getBlockName 35591 } = (0,external_wp_data_namespaceObject.useSelect)(store); 35592 const overridesWithConfig = (0,external_wp_element_namespaceObject.useMemo)(() => { 35593 if (!overrides?.length) { 35594 return; 35595 } 35596 const newOverrides = []; 35597 const overriddenClientIds = []; 35598 for (const [, override] of overrides) { 35599 if (override?.variation && override?.clientId && 35600 /* 35601 * Because this component overwrites existing style overrides, 35602 * filter out any overrides that are already present in the store. 35603 */ 35604 !overriddenClientIds.includes(override.clientId)) { 35605 const blockName = getBlockName(override.clientId); 35606 const configStyles = config?.styles?.blocks?.[blockName]?.variations?.[override.variation]; 35607 if (configStyles) { 35608 const variationConfig = { 35609 settings: config?.settings, 35610 // The variation style data is all that is needed to generate 35611 // the styles for the current application to a block. The variation 35612 // name is updated to match the instance specific class name. 35613 styles: { 35614 blocks: { 35615 [blockName]: { 35616 variations: { 35617 [`$override.variation}-$override.clientId}`]: configStyles 35618 } 35619 } 35620 } 35621 } 35622 }; 35623 const blockSelectors = getBlockSelectors((0,external_wp_blocks_namespaceObject.getBlockTypes)(), getBlockStyles, override.clientId); 35624 const hasBlockGapSupport = false; 35625 const hasFallbackGapSupport = true; 35626 const disableLayoutStyles = true; 35627 const disableRootPadding = true; 35628 const variationStyles = toStyles(variationConfig, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles, disableRootPadding, { 35629 blockGap: false, 35630 blockStyles: true, 35631 layoutStyles: false, 35632 marginReset: false, 35633 presets: false, 35634 rootPadding: false, 35635 variationStyles: true 35636 }); 35637 newOverrides.push({ 35638 id: `$override.variation}-$override.clientId}`, 35639 css: variationStyles, 35640 __unstableType: 'variation', 35641 variation: override.variation, 35642 // The clientId will be stored with the override and used to ensure 35643 // the order of overrides matches the order of blocks so that the 35644 // correct CSS cascade is maintained. 35645 clientId: override.clientId 35646 }); 35647 overriddenClientIds.push(override.clientId); 35648 } 35649 } 35650 } 35651 return newOverrides; 35652 }, [config, overrides, getBlockStyles, getBlockName]); 35653 if (!overridesWithConfig || !overridesWithConfig.length) { 35654 return; 35655 } 35656 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 35657 children: overridesWithConfig.map(override => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(OverrideStyles, { 35658 override: override 35659 }, override.id)) 35660 }); 35661 } 35662 35663 /** 35664 * Retrieves any variation styles data and resolves any referenced values. 35665 * 35666 * @param {Object} globalStyles A complete global styles object, containing settings and styles. 35667 * @param {string} name The name of the desired block type. 35668 * @param {variation} variation The of the block style variation to retrieve data for. 35669 * 35670 * @return {Object|undefined} The global styles data for the specified variation. 35671 */ 35672 function getVariationStylesWithRefValues(globalStyles, name, variation) { 35673 if (!globalStyles?.styles?.blocks?.[name]?.variations?.[variation]) { 35674 return; 35675 } 35676 35677 // Helper to recursively look for `ref` values to resolve. 35678 const replaceRefs = variationStyles => { 35679 Object.keys(variationStyles).forEach(key => { 35680 const value = variationStyles[key]; 35681 35682 // Only process objects. 35683 if (typeof value === 'object' && value !== null) { 35684 // Process `ref` value if present. 35685 if (value.ref !== undefined) { 35686 if (typeof value.ref !== 'string' || value.ref.trim() === '') { 35687 // Remove invalid ref. 35688 delete variationStyles[key]; 35689 } else { 35690 // Resolve `ref` value. 35691 const refValue = getValueFromObjectPath(globalStyles, value.ref); 35692 if (refValue) { 35693 variationStyles[key] = refValue; 35694 } else { 35695 delete variationStyles[key]; 35696 } 35697 } 35698 } else { 35699 // Recursively resolve `ref` values in nested objects. 35700 replaceRefs(value); 35701 35702 // After recursion, if value is empty due to explicitly 35703 // `undefined` ref value, remove it. 35704 if (Object.keys(value).length === 0) { 35705 delete variationStyles[key]; 35706 } 35707 } 35708 } 35709 }); 35710 }; 35711 35712 // Deep clone variation node to avoid mutating it within global styles and losing refs. 35713 const styles = JSON.parse(JSON.stringify(globalStyles.styles.blocks[name].variations[variation])); 35714 replaceRefs(styles); 35715 return styles; 35716 } 35717 function useBlockStyleVariation(name, variation, clientId) { 35718 // Prefer global styles data in GlobalStylesContext, which are available 35719 // if in the site editor. Otherwise fall back to whatever is in the 35720 // editor settings and available in the post editor. 35721 const { 35722 merged: mergedConfig 35723 } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext); 35724 const { 35725 globalSettings, 35726 globalStyles 35727 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 35728 const settings = select(store).getSettings(); 35729 return { 35730 globalSettings: settings.__experimentalFeatures, 35731 globalStyles: settings[globalStylesDataKey] 35732 }; 35733 }, []); 35734 return (0,external_wp_element_namespaceObject.useMemo)(() => { 35735 var _mergedConfig$setting, _mergedConfig$styles, _mergedConfig$setting2; 35736 const variationStyles = getVariationStylesWithRefValues({ 35737 settings: (_mergedConfig$setting = mergedConfig?.settings) !== null && _mergedConfig$setting !== void 0 ? _mergedConfig$setting : globalSettings, 35738 styles: (_mergedConfig$styles = mergedConfig?.styles) !== null && _mergedConfig$styles !== void 0 ? _mergedConfig$styles : globalStyles 35739 }, name, variation); 35740 return { 35741 settings: (_mergedConfig$setting2 = mergedConfig?.settings) !== null && _mergedConfig$setting2 !== void 0 ? _mergedConfig$setting2 : globalSettings, 35742 // The variation style data is all that is needed to generate 35743 // the styles for the current application to a block. The variation 35744 // name is updated to match the instance specific class name. 35745 styles: { 35746 blocks: { 35747 [name]: { 35748 variations: { 35749 [`$variation}-$clientId}`]: variationStyles 35750 } 35751 } 35752 } 35753 } 35754 }; 35755 }, [mergedConfig, globalSettings, globalStyles, variation, clientId, name]); 35756 } 35757 35758 // Rather than leveraging `useInstanceId` here, the `clientId` is used. 35759 // This is so that the variation style override's ID is predictable 35760 // when the order of applied style variations changes. 35761 function block_style_variation_useBlockProps({ 35762 name, 35763 className, 35764 clientId 35765 }) { 35766 const { 35767 getBlockStyles 35768 } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store); 35769 const registeredStyles = getBlockStyles(name); 35770 const variation = getVariationNameFromClass(className, registeredStyles); 35771 const variationClass = `$VARIATION_PREFIX}$variation}-$clientId}`; 35772 const { 35773 settings, 35774 styles 35775 } = useBlockStyleVariation(name, variation, clientId); 35776 const variationStyles = (0,external_wp_element_namespaceObject.useMemo)(() => { 35777 if (!variation) { 35778 return; 35779 } 35780 const variationConfig = { 35781 settings, 35782 styles 35783 }; 35784 const blockSelectors = getBlockSelectors((0,external_wp_blocks_namespaceObject.getBlockTypes)(), getBlockStyles, clientId); 35785 const hasBlockGapSupport = false; 35786 const hasFallbackGapSupport = true; 35787 const disableLayoutStyles = true; 35788 const disableRootPadding = true; 35789 return toStyles(variationConfig, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles, disableRootPadding, { 35790 blockGap: false, 35791 blockStyles: true, 35792 layoutStyles: false, 35793 marginReset: false, 35794 presets: false, 35795 rootPadding: false, 35796 variationStyles: true 35797 }); 35798 }, [variation, settings, styles, getBlockStyles, clientId]); 35799 usePrivateStyleOverride({ 35800 id: `variation-$clientId}`, 35801 css: variationStyles, 35802 __unstableType: 'variation', 35803 variation, 35804 // The clientId will be stored with the override and used to ensure 35805 // the order of overrides matches the order of blocks so that the 35806 // correct CSS cascade is maintained. 35807 clientId 35808 }); 35809 return variation ? { 35810 className: variationClass 35811 } : {}; 35812 } 35813 /* harmony default export */ const block_style_variation = ({ 35814 hasSupport: () => true, 35815 attributeKeys: ['className'], 35816 isMatch: ({ 35817 className 35818 }) => getVariationMatches(className).length > 0, 35819 useBlockProps: block_style_variation_useBlockProps 35820 }); 35821 35822 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/layout.js 35823 /** 35824 * External dependencies 35825 */ 35826 35827 35828 /** 35829 * WordPress dependencies 35830 */ 35831 35832 35833 35834 35835 35836 35837 35838 /** 35839 * Internal dependencies 35840 */ 35841 35842 35843 35844 35845 35846 35847 35848 35849 35850 35851 35852 const layoutBlockSupportKey = 'layout'; 35853 const { 35854 kebabCase: layout_kebabCase 35855 } = unlock(external_wp_components_namespaceObject.privateApis); 35856 function hasLayoutBlockSupport(blockName) { 35857 return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, 'layout') || (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, '__experimentalLayout'); 35858 } 35859 35860 /** 35861 * Generates the utility classnames for the given block's layout attributes. 35862 * 35863 * @param { Object } blockAttributes Block attributes. 35864 * @param { string } blockName Block name. 35865 * 35866 * @return { Array } Array of CSS classname strings. 35867 */ 35868 function useLayoutClasses(blockAttributes = {}, blockName = '') { 35869 const { 35870 layout 35871 } = blockAttributes; 35872 const { 35873 default: defaultBlockLayout 35874 } = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, layoutBlockSupportKey) || {}; 35875 const usedLayout = layout?.inherit || layout?.contentSize || layout?.wideSize ? { 35876 ...layout, 35877 type: 'constrained' 35878 } : layout || defaultBlockLayout || {}; 35879 const layoutClassnames = []; 35880 if (LAYOUT_DEFINITIONS[usedLayout?.type || 'default']?.className) { 35881 const baseClassName = LAYOUT_DEFINITIONS[usedLayout?.type || 'default']?.className; 35882 const splitBlockName = blockName.split('/'); 35883 const fullBlockName = splitBlockName[0] === 'core' ? splitBlockName.pop() : splitBlockName.join('-'); 35884 const compoundClassName = `wp-block-$fullBlockName}-$baseClassName}`; 35885 layoutClassnames.push(baseClassName, compoundClassName); 35886 } 35887 const hasGlobalPadding = (0,external_wp_data_namespaceObject.useSelect)(select => { 35888 return (usedLayout?.inherit || usedLayout?.contentSize || usedLayout?.type === 'constrained') && select(store).getSettings().__experimentalFeatures?.useRootPaddingAwareAlignments; 35889 }, [usedLayout?.contentSize, usedLayout?.inherit, usedLayout?.type]); 35890 if (hasGlobalPadding) { 35891 layoutClassnames.push('has-global-padding'); 35892 } 35893 if (usedLayout?.orientation) { 35894 layoutClassnames.push(`is-$layout_kebabCase(usedLayout.orientation)}`); 35895 } 35896 if (usedLayout?.justifyContent) { 35897 layoutClassnames.push(`is-content-justification-$layout_kebabCase(usedLayout.justifyContent)}`); 35898 } 35899 if (usedLayout?.flexWrap && usedLayout.flexWrap === 'nowrap') { 35900 layoutClassnames.push('is-nowrap'); 35901 } 35902 return layoutClassnames; 35903 } 35904 35905 /** 35906 * Generates a CSS rule with the given block's layout styles. 35907 * 35908 * @param { Object } blockAttributes Block attributes. 35909 * @param { string } blockName Block name. 35910 * @param { string } selector A selector to use in generating the CSS rule. 35911 * 35912 * @return { string } CSS rule. 35913 */ 35914 function useLayoutStyles(blockAttributes = {}, blockName, selector) { 35915 const { 35916 layout = {}, 35917 style = {} 35918 } = blockAttributes; 35919 // Update type for blocks using legacy layouts. 35920 const usedLayout = layout?.inherit || layout?.contentSize || layout?.wideSize ? { 35921 ...layout, 35922 type: 'constrained' 35923 } : layout || {}; 35924 const fullLayoutType = getLayoutType(usedLayout?.type || 'default'); 35925 const [blockGapSupport] = use_settings_useSettings('spacing.blockGap'); 35926 const hasBlockGapSupport = blockGapSupport !== null; 35927 return fullLayoutType?.getLayoutStyle?.({ 35928 blockName, 35929 selector, 35930 layout, 35931 style, 35932 hasBlockGapSupport 35933 }); 35934 } 35935 function LayoutPanelPure({ 35936 layout, 35937 setAttributes, 35938 name: blockName, 35939 clientId 35940 }) { 35941 const settings = useBlockSettings(blockName); 35942 // Block settings come from theme.json under settings.[blockName]. 35943 const { 35944 layout: layoutSettings 35945 } = settings; 35946 const { 35947 themeSupportsLayout 35948 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 35949 const { 35950 getSettings 35951 } = select(store); 35952 return { 35953 themeSupportsLayout: getSettings().supportsLayout 35954 }; 35955 }, []); 35956 const blockEditingMode = useBlockEditingMode(); 35957 if (blockEditingMode !== 'default') { 35958 return null; 35959 } 35960 35961 // Layout block support comes from the block's block.json. 35962 const layoutBlockSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, layoutBlockSupportKey, {}); 35963 const blockSupportAndThemeSettings = { 35964 ...layoutSettings, 35965 ...layoutBlockSupport 35966 }; 35967 const { 35968 allowSwitching, 35969 allowEditing = true, 35970 allowInheriting = true, 35971 default: defaultBlockLayout 35972 } = blockSupportAndThemeSettings; 35973 if (!allowEditing) { 35974 return null; 35975 } 35976 35977 /* 35978 * Try to find the layout type from either the 35979 * block's layout settings or any saved layout config. 35980 */ 35981 const blockSupportAndLayout = { 35982 ...layoutBlockSupport, 35983 ...layout 35984 }; 35985 const { 35986 type, 35987 default: { 35988 type: defaultType = 'default' 35989 } = {} 35990 } = blockSupportAndLayout; 35991 const blockLayoutType = type || defaultType; 35992 35993 // Only show the inherit toggle if it's supported, 35994 // and either the default / flow or the constrained layout type is in use, as the toggle switches from one to the other. 35995 const showInheritToggle = !!(allowInheriting && (!blockLayoutType || blockLayoutType === 'default' || blockLayoutType === 'constrained' || blockSupportAndLayout.inherit)); 35996 const usedLayout = layout || defaultBlockLayout || {}; 35997 const { 35998 inherit = false, 35999 contentSize = null 36000 } = usedLayout; 36001 /** 36002 * `themeSupportsLayout` is only relevant to the `default/flow` or 36003 * `constrained` layouts and it should not be taken into account when other 36004 * `layout` types are used. 36005 */ 36006 if ((blockLayoutType === 'default' || blockLayoutType === 'constrained') && !themeSupportsLayout) { 36007 return null; 36008 } 36009 const layoutType = getLayoutType(blockLayoutType); 36010 const constrainedType = getLayoutType('constrained'); 36011 const displayControlsForLegacyLayouts = !usedLayout.type && (contentSize || inherit); 36012 const hasContentSizeOrLegacySettings = !!inherit || !!contentSize; 36013 const onChangeType = newType => setAttributes({ 36014 layout: { 36015 type: newType 36016 } 36017 }); 36018 const onChangeLayout = newLayout => setAttributes({ 36019 layout: newLayout 36020 }); 36021 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 36022 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, { 36023 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.PanelBody, { 36024 title: (0,external_wp_i18n_namespaceObject.__)('Layout'), 36025 children: [showInheritToggle && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 36026 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, { 36027 __nextHasNoMarginBottom: true, 36028 label: (0,external_wp_i18n_namespaceObject.__)('Inner blocks use content width'), 36029 checked: layoutType?.name === 'constrained' || hasContentSizeOrLegacySettings, 36030 onChange: () => setAttributes({ 36031 layout: { 36032 type: layoutType?.name === 'constrained' || hasContentSizeOrLegacySettings ? 'default' : 'constrained' 36033 } 36034 }), 36035 help: layoutType?.name === 'constrained' || hasContentSizeOrLegacySettings ? (0,external_wp_i18n_namespaceObject.__)('Nested blocks use content width with options for full and wide widths.') : (0,external_wp_i18n_namespaceObject.__)('Nested blocks will fill the width of this container. Toggle to constrain.') 36036 }) 36037 }), !inherit && allowSwitching && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LayoutTypeSwitcher, { 36038 type: blockLayoutType, 36039 onChange: onChangeType 36040 }), layoutType && layoutType.name !== 'default' && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(layoutType.inspectorControls, { 36041 layout: usedLayout, 36042 onChange: onChangeLayout, 36043 layoutBlockSupport: blockSupportAndThemeSettings, 36044 name: blockName, 36045 clientId: clientId 36046 }), constrainedType && displayControlsForLegacyLayouts && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(constrainedType.inspectorControls, { 36047 layout: usedLayout, 36048 onChange: onChangeLayout, 36049 layoutBlockSupport: blockSupportAndThemeSettings, 36050 name: blockName, 36051 clientId: clientId 36052 })] 36053 }) 36054 }), !inherit && layoutType && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(layoutType.toolBarControls, { 36055 layout: usedLayout, 36056 onChange: onChangeLayout, 36057 layoutBlockSupport: layoutBlockSupport, 36058 name: blockName, 36059 clientId: clientId 36060 })] 36061 }); 36062 } 36063 /* harmony default export */ const layout = ({ 36064 shareWithChildBlocks: true, 36065 edit: LayoutPanelPure, 36066 attributeKeys: ['layout'], 36067 hasSupport(name) { 36068 return hasLayoutBlockSupport(name); 36069 } 36070 }); 36071 function LayoutTypeSwitcher({ 36072 type, 36073 onChange 36074 }) { 36075 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 36076 __next40pxDefaultSize: true, 36077 isBlock: true, 36078 label: (0,external_wp_i18n_namespaceObject.__)('Layout type'), 36079 __nextHasNoMarginBottom: true, 36080 hideLabelFromVision: true, 36081 isAdaptiveWidth: true, 36082 value: type, 36083 onChange: onChange, 36084 children: getLayoutTypes().map(({ 36085 name, 36086 label 36087 }) => { 36088 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, { 36089 value: name, 36090 label: label 36091 }, name); 36092 }) 36093 }); 36094 } 36095 36096 /** 36097 * Filters registered block settings, extending attributes to include `layout`. 36098 * 36099 * @param {Object} settings Original block settings. 36100 * 36101 * @return {Object} Filtered block settings. 36102 */ 36103 function layout_addAttribute(settings) { 36104 var _settings$attributes$; 36105 if ('type' in ((_settings$attributes$ = settings.attributes?.layout) !== null && _settings$attributes$ !== void 0 ? _settings$attributes$ : {})) { 36106 return settings; 36107 } 36108 if (hasLayoutBlockSupport(settings)) { 36109 settings.attributes = { 36110 ...settings.attributes, 36111 layout: { 36112 type: 'object' 36113 } 36114 }; 36115 } 36116 return settings; 36117 } 36118 function BlockWithLayoutStyles({ 36119 block: BlockListBlock, 36120 props, 36121 blockGapSupport, 36122 layoutClasses 36123 }) { 36124 const { 36125 name, 36126 attributes 36127 } = props; 36128 const id = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockListBlock); 36129 const { 36130 layout 36131 } = attributes; 36132 const { 36133 default: defaultBlockLayout 36134 } = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, layoutBlockSupportKey) || {}; 36135 const usedLayout = layout?.inherit || layout?.contentSize || layout?.wideSize ? { 36136 ...layout, 36137 type: 'constrained' 36138 } : layout || defaultBlockLayout || {}; 36139 const selectorPrefix = `wp-container-$layout_kebabCase(name)}-is-layout-`; 36140 // Higher specificity to override defaults from theme.json. 36141 const selector = `.$selectorPrefix}$id}`; 36142 const hasBlockGapSupport = blockGapSupport !== null; 36143 36144 // Get CSS string for the current layout type. 36145 // The CSS and `style` element is only output if it is not empty. 36146 const fullLayoutType = getLayoutType(usedLayout?.type || 'default'); 36147 const css = fullLayoutType?.getLayoutStyle?.({ 36148 blockName: name, 36149 selector, 36150 layout: usedLayout, 36151 style: attributes?.style, 36152 hasBlockGapSupport 36153 }); 36154 36155 // Attach a `wp-container-` id-based class name as well as a layout class name such as `is-layout-flex`. 36156 const layoutClassNames = dist_clsx({ 36157 [`$selectorPrefix}$id}`]: !!css // Only attach a container class if there is generated CSS to be attached. 36158 }, layoutClasses); 36159 useStyleOverride({ 36160 css 36161 }); 36162 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListBlock, { 36163 ...props, 36164 __unstableLayoutClassNames: layoutClassNames 36165 }); 36166 } 36167 36168 /** 36169 * Override the default block element to add the layout styles. 36170 * 36171 * @param {Function} BlockListBlock Original component. 36172 * 36173 * @return {Function} Wrapped component. 36174 */ 36175 const withLayoutStyles = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockListBlock => props => { 36176 const { 36177 clientId, 36178 name, 36179 attributes 36180 } = props; 36181 const blockSupportsLayout = hasLayoutBlockSupport(name); 36182 const layoutClasses = useLayoutClasses(attributes, name); 36183 const extraProps = (0,external_wp_data_namespaceObject.useSelect)(select => { 36184 // The callback returns early to avoid block editor subscription. 36185 if (!blockSupportsLayout) { 36186 return; 36187 } 36188 const { 36189 getSettings, 36190 getBlockSettings 36191 } = unlock(select(store)); 36192 const { 36193 disableLayoutStyles 36194 } = getSettings(); 36195 if (disableLayoutStyles) { 36196 return; 36197 } 36198 const [blockGapSupport] = getBlockSettings(clientId, 'spacing.blockGap'); 36199 return { 36200 blockGapSupport 36201 }; 36202 }, [blockSupportsLayout, clientId]); 36203 if (!extraProps) { 36204 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListBlock, { 36205 ...props, 36206 __unstableLayoutClassNames: blockSupportsLayout ? layoutClasses : undefined 36207 }); 36208 } 36209 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockWithLayoutStyles, { 36210 block: BlockListBlock, 36211 props: props, 36212 layoutClasses: layoutClasses, 36213 ...extraProps 36214 }); 36215 }, 'withLayoutStyles'); 36216 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/layout/addAttribute', layout_addAttribute); 36217 (0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockListBlock', 'core/editor/layout/with-layout-styles', withLayoutStyles); 36218 36219 ;// ./node_modules/@wordpress/block-editor/build-module/components/grid/utils.js 36220 function range(start, length) { 36221 return Array.from({ 36222 length 36223 }, (_, i) => start + i); 36224 } 36225 class GridRect { 36226 constructor({ 36227 columnStart, 36228 rowStart, 36229 columnEnd, 36230 rowEnd, 36231 columnSpan, 36232 rowSpan 36233 } = {}) { 36234 this.columnStart = columnStart !== null && columnStart !== void 0 ? columnStart : 1; 36235 this.rowStart = rowStart !== null && rowStart !== void 0 ? rowStart : 1; 36236 if (columnSpan !== undefined) { 36237 this.columnEnd = this.columnStart + columnSpan - 1; 36238 } else { 36239 this.columnEnd = columnEnd !== null && columnEnd !== void 0 ? columnEnd : this.columnStart; 36240 } 36241 if (rowSpan !== undefined) { 36242 this.rowEnd = this.rowStart + rowSpan - 1; 36243 } else { 36244 this.rowEnd = rowEnd !== null && rowEnd !== void 0 ? rowEnd : this.rowStart; 36245 } 36246 } 36247 get columnSpan() { 36248 return this.columnEnd - this.columnStart + 1; 36249 } 36250 get rowSpan() { 36251 return this.rowEnd - this.rowStart + 1; 36252 } 36253 contains(column, row) { 36254 return column >= this.columnStart && column <= this.columnEnd && row >= this.rowStart && row <= this.rowEnd; 36255 } 36256 containsRect(rect) { 36257 return this.contains(rect.columnStart, rect.rowStart) && this.contains(rect.columnEnd, rect.rowEnd); 36258 } 36259 intersectsRect(rect) { 36260 return this.columnStart <= rect.columnEnd && this.columnEnd >= rect.columnStart && this.rowStart <= rect.rowEnd && this.rowEnd >= rect.rowStart; 36261 } 36262 } 36263 function utils_getComputedCSS(element, property) { 36264 return element.ownerDocument.defaultView.getComputedStyle(element).getPropertyValue(property); 36265 } 36266 36267 /** 36268 * Given a grid-template-columns or grid-template-rows CSS property value, gets the start and end 36269 * position in pixels of each grid track. 36270 * 36271 * https://css-tricks.com/snippets/css/complete-guide-grid/#aa-grid-track 36272 * 36273 * @param {string} template The grid-template-columns or grid-template-rows CSS property value. 36274 * Only supports fixed sizes in pixels. 36275 * @param {number} gap The gap between grid tracks in pixels. 36276 * 36277 * @return {Array<{start: number, end: number}>} An array of objects with the start and end 36278 * position in pixels of each grid track. 36279 */ 36280 function getGridTracks(template, gap) { 36281 const tracks = []; 36282 for (const size of template.split(' ')) { 36283 const previousTrack = tracks[tracks.length - 1]; 36284 const start = previousTrack ? previousTrack.end + gap : 0; 36285 const end = start + parseFloat(size); 36286 tracks.push({ 36287 start, 36288 end 36289 }); 36290 } 36291 return tracks; 36292 } 36293 36294 /** 36295 * Given an array of grid tracks and a position in pixels, gets the index of the closest track to 36296 * that position. 36297 * 36298 * https://css-tricks.com/snippets/css/complete-guide-grid/#aa-grid-track 36299 * 36300 * @param {Array<{start: number, end: number}>} tracks An array of objects with the start and end 36301 * position in pixels of each grid track. 36302 * @param {number} position The position in pixels. 36303 * @param {string} edge The edge of the track to compare the 36304 * position to. Either 'start' or 'end'. 36305 * 36306 * @return {number} The index of the closest track to the position. 0-based, unlike CSS grid which 36307 * is 1-based. 36308 */ 36309 function getClosestTrack(tracks, position, edge = 'start') { 36310 return tracks.reduce((closest, track, index) => Math.abs(track[edge] - position) < Math.abs(tracks[closest][edge] - position) ? index : closest, 0); 36311 } 36312 function getGridRect(gridElement, rect) { 36313 const columnGap = parseFloat(utils_getComputedCSS(gridElement, 'column-gap')); 36314 const rowGap = parseFloat(utils_getComputedCSS(gridElement, 'row-gap')); 36315 const gridColumnTracks = getGridTracks(utils_getComputedCSS(gridElement, 'grid-template-columns'), columnGap); 36316 const gridRowTracks = getGridTracks(utils_getComputedCSS(gridElement, 'grid-template-rows'), rowGap); 36317 const columnStart = getClosestTrack(gridColumnTracks, rect.left) + 1; 36318 const rowStart = getClosestTrack(gridRowTracks, rect.top) + 1; 36319 const columnEnd = getClosestTrack(gridColumnTracks, rect.right, 'end') + 1; 36320 const rowEnd = getClosestTrack(gridRowTracks, rect.bottom, 'end') + 1; 36321 return new GridRect({ 36322 columnStart, 36323 columnEnd, 36324 rowStart, 36325 rowEnd 36326 }); 36327 } 36328 function getGridItemRect(gridItemElement) { 36329 return getGridRect(gridItemElement.parentElement, new window.DOMRect(gridItemElement.offsetLeft, gridItemElement.offsetTop, gridItemElement.offsetWidth, gridItemElement.offsetHeight)); 36330 } 36331 function getGridInfo(gridElement) { 36332 const gridTemplateColumns = utils_getComputedCSS(gridElement, 'grid-template-columns'); 36333 const gridTemplateRows = utils_getComputedCSS(gridElement, 'grid-template-rows'); 36334 const numColumns = gridTemplateColumns.split(' ').length; 36335 const numRows = gridTemplateRows.split(' ').length; 36336 const numItems = numColumns * numRows; 36337 return { 36338 numColumns, 36339 numRows, 36340 numItems, 36341 currentColor: utils_getComputedCSS(gridElement, 'color'), 36342 style: { 36343 gridTemplateColumns, 36344 gridTemplateRows, 36345 gap: utils_getComputedCSS(gridElement, 'gap'), 36346 padding: utils_getComputedCSS(gridElement, 'padding') 36347 } 36348 }; 36349 } 36350 36351 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/tips.js 36352 /** 36353 * WordPress dependencies 36354 */ 36355 36356 36357 36358 36359 const globalTips = [(0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)('While writing, you can press <kbd>/</kbd> to quickly insert new blocks.'), { 36360 kbd: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("kbd", {}) 36361 }), (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)('Indent a list by pressing <kbd>space</kbd> at the beginning of a line.'), { 36362 kbd: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("kbd", {}) 36363 }), (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)('Outdent a list by pressing <kbd>backspace</kbd> at the beginning of a line.'), { 36364 kbd: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("kbd", {}) 36365 }), (0,external_wp_i18n_namespaceObject.__)('Drag files into the editor to automatically insert media blocks.'), (0,external_wp_i18n_namespaceObject.__)("Change a block's type by pressing the block icon on the toolbar.")]; 36366 function Tips() { 36367 const [randomIndex] = (0,external_wp_element_namespaceObject.useState)( 36368 // Disable Reason: I'm not generating an HTML id. 36369 // eslint-disable-next-line no-restricted-syntax 36370 Math.floor(Math.random() * globalTips.length)); 36371 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tip, { 36372 children: globalTips[randomIndex] 36373 }); 36374 } 36375 /* harmony default export */ const tips = (Tips); 36376 36377 ;// ./node_modules/@wordpress/icons/build-module/library/chevron-right.js 36378 /** 36379 * WordPress dependencies 36380 */ 36381 36382 36383 const chevronRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 36384 xmlns: "http://www.w3.org/2000/svg", 36385 viewBox: "0 0 24 24", 36386 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 36387 d: "M10.6 6L9.4 7l4.6 5-4.6 5 1.2 1 5.4-6z" 36388 }) 36389 }); 36390 /* harmony default export */ const chevron_right = (chevronRight); 36391 36392 ;// ./node_modules/@wordpress/icons/build-module/library/chevron-left.js 36393 /** 36394 * WordPress dependencies 36395 */ 36396 36397 36398 const chevronLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 36399 xmlns: "http://www.w3.org/2000/svg", 36400 viewBox: "0 0 24 24", 36401 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 36402 d: "M14.6 7l-1.2-1L8 12l5.4 6 1.2-1-4.6-5z" 36403 }) 36404 }); 36405 /* harmony default export */ const chevron_left = (chevronLeft); 36406 36407 ;// ./node_modules/@wordpress/icons/build-module/library/block-default.js 36408 /** 36409 * WordPress dependencies 36410 */ 36411 36412 36413 const blockDefault = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 36414 xmlns: "http://www.w3.org/2000/svg", 36415 viewBox: "0 0 24 24", 36416 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 36417 d: "M19 8h-1V6h-5v2h-2V6H6v2H5c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-8c0-1.1-.9-2-2-2zm.5 10c0 .3-.2.5-.5.5H5c-.3 0-.5-.2-.5-.5v-8c0-.3.2-.5.5-.5h14c.3 0 .5.2.5.5v8z" 36418 }) 36419 }); 36420 /* harmony default export */ const block_default = (blockDefault); 36421 36422 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-icon/index.js 36423 /** 36424 * External dependencies 36425 */ 36426 36427 36428 /** 36429 * WordPress dependencies 36430 */ 36431 36432 36433 36434 36435 function BlockIcon({ 36436 icon, 36437 showColors = false, 36438 className, 36439 context 36440 }) { 36441 if (icon?.src === 'block-default') { 36442 icon = { 36443 src: block_default 36444 }; 36445 } 36446 const renderedIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, { 36447 icon: icon && icon.src ? icon.src : icon, 36448 context: context 36449 }); 36450 const style = showColors ? { 36451 backgroundColor: icon && icon.background, 36452 color: icon && icon.foreground 36453 } : {}; 36454 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 36455 style: style, 36456 className: dist_clsx('block-editor-block-icon', className, { 36457 'has-colors': showColors 36458 }), 36459 children: renderedIcon 36460 }); 36461 } 36462 36463 /** 36464 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-icon/README.md 36465 */ 36466 /* harmony default export */ const block_icon = ((0,external_wp_element_namespaceObject.memo)(BlockIcon)); 36467 36468 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-card/index.js 36469 /** 36470 * External dependencies 36471 */ 36472 36473 36474 /** 36475 * WordPress dependencies 36476 */ 36477 36478 36479 36480 36481 36482 36483 /** 36484 * Internal dependencies 36485 */ 36486 36487 36488 36489 36490 function BlockCard({ 36491 title, 36492 icon, 36493 description, 36494 blockType, 36495 className, 36496 name 36497 }) { 36498 if (blockType) { 36499 external_wp_deprecated_default()('`blockType` property in `BlockCard component`', { 36500 since: '5.7', 36501 alternative: '`title, icon and description` properties' 36502 }); 36503 ({ 36504 title, 36505 icon, 36506 description 36507 } = blockType); 36508 } 36509 const { 36510 parentNavBlockClientId 36511 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 36512 const { 36513 getSelectedBlockClientId, 36514 getBlockParentsByBlockName 36515 } = select(store); 36516 const _selectedBlockClientId = getSelectedBlockClientId(); 36517 return { 36518 parentNavBlockClientId: getBlockParentsByBlockName(_selectedBlockClientId, 'core/navigation', true)[0] 36519 }; 36520 }, []); 36521 const { 36522 selectBlock 36523 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 36524 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 36525 className: dist_clsx('block-editor-block-card', className), 36526 children: [parentNavBlockClientId && 36527 /*#__PURE__*/ 36528 // This is only used by the Navigation block for now. It's not ideal having Navigation block specific code here. 36529 (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 36530 onClick: () => selectBlock(parentNavBlockClientId), 36531 label: (0,external_wp_i18n_namespaceObject.__)('Go to parent Navigation block'), 36532 style: 36533 // TODO: This style override is also used in ToolsPanelHeader. 36534 // It should be supported out-of-the-box by Button. 36535 { 36536 minWidth: 24, 36537 padding: 0 36538 }, 36539 icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left, 36540 size: "small" 36541 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 36542 icon: icon, 36543 showColors: true 36544 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 36545 spacing: 1, 36546 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("h2", { 36547 className: "block-editor-block-card__title", 36548 children: name?.length ? (0,external_wp_i18n_namespaceObject.sprintf)( 36549 // translators: 1: Custom block name. 2: Block title. 36550 (0,external_wp_i18n_namespaceObject._x)('%1$s (%2$s)', 'block label'), name, title) : title 36551 }), description && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, { 36552 className: "block-editor-block-card__description", 36553 children: description 36554 })] 36555 })] 36556 }); 36557 } 36558 /* harmony default export */ const block_card = (BlockCard); 36559 36560 ;// ./node_modules/@wordpress/block-editor/build-module/components/provider/with-registry-provider.js 36561 /** 36562 * WordPress dependencies 36563 */ 36564 36565 36566 36567 36568 /** 36569 * Internal dependencies 36570 */ 36571 36572 36573 36574 function getSubRegistry(subRegistries, registry, useSubRegistry) { 36575 if (!useSubRegistry) { 36576 return registry; 36577 } 36578 let subRegistry = subRegistries.get(registry); 36579 if (!subRegistry) { 36580 subRegistry = (0,external_wp_data_namespaceObject.createRegistry)({}, registry); 36581 subRegistry.registerStore(STORE_NAME, storeConfig); 36582 subRegistries.set(registry, subRegistry); 36583 } 36584 return subRegistry; 36585 } 36586 const withRegistryProvider = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent => ({ 36587 useSubRegistry = true, 36588 ...props 36589 }) => { 36590 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 36591 const [subRegistries] = (0,external_wp_element_namespaceObject.useState)(() => new WeakMap()); 36592 const subRegistry = getSubRegistry(subRegistries, registry, useSubRegistry); 36593 if (subRegistry === registry) { 36594 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { 36595 registry: registry, 36596 ...props 36597 }); 36598 } 36599 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_data_namespaceObject.RegistryProvider, { 36600 value: subRegistry, 36601 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { 36602 registry: subRegistry, 36603 ...props 36604 }) 36605 }); 36606 }, 'withRegistryProvider'); 36607 /* harmony default export */ const with_registry_provider = (withRegistryProvider); 36608 36609 ;// ./node_modules/@wordpress/block-editor/build-module/components/provider/use-block-sync.js 36610 /** 36611 * WordPress dependencies 36612 */ 36613 36614 36615 36616 36617 /** 36618 * Internal dependencies 36619 */ 36620 36621 const use_block_sync_noop = () => {}; 36622 36623 /** 36624 * A function to call when the block value has been updated in the block-editor 36625 * store. 36626 * 36627 * @callback onBlockUpdate 36628 * @param {Object[]} blocks The updated blocks. 36629 * @param {Object} options The updated block options, such as selectionStart 36630 * and selectionEnd. 36631 */ 36632 36633 /** 36634 * useBlockSync is a side effect which handles bidirectional sync between the 36635 * block-editor store and a controlling data source which provides blocks. This 36636 * is most commonly used by the BlockEditorProvider to synchronize the contents 36637 * of the block-editor store with the root entity, like a post. 36638 * 36639 * Another example would be the template part block, which provides blocks from 36640 * a separate entity data source than a root entity. This hook syncs edits to 36641 * the template part in the block editor back to the entity and vice-versa. 36642 * 36643 * Here are some of its basic functions: 36644 * - Initalizes the block-editor store for the given clientID to the blocks 36645 * given via props. 36646 * - Adds incoming changes (like undo) to the block-editor store. 36647 * - Adds outgoing changes (like editing content) to the controlling entity, 36648 * determining if a change should be considered persistent or not. 36649 * - Handles edge cases and race conditions which occur in those operations. 36650 * - Ignores changes which happen to other entities (like nested inner block 36651 * controllers. 36652 * - Passes selection state from the block-editor store to the controlling entity. 36653 * 36654 * @param {Object} props Props for the block sync hook 36655 * @param {string} props.clientId The client ID of the inner block controller. 36656 * If none is passed, then it is assumed to be a 36657 * root controller rather than an inner block 36658 * controller. 36659 * @param {Object[]} props.value The control value for the blocks. This value 36660 * is used to initalize the block-editor store 36661 * and for resetting the blocks to incoming 36662 * changes like undo. 36663 * @param {Object} props.selection The selection state responsible to restore the selection on undo/redo. 36664 * @param {onBlockUpdate} props.onChange Function to call when a persistent 36665 * change has been made in the block-editor blocks 36666 * for the given clientId. For example, after 36667 * this function is called, an entity is marked 36668 * dirty because it has changes to save. 36669 * @param {onBlockUpdate} props.onInput Function to call when a non-persistent 36670 * change has been made in the block-editor blocks 36671 * for the given clientId. When this is called, 36672 * controlling sources do not become dirty. 36673 */ 36674 function useBlockSync({ 36675 clientId = null, 36676 value: controlledBlocks, 36677 selection: controlledSelection, 36678 onChange = use_block_sync_noop, 36679 onInput = use_block_sync_noop 36680 }) { 36681 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 36682 const { 36683 resetBlocks, 36684 resetSelection, 36685 replaceInnerBlocks, 36686 setHasControlledInnerBlocks, 36687 __unstableMarkNextChangeAsNotPersistent 36688 } = registry.dispatch(store); 36689 const { 36690 getBlockName, 36691 getBlocks, 36692 getSelectionStart, 36693 getSelectionEnd 36694 } = registry.select(store); 36695 const isControlled = (0,external_wp_data_namespaceObject.useSelect)(select => { 36696 return !clientId || select(store).areInnerBlocksControlled(clientId); 36697 }, [clientId]); 36698 const pendingChangesRef = (0,external_wp_element_namespaceObject.useRef)({ 36699 incoming: null, 36700 outgoing: [] 36701 }); 36702 const subscribedRef = (0,external_wp_element_namespaceObject.useRef)(false); 36703 const setControlledBlocks = () => { 36704 if (!controlledBlocks) { 36705 return; 36706 } 36707 36708 // We don't need to persist this change because we only replace 36709 // controlled inner blocks when the change was caused by an entity, 36710 // and so it would already be persisted. 36711 __unstableMarkNextChangeAsNotPersistent(); 36712 if (clientId) { 36713 // It is important to batch here because otherwise, 36714 // as soon as `setHasControlledInnerBlocks` is called 36715 // the effect to restore might be triggered 36716 // before the actual blocks get set properly in state. 36717 registry.batch(() => { 36718 setHasControlledInnerBlocks(clientId, true); 36719 const storeBlocks = controlledBlocks.map(block => (0,external_wp_blocks_namespaceObject.cloneBlock)(block)); 36720 if (subscribedRef.current) { 36721 pendingChangesRef.current.incoming = storeBlocks; 36722 } 36723 __unstableMarkNextChangeAsNotPersistent(); 36724 replaceInnerBlocks(clientId, storeBlocks); 36725 }); 36726 } else { 36727 if (subscribedRef.current) { 36728 pendingChangesRef.current.incoming = controlledBlocks; 36729 } 36730 resetBlocks(controlledBlocks); 36731 } 36732 }; 36733 36734 // Clean up the changes made by setControlledBlocks() when the component 36735 // containing useBlockSync() unmounts. 36736 const unsetControlledBlocks = () => { 36737 __unstableMarkNextChangeAsNotPersistent(); 36738 if (clientId) { 36739 setHasControlledInnerBlocks(clientId, false); 36740 __unstableMarkNextChangeAsNotPersistent(); 36741 replaceInnerBlocks(clientId, []); 36742 } else { 36743 resetBlocks([]); 36744 } 36745 }; 36746 36747 // Add a subscription to the block-editor registry to detect when changes 36748 // have been made. This lets us inform the data source of changes. This 36749 // is an effect so that the subscriber can run synchronously without 36750 // waiting for React renders for changes. 36751 const onInputRef = (0,external_wp_element_namespaceObject.useRef)(onInput); 36752 const onChangeRef = (0,external_wp_element_namespaceObject.useRef)(onChange); 36753 (0,external_wp_element_namespaceObject.useEffect)(() => { 36754 onInputRef.current = onInput; 36755 onChangeRef.current = onChange; 36756 }, [onInput, onChange]); 36757 36758 // Determine if blocks need to be reset when they change. 36759 (0,external_wp_element_namespaceObject.useEffect)(() => { 36760 if (pendingChangesRef.current.outgoing.includes(controlledBlocks)) { 36761 // Skip block reset if the value matches expected outbound sync 36762 // triggered by this component by a preceding change detection. 36763 // Only skip if the value matches expectation, since a reset should 36764 // still occur if the value is modified (not equal by reference), 36765 // to allow that the consumer may apply modifications to reflect 36766 // back on the editor. 36767 if (pendingChangesRef.current.outgoing[pendingChangesRef.current.outgoing.length - 1] === controlledBlocks) { 36768 pendingChangesRef.current.outgoing = []; 36769 } 36770 } else if (getBlocks(clientId) !== controlledBlocks) { 36771 // Reset changing value in all other cases than the sync described 36772 // above. Since this can be reached in an update following an out- 36773 // bound sync, unset the outbound value to avoid considering it in 36774 // subsequent renders. 36775 pendingChangesRef.current.outgoing = []; 36776 setControlledBlocks(); 36777 if (controlledSelection) { 36778 resetSelection(controlledSelection.selectionStart, controlledSelection.selectionEnd, controlledSelection.initialPosition); 36779 } 36780 } 36781 }, [controlledBlocks, clientId]); 36782 const isMountedRef = (0,external_wp_element_namespaceObject.useRef)(false); 36783 (0,external_wp_element_namespaceObject.useEffect)(() => { 36784 // On mount, controlled blocks are already set in the effect above. 36785 if (!isMountedRef.current) { 36786 isMountedRef.current = true; 36787 return; 36788 } 36789 36790 // When the block becomes uncontrolled, it means its inner state has been reset 36791 // we need to take the blocks again from the external value property. 36792 if (!isControlled) { 36793 pendingChangesRef.current.outgoing = []; 36794 setControlledBlocks(); 36795 } 36796 }, [isControlled]); 36797 (0,external_wp_element_namespaceObject.useEffect)(() => { 36798 const { 36799 getSelectedBlocksInitialCaretPosition, 36800 isLastBlockChangePersistent, 36801 __unstableIsLastBlockChangeIgnored, 36802 areInnerBlocksControlled 36803 } = registry.select(store); 36804 let blocks = getBlocks(clientId); 36805 let isPersistent = isLastBlockChangePersistent(); 36806 let previousAreBlocksDifferent = false; 36807 subscribedRef.current = true; 36808 const unsubscribe = registry.subscribe(() => { 36809 // Sometimes, when changing block lists, lingering subscriptions 36810 // might trigger before they are cleaned up. If the block for which 36811 // the subscription runs is no longer in the store, this would clear 36812 // its parent entity's block list. To avoid this, we bail out if 36813 // the subscription is triggering for a block (`clientId !== null`) 36814 // and its block name can't be found because it's not on the list. 36815 // (`getBlockName( clientId ) === null`). 36816 if (clientId !== null && getBlockName(clientId) === null) { 36817 return; 36818 } 36819 36820 // When RESET_BLOCKS on parent blocks get called, the controlled blocks 36821 // can reset to uncontrolled, in these situations, it means we need to populate 36822 // the blocks again from the external blocks (the value property here) 36823 // and we should stop triggering onChange 36824 const isStillControlled = !clientId || areInnerBlocksControlled(clientId); 36825 if (!isStillControlled) { 36826 return; 36827 } 36828 const newIsPersistent = isLastBlockChangePersistent(); 36829 const newBlocks = getBlocks(clientId); 36830 const areBlocksDifferent = newBlocks !== blocks; 36831 blocks = newBlocks; 36832 if (areBlocksDifferent && (pendingChangesRef.current.incoming || __unstableIsLastBlockChangeIgnored())) { 36833 pendingChangesRef.current.incoming = null; 36834 isPersistent = newIsPersistent; 36835 return; 36836 } 36837 36838 // Since we often dispatch an action to mark the previous action as 36839 // persistent, we need to make sure that the blocks changed on the 36840 // previous action before committing the change. 36841 const didPersistenceChange = previousAreBlocksDifferent && !areBlocksDifferent && newIsPersistent && !isPersistent; 36842 if (areBlocksDifferent || didPersistenceChange) { 36843 isPersistent = newIsPersistent; 36844 // We know that onChange/onInput will update controlledBlocks. 36845 // We need to be aware that it was caused by an outgoing change 36846 // so that we do not treat it as an incoming change later on, 36847 // which would cause a block reset. 36848 pendingChangesRef.current.outgoing.push(blocks); 36849 36850 // Inform the controlling entity that changes have been made to 36851 // the block-editor store they should be aware about. 36852 const updateParent = isPersistent ? onChangeRef.current : onInputRef.current; 36853 updateParent(blocks, { 36854 selection: { 36855 selectionStart: getSelectionStart(), 36856 selectionEnd: getSelectionEnd(), 36857 initialPosition: getSelectedBlocksInitialCaretPosition() 36858 } 36859 }); 36860 } 36861 previousAreBlocksDifferent = areBlocksDifferent; 36862 }, store); 36863 return () => { 36864 subscribedRef.current = false; 36865 unsubscribe(); 36866 }; 36867 }, [registry, clientId]); 36868 (0,external_wp_element_namespaceObject.useEffect)(() => { 36869 return () => { 36870 unsetControlledBlocks(); 36871 }; 36872 }, []); 36873 } 36874 36875 ;// external ["wp","keyboardShortcuts"] 36876 const external_wp_keyboardShortcuts_namespaceObject = window["wp"]["keyboardShortcuts"]; 36877 ;// ./node_modules/@wordpress/block-editor/build-module/components/keyboard-shortcuts/index.js 36878 /** 36879 * WordPress dependencies 36880 */ 36881 36882 36883 36884 36885 function KeyboardShortcuts() { 36886 return null; 36887 } 36888 function KeyboardShortcutsRegister() { 36889 // Registering the shortcuts. 36890 const { 36891 registerShortcut 36892 } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_keyboardShortcuts_namespaceObject.store); 36893 (0,external_wp_element_namespaceObject.useEffect)(() => { 36894 registerShortcut({ 36895 name: 'core/block-editor/duplicate', 36896 category: 'block', 36897 description: (0,external_wp_i18n_namespaceObject.__)('Duplicate the selected block(s).'), 36898 keyCombination: { 36899 modifier: 'primaryShift', 36900 character: 'd' 36901 } 36902 }); 36903 registerShortcut({ 36904 name: 'core/block-editor/remove', 36905 category: 'block', 36906 description: (0,external_wp_i18n_namespaceObject.__)('Remove the selected block(s).'), 36907 keyCombination: { 36908 modifier: 'access', 36909 character: 'z' 36910 } 36911 }); 36912 registerShortcut({ 36913 name: 'core/block-editor/insert-before', 36914 category: 'block', 36915 description: (0,external_wp_i18n_namespaceObject.__)('Insert a new block before the selected block(s).'), 36916 keyCombination: { 36917 modifier: 'primaryAlt', 36918 character: 't' 36919 } 36920 }); 36921 registerShortcut({ 36922 name: 'core/block-editor/insert-after', 36923 category: 'block', 36924 description: (0,external_wp_i18n_namespaceObject.__)('Insert a new block after the selected block(s).'), 36925 keyCombination: { 36926 modifier: 'primaryAlt', 36927 character: 'y' 36928 } 36929 }); 36930 registerShortcut({ 36931 name: 'core/block-editor/delete-multi-selection', 36932 category: 'block', 36933 description: (0,external_wp_i18n_namespaceObject.__)('Delete selection.'), 36934 keyCombination: { 36935 character: 'del' 36936 }, 36937 aliases: [{ 36938 character: 'backspace' 36939 }] 36940 }); 36941 registerShortcut({ 36942 name: 'core/block-editor/select-all', 36943 category: 'selection', 36944 description: (0,external_wp_i18n_namespaceObject.__)('Select all text when typing. Press again to select all blocks.'), 36945 keyCombination: { 36946 modifier: 'primary', 36947 character: 'a' 36948 } 36949 }); 36950 registerShortcut({ 36951 name: 'core/block-editor/unselect', 36952 category: 'selection', 36953 description: (0,external_wp_i18n_namespaceObject.__)('Clear selection.'), 36954 keyCombination: { 36955 character: 'escape' 36956 } 36957 }); 36958 registerShortcut({ 36959 name: 'core/block-editor/multi-text-selection', 36960 category: 'selection', 36961 description: (0,external_wp_i18n_namespaceObject.__)('Select text across multiple blocks.'), 36962 keyCombination: { 36963 modifier: 'shift', 36964 character: 'arrow' 36965 } 36966 }); 36967 registerShortcut({ 36968 name: 'core/block-editor/focus-toolbar', 36969 category: 'global', 36970 description: (0,external_wp_i18n_namespaceObject.__)('Navigate to the nearest toolbar.'), 36971 keyCombination: { 36972 modifier: 'alt', 36973 character: 'F10' 36974 } 36975 }); 36976 registerShortcut({ 36977 name: 'core/block-editor/move-up', 36978 category: 'block', 36979 description: (0,external_wp_i18n_namespaceObject.__)('Move the selected block(s) up.'), 36980 keyCombination: { 36981 modifier: 'secondary', 36982 character: 't' 36983 } 36984 }); 36985 registerShortcut({ 36986 name: 'core/block-editor/move-down', 36987 category: 'block', 36988 description: (0,external_wp_i18n_namespaceObject.__)('Move the selected block(s) down.'), 36989 keyCombination: { 36990 modifier: 'secondary', 36991 character: 'y' 36992 } 36993 }); 36994 36995 // List view shortcuts. 36996 registerShortcut({ 36997 name: 'core/block-editor/collapse-list-view', 36998 category: 'list-view', 36999 description: (0,external_wp_i18n_namespaceObject.__)('Collapse all other items.'), 37000 keyCombination: { 37001 modifier: 'alt', 37002 character: 'l' 37003 } 37004 }); 37005 registerShortcut({ 37006 name: 'core/block-editor/group', 37007 category: 'block', 37008 description: (0,external_wp_i18n_namespaceObject.__)('Create a group block from the selected multiple blocks.'), 37009 keyCombination: { 37010 modifier: 'primary', 37011 character: 'g' 37012 } 37013 }); 37014 }, [registerShortcut]); 37015 return null; 37016 } 37017 KeyboardShortcuts.Register = KeyboardShortcutsRegister; 37018 /* harmony default export */ const keyboard_shortcuts = (KeyboardShortcuts); 37019 37020 ;// ./node_modules/@wordpress/block-editor/build-module/components/provider/index.js 37021 /** 37022 * WordPress dependencies 37023 */ 37024 37025 37026 37027 37028 /** 37029 * Internal dependencies 37030 */ 37031 37032 37033 37034 37035 37036 37037 37038 /** @typedef {import('@wordpress/data').WPDataRegistry} WPDataRegistry */ 37039 37040 37041 const ExperimentalBlockEditorProvider = with_registry_provider(props => { 37042 const { 37043 children, 37044 settings, 37045 stripExperimentalSettings = false 37046 } = props; 37047 const { 37048 __experimentalUpdateSettings 37049 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 37050 (0,external_wp_element_namespaceObject.useEffect)(() => { 37051 __experimentalUpdateSettings({ 37052 ...settings, 37053 __internalIsInitialized: true 37054 }, { 37055 stripExperimentalSettings, 37056 reset: true 37057 }); 37058 }, [settings, stripExperimentalSettings, __experimentalUpdateSettings]); 37059 37060 // Syncs the entity provider with changes in the block-editor store. 37061 useBlockSync(props); 37062 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.SlotFillProvider, { 37063 passthrough: true, 37064 children: [!settings?.__unstableIsPreviewMode && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(keyboard_shortcuts.Register, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockRefsProvider, { 37065 children: children 37066 })] 37067 }); 37068 }); 37069 const BlockEditorProvider = props => { 37070 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ExperimentalBlockEditorProvider, { 37071 ...props, 37072 stripExperimentalSettings: true, 37073 children: props.children 37074 }); 37075 }; 37076 /* harmony default export */ const provider = (BlockEditorProvider); 37077 37078 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-context/index.js 37079 /** 37080 * WordPress dependencies 37081 */ 37082 37083 37084 /** @typedef {import('react').ReactNode} ReactNode */ 37085 37086 /** 37087 * @typedef BlockContextProviderProps 37088 * 37089 * @property {Record<string,*>} value Context value to merge with current 37090 * value. 37091 * @property {ReactNode} children Component children. 37092 */ 37093 37094 /** @type {import('react').Context<Record<string,*>>} */ 37095 37096 const block_context_Context = (0,external_wp_element_namespaceObject.createContext)({}); 37097 37098 /** 37099 * Component which merges passed value with current consumed block context. 37100 * 37101 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-context/README.md 37102 * 37103 * @param {BlockContextProviderProps} props 37104 */ 37105 function BlockContextProvider({ 37106 value, 37107 children 37108 }) { 37109 const context = (0,external_wp_element_namespaceObject.useContext)(block_context_Context); 37110 const nextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({ 37111 ...context, 37112 ...value 37113 }), [context, value]); 37114 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_context_Context.Provider, { 37115 value: nextValue, 37116 children: children 37117 }); 37118 } 37119 /* harmony default export */ const block_context = (block_context_Context); 37120 37121 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit/edit.js 37122 /** 37123 * External dependencies 37124 */ 37125 37126 37127 /** 37128 * WordPress dependencies 37129 */ 37130 37131 37132 37133 37134 /** 37135 * Internal dependencies 37136 */ 37137 37138 37139 /** 37140 * Default value used for blocks which do not define their own context needs, 37141 * used to guarantee that a block's `context` prop will always be an object. It 37142 * is assigned as a constant since it is always expected to be an empty object, 37143 * and in order to avoid unnecessary React reconciliations of a changing object. 37144 * 37145 * @type {{}} 37146 */ 37147 37148 const DEFAULT_BLOCK_CONTEXT = {}; 37149 const Edit = props => { 37150 const { 37151 name 37152 } = props; 37153 const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name); 37154 if (!blockType) { 37155 return null; 37156 } 37157 37158 // `edit` and `save` are functions or components describing the markup 37159 // with which a block is displayed. If `blockType` is valid, assign 37160 // them preferentially as the render value for the block. 37161 const Component = blockType.edit || blockType.save; 37162 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, { 37163 ...props 37164 }); 37165 }; 37166 const EditWithFilters = (0,external_wp_components_namespaceObject.withFilters)('editor.BlockEdit')(Edit); 37167 const EditWithGeneratedProps = props => { 37168 const { 37169 attributes = {}, 37170 name 37171 } = props; 37172 const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name); 37173 const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context); 37174 37175 // Assign context values using the block type's declared context needs. 37176 const context = (0,external_wp_element_namespaceObject.useMemo)(() => { 37177 return blockType && blockType.usesContext ? Object.fromEntries(Object.entries(blockContext).filter(([key]) => blockType.usesContext.includes(key))) : DEFAULT_BLOCK_CONTEXT; 37178 }, [blockType, blockContext]); 37179 if (!blockType) { 37180 return null; 37181 } 37182 if (blockType.apiVersion > 1) { 37183 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditWithFilters, { 37184 ...props, 37185 context: context 37186 }); 37187 } 37188 37189 // Generate a class name for the block's editable form. 37190 const generatedClassName = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'className', true) ? (0,external_wp_blocks_namespaceObject.getBlockDefaultClassName)(name) : null; 37191 const className = dist_clsx(generatedClassName, attributes.className, props.className); 37192 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditWithFilters, { 37193 ...props, 37194 context: context, 37195 className: className 37196 }); 37197 }; 37198 /* harmony default export */ const block_edit_edit = (EditWithGeneratedProps); 37199 37200 ;// ./node_modules/@wordpress/icons/build-module/library/more-vertical.js 37201 /** 37202 * WordPress dependencies 37203 */ 37204 37205 37206 const moreVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 37207 xmlns: "http://www.w3.org/2000/svg", 37208 viewBox: "0 0 24 24", 37209 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 37210 d: "M13 19h-2v-2h2v2zm0-6h-2v-2h2v2zm0-6h-2V5h2v2z" 37211 }) 37212 }); 37213 /* harmony default export */ const more_vertical = (moreVertical); 37214 37215 ;// ./node_modules/@wordpress/block-editor/build-module/components/warning/index.js 37216 /** 37217 * External dependencies 37218 */ 37219 37220 37221 /** 37222 * WordPress dependencies 37223 */ 37224 37225 37226 37227 37228 37229 37230 function Warning({ 37231 className, 37232 actions, 37233 children, 37234 secondaryActions 37235 }) { 37236 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 37237 style: { 37238 display: 'contents', 37239 all: 'initial' 37240 }, 37241 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 37242 className: dist_clsx(className, 'block-editor-warning'), 37243 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 37244 className: "block-editor-warning__contents", 37245 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 37246 className: "block-editor-warning__message", 37247 children: children 37248 }), (external_wp_element_namespaceObject.Children.count(actions) > 0 || secondaryActions) && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 37249 className: "block-editor-warning__actions", 37250 children: [external_wp_element_namespaceObject.Children.count(actions) > 0 && external_wp_element_namespaceObject.Children.map(actions, (action, i) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 37251 className: "block-editor-warning__action", 37252 children: action 37253 }, i)), secondaryActions && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, { 37254 className: "block-editor-warning__secondary", 37255 icon: more_vertical, 37256 label: (0,external_wp_i18n_namespaceObject.__)('More options'), 37257 popoverProps: { 37258 position: 'bottom left', 37259 className: 'block-editor-warning__dropdown' 37260 }, 37261 noIcons: true, 37262 children: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, { 37263 children: secondaryActions.map((item, pos) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 37264 onClick: item.onClick, 37265 children: item.title 37266 }, pos)) 37267 }) 37268 })] 37269 })] 37270 }) 37271 }) 37272 }); 37273 } 37274 37275 /** 37276 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/warning/README.md 37277 */ 37278 /* harmony default export */ const warning = (Warning); 37279 37280 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit/multiple-usage-warning.js 37281 /** 37282 * WordPress dependencies 37283 */ 37284 37285 37286 37287 37288 37289 /** 37290 * Internal dependencies 37291 */ 37292 37293 37294 37295 37296 function MultipleUsageWarning({ 37297 originalBlockClientId, 37298 name, 37299 onReplace 37300 }) { 37301 const { 37302 selectBlock 37303 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 37304 const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name); 37305 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(warning, { 37306 actions: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 37307 __next40pxDefaultSize: true, 37308 variant: "secondary", 37309 onClick: () => selectBlock(originalBlockClientId), 37310 children: (0,external_wp_i18n_namespaceObject.__)('Find original') 37311 }, "find-original"), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 37312 __next40pxDefaultSize: true, 37313 variant: "secondary", 37314 onClick: () => onReplace([]), 37315 children: (0,external_wp_i18n_namespaceObject.__)('Remove') 37316 }, "remove")], 37317 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("strong", { 37318 children: [blockType?.title, ": "] 37319 }), (0,external_wp_i18n_namespaceObject.__)('This block can only be used once.')] 37320 }); 37321 } 37322 37323 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/private-block-context.js 37324 /** 37325 * WordPress dependencies 37326 */ 37327 37328 const PrivateBlockContext = (0,external_wp_element_namespaceObject.createContext)({}); 37329 37330 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit/index.js 37331 /** 37332 * WordPress dependencies 37333 */ 37334 37335 37336 37337 /** 37338 * Internal dependencies 37339 */ 37340 37341 37342 37343 37344 37345 /** 37346 * The `useBlockEditContext` hook provides information about the block this hook is being used in. 37347 * It returns an object with the `name`, `isSelected` state, and the `clientId` of the block. 37348 * It is useful if you want to create custom hooks that need access to the current blocks clientId 37349 * but don't want to rely on the data getting passed in as a parameter. 37350 * 37351 * @return {Object} Block edit context 37352 */ 37353 37354 37355 37356 function BlockEdit({ 37357 mayDisplayControls, 37358 mayDisplayParentControls, 37359 blockEditingMode, 37360 isPreviewMode, 37361 // The remaining props are passed through the BlockEdit filters and are thus 37362 // public API! 37363 ...props 37364 }) { 37365 const { 37366 name, 37367 isSelected, 37368 clientId, 37369 attributes = {}, 37370 __unstableLayoutClassNames 37371 } = props; 37372 const { 37373 layout = null, 37374 metadata = {} 37375 } = attributes; 37376 const { 37377 bindings 37378 } = metadata; 37379 const layoutSupport = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'layout', false) || (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, '__experimentalLayout', false); 37380 const { 37381 originalBlockClientId 37382 } = (0,external_wp_element_namespaceObject.useContext)(PrivateBlockContext); 37383 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Provider 37384 // It is important to return the same object if props haven't 37385 // changed to avoid unnecessary rerenders. 37386 // See https://reactjs.org/docs/context.html#caveats. 37387 , { 37388 value: (0,external_wp_element_namespaceObject.useMemo)(() => ({ 37389 name, 37390 isSelected, 37391 clientId, 37392 layout: layoutSupport ? layout : null, 37393 __unstableLayoutClassNames, 37394 // We use symbols in favour of an __unstable prefix to avoid 37395 // usage outside of the package (this context is exposed). 37396 [mayDisplayControlsKey]: mayDisplayControls, 37397 [mayDisplayParentControlsKey]: mayDisplayParentControls, 37398 [blockEditingModeKey]: blockEditingMode, 37399 [blockBindingsKey]: bindings, 37400 [isPreviewModeKey]: isPreviewMode 37401 }), [name, isSelected, clientId, layoutSupport, layout, __unstableLayoutClassNames, mayDisplayControls, mayDisplayParentControls, blockEditingMode, bindings, isPreviewMode]), 37402 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_edit_edit, { 37403 ...props 37404 }), originalBlockClientId && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MultipleUsageWarning, { 37405 originalBlockClientId: originalBlockClientId, 37406 name: name, 37407 onReplace: props.onReplace 37408 })] 37409 }); 37410 } 37411 37412 // EXTERNAL MODULE: ./node_modules/diff/lib/diff/character.js 37413 var character = __webpack_require__(8021); 37414 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-compare/block-view.js 37415 /** 37416 * WordPress dependencies 37417 */ 37418 37419 37420 37421 37422 37423 function BlockView({ 37424 title, 37425 rawContent, 37426 renderedContent, 37427 action, 37428 actionText, 37429 className 37430 }) { 37431 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 37432 className: className, 37433 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 37434 className: "block-editor-block-compare__content", 37435 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("h2", { 37436 className: "block-editor-block-compare__heading", 37437 children: title 37438 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 37439 className: "block-editor-block-compare__html", 37440 children: rawContent 37441 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 37442 className: "block-editor-block-compare__preview edit-post-visual-editor", 37443 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.RawHTML, { 37444 children: (0,external_wp_dom_namespaceObject.safeHTML)(renderedContent) 37445 }) 37446 })] 37447 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 37448 className: "block-editor-block-compare__action", 37449 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 37450 __next40pxDefaultSize: true, 37451 variant: "secondary", 37452 tabIndex: "0", 37453 onClick: action, 37454 children: actionText 37455 }) 37456 })] 37457 }); 37458 } 37459 37460 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-compare/index.js 37461 /** 37462 * External dependencies 37463 */ 37464 37465 // diff doesn't tree-shake correctly, so we import from the individual 37466 // module here, to avoid including too much of the library 37467 37468 37469 /** 37470 * WordPress dependencies 37471 */ 37472 37473 37474 37475 /** 37476 * Internal dependencies 37477 */ 37478 37479 37480 37481 function BlockCompare({ 37482 block, 37483 onKeep, 37484 onConvert, 37485 convertor, 37486 convertButtonText 37487 }) { 37488 function getDifference(originalContent, newContent) { 37489 const difference = (0,character/* diffChars */.JJ)(originalContent, newContent); 37490 return difference.map((item, pos) => { 37491 const classes = dist_clsx({ 37492 'block-editor-block-compare__added': item.added, 37493 'block-editor-block-compare__removed': item.removed 37494 }); 37495 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 37496 className: classes, 37497 children: item.value 37498 }, pos); 37499 }); 37500 } 37501 function getConvertedContent(convertedBlock) { 37502 // The convertor may return an array of items or a single item. 37503 const newBlocks = Array.isArray(convertedBlock) ? convertedBlock : [convertedBlock]; 37504 37505 // Get converted block details. 37506 const newContent = newBlocks.map(item => (0,external_wp_blocks_namespaceObject.getSaveContent)(item.name, item.attributes, item.innerBlocks)); 37507 return newContent.join(''); 37508 } 37509 const converted = getConvertedContent(convertor(block)); 37510 const difference = getDifference(block.originalContent, converted); 37511 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 37512 className: "block-editor-block-compare__wrapper", 37513 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockView, { 37514 title: (0,external_wp_i18n_namespaceObject.__)('Current'), 37515 className: "block-editor-block-compare__current", 37516 action: onKeep, 37517 actionText: (0,external_wp_i18n_namespaceObject.__)('Convert to HTML'), 37518 rawContent: block.originalContent, 37519 renderedContent: block.originalContent 37520 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockView, { 37521 title: (0,external_wp_i18n_namespaceObject.__)('After Conversion'), 37522 className: "block-editor-block-compare__converted", 37523 action: onConvert, 37524 actionText: convertButtonText, 37525 rawContent: difference, 37526 renderedContent: converted 37527 })] 37528 }); 37529 } 37530 /* harmony default export */ const block_compare = (BlockCompare); 37531 37532 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-invalid-warning.js 37533 /** 37534 * WordPress dependencies 37535 */ 37536 37537 37538 37539 37540 37541 37542 /** 37543 * Internal dependencies 37544 */ 37545 37546 37547 37548 37549 37550 37551 const blockToBlocks = block => (0,external_wp_blocks_namespaceObject.rawHandler)({ 37552 HTML: block.originalContent 37553 }); 37554 function BlockInvalidWarning({ 37555 clientId 37556 }) { 37557 const { 37558 block, 37559 canInsertHTMLBlock, 37560 canInsertClassicBlock 37561 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 37562 const { 37563 canInsertBlockType, 37564 getBlock, 37565 getBlockRootClientId 37566 } = select(store); 37567 const rootClientId = getBlockRootClientId(clientId); 37568 return { 37569 block: getBlock(clientId), 37570 canInsertHTMLBlock: canInsertBlockType('core/html', rootClientId), 37571 canInsertClassicBlock: canInsertBlockType('core/freeform', rootClientId) 37572 }; 37573 }, [clientId]); 37574 const { 37575 replaceBlock 37576 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 37577 const [compare, setCompare] = (0,external_wp_element_namespaceObject.useState)(false); 37578 const onCompareClose = (0,external_wp_element_namespaceObject.useCallback)(() => setCompare(false), []); 37579 const convert = (0,external_wp_element_namespaceObject.useMemo)(() => ({ 37580 toClassic() { 37581 const classicBlock = (0,external_wp_blocks_namespaceObject.createBlock)('core/freeform', { 37582 content: block.originalContent 37583 }); 37584 return replaceBlock(block.clientId, classicBlock); 37585 }, 37586 toHTML() { 37587 const htmlBlock = (0,external_wp_blocks_namespaceObject.createBlock)('core/html', { 37588 content: block.originalContent 37589 }); 37590 return replaceBlock(block.clientId, htmlBlock); 37591 }, 37592 toBlocks() { 37593 const newBlocks = blockToBlocks(block); 37594 return replaceBlock(block.clientId, newBlocks); 37595 }, 37596 toRecoveredBlock() { 37597 const recoveredBlock = (0,external_wp_blocks_namespaceObject.createBlock)(block.name, block.attributes, block.innerBlocks); 37598 return replaceBlock(block.clientId, recoveredBlock); 37599 } 37600 }), [block, replaceBlock]); 37601 const secondaryActions = (0,external_wp_element_namespaceObject.useMemo)(() => [{ 37602 // translators: Button to fix block content 37603 title: (0,external_wp_i18n_namespaceObject._x)('Resolve', 'imperative verb'), 37604 onClick: () => setCompare(true) 37605 }, canInsertHTMLBlock && { 37606 title: (0,external_wp_i18n_namespaceObject.__)('Convert to HTML'), 37607 onClick: convert.toHTML 37608 }, canInsertClassicBlock && { 37609 title: (0,external_wp_i18n_namespaceObject.__)('Convert to Classic Block'), 37610 onClick: convert.toClassic 37611 }].filter(Boolean), [canInsertHTMLBlock, canInsertClassicBlock, convert]); 37612 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 37613 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(warning, { 37614 actions: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 37615 __next40pxDefaultSize: true, 37616 onClick: convert.toRecoveredBlock, 37617 variant: "primary", 37618 children: (0,external_wp_i18n_namespaceObject.__)('Attempt recovery') 37619 }, "recover")], 37620 secondaryActions: secondaryActions, 37621 children: (0,external_wp_i18n_namespaceObject.__)('Block contains unexpected or invalid content.') 37622 }), compare && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, { 37623 title: 37624 // translators: Dialog title to fix block content 37625 (0,external_wp_i18n_namespaceObject.__)('Resolve Block'), 37626 onRequestClose: onCompareClose, 37627 className: "block-editor-block-compare", 37628 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_compare, { 37629 block: block, 37630 onKeep: convert.toHTML, 37631 onConvert: convert.toBlocks, 37632 convertor: blockToBlocks, 37633 convertButtonText: (0,external_wp_i18n_namespaceObject.__)('Convert to Blocks') 37634 }) 37635 })] 37636 }); 37637 } 37638 37639 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-crash-warning.js 37640 /** 37641 * WordPress dependencies 37642 */ 37643 37644 37645 /** 37646 * Internal dependencies 37647 */ 37648 37649 37650 const block_crash_warning_warning = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(warning, { 37651 className: "block-editor-block-list__block-crash-warning", 37652 children: (0,external_wp_i18n_namespaceObject.__)('This block has encountered an error and cannot be previewed.') 37653 }); 37654 /* harmony default export */ const block_crash_warning = (() => block_crash_warning_warning); 37655 37656 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-crash-boundary.js 37657 /** 37658 * WordPress dependencies 37659 */ 37660 37661 class BlockCrashBoundary extends external_wp_element_namespaceObject.Component { 37662 constructor() { 37663 super(...arguments); 37664 this.state = { 37665 hasError: false 37666 }; 37667 } 37668 componentDidCatch() { 37669 this.setState({ 37670 hasError: true 37671 }); 37672 } 37673 render() { 37674 if (this.state.hasError) { 37675 return this.props.fallback; 37676 } 37677 return this.props.children; 37678 } 37679 } 37680 /* harmony default export */ const block_crash_boundary = (BlockCrashBoundary); 37681 37682 // EXTERNAL MODULE: ./node_modules/react-autosize-textarea/lib/index.js 37683 var lib = __webpack_require__(4132); 37684 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-html.js 37685 /** 37686 * External dependencies 37687 */ 37688 37689 37690 /** 37691 * WordPress dependencies 37692 */ 37693 37694 37695 37696 37697 /** 37698 * Internal dependencies 37699 */ 37700 37701 37702 function BlockHTML({ 37703 clientId 37704 }) { 37705 const [html, setHtml] = (0,external_wp_element_namespaceObject.useState)(''); 37706 const block = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getBlock(clientId), [clientId]); 37707 const { 37708 updateBlock 37709 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 37710 const onChange = () => { 37711 const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(block.name); 37712 if (!blockType) { 37713 return; 37714 } 37715 const attributes = (0,external_wp_blocks_namespaceObject.getBlockAttributes)(blockType, html, block.attributes); 37716 37717 // If html is empty we reset the block to the default HTML and mark it as valid to avoid triggering an error 37718 const content = html ? html : (0,external_wp_blocks_namespaceObject.getSaveContent)(blockType, attributes); 37719 const [isValid] = html ? (0,external_wp_blocks_namespaceObject.validateBlock)({ 37720 ...block, 37721 attributes, 37722 originalContent: content 37723 }) : [true]; 37724 updateBlock(clientId, { 37725 attributes, 37726 originalContent: content, 37727 isValid 37728 }); 37729 37730 // Ensure the state is updated if we reset so it displays the default content. 37731 if (!html) { 37732 setHtml(content); 37733 } 37734 }; 37735 (0,external_wp_element_namespaceObject.useEffect)(() => { 37736 setHtml((0,external_wp_blocks_namespaceObject.getBlockContent)(block)); 37737 }, [block]); 37738 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(lib/* default */.A, { 37739 className: "block-editor-block-list__block-html-textarea", 37740 value: html, 37741 onBlur: onChange, 37742 onChange: event => setHtml(event.target.value) 37743 }); 37744 } 37745 /* harmony default export */ const block_html = (BlockHTML); 37746 37747 ;// ./node_modules/@react-spring/rafz/dist/esm/index.js 37748 var esm_f=esm_l(),esm_n=e=>esm_c(e,esm_f),esm_m=esm_l();esm_n.write=e=>esm_c(e,esm_m);var esm_d=esm_l();esm_n.onStart=e=>esm_c(e,esm_d);var esm_h=esm_l();esm_n.onFrame=e=>esm_c(e,esm_h);var esm_p=esm_l();esm_n.onFinish=e=>esm_c(e,esm_p);var esm_i=[];esm_n.setTimeout=(e,t)=>{let a=esm_n.now()+t,o=()=>{let F=esm_i.findIndex(z=>z.cancel==o);~F&&esm_i.splice(F,1),esm_u-=~F?1:0},s={time:a,handler:e,cancel:o};return esm_i.splice(esm_w(a),0,s),esm_u+=1,esm_v(),s};var esm_w=e=>~(~esm_i.findIndex(t=>t.time>e)||~esm_i.length);esm_n.cancel=e=>{esm_d.delete(e),esm_h.delete(e),esm_p.delete(e),esm_f.delete(e),esm_m.delete(e)};esm_n.sync=e=>{T=!0,esm_n.batchedUpdates(e),T=!1};esm_n.throttle=e=>{let t;function a(){try{e(...t)}finally{t=null}}function o(...s){t=s,esm_n.onStart(a)}return o.handler=e,o.cancel=()=>{esm_d.delete(a),t=null},o};var esm_y=typeof window<"u"?window.requestAnimationFrame:()=>{};esm_n.use=e=>esm_y=e;esm_n.now=typeof performance<"u"?()=>performance.now():Date.now;esm_n.batchedUpdates=e=>e();esm_n.catch=console.error;esm_n.frameLoop="always";esm_n.advance=()=>{esm_n.frameLoop!=="demand"?console.warn("Cannot call the manual advancement of rafz whilst frameLoop is not set as demand"):esm_x()};var esm_r=-1,esm_u=0,T=!1;function esm_c(e,t){T?(t.delete(e),e(0)):(t.add(e),esm_v())}function esm_v(){esm_r<0&&(esm_r=0,esm_n.frameLoop!=="demand"&&esm_y(esm_b))}function esm_R(){esm_r=-1}function esm_b(){~esm_r&&(esm_y(esm_b),esm_n.batchedUpdates(esm_x))}function esm_x(){let e=esm_r;esm_r=esm_n.now();let t=esm_w(esm_r);if(t&&(Q(esm_i.splice(0,t),a=>a.handler()),esm_u-=t),!esm_u){esm_R();return}esm_d.flush(),esm_f.flush(e?Math.min(64,esm_r-e):16.667),esm_h.flush(),esm_m.flush(),esm_p.flush()}function esm_l(){let e=new Set,t=e;return{add(a){esm_u+=t==e&&!e.has(a)?1:0,e.add(a)},delete(a){return esm_u-=t==e&&e.has(a)?1:0,e.delete(a)},flush(a){t.size&&(e=new Set,esm_u-=t.size,Q(t,o=>o(a)&&e.add(o)),esm_u+=e.size,t=e)}}}function Q(e,t){e.forEach(a=>{try{t(a)}catch(o){esm_n.catch(o)}})}var esm_S={count(){return esm_u},isRunning(){return esm_r>=0},clear(){esm_r=-1,esm_i=[],esm_d=esm_l(),esm_f=esm_l(),esm_h=esm_l(),esm_m=esm_l(),esm_p=esm_l(),esm_u=0}}; 37749 37750 ;// ./node_modules/@react-spring/shared/dist/esm/index.js 37751 var ze=Object.defineProperty;var Le=(e,t)=>{for(var r in t)ze(e,r,{get:t[r],enumerable:!0})};var dist_esm_p={};Le(dist_esm_p,{assign:()=>U,colors:()=>dist_esm_c,createStringInterpolator:()=>esm_k,skipAnimation:()=>ee,to:()=>J,willAdvance:()=>dist_esm_S});function Y(){}var mt=(e,t,r)=>Object.defineProperty(e,t,{value:r,writable:!0,configurable:!0}),dist_esm_l={arr:Array.isArray,obj:e=>!!e&&e.constructor.name==="Object",fun:e=>typeof e=="function",str:e=>typeof e=="string",num:e=>typeof e=="number",und:e=>e===void 0};function bt(e,t){if(dist_esm_l.arr(e)){if(!dist_esm_l.arr(t)||e.length!==t.length)return!1;for(let r=0;r<e.length;r++)if(e[r]!==t[r])return!1;return!0}return e===t}var esm_Ve=(e,t)=>e.forEach(t);function xt(e,t,r){if(dist_esm_l.arr(e)){for(let n=0;n<e.length;n++)t.call(r,e[n],`$n}`);return}for(let n in e)e.hasOwnProperty(n)&&t.call(r,e[n],n)}var ht=e=>dist_esm_l.und(e)?[]:dist_esm_l.arr(e)?e:[e];function Pe(e,t){if(e.size){let r=Array.from(e);e.clear(),esm_Ve(r,t)}}var yt=(e,...t)=>Pe(e,r=>r(...t)),dist_esm_h=()=>typeof window>"u"||!window.navigator||/ServerSideRendering|^Deno\//.test(window.navigator.userAgent);var esm_k,J,dist_esm_c=null,ee=!1,dist_esm_S=Y,U=e=>{e.to&&(J=e.to),e.now&&(esm_n.now=e.now),e.colors!==void 0&&(dist_esm_c=e.colors),e.skipAnimation!=null&&(ee=e.skipAnimation),e.createStringInterpolator&&(esm_k=e.createStringInterpolator),e.requestAnimationFrame&&esm_n.use(e.requestAnimationFrame),e.batchedUpdates&&(esm_n.batchedUpdates=e.batchedUpdates),e.willAdvance&&(dist_esm_S=e.willAdvance),e.frameLoop&&(esm_n.frameLoop=e.frameLoop)};var esm_E=new Set,dist_esm_u=[],esm_H=[],A=0,qe={get idle(){return!esm_E.size&&!dist_esm_u.length},start(e){A>e.priority?(esm_E.add(e),esm_n.onStart($e)):(te(e),esm_n(B))},advance:B,sort(e){if(A)esm_n.onFrame(()=>qe.sort(e));else{let t=dist_esm_u.indexOf(e);~t&&(dist_esm_u.splice(t,1),re(e))}},clear(){dist_esm_u=[],esm_E.clear()}};function $e(){esm_E.forEach(te),esm_E.clear(),esm_n(B)}function te(e){dist_esm_u.includes(e)||re(e)}function re(e){dist_esm_u.splice(Ge(dist_esm_u,t=>t.priority>e.priority),0,e)}function B(e){let t=esm_H;for(let r=0;r<dist_esm_u.length;r++){let n=dist_esm_u[r];A=n.priority,n.idle||(dist_esm_S(n),n.advance(e),n.idle||t.push(n))}return A=0,esm_H=dist_esm_u,esm_H.length=0,dist_esm_u=t,dist_esm_u.length>0}function Ge(e,t){let r=e.findIndex(t);return r<0?e.length:r}var ne=(e,t,r)=>Math.min(Math.max(r,e),t);var It={transparent:0,aliceblue:4042850303,antiquewhite:4209760255,aqua:16777215,aquamarine:2147472639,azure:4043309055,beige:4126530815,bisque:4293182719,black:255,blanchedalmond:4293643775,blue:65535,blueviolet:2318131967,brown:2771004159,burlywood:3736635391,burntsienna:3934150143,cadetblue:1604231423,chartreuse:2147418367,chocolate:3530104575,coral:4286533887,cornflowerblue:1687547391,cornsilk:4294499583,crimson:3692313855,cyan:16777215,darkblue:35839,darkcyan:9145343,darkgoldenrod:3095792639,darkgray:2846468607,darkgreen:6553855,darkgrey:2846468607,darkkhaki:3182914559,darkmagenta:2332068863,darkolivegreen:1433087999,darkorange:4287365375,darkorchid:2570243327,darkred:2332033279,darksalmon:3918953215,darkseagreen:2411499519,darkslateblue:1211993087,darkslategray:793726975,darkslategrey:793726975,darkturquoise:13554175,darkviolet:2483082239,deeppink:4279538687,deepskyblue:12582911,dimgray:1768516095,dimgrey:1768516095,dodgerblue:512819199,firebrick:2988581631,floralwhite:4294635775,forestgreen:579543807,fuchsia:4278255615,gainsboro:3705462015,ghostwhite:4177068031,gold:4292280575,goldenrod:3668254975,gray:2155905279,green:8388863,greenyellow:2919182335,grey:2155905279,honeydew:4043305215,hotpink:4285117695,indianred:3445382399,indigo:1258324735,ivory:4294963455,khaki:4041641215,lavender:3873897215,lavenderblush:4293981695,lawngreen:2096890111,lemonchiffon:4294626815,lightblue:2916673279,lightcoral:4034953471,lightcyan:3774873599,lightgoldenrodyellow:4210742015,lightgray:3553874943,lightgreen:2431553791,lightgrey:3553874943,lightpink:4290167295,lightsalmon:4288707327,lightseagreen:548580095,lightskyblue:2278488831,lightslategray:2005441023,lightslategrey:2005441023,lightsteelblue:2965692159,lightyellow:4294959359,lime:16711935,limegreen:852308735,linen:4210091775,magenta:4278255615,maroon:2147483903,mediumaquamarine:1724754687,mediumblue:52735,mediumorchid:3126187007,mediumpurple:2473647103,mediumseagreen:1018393087,mediumslateblue:2070474495,mediumspringgreen:16423679,mediumturquoise:1221709055,mediumvioletred:3340076543,midnightblue:421097727,mintcream:4127193855,mistyrose:4293190143,moccasin:4293178879,navajowhite:4292783615,navy:33023,oldlace:4260751103,olive:2155872511,olivedrab:1804477439,orange:4289003775,orangered:4282712319,orchid:3664828159,palegoldenrod:4008225535,palegreen:2566625535,paleturquoise:2951671551,palevioletred:3681588223,papayawhip:4293907967,peachpuff:4292524543,peru:3448061951,pink:4290825215,plum:3718307327,powderblue:2967529215,purple:2147516671,rebeccapurple:1714657791,red:4278190335,rosybrown:3163525119,royalblue:1097458175,saddlebrown:2336560127,salmon:4202722047,sandybrown:4104413439,seagreen:780883967,seashell:4294307583,sienna:2689740287,silver:3233857791,skyblue:2278484991,slateblue:1784335871,slategray:1887473919,slategrey:1887473919,snow:4294638335,springgreen:16744447,steelblue:1182971135,tan:3535047935,teal:8421631,thistle:3636451583,tomato:4284696575,turquoise:1088475391,violet:4001558271,wheat:4125012991,white:4294967295,whitesmoke:4126537215,yellow:4294902015,yellowgreen:2597139199};var dist_esm_d="[-+]?\\d*\\.?\\d+",esm_M=dist_esm_d+"%";function C(...e){return"\\(\\s*("+e.join(")\\s*,\\s*(")+")\\s*\\)"}var oe=new RegExp("rgb"+C(dist_esm_d,dist_esm_d,dist_esm_d)),fe=new RegExp("rgba"+C(dist_esm_d,dist_esm_d,dist_esm_d,dist_esm_d)),ae=new RegExp("hsl"+C(dist_esm_d,esm_M,esm_M)),ie=new RegExp("hsla"+C(dist_esm_d,esm_M,esm_M,dist_esm_d)),se=/^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,ue=/^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,le=/^#([0-9a-fA-F]{6})$/,esm_ce=/^#([0-9a-fA-F]{8})$/;function be(e){let t;return typeof e=="number"?e>>>0===e&&e>=0&&e<=4294967295?e:null:(t=le.exec(e))?parseInt(t[1]+"ff",16)>>>0:dist_esm_c&&dist_esm_c[e]!==void 0?dist_esm_c[e]:(t=oe.exec(e))?(dist_esm_y(t[1])<<24|dist_esm_y(t[2])<<16|dist_esm_y(t[3])<<8|255)>>>0:(t=fe.exec(e))?(dist_esm_y(t[1])<<24|dist_esm_y(t[2])<<16|dist_esm_y(t[3])<<8|me(t[4]))>>>0:(t=se.exec(e))?parseInt(t[1]+t[1]+t[2]+t[2]+t[3]+t[3]+"ff",16)>>>0:(t=esm_ce.exec(e))?parseInt(t[1],16)>>>0:(t=ue.exec(e))?parseInt(t[1]+t[1]+t[2]+t[2]+t[3]+t[3]+t[4]+t[4],16)>>>0:(t=ae.exec(e))?(de(esm_pe(t[1]),esm_z(t[2]),esm_z(t[3]))|255)>>>0:(t=ie.exec(e))?(de(esm_pe(t[1]),esm_z(t[2]),esm_z(t[3]))|me(t[4]))>>>0:null}function esm_j(e,t,r){return r<0&&(r+=1),r>1&&(r-=1),r<1/6?e+(t-e)*6*r:r<1/2?t:r<2/3?e+(t-e)*(2/3-r)*6:e}function de(e,t,r){let n=r<.5?r*(1+t):r+t-r*t,f=2*r-n,o=esm_j(f,n,e+1/3),i=esm_j(f,n,e),s=esm_j(f,n,e-1/3);return Math.round(o*255)<<24|Math.round(i*255)<<16|Math.round(s*255)<<8}function dist_esm_y(e){let t=parseInt(e,10);return t<0?0:t>255?255:t}function esm_pe(e){return(parseFloat(e)%360+360)%360/360}function me(e){let t=parseFloat(e);return t<0?0:t>1?255:Math.round(t*255)}function esm_z(e){let t=parseFloat(e);return t<0?0:t>100?1:t/100}function D(e){let t=be(e);if(t===null)return e;t=t||0;let r=(t&4278190080)>>>24,n=(t&16711680)>>>16,f=(t&65280)>>>8,o=(t&255)/255;return`rgba($r}, $n}, $f}, $o})`}var W=(e,t,r)=>{if(dist_esm_l.fun(e))return e;if(dist_esm_l.arr(e))return W({range:e,output:t,extrapolate:r});if(dist_esm_l.str(e.output[0]))return esm_k(e);let n=e,f=n.output,o=n.range||[0,1],i=n.extrapolateLeft||n.extrapolate||"extend",s=n.extrapolateRight||n.extrapolate||"extend",x=n.easing||(a=>a);return a=>{let F=He(a,o);return Ue(a,o[F],o[F+1],f[F],f[F+1],x,i,s,n.map)}};function Ue(e,t,r,n,f,o,i,s,x){let a=x?x(e):e;if(a<t){if(i==="identity")return a;i==="clamp"&&(a=t)}if(a>r){if(s==="identity")return a;s==="clamp"&&(a=r)}return n===f?n:t===r?e<=t?n:f:(t===-1/0?a=-a:r===1/0?a=a-t:a=(a-t)/(r-t),a=o(a),n===-1/0?a=-a:f===1/0?a=a+n:a=a*(f-n)+n,a)}function He(e,t){for(var r=1;r<t.length-1&&!(t[r]>=e);++r);return r-1}var Be=(e,t="end")=>r=>{r=t==="end"?Math.min(r,.999):Math.max(r,.001);let n=r*e,f=t==="end"?Math.floor(n):Math.ceil(n);return ne(0,1,f/e)},P=1.70158,L=P*1.525,xe=P+1,he=2*Math.PI/3,ye=2*Math.PI/4.5,V=e=>e<1/2.75?7.5625*e*e:e<2/2.75?7.5625*(e-=1.5/2.75)*e+.75:e<2.5/2.75?7.5625*(e-=2.25/2.75)*e+.9375:7.5625*(e-=2.625/2.75)*e+.984375,Lt={linear:e=>e,easeInQuad:e=>e*e,easeOutQuad:e=>1-(1-e)*(1-e),easeInOutQuad:e=>e<.5?2*e*e:1-Math.pow(-2*e+2,2)/2,easeInCubic:e=>e*e*e,easeOutCubic:e=>1-Math.pow(1-e,3),easeInOutCubic:e=>e<.5?4*e*e*e:1-Math.pow(-2*e+2,3)/2,easeInQuart:e=>e*e*e*e,easeOutQuart:e=>1-Math.pow(1-e,4),easeInOutQuart:e=>e<.5?8*e*e*e*e:1-Math.pow(-2*e+2,4)/2,easeInQuint:e=>e*e*e*e*e,easeOutQuint:e=>1-Math.pow(1-e,5),easeInOutQuint:e=>e<.5?16*e*e*e*e*e:1-Math.pow(-2*e+2,5)/2,easeInSine:e=>1-Math.cos(e*Math.PI/2),easeOutSine:e=>Math.sin(e*Math.PI/2),easeInOutSine:e=>-(Math.cos(Math.PI*e)-1)/2,easeInExpo:e=>e===0?0:Math.pow(2,10*e-10),easeOutExpo:e=>e===1?1:1-Math.pow(2,-10*e),easeInOutExpo:e=>e===0?0:e===1?1:e<.5?Math.pow(2,20*e-10)/2:(2-Math.pow(2,-20*e+10))/2,easeInCirc:e=>1-Math.sqrt(1-Math.pow(e,2)),easeOutCirc:e=>Math.sqrt(1-Math.pow(e-1,2)),easeInOutCirc:e=>e<.5?(1-Math.sqrt(1-Math.pow(2*e,2)))/2:(Math.sqrt(1-Math.pow(-2*e+2,2))+1)/2,easeInBack:e=>xe*e*e*e-P*e*e,easeOutBack:e=>1+xe*Math.pow(e-1,3)+P*Math.pow(e-1,2),easeInOutBack:e=>e<.5?Math.pow(2*e,2)*((L+1)*2*e-L)/2:(Math.pow(2*e-2,2)*((L+1)*(e*2-2)+L)+2)/2,easeInElastic:e=>e===0?0:e===1?1:-Math.pow(2,10*e-10)*Math.sin((e*10-10.75)*he),easeOutElastic:e=>e===0?0:e===1?1:Math.pow(2,-10*e)*Math.sin((e*10-.75)*he)+1,easeInOutElastic:e=>e===0?0:e===1?1:e<.5?-(Math.pow(2,20*e-10)*Math.sin((20*e-11.125)*ye))/2:Math.pow(2,-20*e+10)*Math.sin((20*e-11.125)*ye)/2+1,easeInBounce:e=>1-V(1-e),easeOutBounce:V,easeInOutBounce:e=>e<.5?(1-V(1-2*e))/2:(1+V(2*e-1))/2,steps:Be};var esm_g=Symbol.for("FluidValue.get"),dist_esm_m=Symbol.for("FluidValue.observers");var Pt=e=>Boolean(e&&e[esm_g]),ve=e=>e&&e[esm_g]?e[esm_g]():e,esm_qt=e=>e[dist_esm_m]||null;function je(e,t){e.eventObserved?e.eventObserved(t):e(t)}function $t(e,t){let r=e[dist_esm_m];r&&r.forEach(n=>{je(n,t)})}var esm_ge=class{[esm_g];[dist_esm_m];constructor(t){if(!t&&!(t=this.get))throw Error("Unknown getter");De(this,t)}},De=(e,t)=>Ee(e,esm_g,t);function Gt(e,t){if(e[esm_g]){let r=e[dist_esm_m];r||Ee(e,dist_esm_m,r=new Set),r.has(t)||(r.add(t),e.observerAdded&&e.observerAdded(r.size,t))}return t}function Qt(e,t){let r=e[dist_esm_m];if(r&&r.has(t)){let n=r.size-1;n?r.delete(t):e[dist_esm_m]=null,e.observerRemoved&&e.observerRemoved(n,t)}}var Ee=(e,t,r)=>Object.defineProperty(e,t,{value:r,writable:!0,configurable:!0});var O=/[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,esm_Oe=/(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi,K=new RegExp(`($O.source})(%|[a-z]+)`,"i"),we=/rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi,dist_esm_b=/var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/;var esm_N=e=>{let[t,r]=We(e);if(!t||dist_esm_h())return e;let n=window.getComputedStyle(document.documentElement).getPropertyValue(t);if(n)return n.trim();if(r&&r.startsWith("--")){let f=window.getComputedStyle(document.documentElement).getPropertyValue(r);return f||e}else{if(r&&dist_esm_b.test(r))return esm_N(r);if(r)return r}return e},We=e=>{let t=dist_esm_b.exec(e);if(!t)return[,];let[,r,n]=t;return[r,n]};var _,esm_Ke=(e,t,r,n,f)=>`rgba($Math.round(t)}, $Math.round(r)}, $Math.round(n)}, $f})`,Xt=e=>{_||(_=dist_esm_c?new RegExp(`($Object.keys(dist_esm_c).join("|")})(?!\\w)`,"g"):/^\b$/);let t=e.output.map(o=>ve(o).replace(dist_esm_b,esm_N).replace(esm_Oe,D).replace(_,D)),r=t.map(o=>o.match(O).map(Number)),f=r[0].map((o,i)=>r.map(s=>{if(!(i in s))throw Error('The arity of each "output" value must be equal');return s[i]})).map(o=>W({...e,output:o}));return o=>{let i=!K.test(t[0])&&t.find(x=>K.test(x))?.replace(O,""),s=0;return t[0].replace(O,()=>`$f[s++](o)}$i||""}`).replace(we,esm_Ke)}};var Z="react-spring: ",Te=e=>{let t=e,r=!1;if(typeof t!="function")throw new TypeError(`$Z}once requires a function parameter`);return(...n)=>{r||(t(...n),r=!0)}},Ne=Te(console.warn);function Jt(){Ne(`$Z}The "interpolate" function is deprecated in v9 (use "to" instead)`)}var _e=Te(console.warn);function er(){_e(`$Z}Directly calling start instead of using the api object is deprecated in v9 (use ".start" instead), this will be removed in later 0.X.0 versions`)}function esm_or(e){return dist_esm_l.str(e)&&(e[0]=="#"||/\d/.test(e)||!dist_esm_h()&&dist_esm_b.test(e)||e in(dist_esm_c||{}))}var dist_esm_v,q=new WeakMap,Ze=e=>e.forEach(({target:t,contentRect:r})=>q.get(t)?.forEach(n=>n(r)));function Fe(e,t){dist_esm_v||typeof ResizeObserver<"u"&&(dist_esm_v=new ResizeObserver(Ze));let r=q.get(t);return r||(r=new Set,q.set(t,r)),r.add(e),dist_esm_v&&dist_esm_v.observe(t),()=>{let n=q.get(t);!n||(n.delete(e),!n.size&&dist_esm_v&&dist_esm_v.unobserve(t))}}var esm_$=new Set,dist_esm_w,esm_Xe=()=>{let e=()=>{esm_$.forEach(t=>t({width:window.innerWidth,height:window.innerHeight}))};return window.addEventListener("resize",e),()=>{window.removeEventListener("resize",e)}},Ie=e=>(esm_$.add(e),dist_esm_w||(dist_esm_w=esm_Xe()),()=>{esm_$.delete(e),!esm_$.size&&dist_esm_w&&(dist_esm_w(),dist_esm_w=void 0)});var ke=(e,{container:t=document.documentElement}={})=>t===document.documentElement?Ie(e):Fe(e,t);var Se=(e,t,r)=>t-e===0?1:(r-e)/(t-e);var esm_Ye={x:{length:"Width",position:"Left"},y:{length:"Height",position:"Top"}},esm_G=class{callback;container;info;constructor(t,r){this.callback=t,this.container=r,this.info={time:0,x:this.createAxis(),y:this.createAxis()}}createAxis=()=>({current:0,progress:0,scrollLength:0});updateAxis=t=>{let r=this.info[t],{length:n,position:f}=esm_Ye[t];r.current=this.container[`scroll$f}`],r.scrollLength=this.container["scroll"+n]-this.container["client"+n],r.progress=Se(0,r.scrollLength,r.current)};update=()=>{this.updateAxis("x"),this.updateAxis("y")};sendEvent=()=>{this.callback(this.info)};advance=()=>{this.update(),this.sendEvent()}};var esm_T=new WeakMap,Ae=new WeakMap,X=new WeakMap,Me=e=>e===document.documentElement?window:e,yr=(e,{container:t=document.documentElement}={})=>{let r=X.get(t);r||(r=new Set,X.set(t,r));let n=new esm_G(e,t);if(r.add(n),!esm_T.has(t)){let o=()=>(r?.forEach(s=>s.advance()),!0);esm_T.set(t,o);let i=Me(t);window.addEventListener("resize",o,{passive:!0}),t!==document.documentElement&&Ae.set(t,ke(o,{container:t})),i.addEventListener("scroll",o,{passive:!0})}let f=esm_T.get(t);return Re(f),()=>{Re.cancel(f);let o=X.get(t);if(!o||(o.delete(n),o.size))return;let i=esm_T.get(t);esm_T.delete(t),i&&(Me(t).removeEventListener("scroll",i),window.removeEventListener("resize",i),Ae.get(t)?.())}};function Er(e){let t=Je(null);return t.current===null&&(t.current=e()),t.current}var esm_Q=dist_esm_h()?external_React_.useEffect:external_React_.useLayoutEffect;var Ce=()=>{let e=(0,external_React_.useRef)(!1);return esm_Q(()=>(e.current=!0,()=>{e.current=!1}),[]),e};function Mr(){let e=(0,external_React_.useState)()[1],t=Ce();return()=>{t.current&&e(Math.random())}}function Lr(e,t){let[r]=(0,external_React_.useState)(()=>({inputs:t,result:e()})),n=(0,external_React_.useRef)(),f=n.current,o=f;return o?Boolean(t&&o.inputs&&it(t,o.inputs))||(o={inputs:t,result:e()}):o=r,(0,external_React_.useEffect)(()=>{n.current=o,f==r&&(r.inputs=r.result=void 0)},[o]),o.result}function it(e,t){if(e.length!==t.length)return!1;for(let r=0;r<e.length;r++)if(e[r]!==t[r])return!1;return!0}var $r=e=>(0,external_React_.useEffect)(e,ut),ut=[];function Ur(e){let t=ct();return lt(()=>{t.current=e}),t.current}var Wr=()=>{let[e,t]=dt(null);return esm_Q(()=>{let r=window.matchMedia("(prefers-reduced-motion)"),n=f=>{t(f.matches),U({skipAnimation:f.matches})};return n(r),r.addEventListener("change",n),()=>{r.removeEventListener("change",n)}},[]),e}; 37752 37753 ;// ./node_modules/@react-spring/animated/dist/esm/index.js 37754 var animated_dist_esm_h=Symbol.for("Animated:node"),animated_dist_esm_v=e=>!!e&&e[animated_dist_esm_h]===e,dist_esm_k=e=>e&&e[animated_dist_esm_h],esm_D=(e,t)=>mt(e,animated_dist_esm_h,t),F=e=>e&&e[animated_dist_esm_h]&&e[animated_dist_esm_h].getPayload(),animated_dist_esm_c=class{payload;constructor(){esm_D(this,this)}getPayload(){return this.payload||[]}};var animated_dist_esm_l=class extends animated_dist_esm_c{constructor(r){super();this._value=r;dist_esm_l.num(this._value)&&(this.lastPosition=this._value)}done=!0;elapsedTime;lastPosition;lastVelocity;v0;durationProgress=0;static create(r){return new animated_dist_esm_l(r)}getPayload(){return[this]}getValue(){return this._value}setValue(r,n){return dist_esm_l.num(r)&&(this.lastPosition=r,n&&(r=Math.round(r/n)*n,this.done&&(this.lastPosition=r))),this._value===r?!1:(this._value=r,!0)}reset(){let{done:r}=this;this.done=!1,dist_esm_l.num(this._value)&&(this.elapsedTime=0,this.durationProgress=0,this.lastPosition=this._value,r&&(this.lastVelocity=null),this.v0=null)}};var animated_dist_esm_d=class extends animated_dist_esm_l{_string=null;_toString;constructor(t){super(0),this._toString=W({output:[t,t]})}static create(t){return new animated_dist_esm_d(t)}getValue(){let t=this._string;return t??(this._string=this._toString(this._value))}setValue(t){if(dist_esm_l.str(t)){if(t==this._string)return!1;this._string=t,this._value=1}else if(super.setValue(t))this._string=null;else return!1;return!0}reset(t){t&&(this._toString=W({output:[this.getValue(),t]})),this._value=0,super.reset()}};var dist_esm_f={dependencies:null};var animated_dist_esm_u=class extends animated_dist_esm_c{constructor(r){super();this.source=r;this.setValue(r)}getValue(r){let n={};return xt(this.source,(a,i)=>{animated_dist_esm_v(a)?n[i]=a.getValue(r):Pt(a)?n[i]=ve(a):r||(n[i]=a)}),n}setValue(r){this.source=r,this.payload=this._makePayload(r)}reset(){this.payload&&esm_Ve(this.payload,r=>r.reset())}_makePayload(r){if(r){let n=new Set;return xt(r,this._addToPayload,n),Array.from(n)}}_addToPayload(r){dist_esm_f.dependencies&&Pt(r)&&dist_esm_f.dependencies.add(r);let n=F(r);n&&esm_Ve(n,a=>this.add(a))}};var animated_dist_esm_y=class extends animated_dist_esm_u{constructor(t){super(t)}static create(t){return new animated_dist_esm_y(t)}getValue(){return this.source.map(t=>t.getValue())}setValue(t){let r=this.getPayload();return t.length==r.length?r.map((n,a)=>n.setValue(t[a])).some(Boolean):(super.setValue(t.map(dist_esm_z)),!0)}};function dist_esm_z(e){return(esm_or(e)?animated_dist_esm_d:animated_dist_esm_l).create(e)}function esm_Le(e){let t=dist_esm_k(e);return t?t.constructor:dist_esm_l.arr(e)?animated_dist_esm_y:esm_or(e)?animated_dist_esm_d:animated_dist_esm_l}var dist_esm_x=(e,t)=>{let r=!dist_esm_l.fun(e)||e.prototype&&e.prototype.isReactComponent;return (0,external_React_.forwardRef)((n,a)=>{let i=(0,external_React_.useRef)(null),o=r&&(0,external_React_.useCallback)(s=>{i.current=esm_ae(a,s)},[a]),[m,T]=esm_ne(n,t),W=Mr(),P=()=>{let s=i.current;if(r&&!s)return;(s?t.applyAnimatedValues(s,m.getValue(!0)):!1)===!1&&W()},_=new animated_dist_esm_b(P,T),p=(0,external_React_.useRef)();esm_Q(()=>(p.current=_,esm_Ve(T,s=>Gt(s,_)),()=>{p.current&&(esm_Ve(p.current.deps,s=>Qt(s,p.current)),esm_n.cancel(p.current.update))})),(0,external_React_.useEffect)(P,[]),$r(()=>()=>{let s=p.current;esm_Ve(s.deps,S=>Qt(S,s))});let $=t.getComponentProps(m.getValue());return external_React_.createElement(e,{...$,ref:o})})},animated_dist_esm_b=class{constructor(t,r){this.update=t;this.deps=r}eventObserved(t){t.type=="change"&&esm_n.write(this.update)}};function esm_ne(e,t){let r=new Set;return dist_esm_f.dependencies=r,e.style&&(e={...e,style:t.createAnimatedStyle(e.style)}),e=new animated_dist_esm_u(e),dist_esm_f.dependencies=null,[e,r]}function esm_ae(e,t){return e&&(dist_esm_l.fun(e)?e(t):e.current=t),t}var dist_esm_j=Symbol.for("AnimatedComponent"),dist_esm_Ke=(e,{applyAnimatedValues:t=()=>!1,createAnimatedStyle:r=a=>new animated_dist_esm_u(a),getComponentProps:n=a=>a}={})=>{let a={applyAnimatedValues:t,createAnimatedStyle:r,getComponentProps:n},i=o=>{let m=esm_I(o)||"Anonymous";return dist_esm_l.str(o)?o=i[o]||(i[o]=dist_esm_x(o,a)):o=o[dist_esm_j]||(o[dist_esm_j]=dist_esm_x(o,a)),o.displayName=`Animated($m})`,o};return xt(e,(o,m)=>{dist_esm_l.arr(e)&&(m=esm_I(o)),i[m]=i(o)}),{animated:i}},esm_I=e=>dist_esm_l.str(e)?e:e&&dist_esm_l.str(e.displayName)?e.displayName:dist_esm_l.fun(e)&&e.name||null; 37755 37756 ;// ./node_modules/@react-spring/core/dist/esm/index.js 37757 function dist_esm_I(t,...e){return dist_esm_l.fun(t)?t(...e):t}var esm_te=(t,e)=>t===!0||!!(e&&t&&(dist_esm_l.fun(t)?t(e):ht(t).includes(e))),et=(t,e)=>dist_esm_l.obj(t)?e&&t[e]:t;var esm_ke=(t,e)=>t.default===!0?t[e]:t.default?t.default[e]:void 0,nn=t=>t,dist_esm_ne=(t,e=nn)=>{let n=rn;t.default&&t.default!==!0&&(t=t.default,n=Object.keys(t));let r={};for(let o of n){let s=e(t[o],o);dist_esm_l.und(s)||(r[o]=s)}return r},rn=["config","onProps","onStart","onChange","onPause","onResume","onRest"],on={config:1,from:1,to:1,ref:1,loop:1,reset:1,pause:1,cancel:1,reverse:1,immediate:1,default:1,delay:1,onProps:1,onStart:1,onChange:1,onPause:1,onResume:1,onRest:1,onResolve:1,items:1,trail:1,sort:1,expires:1,initial:1,enter:1,update:1,leave:1,children:1,onDestroyed:1,keys:1,callId:1,parentId:1};function sn(t){let e={},n=0;if(xt(t,(r,o)=>{on[o]||(e[o]=r,n++)}),n)return e}function esm_de(t){let e=sn(t);if(e){let n={to:e};return xt(t,(r,o)=>o in e||(n[o]=r)),n}return{...t}}function esm_me(t){return t=ve(t),dist_esm_l.arr(t)?t.map(esm_me):esm_or(t)?dist_esm_p.createStringInterpolator({range:[0,1],output:[t,t]})(1):t}function esm_Ue(t){for(let e in t)return!0;return!1}function esm_Ee(t){return dist_esm_l.fun(t)||dist_esm_l.arr(t)&&dist_esm_l.obj(t[0])}function esm_xe(t,e){t.ref?.delete(t),e?.delete(t)}function esm_he(t,e){e&&t.ref!==e&&(t.ref?.delete(t),e.add(t),t.ref=e)}function wr(t,e,n=1e3){an(()=>{if(e){let r=0;ge(t,(o,s)=>{let a=o.current;if(a.length){let i=n*e[s];isNaN(i)?i=r:r=i,ge(a,u=>{ge(u.queue,p=>{let f=p.delay;p.delay=d=>i+dist_esm_I(f||0,d)})}),o.start()}})}else{let r=Promise.resolve();ge(t,o=>{let s=o.current;if(s.length){let a=s.map(i=>{let u=i.queue;return i.queue=[],u});r=r.then(()=>(ge(s,(i,u)=>ge(a[u]||[],p=>i.queue.push(p))),Promise.all(o.start())))}})}})}var esm_mt={default:{tension:170,friction:26},gentle:{tension:120,friction:14},wobbly:{tension:180,friction:12},stiff:{tension:210,friction:20},slow:{tension:280,friction:60},molasses:{tension:280,friction:120}};var tt={...esm_mt.default,mass:1,damping:1,easing:Lt.linear,clamp:!1},esm_we=class{tension;friction;frequency;damping;mass;velocity=0;restVelocity;precision;progress;duration;easing;clamp;bounce;decay;round;constructor(){Object.assign(this,tt)}};function gt(t,e,n){n&&(n={...n},esm_ht(n,e),e={...n,...e}),esm_ht(t,e),Object.assign(t,e);for(let a in tt)t[a]==null&&(t[a]=tt[a]);let{mass:r,frequency:o,damping:s}=t;return dist_esm_l.und(o)||(o<.01&&(o=.01),s<0&&(s=0),t.tension=Math.pow(2*Math.PI/o,2)*r,t.friction=4*Math.PI*s*r/o),t}function esm_ht(t,e){if(!dist_esm_l.und(e.decay))t.duration=void 0;else{let n=!dist_esm_l.und(e.tension)||!dist_esm_l.und(e.friction);(n||!dist_esm_l.und(e.frequency)||!dist_esm_l.und(e.damping)||!dist_esm_l.und(e.mass))&&(t.duration=void 0,t.decay=void 0),n&&(t.frequency=void 0)}}var esm_yt=[],dist_esm_Le=class{changed=!1;values=esm_yt;toValues=null;fromValues=esm_yt;to;from;config=new esm_we;immediate=!1};function esm_Me(t,{key:e,props:n,defaultProps:r,state:o,actions:s}){return new Promise((a,i)=>{let u,p,f=esm_te(n.cancel??r?.cancel,e);if(f)b();else{dist_esm_l.und(n.pause)||(o.paused=esm_te(n.pause,e));let c=r?.pause;c!==!0&&(c=o.paused||esm_te(c,e)),u=dist_esm_I(n.delay||0,e),c?(o.resumeQueue.add(m),s.pause()):(s.resume(),m())}function d(){o.resumeQueue.add(m),o.timeouts.delete(p),p.cancel(),u=p.time-esm_n.now()}function m(){u>0&&!dist_esm_p.skipAnimation?(o.delayed=!0,p=esm_n.setTimeout(b,u),o.pauseQueue.add(d),o.timeouts.add(p)):b()}function b(){o.delayed&&(o.delayed=!1),o.pauseQueue.delete(d),o.timeouts.delete(p),t<=(o.cancelId||0)&&(f=!0);try{s.start({...n,callId:t,cancel:f},a)}catch(c){i(c)}}})}var esm_be=(t,e)=>e.length==1?e[0]:e.some(n=>n.cancelled)?esm_q(t.get()):e.every(n=>n.noop)?nt(t.get()):dist_esm_E(t.get(),e.every(n=>n.finished)),nt=t=>({value:t,noop:!0,finished:!0,cancelled:!1}),dist_esm_E=(t,e,n=!1)=>({value:t,finished:e,cancelled:n}),esm_q=t=>({value:t,cancelled:!0,finished:!1});function esm_De(t,e,n,r){let{callId:o,parentId:s,onRest:a}=e,{asyncTo:i,promise:u}=n;return!s&&t===i&&!e.reset?u:n.promise=(async()=>{n.asyncId=o,n.asyncTo=t;let p=dist_esm_ne(e,(l,h)=>h==="onRest"?void 0:l),f,d,m=new Promise((l,h)=>(f=l,d=h)),b=l=>{let h=o<=(n.cancelId||0)&&esm_q(r)||o!==n.asyncId&&dist_esm_E(r,!1);if(h)throw l.result=h,d(l),l},c=(l,h)=>{let g=new esm_Ae,x=new esm_Ne;return(async()=>{if(dist_esm_p.skipAnimation)throw esm_oe(n),x.result=dist_esm_E(r,!1),d(x),x;b(g);let S=dist_esm_l.obj(l)?{...l}:{...h,to:l};S.parentId=o,xt(p,(V,_)=>{dist_esm_l.und(S[_])&&(S[_]=V)});let A=await r.start(S);return b(g),n.paused&&await new Promise(V=>{n.resumeQueue.add(V)}),A})()},P;if(dist_esm_p.skipAnimation)return esm_oe(n),dist_esm_E(r,!1);try{let l;dist_esm_l.arr(t)?l=(async h=>{for(let g of h)await c(g)})(t):l=Promise.resolve(t(c,r.stop.bind(r))),await Promise.all([l.then(f),m]),P=dist_esm_E(r.get(),!0,!1)}catch(l){if(l instanceof esm_Ae)P=l.result;else if(l instanceof esm_Ne)P=l.result;else throw l}finally{o==n.asyncId&&(n.asyncId=s,n.asyncTo=s?i:void 0,n.promise=s?u:void 0)}return dist_esm_l.fun(a)&&esm_n.batchedUpdates(()=>{a(P,r,r.item)}),P})()}function esm_oe(t,e){Pe(t.timeouts,n=>n.cancel()),t.pauseQueue.clear(),t.resumeQueue.clear(),t.asyncId=t.asyncTo=t.promise=void 0,e&&(t.cancelId=e)}var esm_Ae=class extends Error{result;constructor(){super("An async animation has been interrupted. You see this error because you forgot to use `await` or `.catch(...)` on its returned promise.")}},esm_Ne=class extends Error{result;constructor(){super("SkipAnimationSignal")}};var esm_Re=t=>t instanceof esm_X,Sn=1,esm_X=class extends esm_ge{id=Sn++;_priority=0;get priority(){return this._priority}set priority(e){this._priority!=e&&(this._priority=e,this._onPriorityChange(e))}get(){let e=dist_esm_k(this);return e&&e.getValue()}to(...e){return dist_esm_p.to(this,e)}interpolate(...e){return Jt(),dist_esm_p.to(this,e)}toJSON(){return this.get()}observerAdded(e){e==1&&this._attach()}observerRemoved(e){e==0&&this._detach()}_attach(){}_detach(){}_onChange(e,n=!1){$t(this,{type:"change",parent:this,value:e,idle:n})}_onPriorityChange(e){this.idle||qe.sort(this),$t(this,{type:"priority",parent:this,priority:e})}};var esm_se=Symbol.for("SpringPhase"),esm_bt=1,rt=2,ot=4,esm_qe=t=>(t[esm_se]&esm_bt)>0,dist_esm_Q=t=>(t[esm_se]&rt)>0,esm_ye=t=>(t[esm_se]&ot)>0,st=(t,e)=>e?t[esm_se]|=rt|esm_bt:t[esm_se]&=~rt,esm_it=(t,e)=>e?t[esm_se]|=ot:t[esm_se]&=~ot;var esm_ue=class extends esm_X{key;animation=new dist_esm_Le;queue;defaultProps={};_state={paused:!1,delayed:!1,pauseQueue:new Set,resumeQueue:new Set,timeouts:new Set};_pendingCalls=new Set;_lastCallId=0;_lastToId=0;_memoizedDuration=0;constructor(e,n){if(super(),!dist_esm_l.und(e)||!dist_esm_l.und(n)){let r=dist_esm_l.obj(e)?{...e}:{...n,from:e};dist_esm_l.und(r.default)&&(r.default=!0),this.start(r)}}get idle(){return!(dist_esm_Q(this)||this._state.asyncTo)||esm_ye(this)}get goal(){return ve(this.animation.to)}get velocity(){let e=dist_esm_k(this);return e instanceof animated_dist_esm_l?e.lastVelocity||0:e.getPayload().map(n=>n.lastVelocity||0)}get hasAnimated(){return esm_qe(this)}get isAnimating(){return dist_esm_Q(this)}get isPaused(){return esm_ye(this)}get isDelayed(){return this._state.delayed}advance(e){let n=!0,r=!1,o=this.animation,{config:s,toValues:a}=o,i=F(o.to);!i&&Pt(o.to)&&(a=ht(ve(o.to))),o.values.forEach((f,d)=>{if(f.done)return;let m=f.constructor==animated_dist_esm_d?1:i?i[d].lastPosition:a[d],b=o.immediate,c=m;if(!b){if(c=f.lastPosition,s.tension<=0){f.done=!0;return}let P=f.elapsedTime+=e,l=o.fromValues[d],h=f.v0!=null?f.v0:f.v0=dist_esm_l.arr(s.velocity)?s.velocity[d]:s.velocity,g,x=s.precision||(l==m?.005:Math.min(1,Math.abs(m-l)*.001));if(dist_esm_l.und(s.duration))if(s.decay){let S=s.decay===!0?.998:s.decay,A=Math.exp(-(1-S)*P);c=l+h/(1-S)*(1-A),b=Math.abs(f.lastPosition-c)<=x,g=h*A}else{g=f.lastVelocity==null?h:f.lastVelocity;let S=s.restVelocity||x/10,A=s.clamp?0:s.bounce,V=!dist_esm_l.und(A),_=l==m?f.v0>0:l<m,v,w=!1,C=1,$=Math.ceil(e/C);for(let L=0;L<$&&(v=Math.abs(g)>S,!(!v&&(b=Math.abs(m-c)<=x,b)));++L){V&&(w=c==m||c>m==_,w&&(g=-g*A,c=m));let N=-s.tension*1e-6*(c-m),y=-s.friction*.001*g,T=(N+y)/s.mass;g=g+T*C,c=c+g*C}}else{let S=1;s.duration>0&&(this._memoizedDuration!==s.duration&&(this._memoizedDuration=s.duration,f.durationProgress>0&&(f.elapsedTime=s.duration*f.durationProgress,P=f.elapsedTime+=e)),S=(s.progress||0)+P/this._memoizedDuration,S=S>1?1:S<0?0:S,f.durationProgress=S),c=l+s.easing(S)*(m-l),g=(c-f.lastPosition)/e,b=S==1}f.lastVelocity=g,Number.isNaN(c)&&(console.warn("Got NaN while animating:",this),b=!0)}i&&!i[d].done&&(b=!1),b?f.done=!0:n=!1,f.setValue(c,s.round)&&(r=!0)});let u=dist_esm_k(this),p=u.getValue();if(n){let f=ve(o.to);(p!==f||r)&&!s.decay?(u.setValue(f),this._onChange(f)):r&&s.decay&&this._onChange(p),this._stop()}else r&&this._onChange(p)}set(e){return esm_n.batchedUpdates(()=>{this._stop(),this._focus(e),this._set(e)}),this}pause(){this._update({pause:!0})}resume(){this._update({pause:!1})}finish(){if(dist_esm_Q(this)){let{to:e,config:n}=this.animation;esm_n.batchedUpdates(()=>{this._onStart(),n.decay||this._set(e,!1),this._stop()})}return this}update(e){return(this.queue||(this.queue=[])).push(e),this}start(e,n){let r;return dist_esm_l.und(e)?(r=this.queue||[],this.queue=[]):r=[dist_esm_l.obj(e)?e:{...n,to:e}],Promise.all(r.map(o=>this._update(o))).then(o=>esm_be(this,o))}stop(e){let{to:n}=this.animation;return this._focus(this.get()),esm_oe(this._state,e&&this._lastCallId),esm_n.batchedUpdates(()=>this._stop(n,e)),this}reset(){this._update({reset:!0})}eventObserved(e){e.type=="change"?this._start():e.type=="priority"&&(this.priority=e.priority+1)}_prepareNode(e){let n=this.key||"",{to:r,from:o}=e;r=dist_esm_l.obj(r)?r[n]:r,(r==null||esm_Ee(r))&&(r=void 0),o=dist_esm_l.obj(o)?o[n]:o,o==null&&(o=void 0);let s={to:r,from:o};return esm_qe(this)||(e.reverse&&([r,o]=[o,r]),o=ve(o),dist_esm_l.und(o)?dist_esm_k(this)||this._set(r):this._set(o)),s}_update({...e},n){let{key:r,defaultProps:o}=this;e.default&&Object.assign(o,dist_esm_ne(e,(i,u)=>/^on/.test(u)?et(i,r):i)),_t(this,e,"onProps"),esm_Ie(this,"onProps",e,this);let s=this._prepareNode(e);if(Object.isFrozen(this))throw Error("Cannot animate a `SpringValue` object that is frozen. Did you forget to pass your component to `animated(...)` before animating its props?");let a=this._state;return esm_Me(++this._lastCallId,{key:r,props:e,defaultProps:o,state:a,actions:{pause:()=>{esm_ye(this)||(esm_it(this,!0),yt(a.pauseQueue),esm_Ie(this,"onPause",dist_esm_E(this,esm_Ce(this,this.animation.to)),this))},resume:()=>{esm_ye(this)&&(esm_it(this,!1),dist_esm_Q(this)&&this._resume(),yt(a.resumeQueue),esm_Ie(this,"onResume",dist_esm_E(this,esm_Ce(this,this.animation.to)),this))},start:this._merge.bind(this,s)}}).then(i=>{if(e.loop&&i.finished&&!(n&&i.noop)){let u=at(e);if(u)return this._update(u,!0)}return i})}_merge(e,n,r){if(n.cancel)return this.stop(!0),r(esm_q(this));let o=!dist_esm_l.und(e.to),s=!dist_esm_l.und(e.from);if(o||s)if(n.callId>this._lastToId)this._lastToId=n.callId;else return r(esm_q(this));let{key:a,defaultProps:i,animation:u}=this,{to:p,from:f}=u,{to:d=p,from:m=f}=e;s&&!o&&(!n.default||dist_esm_l.und(d))&&(d=m),n.reverse&&([d,m]=[m,d]);let b=!bt(m,f);b&&(u.from=m),m=ve(m);let c=!bt(d,p);c&&this._focus(d);let P=esm_Ee(n.to),{config:l}=u,{decay:h,velocity:g}=l;(o||s)&&(l.velocity=0),n.config&&!P&>(l,dist_esm_I(n.config,a),n.config!==i.config?dist_esm_I(i.config,a):void 0);let x=dist_esm_k(this);if(!x||dist_esm_l.und(d))return r(dist_esm_E(this,!0));let S=dist_esm_l.und(n.reset)?s&&!n.default:!dist_esm_l.und(m)&&esm_te(n.reset,a),A=S?m:this.get(),V=esm_me(d),_=dist_esm_l.num(V)||dist_esm_l.arr(V)||esm_or(V),v=!P&&(!_||esm_te(i.immediate||n.immediate,a));if(c){let L=esm_Le(d);if(L!==x.constructor)if(v)x=this._set(V);else throw Error(`Cannot animate between $x.constructor.name} and $L.name}, as the "to" prop suggests`)}let w=x.constructor,C=Pt(d),$=!1;if(!C){let L=S||!esm_qe(this)&&b;(c||L)&&($=bt(esm_me(A),V),C=!$),(!bt(u.immediate,v)&&!v||!bt(l.decay,h)||!bt(l.velocity,g))&&(C=!0)}if($&&dist_esm_Q(this)&&(u.changed&&!S?C=!0:C||this._stop(p)),!P&&((C||Pt(p))&&(u.values=x.getPayload(),u.toValues=Pt(d)?null:w==animated_dist_esm_d?[1]:ht(V)),u.immediate!=v&&(u.immediate=v,!v&&!S&&this._set(p)),C)){let{onRest:L}=u;esm_Ve(_n,y=>_t(this,n,y));let N=dist_esm_E(this,esm_Ce(this,p));yt(this._pendingCalls,N),this._pendingCalls.add(r),u.changed&&esm_n.batchedUpdates(()=>{u.changed=!S,L?.(N,this),S?dist_esm_I(i.onRest,N):u.onStart?.(N,this)})}S&&this._set(A),P?r(esm_De(n.to,n,this._state,this)):C?this._start():dist_esm_Q(this)&&!c?this._pendingCalls.add(r):r(nt(A))}_focus(e){let n=this.animation;e!==n.to&&(esm_qt(this)&&this._detach(),n.to=e,esm_qt(this)&&this._attach())}_attach(){let e=0,{to:n}=this.animation;Pt(n)&&(Gt(n,this),esm_Re(n)&&(e=n.priority+1)),this.priority=e}_detach(){let{to:e}=this.animation;Pt(e)&&Qt(e,this)}_set(e,n=!0){let r=ve(e);if(!dist_esm_l.und(r)){let o=dist_esm_k(this);if(!o||!bt(r,o.getValue())){let s=esm_Le(r);!o||o.constructor!=s?esm_D(this,s.create(r)):o.setValue(r),o&&esm_n.batchedUpdates(()=>{this._onChange(r,n)})}}return dist_esm_k(this)}_onStart(){let e=this.animation;e.changed||(e.changed=!0,esm_Ie(this,"onStart",dist_esm_E(this,esm_Ce(this,e.to)),this))}_onChange(e,n){n||(this._onStart(),dist_esm_I(this.animation.onChange,e,this)),dist_esm_I(this.defaultProps.onChange,e,this),super._onChange(e,n)}_start(){let e=this.animation;dist_esm_k(this).reset(ve(e.to)),e.immediate||(e.fromValues=e.values.map(n=>n.lastPosition)),dist_esm_Q(this)||(st(this,!0),esm_ye(this)||this._resume())}_resume(){dist_esm_p.skipAnimation?this.finish():qe.start(this)}_stop(e,n){if(dist_esm_Q(this)){st(this,!1);let r=this.animation;esm_Ve(r.values,s=>{s.done=!0}),r.toValues&&(r.onChange=r.onPause=r.onResume=void 0),$t(this,{type:"idle",parent:this});let o=n?esm_q(this.get()):dist_esm_E(this.get(),esm_Ce(this,e??r.to));yt(this._pendingCalls,o),r.changed&&(r.changed=!1,esm_Ie(this,"onRest",o,this))}}};function esm_Ce(t,e){let n=esm_me(e),r=esm_me(t.get());return bt(r,n)}function at(t,e=t.loop,n=t.to){let r=dist_esm_I(e);if(r){let o=r!==!0&&esm_de(r),s=(o||t).reverse,a=!o||o.reset;return esm_Pe({...t,loop:e,default:!1,pause:void 0,to:!s||esm_Ee(n)?n:void 0,from:a?t.from:void 0,reset:a,...o})}}function esm_Pe(t){let{to:e,from:n}=t=esm_de(t),r=new Set;return dist_esm_l.obj(e)&&Vt(e,r),dist_esm_l.obj(n)&&Vt(n,r),t.keys=r.size?Array.from(r):null,t}function Ot(t){let e=esm_Pe(t);return R.und(e.default)&&(e.default=dist_esm_ne(e)),e}function Vt(t,e){xt(t,(n,r)=>n!=null&&e.add(r))}var _n=["onStart","onRest","onChange","onPause","onResume"];function _t(t,e,n){t.animation[n]=e[n]!==esm_ke(e,n)?et(e[n],t.key):void 0}function esm_Ie(t,e,...n){t.animation[e]?.(...n),t.defaultProps[e]?.(...n)}var Fn=["onStart","onChange","onRest"],kn=1,esm_le=class{id=kn++;springs={};queue=[];ref;_flush;_initialProps;_lastAsyncId=0;_active=new Set;_changed=new Set;_started=!1;_item;_state={paused:!1,pauseQueue:new Set,resumeQueue:new Set,timeouts:new Set};_events={onStart:new Map,onChange:new Map,onRest:new Map};constructor(e,n){this._onFrame=this._onFrame.bind(this),n&&(this._flush=n),e&&this.start({default:!0,...e})}get idle(){return!this._state.asyncTo&&Object.values(this.springs).every(e=>e.idle&&!e.isDelayed&&!e.isPaused)}get item(){return this._item}set item(e){this._item=e}get(){let e={};return this.each((n,r)=>e[r]=n.get()),e}set(e){for(let n in e){let r=e[n];dist_esm_l.und(r)||this.springs[n].set(r)}}update(e){return e&&this.queue.push(esm_Pe(e)),this}start(e){let{queue:n}=this;return e?n=ht(e).map(esm_Pe):this.queue=[],this._flush?this._flush(this,n):(jt(this,n),esm_ze(this,n))}stop(e,n){if(e!==!!e&&(n=e),n){let r=this.springs;esm_Ve(ht(n),o=>r[o].stop(!!e))}else esm_oe(this._state,this._lastAsyncId),this.each(r=>r.stop(!!e));return this}pause(e){if(dist_esm_l.und(e))this.start({pause:!0});else{let n=this.springs;esm_Ve(ht(e),r=>n[r].pause())}return this}resume(e){if(dist_esm_l.und(e))this.start({pause:!1});else{let n=this.springs;esm_Ve(ht(e),r=>n[r].resume())}return this}each(e){xt(this.springs,e)}_onFrame(){let{onStart:e,onChange:n,onRest:r}=this._events,o=this._active.size>0,s=this._changed.size>0;(o&&!this._started||s&&!this._started)&&(this._started=!0,Pe(e,([u,p])=>{p.value=this.get(),u(p,this,this._item)}));let a=!o&&this._started,i=s||a&&r.size?this.get():null;s&&n.size&&Pe(n,([u,p])=>{p.value=i,u(p,this,this._item)}),a&&(this._started=!1,Pe(r,([u,p])=>{p.value=i,u(p,this,this._item)}))}eventObserved(e){if(e.type=="change")this._changed.add(e.parent),e.idle||this._active.add(e.parent);else if(e.type=="idle")this._active.delete(e.parent);else return;esm_n.onFrame(this._onFrame)}};function esm_ze(t,e){return Promise.all(e.map(n=>wt(t,n))).then(n=>esm_be(t,n))}async function wt(t,e,n){let{keys:r,to:o,from:s,loop:a,onRest:i,onResolve:u}=e,p=dist_esm_l.obj(e.default)&&e.default;a&&(e.loop=!1),o===!1&&(e.to=null),s===!1&&(e.from=null);let f=dist_esm_l.arr(o)||dist_esm_l.fun(o)?o:void 0;f?(e.to=void 0,e.onRest=void 0,p&&(p.onRest=void 0)):esm_Ve(Fn,P=>{let l=e[P];if(dist_esm_l.fun(l)){let h=t._events[P];e[P]=({finished:g,cancelled:x})=>{let S=h.get(l);S?(g||(S.finished=!1),x&&(S.cancelled=!0)):h.set(l,{value:null,finished:g||!1,cancelled:x||!1})},p&&(p[P]=e[P])}});let d=t._state;e.pause===!d.paused?(d.paused=e.pause,yt(e.pause?d.pauseQueue:d.resumeQueue)):d.paused&&(e.pause=!0);let m=(r||Object.keys(t.springs)).map(P=>t.springs[P].start(e)),b=e.cancel===!0||esm_ke(e,"cancel")===!0;(f||b&&d.asyncId)&&m.push(esm_Me(++t._lastAsyncId,{props:e,state:d,actions:{pause:Y,resume:Y,start(P,l){b?(esm_oe(d,t._lastAsyncId),l(esm_q(t))):(P.onRest=i,l(esm_De(f,P,d,t)))}}})),d.paused&&await new Promise(P=>{d.resumeQueue.add(P)});let c=esm_be(t,await Promise.all(m));if(a&&c.finished&&!(n&&c.noop)){let P=at(e,a,o);if(P)return jt(t,[P]),wt(t,P,!0)}return u&&esm_n.batchedUpdates(()=>u(c,t,t.item)),c}function esm_e(t,e){let n={...t.springs};return e&&pe(Ve(e),r=>{z.und(r.keys)&&(r=esm_Pe(r)),z.obj(r.to)||(r={...r,to:void 0}),Mt(n,r,o=>esm_Lt(o))}),pt(t,n),n}function pt(t,e){Ut(e,(n,r)=>{t.springs[r]||(t.springs[r]=n,Et(n,t))})}function esm_Lt(t,e){let n=new esm_ue;return n.key=t,e&&Gt(n,e),n}function Mt(t,e,n){e.keys&&esm_Ve(e.keys,r=>{(t[r]||(t[r]=n(r)))._prepareNode(e)})}function jt(t,e){esm_Ve(e,n=>{Mt(t.springs,n,r=>esm_Lt(r,t))})}var dist_esm_H=({children:t,...e})=>{let n=(0,external_React_.useContext)(esm_Ge),r=e.pause||!!n.pause,o=e.immediate||!!n.immediate;e=Lr(()=>({pause:r,immediate:o}),[r,o]);let{Provider:s}=esm_Ge;return external_React_.createElement(s,{value:e},t)},esm_Ge=wn(dist_esm_H,{});dist_esm_H.Provider=esm_Ge.Provider;dist_esm_H.Consumer=esm_Ge.Consumer;function wn(t,e){return Object.assign(t,external_React_.createContext(e)),t.Provider._context=t,t.Consumer._context=t,t}var esm_fe=()=>{let t=[],e=function(r){Ln();let o=[];return ce(t,(s,a)=>{if(Ke.und(r))o.push(s.start());else{let i=n(r,s,a);i&&o.push(s.start(i))}}),o};e.current=t,e.add=function(r){t.includes(r)||t.push(r)},e.delete=function(r){let o=t.indexOf(r);~o&&t.splice(o,1)},e.pause=function(){return ce(t,r=>r.pause(...arguments)),this},e.resume=function(){return ce(t,r=>r.resume(...arguments)),this},e.set=function(r){ce(t,(o,s)=>{let a=Ke.fun(r)?r(s,o):r;a&&o.set(a)})},e.start=function(r){let o=[];return ce(t,(s,a)=>{if(Ke.und(r))o.push(s.start());else{let i=this._getProps(r,s,a);i&&o.push(s.start(i))}}),o},e.stop=function(){return ce(t,r=>r.stop(...arguments)),this},e.update=function(r){return ce(t,(o,s)=>o.update(this._getProps(r,o,s))),this};let n=function(r,o,s){return Ke.fun(r)?r(s,o):r};return e._getProps=n,e};function esm_He(t,e,n){let r=jn.fun(e)&&e;r&&!n&&(n=[]);let o=Xe(()=>r||arguments.length==3?esm_fe():void 0,[]),s=Nt(0),a=Dn(),i=Xe(()=>({ctrls:[],queue:[],flush(h,g){let x=esm_e(h,g);return s.current>0&&!i.queue.length&&!Object.keys(x).some(A=>!h.springs[A])?esm_ze(h,g):new Promise(A=>{pt(h,x),i.queue.push(()=>{A(esm_ze(h,g))}),a()})}}),[]),u=Nt([...i.ctrls]),p=[],f=Dt(t)||0;Xe(()=>{Ye(u.current.slice(t,f),h=>{esm_xe(h,o),h.stop(!0)}),u.current.length=t,d(f,t)},[t]),Xe(()=>{d(0,Math.min(f,t))},n);function d(h,g){for(let x=h;x<g;x++){let S=u.current[x]||(u.current[x]=new esm_le(null,i.flush)),A=r?r(x,S):e[x];A&&(p[x]=Ot(A))}}let m=u.current.map((h,g)=>esm_e(h,p[g])),b=Mn(dist_esm_H),c=Dt(b),P=b!==c&&esm_Ue(b);qn(()=>{s.current++,i.ctrls=u.current;let{queue:h}=i;h.length&&(i.queue=[],Ye(h,g=>g())),Ye(u.current,(g,x)=>{o?.add(g),P&&g.start({default:b});let S=p[x];S&&(esm_he(g,S.ref),g.ref?g.queue.push(S):g.start(S))})}),Nn(()=>()=>{Ye(i.ctrls,h=>h.stop(!0))});let l=m.map(h=>({...h}));return o?[l,o]:l}function esm_J(t,e){let n=Qn.fun(t),[[r],o]=esm_He(1,n?t:[t],n?e||[]:e);return n||arguments.length==2?[r,o]:r}var Gn=()=>esm_fe(),Xo=()=>zn(Gn)[0];var Wo=(t,e)=>{let n=Bn(()=>new esm_ue(t,e));return Kn(()=>()=>{n.stop()}),n};function esm_Qt(t,e,n){let r=qt.fun(e)&&e;r&&!n&&(n=[]);let o=!0,s,a=esm_He(t,(i,u)=>{let p=r?r(i,u):e;return s=p.ref,o=o&&p.reverse,p},n||[{}]);if(Yn(()=>{Xn(a[1].current,(i,u)=>{let p=a[1].current[u+(o?1:-1)];if(esm_he(i,s),i.ref){p&&i.update({to:p.springs});return}p?i.start({to:p.springs}):i.start()})},n),r||arguments.length==3){let i=s??a[1];return i._getProps=(u,p,f)=>{let d=qt.fun(u)?u(f,p):u;if(d){let m=i.current[f+(d.reverse?1:-1)];return m&&(d.to=m.springs),d}},a}return a[0]}function esm_Gt(t,e,n){let r=G.fun(e)&&e,{reset:o,sort:s,trail:a=0,expires:i=!0,exitBeforeEnter:u=!1,onDestroyed:p,ref:f,config:d}=r?r():e,m=Jn(()=>r||arguments.length==3?esm_fe():void 0,[]),b=zt(t),c=[],P=lt(null),l=o?null:P.current;Je(()=>{P.current=c}),$n(()=>(j(c,y=>{m?.add(y.ctrl),y.ctrl.ref=m}),()=>{j(P.current,y=>{y.expired&&clearTimeout(y.expirationId),esm_xe(y.ctrl,m),y.ctrl.stop(!0)})}));let h=tr(b,r?r():e,l),g=o&&P.current||[];Je(()=>j(g,({ctrl:y,item:T,key:F})=>{esm_xe(y,m),dist_esm_I(p,T,F)}));let x=[];if(l&&j(l,(y,T)=>{y.expired?(clearTimeout(y.expirationId),g.push(y)):(T=x[T]=h.indexOf(y.key),~T&&(c[T]=y))}),j(b,(y,T)=>{c[T]||(c[T]={key:h[T],item:y,phase:"mount",ctrl:new esm_le},c[T].ctrl.item=y)}),x.length){let y=-1,{leave:T}=r?r():e;j(x,(F,k)=>{let O=l[k];~F?(y=c.indexOf(O),c[y]={...O,item:b[F]}):T&&c.splice(++y,0,O)})}G.fun(s)&&c.sort((y,T)=>s(y.item,T.item));let S=-a,A=Wn(),V=dist_esm_ne(e),_=new Map,v=lt(new Map),w=lt(!1);j(c,(y,T)=>{let F=y.key,k=y.phase,O=r?r():e,U,D,Jt=dist_esm_I(O.delay||0,F);if(k=="mount")U=O.enter,D="enter";else{let M=h.indexOf(F)<0;if(k!="leave")if(M)U=O.leave,D="leave";else if(U=O.update)D="update";else return;else if(!M)U=O.enter,D="enter";else return}if(U=dist_esm_I(U,y.item,T),U=G.obj(U)?esm_de(U):{to:U},!U.config){let M=d||V.config;U.config=dist_esm_I(M,y.item,T,D)}S+=a;let Z={...V,delay:Jt+S,ref:f,immediate:O.immediate,reset:!1,...U};if(D=="enter"&&G.und(Z.from)){let M=r?r():e,Te=G.und(M.initial)||l?M.from:M.initial;Z.from=dist_esm_I(Te,y.item,T)}let{onResolve:Wt}=Z;Z.onResolve=M=>{dist_esm_I(Wt,M);let Te=P.current,B=Te.find(Fe=>Fe.key===F);if(!!B&&!(M.cancelled&&B.phase!="update")&&B.ctrl.idle){let Fe=Te.every(ee=>ee.ctrl.idle);if(B.phase=="leave"){let ee=dist_esm_I(i,B.item);if(ee!==!1){let Ze=ee===!0?0:ee;if(B.expired=!0,!Fe&&Ze>0){Ze<=2147483647&&(B.expirationId=setTimeout(A,Ze));return}}}Fe&&Te.some(ee=>ee.expired)&&(v.current.delete(B),u&&(w.current=!0),A())}};let ft=esm_e(y.ctrl,Z);D==="leave"&&u?v.current.set(y,{phase:D,springs:ft,payload:Z}):_.set(y,{phase:D,springs:ft,payload:Z})});let C=Hn(dist_esm_H),$=Zn(C),L=C!==$&&esm_Ue(C);Je(()=>{L&&j(c,y=>{y.ctrl.start({default:C})})},[C]),j(_,(y,T)=>{if(v.current.size){let F=c.findIndex(k=>k.key===T.key);c.splice(F,1)}}),Je(()=>{j(v.current.size?v.current:_,({phase:y,payload:T},F)=>{let{ctrl:k}=F;F.phase=y,m?.add(k),L&&y=="enter"&&k.start({default:C}),T&&(esm_he(k,T.ref),(k.ref||m)&&!w.current?k.update(T):(k.start(T),w.current&&(w.current=!1)))})},o?void 0:n);let N=y=>Oe.createElement(Oe.Fragment,null,c.map((T,F)=>{let{springs:k}=_.get(T)||T.ctrl,O=y({...k},T.item,T,F);return O&&O.type?Oe.createElement(O.type,{...O.props,key:G.str(T.key)||G.num(T.key)?T.key:T.ctrl.id,ref:O.ref}):O}));return m?[N,m]:N}var esm_er=1;function tr(t,{key:e,keys:n=e},r){if(n===null){let o=new Set;return t.map(s=>{let a=r&&r.find(i=>i.item===s&&i.phase!=="leave"&&!o.has(i));return a?(o.add(a),a.key):esm_er++})}return G.und(n)?t:G.fun(n)?t.map(n):zt(n)}var hs=({container:t,...e}={})=>{let[n,r]=esm_J(()=>({scrollX:0,scrollY:0,scrollXProgress:0,scrollYProgress:0,...e}),[]);return or(()=>{let o=rr(({x:s,y:a})=>{r.start({scrollX:s.current,scrollXProgress:s.progress,scrollY:a.current,scrollYProgress:a.progress})},{container:t?.current||void 0});return()=>{nr(Object.values(n),s=>s.stop()),o()}},[]),n};var Ps=({container:t,...e})=>{let[n,r]=esm_J(()=>({width:0,height:0,...e}),[]);return ar(()=>{let o=sr(({width:s,height:a})=>{r.start({width:s,height:a,immediate:n.width.get()===0||n.height.get()===0})},{container:t?.current||void 0});return()=>{ir(Object.values(n),s=>s.stop()),o()}},[]),n};var cr={any:0,all:1};function Cs(t,e){let[n,r]=pr(!1),o=ur(),s=Bt.fun(t)&&t,a=s?s():{},{to:i={},from:u={},...p}=a,f=s?e:t,[d,m]=esm_J(()=>({from:u,...p}),[]);return lr(()=>{let b=o.current,{root:c,once:P,amount:l="any",...h}=f??{};if(!b||P&&n||typeof IntersectionObserver>"u")return;let g=new WeakMap,x=()=>(i&&m.start(i),r(!0),P?void 0:()=>{u&&m.start(u),r(!1)}),S=V=>{V.forEach(_=>{let v=g.get(_.target);if(_.isIntersecting!==Boolean(v))if(_.isIntersecting){let w=x();Bt.fun(w)?g.set(_.target,w):A.unobserve(_.target)}else v&&(v(),g.delete(_.target))})},A=new IntersectionObserver(S,{root:c&&c.current||void 0,threshold:typeof l=="number"||Array.isArray(l)?l:cr[l],...h});return A.observe(b),()=>A.unobserve(b)},[f]),s?[o,d]:[o,n]}function qs({children:t,...e}){return t(esm_J(e))}function Bs({items:t,children:e,...n}){let r=esm_Qt(t.length,n);return t.map((o,s)=>{let a=e(o,s);return fr.fun(a)?a(r[s]):a})}function Ys({items:t,children:e,...n}){return esm_Gt(t,n)(e)}var esm_W=class extends esm_X{constructor(n,r){super();this.source=n;this.calc=W(...r);let o=this._get(),s=esm_Le(o);esm_D(this,s.create(o))}key;idle=!0;calc;_active=new Set;advance(n){let r=this._get(),o=this.get();bt(r,o)||(dist_esm_k(this).setValue(r),this._onChange(r,this.idle)),!this.idle&&Yt(this._active)&&esm_ct(this)}_get(){let n=dist_esm_l.arr(this.source)?this.source.map(ve):ht(ve(this.source));return this.calc(...n)}_start(){this.idle&&!Yt(this._active)&&(this.idle=!1,esm_Ve(F(this),n=>{n.done=!1}),dist_esm_p.skipAnimation?(esm_n.batchedUpdates(()=>this.advance()),esm_ct(this)):qe.start(this))}_attach(){let n=1;esm_Ve(ht(this.source),r=>{Pt(r)&&Gt(r,this),esm_Re(r)&&(r.idle||this._active.add(r),n=Math.max(n,r.priority+1))}),this.priority=n,this._start()}_detach(){esm_Ve(ht(this.source),n=>{Pt(n)&&Qt(n,this)}),this._active.clear(),esm_ct(this)}eventObserved(n){n.type=="change"?n.idle?this.advance():(this._active.add(n.parent),this._start()):n.type=="idle"?this._active.delete(n.parent):n.type=="priority"&&(this.priority=ht(this.source).reduce((r,o)=>Math.max(r,(esm_Re(o)?o.priority:0)+1),0))}};function vr(t){return t.idle!==!1}function Yt(t){return!t.size||Array.from(t).every(vr)}function esm_ct(t){t.idle||(t.idle=!0,esm_Ve(F(t),e=>{e.done=!0}),$t(t,{type:"idle",parent:t}))}var esm_ui=(t,...e)=>new esm_W(t,e),pi=(t,...e)=>(Cr(),new esm_W(t,e));dist_esm_p.assign({createStringInterpolator:Xt,to:(t,e)=>new esm_W(t,e)});var di=qe.advance; 37758 37759 ;// external "ReactDOM" 37760 const external_ReactDOM_namespaceObject = window["ReactDOM"]; 37761 ;// ./node_modules/@react-spring/web/dist/esm/index.js 37762 var web_dist_esm_k=/^--/;function web_dist_esm_I(t,e){return e==null||typeof e=="boolean"||e===""?"":typeof e=="number"&&e!==0&&!web_dist_esm_k.test(t)&&!(web_dist_esm_c.hasOwnProperty(t)&&web_dist_esm_c[t])?e+"px":(""+e).trim()}var web_dist_esm_v={};function esm_V(t,e){if(!t.nodeType||!t.setAttribute)return!1;let r=t.nodeName==="filter"||t.parentNode&&t.parentNode.nodeName==="filter",{style:i,children:s,scrollTop:u,scrollLeft:l,viewBox:a,...n}=e,d=Object.values(n),m=Object.keys(n).map(o=>r||t.hasAttribute(o)?o:web_dist_esm_v[o]||(web_dist_esm_v[o]=o.replace(/([A-Z])/g,p=>"-"+p.toLowerCase())));s!==void 0&&(t.textContent=s);for(let o in i)if(i.hasOwnProperty(o)){let p=web_dist_esm_I(o,i[o]);web_dist_esm_k.test(o)?t.style.setProperty(o,p):t.style[o]=p}m.forEach((o,p)=>{t.setAttribute(o,d[p])}),u!==void 0&&(t.scrollTop=u),l!==void 0&&(t.scrollLeft=l),a!==void 0&&t.setAttribute("viewBox",a)}var web_dist_esm_c={animationIterationCount:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},esm_F=(t,e)=>t+e.charAt(0).toUpperCase()+e.substring(1),esm_L=["Webkit","Ms","Moz","O"];web_dist_esm_c=Object.keys(web_dist_esm_c).reduce((t,e)=>(esm_L.forEach(r=>t[esm_F(r,e)]=t[e]),t),web_dist_esm_c);var esm_=/^(matrix|translate|scale|rotate|skew)/,dist_esm_$=/^(translate)/,dist_esm_G=/^(rotate|skew)/,web_dist_esm_y=(t,e)=>dist_esm_l.num(t)&&t!==0?t+e:t,web_dist_esm_h=(t,e)=>dist_esm_l.arr(t)?t.every(r=>web_dist_esm_h(r,e)):dist_esm_l.num(t)?t===e:parseFloat(t)===e,dist_esm_g=class extends animated_dist_esm_u{constructor({x:e,y:r,z:i,...s}){let u=[],l=[];(e||r||i)&&(u.push([e||0,r||0,i||0]),l.push(a=>[`translate3d($a.map(n=>web_dist_esm_y(n,"px")).join(",")})`,web_dist_esm_h(a,0)])),xt(s,(a,n)=>{if(n==="transform")u.push([a||""]),l.push(d=>[d,d===""]);else if(esm_.test(n)){if(delete s[n],dist_esm_l.und(a))return;let d=dist_esm_$.test(n)?"px":dist_esm_G.test(n)?"deg":"";u.push(ht(a)),l.push(n==="rotate3d"?([m,o,p,O])=>[`rotate3d($m},$o},$p},$web_dist_esm_y(O,d)})`,web_dist_esm_h(O,0)]:m=>[`$n}($m.map(o=>web_dist_esm_y(o,d)).join(",")})`,web_dist_esm_h(m,n.startsWith("scale")?1:0)])}}),u.length&&(s.transform=new web_dist_esm_x(u,l)),super(s)}},web_dist_esm_x=class extends esm_ge{constructor(r,i){super();this.inputs=r;this.transforms=i}_value=null;get(){return this._value||(this._value=this._get())}_get(){let r="",i=!0;return esm_Ve(this.inputs,(s,u)=>{let l=ve(s[0]),[a,n]=this.transforms[u](dist_esm_l.arr(l)?l:s.map(ve));r+=" "+a,i=i&&n}),i?"none":r}observerAdded(r){r==1&&esm_Ve(this.inputs,i=>esm_Ve(i,s=>Pt(s)&&Gt(s,this)))}observerRemoved(r){r==0&&esm_Ve(this.inputs,i=>esm_Ve(i,s=>Pt(s)&&Qt(s,this)))}eventObserved(r){r.type=="change"&&(this._value=null),$t(this,r)}};var esm_C=["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","big","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","iframe","img","input","ins","kbd","keygen","label","legend","li","link","main","map","mark","menu","menuitem","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","param","picture","pre","progress","q","rp","rt","ruby","s","samp","script","section","select","small","source","span","strong","style","sub","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","title","tr","track","u","ul","var","video","wbr","circle","clipPath","defs","ellipse","foreignObject","g","image","line","linearGradient","mask","path","pattern","polygon","polyline","radialGradient","rect","stop","svg","text","tspan"];dist_esm_p.assign({batchedUpdates:external_ReactDOM_namespaceObject.unstable_batchedUpdates,createStringInterpolator:Xt,colors:It});var dist_esm_q=dist_esm_Ke(esm_C,{applyAnimatedValues:esm_V,createAnimatedStyle:t=>new dist_esm_g(t),getComponentProps:({scrollTop:t,scrollLeft:e,...r})=>r}),dist_esm_it=dist_esm_q.animated; 37763 37764 ;// ./node_modules/@wordpress/block-editor/build-module/components/use-moving-animation/index.js 37765 /** 37766 * External dependencies 37767 */ 37768 37769 37770 /** 37771 * WordPress dependencies 37772 */ 37773 37774 37775 37776 37777 /** 37778 * Internal dependencies 37779 */ 37780 37781 37782 /** 37783 * If the block count exceeds the threshold, we disable the reordering animation 37784 * to avoid laginess. 37785 */ 37786 const BLOCK_ANIMATION_THRESHOLD = 200; 37787 function getAbsolutePosition(element) { 37788 return { 37789 top: element.offsetTop, 37790 left: element.offsetLeft 37791 }; 37792 } 37793 37794 /** 37795 * Hook used to compute the styles required to move a div into a new position. 37796 * 37797 * The way this animation works is the following: 37798 * - It first renders the element as if there was no animation. 37799 * - It takes a snapshot of the position of the block to use it 37800 * as a destination point for the animation. 37801 * - It restores the element to the previous position using a CSS transform 37802 * - It uses the "resetAnimation" flag to reset the animation 37803 * from the beginning in order to animate to the new destination point. 37804 * 37805 * @param {Object} $1 Options 37806 * @param {*} $1.triggerAnimationOnChange Variable used to trigger the animation if it changes. 37807 * @param {string} $1.clientId 37808 */ 37809 function useMovingAnimation({ 37810 triggerAnimationOnChange, 37811 clientId 37812 }) { 37813 const ref = (0,external_wp_element_namespaceObject.useRef)(); 37814 const { 37815 isTyping, 37816 getGlobalBlockCount, 37817 isBlockSelected, 37818 isFirstMultiSelectedBlock, 37819 isBlockMultiSelected, 37820 isAncestorMultiSelected 37821 } = (0,external_wp_data_namespaceObject.useSelect)(store); 37822 37823 // Whenever the trigger changes, we need to take a snapshot of the current 37824 // position of the block to use it as a destination point for the animation. 37825 const { 37826 previous, 37827 prevRect 37828 } = (0,external_wp_element_namespaceObject.useMemo)(() => ({ 37829 previous: ref.current && getAbsolutePosition(ref.current), 37830 prevRect: ref.current && ref.current.getBoundingClientRect() 37831 }), 37832 // eslint-disable-next-line react-hooks/exhaustive-deps 37833 [triggerAnimationOnChange]); 37834 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 37835 if (!previous || !ref.current) { 37836 return; 37837 } 37838 const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(ref.current); 37839 const isSelected = isBlockSelected(clientId); 37840 const adjustScrolling = isSelected || isFirstMultiSelectedBlock(clientId); 37841 function preserveScrollPosition() { 37842 if (adjustScrolling && prevRect) { 37843 const blockRect = ref.current.getBoundingClientRect(); 37844 const diff = blockRect.top - prevRect.top; 37845 if (diff) { 37846 scrollContainer.scrollTop += diff; 37847 } 37848 } 37849 } 37850 37851 // We disable the animation if the user has a preference for reduced 37852 // motion, if the user is typing (insertion by Enter), or if the block 37853 // count exceeds the threshold (insertion caused all the blocks that 37854 // follow to animate). 37855 // To do: consider enableing the _moving_ animation even for large 37856 // posts, while only disabling the _insertion_ animation? 37857 const disableAnimation = window.matchMedia('(prefers-reduced-motion: reduce)').matches || isTyping() || getGlobalBlockCount() > BLOCK_ANIMATION_THRESHOLD; 37858 if (disableAnimation) { 37859 // If the animation is disabled and the scroll needs to be adjusted, 37860 // just move directly to the final scroll position. 37861 preserveScrollPosition(); 37862 return; 37863 } 37864 const isPartOfSelection = isSelected || isBlockMultiSelected(clientId) || isAncestorMultiSelected(clientId); 37865 // Make sure the other blocks move under the selected block(s). 37866 const zIndex = isPartOfSelection ? '1' : ''; 37867 const controller = new esm_le({ 37868 x: 0, 37869 y: 0, 37870 config: { 37871 mass: 5, 37872 tension: 2000, 37873 friction: 200 37874 }, 37875 onChange({ 37876 value 37877 }) { 37878 if (!ref.current) { 37879 return; 37880 } 37881 let { 37882 x, 37883 y 37884 } = value; 37885 x = Math.round(x); 37886 y = Math.round(y); 37887 const finishedMoving = x === 0 && y === 0; 37888 ref.current.style.transformOrigin = 'center center'; 37889 ref.current.style.transform = finishedMoving ? null // Set to `null` to explicitly remove the transform. 37890 : `translate3d($x}px,$y}px,0)`; 37891 ref.current.style.zIndex = zIndex; 37892 preserveScrollPosition(); 37893 } 37894 }); 37895 ref.current.style.transform = undefined; 37896 const destination = getAbsolutePosition(ref.current); 37897 const x = Math.round(previous.left - destination.left); 37898 const y = Math.round(previous.top - destination.top); 37899 controller.start({ 37900 x: 0, 37901 y: 0, 37902 from: { 37903 x, 37904 y 37905 } 37906 }); 37907 return () => { 37908 controller.stop(); 37909 controller.set({ 37910 x: 0, 37911 y: 0 37912 }); 37913 }; 37914 }, [previous, prevRect, clientId, isTyping, getGlobalBlockCount, isBlockSelected, isFirstMultiSelectedBlock, isBlockMultiSelected, isAncestorMultiSelected]); 37915 return ref; 37916 } 37917 /* harmony default export */ const use_moving_animation = (useMovingAnimation); 37918 37919 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-focus-first-element.js 37920 /** 37921 * WordPress dependencies 37922 */ 37923 37924 37925 37926 37927 /** 37928 * Internal dependencies 37929 */ 37930 37931 37932 37933 /** @typedef {import('@wordpress/element').RefObject} RefObject */ 37934 37935 /** 37936 * Transitions focus to the block or inner tabbable when the block becomes 37937 * selected and an initial position is set. 37938 * 37939 * @param {string} clientId Block client ID. 37940 * 37941 * @return {RefObject} React ref with the block element. 37942 */ 37943 function useFocusFirstElement({ 37944 clientId, 37945 initialPosition 37946 }) { 37947 const ref = (0,external_wp_element_namespaceObject.useRef)(); 37948 const { 37949 isBlockSelected, 37950 isMultiSelecting, 37951 __unstableGetEditorMode 37952 } = (0,external_wp_data_namespaceObject.useSelect)(store); 37953 (0,external_wp_element_namespaceObject.useEffect)(() => { 37954 // Check if the block is still selected at the time this effect runs. 37955 if (!isBlockSelected(clientId) || isMultiSelecting() || __unstableGetEditorMode() === 'zoom-out') { 37956 return; 37957 } 37958 if (initialPosition === undefined || initialPosition === null) { 37959 return; 37960 } 37961 if (!ref.current) { 37962 return; 37963 } 37964 const { 37965 ownerDocument 37966 } = ref.current; 37967 37968 // Do not focus the block if it already contains the active element. 37969 if (isInsideRootBlock(ref.current, ownerDocument.activeElement)) { 37970 return; 37971 } 37972 37973 // Find all tabbables within node. 37974 const textInputs = external_wp_dom_namespaceObject.focus.tabbable.find(ref.current).filter(node => (0,external_wp_dom_namespaceObject.isTextField)(node)); 37975 37976 // If reversed (e.g. merge via backspace), use the last in the set of 37977 // tabbables. 37978 const isReverse = -1 === initialPosition; 37979 const target = textInputs[isReverse ? textInputs.length - 1 : 0] || ref.current; 37980 if (!isInsideRootBlock(ref.current, target)) { 37981 ref.current.focus(); 37982 return; 37983 } 37984 37985 // Check to see if element is focussable before a generic caret insert. 37986 if (!ref.current.getAttribute('contenteditable')) { 37987 const focusElement = external_wp_dom_namespaceObject.focus.tabbable.findNext(ref.current); 37988 // Make sure focusElement is valid, contained in the same block, and a form field. 37989 if (focusElement && isInsideRootBlock(ref.current, focusElement) && (0,external_wp_dom_namespaceObject.isFormElement)(focusElement)) { 37990 focusElement.focus(); 37991 return; 37992 } 37993 } 37994 (0,external_wp_dom_namespaceObject.placeCaretAtHorizontalEdge)(target, isReverse); 37995 }, [initialPosition, clientId]); 37996 return ref; 37997 } 37998 37999 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-is-hovered.js 38000 /** 38001 * WordPress dependencies 38002 */ 38003 38004 38005 38006 /** 38007 * Internal dependencies 38008 */ 38009 38010 38011 /* 38012 * Adds `is-hovered` class when the block is hovered and in navigation or 38013 * outline mode. 38014 */ 38015 function useIsHovered({ 38016 clientId 38017 }) { 38018 const { 38019 hoverBlock 38020 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 38021 function listener(event) { 38022 if (event.defaultPrevented) { 38023 return; 38024 } 38025 const action = event.type === 'mouseover' ? 'add' : 'remove'; 38026 event.preventDefault(); 38027 event.currentTarget.classList[action]('is-hovered'); 38028 if (action === 'add') { 38029 hoverBlock(clientId); 38030 } else { 38031 hoverBlock(null); 38032 } 38033 } 38034 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 38035 node.addEventListener('mouseout', listener); 38036 node.addEventListener('mouseover', listener); 38037 return () => { 38038 node.removeEventListener('mouseout', listener); 38039 node.removeEventListener('mouseover', listener); 38040 38041 // Remove class in case it lingers. 38042 node.classList.remove('is-hovered'); 38043 hoverBlock(null); 38044 }; 38045 }, []); 38046 } 38047 38048 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-focus-handler.js 38049 /** 38050 * WordPress dependencies 38051 */ 38052 38053 38054 38055 /** 38056 * Internal dependencies 38057 */ 38058 38059 38060 38061 /** 38062 * Selects the block if it receives focus. 38063 * 38064 * @param {string} clientId Block client ID. 38065 */ 38066 function useFocusHandler(clientId) { 38067 const { 38068 isBlockSelected 38069 } = (0,external_wp_data_namespaceObject.useSelect)(store); 38070 const { 38071 selectBlock, 38072 selectionChange 38073 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 38074 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 38075 /** 38076 * Marks the block as selected when focused and not already 38077 * selected. This specifically handles the case where block does not 38078 * set focus on its own (via `setFocus`), typically if there is no 38079 * focusable input in the block. 38080 * 38081 * @param {FocusEvent} event Focus event. 38082 */ 38083 function onFocus(event) { 38084 // When the whole editor is editable, let writing flow handle 38085 // selection. 38086 if (node.parentElement.closest('[contenteditable="true"]')) { 38087 return; 38088 } 38089 38090 // Check synchronously because a non-selected block might be 38091 // getting data through `useSelect` asynchronously. 38092 if (isBlockSelected(clientId)) { 38093 // Potentially change selection away from rich text. 38094 if (!event.target.isContentEditable) { 38095 selectionChange(clientId); 38096 } 38097 return; 38098 } 38099 38100 // If an inner block is focussed, that block is resposible for 38101 // setting the selected block. 38102 if (!isInsideRootBlock(node, event.target)) { 38103 return; 38104 } 38105 selectBlock(clientId); 38106 } 38107 node.addEventListener('focusin', onFocus); 38108 return () => { 38109 node.removeEventListener('focusin', onFocus); 38110 }; 38111 }, [isBlockSelected, selectBlock]); 38112 } 38113 38114 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-selected-block-event-handlers.js 38115 /** 38116 * WordPress dependencies 38117 */ 38118 38119 38120 38121 38122 38123 /** 38124 * Internal dependencies 38125 */ 38126 38127 38128 38129 /** 38130 * Adds block behaviour: 38131 * - Removes the block on BACKSPACE. 38132 * - Inserts a default block on ENTER. 38133 * - Disables dragging of block contents. 38134 * 38135 * @param {string} clientId Block client ID. 38136 */ 38137 function useEventHandlers({ 38138 clientId, 38139 isSelected 38140 }) { 38141 const { 38142 getBlockRootClientId, 38143 getBlockIndex, 38144 isZoomOut, 38145 __unstableGetEditorMode 38146 } = unlock((0,external_wp_data_namespaceObject.useSelect)(store)); 38147 const { 38148 insertAfterBlock, 38149 removeBlock, 38150 __unstableSetEditorMode, 38151 resetZoomLevel 38152 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 38153 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 38154 if (!isSelected) { 38155 return; 38156 } 38157 38158 /** 38159 * Interprets keydown event intent to remove or insert after block if 38160 * key event occurs on wrapper node. This can occur when the block has 38161 * no text fields of its own, particularly after initial insertion, to 38162 * allow for easy deletion and continuous writing flow to add additional 38163 * content. 38164 * 38165 * @param {KeyboardEvent} event Keydown event. 38166 */ 38167 function onKeyDown(event) { 38168 const { 38169 keyCode, 38170 target 38171 } = event; 38172 if (keyCode !== external_wp_keycodes_namespaceObject.ENTER && keyCode !== external_wp_keycodes_namespaceObject.BACKSPACE && keyCode !== external_wp_keycodes_namespaceObject.DELETE) { 38173 return; 38174 } 38175 if (target !== node || (0,external_wp_dom_namespaceObject.isTextField)(target)) { 38176 return; 38177 } 38178 event.preventDefault(); 38179 if (keyCode === external_wp_keycodes_namespaceObject.ENTER && __unstableGetEditorMode() === 'zoom-out' && isZoomOut()) { 38180 __unstableSetEditorMode('edit'); 38181 resetZoomLevel(); 38182 } else if (keyCode === external_wp_keycodes_namespaceObject.ENTER) { 38183 insertAfterBlock(clientId); 38184 } else { 38185 removeBlock(clientId); 38186 } 38187 } 38188 38189 /** 38190 * Prevents default dragging behavior within a block. To do: we must 38191 * handle this in the future and clean up the drag target. 38192 * 38193 * @param {DragEvent} event Drag event. 38194 */ 38195 function onDragStart(event) { 38196 event.preventDefault(); 38197 } 38198 node.addEventListener('keydown', onKeyDown); 38199 node.addEventListener('dragstart', onDragStart); 38200 return () => { 38201 node.removeEventListener('keydown', onKeyDown); 38202 node.removeEventListener('dragstart', onDragStart); 38203 }; 38204 }, [clientId, isSelected, getBlockRootClientId, getBlockIndex, insertAfterBlock, removeBlock, __unstableGetEditorMode, __unstableSetEditorMode, isZoomOut, resetZoomLevel]); 38205 } 38206 38207 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-nav-mode-exit.js 38208 /** 38209 * WordPress dependencies 38210 */ 38211 38212 38213 38214 /** 38215 * Internal dependencies 38216 */ 38217 38218 38219 /** 38220 * Allows navigation mode to be exited by clicking in the selected block. 38221 * 38222 * @param {string} clientId Block client ID. 38223 */ 38224 function useNavModeExit(clientId) { 38225 const { 38226 isNavigationMode, 38227 isBlockSelected 38228 } = (0,external_wp_data_namespaceObject.useSelect)(store); 38229 const { 38230 setNavigationMode, 38231 selectBlock 38232 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 38233 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 38234 function onMouseDown(event) { 38235 // Don't select a block if it's already handled by a child 38236 // block. 38237 if (isNavigationMode() && !event.defaultPrevented) { 38238 // Prevent focus from moving to the block. 38239 event.preventDefault(); 38240 38241 // When clicking on a selected block, exit navigation mode. 38242 if (isBlockSelected(clientId)) { 38243 setNavigationMode(false); 38244 } else { 38245 selectBlock(clientId); 38246 } 38247 } 38248 } 38249 node.addEventListener('mousedown', onMouseDown); 38250 return () => { 38251 node.removeEventListener('mousedown', onMouseDown); 38252 }; 38253 }, [clientId, isNavigationMode, isBlockSelected, setNavigationMode]); 38254 } 38255 38256 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-zoom-out-mode-exit.js 38257 /** 38258 * WordPress dependencies 38259 */ 38260 38261 38262 38263 /** 38264 * Internal dependencies 38265 */ 38266 38267 38268 38269 /** 38270 * Allows Zoom Out mode to be exited by double clicking in the selected block. 38271 */ 38272 function useZoomOutModeExit() { 38273 const { 38274 getSettings, 38275 isZoomOut, 38276 __unstableGetEditorMode 38277 } = unlock((0,external_wp_data_namespaceObject.useSelect)(store)); 38278 const { 38279 __unstableSetEditorMode, 38280 resetZoomLevel 38281 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 38282 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 38283 function onDoubleClick(event) { 38284 // In "compose" mode. 38285 const composeMode = __unstableGetEditorMode() === 'zoom-out' && isZoomOut(); 38286 if (!composeMode) { 38287 return; 38288 } 38289 if (!event.defaultPrevented) { 38290 event.preventDefault(); 38291 const { 38292 __experimentalSetIsInserterOpened 38293 } = getSettings(); 38294 if (typeof __experimentalSetIsInserterOpened === 'function') { 38295 __experimentalSetIsInserterOpened(false); 38296 } 38297 __unstableSetEditorMode('edit'); 38298 resetZoomLevel(); 38299 } 38300 } 38301 node.addEventListener('dblclick', onDoubleClick); 38302 return () => { 38303 node.removeEventListener('dblclick', onDoubleClick); 38304 }; 38305 }, [getSettings, __unstableSetEditorMode, __unstableGetEditorMode, isZoomOut, resetZoomLevel]); 38306 } 38307 38308 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-intersection-observer.js 38309 /** 38310 * WordPress dependencies 38311 */ 38312 38313 38314 38315 /** 38316 * Internal dependencies 38317 */ 38318 38319 function useIntersectionObserver() { 38320 const observer = (0,external_wp_element_namespaceObject.useContext)(block_list_IntersectionObserver); 38321 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 38322 if (observer) { 38323 observer.observe(node); 38324 return () => { 38325 observer.unobserve(node); 38326 }; 38327 } 38328 }, [observer]); 38329 } 38330 38331 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-scroll-into-view.js 38332 /** 38333 * WordPress dependencies 38334 */ 38335 38336 function useScrollIntoView({ 38337 isSelected 38338 }) { 38339 const prefersReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)(); 38340 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 38341 if (isSelected) { 38342 const { 38343 ownerDocument 38344 } = node; 38345 const { 38346 defaultView 38347 } = ownerDocument; 38348 if (!defaultView.IntersectionObserver) { 38349 return; 38350 } 38351 const observer = new defaultView.IntersectionObserver(entries => { 38352 // Once observing starts, we always get an initial 38353 // entry with the intersecting state. 38354 if (!entries[0].isIntersecting) { 38355 node.scrollIntoView({ 38356 behavior: prefersReducedMotion ? 'instant' : 'smooth' 38357 }); 38358 } 38359 observer.disconnect(); 38360 }); 38361 observer.observe(node); 38362 return () => { 38363 observer.disconnect(); 38364 }; 38365 } 38366 }, [isSelected]); 38367 } 38368 38369 ;// ./node_modules/@wordpress/block-editor/build-module/components/use-flash-editable-blocks/index.js 38370 /** 38371 * WordPress dependencies 38372 */ 38373 38374 38375 38376 /** 38377 * Internal dependencies 38378 */ 38379 38380 38381 function useFlashEditableBlocks({ 38382 clientId = '', 38383 isEnabled = true 38384 } = {}) { 38385 const { 38386 getEnabledClientIdsTree 38387 } = unlock((0,external_wp_data_namespaceObject.useSelect)(store)); 38388 return (0,external_wp_compose_namespaceObject.useRefEffect)(element => { 38389 if (!isEnabled) { 38390 return; 38391 } 38392 const flashEditableBlocks = () => { 38393 getEnabledClientIdsTree(clientId).forEach(({ 38394 clientId: id 38395 }) => { 38396 const block = element.querySelector(`[data-block="$id}"]`); 38397 if (!block) { 38398 return; 38399 } 38400 block.classList.remove('has-editable-outline'); 38401 // Force reflow to trigger the animation. 38402 // eslint-disable-next-line no-unused-expressions 38403 block.offsetWidth; 38404 block.classList.add('has-editable-outline'); 38405 }); 38406 }; 38407 const handleClick = event => { 38408 const shouldFlash = event.target === element || event.target.classList.contains('is-root-container'); 38409 if (!shouldFlash) { 38410 return; 38411 } 38412 if (event.defaultPrevented) { 38413 return; 38414 } 38415 event.preventDefault(); 38416 flashEditableBlocks(); 38417 }; 38418 element.addEventListener('click', handleClick); 38419 return () => element.removeEventListener('click', handleClick); 38420 }, [isEnabled]); 38421 } 38422 38423 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-bindings-attributes.js 38424 /** 38425 * WordPress dependencies 38426 */ 38427 38428 38429 38430 38431 38432 38433 /** 38434 * Internal dependencies 38435 */ 38436 38437 38438 38439 38440 /** @typedef {import('@wordpress/compose').WPHigherOrderComponent} WPHigherOrderComponent */ 38441 /** @typedef {import('@wordpress/blocks').WPBlockSettings} WPBlockSettings */ 38442 38443 /** 38444 * Given a binding of block attributes, returns a higher order component that 38445 * overrides its `attributes` and `setAttributes` props to sync any changes needed. 38446 * 38447 * @return {WPHigherOrderComponent} Higher-order component. 38448 */ 38449 38450 38451 const BLOCK_BINDINGS_ALLOWED_BLOCKS = { 38452 'core/paragraph': ['content'], 38453 'core/heading': ['content'], 38454 'core/image': ['id', 'url', 'title', 'alt'], 38455 'core/button': ['url', 'text', 'linkTarget', 'rel'] 38456 }; 38457 const DEFAULT_ATTRIBUTE = '__default'; 38458 38459 /** 38460 * Returns the bindings with the `__default` binding for pattern overrides 38461 * replaced with the full-set of supported attributes. e.g.: 38462 * 38463 * bindings passed in: `{ __default: { source: 'core/pattern-overrides' } }` 38464 * bindings returned: `{ content: { source: 'core/pattern-overrides' } }` 38465 * 38466 * @param {string} blockName The block name (e.g. 'core/paragraph'). 38467 * @param {Object} bindings A block's bindings from the metadata attribute. 38468 * 38469 * @return {Object} The bindings with default replaced for pattern overrides. 38470 */ 38471 function replacePatternOverrideDefaultBindings(blockName, bindings) { 38472 // The `__default` binding currently only works for pattern overrides. 38473 if (bindings?.[DEFAULT_ATTRIBUTE]?.source === 'core/pattern-overrides') { 38474 const supportedAttributes = BLOCK_BINDINGS_ALLOWED_BLOCKS[blockName]; 38475 const bindingsWithDefaults = {}; 38476 for (const attributeName of supportedAttributes) { 38477 // If the block has mixed binding sources, retain any non pattern override bindings. 38478 const bindingSource = bindings[attributeName] ? bindings[attributeName] : { 38479 source: 'core/pattern-overrides' 38480 }; 38481 bindingsWithDefaults[attributeName] = bindingSource; 38482 } 38483 return bindingsWithDefaults; 38484 } 38485 return bindings; 38486 } 38487 38488 /** 38489 * Based on the given block name, 38490 * check if it is possible to bind the block. 38491 * 38492 * @param {string} blockName - The block name. 38493 * @return {boolean} Whether it is possible to bind the block to sources. 38494 */ 38495 function canBindBlock(blockName) { 38496 return blockName in BLOCK_BINDINGS_ALLOWED_BLOCKS; 38497 } 38498 38499 /** 38500 * Based on the given block name and attribute name, 38501 * check if it is possible to bind the block attribute. 38502 * 38503 * @param {string} blockName - The block name. 38504 * @param {string} attributeName - The attribute name. 38505 * @return {boolean} Whether it is possible to bind the block attribute. 38506 */ 38507 function canBindAttribute(blockName, attributeName) { 38508 return canBindBlock(blockName) && BLOCK_BINDINGS_ALLOWED_BLOCKS[blockName].includes(attributeName); 38509 } 38510 function getBindableAttributes(blockName) { 38511 return BLOCK_BINDINGS_ALLOWED_BLOCKS[blockName]; 38512 } 38513 const withBlockBindingSupport = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockEdit => props => { 38514 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 38515 const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context); 38516 const sources = (0,external_wp_data_namespaceObject.useSelect)(select => unlock(select(external_wp_blocks_namespaceObject.store)).getAllBlockBindingsSources()); 38517 const { 38518 name, 38519 clientId, 38520 context, 38521 setAttributes 38522 } = props; 38523 const blockBindings = (0,external_wp_element_namespaceObject.useMemo)(() => replacePatternOverrideDefaultBindings(name, props.attributes.metadata?.bindings), [props.attributes.metadata?.bindings, name]); 38524 38525 // While this hook doesn't directly call any selectors, `useSelect` is 38526 // used purposely here to ensure `boundAttributes` is updated whenever 38527 // there are attribute updates. 38528 // `source.getValues` may also call a selector via `registry.select`. 38529 const updatedContext = {}; 38530 const boundAttributes = (0,external_wp_data_namespaceObject.useSelect)(select => { 38531 if (!blockBindings) { 38532 return; 38533 } 38534 const attributes = {}; 38535 const blockBindingsBySource = new Map(); 38536 for (const [attributeName, binding] of Object.entries(blockBindings)) { 38537 const { 38538 source: sourceName, 38539 args: sourceArgs 38540 } = binding; 38541 const source = sources[sourceName]; 38542 if (!source || !canBindAttribute(name, attributeName)) { 38543 continue; 38544 } 38545 38546 // Populate context. 38547 for (const key of source.usesContext || []) { 38548 updatedContext[key] = blockContext[key]; 38549 } 38550 blockBindingsBySource.set(source, { 38551 ...blockBindingsBySource.get(source), 38552 [attributeName]: { 38553 args: sourceArgs 38554 } 38555 }); 38556 } 38557 if (blockBindingsBySource.size) { 38558 for (const [source, bindings] of blockBindingsBySource) { 38559 // Get values in batch if the source supports it. 38560 let values = {}; 38561 if (!source.getValues) { 38562 Object.keys(bindings).forEach(attr => { 38563 // Default to the the source label when `getValues` doesn't exist. 38564 values[attr] = source.label; 38565 }); 38566 } else { 38567 values = source.getValues({ 38568 select, 38569 context: updatedContext, 38570 clientId, 38571 bindings 38572 }); 38573 } 38574 for (const [attributeName, value] of Object.entries(values)) { 38575 if (attributeName === 'url' && (!value || !isURLLike(value))) { 38576 // Return null if value is not a valid URL. 38577 attributes[attributeName] = null; 38578 } else { 38579 attributes[attributeName] = value; 38580 } 38581 } 38582 } 38583 } 38584 return attributes; 38585 }, [blockBindings, name, clientId, updatedContext, sources]); 38586 const hasParentPattern = !!updatedContext['pattern/overrides']; 38587 const hasPatternOverridesDefaultBinding = props.attributes.metadata?.bindings?.[DEFAULT_ATTRIBUTE]?.source === 'core/pattern-overrides'; 38588 const _setAttributes = (0,external_wp_element_namespaceObject.useCallback)(nextAttributes => { 38589 registry.batch(() => { 38590 if (!blockBindings) { 38591 setAttributes(nextAttributes); 38592 return; 38593 } 38594 const keptAttributes = { 38595 ...nextAttributes 38596 }; 38597 const blockBindingsBySource = new Map(); 38598 38599 // Loop only over the updated attributes to avoid modifying the bound ones that haven't changed. 38600 for (const [attributeName, newValue] of Object.entries(keptAttributes)) { 38601 if (!blockBindings[attributeName] || !canBindAttribute(name, attributeName)) { 38602 continue; 38603 } 38604 const binding = blockBindings[attributeName]; 38605 const source = sources[binding?.source]; 38606 if (!source?.setValues) { 38607 continue; 38608 } 38609 blockBindingsBySource.set(source, { 38610 ...blockBindingsBySource.get(source), 38611 [attributeName]: { 38612 args: binding.args, 38613 newValue 38614 } 38615 }); 38616 delete keptAttributes[attributeName]; 38617 } 38618 if (blockBindingsBySource.size) { 38619 for (const [source, bindings] of blockBindingsBySource) { 38620 source.setValues({ 38621 select: registry.select, 38622 dispatch: registry.dispatch, 38623 context: updatedContext, 38624 clientId, 38625 bindings 38626 }); 38627 } 38628 } 38629 if ( 38630 // Don't update non-connected attributes if the block is using pattern overrides 38631 // and the editing is happening while overriding the pattern (not editing the original). 38632 !(hasPatternOverridesDefaultBinding && hasParentPattern) && Object.keys(keptAttributes).length) { 38633 // Don't update caption and href until they are supported. 38634 if (hasPatternOverridesDefaultBinding) { 38635 delete keptAttributes?.caption; 38636 delete keptAttributes?.href; 38637 } 38638 setAttributes(keptAttributes); 38639 } 38640 }); 38641 }, [registry, blockBindings, name, clientId, updatedContext, setAttributes, sources, hasPatternOverridesDefaultBinding, hasParentPattern]); 38642 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 38643 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEdit, { 38644 ...props, 38645 attributes: { 38646 ...props.attributes, 38647 ...boundAttributes 38648 }, 38649 setAttributes: _setAttributes, 38650 context: { 38651 ...context, 38652 ...updatedContext 38653 } 38654 }) 38655 }); 38656 }, 'withBlockBindingSupport'); 38657 38658 /** 38659 * Filters a registered block's settings to enhance a block's `edit` component 38660 * to upgrade bound attributes. 38661 * 38662 * @param {WPBlockSettings} settings - Registered block settings. 38663 * @param {string} name - Block name. 38664 * @return {WPBlockSettings} Filtered block settings. 38665 */ 38666 function shimAttributeSource(settings, name) { 38667 if (!canBindBlock(name)) { 38668 return settings; 38669 } 38670 return { 38671 ...settings, 38672 edit: withBlockBindingSupport(settings.edit) 38673 }; 38674 } 38675 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/editor/custom-sources-backwards-compatibility/shim-attribute-source', shimAttributeSource); 38676 38677 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/index.js 38678 /** 38679 * External dependencies 38680 */ 38681 38682 38683 /** 38684 * WordPress dependencies 38685 */ 38686 38687 38688 38689 38690 38691 38692 /** 38693 * Internal dependencies 38694 */ 38695 38696 38697 38698 38699 38700 38701 38702 38703 38704 38705 38706 38707 38708 38709 38710 /** 38711 * This hook is used to lightly mark an element as a block element. The element 38712 * should be the outermost element of a block. Call this hook and pass the 38713 * returned props to the element to mark as a block. If you define a ref for the 38714 * element, it is important to pass the ref to this hook, which the hook in turn 38715 * will pass to the component through the props it returns. Optionally, you can 38716 * also pass any other props through this hook, and they will be merged and 38717 * returned. 38718 * 38719 * Use of this hook on the outermost element of a block is required if using API >= v2. 38720 * 38721 * @example 38722 * ```js 38723 * import { useBlockProps } from '@wordpress/block-editor'; 38724 * 38725 * export default function Edit() { 38726 * 38727 * const blockProps = useBlockProps( { 38728 * className: 'my-custom-class', 38729 * style: { 38730 * color: '#222222', 38731 * backgroundColor: '#eeeeee' 38732 * } 38733 * } ) 38734 * 38735 * return ( 38736 * <div { ...blockProps }> 38737 * 38738 * </div> 38739 * ) 38740 * } 38741 * 38742 * ``` 38743 * 38744 * 38745 * @param {Object} props Optional. Props to pass to the element. Must contain 38746 * the ref if one is defined. 38747 * @param {Object} options Options for internal use only. 38748 * @param {boolean} options.__unstableIsHtml 38749 * 38750 * @return {Object} Props to pass to the element to mark as a block. 38751 */ 38752 function use_block_props_useBlockProps(props = {}, { 38753 __unstableIsHtml 38754 } = {}) { 38755 const { 38756 clientId, 38757 className, 38758 wrapperProps = {}, 38759 isAligned, 38760 index, 38761 mode, 38762 name, 38763 blockApiVersion, 38764 blockTitle, 38765 isSelected, 38766 isSubtreeDisabled, 38767 hasOverlay, 38768 initialPosition, 38769 blockEditingMode, 38770 isHighlighted, 38771 isMultiSelected, 38772 isPartiallySelected, 38773 isReusable, 38774 isDragging, 38775 hasChildSelected, 38776 isBlockMovingMode, 38777 canInsertMovingBlock, 38778 isEditingDisabled, 38779 hasEditableOutline, 38780 isTemporarilyEditingAsBlocks, 38781 defaultClassName, 38782 templateLock 38783 } = (0,external_wp_element_namespaceObject.useContext)(PrivateBlockContext); 38784 38785 // translators: %s: Type of block (i.e. Text, Image etc) 38786 const blockLabel = (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)('Block: %s'), blockTitle); 38787 const htmlSuffix = mode === 'html' && !__unstableIsHtml ? '-visual' : ''; 38788 const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([props.ref, useFocusFirstElement({ 38789 clientId, 38790 initialPosition 38791 }), useBlockRefProvider(clientId), useFocusHandler(clientId), useEventHandlers({ 38792 clientId, 38793 isSelected 38794 }), useNavModeExit(clientId), useZoomOutModeExit(), useIsHovered({ 38795 clientId 38796 }), useIntersectionObserver(), use_moving_animation({ 38797 triggerAnimationOnChange: index, 38798 clientId 38799 }), (0,external_wp_compose_namespaceObject.useDisabled)({ 38800 isDisabled: !hasOverlay 38801 }), useFlashEditableBlocks({ 38802 clientId, 38803 isEnabled: name === 'core/block' || templateLock === 'contentOnly' 38804 }), useScrollIntoView({ 38805 isSelected 38806 })]); 38807 const blockEditContext = useBlockEditContext(); 38808 const hasBlockBindings = !!blockEditContext[blockBindingsKey]; 38809 const bindingsStyle = hasBlockBindings && canBindBlock(name) ? { 38810 '--wp-admin-theme-color': 'var(--wp-block-synced-color)', 38811 '--wp-admin-theme-color--rgb': 'var(--wp-block-synced-color--rgb)' 38812 } : {}; 38813 38814 // Ensures it warns only inside the `edit` implementation for the block. 38815 if (blockApiVersion < 2 && clientId === blockEditContext.clientId) { 38816 true ? external_wp_warning_default()(`Block type "$name}" must support API version 2 or higher to work correctly with "useBlockProps" method.`) : 0; 38817 } 38818 let hasNegativeMargin = false; 38819 if (wrapperProps?.style?.marginTop?.charAt(0) === '-' || wrapperProps?.style?.marginBottom?.charAt(0) === '-' || wrapperProps?.style?.marginLeft?.charAt(0) === '-' || wrapperProps?.style?.marginRight?.charAt(0) === '-') { 38820 hasNegativeMargin = true; 38821 } 38822 return { 38823 tabIndex: blockEditingMode === 'disabled' ? -1 : 0, 38824 ...wrapperProps, 38825 ...props, 38826 ref: mergedRefs, 38827 id: `block-$clientId}$htmlSuffix}`, 38828 role: 'document', 38829 'aria-label': blockLabel, 38830 'data-block': clientId, 38831 'data-type': name, 38832 'data-title': blockTitle, 38833 inert: isSubtreeDisabled ? 'true' : undefined, 38834 className: dist_clsx('block-editor-block-list__block', { 38835 // The wp-block className is important for editor styles. 38836 'wp-block': !isAligned, 38837 'has-block-overlay': hasOverlay, 38838 'is-selected': isSelected, 38839 'is-highlighted': isHighlighted, 38840 'is-multi-selected': isMultiSelected, 38841 'is-partially-selected': isPartiallySelected, 38842 'is-reusable': isReusable, 38843 'is-dragging': isDragging, 38844 'has-child-selected': hasChildSelected, 38845 'is-block-moving-mode': isBlockMovingMode, 38846 'can-insert-moving-block': canInsertMovingBlock, 38847 'is-editing-disabled': isEditingDisabled, 38848 'has-editable-outline': hasEditableOutline, 38849 'has-negative-margin': hasNegativeMargin, 38850 'is-content-locked-temporarily-editing-as-blocks': isTemporarilyEditingAsBlocks 38851 }, className, props.className, wrapperProps.className, defaultClassName), 38852 style: { 38853 ...wrapperProps.style, 38854 ...props.style, 38855 ...bindingsStyle 38856 } 38857 }; 38858 } 38859 38860 /** 38861 * Call within a save function to get the props for the block wrapper. 38862 * 38863 * @param {Object} props Optional. Props to pass to the element. 38864 */ 38865 use_block_props_useBlockProps.save = external_wp_blocks_namespaceObject.__unstableGetBlockProps; 38866 38867 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block.js 38868 /** 38869 * External dependencies 38870 */ 38871 38872 38873 /** 38874 * WordPress dependencies 38875 */ 38876 38877 38878 38879 38880 38881 38882 38883 /** 38884 * Internal dependencies 38885 */ 38886 38887 38888 38889 38890 38891 38892 38893 38894 38895 38896 38897 38898 38899 const { 38900 isUnmodifiedBlockContent 38901 } = unlock(external_wp_blocks_namespaceObject.privateApis); 38902 38903 /** 38904 * Merges wrapper props with special handling for classNames and styles. 38905 * 38906 * @param {Object} propsA 38907 * @param {Object} propsB 38908 * 38909 * @return {Object} Merged props. 38910 */ 38911 function mergeWrapperProps(propsA, propsB) { 38912 const newProps = { 38913 ...propsA, 38914 ...propsB 38915 }; 38916 38917 // May be set to undefined, so check if the property is set! 38918 if (propsA?.hasOwnProperty('className') && propsB?.hasOwnProperty('className')) { 38919 newProps.className = dist_clsx(propsA.className, propsB.className); 38920 } 38921 if (propsA?.hasOwnProperty('style') && propsB?.hasOwnProperty('style')) { 38922 newProps.style = { 38923 ...propsA.style, 38924 ...propsB.style 38925 }; 38926 } 38927 return newProps; 38928 } 38929 function Block({ 38930 children, 38931 isHtml, 38932 ...props 38933 }) { 38934 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 38935 ...use_block_props_useBlockProps(props, { 38936 __unstableIsHtml: isHtml 38937 }), 38938 children: children 38939 }); 38940 } 38941 function BlockListBlock({ 38942 block: { 38943 __unstableBlockSource 38944 }, 38945 mode, 38946 isLocked, 38947 canRemove, 38948 clientId, 38949 isSelected, 38950 isSelectionEnabled, 38951 className, 38952 __unstableLayoutClassNames: layoutClassNames, 38953 name, 38954 isValid, 38955 attributes, 38956 wrapperProps, 38957 setAttributes, 38958 onReplace, 38959 onInsertBlocksAfter, 38960 onMerge, 38961 toggleSelection 38962 }) { 38963 var _wrapperProps; 38964 const { 38965 mayDisplayControls, 38966 mayDisplayParentControls, 38967 themeSupportsLayout, 38968 ...context 38969 } = (0,external_wp_element_namespaceObject.useContext)(PrivateBlockContext); 38970 const { 38971 removeBlock 38972 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 38973 const onRemove = (0,external_wp_element_namespaceObject.useCallback)(() => removeBlock(clientId), [clientId, removeBlock]); 38974 const parentLayout = useLayout() || {}; 38975 38976 // We wrap the BlockEdit component in a div that hides it when editing in 38977 // HTML mode. This allows us to render all of the ancillary pieces 38978 // (InspectorControls, etc.) which are inside `BlockEdit` but not 38979 // `BlockHTML`, even in HTML mode. 38980 let blockEdit = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEdit, { 38981 name: name, 38982 isSelected: isSelected, 38983 attributes: attributes, 38984 setAttributes: setAttributes, 38985 insertBlocksAfter: isLocked ? undefined : onInsertBlocksAfter, 38986 onReplace: canRemove ? onReplace : undefined, 38987 onRemove: canRemove ? onRemove : undefined, 38988 mergeBlocks: canRemove ? onMerge : undefined, 38989 clientId: clientId, 38990 isSelectionEnabled: isSelectionEnabled, 38991 toggleSelection: toggleSelection, 38992 __unstableLayoutClassNames: layoutClassNames, 38993 __unstableParentLayout: Object.keys(parentLayout).length ? parentLayout : undefined, 38994 mayDisplayControls: mayDisplayControls, 38995 mayDisplayParentControls: mayDisplayParentControls, 38996 blockEditingMode: context.blockEditingMode, 38997 isPreviewMode: context.isPreviewMode 38998 }); 38999 const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name); 39000 39001 // Determine whether the block has props to apply to the wrapper. 39002 if (blockType?.getEditWrapperProps) { 39003 wrapperProps = mergeWrapperProps(wrapperProps, blockType.getEditWrapperProps(attributes)); 39004 } 39005 const isAligned = wrapperProps && !!wrapperProps['data-align'] && !themeSupportsLayout; 39006 39007 // Support for sticky position in classic themes with alignment wrappers. 39008 39009 const isSticky = className?.includes('is-position-sticky'); 39010 39011 // For aligned blocks, provide a wrapper element so the block can be 39012 // positioned relative to the block column. 39013 // This is only kept for classic themes that don't support layout 39014 // Historically we used to rely on extra divs and data-align to 39015 // provide the alignments styles in the editor. 39016 // Due to the differences between frontend and backend, we migrated 39017 // to the layout feature, and we're now aligning the markup of frontend 39018 // and backend. 39019 if (isAligned) { 39020 blockEdit = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 39021 className: dist_clsx('wp-block', isSticky && className), 39022 "data-align": wrapperProps['data-align'], 39023 children: blockEdit 39024 }); 39025 } 39026 let block; 39027 if (!isValid) { 39028 const saveContent = __unstableBlockSource ? (0,external_wp_blocks_namespaceObject.serializeRawBlock)(__unstableBlockSource) : (0,external_wp_blocks_namespaceObject.getSaveContent)(blockType, attributes); 39029 block = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Block, { 39030 className: "has-warning", 39031 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockInvalidWarning, { 39032 clientId: clientId 39033 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.RawHTML, { 39034 children: (0,external_wp_dom_namespaceObject.safeHTML)(saveContent) 39035 })] 39036 }); 39037 } else if (mode === 'html') { 39038 // Render blockEdit so the inspector controls don't disappear. 39039 // See #8969. 39040 block = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 39041 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 39042 style: { 39043 display: 'none' 39044 }, 39045 children: blockEdit 39046 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Block, { 39047 isHtml: true, 39048 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_html, { 39049 clientId: clientId 39050 }) 39051 })] 39052 }); 39053 } else if (blockType?.apiVersion > 1) { 39054 block = blockEdit; 39055 } else { 39056 block = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Block, { 39057 children: blockEdit 39058 }); 39059 } 39060 const { 39061 'data-align': dataAlign, 39062 ...restWrapperProps 39063 } = (_wrapperProps = wrapperProps) !== null && _wrapperProps !== void 0 ? _wrapperProps : {}; 39064 const updatedWrapperProps = { 39065 ...restWrapperProps, 39066 className: dist_clsx(restWrapperProps.className, dataAlign && themeSupportsLayout && `align$dataAlign}`, !(dataAlign && isSticky) && className) 39067 }; 39068 39069 // We set a new context with the adjusted and filtered wrapperProps (through 39070 // `editor.BlockListBlock`), which the `BlockListBlockProvider` did not have 39071 // access to. 39072 // Note that the context value doesn't have to be memoized in this case 39073 // because when it changes, this component will be re-rendered anyway, and 39074 // none of the consumers (BlockListBlock and useBlockProps) are memoized or 39075 // "pure". This is different from the public BlockEditContext, where 39076 // consumers might be memoized or "pure". 39077 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockContext.Provider, { 39078 value: { 39079 wrapperProps: updatedWrapperProps, 39080 isAligned, 39081 ...context 39082 }, 39083 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_crash_boundary, { 39084 fallback: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Block, { 39085 className: "has-warning", 39086 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_crash_warning, {}) 39087 }), 39088 children: block 39089 }) 39090 }); 39091 } 39092 const applyWithDispatch = (0,external_wp_data_namespaceObject.withDispatch)((dispatch, ownProps, registry) => { 39093 const { 39094 updateBlockAttributes, 39095 insertBlocks, 39096 mergeBlocks, 39097 replaceBlocks, 39098 toggleSelection, 39099 __unstableMarkLastChangeAsPersistent, 39100 moveBlocksToPosition, 39101 removeBlock, 39102 selectBlock 39103 } = dispatch(store); 39104 39105 // Do not add new properties here, use `useDispatch` instead to avoid 39106 // leaking new props to the public API (editor.BlockListBlock filter). 39107 return { 39108 setAttributes(newAttributes) { 39109 const { 39110 getMultiSelectedBlockClientIds 39111 } = registry.select(store); 39112 const multiSelectedBlockClientIds = getMultiSelectedBlockClientIds(); 39113 const { 39114 clientId 39115 } = ownProps; 39116 const clientIds = multiSelectedBlockClientIds.length ? multiSelectedBlockClientIds : [clientId]; 39117 updateBlockAttributes(clientIds, newAttributes); 39118 }, 39119 onInsertBlocks(blocks, index) { 39120 const { 39121 rootClientId 39122 } = ownProps; 39123 insertBlocks(blocks, index, rootClientId); 39124 }, 39125 onInsertBlocksAfter(blocks) { 39126 const { 39127 clientId, 39128 rootClientId 39129 } = ownProps; 39130 const { 39131 getBlockIndex 39132 } = registry.select(store); 39133 const index = getBlockIndex(clientId); 39134 insertBlocks(blocks, index + 1, rootClientId); 39135 }, 39136 onMerge(forward) { 39137 const { 39138 clientId, 39139 rootClientId 39140 } = ownProps; 39141 const { 39142 getPreviousBlockClientId, 39143 getNextBlockClientId, 39144 getBlock, 39145 getBlockAttributes, 39146 getBlockName, 39147 getBlockOrder, 39148 getBlockIndex, 39149 getBlockRootClientId, 39150 canInsertBlockType 39151 } = registry.select(store); 39152 function switchToDefaultOrRemove() { 39153 const block = getBlock(clientId); 39154 const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)(); 39155 if (getBlockName(clientId) !== defaultBlockName) { 39156 const replacement = (0,external_wp_blocks_namespaceObject.switchToBlockType)(block, defaultBlockName); 39157 if (replacement && replacement.length) { 39158 replaceBlocks(clientId, replacement); 39159 } 39160 } else if ((0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(block)) { 39161 const nextBlockClientId = getNextBlockClientId(clientId); 39162 if (nextBlockClientId) { 39163 registry.batch(() => { 39164 removeBlock(clientId); 39165 selectBlock(nextBlockClientId); 39166 }); 39167 } 39168 } 39169 } 39170 39171 /** 39172 * Moves the block with clientId up one level. If the block type 39173 * cannot be inserted at the new location, it will be attempted to 39174 * convert to the default block type. 39175 * 39176 * @param {string} _clientId The block to move. 39177 * @param {boolean} changeSelection Whether to change the selection 39178 * to the moved block. 39179 */ 39180 function moveFirstItemUp(_clientId, changeSelection = true) { 39181 const targetRootClientId = getBlockRootClientId(_clientId); 39182 const blockOrder = getBlockOrder(_clientId); 39183 const [firstClientId] = blockOrder; 39184 if (blockOrder.length === 1 && (0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(getBlock(firstClientId))) { 39185 removeBlock(_clientId); 39186 } else { 39187 registry.batch(() => { 39188 const firstBlock = getBlock(firstClientId); 39189 const isFirstBlockContentUnmodified = isUnmodifiedBlockContent(firstBlock); 39190 const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)(); 39191 const replacement = (0,external_wp_blocks_namespaceObject.switchToBlockType)(firstBlock, defaultBlockName); 39192 const canTransformToDefaultBlock = !!replacement?.length && replacement.every(block => canInsertBlockType(block.name, _clientId)); 39193 if (isFirstBlockContentUnmodified && canTransformToDefaultBlock) { 39194 // Step 1: If the block is empty and can be transformed to the default block type. 39195 replaceBlocks(firstClientId, replacement, changeSelection); 39196 } else if (isFirstBlockContentUnmodified && firstBlock.name === defaultBlockName) { 39197 // Step 2: If the block is empty and is already the default block type. 39198 removeBlock(firstClientId); 39199 const nextBlockClientId = getNextBlockClientId(clientId); 39200 if (nextBlockClientId) { 39201 selectBlock(nextBlockClientId); 39202 } 39203 } else if (canInsertBlockType(firstBlock.name, targetRootClientId)) { 39204 // Step 3: If the block can be moved up. 39205 moveBlocksToPosition([firstClientId], _clientId, targetRootClientId, getBlockIndex(_clientId)); 39206 } else { 39207 const canLiftAndTransformToDefaultBlock = !!replacement?.length && replacement.every(block => canInsertBlockType(block.name, targetRootClientId)); 39208 if (canLiftAndTransformToDefaultBlock) { 39209 // Step 4: If the block can be transformed to the default block type and moved up. 39210 insertBlocks(replacement, getBlockIndex(_clientId), targetRootClientId, changeSelection); 39211 removeBlock(firstClientId, false); 39212 } else { 39213 // Step 5: Continue the default behavior. 39214 switchToDefaultOrRemove(); 39215 } 39216 } 39217 if (!getBlockOrder(_clientId).length && (0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(getBlock(_clientId))) { 39218 removeBlock(_clientId, false); 39219 } 39220 }); 39221 } 39222 } 39223 39224 // For `Delete` or forward merge, we should do the exact same thing 39225 // as `Backspace`, but from the other block. 39226 if (forward) { 39227 if (rootClientId) { 39228 const nextRootClientId = getNextBlockClientId(rootClientId); 39229 if (nextRootClientId) { 39230 // If there is a block that follows with the same parent 39231 // block name and the same attributes, merge the inner 39232 // blocks. 39233 if (getBlockName(rootClientId) === getBlockName(nextRootClientId)) { 39234 const rootAttributes = getBlockAttributes(rootClientId); 39235 const previousRootAttributes = getBlockAttributes(nextRootClientId); 39236 if (Object.keys(rootAttributes).every(key => rootAttributes[key] === previousRootAttributes[key])) { 39237 registry.batch(() => { 39238 moveBlocksToPosition(getBlockOrder(nextRootClientId), nextRootClientId, rootClientId); 39239 removeBlock(nextRootClientId, false); 39240 }); 39241 return; 39242 } 39243 } else { 39244 mergeBlocks(rootClientId, nextRootClientId); 39245 return; 39246 } 39247 } 39248 } 39249 const nextBlockClientId = getNextBlockClientId(clientId); 39250 if (!nextBlockClientId) { 39251 return; 39252 } 39253 if (getBlockOrder(nextBlockClientId).length) { 39254 moveFirstItemUp(nextBlockClientId, false); 39255 } else { 39256 mergeBlocks(clientId, nextBlockClientId); 39257 } 39258 } else { 39259 const previousBlockClientId = getPreviousBlockClientId(clientId); 39260 if (previousBlockClientId) { 39261 mergeBlocks(previousBlockClientId, clientId); 39262 } else if (rootClientId) { 39263 const previousRootClientId = getPreviousBlockClientId(rootClientId); 39264 39265 // If there is a preceding block with the same parent block 39266 // name and the same attributes, merge the inner blocks. 39267 if (previousRootClientId && getBlockName(rootClientId) === getBlockName(previousRootClientId)) { 39268 const rootAttributes = getBlockAttributes(rootClientId); 39269 const previousRootAttributes = getBlockAttributes(previousRootClientId); 39270 if (Object.keys(rootAttributes).every(key => rootAttributes[key] === previousRootAttributes[key])) { 39271 registry.batch(() => { 39272 moveBlocksToPosition(getBlockOrder(rootClientId), rootClientId, previousRootClientId); 39273 removeBlock(rootClientId, false); 39274 }); 39275 return; 39276 } 39277 } 39278 moveFirstItemUp(rootClientId); 39279 } else { 39280 switchToDefaultOrRemove(); 39281 } 39282 } 39283 }, 39284 onReplace(blocks, indexToSelect, initialPosition) { 39285 if (blocks.length && !(0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(blocks[blocks.length - 1])) { 39286 __unstableMarkLastChangeAsPersistent(); 39287 } 39288 //Unsynced patterns are nested in an array so we need to flatten them. 39289 const replacementBlocks = blocks?.length === 1 && Array.isArray(blocks[0]) ? blocks[0] : blocks; 39290 replaceBlocks([ownProps.clientId], replacementBlocks, indexToSelect, initialPosition); 39291 }, 39292 toggleSelection(selectionEnabled) { 39293 toggleSelection(selectionEnabled); 39294 } 39295 }; 39296 }); 39297 39298 // This component is used by the BlockListBlockProvider component below. It will 39299 // add the props necessary for the `editor.BlockListBlock` filters. 39300 BlockListBlock = (0,external_wp_compose_namespaceObject.compose)(applyWithDispatch, (0,external_wp_components_namespaceObject.withFilters)('editor.BlockListBlock'))(BlockListBlock); 39301 39302 // This component provides all the information we need through a single store 39303 // subscription (useSelect mapping). Only the necessary props are passed down 39304 // to the BlockListBlock component, which is a filtered component, so these 39305 // props are public API. To avoid adding to the public API, we use a private 39306 // context to pass the rest of the information to the filtered BlockListBlock 39307 // component, and useBlockProps. 39308 function BlockListBlockProvider(props) { 39309 const { 39310 clientId, 39311 rootClientId 39312 } = props; 39313 const selectedProps = (0,external_wp_data_namespaceObject.useSelect)(select => { 39314 const { 39315 isBlockSelected, 39316 getBlockMode, 39317 isSelectionEnabled, 39318 getTemplateLock, 39319 getBlockWithoutAttributes, 39320 getBlockAttributes, 39321 canRemoveBlock, 39322 canMoveBlock, 39323 getSettings, 39324 getTemporarilyEditingAsBlocks, 39325 getBlockEditingMode, 39326 getBlockName, 39327 isFirstMultiSelectedBlock, 39328 getMultiSelectedBlockClientIds, 39329 hasSelectedInnerBlock, 39330 getBlocksByName, 39331 getBlockIndex, 39332 isBlockMultiSelected, 39333 isBlockSubtreeDisabled, 39334 isBlockHighlighted, 39335 __unstableIsFullySelected, 39336 __unstableSelectionHasUnmergeableBlock, 39337 isBlockBeingDragged, 39338 isDragging, 39339 hasBlockMovingClientId, 39340 canInsertBlockType, 39341 __unstableHasActiveBlockOverlayActive, 39342 __unstableGetEditorMode, 39343 getSelectedBlocksInitialCaretPosition 39344 } = unlock(select(store)); 39345 const blockWithoutAttributes = getBlockWithoutAttributes(clientId); 39346 39347 // This is a temporary fix. 39348 // This function should never be called when a block is not 39349 // present in the state. It happens now because the order in 39350 // withSelect rendering is not correct. 39351 if (!blockWithoutAttributes) { 39352 return; 39353 } 39354 const { 39355 hasBlockSupport: _hasBlockSupport, 39356 getActiveBlockVariation 39357 } = select(external_wp_blocks_namespaceObject.store); 39358 const attributes = getBlockAttributes(clientId); 39359 const { 39360 name: blockName, 39361 isValid 39362 } = blockWithoutAttributes; 39363 const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName); 39364 const { 39365 supportsLayout, 39366 __unstableIsPreviewMode: isPreviewMode 39367 } = getSettings(); 39368 const hasLightBlockWrapper = blockType?.apiVersion > 1; 39369 const previewContext = { 39370 isPreviewMode, 39371 blockWithoutAttributes, 39372 name: blockName, 39373 attributes, 39374 isValid, 39375 themeSupportsLayout: supportsLayout, 39376 index: getBlockIndex(clientId), 39377 isReusable: (0,external_wp_blocks_namespaceObject.isReusableBlock)(blockType), 39378 className: hasLightBlockWrapper ? attributes.className : undefined, 39379 defaultClassName: hasLightBlockWrapper ? (0,external_wp_blocks_namespaceObject.getBlockDefaultClassName)(blockName) : undefined, 39380 blockTitle: blockType?.title 39381 }; 39382 39383 // When in preview mode, we can avoid a lot of selection and 39384 // editing related selectors. 39385 if (isPreviewMode) { 39386 return previewContext; 39387 } 39388 const _isSelected = isBlockSelected(clientId); 39389 const canRemove = canRemoveBlock(clientId); 39390 const canMove = canMoveBlock(clientId); 39391 const match = getActiveBlockVariation(blockName, attributes); 39392 const isMultiSelected = isBlockMultiSelected(clientId); 39393 const checkDeep = true; 39394 const isAncestorOfSelectedBlock = hasSelectedInnerBlock(clientId, checkDeep); 39395 const movingClientId = hasBlockMovingClientId(); 39396 const blockEditingMode = getBlockEditingMode(clientId); 39397 const multiple = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, 'multiple', true); 39398 39399 // For block types with `multiple` support, there is no "original 39400 // block" to be found in the content, as the block itself is valid. 39401 const blocksWithSameName = multiple ? [] : getBlocksByName(blockName); 39402 const isInvalid = blocksWithSameName.length && blocksWithSameName[0] !== clientId; 39403 const editorMode = __unstableGetEditorMode(); 39404 return { 39405 ...previewContext, 39406 mode: getBlockMode(clientId), 39407 isSelectionEnabled: isSelectionEnabled(), 39408 isLocked: !!getTemplateLock(rootClientId), 39409 templateLock: getTemplateLock(clientId), 39410 canRemove, 39411 canMove, 39412 isSelected: _isSelected, 39413 isTemporarilyEditingAsBlocks: getTemporarilyEditingAsBlocks() === clientId, 39414 blockEditingMode, 39415 mayDisplayControls: _isSelected || isFirstMultiSelectedBlock(clientId) && getMultiSelectedBlockClientIds().every(id => getBlockName(id) === blockName), 39416 mayDisplayParentControls: _hasBlockSupport(getBlockName(clientId), '__experimentalExposeControlsToChildren', false) && hasSelectedInnerBlock(clientId), 39417 blockApiVersion: blockType?.apiVersion || 1, 39418 blockTitle: match?.title || blockType?.title, 39419 isSubtreeDisabled: blockEditingMode === 'disabled' && isBlockSubtreeDisabled(clientId), 39420 hasOverlay: __unstableHasActiveBlockOverlayActive(clientId) && !isDragging(), 39421 initialPosition: _isSelected && (editorMode === 'edit' || editorMode === 'zoom-out') // Don't recalculate the initialPosition when toggling in/out of zoom-out mode 39422 ? getSelectedBlocksInitialCaretPosition() : undefined, 39423 isHighlighted: isBlockHighlighted(clientId), 39424 isMultiSelected, 39425 isPartiallySelected: isMultiSelected && !__unstableIsFullySelected() && !__unstableSelectionHasUnmergeableBlock(), 39426 isDragging: isBlockBeingDragged(clientId), 39427 hasChildSelected: isAncestorOfSelectedBlock, 39428 isBlockMovingMode: !!movingClientId, 39429 canInsertMovingBlock: movingClientId && canInsertBlockType(getBlockName(movingClientId), rootClientId), 39430 isEditingDisabled: blockEditingMode === 'disabled', 39431 hasEditableOutline: blockEditingMode !== 'disabled' && getBlockEditingMode(rootClientId) === 'disabled', 39432 originalBlockClientId: isInvalid ? blocksWithSameName[0] : false 39433 }; 39434 }, [clientId, rootClientId]); 39435 const { 39436 isPreviewMode, 39437 // Fill values that end up as a public API and may not be defined in 39438 // preview mode. 39439 mode = 'visual', 39440 isSelectionEnabled = false, 39441 isLocked = false, 39442 canRemove = false, 39443 canMove = false, 39444 blockWithoutAttributes, 39445 name, 39446 attributes, 39447 isValid, 39448 isSelected = false, 39449 themeSupportsLayout, 39450 isTemporarilyEditingAsBlocks, 39451 blockEditingMode, 39452 mayDisplayControls, 39453 mayDisplayParentControls, 39454 index, 39455 blockApiVersion, 39456 blockTitle, 39457 isSubtreeDisabled, 39458 hasOverlay, 39459 initialPosition, 39460 isHighlighted, 39461 isMultiSelected, 39462 isPartiallySelected, 39463 isReusable, 39464 isDragging, 39465 hasChildSelected, 39466 isBlockMovingMode, 39467 canInsertMovingBlock, 39468 templateLock, 39469 isEditingDisabled, 39470 hasEditableOutline, 39471 className, 39472 defaultClassName, 39473 originalBlockClientId 39474 } = selectedProps; 39475 39476 // Users of the editor.BlockListBlock filter used to be able to 39477 // access the block prop. 39478 // Ideally these blocks would rely on the clientId prop only. 39479 // This is kept for backward compatibility reasons. 39480 const block = (0,external_wp_element_namespaceObject.useMemo)(() => ({ 39481 ...blockWithoutAttributes, 39482 attributes 39483 }), [blockWithoutAttributes, attributes]); 39484 39485 // Block is sometimes not mounted at the right time, causing it be 39486 // undefined see issue for more info 39487 // https://github.com/WordPress/gutenberg/issues/17013 39488 if (!selectedProps) { 39489 return null; 39490 } 39491 const privateContext = { 39492 isPreviewMode, 39493 clientId, 39494 className, 39495 index, 39496 mode, 39497 name, 39498 blockApiVersion, 39499 blockTitle, 39500 isSelected, 39501 isSubtreeDisabled, 39502 hasOverlay, 39503 initialPosition, 39504 blockEditingMode, 39505 isHighlighted, 39506 isMultiSelected, 39507 isPartiallySelected, 39508 isReusable, 39509 isDragging, 39510 hasChildSelected, 39511 isBlockMovingMode, 39512 canInsertMovingBlock, 39513 templateLock, 39514 isEditingDisabled, 39515 hasEditableOutline, 39516 isTemporarilyEditingAsBlocks, 39517 defaultClassName, 39518 mayDisplayControls, 39519 mayDisplayParentControls, 39520 originalBlockClientId, 39521 themeSupportsLayout 39522 }; 39523 39524 // Here we separate between the props passed to BlockListBlock and any other 39525 // information we selected for internal use. BlockListBlock is a filtered 39526 // component and thus ALL the props are PUBLIC API. 39527 39528 // Note that the context value doesn't have to be memoized in this case 39529 // because when it changes, this component will be re-rendered anyway, and 39530 // none of the consumers (BlockListBlock and useBlockProps) are memoized or 39531 // "pure". This is different from the public BlockEditContext, where 39532 // consumers might be memoized or "pure". 39533 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockContext.Provider, { 39534 value: privateContext, 39535 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListBlock, { 39536 ...props, 39537 mode, 39538 isSelectionEnabled, 39539 isLocked, 39540 canRemove, 39541 canMove, 39542 // Users of the editor.BlockListBlock filter used to be able 39543 // to access the block prop. Ideally these blocks would rely 39544 // on the clientId prop only. This is kept for backward 39545 // compatibility reasons. 39546 block, 39547 name, 39548 attributes, 39549 isValid, 39550 isSelected 39551 }) 39552 }); 39553 } 39554 /* harmony default export */ const block = ((0,external_wp_element_namespaceObject.memo)(BlockListBlockProvider)); 39555 39556 ;// external ["wp","htmlEntities"] 39557 const external_wp_htmlEntities_namespaceObject = window["wp"]["htmlEntities"]; 39558 ;// ./node_modules/@wordpress/block-editor/build-module/components/default-block-appender/index.js 39559 /** 39560 * External dependencies 39561 */ 39562 39563 39564 /** 39565 * WordPress dependencies 39566 */ 39567 39568 39569 39570 39571 39572 /** 39573 * Internal dependencies 39574 */ 39575 39576 39577 39578 /** 39579 * Zero width non-breaking space, used as padding for the paragraph when it is 39580 * empty. 39581 */ 39582 39583 39584 const ZWNBSP = '\ufeff'; 39585 function DefaultBlockAppender({ 39586 rootClientId 39587 }) { 39588 const { 39589 showPrompt, 39590 isLocked, 39591 placeholder, 39592 isManualGrid 39593 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 39594 const { 39595 getBlockCount, 39596 getSettings, 39597 getTemplateLock, 39598 getBlockAttributes 39599 } = select(store); 39600 const isEmpty = !getBlockCount(rootClientId); 39601 const { 39602 bodyPlaceholder 39603 } = getSettings(); 39604 return { 39605 showPrompt: isEmpty, 39606 isLocked: !!getTemplateLock(rootClientId), 39607 placeholder: bodyPlaceholder, 39608 isManualGrid: getBlockAttributes(rootClientId)?.layout?.isManualPlacement 39609 }; 39610 }, [rootClientId]); 39611 const { 39612 insertDefaultBlock, 39613 startTyping 39614 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 39615 if (isLocked || isManualGrid) { 39616 return null; 39617 } 39618 const value = (0,external_wp_htmlEntities_namespaceObject.decodeEntities)(placeholder) || (0,external_wp_i18n_namespaceObject.__)('Type / to choose a block'); 39619 const onAppend = () => { 39620 insertDefaultBlock(undefined, rootClientId); 39621 startTyping(); 39622 }; 39623 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 39624 "data-root-client-id": rootClientId || '', 39625 className: dist_clsx('block-editor-default-block-appender', { 39626 'has-visible-prompt': showPrompt 39627 }), 39628 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 39629 tabIndex: "0" 39630 // We want this element to be styled as a paragraph by themes. 39631 // eslint-disable-next-line jsx-a11y/no-noninteractive-element-to-interactive-role 39632 , 39633 role: "button", 39634 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Add default block') 39635 // A wrapping container for this one already has the wp-block className. 39636 , 39637 className: "block-editor-default-block-appender__content", 39638 onKeyDown: event => { 39639 if (external_wp_keycodes_namespaceObject.ENTER === event.keyCode || external_wp_keycodes_namespaceObject.SPACE === event.keyCode) { 39640 onAppend(); 39641 } 39642 }, 39643 onClick: () => onAppend(), 39644 onFocus: () => { 39645 if (showPrompt) { 39646 onAppend(); 39647 } 39648 }, 39649 children: showPrompt ? value : ZWNBSP 39650 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, { 39651 rootClientId: rootClientId, 39652 position: "bottom right", 39653 isAppender: true, 39654 __experimentalIsQuick: true 39655 })] 39656 }); 39657 } 39658 39659 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list-appender/index.js 39660 /** 39661 * External dependencies 39662 */ 39663 39664 39665 /** 39666 * WordPress dependencies 39667 */ 39668 39669 39670 39671 /** 39672 * Internal dependencies 39673 */ 39674 39675 39676 39677 39678 function DefaultAppender({ 39679 rootClientId 39680 }) { 39681 const canInsertDefaultBlock = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).canInsertBlockType((0,external_wp_blocks_namespaceObject.getDefaultBlockName)(), rootClientId)); 39682 if (canInsertDefaultBlock) { 39683 // Render the default block appender if the context supports use 39684 // of the default appender. 39685 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultBlockAppender, { 39686 rootClientId: rootClientId 39687 }); 39688 } 39689 39690 // Fallback in case the default block can't be inserted. 39691 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(button_block_appender, { 39692 rootClientId: rootClientId, 39693 className: "block-list-appender__toggle" 39694 }); 39695 } 39696 function BlockListAppender({ 39697 rootClientId, 39698 CustomAppender, 39699 className, 39700 tagName: TagName = 'div' 39701 }) { 39702 const isDragOver = (0,external_wp_data_namespaceObject.useSelect)(select => { 39703 const { 39704 getBlockInsertionPoint, 39705 isBlockInsertionPointVisible, 39706 getBlockCount 39707 } = select(store); 39708 const insertionPoint = getBlockInsertionPoint(); 39709 // Ideally we should also check for `isDragging` but currently it 39710 // requires a lot more setup. We can revisit this once we refactor 39711 // the DnD utility hooks. 39712 return isBlockInsertionPointVisible() && rootClientId === insertionPoint?.rootClientId && getBlockCount(rootClientId) === 0; 39713 }, [rootClientId]); 39714 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TagName 39715 // A `tabIndex` is used on the wrapping `div` element in order to 39716 // force a focus event to occur when an appender `button` element 39717 // is clicked. In some browsers (Firefox, Safari), button clicks do 39718 // not emit a focus event, which could cause this event to propagate 39719 // unexpectedly. The `tabIndex` ensures that the interaction is 39720 // captured as a focus, without also adding an extra tab stop. 39721 // 39722 // See: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus 39723 , { 39724 tabIndex: -1, 39725 className: dist_clsx('block-list-appender wp-block', className, { 39726 'is-drag-over': isDragOver 39727 }) 39728 // Needed in case the whole editor is content editable (for multi 39729 // selection). It fixes an edge case where ArrowDown and ArrowRight 39730 // should collapse the selection to the end of that selection and 39731 // not into the appender. 39732 , 39733 contentEditable: false 39734 // The appender exists to let you add the first Paragraph before 39735 // any is inserted. To that end, this appender should visually be 39736 // presented as a block. That means theme CSS should style it as if 39737 // it were an empty paragraph block. That means a `wp-block` class to 39738 // ensure the width is correct, and a [data-block] attribute to ensure 39739 // the correct margin is applied, especially for classic themes which 39740 // have commonly targeted that attribute for margins. 39741 , 39742 "data-block": true, 39743 children: CustomAppender ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CustomAppender, {}) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultAppender, { 39744 rootClientId: rootClientId 39745 }) 39746 }); 39747 } 39748 39749 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/inbetween.js 39750 /** 39751 * External dependencies 39752 */ 39753 39754 39755 /** 39756 * WordPress dependencies 39757 */ 39758 39759 39760 39761 39762 39763 /** 39764 * Internal dependencies 39765 */ 39766 39767 39768 39769 39770 const inbetween_MAX_POPOVER_RECOMPUTE_COUNTER = Number.MAX_SAFE_INTEGER; 39771 const InsertionPointOpenRef = (0,external_wp_element_namespaceObject.createContext)(); 39772 function BlockPopoverInbetween({ 39773 previousClientId, 39774 nextClientId, 39775 children, 39776 __unstablePopoverSlot, 39777 __unstableContentRef, 39778 operation = 'insert', 39779 nearestSide = 'right', 39780 ...props 39781 }) { 39782 // This is a temporary hack to get the inbetween inserter to recompute properly. 39783 const [popoverRecomputeCounter, forcePopoverRecompute] = (0,external_wp_element_namespaceObject.useReducer)( 39784 // Module is there to make sure that the counter doesn't overflow. 39785 s => (s + 1) % inbetween_MAX_POPOVER_RECOMPUTE_COUNTER, 0); 39786 const { 39787 orientation, 39788 rootClientId, 39789 isVisible 39790 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 39791 const { 39792 getBlockListSettings, 39793 getBlockRootClientId, 39794 isBlockVisible 39795 } = select(store); 39796 const _rootClientId = getBlockRootClientId(previousClientId !== null && previousClientId !== void 0 ? previousClientId : nextClientId); 39797 return { 39798 orientation: getBlockListSettings(_rootClientId)?.orientation || 'vertical', 39799 rootClientId: _rootClientId, 39800 isVisible: isBlockVisible(previousClientId) && isBlockVisible(nextClientId) 39801 }; 39802 }, [previousClientId, nextClientId]); 39803 const previousElement = useBlockElement(previousClientId); 39804 const nextElement = useBlockElement(nextClientId); 39805 const isVertical = orientation === 'vertical'; 39806 const popoverAnchor = (0,external_wp_element_namespaceObject.useMemo)(() => { 39807 if ( 39808 // popoverRecomputeCounter is by definition always equal or greater than 0. 39809 // This check is only there to satisfy the correctness of the 39810 // exhaustive-deps rule for the `useMemo` hook. 39811 popoverRecomputeCounter < 0 || !previousElement && !nextElement || !isVisible) { 39812 return undefined; 39813 } 39814 const contextElement = operation === 'group' ? nextElement || previousElement : previousElement || nextElement; 39815 return { 39816 contextElement, 39817 getBoundingClientRect() { 39818 const previousRect = previousElement ? previousElement.getBoundingClientRect() : null; 39819 const nextRect = nextElement ? nextElement.getBoundingClientRect() : null; 39820 let left = 0; 39821 let top = 0; 39822 let width = 0; 39823 let height = 0; 39824 if (operation === 'group') { 39825 const targetRect = nextRect || previousRect; 39826 top = targetRect.top; 39827 // No spacing is likely around blocks in this operation. 39828 // So width of the inserter containing rect is set to 0. 39829 width = 0; 39830 height = targetRect.bottom - targetRect.top; 39831 // Popover calculates its distance from mid-block so some 39832 // adjustments are needed to make it appear in the right place. 39833 left = nearestSide === 'left' ? targetRect.left - 2 : targetRect.right - 2; 39834 } else if (isVertical) { 39835 // vertical 39836 top = previousRect ? previousRect.bottom : nextRect.top; 39837 width = previousRect ? previousRect.width : nextRect.width; 39838 height = nextRect && previousRect ? nextRect.top - previousRect.bottom : 0; 39839 left = previousRect ? previousRect.left : nextRect.left; 39840 } else { 39841 top = previousRect ? previousRect.top : nextRect.top; 39842 height = previousRect ? previousRect.height : nextRect.height; 39843 if ((0,external_wp_i18n_namespaceObject.isRTL)()) { 39844 // non vertical, rtl 39845 left = nextRect ? nextRect.right : previousRect.left; 39846 width = previousRect && nextRect ? previousRect.left - nextRect.right : 0; 39847 } else { 39848 // non vertical, ltr 39849 left = previousRect ? previousRect.right : nextRect.left; 39850 width = previousRect && nextRect ? nextRect.left - previousRect.right : 0; 39851 } 39852 } 39853 return new window.DOMRect(left, top, width, height); 39854 } 39855 }; 39856 }, [previousElement, nextElement, popoverRecomputeCounter, isVertical, isVisible, operation, nearestSide]); 39857 const popoverScrollRef = use_popover_scroll(__unstableContentRef); 39858 39859 // This is only needed for a smooth transition when moving blocks. 39860 // When blocks are moved up/down, their position can be set by 39861 // updating the `transform` property manually (i.e. without using CSS 39862 // transitions or animations). The animation, which can also scroll the block 39863 // editor, can sometimes cause the position of the Popover to get out of sync. 39864 // A MutationObserver is therefore used to make sure that changes to the 39865 // selectedElement's attribute (i.e. `transform`) can be tracked and used to 39866 // trigger the Popover to rerender. 39867 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 39868 if (!previousElement) { 39869 return; 39870 } 39871 const observer = new window.MutationObserver(forcePopoverRecompute); 39872 observer.observe(previousElement, { 39873 attributes: true 39874 }); 39875 return () => { 39876 observer.disconnect(); 39877 }; 39878 }, [previousElement]); 39879 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 39880 if (!nextElement) { 39881 return; 39882 } 39883 const observer = new window.MutationObserver(forcePopoverRecompute); 39884 observer.observe(nextElement, { 39885 attributes: true 39886 }); 39887 return () => { 39888 observer.disconnect(); 39889 }; 39890 }, [nextElement]); 39891 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 39892 if (!previousElement) { 39893 return; 39894 } 39895 previousElement.ownerDocument.defaultView.addEventListener('resize', forcePopoverRecompute); 39896 return () => { 39897 previousElement.ownerDocument.defaultView?.removeEventListener('resize', forcePopoverRecompute); 39898 }; 39899 }, [previousElement]); 39900 39901 // If there's either a previous or a next element, show the inbetween popover. 39902 // Note that drag and drop uses the inbetween popover to show the drop indicator 39903 // before the first block and after the last block. 39904 if (!previousElement && !nextElement || !isVisible) { 39905 return null; 39906 } 39907 39908 /* eslint-disable jsx-a11y/no-static-element-interactions, jsx-a11y/click-events-have-key-events */ 39909 // While ideally it would be enough to capture the 39910 // bubbling focus event from the Inserter, due to the 39911 // characteristics of click focusing of `button`s in 39912 // Firefox and Safari, it is not reliable. 39913 // 39914 // See: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus 39915 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, { 39916 ref: popoverScrollRef, 39917 animate: false, 39918 anchor: popoverAnchor, 39919 focusOnMount: false 39920 // Render in the old slot if needed for backward compatibility, 39921 // otherwise render in place (not in the default popover slot). 39922 , 39923 __unstableSlotName: __unstablePopoverSlot, 39924 inline: !__unstablePopoverSlot 39925 // Forces a remount of the popover when its position changes 39926 // This makes sure the popover doesn't animate from its previous position. 39927 , 39928 ...props, 39929 className: dist_clsx('block-editor-block-popover', 'block-editor-block-popover__inbetween', props.className), 39930 resize: false, 39931 flip: false, 39932 placement: "overlay", 39933 variant: "unstyled", 39934 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 39935 className: "block-editor-block-popover__inbetween-container", 39936 children: children 39937 }) 39938 }, nextClientId + '--' + rootClientId); 39939 /* eslint-enable jsx-a11y/no-static-element-interactions, jsx-a11y/click-events-have-key-events */ 39940 } 39941 /* harmony default export */ const inbetween = (BlockPopoverInbetween); 39942 39943 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/drop-zone.js 39944 /** 39945 * WordPress dependencies 39946 */ 39947 39948 39949 39950 39951 /** 39952 * Internal dependencies 39953 */ 39954 39955 39956 39957 const animateVariants = { 39958 hide: { 39959 opacity: 0, 39960 scaleY: 0.75 39961 }, 39962 show: { 39963 opacity: 1, 39964 scaleY: 1 39965 }, 39966 exit: { 39967 opacity: 0, 39968 scaleY: 0.9 39969 } 39970 }; 39971 function BlockDropZonePopover({ 39972 __unstablePopoverSlot, 39973 __unstableContentRef 39974 }) { 39975 const { 39976 clientId 39977 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 39978 const { 39979 getBlockOrder, 39980 getBlockInsertionPoint 39981 } = select(store); 39982 const insertionPoint = getBlockInsertionPoint(); 39983 const order = getBlockOrder(insertionPoint.rootClientId); 39984 if (!order.length) { 39985 return {}; 39986 } 39987 return { 39988 clientId: order[insertionPoint.index] 39989 }; 39990 }, []); 39991 const reducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)(); 39992 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, { 39993 clientId: clientId, 39994 __unstablePopoverSlot: __unstablePopoverSlot, 39995 __unstableContentRef: __unstableContentRef, 39996 className: "block-editor-block-popover__drop-zone", 39997 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, { 39998 "data-testid": "block-popover-drop-zone", 39999 initial: reducedMotion ? animateVariants.show : animateVariants.hide, 40000 animate: animateVariants.show, 40001 exit: reducedMotion ? animateVariants.show : animateVariants.exit, 40002 className: "block-editor-block-popover__drop-zone-foreground" 40003 }) 40004 }); 40005 } 40006 /* harmony default export */ const drop_zone = (BlockDropZonePopover); 40007 40008 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/insertion-point.js 40009 /** 40010 * External dependencies 40011 */ 40012 40013 40014 /** 40015 * WordPress dependencies 40016 */ 40017 40018 40019 40020 40021 40022 /** 40023 * Internal dependencies 40024 */ 40025 40026 40027 40028 40029 40030 40031 const insertion_point_InsertionPointOpenRef = (0,external_wp_element_namespaceObject.createContext)(); 40032 function InbetweenInsertionPointPopover({ 40033 __unstablePopoverSlot, 40034 __unstableContentRef, 40035 operation = 'insert', 40036 nearestSide = 'right' 40037 }) { 40038 const { 40039 selectBlock, 40040 hideInsertionPoint 40041 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 40042 const openRef = (0,external_wp_element_namespaceObject.useContext)(insertion_point_InsertionPointOpenRef); 40043 const ref = (0,external_wp_element_namespaceObject.useRef)(); 40044 const { 40045 orientation, 40046 previousClientId, 40047 nextClientId, 40048 rootClientId, 40049 isInserterShown, 40050 isDistractionFree, 40051 isNavigationMode, 40052 isZoomOutMode 40053 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 40054 const { 40055 getBlockOrder, 40056 getBlockListSettings, 40057 getBlockInsertionPoint, 40058 isBlockBeingDragged, 40059 getPreviousBlockClientId, 40060 getNextBlockClientId, 40061 getSettings, 40062 isNavigationMode: _isNavigationMode, 40063 __unstableGetEditorMode 40064 } = select(store); 40065 const insertionPoint = getBlockInsertionPoint(); 40066 const order = getBlockOrder(insertionPoint.rootClientId); 40067 if (!order.length) { 40068 return {}; 40069 } 40070 let _previousClientId = order[insertionPoint.index - 1]; 40071 let _nextClientId = order[insertionPoint.index]; 40072 while (isBlockBeingDragged(_previousClientId)) { 40073 _previousClientId = getPreviousBlockClientId(_previousClientId); 40074 } 40075 while (isBlockBeingDragged(_nextClientId)) { 40076 _nextClientId = getNextBlockClientId(_nextClientId); 40077 } 40078 const settings = getSettings(); 40079 return { 40080 previousClientId: _previousClientId, 40081 nextClientId: _nextClientId, 40082 orientation: getBlockListSettings(insertionPoint.rootClientId)?.orientation || 'vertical', 40083 rootClientId: insertionPoint.rootClientId, 40084 isNavigationMode: _isNavigationMode(), 40085 isDistractionFree: settings.isDistractionFree, 40086 isInserterShown: insertionPoint?.__unstableWithInserter, 40087 isZoomOutMode: __unstableGetEditorMode() === 'zoom-out' 40088 }; 40089 }, []); 40090 const { 40091 getBlockEditingMode 40092 } = (0,external_wp_data_namespaceObject.useSelect)(store); 40093 const disableMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)(); 40094 function onClick(event) { 40095 if (event.target === ref.current && nextClientId && getBlockEditingMode(nextClientId) !== 'disabled') { 40096 selectBlock(nextClientId, -1); 40097 } 40098 } 40099 function maybeHideInserterPoint(event) { 40100 // Only hide the inserter if it's triggered on the wrapper, 40101 // and the inserter is not open. 40102 if (event.target === ref.current && !openRef.current) { 40103 hideInsertionPoint(); 40104 } 40105 } 40106 function onFocus(event) { 40107 // Only handle click on the wrapper specifically, and not an event 40108 // bubbled from the inserter itself. 40109 if (event.target !== ref.current) { 40110 openRef.current = true; 40111 } 40112 } 40113 const lineVariants = { 40114 // Initial position starts from the center and invisible. 40115 start: { 40116 opacity: 0, 40117 scale: 0 40118 }, 40119 // The line expands to fill the container. If the inserter is visible it 40120 // is delayed so it appears orchestrated. 40121 rest: { 40122 opacity: 1, 40123 scale: 1, 40124 transition: { 40125 delay: isInserterShown ? 0.5 : 0, 40126 type: 'tween' 40127 } 40128 }, 40129 hover: { 40130 opacity: 1, 40131 scale: 1, 40132 transition: { 40133 delay: 0.5, 40134 type: 'tween' 40135 } 40136 } 40137 }; 40138 const inserterVariants = { 40139 start: { 40140 scale: disableMotion ? 1 : 0 40141 }, 40142 rest: { 40143 scale: 1, 40144 transition: { 40145 delay: 0.4, 40146 type: 'tween' 40147 } 40148 } 40149 }; 40150 if (isDistractionFree && !isNavigationMode) { 40151 return null; 40152 } 40153 40154 // Zoom out mode should only show the insertion point for the insert operation. 40155 // Other operations such as "group" are when the editor tries to create a row 40156 // block by grouping the block being dragged with the block it's being dropped 40157 // onto. 40158 if (isZoomOutMode && operation !== 'insert') { 40159 return null; 40160 } 40161 const orientationClassname = orientation === 'horizontal' || operation === 'group' ? 'is-horizontal' : 'is-vertical'; 40162 const className = dist_clsx('block-editor-block-list__insertion-point', orientationClassname); 40163 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inbetween, { 40164 previousClientId: previousClientId, 40165 nextClientId: nextClientId, 40166 __unstablePopoverSlot: __unstablePopoverSlot, 40167 __unstableContentRef: __unstableContentRef, 40168 operation: operation, 40169 nearestSide: nearestSide, 40170 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__unstableMotion.div, { 40171 layout: !disableMotion, 40172 initial: disableMotion ? 'rest' : 'start', 40173 animate: "rest", 40174 whileHover: "hover", 40175 whileTap: "pressed", 40176 exit: "start", 40177 ref: ref, 40178 tabIndex: -1, 40179 onClick: onClick, 40180 onFocus: onFocus, 40181 className: dist_clsx(className, { 40182 'is-with-inserter': isInserterShown 40183 }), 40184 onHoverEnd: maybeHideInserterPoint, 40185 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, { 40186 variants: lineVariants, 40187 className: "block-editor-block-list__insertion-point-indicator", 40188 "data-testid": "block-list-insertion-point-indicator" 40189 }), isInserterShown && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, { 40190 variants: inserterVariants, 40191 className: dist_clsx('block-editor-block-list__insertion-point-inserter'), 40192 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, { 40193 position: "bottom center", 40194 clientId: nextClientId, 40195 rootClientId: rootClientId, 40196 __experimentalIsQuick: true, 40197 onToggle: isOpen => { 40198 openRef.current = isOpen; 40199 }, 40200 onSelectOrClose: () => { 40201 openRef.current = false; 40202 } 40203 }) 40204 })] 40205 }) 40206 }); 40207 } 40208 function InsertionPoint(props) { 40209 const { 40210 insertionPoint, 40211 isVisible, 40212 isBlockListEmpty 40213 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 40214 const { 40215 getBlockInsertionPoint, 40216 isBlockInsertionPointVisible, 40217 getBlockCount 40218 } = select(store); 40219 const blockInsertionPoint = getBlockInsertionPoint(); 40220 return { 40221 insertionPoint: blockInsertionPoint, 40222 isVisible: isBlockInsertionPointVisible(), 40223 isBlockListEmpty: getBlockCount(blockInsertionPoint?.rootClientId) === 0 40224 }; 40225 }, []); 40226 if (!isVisible || 40227 // Don't render the insertion point if the block list is empty. 40228 // The insertion point will be represented by the appender instead. 40229 isBlockListEmpty) { 40230 return null; 40231 } 40232 40233 /** 40234 * Render a popover that overlays the block when the desired operation is to replace it. 40235 * Otherwise, render a popover in between blocks for the indication of inserting between them. 40236 */ 40237 return insertionPoint.operation === 'replace' ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(drop_zone 40238 // Force remount to trigger the animation. 40239 , { 40240 ...props 40241 }, `$insertionPoint.rootClientId}-$insertionPoint.index}`) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InbetweenInsertionPointPopover, { 40242 operation: insertionPoint.operation, 40243 nearestSide: insertionPoint.nearestSide, 40244 ...props 40245 }); 40246 } 40247 40248 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-in-between-inserter.js 40249 /** 40250 * WordPress dependencies 40251 */ 40252 40253 40254 40255 40256 40257 /** 40258 * Internal dependencies 40259 */ 40260 40261 40262 function useInBetweenInserter() { 40263 const openRef = (0,external_wp_element_namespaceObject.useContext)(insertion_point_InsertionPointOpenRef); 40264 const isInBetweenInserterDisabled = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSettings().isDistractionFree || select(store).__unstableGetEditorMode() === 'zoom-out', []); 40265 const { 40266 getBlockListSettings, 40267 getBlockIndex, 40268 isMultiSelecting, 40269 getSelectedBlockClientIds, 40270 getSettings, 40271 getTemplateLock, 40272 __unstableIsWithinBlockOverlay, 40273 getBlockEditingMode, 40274 getBlockName, 40275 getBlockAttributes 40276 } = (0,external_wp_data_namespaceObject.useSelect)(store); 40277 const { 40278 showInsertionPoint, 40279 hideInsertionPoint 40280 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 40281 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 40282 if (isInBetweenInserterDisabled) { 40283 return; 40284 } 40285 function onMouseMove(event) { 40286 // openRef is the reference to the insertion point between blocks. 40287 // If the reference is not set or the insertion point is already open, return. 40288 if (openRef === undefined || openRef.current) { 40289 return; 40290 } 40291 40292 // Ignore text nodes sometimes detected in FireFox. 40293 if (event.target.nodeType === event.target.TEXT_NODE) { 40294 return; 40295 } 40296 if (isMultiSelecting()) { 40297 return; 40298 } 40299 if (!event.target.classList.contains('block-editor-block-list__layout')) { 40300 hideInsertionPoint(); 40301 return; 40302 } 40303 let rootClientId; 40304 if (!event.target.classList.contains('is-root-container')) { 40305 const blockElement = !!event.target.getAttribute('data-block') ? event.target : event.target.closest('[data-block]'); 40306 rootClientId = blockElement.getAttribute('data-block'); 40307 } 40308 if (getTemplateLock(rootClientId) || getBlockEditingMode(rootClientId) === 'disabled' || getBlockName(rootClientId) === 'core/block' || rootClientId && getBlockAttributes(rootClientId).layout?.isManualPlacement) { 40309 return; 40310 } 40311 const blockListSettings = getBlockListSettings(rootClientId); 40312 const orientation = blockListSettings?.orientation || 'vertical'; 40313 const captureToolbars = !!blockListSettings?.__experimentalCaptureToolbars; 40314 const offsetTop = event.clientY; 40315 const offsetLeft = event.clientX; 40316 const children = Array.from(event.target.children); 40317 let element = children.find(blockEl => { 40318 const blockElRect = blockEl.getBoundingClientRect(); 40319 return blockEl.classList.contains('wp-block') && orientation === 'vertical' && blockElRect.top > offsetTop || blockEl.classList.contains('wp-block') && orientation === 'horizontal' && ((0,external_wp_i18n_namespaceObject.isRTL)() ? blockElRect.right < offsetLeft : blockElRect.left > offsetLeft); 40320 }); 40321 if (!element) { 40322 hideInsertionPoint(); 40323 return; 40324 } 40325 40326 // The block may be in an alignment wrapper, so check the first direct 40327 // child if the element has no ID. 40328 if (!element.id) { 40329 element = element.firstElementChild; 40330 if (!element) { 40331 hideInsertionPoint(); 40332 return; 40333 } 40334 } 40335 40336 // Don't show the insertion point if a parent block has an "overlay" 40337 // See https://github.com/WordPress/gutenberg/pull/34012#pullrequestreview-727762337 40338 const clientId = element.id.slice('block-'.length); 40339 if (!clientId || __unstableIsWithinBlockOverlay(clientId)) { 40340 return; 40341 } 40342 40343 // Don't show the inserter if the following conditions are met, 40344 // as it conflicts with the block toolbar: 40345 // 1. when hovering above or inside selected block(s) 40346 // 2. when the orientation is vertical 40347 // 3. when the __experimentalCaptureToolbars is not enabled 40348 // 4. when the Top Toolbar is not disabled 40349 if (getSelectedBlockClientIds().includes(clientId) && orientation === 'vertical' && !captureToolbars && !getSettings().hasFixedToolbar) { 40350 return; 40351 } 40352 const elementRect = element.getBoundingClientRect(); 40353 if (orientation === 'horizontal' && (event.clientY > elementRect.bottom || event.clientY < elementRect.top) || orientation === 'vertical' && (event.clientX > elementRect.right || event.clientX < elementRect.left)) { 40354 hideInsertionPoint(); 40355 return; 40356 } 40357 const index = getBlockIndex(clientId); 40358 40359 // Don't show the in-between inserter before the first block in 40360 // the list (preserves the original behaviour). 40361 if (index === 0) { 40362 hideInsertionPoint(); 40363 return; 40364 } 40365 showInsertionPoint(rootClientId, index, { 40366 __unstableWithInserter: true 40367 }); 40368 } 40369 node.addEventListener('mousemove', onMouseMove); 40370 return () => { 40371 node.removeEventListener('mousemove', onMouseMove); 40372 }; 40373 }, [openRef, getBlockListSettings, getBlockIndex, isMultiSelecting, showInsertionPoint, hideInsertionPoint, getSelectedBlockClientIds, isInBetweenInserterDisabled]); 40374 } 40375 40376 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-selection-clearer/index.js 40377 /** 40378 * WordPress dependencies 40379 */ 40380 40381 40382 40383 /** 40384 * Internal dependencies 40385 */ 40386 40387 40388 /** 40389 * Pass the returned ref callback to an element that should clear block 40390 * selection. Selection will only be cleared if the element is clicked directly, 40391 * not if a child element is clicked. 40392 * 40393 * @return {import('react').RefCallback} Ref callback. 40394 */ 40395 40396 function useBlockSelectionClearer() { 40397 const { 40398 getSettings, 40399 hasSelectedBlock, 40400 hasMultiSelection 40401 } = (0,external_wp_data_namespaceObject.useSelect)(store); 40402 const { 40403 clearSelectedBlock 40404 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 40405 const { 40406 clearBlockSelection: isEnabled 40407 } = getSettings(); 40408 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 40409 if (!isEnabled) { 40410 return; 40411 } 40412 function onMouseDown(event) { 40413 if (!hasSelectedBlock() && !hasMultiSelection()) { 40414 return; 40415 } 40416 40417 // Only handle clicks on the element, not the children. 40418 if (event.target !== node) { 40419 return; 40420 } 40421 clearSelectedBlock(); 40422 } 40423 node.addEventListener('mousedown', onMouseDown); 40424 return () => { 40425 node.removeEventListener('mousedown', onMouseDown); 40426 }; 40427 }, [hasSelectedBlock, hasMultiSelection, clearSelectedBlock, isEnabled]); 40428 } 40429 function BlockSelectionClearer(props) { 40430 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 40431 ref: useBlockSelectionClearer(), 40432 ...props 40433 }); 40434 } 40435 40436 ;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/button-block-appender.js 40437 /** 40438 * External dependencies 40439 */ 40440 40441 40442 /** 40443 * Internal dependencies 40444 */ 40445 40446 40447 40448 function ButtonBlockAppender({ 40449 showSeparator, 40450 isFloating, 40451 onAddBlock, 40452 isToggle 40453 }) { 40454 const { 40455 clientId 40456 } = useBlockEditContext(); 40457 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(button_block_appender, { 40458 className: dist_clsx({ 40459 'block-list-appender__toggle': isToggle 40460 }), 40461 rootClientId: clientId, 40462 showSeparator: showSeparator, 40463 isFloating: isFloating, 40464 onAddBlock: onAddBlock 40465 }); 40466 } 40467 40468 ;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/default-block-appender.js 40469 /** 40470 * Internal dependencies 40471 */ 40472 40473 40474 40475 function default_block_appender_DefaultBlockAppender() { 40476 const { 40477 clientId 40478 } = useBlockEditContext(); 40479 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultBlockAppender, { 40480 rootClientId: clientId 40481 }); 40482 } 40483 40484 ;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/use-nested-settings-update.js 40485 /** 40486 * WordPress dependencies 40487 */ 40488 40489 40490 40491 40492 40493 /** 40494 * Internal dependencies 40495 */ 40496 40497 40498 40499 /** @typedef {import('../../selectors').WPDirectInsertBlock } WPDirectInsertBlock */ 40500 40501 const pendingSettingsUpdates = new WeakMap(); 40502 function useShallowMemo(value) { 40503 const [prevValue, setPrevValue] = (0,external_wp_element_namespaceObject.useState)(value); 40504 if (!external_wp_isShallowEqual_default()(prevValue, value)) { 40505 setPrevValue(value); 40506 } 40507 return prevValue; 40508 } 40509 40510 /** 40511 * This hook is a side effect which updates the block-editor store when changes 40512 * happen to inner block settings. The given props are transformed into a 40513 * settings object, and if that is different from the current settings object in 40514 * the block-editor store, then the store is updated with the new settings which 40515 * came from props. 40516 * 40517 * @param {string} clientId The client ID of the block to update. 40518 * @param {string} parentLock 40519 * @param {string[]} allowedBlocks An array of block names which are permitted 40520 * in inner blocks. 40521 * @param {string[]} prioritizedInserterBlocks Block names and/or block variations to be prioritized in the inserter, in the format {blockName}/{variationName}. 40522 * @param {?WPDirectInsertBlock} defaultBlock The default block to insert: [ blockName, { blockAttributes } ]. 40523 * @param {?boolean} directInsert If a default block should be inserted directly by the appender. 40524 * 40525 * @param {?WPDirectInsertBlock} __experimentalDefaultBlock A deprecated prop for the default block to insert: [ blockName, { blockAttributes } ]. Use `defaultBlock` instead. 40526 * 40527 * @param {?boolean} __experimentalDirectInsert A deprecated prop for whether a default block should be inserted directly by the appender. Use `directInsert` instead. 40528 * 40529 * @param {string} [templateLock] The template lock specified for the inner 40530 * blocks component. (e.g. "all") 40531 * @param {boolean} captureToolbars Whether or children toolbars should be shown 40532 * in the inner blocks component rather than on 40533 * the child block. 40534 * @param {string} orientation The direction in which the block 40535 * should face. 40536 * @param {Object} layout The layout object for the block container. 40537 */ 40538 function useNestedSettingsUpdate(clientId, parentLock, allowedBlocks, prioritizedInserterBlocks, defaultBlock, directInsert, __experimentalDefaultBlock, __experimentalDirectInsert, templateLock, captureToolbars, orientation, layout) { 40539 // Instead of adding a useSelect mapping here, please add to the useSelect 40540 // mapping in InnerBlocks! Every subscription impacts performance. 40541 40542 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 40543 40544 // Implementors often pass a new array on every render, 40545 // and the contents of the arrays are just strings, so the entire array 40546 // can be passed as dependencies but We need to include the length of the array, 40547 // otherwise if the arrays change length but the first elements are equal the comparison, 40548 // does not works as expected. 40549 const _allowedBlocks = useShallowMemo(allowedBlocks); 40550 const _prioritizedInserterBlocks = (0,external_wp_element_namespaceObject.useMemo)(() => prioritizedInserterBlocks, 40551 // eslint-disable-next-line react-hooks/exhaustive-deps 40552 prioritizedInserterBlocks); 40553 const _templateLock = templateLock === undefined || parentLock === 'contentOnly' ? parentLock : templateLock; 40554 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 40555 const newSettings = { 40556 allowedBlocks: _allowedBlocks, 40557 prioritizedInserterBlocks: _prioritizedInserterBlocks, 40558 templateLock: _templateLock 40559 }; 40560 40561 // These values are not defined for RN, so only include them if they 40562 // are defined. 40563 if (captureToolbars !== undefined) { 40564 newSettings.__experimentalCaptureToolbars = captureToolbars; 40565 } 40566 40567 // Orientation depends on layout, 40568 // ideally the separate orientation prop should be deprecated. 40569 if (orientation !== undefined) { 40570 newSettings.orientation = orientation; 40571 } else { 40572 const layoutType = getLayoutType(layout?.type); 40573 newSettings.orientation = layoutType.getOrientation(layout); 40574 } 40575 if (__experimentalDefaultBlock !== undefined) { 40576 external_wp_deprecated_default()('__experimentalDefaultBlock', { 40577 alternative: 'defaultBlock', 40578 since: '6.3', 40579 version: '6.4' 40580 }); 40581 newSettings.defaultBlock = __experimentalDefaultBlock; 40582 } 40583 if (defaultBlock !== undefined) { 40584 newSettings.defaultBlock = defaultBlock; 40585 } 40586 if (__experimentalDirectInsert !== undefined) { 40587 external_wp_deprecated_default()('__experimentalDirectInsert', { 40588 alternative: 'directInsert', 40589 since: '6.3', 40590 version: '6.4' 40591 }); 40592 newSettings.directInsert = __experimentalDirectInsert; 40593 } 40594 if (directInsert !== undefined) { 40595 newSettings.directInsert = directInsert; 40596 } 40597 if (newSettings.directInsert !== undefined && typeof newSettings.directInsert !== 'boolean') { 40598 external_wp_deprecated_default()('Using `Function` as a `directInsert` argument', { 40599 alternative: '`boolean` values', 40600 since: '6.5' 40601 }); 40602 } 40603 40604 // Batch updates to block list settings to avoid triggering cascading renders 40605 // for each container block included in a tree and optimize initial render. 40606 // To avoid triggering updateBlockListSettings for each container block 40607 // causing X re-renderings for X container blocks, 40608 // we batch all the updatedBlockListSettings in a single "data" batch 40609 // which results in a single re-render. 40610 if (!pendingSettingsUpdates.get(registry)) { 40611 pendingSettingsUpdates.set(registry, {}); 40612 } 40613 pendingSettingsUpdates.get(registry)[clientId] = newSettings; 40614 window.queueMicrotask(() => { 40615 const settings = pendingSettingsUpdates.get(registry); 40616 if (Object.keys(settings).length) { 40617 const { 40618 updateBlockListSettings 40619 } = registry.dispatch(store); 40620 updateBlockListSettings(settings); 40621 pendingSettingsUpdates.set(registry, {}); 40622 } 40623 }); 40624 }, [clientId, _allowedBlocks, _prioritizedInserterBlocks, _templateLock, defaultBlock, directInsert, __experimentalDefaultBlock, __experimentalDirectInsert, captureToolbars, orientation, layout, registry]); 40625 } 40626 40627 ;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/use-inner-block-template-sync.js 40628 /** 40629 * External dependencies 40630 */ 40631 40632 40633 /** 40634 * WordPress dependencies 40635 */ 40636 40637 40638 40639 40640 /** 40641 * Internal dependencies 40642 */ 40643 40644 40645 /** 40646 * This hook makes sure that a block's inner blocks stay in sync with the given 40647 * block "template". The template is a block hierarchy to which inner blocks must 40648 * conform. If the blocks get "out of sync" with the template and the template 40649 * is meant to be locked (e.g. templateLock = "all" or templateLock = "contentOnly"), 40650 * then we replace the inner blocks with the correct value after synchronizing it with the template. 40651 * 40652 * @param {string} clientId The block client ID. 40653 * @param {Object} template The template to match. 40654 * @param {string} templateLock The template lock state for the inner blocks. For 40655 * example, if the template lock is set to "all", 40656 * then the inner blocks will stay in sync with the 40657 * template. If not defined or set to false, then 40658 * the inner blocks will not be synchronized with 40659 * the given template. 40660 * @param {boolean} templateInsertUpdatesSelection Whether or not to update the 40661 * block-editor selection state when inner blocks 40662 * are replaced after template synchronization. 40663 */ 40664 function useInnerBlockTemplateSync(clientId, template, templateLock, templateInsertUpdatesSelection) { 40665 // Instead of adding a useSelect mapping here, please add to the useSelect 40666 // mapping in InnerBlocks! Every subscription impacts performance. 40667 40668 const { 40669 getBlocks, 40670 getSelectedBlocksInitialCaretPosition, 40671 isBlockSelected 40672 } = (0,external_wp_data_namespaceObject.useSelect)(store); 40673 const { 40674 replaceInnerBlocks, 40675 __unstableMarkNextChangeAsNotPersistent 40676 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 40677 40678 // Maintain a reference to the previous value so we can do a deep equality check. 40679 const existingTemplateRef = (0,external_wp_element_namespaceObject.useRef)(null); 40680 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 40681 let isCancelled = false; 40682 40683 // There's an implicit dependency between useInnerBlockTemplateSync and useNestedSettingsUpdate 40684 // The former needs to happen after the latter and since the latter is using microtasks to batch updates (performance optimization), 40685 // we need to schedule this one in a microtask as well. 40686 // Example: If you remove queueMicrotask here, ctrl + click to insert quote block won't close the inserter. 40687 window.queueMicrotask(() => { 40688 if (isCancelled) { 40689 return; 40690 } 40691 40692 // Only synchronize innerBlocks with template if innerBlocks are empty 40693 // or a locking "all" or "contentOnly" exists directly on the block. 40694 const currentInnerBlocks = getBlocks(clientId); 40695 const shouldApplyTemplate = currentInnerBlocks.length === 0 || templateLock === 'all' || templateLock === 'contentOnly'; 40696 const hasTemplateChanged = !es6_default()(template, existingTemplateRef.current); 40697 if (!shouldApplyTemplate || !hasTemplateChanged) { 40698 return; 40699 } 40700 existingTemplateRef.current = template; 40701 const nextBlocks = (0,external_wp_blocks_namespaceObject.synchronizeBlocksWithTemplate)(currentInnerBlocks, template); 40702 if (!es6_default()(nextBlocks, currentInnerBlocks)) { 40703 __unstableMarkNextChangeAsNotPersistent(); 40704 replaceInnerBlocks(clientId, nextBlocks, currentInnerBlocks.length === 0 && templateInsertUpdatesSelection && nextBlocks.length !== 0 && isBlockSelected(clientId), 40705 // This ensures the "initialPosition" doesn't change when applying the template 40706 // If we're supposed to focus the block, we'll focus the first inner block 40707 // otherwise, we won't apply any auto-focus. 40708 // This ensures for instance that the focus stays in the inserter when inserting the "buttons" block. 40709 getSelectedBlocksInitialCaretPosition()); 40710 } 40711 }); 40712 return () => { 40713 isCancelled = true; 40714 }; 40715 }, [template, templateLock, clientId]); 40716 } 40717 40718 ;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/use-block-context.js 40719 /** 40720 * WordPress dependencies 40721 */ 40722 40723 40724 40725 /** 40726 * Internal dependencies 40727 */ 40728 40729 40730 /** 40731 * Returns a context object for a given block. 40732 * 40733 * @param {string} clientId The block client ID. 40734 * 40735 * @return {Record<string,*>} Context value. 40736 */ 40737 function useBlockContext(clientId) { 40738 return (0,external_wp_data_namespaceObject.useSelect)(select => { 40739 const block = select(store).getBlock(clientId); 40740 if (!block) { 40741 return undefined; 40742 } 40743 const blockType = select(external_wp_blocks_namespaceObject.store).getBlockType(block.name); 40744 if (!blockType) { 40745 return undefined; 40746 } 40747 if (Object.keys(blockType.providesContext).length === 0) { 40748 return undefined; 40749 } 40750 return Object.fromEntries(Object.entries(blockType.providesContext).map(([contextName, attributeName]) => [contextName, block.attributes[attributeName]])); 40751 }, [clientId]); 40752 } 40753 40754 ;// ./node_modules/@wordpress/block-editor/build-module/components/use-on-block-drop/index.js 40755 /** 40756 * WordPress dependencies 40757 */ 40758 40759 40760 40761 40762 40763 /** 40764 * Internal dependencies 40765 */ 40766 40767 40768 /** @typedef {import('react').SyntheticEvent} SyntheticEvent */ 40769 /** @typedef {import('./types').WPDropOperation} WPDropOperation */ 40770 40771 /** 40772 * Retrieve the data for a block drop event. 40773 * 40774 * @param {SyntheticEvent} event The drop event. 40775 * 40776 * @return {Object} An object with block drag and drop data. 40777 */ 40778 function parseDropEvent(event) { 40779 let result = { 40780 srcRootClientId: null, 40781 srcClientIds: null, 40782 srcIndex: null, 40783 type: null, 40784 blocks: null 40785 }; 40786 if (!event.dataTransfer) { 40787 return result; 40788 } 40789 try { 40790 result = Object.assign(result, JSON.parse(event.dataTransfer.getData('wp-blocks'))); 40791 } catch (err) { 40792 return result; 40793 } 40794 return result; 40795 } 40796 40797 /** 40798 * A function that returns an event handler function for block drop events. 40799 * 40800 * @param {string} targetRootClientId The root client id where the block(s) will be inserted. 40801 * @param {number} targetBlockIndex The index where the block(s) will be inserted. 40802 * @param {Function} getBlockIndex A function that gets the index of a block. 40803 * @param {Function} getClientIdsOfDescendants A function that gets the client ids of descendant blocks. 40804 * @param {Function} moveBlocks A function that moves blocks. 40805 * @param {Function} insertOrReplaceBlocks A function that inserts or replaces blocks. 40806 * @param {Function} clearSelectedBlock A function that clears block selection. 40807 * @param {string} operation The type of operation to perform on drop. Could be `insert` or `replace` or `group`. 40808 * @param {Function} getBlock A function that returns a block given its client id. 40809 * @return {Function} The event handler for a block drop event. 40810 */ 40811 function onBlockDrop(targetRootClientId, targetBlockIndex, getBlockIndex, getClientIdsOfDescendants, moveBlocks, insertOrReplaceBlocks, clearSelectedBlock, operation, getBlock) { 40812 return event => { 40813 const { 40814 srcRootClientId: sourceRootClientId, 40815 srcClientIds: sourceClientIds, 40816 type: dropType, 40817 blocks 40818 } = parseDropEvent(event); 40819 40820 // If the user is inserting a block. 40821 if (dropType === 'inserter') { 40822 clearSelectedBlock(); 40823 const blocksToInsert = blocks.map(block => (0,external_wp_blocks_namespaceObject.cloneBlock)(block)); 40824 insertOrReplaceBlocks(blocksToInsert, true, null); 40825 } 40826 40827 // If the user is moving a block. 40828 if (dropType === 'block') { 40829 const sourceBlockIndex = getBlockIndex(sourceClientIds[0]); 40830 40831 // If the user is dropping to the same position, return early. 40832 if (sourceRootClientId === targetRootClientId && sourceBlockIndex === targetBlockIndex) { 40833 return; 40834 } 40835 40836 // If the user is attempting to drop a block within its own 40837 // nested blocks, return early as this would create infinite 40838 // recursion. 40839 if (sourceClientIds.includes(targetRootClientId) || getClientIdsOfDescendants(sourceClientIds).some(id => id === targetRootClientId)) { 40840 return; 40841 } 40842 40843 // If the user is dropping a block over another block, replace both blocks 40844 // with a group block containing them 40845 if (operation === 'group') { 40846 const blocksToInsert = sourceClientIds.map(clientId => getBlock(clientId)); 40847 insertOrReplaceBlocks(blocksToInsert, true, null, sourceClientIds); 40848 return; 40849 } 40850 const isAtSameLevel = sourceRootClientId === targetRootClientId; 40851 const draggedBlockCount = sourceClientIds.length; 40852 40853 // If the block is kept at the same level and moved downwards, 40854 // subtract to take into account that the blocks being dragged 40855 // were removed from the block list above the insertion point. 40856 const insertIndex = isAtSameLevel && sourceBlockIndex < targetBlockIndex ? targetBlockIndex - draggedBlockCount : targetBlockIndex; 40857 moveBlocks(sourceClientIds, sourceRootClientId, insertIndex); 40858 } 40859 }; 40860 } 40861 40862 /** 40863 * A function that returns an event handler function for block-related file drop events. 40864 * 40865 * @param {string} targetRootClientId The root client id where the block(s) will be inserted. 40866 * @param {Function} getSettings A function that gets the block editor settings. 40867 * @param {Function} updateBlockAttributes A function that updates a block's attributes. 40868 * @param {Function} canInsertBlockType A function that returns checks whether a block type can be inserted. 40869 * @param {Function} insertOrReplaceBlocks A function that inserts or replaces blocks. 40870 * 40871 * @return {Function} The event handler for a block-related file drop event. 40872 */ 40873 function onFilesDrop(targetRootClientId, getSettings, updateBlockAttributes, canInsertBlockType, insertOrReplaceBlocks) { 40874 return files => { 40875 if (!getSettings().mediaUpload) { 40876 return; 40877 } 40878 const transformation = (0,external_wp_blocks_namespaceObject.findTransform)((0,external_wp_blocks_namespaceObject.getBlockTransforms)('from'), transform => transform.type === 'files' && canInsertBlockType(transform.blockName, targetRootClientId) && transform.isMatch(files)); 40879 if (transformation) { 40880 const blocks = transformation.transform(files, updateBlockAttributes); 40881 insertOrReplaceBlocks(blocks); 40882 } 40883 }; 40884 } 40885 40886 /** 40887 * A function that returns an event handler function for block-related HTML drop events. 40888 * 40889 * @param {Function} insertOrReplaceBlocks A function that inserts or replaces blocks. 40890 * 40891 * @return {Function} The event handler for a block-related HTML drop event. 40892 */ 40893 function onHTMLDrop(insertOrReplaceBlocks) { 40894 return HTML => { 40895 const blocks = (0,external_wp_blocks_namespaceObject.pasteHandler)({ 40896 HTML, 40897 mode: 'BLOCKS' 40898 }); 40899 if (blocks.length) { 40900 insertOrReplaceBlocks(blocks); 40901 } 40902 }; 40903 } 40904 40905 /** 40906 * A React hook for handling block drop events. 40907 * 40908 * @param {string} targetRootClientId The root client id where the block(s) will be inserted. 40909 * @param {number} targetBlockIndex The index where the block(s) will be inserted. 40910 * @param {Object} options The optional options. 40911 * @param {WPDropOperation} [options.operation] The type of operation to perform on drop. Could be `insert` or `replace` for now. 40912 * 40913 * @return {Function} A function to be passed to the onDrop handler. 40914 */ 40915 function useOnBlockDrop(targetRootClientId, targetBlockIndex, options = {}) { 40916 const { 40917 operation = 'insert', 40918 nearestSide = 'right' 40919 } = options; 40920 const { 40921 canInsertBlockType, 40922 getBlockIndex, 40923 getClientIdsOfDescendants, 40924 getBlockOrder, 40925 getBlocksByClientId, 40926 getSettings, 40927 getBlock 40928 } = (0,external_wp_data_namespaceObject.useSelect)(store); 40929 const { 40930 getGroupingBlockName 40931 } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store); 40932 const { 40933 insertBlocks, 40934 moveBlocksToPosition, 40935 updateBlockAttributes, 40936 clearSelectedBlock, 40937 replaceBlocks, 40938 removeBlocks 40939 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 40940 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 40941 const insertOrReplaceBlocks = (0,external_wp_element_namespaceObject.useCallback)((blocks, updateSelection = true, initialPosition = 0, clientIdsToReplace = []) => { 40942 if (!Array.isArray(blocks)) { 40943 blocks = [blocks]; 40944 } 40945 const clientIds = getBlockOrder(targetRootClientId); 40946 const clientId = clientIds[targetBlockIndex]; 40947 if (operation === 'replace') { 40948 replaceBlocks(clientId, blocks, undefined, initialPosition); 40949 } else if (operation === 'group') { 40950 const targetBlock = getBlock(clientId); 40951 if (nearestSide === 'left') { 40952 blocks.push(targetBlock); 40953 } else { 40954 blocks.unshift(targetBlock); 40955 } 40956 const groupInnerBlocks = blocks.map(block => { 40957 return (0,external_wp_blocks_namespaceObject.createBlock)(block.name, block.attributes, block.innerBlocks); 40958 }); 40959 const areAllImages = blocks.every(block => { 40960 return block.name === 'core/image'; 40961 }); 40962 const galleryBlock = canInsertBlockType('core/gallery', targetRootClientId); 40963 const wrappedBlocks = (0,external_wp_blocks_namespaceObject.createBlock)(areAllImages && galleryBlock ? 'core/gallery' : getGroupingBlockName(), { 40964 layout: { 40965 type: 'flex', 40966 flexWrap: areAllImages && galleryBlock ? null : 'nowrap' 40967 } 40968 }, groupInnerBlocks); 40969 // Need to make sure both the target block and the block being dragged are replaced 40970 // otherwise the dragged block will be duplicated. 40971 replaceBlocks([clientId, ...clientIdsToReplace], wrappedBlocks, undefined, initialPosition); 40972 } else { 40973 insertBlocks(blocks, targetBlockIndex, targetRootClientId, updateSelection, initialPosition); 40974 } 40975 }, [getBlockOrder, targetRootClientId, targetBlockIndex, operation, replaceBlocks, getBlock, nearestSide, canInsertBlockType, getGroupingBlockName, insertBlocks]); 40976 const moveBlocks = (0,external_wp_element_namespaceObject.useCallback)((sourceClientIds, sourceRootClientId, insertIndex) => { 40977 if (operation === 'replace') { 40978 const sourceBlocks = getBlocksByClientId(sourceClientIds); 40979 const targetBlockClientIds = getBlockOrder(targetRootClientId); 40980 const targetBlockClientId = targetBlockClientIds[targetBlockIndex]; 40981 registry.batch(() => { 40982 // Remove the source blocks. 40983 removeBlocks(sourceClientIds, false); 40984 // Replace the target block with the source blocks. 40985 replaceBlocks(targetBlockClientId, sourceBlocks, undefined, 0); 40986 }); 40987 } else { 40988 moveBlocksToPosition(sourceClientIds, sourceRootClientId, targetRootClientId, insertIndex); 40989 } 40990 }, [operation, getBlockOrder, getBlocksByClientId, moveBlocksToPosition, registry, removeBlocks, replaceBlocks, targetBlockIndex, targetRootClientId]); 40991 const _onDrop = onBlockDrop(targetRootClientId, targetBlockIndex, getBlockIndex, getClientIdsOfDescendants, moveBlocks, insertOrReplaceBlocks, clearSelectedBlock, operation, getBlock); 40992 const _onFilesDrop = onFilesDrop(targetRootClientId, getSettings, updateBlockAttributes, canInsertBlockType, insertOrReplaceBlocks); 40993 const _onHTMLDrop = onHTMLDrop(insertOrReplaceBlocks); 40994 return event => { 40995 const files = (0,external_wp_dom_namespaceObject.getFilesFromDataTransfer)(event.dataTransfer); 40996 const html = event.dataTransfer.getData('text/html'); 40997 40998 /** 40999 * From Windows Chrome 96, the `event.dataTransfer` returns both file object and HTML. 41000 * The order of the checks is important to recognise the HTML drop. 41001 */ 41002 if (html) { 41003 _onHTMLDrop(html); 41004 } else if (files.length) { 41005 _onFilesDrop(files); 41006 } else { 41007 _onDrop(event); 41008 } 41009 }; 41010 } 41011 41012 ;// ./node_modules/@wordpress/block-editor/build-module/utils/math.js 41013 /** 41014 * A string representing the name of an edge. 41015 * 41016 * @typedef {'top'|'right'|'bottom'|'left'} WPEdgeName 41017 */ 41018 41019 /** 41020 * @typedef {Object} WPPoint 41021 * @property {number} x The horizontal position. 41022 * @property {number} y The vertical position. 41023 */ 41024 41025 /** 41026 * Given a point, a DOMRect and the name of an edge, returns the distance to 41027 * that edge of the rect. 41028 * 41029 * This function works for edges that are horizontal or vertical (e.g. not 41030 * rotated), the following terms are used so that the function works in both 41031 * orientations: 41032 * 41033 * - Forward, meaning the axis running horizontally when an edge is vertical 41034 * and vertically when an edge is horizontal. 41035 * - Lateral, meaning the axis running vertically when an edge is vertical 41036 * and horizontally when an edge is horizontal. 41037 * 41038 * @param {WPPoint} point The point to measure distance from. 41039 * @param {DOMRect} rect A DOM Rect containing edge positions. 41040 * @param {WPEdgeName} edge The edge to measure to. 41041 */ 41042 function getDistanceFromPointToEdge(point, rect, edge) { 41043 const isHorizontal = edge === 'top' || edge === 'bottom'; 41044 const { 41045 x, 41046 y 41047 } = point; 41048 const pointLateralPosition = isHorizontal ? x : y; 41049 const pointForwardPosition = isHorizontal ? y : x; 41050 const edgeStart = isHorizontal ? rect.left : rect.top; 41051 const edgeEnd = isHorizontal ? rect.right : rect.bottom; 41052 const edgeForwardPosition = rect[edge]; 41053 41054 // Measure the straight line distance to the edge of the rect, when the 41055 // point is adjacent to the edge. 41056 // Else, if the point is positioned diagonally to the edge of the rect, 41057 // measure diagonally to the nearest corner that the edge meets. 41058 let edgeLateralPosition; 41059 if (pointLateralPosition >= edgeStart && pointLateralPosition <= edgeEnd) { 41060 edgeLateralPosition = pointLateralPosition; 41061 } else if (pointLateralPosition < edgeEnd) { 41062 edgeLateralPosition = edgeStart; 41063 } else { 41064 edgeLateralPosition = edgeEnd; 41065 } 41066 return Math.sqrt((pointLateralPosition - edgeLateralPosition) ** 2 + (pointForwardPosition - edgeForwardPosition) ** 2); 41067 } 41068 41069 /** 41070 * Given a point, a DOMRect and a list of allowed edges returns the name of and 41071 * distance to the nearest edge. 41072 * 41073 * @param {WPPoint} point The point to measure distance from. 41074 * @param {DOMRect} rect A DOM Rect containing edge positions. 41075 * @param {WPEdgeName[]} allowedEdges A list of the edges included in the 41076 * calculation. Defaults to all edges. 41077 * 41078 * @return {[number, string]} An array where the first value is the distance 41079 * and a second is the edge name. 41080 */ 41081 function getDistanceToNearestEdge(point, rect, allowedEdges = ['top', 'bottom', 'left', 'right']) { 41082 let candidateDistance; 41083 let candidateEdge; 41084 allowedEdges.forEach(edge => { 41085 const distance = getDistanceFromPointToEdge(point, rect, edge); 41086 if (candidateDistance === undefined || distance < candidateDistance) { 41087 candidateDistance = distance; 41088 candidateEdge = edge; 41089 } 41090 }); 41091 return [candidateDistance, candidateEdge]; 41092 } 41093 41094 /** 41095 * Is the point contained by the rectangle. 41096 * 41097 * @param {WPPoint} point The point. 41098 * @param {DOMRect} rect The rectangle. 41099 * 41100 * @return {boolean} True if the point is contained by the rectangle, false otherwise. 41101 */ 41102 function isPointContainedByRect(point, rect) { 41103 return rect.left <= point.x && rect.right >= point.x && rect.top <= point.y && rect.bottom >= point.y; 41104 } 41105 41106 /** 41107 * Is the point within the top and bottom boundaries of the rectangle. 41108 * 41109 * @param {WPPoint} point The point. 41110 * @param {DOMRect} rect The rectangle. 41111 * 41112 * @return {boolean} True if the point is within top and bottom of rectangle, false otherwise. 41113 */ 41114 function isPointWithinTopAndBottomBoundariesOfRect(point, rect) { 41115 return rect.top <= point.y && rect.bottom >= point.y; 41116 } 41117 41118 ;// ./node_modules/@wordpress/block-editor/build-module/components/use-block-drop-zone/index.js 41119 /** 41120 * WordPress dependencies 41121 */ 41122 41123 41124 41125 41126 41127 41128 /** 41129 * Internal dependencies 41130 */ 41131 41132 41133 41134 41135 const THRESHOLD_DISTANCE = 30; 41136 const MINIMUM_HEIGHT_FOR_THRESHOLD = 120; 41137 const MINIMUM_WIDTH_FOR_THRESHOLD = 120; 41138 41139 /** @typedef {import('../../utils/math').WPPoint} WPPoint */ 41140 /** @typedef {import('../use-on-block-drop/types').WPDropOperation} WPDropOperation */ 41141 41142 /** 41143 * The orientation of a block list. 41144 * 41145 * @typedef {'horizontal'|'vertical'|undefined} WPBlockListOrientation 41146 */ 41147 41148 /** 41149 * The insert position when dropping a block. 41150 * 41151 * @typedef {'before'|'after'} WPInsertPosition 41152 */ 41153 41154 /** 41155 * @typedef {Object} WPBlockData 41156 * @property {boolean} isUnmodifiedDefaultBlock Is the block unmodified default block. 41157 * @property {() => DOMRect} getBoundingClientRect Get the bounding client rect of the block. 41158 * @property {number} blockIndex The index of the block. 41159 */ 41160 41161 /** 41162 * Get the drop target position from a given drop point and the orientation. 41163 * 41164 * @param {WPBlockData[]} blocksData The block data list. 41165 * @param {WPPoint} position The position of the item being dragged. 41166 * @param {WPBlockListOrientation} orientation The orientation of the block list. 41167 * @param {Object} options Additional options. 41168 * @return {[number, WPDropOperation]} The drop target position. 41169 */ 41170 function getDropTargetPosition(blocksData, position, orientation = 'vertical', options = {}) { 41171 const allowedEdges = orientation === 'horizontal' ? ['left', 'right'] : ['top', 'bottom']; 41172 let nearestIndex = 0; 41173 let insertPosition = 'before'; 41174 let minDistance = Infinity; 41175 let targetBlockIndex = null; 41176 let nearestSide = 'right'; 41177 const { 41178 dropZoneElement, 41179 parentBlockOrientation, 41180 rootBlockIndex = 0 41181 } = options; 41182 41183 // Allow before/after when dragging over the top/bottom edges of the drop zone. 41184 if (dropZoneElement && parentBlockOrientation !== 'horizontal') { 41185 const rect = dropZoneElement.getBoundingClientRect(); 41186 const [distance, edge] = getDistanceToNearestEdge(position, rect, ['top', 'bottom']); 41187 41188 // If dragging over the top or bottom of the drop zone, insert the block 41189 // before or after the parent block. This only applies to blocks that use 41190 // a drop zone element, typically container blocks such as Group or Cover. 41191 if (rect.height > MINIMUM_HEIGHT_FOR_THRESHOLD && distance < THRESHOLD_DISTANCE) { 41192 if (edge === 'top') { 41193 return [rootBlockIndex, 'before']; 41194 } 41195 if (edge === 'bottom') { 41196 return [rootBlockIndex + 1, 'after']; 41197 } 41198 } 41199 } 41200 const isRightToLeft = (0,external_wp_i18n_namespaceObject.isRTL)(); 41201 41202 // Allow before/after when dragging over the left/right edges of the drop zone. 41203 if (dropZoneElement && parentBlockOrientation === 'horizontal') { 41204 const rect = dropZoneElement.getBoundingClientRect(); 41205 const [distance, edge] = getDistanceToNearestEdge(position, rect, ['left', 'right']); 41206 41207 // If dragging over the left or right of the drop zone, insert the block 41208 // before or after the parent block. This only applies to blocks that use 41209 // a drop zone element, typically container blocks such as Group. 41210 if (rect.width > MINIMUM_WIDTH_FOR_THRESHOLD && distance < THRESHOLD_DISTANCE) { 41211 if (isRightToLeft && edge === 'right' || !isRightToLeft && edge === 'left') { 41212 return [rootBlockIndex, 'before']; 41213 } 41214 if (isRightToLeft && edge === 'left' || !isRightToLeft && edge === 'right') { 41215 return [rootBlockIndex + 1, 'after']; 41216 } 41217 } 41218 } 41219 blocksData.forEach(({ 41220 isUnmodifiedDefaultBlock, 41221 getBoundingClientRect, 41222 blockIndex, 41223 blockOrientation 41224 }) => { 41225 const rect = getBoundingClientRect(); 41226 let [distance, edge] = getDistanceToNearestEdge(position, rect, allowedEdges); 41227 // If the the point is close to a side, prioritize that side. 41228 const [sideDistance, sideEdge] = getDistanceToNearestEdge(position, rect, ['left', 'right']); 41229 const isPointInsideRect = isPointContainedByRect(position, rect); 41230 41231 // Prioritize the element if the point is inside of an unmodified default block. 41232 if (isUnmodifiedDefaultBlock && isPointInsideRect) { 41233 distance = 0; 41234 } else if (orientation === 'vertical' && blockOrientation !== 'horizontal' && (isPointInsideRect && sideDistance < THRESHOLD_DISTANCE || !isPointInsideRect && isPointWithinTopAndBottomBoundariesOfRect(position, rect))) { 41235 /** 41236 * This condition should only apply when the layout is vertical (otherwise there's 41237 * no need to create a Row) and dropzones should only activate when the block is 41238 * either within and close to the sides of the target block or on its outer sides. 41239 */ 41240 targetBlockIndex = blockIndex; 41241 nearestSide = sideEdge; 41242 } 41243 if (distance < minDistance) { 41244 // Where the dropped block will be inserted on the nearest block. 41245 insertPosition = edge === 'bottom' || !isRightToLeft && edge === 'right' || isRightToLeft && edge === 'left' ? 'after' : 'before'; 41246 41247 // Update the currently known best candidate. 41248 minDistance = distance; 41249 nearestIndex = blockIndex; 41250 } 41251 }); 41252 const adjacentIndex = nearestIndex + (insertPosition === 'after' ? 1 : -1); 41253 const isNearestBlockUnmodifiedDefaultBlock = !!blocksData[nearestIndex]?.isUnmodifiedDefaultBlock; 41254 const isAdjacentBlockUnmodifiedDefaultBlock = !!blocksData[adjacentIndex]?.isUnmodifiedDefaultBlock; 41255 41256 // If the target index is set then group with the block at that index. 41257 if (targetBlockIndex !== null) { 41258 return [targetBlockIndex, 'group', nearestSide]; 41259 } 41260 // If both blocks are not unmodified default blocks then just insert between them. 41261 if (!isNearestBlockUnmodifiedDefaultBlock && !isAdjacentBlockUnmodifiedDefaultBlock) { 41262 // If the user is dropping to the trailing edge of the block 41263 // add 1 to the index to represent dragging after. 41264 const insertionIndex = insertPosition === 'after' ? nearestIndex + 1 : nearestIndex; 41265 return [insertionIndex, 'insert']; 41266 } 41267 41268 // Otherwise, replace the nearest unmodified default block. 41269 return [isNearestBlockUnmodifiedDefaultBlock ? nearestIndex : adjacentIndex, 'replace']; 41270 } 41271 41272 /** 41273 * Check if the dragged blocks can be dropped on the target. 41274 * @param {Function} getBlockType 41275 * @param {Object[]} allowedBlocks 41276 * @param {string[]} draggedBlockNames 41277 * @param {string} targetBlockName 41278 * @return {boolean} Whether the dragged blocks can be dropped on the target. 41279 */ 41280 function isDropTargetValid(getBlockType, allowedBlocks, draggedBlockNames, targetBlockName) { 41281 // At root level allowedBlocks is undefined and all blocks are allowed. 41282 // Otherwise, check if all dragged blocks are allowed. 41283 let areBlocksAllowed = true; 41284 if (allowedBlocks) { 41285 const allowedBlockNames = allowedBlocks?.map(({ 41286 name 41287 }) => name); 41288 areBlocksAllowed = draggedBlockNames.every(name => allowedBlockNames?.includes(name)); 41289 } 41290 41291 // Work out if dragged blocks have an allowed parent and if so 41292 // check target block matches the allowed parent. 41293 const draggedBlockTypes = draggedBlockNames.map(name => getBlockType(name)); 41294 const targetMatchesDraggedBlockParents = draggedBlockTypes.every(block => { 41295 const [allowedParentName] = block?.parent || []; 41296 if (!allowedParentName) { 41297 return true; 41298 } 41299 return allowedParentName === targetBlockName; 41300 }); 41301 return areBlocksAllowed && targetMatchesDraggedBlockParents; 41302 } 41303 41304 /** 41305 * Checks if the given element is an insertion point. 41306 * 41307 * @param {EventTarget|null} targetToCheck - The element to check. 41308 * @param {Document} ownerDocument - The owner document of the element. 41309 * @return {boolean} True if the element is a insertion point, false otherwise. 41310 */ 41311 function isInsertionPoint(targetToCheck, ownerDocument) { 41312 const { 41313 defaultView 41314 } = ownerDocument; 41315 return !!(defaultView && targetToCheck instanceof defaultView.HTMLElement && targetToCheck.closest('[data-is-insertion-point]')); 41316 } 41317 41318 /** 41319 * @typedef {Object} WPBlockDropZoneConfig 41320 * @property {?HTMLElement} dropZoneElement Optional element to be used as the drop zone. 41321 * @property {string} rootClientId The root client id for the block list. 41322 */ 41323 41324 /** 41325 * A React hook that can be used to make a block list handle drag and drop. 41326 * 41327 * @param {WPBlockDropZoneConfig} dropZoneConfig configuration data for the drop zone. 41328 */ 41329 function useBlockDropZone({ 41330 dropZoneElement, 41331 // An undefined value represents a top-level block. Default to an empty 41332 // string for this so that `targetRootClientId` can be easily compared to 41333 // values returned by the `getRootBlockClientId` selector, which also uses 41334 // an empty string to represent top-level blocks. 41335 rootClientId: targetRootClientId = '', 41336 parentClientId: parentBlockClientId = '', 41337 isDisabled = false 41338 } = {}) { 41339 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 41340 const [dropTarget, setDropTarget] = (0,external_wp_element_namespaceObject.useState)({ 41341 index: null, 41342 operation: 'insert' 41343 }); 41344 const { 41345 getBlockType, 41346 getBlockVariations, 41347 getGroupingBlockName 41348 } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store); 41349 const { 41350 canInsertBlockType, 41351 getBlockListSettings, 41352 getBlocks, 41353 getBlockIndex, 41354 getDraggedBlockClientIds, 41355 getBlockNamesByClientId, 41356 getAllowedBlocks, 41357 isDragging, 41358 isGroupable, 41359 isZoomOutMode, 41360 getSectionRootClientId 41361 } = unlock((0,external_wp_data_namespaceObject.useSelect)(store)); 41362 const { 41363 showInsertionPoint, 41364 hideInsertionPoint, 41365 startDragging, 41366 stopDragging 41367 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 41368 const onBlockDrop = useOnBlockDrop(dropTarget.operation === 'before' || dropTarget.operation === 'after' ? parentBlockClientId : targetRootClientId, dropTarget.index, { 41369 operation: dropTarget.operation, 41370 nearestSide: dropTarget.nearestSide 41371 }); 41372 const throttled = (0,external_wp_compose_namespaceObject.useThrottle)((0,external_wp_element_namespaceObject.useCallback)((event, ownerDocument) => { 41373 if (!isDragging()) { 41374 // When dragging from the desktop, no drag start event is fired. 41375 // So, ensure that the drag state is set when the user drags over a drop zone. 41376 startDragging(); 41377 } 41378 const allowedBlocks = getAllowedBlocks(targetRootClientId); 41379 const targetBlockName = getBlockNamesByClientId([targetRootClientId])[0]; 41380 const draggedBlockNames = getBlockNamesByClientId(getDraggedBlockClientIds()); 41381 const isBlockDroppingAllowed = isDropTargetValid(getBlockType, allowedBlocks, draggedBlockNames, targetBlockName); 41382 if (!isBlockDroppingAllowed) { 41383 return; 41384 } 41385 const sectionRootClientId = getSectionRootClientId(); 41386 41387 // In Zoom Out mode, if the target is not the section root provided by settings then 41388 // do not allow dropping as the drop target is not within the root (that which is 41389 // treated as "the content" by Zoom Out Mode). 41390 if (isZoomOutMode() && sectionRootClientId !== targetRootClientId) { 41391 return; 41392 } 41393 const blocks = getBlocks(targetRootClientId); 41394 41395 // The block list is empty, don't show the insertion point but still allow dropping. 41396 if (blocks.length === 0) { 41397 registry.batch(() => { 41398 setDropTarget({ 41399 index: 0, 41400 operation: 'insert' 41401 }); 41402 showInsertionPoint(targetRootClientId, 0, { 41403 operation: 'insert' 41404 }); 41405 }); 41406 return; 41407 } 41408 const blocksData = blocks.map(block => { 41409 const clientId = block.clientId; 41410 return { 41411 isUnmodifiedDefaultBlock: (0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(block), 41412 getBoundingClientRect: () => ownerDocument.getElementById(`block-$clientId}`).getBoundingClientRect(), 41413 blockIndex: getBlockIndex(clientId), 41414 blockOrientation: getBlockListSettings(clientId)?.orientation 41415 }; 41416 }); 41417 const dropTargetPosition = getDropTargetPosition(blocksData, { 41418 x: event.clientX, 41419 y: event.clientY 41420 }, getBlockListSettings(targetRootClientId)?.orientation, { 41421 dropZoneElement, 41422 parentBlockClientId, 41423 parentBlockOrientation: parentBlockClientId ? getBlockListSettings(parentBlockClientId)?.orientation : undefined, 41424 rootBlockIndex: getBlockIndex(targetRootClientId) 41425 }); 41426 const [targetIndex, operation, nearestSide] = dropTargetPosition; 41427 if (isZoomOutMode() && operation !== 'insert') { 41428 return; 41429 } 41430 if (operation === 'group') { 41431 const targetBlock = blocks[targetIndex]; 41432 const areAllImages = [targetBlock.name, ...draggedBlockNames].every(name => name === 'core/image'); 41433 const canInsertGalleryBlock = canInsertBlockType('core/gallery', targetRootClientId); 41434 const areGroupableBlocks = isGroupable([targetBlock.clientId, getDraggedBlockClientIds()]); 41435 const groupBlockVariations = getBlockVariations(getGroupingBlockName(), 'block'); 41436 const canInsertRow = groupBlockVariations && groupBlockVariations.find(({ 41437 name 41438 }) => name === 'group-row'); 41439 41440 // If the dragged blocks and the target block are all images, 41441 // check if it is creatable either a Row variation or a Gallery block. 41442 if (areAllImages && !canInsertGalleryBlock && (!areGroupableBlocks || !canInsertRow)) { 41443 return; 41444 } 41445 // If the dragged blocks and the target block are not all images, 41446 // check if it is creatable a Row variation. 41447 if (!areAllImages && (!areGroupableBlocks || !canInsertRow)) { 41448 return; 41449 } 41450 } 41451 registry.batch(() => { 41452 setDropTarget({ 41453 index: targetIndex, 41454 operation, 41455 nearestSide 41456 }); 41457 const insertionPointClientId = ['before', 'after'].includes(operation) ? parentBlockClientId : targetRootClientId; 41458 showInsertionPoint(insertionPointClientId, targetIndex, { 41459 operation, 41460 nearestSide 41461 }); 41462 }); 41463 }, [isDragging, getAllowedBlocks, targetRootClientId, getBlockNamesByClientId, getDraggedBlockClientIds, getBlockType, getSectionRootClientId, isZoomOutMode, getBlocks, getBlockListSettings, dropZoneElement, parentBlockClientId, getBlockIndex, registry, startDragging, showInsertionPoint, canInsertBlockType, isGroupable, getBlockVariations, getGroupingBlockName]), 200); 41464 return (0,external_wp_compose_namespaceObject.__experimentalUseDropZone)({ 41465 dropZoneElement, 41466 isDisabled, 41467 onDrop: onBlockDrop, 41468 onDragOver(event) { 41469 // `currentTarget` is only available while the event is being 41470 // handled, so get it now and pass it to the thottled function. 41471 // https://developer.mozilla.org/en-US/docs/Web/API/Event/currentTarget 41472 throttled(event, event.currentTarget.ownerDocument); 41473 }, 41474 onDragLeave(event) { 41475 const { 41476 ownerDocument 41477 } = event.currentTarget; 41478 41479 // If the drag event is leaving the drop zone and entering an insertion point, 41480 // do not hide the insertion point as it is conceptually within the dropzone. 41481 if (isInsertionPoint(event.relatedTarget, ownerDocument) || isInsertionPoint(event.target, ownerDocument)) { 41482 return; 41483 } 41484 throttled.cancel(); 41485 hideInsertionPoint(); 41486 }, 41487 onDragEnd() { 41488 throttled.cancel(); 41489 stopDragging(); 41490 hideInsertionPoint(); 41491 } 41492 }); 41493 } 41494 41495 ;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/index.js 41496 /** 41497 * External dependencies 41498 */ 41499 41500 41501 /** 41502 * WordPress dependencies 41503 */ 41504 41505 41506 41507 41508 41509 /** 41510 * Internal dependencies 41511 */ 41512 41513 41514 41515 41516 41517 41518 41519 41520 41521 41522 41523 41524 41525 const inner_blocks_EMPTY_OBJECT = {}; 41526 function BlockContext({ 41527 children, 41528 clientId 41529 }) { 41530 const context = useBlockContext(clientId); 41531 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockContextProvider, { 41532 value: context, 41533 children: children 41534 }); 41535 } 41536 const BlockListItemsMemo = (0,external_wp_element_namespaceObject.memo)(BlockListItems); 41537 41538 /** 41539 * InnerBlocks is a component which allows a single block to have multiple blocks 41540 * as children. The UncontrolledInnerBlocks component is used whenever the inner 41541 * blocks are not controlled by another entity. In other words, it is normally 41542 * used for inner blocks in the post editor 41543 * 41544 * @param {Object} props The component props. 41545 */ 41546 function UncontrolledInnerBlocks(props) { 41547 const { 41548 clientId, 41549 allowedBlocks, 41550 prioritizedInserterBlocks, 41551 defaultBlock, 41552 directInsert, 41553 __experimentalDefaultBlock, 41554 __experimentalDirectInsert, 41555 template, 41556 templateLock, 41557 wrapperRef, 41558 templateInsertUpdatesSelection, 41559 __experimentalCaptureToolbars: captureToolbars, 41560 __experimentalAppenderTagName, 41561 renderAppender, 41562 orientation, 41563 placeholder, 41564 layout, 41565 name, 41566 blockType, 41567 parentLock, 41568 defaultLayout 41569 } = props; 41570 useNestedSettingsUpdate(clientId, parentLock, allowedBlocks, prioritizedInserterBlocks, defaultBlock, directInsert, __experimentalDefaultBlock, __experimentalDirectInsert, templateLock, captureToolbars, orientation, layout); 41571 useInnerBlockTemplateSync(clientId, template, templateLock, templateInsertUpdatesSelection); 41572 const defaultLayoutBlockSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, 'layout') || (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, '__experimentalLayout') || inner_blocks_EMPTY_OBJECT; 41573 const { 41574 allowSizingOnChildren = false 41575 } = defaultLayoutBlockSupport; 41576 const usedLayout = layout || defaultLayoutBlockSupport; 41577 const memoedLayout = (0,external_wp_element_namespaceObject.useMemo)(() => ({ 41578 // Default layout will know about any content/wide size defined by the theme. 41579 ...defaultLayout, 41580 ...usedLayout, 41581 ...(allowSizingOnChildren && { 41582 allowSizingOnChildren: true 41583 }) 41584 }), [defaultLayout, usedLayout, allowSizingOnChildren]); 41585 41586 // For controlled inner blocks, we don't want a change in blocks to 41587 // re-render the blocks list. 41588 const items = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListItemsMemo, { 41589 rootClientId: clientId, 41590 renderAppender: renderAppender, 41591 __experimentalAppenderTagName: __experimentalAppenderTagName, 41592 layout: memoedLayout, 41593 wrapperRef: wrapperRef, 41594 placeholder: placeholder 41595 }); 41596 if (!blockType?.providesContext || Object.keys(blockType.providesContext).length === 0) { 41597 return items; 41598 } 41599 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockContext, { 41600 clientId: clientId, 41601 children: items 41602 }); 41603 } 41604 41605 /** 41606 * The controlled inner blocks component wraps the uncontrolled inner blocks 41607 * component with the blockSync hook. This keeps the innerBlocks of the block in 41608 * the block-editor store in sync with the blocks of the controlling entity. An 41609 * example of an inner block controller is a template part block, which provides 41610 * its own blocks from the template part entity data source. 41611 * 41612 * @param {Object} props The component props. 41613 */ 41614 function ControlledInnerBlocks(props) { 41615 useBlockSync(props); 41616 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UncontrolledInnerBlocks, { 41617 ...props 41618 }); 41619 } 41620 const ForwardedInnerBlocks = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => { 41621 const innerBlocksProps = useInnerBlocksProps({ 41622 ref 41623 }, props); 41624 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 41625 className: "block-editor-inner-blocks", 41626 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 41627 ...innerBlocksProps 41628 }) 41629 }); 41630 }); 41631 41632 /** 41633 * This hook is used to lightly mark an element as an inner blocks wrapper 41634 * element. Call this hook and pass the returned props to the element to mark as 41635 * an inner blocks wrapper, automatically rendering inner blocks as children. If 41636 * you define a ref for the element, it is important to pass the ref to this 41637 * hook, which the hook in turn will pass to the component through the props it 41638 * returns. Optionally, you can also pass any other props through this hook, and 41639 * they will be merged and returned. 41640 * 41641 * @param {Object} props Optional. Props to pass to the element. Must contain 41642 * the ref if one is defined. 41643 * @param {Object} options Optional. Inner blocks options. 41644 * 41645 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/inner-blocks/README.md 41646 */ 41647 function useInnerBlocksProps(props = {}, options = {}) { 41648 const { 41649 __unstableDisableLayoutClassNames, 41650 __unstableDisableDropZone, 41651 dropZoneElement 41652 } = options; 41653 const { 41654 clientId, 41655 layout = null, 41656 __unstableLayoutClassNames: layoutClassNames = '' 41657 } = useBlockEditContext(); 41658 const selected = (0,external_wp_data_namespaceObject.useSelect)(select => { 41659 const { 41660 getBlockName, 41661 isBlockSelected, 41662 hasSelectedInnerBlock, 41663 __unstableGetEditorMode, 41664 getTemplateLock, 41665 getBlockRootClientId, 41666 getBlockEditingMode, 41667 getBlockSettings, 41668 isDragging, 41669 getSectionRootClientId, 41670 isZoomOutMode: isZoomOut 41671 } = unlock(select(store)); 41672 if (!clientId) { 41673 const sectionRootClientId = getSectionRootClientId(); 41674 // Disable the root drop zone when zoomed out and the section root client id 41675 // is not the root block list (represented by an empty string). 41676 // This avoids drag handling bugs caused by having two block lists acting as 41677 // drop zones - the actual 'root' block list and the section root. 41678 return { 41679 isDropZoneDisabled: isZoomOut() && sectionRootClientId !== '' 41680 }; 41681 } 41682 const { 41683 hasBlockSupport, 41684 getBlockType 41685 } = select(external_wp_blocks_namespaceObject.store); 41686 const blockName = getBlockName(clientId); 41687 const enableClickThrough = __unstableGetEditorMode() === 'navigation'; 41688 const blockEditingMode = getBlockEditingMode(clientId); 41689 const parentClientId = getBlockRootClientId(clientId); 41690 const [defaultLayout] = getBlockSettings(clientId, 'layout'); 41691 let _isDropZoneDisabled = blockEditingMode === 'disabled'; 41692 if (__unstableGetEditorMode() === 'zoom-out') { 41693 // In zoom out mode, we want to disable the drop zone for the sections. 41694 // The inner blocks belonging to the section drop zone is 41695 // already disabled by the blocks themselves being disabled. 41696 const sectionRootClientId = getSectionRootClientId(); 41697 _isDropZoneDisabled = clientId !== sectionRootClientId; 41698 } 41699 return { 41700 __experimentalCaptureToolbars: hasBlockSupport(blockName, '__experimentalExposeControlsToChildren', false), 41701 hasOverlay: blockName !== 'core/template' && !isBlockSelected(clientId) && !hasSelectedInnerBlock(clientId, true) && enableClickThrough && !isDragging(), 41702 name: blockName, 41703 blockType: getBlockType(blockName), 41704 parentLock: getTemplateLock(parentClientId), 41705 parentClientId, 41706 isDropZoneDisabled: _isDropZoneDisabled, 41707 defaultLayout 41708 }; 41709 }, [clientId]); 41710 const { 41711 __experimentalCaptureToolbars, 41712 hasOverlay, 41713 name, 41714 blockType, 41715 parentLock, 41716 parentClientId, 41717 isDropZoneDisabled, 41718 defaultLayout 41719 } = selected; 41720 const blockDropZoneRef = useBlockDropZone({ 41721 dropZoneElement, 41722 rootClientId: clientId, 41723 parentClientId 41724 }); 41725 const ref = (0,external_wp_compose_namespaceObject.useMergeRefs)([props.ref, __unstableDisableDropZone || isDropZoneDisabled || layout?.isManualPlacement && window.__experimentalEnableGridInteractivity ? null : blockDropZoneRef]); 41726 const innerBlocksProps = { 41727 __experimentalCaptureToolbars, 41728 layout, 41729 name, 41730 blockType, 41731 parentLock, 41732 defaultLayout, 41733 ...options 41734 }; 41735 const InnerBlocks = innerBlocksProps.value && innerBlocksProps.onChange ? ControlledInnerBlocks : UncontrolledInnerBlocks; 41736 return { 41737 ...props, 41738 ref, 41739 className: dist_clsx(props.className, 'block-editor-block-list__layout', __unstableDisableLayoutClassNames ? '' : layoutClassNames, { 41740 'has-overlay': hasOverlay 41741 }), 41742 children: clientId ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InnerBlocks, { 41743 ...innerBlocksProps, 41744 clientId: clientId 41745 }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListItems, { 41746 ...options 41747 }) 41748 }; 41749 } 41750 useInnerBlocksProps.save = external_wp_blocks_namespaceObject.__unstableGetInnerBlocksProps; 41751 41752 // Expose default appender placeholders as components. 41753 ForwardedInnerBlocks.DefaultBlockAppender = default_block_appender_DefaultBlockAppender; 41754 ForwardedInnerBlocks.ButtonBlockAppender = ButtonBlockAppender; 41755 ForwardedInnerBlocks.Content = () => useInnerBlocksProps.save().children; 41756 41757 /** 41758 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/inner-blocks/README.md 41759 */ 41760 /* harmony default export */ const inner_blocks = (ForwardedInnerBlocks); 41761 41762 ;// ./node_modules/@wordpress/block-editor/build-module/components/observe-typing/index.js 41763 /** 41764 * WordPress dependencies 41765 */ 41766 41767 41768 41769 41770 41771 /** 41772 * Internal dependencies 41773 */ 41774 41775 41776 /** 41777 * Set of key codes upon which typing is to be initiated on a keydown event. 41778 * 41779 * @type {Set<number>} 41780 */ 41781 41782 const KEY_DOWN_ELIGIBLE_KEY_CODES = new Set([external_wp_keycodes_namespaceObject.UP, external_wp_keycodes_namespaceObject.RIGHT, external_wp_keycodes_namespaceObject.DOWN, external_wp_keycodes_namespaceObject.LEFT, external_wp_keycodes_namespaceObject.ENTER, external_wp_keycodes_namespaceObject.BACKSPACE]); 41783 41784 /** 41785 * Returns true if a given keydown event can be inferred as intent to start 41786 * typing, or false otherwise. A keydown is considered eligible if it is a 41787 * text navigation without shift active. 41788 * 41789 * @param {KeyboardEvent} event Keydown event to test. 41790 * 41791 * @return {boolean} Whether event is eligible to start typing. 41792 */ 41793 function isKeyDownEligibleForStartTyping(event) { 41794 const { 41795 keyCode, 41796 shiftKey 41797 } = event; 41798 return !shiftKey && KEY_DOWN_ELIGIBLE_KEY_CODES.has(keyCode); 41799 } 41800 41801 /** 41802 * Removes the `isTyping` flag when the mouse moves in the document of the given 41803 * element. 41804 */ 41805 function useMouseMoveTypingReset() { 41806 const isTyping = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).isTyping(), []); 41807 const { 41808 stopTyping 41809 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 41810 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 41811 if (!isTyping) { 41812 return; 41813 } 41814 const { 41815 ownerDocument 41816 } = node; 41817 let lastClientX; 41818 let lastClientY; 41819 41820 /** 41821 * On mouse move, unset typing flag if user has moved cursor. 41822 * 41823 * @param {MouseEvent} event Mousemove event. 41824 */ 41825 function stopTypingOnMouseMove(event) { 41826 const { 41827 clientX, 41828 clientY 41829 } = event; 41830 41831 // We need to check that the mouse really moved because Safari 41832 // triggers mousemove events when shift or ctrl are pressed. 41833 if (lastClientX && lastClientY && (lastClientX !== clientX || lastClientY !== clientY)) { 41834 stopTyping(); 41835 } 41836 lastClientX = clientX; 41837 lastClientY = clientY; 41838 } 41839 ownerDocument.addEventListener('mousemove', stopTypingOnMouseMove); 41840 return () => { 41841 ownerDocument.removeEventListener('mousemove', stopTypingOnMouseMove); 41842 }; 41843 }, [isTyping, stopTyping]); 41844 } 41845 41846 /** 41847 * Sets and removes the `isTyping` flag based on user actions: 41848 * 41849 * - Sets the flag if the user types within the given element. 41850 * - Removes the flag when the user selects some text, focusses a non-text 41851 * field, presses ESC or TAB, or moves the mouse in the document. 41852 */ 41853 function useTypingObserver() { 41854 const { 41855 isTyping 41856 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 41857 const { 41858 isTyping: _isTyping 41859 } = select(store); 41860 return { 41861 isTyping: _isTyping() 41862 }; 41863 }, []); 41864 const { 41865 startTyping, 41866 stopTyping 41867 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 41868 const ref1 = useMouseMoveTypingReset(); 41869 const ref2 = (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 41870 const { 41871 ownerDocument 41872 } = node; 41873 const { 41874 defaultView 41875 } = ownerDocument; 41876 const selection = defaultView.getSelection(); 41877 41878 // Listeners to stop typing should only be added when typing. 41879 // Listeners to start typing should only be added when not typing. 41880 if (isTyping) { 41881 let timerId; 41882 41883 /** 41884 * Stops typing when focus transitions to a non-text field element. 41885 * 41886 * @param {FocusEvent} event Focus event. 41887 */ 41888 function stopTypingOnNonTextField(event) { 41889 const { 41890 target 41891 } = event; 41892 41893 // Since focus to a non-text field via arrow key will trigger 41894 // before the keydown event, wait until after current stack 41895 // before evaluating whether typing is to be stopped. Otherwise, 41896 // typing will re-start. 41897 timerId = defaultView.setTimeout(() => { 41898 if (!(0,external_wp_dom_namespaceObject.isTextField)(target)) { 41899 stopTyping(); 41900 } 41901 }); 41902 } 41903 41904 /** 41905 * Unsets typing flag if user presses Escape while typing flag is 41906 * active. 41907 * 41908 * @param {KeyboardEvent} event Keypress or keydown event to 41909 * interpret. 41910 */ 41911 function stopTypingOnEscapeKey(event) { 41912 const { 41913 keyCode 41914 } = event; 41915 if (keyCode === external_wp_keycodes_namespaceObject.ESCAPE || keyCode === external_wp_keycodes_namespaceObject.TAB) { 41916 stopTyping(); 41917 } 41918 } 41919 41920 /** 41921 * On selection change, unset typing flag if user has made an 41922 * uncollapsed (shift) selection. 41923 */ 41924 function stopTypingOnSelectionUncollapse() { 41925 if (!selection.isCollapsed) { 41926 stopTyping(); 41927 } 41928 } 41929 node.addEventListener('focus', stopTypingOnNonTextField); 41930 node.addEventListener('keydown', stopTypingOnEscapeKey); 41931 ownerDocument.addEventListener('selectionchange', stopTypingOnSelectionUncollapse); 41932 return () => { 41933 defaultView.clearTimeout(timerId); 41934 node.removeEventListener('focus', stopTypingOnNonTextField); 41935 node.removeEventListener('keydown', stopTypingOnEscapeKey); 41936 ownerDocument.removeEventListener('selectionchange', stopTypingOnSelectionUncollapse); 41937 }; 41938 } 41939 41940 /** 41941 * Handles a keypress or keydown event to infer intention to start 41942 * typing. 41943 * 41944 * @param {KeyboardEvent} event Keypress or keydown event to interpret. 41945 */ 41946 function startTypingInTextField(event) { 41947 const { 41948 type, 41949 target 41950 } = event; 41951 41952 // Abort early if already typing, or key press is incurred outside a 41953 // text field (e.g. arrow-ing through toolbar buttons). 41954 // Ignore typing if outside the current DOM container 41955 if (!(0,external_wp_dom_namespaceObject.isTextField)(target) || !node.contains(target)) { 41956 return; 41957 } 41958 41959 // Special-case keydown because certain keys do not emit a keypress 41960 // event. Conversely avoid keydown as the canonical event since 41961 // there are many keydown which are explicitly not targeted for 41962 // typing. 41963 if (type === 'keydown' && !isKeyDownEligibleForStartTyping(event)) { 41964 return; 41965 } 41966 startTyping(); 41967 } 41968 node.addEventListener('keypress', startTypingInTextField); 41969 node.addEventListener('keydown', startTypingInTextField); 41970 return () => { 41971 node.removeEventListener('keypress', startTypingInTextField); 41972 node.removeEventListener('keydown', startTypingInTextField); 41973 }; 41974 }, [isTyping, startTyping, stopTyping]); 41975 return (0,external_wp_compose_namespaceObject.useMergeRefs)([ref1, ref2]); 41976 } 41977 function ObserveTyping({ 41978 children 41979 }) { 41980 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 41981 ref: useTypingObserver(), 41982 children: children 41983 }); 41984 } 41985 41986 /** 41987 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/observe-typing/README.md 41988 */ 41989 /* harmony default export */ const observe_typing = (ObserveTyping); 41990 41991 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/zoom-out-separator.js 41992 /** 41993 * External dependencies 41994 */ 41995 41996 41997 /** 41998 * WordPress dependencies 41999 */ 42000 42001 42002 42003 42004 42005 42006 /** 42007 * Internal dependencies 42008 */ 42009 42010 42011 42012 function ZoomOutSeparator({ 42013 clientId, 42014 rootClientId = '', 42015 position = 'top' 42016 }) { 42017 const [isDraggedOver, setIsDraggedOver] = (0,external_wp_element_namespaceObject.useState)(false); 42018 const { 42019 sectionRootClientId, 42020 sectionClientIds, 42021 blockInsertionPoint, 42022 blockInsertionPointVisible 42023 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 42024 const { 42025 getBlockInsertionPoint, 42026 getBlockOrder, 42027 isBlockInsertionPointVisible, 42028 getSectionRootClientId 42029 } = unlock(select(store)); 42030 const root = getSectionRootClientId(); 42031 const sectionRootClientIds = getBlockOrder(root); 42032 return { 42033 sectionRootClientId: root, 42034 sectionClientIds: sectionRootClientIds, 42035 blockOrder: getBlockOrder(root), 42036 blockInsertionPoint: getBlockInsertionPoint(), 42037 blockInsertionPointVisible: isBlockInsertionPointVisible() 42038 }; 42039 }, []); 42040 const isReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)(); 42041 if (!clientId) { 42042 return; 42043 } 42044 let isVisible = false; 42045 const isSectionBlock = rootClientId === sectionRootClientId && sectionClientIds && sectionClientIds.includes(clientId); 42046 if (!isSectionBlock) { 42047 return null; 42048 } 42049 if (position === 'top') { 42050 isVisible = blockInsertionPointVisible && blockInsertionPoint.index === 0 && clientId === sectionClientIds[blockInsertionPoint.index]; 42051 } 42052 if (position === 'bottom') { 42053 isVisible = blockInsertionPointVisible && clientId === sectionClientIds[blockInsertionPoint.index - 1]; 42054 } 42055 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableAnimatePresence, { 42056 children: isVisible && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, { 42057 initial: { 42058 height: 0 42059 }, 42060 animate: { 42061 // Use a height equal to that of the zoom out frame size. 42062 height: 'calc(1.5 * var(--wp-block-editor-iframe-zoom-out-frame-size) / var(--wp-block-editor-iframe-zoom-out-scale)' 42063 }, 42064 exit: { 42065 height: 0 42066 }, 42067 transition: { 42068 type: 'tween', 42069 duration: isReducedMotion ? 0 : 0.2, 42070 ease: [0.6, 0, 0.4, 1] 42071 }, 42072 className: dist_clsx('block-editor-block-list__zoom-out-separator', { 42073 'is-dragged-over': isDraggedOver 42074 }), 42075 "data-is-insertion-point": "true", 42076 onDragOver: () => setIsDraggedOver(true), 42077 onDragLeave: () => setIsDraggedOver(false), 42078 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, { 42079 initial: { 42080 opacity: 0 42081 }, 42082 animate: { 42083 opacity: 1 42084 }, 42085 exit: { 42086 opacity: 0, 42087 transition: { 42088 delay: -0.125 42089 } 42090 }, 42091 transition: { 42092 ease: 'linear', 42093 duration: 0.1, 42094 delay: 0.125 42095 }, 42096 children: (0,external_wp_i18n_namespaceObject.__)('Drop pattern.') 42097 }) 42098 }) 42099 }); 42100 } 42101 42102 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/index.js 42103 /** 42104 * External dependencies 42105 */ 42106 42107 42108 /** 42109 * WordPress dependencies 42110 */ 42111 42112 42113 42114 42115 /** 42116 * Internal dependencies 42117 */ 42118 42119 42120 42121 42122 42123 42124 42125 42126 42127 42128 42129 42130 42131 const block_list_IntersectionObserver = (0,external_wp_element_namespaceObject.createContext)(); 42132 const pendingBlockVisibilityUpdatesPerRegistry = new WeakMap(); 42133 function Root({ 42134 className, 42135 ...settings 42136 }) { 42137 const isLargeViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium'); 42138 const { 42139 isOutlineMode, 42140 isFocusMode, 42141 editorMode, 42142 temporarilyEditingAsBlocks 42143 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 42144 const { 42145 getSettings, 42146 __unstableGetEditorMode, 42147 getTemporarilyEditingAsBlocks, 42148 isTyping 42149 } = unlock(select(store)); 42150 const { 42151 outlineMode, 42152 focusMode 42153 } = getSettings(); 42154 return { 42155 isOutlineMode: outlineMode && !isTyping(), 42156 isFocusMode: focusMode, 42157 editorMode: __unstableGetEditorMode(), 42158 temporarilyEditingAsBlocks: getTemporarilyEditingAsBlocks() 42159 }; 42160 }, []); 42161 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 42162 const { 42163 setBlockVisibility 42164 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 42165 const delayedBlockVisibilityUpdates = (0,external_wp_compose_namespaceObject.useDebounce)((0,external_wp_element_namespaceObject.useCallback)(() => { 42166 const updates = {}; 42167 pendingBlockVisibilityUpdatesPerRegistry.get(registry).forEach(([id, isIntersecting]) => { 42168 updates[id] = isIntersecting; 42169 }); 42170 setBlockVisibility(updates); 42171 }, [registry]), 300, { 42172 trailing: true 42173 }); 42174 const intersectionObserver = (0,external_wp_element_namespaceObject.useMemo)(() => { 42175 const { 42176 IntersectionObserver: Observer 42177 } = window; 42178 if (!Observer) { 42179 return; 42180 } 42181 return new Observer(entries => { 42182 if (!pendingBlockVisibilityUpdatesPerRegistry.get(registry)) { 42183 pendingBlockVisibilityUpdatesPerRegistry.set(registry, []); 42184 } 42185 for (const entry of entries) { 42186 const clientId = entry.target.getAttribute('data-block'); 42187 pendingBlockVisibilityUpdatesPerRegistry.get(registry).push([clientId, entry.isIntersecting]); 42188 } 42189 delayedBlockVisibilityUpdates(); 42190 }); 42191 }, []); 42192 const innerBlocksProps = useInnerBlocksProps({ 42193 ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([useBlockSelectionClearer(), useInBetweenInserter(), useTypingObserver()]), 42194 className: dist_clsx('is-root-container', className, { 42195 'is-outline-mode': isOutlineMode, 42196 'is-focus-mode': isFocusMode && isLargeViewport, 42197 'is-navigate-mode': editorMode === 'navigation' 42198 }) 42199 }, settings); 42200 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(block_list_IntersectionObserver.Provider, { 42201 value: intersectionObserver, 42202 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 42203 ...innerBlocksProps 42204 }), !!temporarilyEditingAsBlocks && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(StopEditingAsBlocksOnOutsideSelect, { 42205 clientId: temporarilyEditingAsBlocks 42206 })] 42207 }); 42208 } 42209 function StopEditingAsBlocksOnOutsideSelect({ 42210 clientId 42211 }) { 42212 const { 42213 stopEditingAsBlocks 42214 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 42215 const isBlockOrDescendantSelected = (0,external_wp_data_namespaceObject.useSelect)(select => { 42216 const { 42217 isBlockSelected, 42218 hasSelectedInnerBlock 42219 } = select(store); 42220 return isBlockSelected(clientId) || hasSelectedInnerBlock(clientId, true); 42221 }, [clientId]); 42222 (0,external_wp_element_namespaceObject.useEffect)(() => { 42223 if (!isBlockOrDescendantSelected) { 42224 stopEditingAsBlocks(clientId); 42225 } 42226 }, [isBlockOrDescendantSelected, clientId, stopEditingAsBlocks]); 42227 return null; 42228 } 42229 function BlockList(settings) { 42230 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Provider, { 42231 value: DEFAULT_BLOCK_EDIT_CONTEXT, 42232 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Root, { 42233 ...settings 42234 }) 42235 }); 42236 } 42237 const block_list_EMPTY_ARRAY = []; 42238 const block_list_EMPTY_SET = new Set(); 42239 function Items({ 42240 placeholder, 42241 rootClientId, 42242 renderAppender: CustomAppender, 42243 __experimentalAppenderTagName, 42244 layout = defaultLayout 42245 }) { 42246 // Avoid passing CustomAppender to useSelect because it could be a new 42247 // function on every render. 42248 const hasAppender = CustomAppender !== false; 42249 const hasCustomAppender = !!CustomAppender; 42250 const { 42251 order, 42252 isZoomOut, 42253 selectedBlocks, 42254 visibleBlocks, 42255 shouldRenderAppender 42256 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 42257 const { 42258 getSettings, 42259 getBlockOrder, 42260 getSelectedBlockClientId, 42261 getSelectedBlockClientIds, 42262 __unstableGetVisibleBlocks, 42263 getTemplateLock, 42264 getBlockEditingMode, 42265 __unstableGetEditorMode 42266 } = select(store); 42267 const _order = getBlockOrder(rootClientId); 42268 if (getSettings().__unstableIsPreviewMode) { 42269 return { 42270 order: _order, 42271 selectedBlocks: block_list_EMPTY_ARRAY, 42272 visibleBlocks: block_list_EMPTY_SET 42273 }; 42274 } 42275 const selectedBlockClientId = getSelectedBlockClientId(); 42276 return { 42277 order: _order, 42278 selectedBlocks: getSelectedBlockClientIds(), 42279 visibleBlocks: __unstableGetVisibleBlocks(), 42280 isZoomOut: __unstableGetEditorMode() === 'zoom-out', 42281 shouldRenderAppender: hasAppender && __unstableGetEditorMode() !== 'zoom-out' && (hasCustomAppender ? !getTemplateLock(rootClientId) && getBlockEditingMode(rootClientId) !== 'disabled' : rootClientId === selectedBlockClientId || !rootClientId && !selectedBlockClientId && !_order.length) 42282 }; 42283 }, [rootClientId, hasAppender, hasCustomAppender]); 42284 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(LayoutProvider, { 42285 value: layout, 42286 children: [order.map(clientId => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_data_namespaceObject.AsyncModeProvider, { 42287 value: 42288 // Only provide data asynchronously if the block is 42289 // not visible and not selected. 42290 !visibleBlocks.has(clientId) && !selectedBlocks.includes(clientId), 42291 children: [isZoomOut && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ZoomOutSeparator, { 42292 clientId: clientId, 42293 rootClientId: rootClientId, 42294 position: "top" 42295 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block, { 42296 rootClientId: rootClientId, 42297 clientId: clientId 42298 }), isZoomOut && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ZoomOutSeparator, { 42299 clientId: clientId, 42300 rootClientId: rootClientId, 42301 position: "bottom" 42302 })] 42303 }, clientId)), order.length < 1 && placeholder, shouldRenderAppender && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListAppender, { 42304 tagName: __experimentalAppenderTagName, 42305 rootClientId: rootClientId, 42306 CustomAppender: CustomAppender 42307 })] 42308 }); 42309 } 42310 function BlockListItems(props) { 42311 // This component needs to always be synchronous as it's the one changing 42312 // the async mode depending on the block selection. 42313 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_data_namespaceObject.AsyncModeProvider, { 42314 value: false, 42315 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Items, { 42316 ...props 42317 }) 42318 }); 42319 } 42320 42321 ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-multi-selection.js 42322 /** 42323 * WordPress dependencies 42324 */ 42325 42326 42327 42328 /** 42329 * Internal dependencies 42330 */ 42331 42332 function selector(select) { 42333 const { 42334 isMultiSelecting, 42335 getMultiSelectedBlockClientIds, 42336 hasMultiSelection, 42337 getSelectedBlockClientId, 42338 getSelectedBlocksInitialCaretPosition, 42339 __unstableIsFullySelected 42340 } = select(store); 42341 return { 42342 isMultiSelecting: isMultiSelecting(), 42343 multiSelectedBlockClientIds: getMultiSelectedBlockClientIds(), 42344 hasMultiSelection: hasMultiSelection(), 42345 selectedBlockClientId: getSelectedBlockClientId(), 42346 initialPosition: getSelectedBlocksInitialCaretPosition(), 42347 isFullSelection: __unstableIsFullySelected() 42348 }; 42349 } 42350 function useMultiSelection() { 42351 const { 42352 initialPosition, 42353 isMultiSelecting, 42354 multiSelectedBlockClientIds, 42355 hasMultiSelection, 42356 selectedBlockClientId, 42357 isFullSelection 42358 } = (0,external_wp_data_namespaceObject.useSelect)(selector, []); 42359 42360 /** 42361 * When the component updates, and there is multi selection, we need to 42362 * select the entire block contents. 42363 */ 42364 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 42365 const { 42366 ownerDocument 42367 } = node; 42368 const { 42369 defaultView 42370 } = ownerDocument; 42371 42372 // Allow initialPosition to bypass focus behavior. This is useful 42373 // for the list view or other areas where we don't want to transfer 42374 // focus to the editor canvas. 42375 if (initialPosition === undefined || initialPosition === null) { 42376 return; 42377 } 42378 if (!hasMultiSelection || isMultiSelecting) { 42379 return; 42380 } 42381 const { 42382 length 42383 } = multiSelectedBlockClientIds; 42384 if (length < 2) { 42385 return; 42386 } 42387 if (!isFullSelection) { 42388 return; 42389 } 42390 42391 // Allow cross contentEditable selection by temporarily making 42392 // all content editable. We can't rely on using the store and 42393 // React because re-rending happens too slowly. We need to be 42394 // able to select across instances immediately. 42395 node.contentEditable = true; 42396 42397 // For some browsers, like Safari, it is important that focus 42398 // happens BEFORE selection removal. 42399 node.focus(); 42400 defaultView.getSelection().removeAllRanges(); 42401 }, [hasMultiSelection, isMultiSelecting, multiSelectedBlockClientIds, selectedBlockClientId, initialPosition, isFullSelection]); 42402 } 42403 42404 ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-tab-nav.js 42405 /** 42406 * WordPress dependencies 42407 */ 42408 42409 42410 42411 42412 42413 42414 /** 42415 * Internal dependencies 42416 */ 42417 42418 42419 42420 42421 function useTabNav() { 42422 const container = (0,external_wp_element_namespaceObject.useRef)(); 42423 const focusCaptureBeforeRef = (0,external_wp_element_namespaceObject.useRef)(); 42424 const focusCaptureAfterRef = (0,external_wp_element_namespaceObject.useRef)(); 42425 const { 42426 hasMultiSelection, 42427 getSelectedBlockClientId, 42428 getBlockCount 42429 } = (0,external_wp_data_namespaceObject.useSelect)(store); 42430 const { 42431 setNavigationMode, 42432 setLastFocus 42433 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 42434 const isNavigationMode = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).isNavigationMode(), []); 42435 const { 42436 getLastFocus 42437 } = unlock((0,external_wp_data_namespaceObject.useSelect)(store)); 42438 42439 // Don't allow tabbing to this element in Navigation mode. 42440 const focusCaptureTabIndex = !isNavigationMode ? '0' : undefined; 42441 42442 // Reference that holds the a flag for enabling or disabling 42443 // capturing on the focus capture elements. 42444 const noCaptureRef = (0,external_wp_element_namespaceObject.useRef)(); 42445 function onFocusCapture(event) { 42446 // Do not capture incoming focus if set by us in WritingFlow. 42447 if (noCaptureRef.current) { 42448 noCaptureRef.current = null; 42449 } else if (hasMultiSelection()) { 42450 container.current.focus(); 42451 } else if (getSelectedBlockClientId()) { 42452 if (getLastFocus()?.current) { 42453 getLastFocus().current.focus(); 42454 } else { 42455 // Handles when the last focus has not been set yet, or has been cleared by new blocks being added via the inserter. 42456 container.current.querySelector(`[data-block="$getSelectedBlockClientId()}"]`).focus(); 42457 } 42458 } else { 42459 setNavigationMode(true); 42460 const canvasElement = container.current.ownerDocument === event.target.ownerDocument ? container.current : container.current.ownerDocument.defaultView.frameElement; 42461 const isBefore = 42462 // eslint-disable-next-line no-bitwise 42463 event.target.compareDocumentPosition(canvasElement) & event.target.DOCUMENT_POSITION_FOLLOWING; 42464 const tabbables = external_wp_dom_namespaceObject.focus.tabbable.find(container.current); 42465 if (tabbables.length) { 42466 const next = isBefore ? tabbables[0] : tabbables[tabbables.length - 1]; 42467 next.focus(); 42468 } 42469 } 42470 } 42471 const before = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 42472 ref: focusCaptureBeforeRef, 42473 tabIndex: focusCaptureTabIndex, 42474 onFocus: onFocusCapture 42475 }); 42476 const after = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 42477 ref: focusCaptureAfterRef, 42478 tabIndex: focusCaptureTabIndex, 42479 onFocus: onFocusCapture 42480 }); 42481 const ref = (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 42482 function onKeyDown(event) { 42483 if (event.defaultPrevented) { 42484 return; 42485 } 42486 if (event.keyCode === external_wp_keycodes_namespaceObject.ESCAPE && !hasMultiSelection()) { 42487 event.preventDefault(); 42488 setNavigationMode(true); 42489 return; 42490 } 42491 42492 // In Edit mode, Tab should focus the first tabbable element after 42493 // the content, which is normally the sidebar (with block controls) 42494 // and Shift+Tab should focus the first tabbable element before the 42495 // content, which is normally the block toolbar. 42496 // Arrow keys can be used, and Tab and arrow keys can be used in 42497 // Navigation mode (press Esc), to navigate through blocks. 42498 if (event.keyCode !== external_wp_keycodes_namespaceObject.TAB) { 42499 return; 42500 } 42501 const isShift = event.shiftKey; 42502 const direction = isShift ? 'findPrevious' : 'findNext'; 42503 if (!hasMultiSelection() && !getSelectedBlockClientId()) { 42504 // Preserve the behaviour of entering navigation mode when 42505 // tabbing into the content without a block selection. 42506 // `onFocusCapture` already did this previously, but we need to 42507 // do it again here because after clearing block selection, 42508 // focus land on the writing flow container and pressing Tab 42509 // will no longer send focus through the focus capture element. 42510 if (event.target === node) { 42511 setNavigationMode(true); 42512 } 42513 return; 42514 } 42515 const nextTabbable = external_wp_dom_namespaceObject.focus.tabbable[direction](event.target); 42516 42517 // We want to constrain the tabbing to the block and its child blocks. 42518 // If the preceding form element is within a different block, 42519 // such as two sibling image blocks in the placeholder state, 42520 // we want shift + tab from the first form element to move to the image 42521 // block toolbar and not the previous image block's form element. 42522 const currentBlock = event.target.closest('[data-block]'); 42523 const isElementPartOfSelectedBlock = currentBlock && nextTabbable && (isInSameBlock(currentBlock, nextTabbable) || isInsideRootBlock(currentBlock, nextTabbable)); 42524 42525 // Allow tabbing from the block wrapper to a form element, 42526 // and between form elements rendered in a block and its child blocks, 42527 // such as inside a placeholder. Form elements are generally 42528 // meant to be UI rather than part of the content. Ideally 42529 // these are not rendered in the content and perhaps in the 42530 // future they can be rendered in an iframe or shadow DOM. 42531 if ((0,external_wp_dom_namespaceObject.isFormElement)(nextTabbable) && isElementPartOfSelectedBlock) { 42532 return; 42533 } 42534 const next = isShift ? focusCaptureBeforeRef : focusCaptureAfterRef; 42535 42536 // Disable focus capturing on the focus capture element, so it 42537 // doesn't refocus this block and so it allows default behaviour 42538 // (moving focus to the next tabbable element). 42539 noCaptureRef.current = true; 42540 42541 // Focusing the focus capture element, which is located above and 42542 // below the editor, should not scroll the page all the way up or 42543 // down. 42544 next.current.focus({ 42545 preventScroll: true 42546 }); 42547 } 42548 function onFocusOut(event) { 42549 setLastFocus({ 42550 ...getLastFocus(), 42551 current: event.target 42552 }); 42553 const { 42554 ownerDocument 42555 } = node; 42556 42557 // If focus disappears due to there being no blocks, move focus to 42558 // the writing flow wrapper. 42559 if (!event.relatedTarget && ownerDocument.activeElement === ownerDocument.body && getBlockCount() === 0) { 42560 node.focus(); 42561 } 42562 } 42563 42564 // When tabbing back to an element in block list, this event handler prevents scrolling if the 42565 // focus capture divs (before/after) are outside of the viewport. (For example shift+tab back to a paragraph 42566 // when focus is on a sidebar element. This prevents the scrollable writing area from jumping either to the 42567 // top or bottom of the document. 42568 // 42569 // Note that it isn't possible to disable scrolling in the onFocus event. We need to intercept this 42570 // earlier in the keypress handler, and call focus( { preventScroll: true } ) instead. 42571 // https://developer.mozilla.org/en-US/docs/Web/API/HTMLOrForeignElement/focus#parameters 42572 function preventScrollOnTab(event) { 42573 if (event.keyCode !== external_wp_keycodes_namespaceObject.TAB) { 42574 return; 42575 } 42576 if (event.target?.getAttribute('role') === 'region') { 42577 return; 42578 } 42579 if (container.current === event.target) { 42580 return; 42581 } 42582 const isShift = event.shiftKey; 42583 const direction = isShift ? 'findPrevious' : 'findNext'; 42584 const target = external_wp_dom_namespaceObject.focus.tabbable[direction](event.target); 42585 // Only do something when the next tabbable is a focus capture div (before/after) 42586 if (target === focusCaptureBeforeRef.current || target === focusCaptureAfterRef.current) { 42587 event.preventDefault(); 42588 target.focus({ 42589 preventScroll: true 42590 }); 42591 } 42592 } 42593 const { 42594 ownerDocument 42595 } = node; 42596 const { 42597 defaultView 42598 } = ownerDocument; 42599 defaultView.addEventListener('keydown', preventScrollOnTab); 42600 node.addEventListener('keydown', onKeyDown); 42601 node.addEventListener('focusout', onFocusOut); 42602 return () => { 42603 defaultView.removeEventListener('keydown', preventScrollOnTab); 42604 node.removeEventListener('keydown', onKeyDown); 42605 node.removeEventListener('focusout', onFocusOut); 42606 }; 42607 }, []); 42608 const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([container, ref]); 42609 return [before, mergedRefs, after]; 42610 } 42611 42612 ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-arrow-nav.js 42613 /** 42614 * WordPress dependencies 42615 */ 42616 42617 42618 42619 42620 42621 /** 42622 * Internal dependencies 42623 */ 42624 42625 42626 42627 /** 42628 * Returns true if the element should consider edge navigation upon a keyboard 42629 * event of the given directional key code, or false otherwise. 42630 * 42631 * @param {Element} element HTML element to test. 42632 * @param {number} keyCode KeyboardEvent keyCode to test. 42633 * @param {boolean} hasModifier Whether a modifier is pressed. 42634 * 42635 * @return {boolean} Whether element should consider edge navigation. 42636 */ 42637 function isNavigationCandidate(element, keyCode, hasModifier) { 42638 const isVertical = keyCode === external_wp_keycodes_namespaceObject.UP || keyCode === external_wp_keycodes_namespaceObject.DOWN; 42639 const { 42640 tagName 42641 } = element; 42642 const elementType = element.getAttribute('type'); 42643 42644 // Native inputs should not navigate vertically, unless they are simple types that don't need up/down arrow keys. 42645 if (isVertical && !hasModifier) { 42646 if (tagName === 'INPUT') { 42647 const verticalInputTypes = ['date', 'datetime-local', 'month', 'number', 'range', 'time', 'week']; 42648 return !verticalInputTypes.includes(elementType); 42649 } 42650 return true; 42651 } 42652 42653 // Native inputs should not navigate horizontally, unless they are simple types that don't need left/right arrow keys. 42654 if (tagName === 'INPUT') { 42655 const simpleInputTypes = ['button', 'checkbox', 'number', 'color', 'file', 'image', 'radio', 'reset', 'submit']; 42656 return simpleInputTypes.includes(elementType); 42657 } 42658 42659 // Native textareas should not navigate horizontally. 42660 return tagName !== 'TEXTAREA'; 42661 } 42662 42663 /** 42664 * Returns the optimal tab target from the given focused element in the desired 42665 * direction. A preference is made toward text fields, falling back to the block 42666 * focus stop if no other candidates exist for the block. 42667 * 42668 * @param {Element} target Currently focused text field. 42669 * @param {boolean} isReverse True if considering as the first field. 42670 * @param {Element} containerElement Element containing all blocks. 42671 * @param {boolean} onlyVertical Whether to only consider tabbable elements 42672 * that are visually above or under the 42673 * target. 42674 * 42675 * @return {?Element} Optimal tab target, if one exists. 42676 */ 42677 function getClosestTabbable(target, isReverse, containerElement, onlyVertical) { 42678 // Since the current focus target is not guaranteed to be a text field, find 42679 // all focusables. Tabbability is considered later. 42680 let focusableNodes = external_wp_dom_namespaceObject.focus.focusable.find(containerElement); 42681 if (isReverse) { 42682 focusableNodes.reverse(); 42683 } 42684 42685 // Consider as candidates those focusables after the current target. It's 42686 // assumed this can only be reached if the target is focusable (on its 42687 // keydown event), so no need to verify it exists in the set. 42688 focusableNodes = focusableNodes.slice(focusableNodes.indexOf(target) + 1); 42689 let targetRect; 42690 if (onlyVertical) { 42691 targetRect = target.getBoundingClientRect(); 42692 } 42693 function isTabCandidate(node) { 42694 if (node.closest('[inert]')) { 42695 return; 42696 } 42697 42698 // Skip if there's only one child that is content editable (and thus a 42699 // better candidate). 42700 if (node.children.length === 1 && isInSameBlock(node, node.firstElementChild) && node.firstElementChild.getAttribute('contenteditable') === 'true') { 42701 return; 42702 } 42703 42704 // Not a candidate if the node is not tabbable. 42705 if (!external_wp_dom_namespaceObject.focus.tabbable.isTabbableIndex(node)) { 42706 return false; 42707 } 42708 42709 // Skip focusable elements such as links within content editable nodes. 42710 if (node.isContentEditable && node.contentEditable !== 'true') { 42711 return false; 42712 } 42713 if (onlyVertical) { 42714 const nodeRect = node.getBoundingClientRect(); 42715 if (nodeRect.left >= targetRect.right || nodeRect.right <= targetRect.left) { 42716 return false; 42717 } 42718 } 42719 return true; 42720 } 42721 return focusableNodes.find(isTabCandidate); 42722 } 42723 function useArrowNav() { 42724 const { 42725 getMultiSelectedBlocksStartClientId, 42726 getMultiSelectedBlocksEndClientId, 42727 getSettings, 42728 hasMultiSelection, 42729 __unstableIsFullySelected 42730 } = (0,external_wp_data_namespaceObject.useSelect)(store); 42731 const { 42732 selectBlock 42733 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 42734 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 42735 // Here a DOMRect is stored while moving the caret vertically so 42736 // vertical position of the start position can be restored. This is to 42737 // recreate browser behaviour across blocks. 42738 let verticalRect; 42739 function onMouseDown() { 42740 verticalRect = null; 42741 } 42742 function isClosestTabbableABlock(target, isReverse) { 42743 const closestTabbable = getClosestTabbable(target, isReverse, node); 42744 return closestTabbable && getBlockClientId(closestTabbable); 42745 } 42746 function onKeyDown(event) { 42747 // Abort if navigation has already been handled (e.g. RichText 42748 // inline boundaries). 42749 if (event.defaultPrevented) { 42750 return; 42751 } 42752 const { 42753 keyCode, 42754 target, 42755 shiftKey, 42756 ctrlKey, 42757 altKey, 42758 metaKey 42759 } = event; 42760 const isUp = keyCode === external_wp_keycodes_namespaceObject.UP; 42761 const isDown = keyCode === external_wp_keycodes_namespaceObject.DOWN; 42762 const isLeft = keyCode === external_wp_keycodes_namespaceObject.LEFT; 42763 const isRight = keyCode === external_wp_keycodes_namespaceObject.RIGHT; 42764 const isReverse = isUp || isLeft; 42765 const isHorizontal = isLeft || isRight; 42766 const isVertical = isUp || isDown; 42767 const isNav = isHorizontal || isVertical; 42768 const hasModifier = shiftKey || ctrlKey || altKey || metaKey; 42769 const isNavEdge = isVertical ? external_wp_dom_namespaceObject.isVerticalEdge : external_wp_dom_namespaceObject.isHorizontalEdge; 42770 const { 42771 ownerDocument 42772 } = node; 42773 const { 42774 defaultView 42775 } = ownerDocument; 42776 if (!isNav) { 42777 return; 42778 } 42779 42780 // If there is a multi-selection, the arrow keys should collapse the 42781 // selection to the start or end of the selection. 42782 if (hasMultiSelection()) { 42783 if (shiftKey) { 42784 return; 42785 } 42786 42787 // Only handle if we have a full selection (not a native partial 42788 // selection). 42789 if (!__unstableIsFullySelected()) { 42790 return; 42791 } 42792 event.preventDefault(); 42793 if (isReverse) { 42794 selectBlock(getMultiSelectedBlocksStartClientId()); 42795 } else { 42796 selectBlock(getMultiSelectedBlocksEndClientId(), -1); 42797 } 42798 return; 42799 } 42800 42801 // Abort if our current target is not a candidate for navigation 42802 // (e.g. preserve native input behaviors). 42803 if (!isNavigationCandidate(target, keyCode, hasModifier)) { 42804 return; 42805 } 42806 42807 // When presing any key other than up or down, the initial vertical 42808 // position must ALWAYS be reset. The vertical position is saved so 42809 // it can be restored as well as possible on sebsequent vertical 42810 // arrow key presses. It may not always be possible to restore the 42811 // exact same position (such as at an empty line), so it wouldn't be 42812 // good to compute the position right before any vertical arrow key 42813 // press. 42814 if (!isVertical) { 42815 verticalRect = null; 42816 } else if (!verticalRect) { 42817 verticalRect = (0,external_wp_dom_namespaceObject.computeCaretRect)(defaultView); 42818 } 42819 42820 // In the case of RTL scripts, right means previous and left means 42821 // next, which is the exact reverse of LTR. 42822 const isReverseDir = (0,external_wp_dom_namespaceObject.isRTL)(target) ? !isReverse : isReverse; 42823 const { 42824 keepCaretInsideBlock 42825 } = getSettings(); 42826 if (shiftKey) { 42827 if (isClosestTabbableABlock(target, isReverse) && isNavEdge(target, isReverse)) { 42828 node.contentEditable = true; 42829 // Firefox doesn't automatically move focus. 42830 node.focus(); 42831 } 42832 } else if (isVertical && (0,external_wp_dom_namespaceObject.isVerticalEdge)(target, isReverse) && ( 42833 // When Alt is pressed, only intercept if the caret is also at 42834 // the horizontal edge. 42835 altKey ? (0,external_wp_dom_namespaceObject.isHorizontalEdge)(target, isReverseDir) : true) && !keepCaretInsideBlock) { 42836 const closestTabbable = getClosestTabbable(target, isReverse, node, true); 42837 if (closestTabbable) { 42838 (0,external_wp_dom_namespaceObject.placeCaretAtVerticalEdge)(closestTabbable, 42839 // When Alt is pressed, place the caret at the furthest 42840 // horizontal edge and the furthest vertical edge. 42841 altKey ? !isReverse : isReverse, altKey ? undefined : verticalRect); 42842 event.preventDefault(); 42843 } 42844 } else if (isHorizontal && defaultView.getSelection().isCollapsed && (0,external_wp_dom_namespaceObject.isHorizontalEdge)(target, isReverseDir) && !keepCaretInsideBlock) { 42845 const closestTabbable = getClosestTabbable(target, isReverseDir, node); 42846 (0,external_wp_dom_namespaceObject.placeCaretAtHorizontalEdge)(closestTabbable, isReverse); 42847 event.preventDefault(); 42848 } 42849 } 42850 node.addEventListener('mousedown', onMouseDown); 42851 node.addEventListener('keydown', onKeyDown); 42852 return () => { 42853 node.removeEventListener('mousedown', onMouseDown); 42854 node.removeEventListener('keydown', onKeyDown); 42855 }; 42856 }, []); 42857 } 42858 42859 ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-select-all.js 42860 /** 42861 * WordPress dependencies 42862 */ 42863 42864 42865 42866 42867 42868 /** 42869 * Internal dependencies 42870 */ 42871 42872 function useSelectAll() { 42873 const { 42874 getBlockOrder, 42875 getSelectedBlockClientIds, 42876 getBlockRootClientId 42877 } = (0,external_wp_data_namespaceObject.useSelect)(store); 42878 const { 42879 multiSelect, 42880 selectBlock 42881 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 42882 const isMatch = (0,external_wp_keyboardShortcuts_namespaceObject.__unstableUseShortcutEventMatch)(); 42883 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 42884 function onKeyDown(event) { 42885 if (!isMatch('core/block-editor/select-all', event)) { 42886 return; 42887 } 42888 const selectedClientIds = getSelectedBlockClientIds(); 42889 if (selectedClientIds.length < 2 && !(0,external_wp_dom_namespaceObject.isEntirelySelected)(event.target)) { 42890 return; 42891 } 42892 event.preventDefault(); 42893 const [firstSelectedClientId] = selectedClientIds; 42894 const rootClientId = getBlockRootClientId(firstSelectedClientId); 42895 const blockClientIds = getBlockOrder(rootClientId); 42896 42897 // If we have selected all sibling nested blocks, try selecting up a 42898 // level. See: https://github.com/WordPress/gutenberg/pull/31859/ 42899 if (selectedClientIds.length === blockClientIds.length) { 42900 if (rootClientId) { 42901 node.ownerDocument.defaultView.getSelection().removeAllRanges(); 42902 selectBlock(rootClientId); 42903 } 42904 return; 42905 } 42906 multiSelect(blockClientIds[0], blockClientIds[blockClientIds.length - 1]); 42907 } 42908 node.addEventListener('keydown', onKeyDown); 42909 return () => { 42910 node.removeEventListener('keydown', onKeyDown); 42911 }; 42912 }, []); 42913 } 42914 42915 ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-drag-selection.js 42916 /** 42917 * WordPress dependencies 42918 */ 42919 42920 42921 42922 /** 42923 * Internal dependencies 42924 */ 42925 42926 42927 /** 42928 * Sets the `contenteditable` wrapper element to `value`. 42929 * 42930 * @param {HTMLElement} node Block element. 42931 * @param {boolean} value `contentEditable` value (true or false) 42932 */ 42933 function setContentEditableWrapper(node, value) { 42934 node.contentEditable = value; 42935 // Firefox doesn't automatically move focus. 42936 if (value) { 42937 node.focus(); 42938 } 42939 } 42940 42941 /** 42942 * Sets a multi-selection based on the native selection across blocks. 42943 */ 42944 function useDragSelection() { 42945 const { 42946 startMultiSelect, 42947 stopMultiSelect 42948 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 42949 const { 42950 isSelectionEnabled, 42951 hasSelectedBlock, 42952 isDraggingBlocks, 42953 isMultiSelecting 42954 } = (0,external_wp_data_namespaceObject.useSelect)(store); 42955 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 42956 const { 42957 ownerDocument 42958 } = node; 42959 const { 42960 defaultView 42961 } = ownerDocument; 42962 let anchorElement; 42963 let rafId; 42964 function onMouseUp() { 42965 stopMultiSelect(); 42966 // Equivalent to attaching the listener once. 42967 defaultView.removeEventListener('mouseup', onMouseUp); 42968 // The browser selection won't have updated yet at this point, 42969 // so wait until the next animation frame to get the browser 42970 // selection. 42971 rafId = defaultView.requestAnimationFrame(() => { 42972 if (!hasSelectedBlock()) { 42973 return; 42974 } 42975 42976 // If the selection is complete (on mouse up), and no 42977 // multiple blocks have been selected, set focus back to the 42978 // anchor element. if the anchor element contains the 42979 // selection. Additionally, the contentEditable wrapper can 42980 // now be disabled again. 42981 setContentEditableWrapper(node, false); 42982 const selection = defaultView.getSelection(); 42983 if (selection.rangeCount) { 42984 const range = selection.getRangeAt(0); 42985 const { 42986 commonAncestorContainer 42987 } = range; 42988 const clonedRange = range.cloneRange(); 42989 if (anchorElement.contains(commonAncestorContainer)) { 42990 anchorElement.focus(); 42991 selection.removeAllRanges(); 42992 selection.addRange(clonedRange); 42993 } 42994 } 42995 }); 42996 } 42997 function onMouseLeave({ 42998 buttons, 42999 target, 43000 relatedTarget 43001 }) { 43002 // If we're moving into a child element, ignore. We're tracking 43003 // the mouse leaving the element to a parent, no a child. 43004 if (target.contains(relatedTarget)) { 43005 return; 43006 } 43007 43008 // Avoid triggering a multi-selection if the user is already 43009 // dragging blocks. 43010 if (isDraggingBlocks()) { 43011 return; 43012 } 43013 43014 // The primary button must be pressed to initiate selection. 43015 // See https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons 43016 if (buttons !== 1) { 43017 return; 43018 } 43019 43020 // Abort if we are already multi-selecting. 43021 if (isMultiSelecting()) { 43022 return; 43023 } 43024 43025 // Abort if selection is leaving writing flow. 43026 if (node === target) { 43027 return; 43028 } 43029 43030 // Check the attribute, not the contentEditable attribute. All 43031 // child elements of the content editable wrapper are editable 43032 // and return true for this property. We only want to start 43033 // multi selecting when the mouse leaves the wrapper. 43034 if (target.getAttribute('contenteditable') !== 'true') { 43035 return; 43036 } 43037 if (!isSelectionEnabled()) { 43038 return; 43039 } 43040 43041 // Do not rely on the active element because it may change after 43042 // the mouse leaves for the first time. See 43043 // https://github.com/WordPress/gutenberg/issues/48747. 43044 anchorElement = target; 43045 startMultiSelect(); 43046 43047 // `onSelectionStart` is called after `mousedown` and 43048 // `mouseleave` (from a block). The selection ends when 43049 // `mouseup` happens anywhere in the window. 43050 defaultView.addEventListener('mouseup', onMouseUp); 43051 43052 // Allow cross contentEditable selection by temporarily making 43053 // all content editable. We can't rely on using the store and 43054 // React because re-rending happens too slowly. We need to be 43055 // able to select across instances immediately. 43056 setContentEditableWrapper(node, true); 43057 } 43058 node.addEventListener('mouseout', onMouseLeave); 43059 return () => { 43060 node.removeEventListener('mouseout', onMouseLeave); 43061 defaultView.removeEventListener('mouseup', onMouseUp); 43062 defaultView.cancelAnimationFrame(rafId); 43063 }; 43064 }, [startMultiSelect, stopMultiSelect, isSelectionEnabled, hasSelectedBlock]); 43065 } 43066 43067 ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-selection-observer.js 43068 /** 43069 * WordPress dependencies 43070 */ 43071 43072 43073 43074 43075 43076 /** 43077 * Internal dependencies 43078 */ 43079 43080 43081 43082 /** 43083 * Extract the selection start node from the selection. When the anchor node is 43084 * not a text node, the selection offset is the index of a child node. 43085 * 43086 * @param {Selection} selection The selection. 43087 * 43088 * @return {Element} The selection start node. 43089 */ 43090 function extractSelectionStartNode(selection) { 43091 const { 43092 anchorNode, 43093 anchorOffset 43094 } = selection; 43095 if (anchorNode.nodeType === anchorNode.TEXT_NODE) { 43096 return anchorNode; 43097 } 43098 if (anchorOffset === 0) { 43099 return anchorNode; 43100 } 43101 return anchorNode.childNodes[anchorOffset - 1]; 43102 } 43103 43104 /** 43105 * Extract the selection end node from the selection. When the focus node is not 43106 * a text node, the selection offset is the index of a child node. The selection 43107 * reaches up to but excluding that child node. 43108 * 43109 * @param {Selection} selection The selection. 43110 * 43111 * @return {Element} The selection start node. 43112 */ 43113 function extractSelectionEndNode(selection) { 43114 const { 43115 focusNode, 43116 focusOffset 43117 } = selection; 43118 if (focusNode.nodeType === focusNode.TEXT_NODE) { 43119 return focusNode; 43120 } 43121 if (focusOffset === focusNode.childNodes.length) { 43122 return focusNode; 43123 } 43124 43125 // When the selection is forward (the selection ends with the focus node), 43126 // the selection may extend into the next element with an offset of 0. This 43127 // may trigger multi selection even though the selection does not visually 43128 // end in the next block. 43129 if (focusOffset === 0 && (0,external_wp_dom_namespaceObject.isSelectionForward)(selection)) { 43130 var _focusNode$previousSi; 43131 return (_focusNode$previousSi = focusNode.previousSibling) !== null && _focusNode$previousSi !== void 0 ? _focusNode$previousSi : focusNode.parentElement; 43132 } 43133 return focusNode.childNodes[focusOffset]; 43134 } 43135 function findDepth(a, b) { 43136 let depth = 0; 43137 while (a[depth] === b[depth]) { 43138 depth++; 43139 } 43140 return depth; 43141 } 43142 43143 /** 43144 * Sets the `contenteditable` wrapper element to `value`. 43145 * 43146 * @param {HTMLElement} node Block element. 43147 * @param {boolean} value `contentEditable` value (true or false) 43148 */ 43149 function use_selection_observer_setContentEditableWrapper(node, value) { 43150 // Since we are calling this on every selection change, check if the value 43151 // needs to be updated first because it trigger the browser to recalculate 43152 // style. 43153 if (node.contentEditable !== String(value)) { 43154 node.contentEditable = value; 43155 43156 // Firefox doesn't automatically move focus. 43157 if (value) { 43158 node.focus(); 43159 } 43160 } 43161 } 43162 function getRichTextElement(node) { 43163 const element = node.nodeType === node.ELEMENT_NODE ? node : node.parentElement; 43164 return element?.closest('[data-wp-block-attribute-key]'); 43165 } 43166 43167 /** 43168 * Sets a multi-selection based on the native selection across blocks. 43169 */ 43170 function useSelectionObserver() { 43171 const { 43172 multiSelect, 43173 selectBlock, 43174 selectionChange 43175 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 43176 const { 43177 getBlockParents, 43178 getBlockSelectionStart, 43179 isMultiSelecting 43180 } = (0,external_wp_data_namespaceObject.useSelect)(store); 43181 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 43182 const { 43183 ownerDocument 43184 } = node; 43185 const { 43186 defaultView 43187 } = ownerDocument; 43188 function onSelectionChange(event) { 43189 const selection = defaultView.getSelection(); 43190 if (!selection.rangeCount) { 43191 return; 43192 } 43193 const startNode = extractSelectionStartNode(selection); 43194 const endNode = extractSelectionEndNode(selection); 43195 if (!node.contains(startNode) || !node.contains(endNode)) { 43196 return; 43197 } 43198 43199 // If selection is collapsed and we haven't used `shift+click`, 43200 // end multi selection and disable the contentEditable wrapper. 43201 // We have to check about `shift+click` case because elements 43202 // that don't support text selection might be involved, and we might 43203 // update the clientIds to multi-select blocks. 43204 // For now we check if the event is a `mouse` event. 43205 const isClickShift = event.shiftKey && event.type === 'mouseup'; 43206 if (selection.isCollapsed && !isClickShift) { 43207 if (node.contentEditable === 'true' && !isMultiSelecting()) { 43208 use_selection_observer_setContentEditableWrapper(node, false); 43209 let element = startNode.nodeType === startNode.ELEMENT_NODE ? startNode : startNode.parentElement; 43210 element = element?.closest('[contenteditable]'); 43211 element?.focus(); 43212 } 43213 return; 43214 } 43215 let startClientId = getBlockClientId(startNode); 43216 let endClientId = getBlockClientId(endNode); 43217 43218 // If the selection has changed and we had pressed `shift+click`, 43219 // we need to check if in an element that doesn't support 43220 // text selection has been clicked. 43221 if (isClickShift) { 43222 const selectedClientId = getBlockSelectionStart(); 43223 const clickedClientId = getBlockClientId(event.target); 43224 // `endClientId` is not defined if we end the selection by clicking a non-selectable block. 43225 // We need to check if there was already a selection with a non-selectable focusNode. 43226 const focusNodeIsNonSelectable = clickedClientId !== endClientId; 43227 if (startClientId === endClientId && selection.isCollapsed || !endClientId || focusNodeIsNonSelectable) { 43228 endClientId = clickedClientId; 43229 } 43230 // Handle the case when we have a non-selectable block 43231 // selected and click another one. 43232 if (startClientId !== selectedClientId) { 43233 startClientId = selectedClientId; 43234 } 43235 } 43236 43237 // If the selection did not involve a block, return. 43238 if (startClientId === undefined && endClientId === undefined) { 43239 use_selection_observer_setContentEditableWrapper(node, false); 43240 return; 43241 } 43242 const isSingularSelection = startClientId === endClientId; 43243 if (isSingularSelection) { 43244 if (!isMultiSelecting()) { 43245 selectBlock(startClientId); 43246 } else { 43247 multiSelect(startClientId, startClientId); 43248 } 43249 } else { 43250 const startPath = [...getBlockParents(startClientId), startClientId]; 43251 const endPath = [...getBlockParents(endClientId), endClientId]; 43252 const depth = findDepth(startPath, endPath); 43253 if (startPath[depth] !== startClientId || endPath[depth] !== endClientId) { 43254 multiSelect(startPath[depth], endPath[depth]); 43255 return; 43256 } 43257 const richTextElementStart = getRichTextElement(startNode); 43258 const richTextElementEnd = getRichTextElement(endNode); 43259 if (richTextElementStart && richTextElementEnd) { 43260 var _richTextDataStart$st, _richTextDataEnd$star; 43261 const range = selection.getRangeAt(0); 43262 const richTextDataStart = (0,external_wp_richText_namespaceObject.create)({ 43263 element: richTextElementStart, 43264 range, 43265 __unstableIsEditableTree: true 43266 }); 43267 const richTextDataEnd = (0,external_wp_richText_namespaceObject.create)({ 43268 element: richTextElementEnd, 43269 range, 43270 __unstableIsEditableTree: true 43271 }); 43272 const startOffset = (_richTextDataStart$st = richTextDataStart.start) !== null && _richTextDataStart$st !== void 0 ? _richTextDataStart$st : richTextDataStart.end; 43273 const endOffset = (_richTextDataEnd$star = richTextDataEnd.start) !== null && _richTextDataEnd$star !== void 0 ? _richTextDataEnd$star : richTextDataEnd.end; 43274 selectionChange({ 43275 start: { 43276 clientId: startClientId, 43277 attributeKey: richTextElementStart.dataset.wpBlockAttributeKey, 43278 offset: startOffset 43279 }, 43280 end: { 43281 clientId: endClientId, 43282 attributeKey: richTextElementEnd.dataset.wpBlockAttributeKey, 43283 offset: endOffset 43284 } 43285 }); 43286 } else { 43287 multiSelect(startClientId, endClientId); 43288 } 43289 } 43290 } 43291 ownerDocument.addEventListener('selectionchange', onSelectionChange); 43292 defaultView.addEventListener('mouseup', onSelectionChange); 43293 return () => { 43294 ownerDocument.removeEventListener('selectionchange', onSelectionChange); 43295 defaultView.removeEventListener('mouseup', onSelectionChange); 43296 }; 43297 }, [multiSelect, selectBlock, selectionChange, getBlockParents]); 43298 } 43299 43300 ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-click-selection.js 43301 /** 43302 * WordPress dependencies 43303 */ 43304 43305 43306 43307 /** 43308 * Internal dependencies 43309 */ 43310 43311 43312 function useClickSelection() { 43313 const { 43314 selectBlock 43315 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 43316 const { 43317 isSelectionEnabled, 43318 getBlockSelectionStart, 43319 hasMultiSelection 43320 } = (0,external_wp_data_namespaceObject.useSelect)(store); 43321 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 43322 function onMouseDown(event) { 43323 // The main button. 43324 // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button 43325 if (!isSelectionEnabled() || event.button !== 0) { 43326 return; 43327 } 43328 const startClientId = getBlockSelectionStart(); 43329 const clickedClientId = getBlockClientId(event.target); 43330 if (event.shiftKey) { 43331 if (startClientId !== clickedClientId) { 43332 node.contentEditable = true; 43333 // Firefox doesn't automatically move focus. 43334 node.focus(); 43335 } 43336 } else if (hasMultiSelection()) { 43337 // Allow user to escape out of a multi-selection to a 43338 // singular selection of a block via click. This is handled 43339 // here since focus handling excludes blocks when there is 43340 // multiselection, as focus can be incurred by starting a 43341 // multiselection (focus moved to first block's multi- 43342 // controls). 43343 selectBlock(clickedClientId); 43344 } 43345 } 43346 node.addEventListener('mousedown', onMouseDown); 43347 return () => { 43348 node.removeEventListener('mousedown', onMouseDown); 43349 }; 43350 }, [selectBlock, isSelectionEnabled, getBlockSelectionStart, hasMultiSelection]); 43351 } 43352 43353 ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-input.js 43354 /** 43355 * WordPress dependencies 43356 */ 43357 43358 43359 43360 43361 43362 /** 43363 * Internal dependencies 43364 */ 43365 43366 43367 /** 43368 * Handles input for selections across blocks. 43369 */ 43370 function useInput() { 43371 const { 43372 __unstableIsFullySelected, 43373 getSelectedBlockClientIds, 43374 getSelectedBlockClientId, 43375 __unstableIsSelectionMergeable, 43376 hasMultiSelection, 43377 getBlockName, 43378 canInsertBlockType, 43379 getBlockRootClientId, 43380 getSelectionStart, 43381 getSelectionEnd, 43382 getBlockAttributes 43383 } = (0,external_wp_data_namespaceObject.useSelect)(store); 43384 const { 43385 replaceBlocks, 43386 __unstableSplitSelection, 43387 removeBlocks, 43388 __unstableDeleteSelection, 43389 __unstableExpandSelection, 43390 __unstableMarkAutomaticChange 43391 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 43392 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 43393 function onBeforeInput(event) { 43394 // If writing flow is editable, NEVER allow the browser to alter the 43395 // DOM. This will cause React errors (and the DOM should only be 43396 // altered in a controlled fashion). 43397 if (node.contentEditable === 'true') { 43398 event.preventDefault(); 43399 } 43400 } 43401 function onKeyDown(event) { 43402 if (event.defaultPrevented) { 43403 return; 43404 } 43405 if (!hasMultiSelection()) { 43406 if (event.keyCode === external_wp_keycodes_namespaceObject.ENTER) { 43407 if (event.shiftKey || __unstableIsFullySelected()) { 43408 return; 43409 } 43410 const clientId = getSelectedBlockClientId(); 43411 const blockName = getBlockName(clientId); 43412 const selectionStart = getSelectionStart(); 43413 const selectionEnd = getSelectionEnd(); 43414 if (selectionStart.attributeKey === selectionEnd.attributeKey) { 43415 const selectedAttributeValue = getBlockAttributes(clientId)[selectionStart.attributeKey]; 43416 const transforms = (0,external_wp_blocks_namespaceObject.getBlockTransforms)('from').filter(({ 43417 type 43418 }) => type === 'enter'); 43419 const transformation = (0,external_wp_blocks_namespaceObject.findTransform)(transforms, item => { 43420 return item.regExp.test(selectedAttributeValue); 43421 }); 43422 if (transformation) { 43423 replaceBlocks(clientId, transformation.transform({ 43424 content: selectedAttributeValue 43425 })); 43426 __unstableMarkAutomaticChange(); 43427 return; 43428 } 43429 } 43430 if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, 'splitting', false) && !event.__deprecatedOnSplit) { 43431 return; 43432 } 43433 43434 // Ensure template is not locked. 43435 if (canInsertBlockType(blockName, getBlockRootClientId(clientId))) { 43436 __unstableSplitSelection(); 43437 event.preventDefault(); 43438 } 43439 } 43440 return; 43441 } 43442 if (event.keyCode === external_wp_keycodes_namespaceObject.ENTER) { 43443 node.contentEditable = false; 43444 event.preventDefault(); 43445 if (__unstableIsFullySelected()) { 43446 replaceBlocks(getSelectedBlockClientIds(), (0,external_wp_blocks_namespaceObject.createBlock)((0,external_wp_blocks_namespaceObject.getDefaultBlockName)())); 43447 } else { 43448 __unstableSplitSelection(); 43449 } 43450 } else if (event.keyCode === external_wp_keycodes_namespaceObject.BACKSPACE || event.keyCode === external_wp_keycodes_namespaceObject.DELETE) { 43451 node.contentEditable = false; 43452 event.preventDefault(); 43453 if (__unstableIsFullySelected()) { 43454 removeBlocks(getSelectedBlockClientIds()); 43455 } else if (__unstableIsSelectionMergeable()) { 43456 __unstableDeleteSelection(event.keyCode === external_wp_keycodes_namespaceObject.DELETE); 43457 } else { 43458 __unstableExpandSelection(); 43459 } 43460 } else if ( 43461 // If key.length is longer than 1, it's a control key that doesn't 43462 // input anything. 43463 event.key.length === 1 && !(event.metaKey || event.ctrlKey)) { 43464 node.contentEditable = false; 43465 if (__unstableIsSelectionMergeable()) { 43466 __unstableDeleteSelection(event.keyCode === external_wp_keycodes_namespaceObject.DELETE); 43467 } else { 43468 event.preventDefault(); 43469 // Safari does not stop default behaviour with either 43470 // event.preventDefault() or node.contentEditable = false, so 43471 // remove the selection to stop browser manipulation. 43472 node.ownerDocument.defaultView.getSelection().removeAllRanges(); 43473 } 43474 } 43475 } 43476 function onCompositionStart(event) { 43477 if (!hasMultiSelection()) { 43478 return; 43479 } 43480 node.contentEditable = false; 43481 if (__unstableIsSelectionMergeable()) { 43482 __unstableDeleteSelection(); 43483 } else { 43484 event.preventDefault(); 43485 // Safari does not stop default behaviour with either 43486 // event.preventDefault() or node.contentEditable = false, so 43487 // remove the selection to stop browser manipulation. 43488 node.ownerDocument.defaultView.getSelection().removeAllRanges(); 43489 } 43490 } 43491 node.addEventListener('beforeinput', onBeforeInput); 43492 node.addEventListener('keydown', onKeyDown); 43493 node.addEventListener('compositionstart', onCompositionStart); 43494 return () => { 43495 node.removeEventListener('beforeinput', onBeforeInput); 43496 node.removeEventListener('keydown', onKeyDown); 43497 node.removeEventListener('compositionstart', onCompositionStart); 43498 }; 43499 }, []); 43500 } 43501 43502 ;// ./node_modules/@wordpress/block-editor/build-module/utils/use-notify-copy.js 43503 /** 43504 * WordPress dependencies 43505 */ 43506 43507 43508 43509 43510 43511 43512 /** 43513 * Internal dependencies 43514 */ 43515 43516 function useNotifyCopy() { 43517 const { 43518 getBlockName 43519 } = (0,external_wp_data_namespaceObject.useSelect)(store); 43520 const { 43521 getBlockType 43522 } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store); 43523 const { 43524 createSuccessNotice 43525 } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store); 43526 return (0,external_wp_element_namespaceObject.useCallback)((eventType, selectedBlockClientIds) => { 43527 let notice = ''; 43528 if (selectedBlockClientIds.length === 1) { 43529 const clientId = selectedBlockClientIds[0]; 43530 const title = getBlockType(getBlockName(clientId))?.title; 43531 notice = eventType === 'copy' ? (0,external_wp_i18n_namespaceObject.sprintf)( 43532 // Translators: Name of the block being copied, e.g. "Paragraph". 43533 (0,external_wp_i18n_namespaceObject.__)('Copied "%s" to clipboard.'), title) : (0,external_wp_i18n_namespaceObject.sprintf)( 43534 // Translators: Name of the block being cut, e.g. "Paragraph". 43535 (0,external_wp_i18n_namespaceObject.__)('Moved "%s" to clipboard.'), title); 43536 } else { 43537 notice = eventType === 'copy' ? (0,external_wp_i18n_namespaceObject.sprintf)( 43538 // Translators: %d: Number of blocks being copied. 43539 (0,external_wp_i18n_namespaceObject._n)('Copied %d block to clipboard.', 'Copied %d blocks to clipboard.', selectedBlockClientIds.length), selectedBlockClientIds.length) : (0,external_wp_i18n_namespaceObject.sprintf)( 43540 // Translators: %d: Number of blocks being cut. 43541 (0,external_wp_i18n_namespaceObject._n)('Moved %d block to clipboard.', 'Moved %d blocks to clipboard.', selectedBlockClientIds.length), selectedBlockClientIds.length); 43542 } 43543 createSuccessNotice(notice, { 43544 type: 'snackbar' 43545 }); 43546 }, []); 43547 } 43548 43549 ;// ./node_modules/@wordpress/block-editor/build-module/utils/pasting.js 43550 /** 43551 * WordPress dependencies 43552 */ 43553 43554 43555 /** 43556 * Normalizes a given string of HTML to remove the Windows-specific "Fragment" 43557 * comments and any preceding and trailing content. 43558 * 43559 * @param {string} html the html to be normalized 43560 * @return {string} the normalized html 43561 */ 43562 function removeWindowsFragments(html) { 43563 const startStr = '<!--StartFragment-->'; 43564 const startIdx = html.indexOf(startStr); 43565 if (startIdx > -1) { 43566 html = html.substring(startIdx + startStr.length); 43567 } else { 43568 // No point looking for EndFragment 43569 return html; 43570 } 43571 const endStr = '<!--EndFragment-->'; 43572 const endIdx = html.indexOf(endStr); 43573 if (endIdx > -1) { 43574 html = html.substring(0, endIdx); 43575 } 43576 return html; 43577 } 43578 43579 /** 43580 * Removes the charset meta tag inserted by Chromium. 43581 * See: 43582 * - https://github.com/WordPress/gutenberg/issues/33585 43583 * - https://bugs.chromium.org/p/chromium/issues/detail?id=1264616#c4 43584 * 43585 * @param {string} html the html to be stripped of the meta tag. 43586 * @return {string} the cleaned html 43587 */ 43588 function removeCharsetMetaTag(html) { 43589 const metaTag = `<meta charset='utf-8'>`; 43590 if (html.startsWith(metaTag)) { 43591 return html.slice(metaTag.length); 43592 } 43593 return html; 43594 } 43595 function getPasteEventData({ 43596 clipboardData 43597 }) { 43598 let plainText = ''; 43599 let html = ''; 43600 try { 43601 plainText = clipboardData.getData('text/plain'); 43602 html = clipboardData.getData('text/html'); 43603 } catch (error) { 43604 // Some browsers like UC Browser paste plain text by default and 43605 // don't support clipboardData at all, so allow default 43606 // behaviour. 43607 return; 43608 } 43609 43610 // Remove Windows-specific metadata appended within copied HTML text. 43611 html = removeWindowsFragments(html); 43612 43613 // Strip meta tag. 43614 html = removeCharsetMetaTag(html); 43615 const files = (0,external_wp_dom_namespaceObject.getFilesFromDataTransfer)(clipboardData); 43616 if (files.length && !shouldDismissPastedFiles(files, html)) { 43617 return { 43618 files 43619 }; 43620 } 43621 return { 43622 html, 43623 plainText, 43624 files: [] 43625 }; 43626 } 43627 43628 /** 43629 * Given a collection of DataTransfer files and HTML and plain text strings, 43630 * determine whether the files are to be dismissed in favor of the HTML. 43631 * 43632 * Certain office-type programs, like Microsoft Word or Apple Numbers, 43633 * will, upon copy, generate a screenshot of the content being copied and 43634 * attach it to the clipboard alongside the actual rich text that the user 43635 * sought to copy. In those cases, we should let Gutenberg handle the rich text 43636 * content and not the screenshot, since this allows Gutenberg to insert 43637 * meaningful blocks, like paragraphs, lists or even tables. 43638 * 43639 * @param {File[]} files File objects obtained from a paste event 43640 * @param {string} html HTML content obtained from a paste event 43641 * @return {boolean} True if the files should be dismissed 43642 */ 43643 function shouldDismissPastedFiles(files, html /*, plainText */) { 43644 // The question is only relevant when there is actual HTML content and when 43645 // there is exactly one image file. 43646 if (html && files?.length === 1 && files[0].type.indexOf('image/') === 0) { 43647 // A single <img> tag found in the HTML source suggests that the 43648 // content being pasted revolves around an image. Sometimes there are 43649 // other elements found, like <figure>, but we assume that the user's 43650 // intention is to paste the actual image file. 43651 const IMAGE_TAG = /<\s*img\b/gi; 43652 if (html.match(IMAGE_TAG)?.length !== 1) { 43653 return true; 43654 } 43655 43656 // Even when there is exactly one <img> tag in the HTML payload, we 43657 // choose to weed out local images, i.e. those whose source starts with 43658 // "file://". These payloads occur in specific configurations, such as 43659 // when copying an entire document from Microsoft Word, that contains 43660 // text and exactly one image, and pasting that content using Google 43661 // Chrome. 43662 const IMG_WITH_LOCAL_SRC = /<\s*img\b[^>]*\bsrc="file:\/\//i; 43663 if (html.match(IMG_WITH_LOCAL_SRC)) { 43664 return true; 43665 } 43666 } 43667 return false; 43668 } 43669 43670 ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/utils.js 43671 /** 43672 * WordPress dependencies 43673 */ 43674 43675 43676 43677 /** 43678 * Internal dependencies 43679 */ 43680 43681 43682 const requiresWrapperOnCopy = Symbol('requiresWrapperOnCopy'); 43683 43684 /** 43685 * Sets the clipboard data for the provided blocks, with both HTML and plain 43686 * text representations. 43687 * 43688 * @param {ClipboardEvent} event Clipboard event. 43689 * @param {WPBlock[]} blocks Blocks to set as clipboard data. 43690 * @param {Object} registry The registry to select from. 43691 */ 43692 function setClipboardBlocks(event, blocks, registry) { 43693 let _blocks = blocks; 43694 const [firstBlock] = blocks; 43695 if (firstBlock) { 43696 const firstBlockType = registry.select(external_wp_blocks_namespaceObject.store).getBlockType(firstBlock.name); 43697 if (firstBlockType[requiresWrapperOnCopy]) { 43698 const { 43699 getBlockRootClientId, 43700 getBlockName, 43701 getBlockAttributes 43702 } = registry.select(store); 43703 const wrapperBlockClientId = getBlockRootClientId(firstBlock.clientId); 43704 const wrapperBlockName = getBlockName(wrapperBlockClientId); 43705 if (wrapperBlockName) { 43706 _blocks = (0,external_wp_blocks_namespaceObject.createBlock)(wrapperBlockName, getBlockAttributes(wrapperBlockClientId), _blocks); 43707 } 43708 } 43709 } 43710 const serialized = (0,external_wp_blocks_namespaceObject.serialize)(_blocks); 43711 event.clipboardData.setData('text/plain', toPlainText(serialized)); 43712 event.clipboardData.setData('text/html', serialized); 43713 } 43714 43715 /** 43716 * Returns the blocks to be pasted from the clipboard event. 43717 * 43718 * @param {ClipboardEvent} event The clipboard event. 43719 * @param {boolean} canUserUseUnfilteredHTML Whether the user can or can't post unfiltered HTML. 43720 * @return {Array|string} A list of blocks or a string, depending on `handlerMode`. 43721 */ 43722 function getPasteBlocks(event, canUserUseUnfilteredHTML) { 43723 const { 43724 plainText, 43725 html, 43726 files 43727 } = getPasteEventData(event); 43728 let blocks = []; 43729 if (files.length) { 43730 const fromTransforms = (0,external_wp_blocks_namespaceObject.getBlockTransforms)('from'); 43731 blocks = files.reduce((accumulator, file) => { 43732 const transformation = (0,external_wp_blocks_namespaceObject.findTransform)(fromTransforms, transform => transform.type === 'files' && transform.isMatch([file])); 43733 if (transformation) { 43734 accumulator.push(transformation.transform([file])); 43735 } 43736 return accumulator; 43737 }, []).flat(); 43738 } else { 43739 blocks = (0,external_wp_blocks_namespaceObject.pasteHandler)({ 43740 HTML: html, 43741 plainText, 43742 mode: 'BLOCKS', 43743 canUserUseUnfilteredHTML 43744 }); 43745 } 43746 return blocks; 43747 } 43748 43749 /** 43750 * Given a string of HTML representing serialized blocks, returns the plain 43751 * text extracted after stripping the HTML of any tags and fixing line breaks. 43752 * 43753 * @param {string} html Serialized blocks. 43754 * @return {string} The plain-text content with any html removed. 43755 */ 43756 function toPlainText(html) { 43757 // Manually handle BR tags as line breaks prior to `stripHTML` call 43758 html = html.replace(/<br>/g, '\n'); 43759 const plainText = (0,external_wp_dom_namespaceObject.__unstableStripHTML)(html).trim(); 43760 43761 // Merge any consecutive line breaks 43762 return plainText.replace(/\n\n+/g, '\n\n'); 43763 } 43764 43765 ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-clipboard-handler.js 43766 /** 43767 * WordPress dependencies 43768 */ 43769 43770 43771 43772 43773 43774 /** 43775 * Internal dependencies 43776 */ 43777 43778 43779 43780 43781 function useClipboardHandler() { 43782 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 43783 const { 43784 getBlocksByClientId, 43785 getSelectedBlockClientIds, 43786 hasMultiSelection, 43787 getSettings, 43788 getBlockName, 43789 __unstableIsFullySelected, 43790 __unstableIsSelectionCollapsed, 43791 __unstableIsSelectionMergeable, 43792 __unstableGetSelectedBlocksWithPartialSelection, 43793 canInsertBlockType, 43794 getBlockRootClientId 43795 } = (0,external_wp_data_namespaceObject.useSelect)(store); 43796 const { 43797 flashBlock, 43798 removeBlocks, 43799 replaceBlocks, 43800 __unstableDeleteSelection, 43801 __unstableExpandSelection, 43802 __unstableSplitSelection 43803 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 43804 const notifyCopy = useNotifyCopy(); 43805 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 43806 function handler(event) { 43807 if (event.defaultPrevented) { 43808 // This was likely already handled in rich-text/use-paste-handler.js. 43809 return; 43810 } 43811 const selectedBlockClientIds = getSelectedBlockClientIds(); 43812 if (selectedBlockClientIds.length === 0) { 43813 return; 43814 } 43815 43816 // Let native copy/paste behaviour take over in input fields. 43817 // But always handle multiple selected blocks. 43818 if (!hasMultiSelection()) { 43819 const { 43820 target 43821 } = event; 43822 const { 43823 ownerDocument 43824 } = target; 43825 // If copying, only consider actual text selection as selection. 43826 // Otherwise, any focus on an input field is considered. 43827 const hasSelection = event.type === 'copy' || event.type === 'cut' ? (0,external_wp_dom_namespaceObject.documentHasUncollapsedSelection)(ownerDocument) : (0,external_wp_dom_namespaceObject.documentHasSelection)(ownerDocument) && !ownerDocument.activeElement.isContentEditable; 43828 43829 // Let native copy behaviour take over in input fields. 43830 if (hasSelection) { 43831 return; 43832 } 43833 } 43834 const { 43835 activeElement 43836 } = event.target.ownerDocument; 43837 if (!node.contains(activeElement)) { 43838 return; 43839 } 43840 const isSelectionMergeable = __unstableIsSelectionMergeable(); 43841 const shouldHandleWholeBlocks = __unstableIsSelectionCollapsed() || __unstableIsFullySelected(); 43842 const expandSelectionIsNeeded = !shouldHandleWholeBlocks && !isSelectionMergeable; 43843 if (event.type === 'copy' || event.type === 'cut') { 43844 event.preventDefault(); 43845 if (selectedBlockClientIds.length === 1) { 43846 flashBlock(selectedBlockClientIds[0]); 43847 } 43848 // If we have a partial selection that is not mergeable, just 43849 // expand the selection to the whole blocks. 43850 if (expandSelectionIsNeeded) { 43851 __unstableExpandSelection(); 43852 } else { 43853 notifyCopy(event.type, selectedBlockClientIds); 43854 let blocks; 43855 // Check if we have partial selection. 43856 if (shouldHandleWholeBlocks) { 43857 blocks = getBlocksByClientId(selectedBlockClientIds); 43858 } else { 43859 const [head, tail] = __unstableGetSelectedBlocksWithPartialSelection(); 43860 const inBetweenBlocks = getBlocksByClientId(selectedBlockClientIds.slice(1, selectedBlockClientIds.length - 1)); 43861 blocks = [head, ...inBetweenBlocks, tail]; 43862 } 43863 setClipboardBlocks(event, blocks, registry); 43864 } 43865 } 43866 if (event.type === 'cut') { 43867 // We need to also check if at the start we needed to 43868 // expand the selection, as in this point we might have 43869 // programmatically fully selected the blocks above. 43870 if (shouldHandleWholeBlocks && !expandSelectionIsNeeded) { 43871 removeBlocks(selectedBlockClientIds); 43872 } else { 43873 event.target.ownerDocument.activeElement.contentEditable = false; 43874 __unstableDeleteSelection(); 43875 } 43876 } else if (event.type === 'paste') { 43877 const { 43878 __experimentalCanUserUseUnfilteredHTML: canUserUseUnfilteredHTML 43879 } = getSettings(); 43880 const isInternal = event.clipboardData.getData('rich-text') === 'true'; 43881 if (isInternal) { 43882 return; 43883 } 43884 const { 43885 plainText, 43886 html, 43887 files 43888 } = getPasteEventData(event); 43889 const isFullySelected = __unstableIsFullySelected(); 43890 let blocks = []; 43891 if (files.length) { 43892 const fromTransforms = (0,external_wp_blocks_namespaceObject.getBlockTransforms)('from'); 43893 blocks = files.reduce((accumulator, file) => { 43894 const transformation = (0,external_wp_blocks_namespaceObject.findTransform)(fromTransforms, transform => transform.type === 'files' && transform.isMatch([file])); 43895 if (transformation) { 43896 accumulator.push(transformation.transform([file])); 43897 } 43898 return accumulator; 43899 }, []).flat(); 43900 } else { 43901 blocks = (0,external_wp_blocks_namespaceObject.pasteHandler)({ 43902 HTML: html, 43903 plainText, 43904 mode: isFullySelected ? 'BLOCKS' : 'AUTO', 43905 canUserUseUnfilteredHTML 43906 }); 43907 } 43908 43909 // Inline paste: let rich text handle it. 43910 if (typeof blocks === 'string') { 43911 return; 43912 } 43913 if (isFullySelected) { 43914 replaceBlocks(selectedBlockClientIds, blocks, blocks.length - 1, -1); 43915 event.preventDefault(); 43916 return; 43917 } 43918 43919 // If a block doesn't support splitting, let rich text paste 43920 // inline. 43921 if (!hasMultiSelection() && !(0,external_wp_blocks_namespaceObject.hasBlockSupport)(getBlockName(selectedBlockClientIds[0]), 'splitting', false) && !event.__deprecatedOnSplit) { 43922 return; 43923 } 43924 const [firstSelectedClientId] = selectedBlockClientIds; 43925 const rootClientId = getBlockRootClientId(firstSelectedClientId); 43926 const newBlocks = []; 43927 for (const block of blocks) { 43928 if (canInsertBlockType(block.name, rootClientId)) { 43929 newBlocks.push(block); 43930 } else { 43931 // If a block cannot be inserted in a root block, try 43932 // converting it to that root block type and insert the 43933 // inner blocks. 43934 // Example: paragraphs cannot be inserted into a list, 43935 // so convert the paragraphs to a list for list items. 43936 const rootBlockName = getBlockName(rootClientId); 43937 const switchedBlocks = block.name !== rootBlockName ? (0,external_wp_blocks_namespaceObject.switchToBlockType)(block, rootBlockName) : [block]; 43938 if (!switchedBlocks) { 43939 return; 43940 } 43941 for (const switchedBlock of switchedBlocks) { 43942 for (const innerBlock of switchedBlock.innerBlocks) { 43943 newBlocks.push(innerBlock); 43944 } 43945 } 43946 } 43947 } 43948 __unstableSplitSelection(newBlocks); 43949 event.preventDefault(); 43950 } 43951 } 43952 node.ownerDocument.addEventListener('copy', handler); 43953 node.ownerDocument.addEventListener('cut', handler); 43954 node.ownerDocument.addEventListener('paste', handler); 43955 return () => { 43956 node.ownerDocument.removeEventListener('copy', handler); 43957 node.ownerDocument.removeEventListener('cut', handler); 43958 node.ownerDocument.removeEventListener('paste', handler); 43959 }; 43960 }, []); 43961 } 43962 43963 ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/index.js 43964 /** 43965 * External dependencies 43966 */ 43967 43968 43969 /** 43970 * WordPress dependencies 43971 */ 43972 43973 43974 43975 43976 43977 /** 43978 * Internal dependencies 43979 */ 43980 43981 43982 43983 43984 43985 43986 43987 43988 43989 43990 43991 43992 43993 function useWritingFlow() { 43994 const [before, ref, after] = useTabNav(); 43995 const hasMultiSelection = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).hasMultiSelection(), []); 43996 return [before, (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, useClipboardHandler(), useInput(), useDragSelection(), useSelectionObserver(), useClickSelection(), useMultiSelection(), useSelectAll(), useArrowNav(), (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 43997 node.tabIndex = 0; 43998 if (!hasMultiSelection) { 43999 return; 44000 } 44001 node.classList.add('has-multi-selection'); 44002 node.setAttribute('aria-label', (0,external_wp_i18n_namespaceObject.__)('Multiple selected blocks')); 44003 return () => { 44004 node.classList.remove('has-multi-selection'); 44005 node.removeAttribute('aria-label'); 44006 }; 44007 }, [hasMultiSelection])]), after]; 44008 } 44009 function WritingFlow({ 44010 children, 44011 ...props 44012 }, forwardedRef) { 44013 const [before, ref, after] = useWritingFlow(); 44014 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 44015 children: [before, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 44016 ...props, 44017 ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, forwardedRef]), 44018 className: dist_clsx(props.className, 'block-editor-writing-flow'), 44019 children: children 44020 }), after] 44021 }); 44022 } 44023 44024 /** 44025 * Handles selection and navigation across blocks. This component should be 44026 * wrapped around BlockList. 44027 * 44028 * @param {Object} props Component properties. 44029 * @param {Element} props.children Children to be rendered. 44030 */ 44031 /* harmony default export */ const writing_flow = ((0,external_wp_element_namespaceObject.forwardRef)(WritingFlow)); 44032 44033 ;// ./node_modules/@wordpress/block-editor/build-module/components/iframe/get-compatibility-styles.js 44034 let compatibilityStyles = null; 44035 44036 /** 44037 * Returns a list of stylesheets that target the editor canvas. A stylesheet is 44038 * considered targetting the editor a canvas if it contains the 44039 * `editor-styles-wrapper`, `wp-block`, or `wp-block-*` class selectors. 44040 * 44041 * Ideally, this hook should be removed in the future and styles should be added 44042 * explicitly as editor styles. 44043 */ 44044 function getCompatibilityStyles() { 44045 if (compatibilityStyles) { 44046 return compatibilityStyles; 44047 } 44048 44049 // Only memoize the result once on load, since these stylesheets should not 44050 // change. 44051 compatibilityStyles = Array.from(document.styleSheets).reduce((accumulator, styleSheet) => { 44052 try { 44053 // May fail for external styles. 44054 // eslint-disable-next-line no-unused-expressions 44055 styleSheet.cssRules; 44056 } catch (e) { 44057 return accumulator; 44058 } 44059 const { 44060 ownerNode, 44061 cssRules 44062 } = styleSheet; 44063 44064 // Stylesheet is added by another stylesheet. See 44065 // https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet/ownerNode#notes. 44066 if (ownerNode === null) { 44067 return accumulator; 44068 } 44069 if (!cssRules) { 44070 return accumulator; 44071 } 44072 44073 // Don't try to add the reset styles, which were removed as a dependency 44074 // from `edit-blocks` for the iframe since we don't need to reset admin 44075 // styles. 44076 if (['wp-reset-editor-styles-css', 'wp-reset-editor-styles-rtl-css'].includes(ownerNode.id)) { 44077 return accumulator; 44078 } 44079 44080 // Don't try to add styles without ID. Styles enqueued via the WP dependency system will always have IDs. 44081 if (!ownerNode.id) { 44082 return accumulator; 44083 } 44084 function matchFromRules(_cssRules) { 44085 return Array.from(_cssRules).find(({ 44086 selectorText, 44087 conditionText, 44088 cssRules: __cssRules 44089 }) => { 44090 // If the rule is conditional then it will not have selector text. 44091 // Recurse into child CSS ruleset to determine selector eligibility. 44092 if (conditionText) { 44093 return matchFromRules(__cssRules); 44094 } 44095 return selectorText && (selectorText.includes('.editor-styles-wrapper') || selectorText.includes('.wp-block')); 44096 }); 44097 } 44098 if (matchFromRules(cssRules)) { 44099 const isInline = ownerNode.tagName === 'STYLE'; 44100 if (isInline) { 44101 // If the current target is inline, 44102 // it could be a dependency of an existing stylesheet. 44103 // Look for that dependency and add it BEFORE the current target. 44104 const mainStylesCssId = ownerNode.id.replace('-inline-css', '-css'); 44105 const mainStylesElement = document.getElementById(mainStylesCssId); 44106 if (mainStylesElement) { 44107 accumulator.push(mainStylesElement.cloneNode(true)); 44108 } 44109 } 44110 accumulator.push(ownerNode.cloneNode(true)); 44111 if (!isInline) { 44112 // If the current target is not inline, 44113 // we still look for inline styles that could be relevant for the current target. 44114 // If they exist, add them AFTER the current target. 44115 const inlineStylesCssId = ownerNode.id.replace('-css', '-inline-css'); 44116 const inlineStylesElement = document.getElementById(inlineStylesCssId); 44117 if (inlineStylesElement) { 44118 accumulator.push(inlineStylesElement.cloneNode(true)); 44119 } 44120 } 44121 } 44122 return accumulator; 44123 }, []); 44124 return compatibilityStyles; 44125 } 44126 44127 ;// ./node_modules/@wordpress/block-editor/build-module/components/iframe/index.js 44128 /* wp:polyfill */ 44129 /** 44130 * External dependencies 44131 */ 44132 44133 44134 /** 44135 * WordPress dependencies 44136 */ 44137 44138 44139 44140 44141 44142 44143 /** 44144 * Internal dependencies 44145 */ 44146 44147 44148 44149 44150 44151 44152 44153 function bubbleEvent(event, Constructor, frame) { 44154 const init = {}; 44155 for (const key in event) { 44156 init[key] = event[key]; 44157 } 44158 44159 // Check if the event is a MouseEvent generated within the iframe. 44160 // If so, adjust the coordinates to be relative to the position of 44161 // the iframe. This ensures that components such as Draggable 44162 // receive coordinates relative to the window, instead of relative 44163 // to the iframe. Without this, the Draggable event handler would 44164 // result in components "jumping" position as soon as the user 44165 // drags over the iframe. 44166 if (event instanceof frame.contentDocument.defaultView.MouseEvent) { 44167 const rect = frame.getBoundingClientRect(); 44168 init.clientX += rect.left; 44169 init.clientY += rect.top; 44170 } 44171 const newEvent = new Constructor(event.type, init); 44172 if (init.defaultPrevented) { 44173 newEvent.preventDefault(); 44174 } 44175 const cancelled = !frame.dispatchEvent(newEvent); 44176 if (cancelled) { 44177 event.preventDefault(); 44178 } 44179 } 44180 44181 /** 44182 * Bubbles some event types (keydown, keypress, and dragover) to parent document 44183 * document to ensure that the keyboard shortcuts and drag and drop work. 44184 * 44185 * Ideally, we should remove event bubbling in the future. Keyboard shortcuts 44186 * should be context dependent, e.g. actions on blocks like Cmd+A should not 44187 * work globally outside the block editor. 44188 * 44189 * @param {Document} iframeDocument Document to attach listeners to. 44190 */ 44191 function useBubbleEvents(iframeDocument) { 44192 return (0,external_wp_compose_namespaceObject.useRefEffect)(() => { 44193 const { 44194 defaultView 44195 } = iframeDocument; 44196 if (!defaultView) { 44197 return; 44198 } 44199 const { 44200 frameElement 44201 } = defaultView; 44202 const html = iframeDocument.documentElement; 44203 const eventTypes = ['dragover', 'mousemove']; 44204 const handlers = {}; 44205 for (const name of eventTypes) { 44206 handlers[name] = event => { 44207 const prototype = Object.getPrototypeOf(event); 44208 const constructorName = prototype.constructor.name; 44209 const Constructor = window[constructorName]; 44210 bubbleEvent(event, Constructor, frameElement); 44211 }; 44212 html.addEventListener(name, handlers[name]); 44213 } 44214 return () => { 44215 for (const name of eventTypes) { 44216 html.removeEventListener(name, handlers[name]); 44217 } 44218 }; 44219 }); 44220 } 44221 function Iframe({ 44222 contentRef, 44223 children, 44224 tabIndex = 0, 44225 scale = 1, 44226 frameSize = 0, 44227 readonly, 44228 forwardedRef: ref, 44229 title = (0,external_wp_i18n_namespaceObject.__)('Editor canvas'), 44230 ...props 44231 }) { 44232 const { 44233 resolvedAssets, 44234 isPreviewMode 44235 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 44236 const { 44237 getSettings 44238 } = select(store); 44239 const settings = getSettings(); 44240 return { 44241 resolvedAssets: settings.__unstableResolvedAssets, 44242 isPreviewMode: settings.__unstableIsPreviewMode 44243 }; 44244 }, []); 44245 const { 44246 styles = '', 44247 scripts = '' 44248 } = resolvedAssets; 44249 const [iframeDocument, setIframeDocument] = (0,external_wp_element_namespaceObject.useState)(); 44250 const initialContainerWidth = (0,external_wp_element_namespaceObject.useRef)(0); 44251 const [bodyClasses, setBodyClasses] = (0,external_wp_element_namespaceObject.useState)([]); 44252 const clearerRef = useBlockSelectionClearer(); 44253 const [before, writingFlowRef, after] = useWritingFlow(); 44254 const [contentResizeListener, { 44255 height: contentHeight 44256 }] = (0,external_wp_compose_namespaceObject.useResizeObserver)(); 44257 const [containerResizeListener, { 44258 width: containerWidth 44259 }] = (0,external_wp_compose_namespaceObject.useResizeObserver)(); 44260 const setRef = (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 44261 node._load = () => { 44262 setIframeDocument(node.contentDocument); 44263 }; 44264 let iFrameDocument; 44265 // Prevent the default browser action for files dropped outside of dropzones. 44266 function preventFileDropDefault(event) { 44267 event.preventDefault(); 44268 } 44269 function onLoad() { 44270 const { 44271 contentDocument, 44272 ownerDocument 44273 } = node; 44274 const { 44275 documentElement 44276 } = contentDocument; 44277 iFrameDocument = contentDocument; 44278 documentElement.classList.add('block-editor-iframe__html'); 44279 clearerRef(documentElement); 44280 44281 // Ideally ALL classes that are added through get_body_class should 44282 // be added in the editor too, which we'll somehow have to get from 44283 // the server in the future (which will run the PHP filters). 44284 setBodyClasses(Array.from(ownerDocument.body.classList).filter(name => name.startsWith('admin-color-') || name.startsWith('post-type-') || name === 'wp-embed-responsive')); 44285 contentDocument.dir = ownerDocument.dir; 44286 for (const compatStyle of getCompatibilityStyles()) { 44287 if (contentDocument.getElementById(compatStyle.id)) { 44288 continue; 44289 } 44290 contentDocument.head.appendChild(compatStyle.cloneNode(true)); 44291 if (!isPreviewMode) { 44292 // eslint-disable-next-line no-console 44293 console.warn(`$compatStyle.id} was added to the iframe incorrectly. Please use block.json or enqueue_block_assets to add styles to the iframe.`, compatStyle); 44294 } 44295 } 44296 iFrameDocument.addEventListener('dragover', preventFileDropDefault, false); 44297 iFrameDocument.addEventListener('drop', preventFileDropDefault, false); 44298 } 44299 node.addEventListener('load', onLoad); 44300 return () => { 44301 delete node._load; 44302 node.removeEventListener('load', onLoad); 44303 iFrameDocument?.removeEventListener('dragover', preventFileDropDefault); 44304 iFrameDocument?.removeEventListener('drop', preventFileDropDefault); 44305 }; 44306 }, []); 44307 const [iframeWindowInnerHeight, setIframeWindowInnerHeight] = (0,external_wp_element_namespaceObject.useState)(); 44308 const iframeResizeRef = (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 44309 const nodeWindow = node.ownerDocument.defaultView; 44310 setIframeWindowInnerHeight(nodeWindow.innerHeight); 44311 const onResize = () => { 44312 setIframeWindowInnerHeight(nodeWindow.innerHeight); 44313 }; 44314 nodeWindow.addEventListener('resize', onResize); 44315 return () => { 44316 nodeWindow.removeEventListener('resize', onResize); 44317 }; 44318 }, []); 44319 const [windowInnerWidth, setWindowInnerWidth] = (0,external_wp_element_namespaceObject.useState)(); 44320 const windowResizeRef = (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 44321 const nodeWindow = node.ownerDocument.defaultView; 44322 setWindowInnerWidth(nodeWindow.innerWidth); 44323 const onResize = () => { 44324 setWindowInnerWidth(nodeWindow.innerWidth); 44325 }; 44326 nodeWindow.addEventListener('resize', onResize); 44327 return () => { 44328 nodeWindow.removeEventListener('resize', onResize); 44329 }; 44330 }, []); 44331 const isZoomedOut = scale !== 1; 44332 (0,external_wp_element_namespaceObject.useEffect)(() => { 44333 if (!isZoomedOut) { 44334 initialContainerWidth.current = containerWidth; 44335 } 44336 }, [containerWidth, isZoomedOut]); 44337 const scaleContainerWidth = Math.max(initialContainerWidth.current, containerWidth); 44338 const disabledRef = (0,external_wp_compose_namespaceObject.useDisabled)({ 44339 isDisabled: !readonly 44340 }); 44341 const bodyRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([useBubbleEvents(iframeDocument), contentRef, clearerRef, writingFlowRef, disabledRef, 44342 // Avoid resize listeners when not needed, these will trigger 44343 // unnecessary re-renders when animating the iframe width, or when 44344 // expanding preview iframes. 44345 isZoomedOut ? iframeResizeRef : null]); 44346 44347 // Correct doctype is required to enable rendering in standards 44348 // mode. Also preload the styles to avoid a flash of unstyled 44349 // content. 44350 const html = `<!doctype html> 44351 <html> 44352 <head> 44353 <meta charset="utf-8"> 44354 <script>window.frameElement._load()</script> 44355 <style> 44356 html{ 44357 height: auto !important; 44358 min-height: 100%; 44359 } 44360 /* Lowest specificity to not override global styles */ 44361 :where(body) { 44362 margin: 0; 44363 /* Default background color in case zoom out mode background 44364 colors the html element */ 44365 background-color: white; 44366 } 44367 </style> 44368 $styles} 44369 $scripts} 44370 </head> 44371 <body> 44372 <script>document.currentScript.parentElement.remove()</script> 44373 </body> 44374 </html>`; 44375 const [src, cleanup] = (0,external_wp_element_namespaceObject.useMemo)(() => { 44376 const _src = URL.createObjectURL(new window.Blob([html], { 44377 type: 'text/html' 44378 })); 44379 return [_src, () => URL.revokeObjectURL(_src)]; 44380 }, [html]); 44381 (0,external_wp_element_namespaceObject.useEffect)(() => cleanup, [cleanup]); 44382 const zoomOutAnimationClassnameRef = (0,external_wp_element_namespaceObject.useRef)(null); 44383 44384 // Toggle zoom out CSS Classes only when zoom out mode changes. We could add these into the useEffect 44385 // that controls settings the CSS variables, but then we would need to do more work to ensure we're 44386 // only toggling these when the zoom out mode changes, as that useEffect is also triggered by a large 44387 // number of dependencies. 44388 (0,external_wp_element_namespaceObject.useEffect)(() => { 44389 if (!iframeDocument || !isZoomedOut) { 44390 return; 44391 } 44392 const handleZoomOutAnimationClassname = () => { 44393 clearTimeout(zoomOutAnimationClassnameRef.current); 44394 iframeDocument.documentElement.classList.add('zoom-out-animation'); 44395 zoomOutAnimationClassnameRef.current = setTimeout(() => { 44396 iframeDocument.documentElement.classList.remove('zoom-out-animation'); 44397 }, 400); // 400ms should match the animation speed used in components/iframe/content.scss 44398 }; 44399 handleZoomOutAnimationClassname(); 44400 iframeDocument.documentElement.classList.add('is-zoomed-out'); 44401 return () => { 44402 handleZoomOutAnimationClassname(); 44403 iframeDocument.documentElement.classList.remove('is-zoomed-out'); 44404 }; 44405 }, [iframeDocument, isZoomedOut]); 44406 44407 // Calculate the scaling and CSS variables for the zoom out canvas 44408 (0,external_wp_element_namespaceObject.useEffect)(() => { 44409 if (!iframeDocument || !isZoomedOut) { 44410 return; 44411 } 44412 const maxWidth = 750; 44413 // Note: When we initialize the zoom out when the canvas is smaller (sidebars open), 44414 // initialContainerWidth will be smaller than the full page, and reflow will happen 44415 // when the canvas area becomes larger due to sidebars closing. This is a known but 44416 // minor divergence for now. 44417 44418 // This scaling calculation has to happen within the JS because CSS calc() can 44419 // only divide and multiply by a unitless value. I.e. calc( 100px / 2 ) is valid 44420 // but calc( 100px / 2px ) is not. 44421 iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-scale', scale === 'default' ? (Math.min(containerWidth, maxWidth) - parseInt(frameSize) * 2) / scaleContainerWidth : scale); 44422 44423 // frameSize has to be a px value for the scaling and frame size to be computed correctly. 44424 iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-frame-size', typeof frameSize === 'number' ? `$frameSize}px` : frameSize); 44425 iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-content-height', `$contentHeight}px`); 44426 iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-inner-height', `$iframeWindowInnerHeight}px`); 44427 iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-container-width', `$containerWidth}px`); 44428 iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-scale-container-width', `$scaleContainerWidth}px`); 44429 return () => { 44430 iframeDocument.documentElement.style.removeProperty('--wp-block-editor-iframe-zoom-out-scale'); 44431 iframeDocument.documentElement.style.removeProperty('--wp-block-editor-iframe-zoom-out-frame-size'); 44432 iframeDocument.documentElement.style.removeProperty('--wp-block-editor-iframe-zoom-out-content-height'); 44433 iframeDocument.documentElement.style.removeProperty('--wp-block-editor-iframe-zoom-out-inner-height'); 44434 iframeDocument.documentElement.style.removeProperty('--wp-block-editor-iframe-zoom-out-container-width'); 44435 iframeDocument.documentElement.style.removeProperty('--wp-block-editor-iframe-zoom-out-scale-container-width'); 44436 }; 44437 }, [scale, frameSize, iframeDocument, iframeWindowInnerHeight, contentHeight, containerWidth, windowInnerWidth, isZoomedOut, scaleContainerWidth]); 44438 44439 // Make sure to not render the before and after focusable div elements in view 44440 // mode. They're only needed to capture focus in edit mode. 44441 const shouldRenderFocusCaptureElements = tabIndex >= 0 && !isPreviewMode; 44442 const iframe = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 44443 children: [shouldRenderFocusCaptureElements && before, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("iframe", { 44444 ...props, 44445 style: { 44446 ...props.style, 44447 height: props.style?.height, 44448 border: 0 44449 }, 44450 ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, setRef]), 44451 tabIndex: tabIndex 44452 // Correct doctype is required to enable rendering in standards 44453 // mode. Also preload the styles to avoid a flash of unstyled 44454 // content. 44455 , 44456 src: src, 44457 title: title, 44458 onKeyDown: event => { 44459 if (props.onKeyDown) { 44460 props.onKeyDown(event); 44461 } 44462 // If the event originates from inside the iframe, it means 44463 // it bubbled through the portal, but only with React 44464 // events. We need to to bubble native events as well, 44465 // though by doing so we also trigger another React event, 44466 // so we need to stop the propagation of this event to avoid 44467 // duplication. 44468 if (event.currentTarget.ownerDocument !== event.target.ownerDocument) { 44469 // We should only stop propagation of the React event, 44470 // the native event should further bubble inside the 44471 // iframe to the document and window. 44472 // Alternatively, we could consider redispatching the 44473 // native event in the iframe. 44474 const { 44475 stopPropagation 44476 } = event.nativeEvent; 44477 event.nativeEvent.stopPropagation = () => {}; 44478 event.stopPropagation(); 44479 event.nativeEvent.stopPropagation = stopPropagation; 44480 bubbleEvent(event, window.KeyboardEvent, event.currentTarget); 44481 } 44482 }, 44483 children: iframeDocument && (0,external_wp_element_namespaceObject.createPortal)( 44484 /*#__PURE__*/ 44485 // We want to prevent React events from bubbling throught the iframe 44486 // we bubble these manually. 44487 /* eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions */ 44488 (0,external_ReactJSXRuntime_namespaceObject.jsxs)("body", { 44489 ref: bodyRef, 44490 className: dist_clsx('block-editor-iframe__body', 'editor-styles-wrapper', ...bodyClasses), 44491 children: [contentResizeListener, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalStyleProvider, { 44492 document: iframeDocument, 44493 children: children 44494 })] 44495 }), iframeDocument.documentElement) 44496 }), shouldRenderFocusCaptureElements && after] 44497 }); 44498 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 44499 className: "block-editor-iframe__container", 44500 ref: windowResizeRef, 44501 children: [containerResizeListener, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 44502 className: dist_clsx('block-editor-iframe__scale-container', isZoomedOut && 'is-zoomed-out'), 44503 style: { 44504 '--wp-block-editor-iframe-zoom-out-scale-container-width': isZoomedOut && `$scaleContainerWidth}px` 44505 }, 44506 children: iframe 44507 })] 44508 }); 44509 } 44510 function IframeIfReady(props, ref) { 44511 const isInitialised = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSettings().__internalIsInitialized, []); 44512 44513 // We shouldn't render the iframe until the editor settings are initialised. 44514 // The initial settings are needed to get the styles for the srcDoc, which 44515 // cannot be changed after the iframe is mounted. srcDoc is used to to set 44516 // the initial iframe HTML, which is required to avoid a flash of unstyled 44517 // content. 44518 if (!isInitialised) { 44519 return null; 44520 } 44521 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Iframe, { 44522 ...props, 44523 forwardedRef: ref 44524 }); 44525 } 44526 /* harmony default export */ const iframe = ((0,external_wp_element_namespaceObject.forwardRef)(IframeIfReady)); 44527 44528 ;// ./node_modules/parsel-js/dist/parsel.js 44529 const TOKENS = { 44530 attribute: /\[\s*(?:(?<namespace>\*|[-\w\P{ASCII}]*)\|)?(?<name>[-\w\P{ASCII}]+)\s*(?:(?<operator>\W?=)\s*(?<value>.+?)\s*(\s(?<caseSensitive>[iIsS]))?\s*)?\]/gu, 44531 id: /#(?<name>[-\w\P{ASCII}]+)/gu, 44532 class: /\.(?<name>[-\w\P{ASCII}]+)/gu, 44533 comma: /\s*,\s*/g, 44534 combinator: /\s*[\s>+~]\s*/g, 44535 'pseudo-element': /::(?<name>[-\w\P{ASCII}]+)(?:\((?<argument>¶*)\))?/gu, 44536 'pseudo-class': /:(?<name>[-\w\P{ASCII}]+)(?:\((?<argument>¶*)\))?/gu, 44537 universal: /(?:(?<namespace>\*|[-\w\P{ASCII}]*)\|)?\*/gu, 44538 type: /(?:(?<namespace>\*|[-\w\P{ASCII}]*)\|)?(?<name>[-\w\P{ASCII}]+)/gu, // this must be last 44539 }; 44540 const TRIM_TOKENS = new Set(['combinator', 'comma']); 44541 const RECURSIVE_PSEUDO_CLASSES = new Set([ 44542 'not', 44543 'is', 44544 'where', 44545 'has', 44546 'matches', 44547 '-moz-any', 44548 '-webkit-any', 44549 'nth-child', 44550 'nth-last-child', 44551 ]); 44552 const nthChildRegExp = /(?<index>[\dn+-]+)\s+of\s+(?<subtree>.+)/; 44553 const RECURSIVE_PSEUDO_CLASSES_ARGS = { 44554 'nth-child': nthChildRegExp, 44555 'nth-last-child': nthChildRegExp, 44556 }; 44557 const getArgumentPatternByType = (type) => { 44558 switch (type) { 44559 case 'pseudo-element': 44560 case 'pseudo-class': 44561 return new RegExp(TOKENS[type].source.replace('(?<argument>¶*)', '(?<argument>.*)'), 'gu'); 44562 default: 44563 return TOKENS[type]; 44564 } 44565 }; 44566 function gobbleParens(text, offset) { 44567 let nesting = 0; 44568 let result = ''; 44569 for (; offset < text.length; offset++) { 44570 const char = text[offset]; 44571 switch (char) { 44572 case '(': 44573 ++nesting; 44574 break; 44575 case ')': 44576 --nesting; 44577 break; 44578 } 44579 result += char; 44580 if (nesting === 0) { 44581 return result; 44582 } 44583 } 44584 return result; 44585 } 44586 function tokenizeBy(text, grammar = TOKENS) { 44587 if (!text) { 44588 return []; 44589 } 44590 const tokens = [text]; 44591 for (const [type, pattern] of Object.entries(grammar)) { 44592 for (let i = 0; i < tokens.length; i++) { 44593 const token = tokens[i]; 44594 if (typeof token !== 'string') { 44595 continue; 44596 } 44597 pattern.lastIndex = 0; 44598 const match = pattern.exec(token); 44599 if (!match) { 44600 continue; 44601 } 44602 const from = match.index - 1; 44603 const args = []; 44604 const content = match[0]; 44605 const before = token.slice(0, from + 1); 44606 if (before) { 44607 args.push(before); 44608 } 44609 args.push({ 44610 ...match.groups, 44611 type, 44612 content, 44613 }); 44614 const after = token.slice(from + content.length + 1); 44615 if (after) { 44616 args.push(after); 44617 } 44618 tokens.splice(i, 1, ...args); 44619 } 44620 } 44621 let offset = 0; 44622 for (const token of tokens) { 44623 switch (typeof token) { 44624 case 'string': 44625 throw new Error(`Unexpected sequence $token} found at index $offset}`); 44626 case 'object': 44627 offset += token.content.length; 44628 token.pos = [offset - token.content.length, offset]; 44629 if (TRIM_TOKENS.has(token.type)) { 44630 token.content = token.content.trim() || ' '; 44631 } 44632 break; 44633 } 44634 } 44635 return tokens; 44636 } 44637 const STRING_PATTERN = /(['"])([^\\\n]+?)\1/g; 44638 const ESCAPE_PATTERN = /\\./g; 44639 function parsel_tokenize(selector, grammar = TOKENS) { 44640 // Prevent leading/trailing whitespaces from being interpreted as combinators 44641 selector = selector.trim(); 44642 if (selector === '') { 44643 return []; 44644 } 44645 const replacements = []; 44646 // Replace escapes with placeholders. 44647 selector = selector.replace(ESCAPE_PATTERN, (value, offset) => { 44648 replacements.push({ value, offset }); 44649 return '\uE000'.repeat(value.length); 44650 }); 44651 // Replace strings with placeholders. 44652 selector = selector.replace(STRING_PATTERN, (value, quote, content, offset) => { 44653 replacements.push({ value, offset }); 44654 return `$quote}${'\uE001'.repeat(content.length)}$quote}`; 44655 }); 44656 // Replace parentheses with placeholders. 44657 { 44658 let pos = 0; 44659 let offset; 44660 while ((offset = selector.indexOf('(', pos)) > -1) { 44661 const value = gobbleParens(selector, offset); 44662 replacements.push({ value, offset }); 44663 selector = `$selector.substring(0, offset)}(${'¶'.repeat(value.length - 2)})$selector.substring(offset + value.length)}`; 44664 pos = offset + value.length; 44665 } 44666 } 44667 // Now we have no nested structures and we can parse with regexes 44668 const tokens = tokenizeBy(selector, grammar); 44669 // Replace placeholders in reverse order. 44670 const changedTokens = new Set(); 44671 for (const replacement of replacements.reverse()) { 44672 for (const token of tokens) { 44673 const { offset, value } = replacement; 44674 if (!(token.pos[0] <= offset && 44675 offset + value.length <= token.pos[1])) { 44676 continue; 44677 } 44678 const { content } = token; 44679 const tokenOffset = offset - token.pos[0]; 44680 token.content = 44681 content.slice(0, tokenOffset) + 44682 value + 44683 content.slice(tokenOffset + value.length); 44684 if (token.content !== content) { 44685 changedTokens.add(token); 44686 } 44687 } 44688 } 44689 // Update changed tokens. 44690 for (const token of changedTokens) { 44691 const pattern = getArgumentPatternByType(token.type); 44692 if (!pattern) { 44693 throw new Error(`Unknown token type: $token.type}`); 44694 } 44695 pattern.lastIndex = 0; 44696 const match = pattern.exec(token.content); 44697 if (!match) { 44698 throw new Error(`Unable to parse content for $token.type}: $token.content}`); 44699 } 44700 Object.assign(token, match.groups); 44701 } 44702 return tokens; 44703 } 44704 /** 44705 * Convert a flat list of tokens into a tree of complex & compound selectors 44706 */ 44707 function nestTokens(tokens, { list = true } = {}) { 44708 if (list && tokens.find((t) => t.type === 'comma')) { 44709 const selectors = []; 44710 const temp = []; 44711 for (let i = 0; i < tokens.length; i++) { 44712 if (tokens[i].type === 'comma') { 44713 if (temp.length === 0) { 44714 throw new Error('Incorrect comma at ' + i); 44715 } 44716 selectors.push(nestTokens(temp, { list: false })); 44717 temp.length = 0; 44718 } 44719 else { 44720 temp.push(tokens[i]); 44721 } 44722 } 44723 if (temp.length === 0) { 44724 throw new Error('Trailing comma'); 44725 } 44726 else { 44727 selectors.push(nestTokens(temp, { list: false })); 44728 } 44729 return { type: 'list', list: selectors }; 44730 } 44731 for (let i = tokens.length - 1; i >= 0; i--) { 44732 let token = tokens[i]; 44733 if (token.type === 'combinator') { 44734 let left = tokens.slice(0, i); 44735 let right = tokens.slice(i + 1); 44736 return { 44737 type: 'complex', 44738 combinator: token.content, 44739 left: nestTokens(left), 44740 right: nestTokens(right), 44741 }; 44742 } 44743 } 44744 switch (tokens.length) { 44745 case 0: 44746 throw new Error('Could not build AST.'); 44747 case 1: 44748 // If we're here, there are no combinators, so it's just a list. 44749 return tokens[0]; 44750 default: 44751 return { 44752 type: 'compound', 44753 list: [...tokens], // clone to avoid pointers messing up the AST 44754 }; 44755 } 44756 } 44757 /** 44758 * Traverse an AST in depth-first order 44759 */ 44760 function* flatten(node, 44761 /** 44762 * @internal 44763 */ 44764 parent) { 44765 switch (node.type) { 44766 case 'list': 44767 for (let child of node.list) { 44768 yield* flatten(child, node); 44769 } 44770 break; 44771 case 'complex': 44772 yield* flatten(node.left, node); 44773 yield* flatten(node.right, node); 44774 break; 44775 case 'compound': 44776 yield* node.list.map((token) => [token, node]); 44777 break; 44778 default: 44779 yield [node, parent]; 44780 } 44781 } 44782 /** 44783 * Traverse an AST (or part thereof), in depth-first order 44784 */ 44785 function walk(node, visit, 44786 /** 44787 * @internal 44788 */ 44789 parent) { 44790 if (!node) { 44791 return; 44792 } 44793 for (const [token, ast] of flatten(node, parent)) { 44794 visit(token, ast); 44795 } 44796 } 44797 /** 44798 * Parse a CSS selector 44799 * 44800 * @param selector - The selector to parse 44801 * @param options.recursive - Whether to parse the arguments of pseudo-classes like :is(), :has() etc. Defaults to true. 44802 * @param options.list - Whether this can be a selector list (A, B, C etc). Defaults to true. 44803 */ 44804 function parse(selector, { recursive = true, list = true } = {}) { 44805 const tokens = parsel_tokenize(selector); 44806 if (!tokens) { 44807 return; 44808 } 44809 const ast = nestTokens(tokens, { list }); 44810 if (!recursive) { 44811 return ast; 44812 } 44813 for (const [token] of flatten(ast)) { 44814 if (token.type !== 'pseudo-class' || !token.argument) { 44815 continue; 44816 } 44817 if (!RECURSIVE_PSEUDO_CLASSES.has(token.name)) { 44818 continue; 44819 } 44820 let argument = token.argument; 44821 const childArg = RECURSIVE_PSEUDO_CLASSES_ARGS[token.name]; 44822 if (childArg) { 44823 const match = childArg.exec(argument); 44824 if (!match) { 44825 continue; 44826 } 44827 Object.assign(token, match.groups); 44828 argument = match.groups['subtree']; 44829 } 44830 if (!argument) { 44831 continue; 44832 } 44833 Object.assign(token, { 44834 subtree: parse(argument, { 44835 recursive: true, 44836 list: true, 44837 }), 44838 }); 44839 } 44840 return ast; 44841 } 44842 /** 44843 * Converts the given list or (sub)tree to a string. 44844 */ 44845 function stringify(listOrNode) { 44846 let tokens; 44847 if (Array.isArray(listOrNode)) { 44848 tokens = listOrNode; 44849 } 44850 else { 44851 tokens = [...flatten(listOrNode)].map(([token]) => token); 44852 } 44853 return tokens.map(token => token.content).join(''); 44854 } 44855 /** 44856 * To convert the specificity array to a number 44857 */ 44858 function specificityToNumber(specificity, base) { 44859 base = base || Math.max(...specificity) + 1; 44860 return (specificity[0] * (base << 1) + specificity[1] * base + specificity[2]); 44861 } 44862 /** 44863 * Calculate specificity of a selector. 44864 * 44865 * If the selector is a list, the max specificity is returned. 44866 */ 44867 function specificity(selector) { 44868 let ast = selector; 44869 if (typeof ast === 'string') { 44870 ast = parse(ast, { recursive: true }); 44871 } 44872 if (!ast) { 44873 return []; 44874 } 44875 if (ast.type === 'list' && 'list' in ast) { 44876 let base = 10; 44877 const specificities = ast.list.map((ast) => { 44878 const sp = specificity(ast); 44879 base = Math.max(base, ...specificity(ast)); 44880 return sp; 44881 }); 44882 const numbers = specificities.map((ast) => specificityToNumber(ast, base)); 44883 return specificities[numbers.indexOf(Math.max(...numbers))]; 44884 } 44885 const ret = [0, 0, 0]; 44886 for (const [token] of flatten(ast)) { 44887 switch (token.type) { 44888 case 'id': 44889 ret[0]++; 44890 break; 44891 case 'class': 44892 case 'attribute': 44893 ret[1]++; 44894 break; 44895 case 'pseudo-element': 44896 case 'type': 44897 ret[2]++; 44898 break; 44899 case 'pseudo-class': 44900 if (token.name === 'where') { 44901 break; 44902 } 44903 if (!RECURSIVE_PSEUDO_CLASSES.has(token.name) || 44904 !token.subtree) { 44905 ret[1]++; 44906 break; 44907 } 44908 const sub = specificity(token.subtree); 44909 sub.forEach((s, i) => (ret[i] += s)); 44910 // :nth-child() & :nth-last-child() add (0, 1, 0) to the specificity of their most complex selector 44911 if (token.name === 'nth-child' || 44912 token.name === 'nth-last-child') { 44913 ret[1]++; 44914 } 44915 } 44916 } 44917 return ret; 44918 } 44919 44920 44921 44922 // EXTERNAL MODULE: ./node_modules/postcss/lib/postcss.js 44923 var postcss = __webpack_require__(4529); 44924 ;// ./node_modules/postcss/lib/postcss.mjs 44925 44926 44927 /* harmony default export */ const lib_postcss = (postcss); 44928 44929 const postcss_stringify = postcss.stringify 44930 const fromJSON = postcss.fromJSON 44931 const postcss_plugin = postcss.plugin 44932 const postcss_parse = postcss.parse 44933 const list = postcss.list 44934 44935 const postcss_document = postcss.document 44936 const comment = postcss.comment 44937 const atRule = postcss.atRule 44938 const rule = postcss.rule 44939 const decl = postcss.decl 44940 const root = postcss.root 44941 44942 const CssSyntaxError = postcss.CssSyntaxError 44943 const Declaration = postcss.Declaration 44944 const Container = postcss.Container 44945 const Processor = postcss.Processor 44946 const Document = postcss.Document 44947 const Comment = postcss.Comment 44948 const postcss_Warning = postcss.Warning 44949 const AtRule = postcss.AtRule 44950 const Result = postcss.Result 44951 const Input = postcss.Input 44952 const Rule = postcss.Rule 44953 const postcss_Root = postcss.Root 44954 const Node = postcss.Node 44955 44956 // EXTERNAL MODULE: ./node_modules/postcss-prefix-selector/index.js 44957 var postcss_prefix_selector = __webpack_require__(1443); 44958 var postcss_prefix_selector_default = /*#__PURE__*/__webpack_require__.n(postcss_prefix_selector); 44959 // EXTERNAL MODULE: ./node_modules/postcss-urlrebase/index.js 44960 var postcss_urlrebase = __webpack_require__(5404); 44961 var postcss_urlrebase_default = /*#__PURE__*/__webpack_require__.n(postcss_urlrebase); 44962 ;// ./node_modules/@wordpress/block-editor/build-module/utils/transform-styles/index.js 44963 /** 44964 * External dependencies 44965 */ 44966 44967 44968 44969 44970 const cacheByWrapperSelector = new Map(); 44971 const ROOT_SELECTOR_TOKENS = [{ 44972 type: 'type', 44973 content: 'body' 44974 }, { 44975 type: 'type', 44976 content: 'html' 44977 }, { 44978 type: 'pseudo-class', 44979 content: ':root' 44980 }, { 44981 type: 'pseudo-class', 44982 content: ':where(body)' 44983 }, { 44984 type: 'pseudo-class', 44985 content: ':where(:root)' 44986 }, { 44987 type: 'pseudo-class', 44988 content: ':where(html)' 44989 }]; 44990 44991 /** 44992 * Prefixes root selectors in a way that ensures consistent specificity. 44993 * This requires special handling, since prefixing a classname before 44994 * html, body, or :root will generally result in an invalid selector. 44995 * 44996 * Some libraries will simply replace the root selector with the prefix 44997 * instead, but this results in inconsistent specificity. 44998 * 44999 * This function instead inserts the prefix after the root tags but before 45000 * any other part of the selector. This results in consistent specificity: 45001 * - If a `:where()` selector is used for the prefix, all selectors output 45002 * by `transformStyles` will have no specificity increase. 45003 * - If a classname, id, or something else is used as the prefix, all selectors 45004 * will have the same specificity bump when transformed. 45005 * 45006 * @param {string} prefix The prefix. 45007 * @param {string} selector The selector. 45008 * 45009 * @return {string} The prefixed root selector. 45010 */ 45011 function prefixRootSelector(prefix, selector) { 45012 // Use a tokenizer, since regular expressions are unreliable. 45013 const tokenized = parsel_tokenize(selector); 45014 45015 // Find the last token that contains a root selector by walking back 45016 // through the tokens. 45017 const lastRootIndex = tokenized.findLastIndex(({ 45018 content, 45019 type 45020 }) => { 45021 return ROOT_SELECTOR_TOKENS.some(rootSelector => content === rootSelector.content && type === rootSelector.type); 45022 }); 45023 45024 // Walk forwards to find the combinator after the last root. 45025 // This is where the root ends and the rest of the selector begins, 45026 // and the index to insert before. 45027 // Doing it this way takes into account that a root selector like 45028 // 'body' may have additional id/class/pseudo-class/attribute-selector 45029 // parts chained to it, which is difficult to quantify using a regex. 45030 let insertionPoint = -1; 45031 for (let i = lastRootIndex + 1; i < tokenized.length; i++) { 45032 if (tokenized[i].type === 'combinator') { 45033 insertionPoint = i; 45034 break; 45035 } 45036 } 45037 45038 // Tokenize and insert the prefix with a ' ' combinator before it. 45039 const tokenizedPrefix = parsel_tokenize(prefix); 45040 tokenized.splice( 45041 // Insert at the insertion point, or the end. 45042 insertionPoint === -1 ? tokenized.length : insertionPoint, 0, { 45043 type: 'combinator', 45044 content: ' ' 45045 }, ...tokenizedPrefix); 45046 return stringify(tokenized); 45047 } 45048 function transformStyle({ 45049 css, 45050 ignoredSelectors = [], 45051 baseURL 45052 }, wrapperSelector = '', transformOptions) { 45053 // When there is no wrapper selector and no base URL, there is no need 45054 // to transform the CSS. This is most cases because in the default 45055 // iframed editor, no wrapping is needed, and not many styles 45056 // provide a base URL. 45057 if (!wrapperSelector && !baseURL) { 45058 return css; 45059 } 45060 try { 45061 var _transformOptions$ign; 45062 const excludedSelectors = [...ignoredSelectors, ...((_transformOptions$ign = transformOptions?.ignoredSelectors) !== null && _transformOptions$ign !== void 0 ? _transformOptions$ign : []), wrapperSelector]; 45063 return lib_postcss([wrapperSelector && postcss_prefix_selector_default()({ 45064 prefix: wrapperSelector, 45065 transform(prefix, selector, prefixedSelector) { 45066 // For backwards compatibility, don't use the `exclude` option 45067 // of postcss-prefix-selector, instead handle it here to match 45068 // the behavior of the old library (postcss-prefix-wrap) that 45069 // `transformStyle` previously used. 45070 if (excludedSelectors.some(excludedSelector => excludedSelector instanceof RegExp ? selector.match(excludedSelector) : selector.includes(excludedSelector))) { 45071 return selector; 45072 } 45073 const hasRootSelector = ROOT_SELECTOR_TOKENS.some(rootSelector => selector.startsWith(rootSelector.content)); 45074 45075 // Reorganize root selectors such that the root part comes before the prefix, 45076 // but the prefix still comes before the remaining part of the selector. 45077 if (hasRootSelector) { 45078 return prefixRootSelector(prefix, selector); 45079 } 45080 return prefixedSelector; 45081 } 45082 }), baseURL && postcss_urlrebase_default()({ 45083 rootUrl: baseURL 45084 })].filter(Boolean)).process(css, {}).css; // use sync PostCSS API 45085 } catch (error) { 45086 if (error instanceof CssSyntaxError) { 45087 // eslint-disable-next-line no-console 45088 console.warn('wp.blockEditor.transformStyles Failed to transform CSS.', error.message + '\n' + error.showSourceCode(false)); 45089 } else { 45090 // eslint-disable-next-line no-console 45091 console.warn('wp.blockEditor.transformStyles Failed to transform CSS.', error); 45092 } 45093 return null; 45094 } 45095 } 45096 45097 /** 45098 * @typedef {Object} EditorStyle 45099 * @property {string} css the CSS block(s), as a single string. 45100 * @property {?string} baseURL the base URL to be used as the reference when rewritting urls. 45101 * @property {?string[]} ignoredSelectors the selectors not to wrap. 45102 */ 45103 45104 /** 45105 * @typedef {Object} TransformOptions 45106 * @property {?string[]} ignoredSelectors the selectors not to wrap. 45107 */ 45108 45109 /** 45110 * Applies a series of CSS rule transforms to wrap selectors inside a given class and/or rewrite URLs depending on the parameters passed. 45111 * 45112 * @param {EditorStyle[]} styles CSS rules. 45113 * @param {string} wrapperSelector Wrapper selector. 45114 * @param {TransformOptions} transformOptions Additional options for style transformation. 45115 * @return {Array} converted rules. 45116 */ 45117 const transform_styles_transformStyles = (styles, wrapperSelector = '', transformOptions) => { 45118 let cache = cacheByWrapperSelector.get(wrapperSelector); 45119 if (!cache) { 45120 cache = new WeakMap(); 45121 cacheByWrapperSelector.set(wrapperSelector, cache); 45122 } 45123 return styles.map(style => { 45124 let css = cache.get(style); 45125 if (!css) { 45126 css = transformStyle(style, wrapperSelector, transformOptions); 45127 cache.set(style, css); 45128 } 45129 return css; 45130 }); 45131 }; 45132 /* harmony default export */ const transform_styles = (transform_styles_transformStyles); 45133 45134 ;// ./node_modules/@wordpress/block-editor/build-module/components/editor-styles/index.js 45135 /** 45136 * External dependencies 45137 */ 45138 45139 45140 45141 45142 /** 45143 * WordPress dependencies 45144 */ 45145 45146 45147 45148 45149 /** 45150 * Internal dependencies 45151 */ 45152 45153 45154 45155 45156 45157 45158 k([names, a11y]); 45159 function useDarkThemeBodyClassName(styles, scope) { 45160 return (0,external_wp_element_namespaceObject.useCallback)(node => { 45161 if (!node) { 45162 return; 45163 } 45164 const { 45165 ownerDocument 45166 } = node; 45167 const { 45168 defaultView, 45169 body 45170 } = ownerDocument; 45171 const canvas = scope ? ownerDocument.querySelector(scope) : body; 45172 let backgroundColor; 45173 if (!canvas) { 45174 // The real .editor-styles-wrapper element might not exist in the 45175 // DOM, so calculate the background color by creating a fake 45176 // wrapper. 45177 const tempCanvas = ownerDocument.createElement('div'); 45178 tempCanvas.classList.add('editor-styles-wrapper'); 45179 body.appendChild(tempCanvas); 45180 backgroundColor = defaultView?.getComputedStyle(tempCanvas, null).getPropertyValue('background-color'); 45181 body.removeChild(tempCanvas); 45182 } else { 45183 backgroundColor = defaultView?.getComputedStyle(canvas, null).getPropertyValue('background-color'); 45184 } 45185 const colordBackgroundColor = w(backgroundColor); 45186 // If background is transparent, it should be treated as light color. 45187 if (colordBackgroundColor.luminance() > 0.5 || colordBackgroundColor.alpha() === 0) { 45188 body.classList.remove('is-dark-theme'); 45189 } else { 45190 body.classList.add('is-dark-theme'); 45191 } 45192 }, [styles, scope]); 45193 } 45194 function EditorStyles({ 45195 styles, 45196 scope, 45197 transformOptions 45198 }) { 45199 const overrides = (0,external_wp_data_namespaceObject.useSelect)(select => unlock(select(store)).getStyleOverrides(), []); 45200 const [transformedStyles, transformedSvgs] = (0,external_wp_element_namespaceObject.useMemo)(() => { 45201 const _styles = Object.values(styles !== null && styles !== void 0 ? styles : []); 45202 for (const [id, override] of overrides) { 45203 const index = _styles.findIndex(({ 45204 id: _id 45205 }) => id === _id); 45206 const overrideWithId = { 45207 ...override, 45208 id 45209 }; 45210 if (index === -1) { 45211 _styles.push(overrideWithId); 45212 } else { 45213 _styles[index] = overrideWithId; 45214 } 45215 } 45216 return [transform_styles(_styles.filter(style => style?.css), scope, transformOptions), _styles.filter(style => style.__unstableType === 'svgs').map(style => style.assets).join('')]; 45217 }, [styles, overrides, scope, transformOptions]); 45218 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 45219 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("style", { 45220 ref: useDarkThemeBodyClassName(transformedStyles, scope) 45221 }), transformedStyles.map((css, index) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("style", { 45222 children: css 45223 }, index)), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, { 45224 xmlns: "http://www.w3.org/2000/svg", 45225 viewBox: "0 0 0 0", 45226 width: "0", 45227 height: "0", 45228 role: "none", 45229 style: { 45230 visibility: 'hidden', 45231 position: 'absolute', 45232 left: '-9999px', 45233 overflow: 'hidden' 45234 }, 45235 dangerouslySetInnerHTML: { 45236 __html: transformedSvgs 45237 } 45238 })] 45239 }); 45240 } 45241 /* harmony default export */ const editor_styles = ((0,external_wp_element_namespaceObject.memo)(EditorStyles)); 45242 45243 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-preview/auto.js 45244 /** 45245 * WordPress dependencies 45246 */ 45247 45248 45249 45250 45251 45252 /** 45253 * Internal dependencies 45254 */ 45255 45256 45257 45258 45259 45260 // This is used to avoid rendering the block list if the sizes change. 45261 45262 45263 45264 let MemoizedBlockList; 45265 const MAX_HEIGHT = 2000; 45266 const EMPTY_ADDITIONAL_STYLES = []; 45267 function ScaledBlockPreview({ 45268 viewportWidth, 45269 containerWidth, 45270 minHeight, 45271 additionalStyles = EMPTY_ADDITIONAL_STYLES 45272 }) { 45273 if (!viewportWidth) { 45274 viewportWidth = containerWidth; 45275 } 45276 const [contentResizeListener, { 45277 height: contentHeight 45278 }] = (0,external_wp_compose_namespaceObject.useResizeObserver)(); 45279 const { 45280 styles 45281 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 45282 const settings = select(store).getSettings(); 45283 return { 45284 styles: settings.styles 45285 }; 45286 }, []); 45287 45288 // Avoid scrollbars for pattern previews. 45289 const editorStyles = (0,external_wp_element_namespaceObject.useMemo)(() => { 45290 if (styles) { 45291 return [...styles, { 45292 css: 'body{height:auto;overflow:hidden;border:none;padding:0;}', 45293 __unstableType: 'presets' 45294 }, ...additionalStyles]; 45295 } 45296 return styles; 45297 }, [styles, additionalStyles]); 45298 45299 // Initialize on render instead of module top level, to avoid circular dependency issues. 45300 MemoizedBlockList = MemoizedBlockList || (0,external_wp_element_namespaceObject.memo)(BlockList); 45301 const scale = containerWidth / viewportWidth; 45302 const aspectRatio = contentHeight ? containerWidth / (contentHeight * scale) : 0; 45303 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Disabled, { 45304 className: "block-editor-block-preview__content", 45305 style: { 45306 transform: `scale($scale})`, 45307 // Using width + aspect-ratio instead of height here triggers browsers' native 45308 // handling of scrollbar's visibility. It prevents the flickering issue seen 45309 // in https://github.com/WordPress/gutenberg/issues/52027. 45310 // See https://github.com/WordPress/gutenberg/pull/52921 for more info. 45311 aspectRatio, 45312 maxHeight: contentHeight > MAX_HEIGHT ? MAX_HEIGHT * scale : undefined, 45313 minHeight 45314 }, 45315 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(iframe, { 45316 contentRef: (0,external_wp_compose_namespaceObject.useRefEffect)(bodyElement => { 45317 const { 45318 ownerDocument: { 45319 documentElement 45320 } 45321 } = bodyElement; 45322 documentElement.classList.add('block-editor-block-preview__content-iframe'); 45323 documentElement.style.position = 'absolute'; 45324 documentElement.style.width = '100%'; 45325 45326 // Necessary for contentResizeListener to work. 45327 bodyElement.style.boxSizing = 'border-box'; 45328 bodyElement.style.position = 'absolute'; 45329 bodyElement.style.width = '100%'; 45330 }, []), 45331 "aria-hidden": true, 45332 tabIndex: -1, 45333 style: { 45334 position: 'absolute', 45335 width: viewportWidth, 45336 height: contentHeight, 45337 pointerEvents: 'none', 45338 // This is a catch-all max-height for patterns. 45339 // See: https://github.com/WordPress/gutenberg/pull/38175. 45340 maxHeight: MAX_HEIGHT, 45341 minHeight: scale !== 0 && scale < 1 && minHeight ? minHeight / scale : minHeight 45342 }, 45343 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editor_styles, { 45344 styles: editorStyles 45345 }), contentResizeListener, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MemoizedBlockList, { 45346 renderAppender: false 45347 })] 45348 }) 45349 }); 45350 } 45351 function AutoBlockPreview(props) { 45352 const [containerResizeListener, { 45353 width: containerWidth 45354 }] = (0,external_wp_compose_namespaceObject.useResizeObserver)(); 45355 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 45356 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 45357 style: { 45358 position: 'relative', 45359 width: '100%', 45360 height: 0 45361 }, 45362 children: containerResizeListener 45363 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 45364 className: "block-editor-block-preview__container", 45365 children: !!containerWidth && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ScaledBlockPreview, { 45366 ...props, 45367 containerWidth: containerWidth 45368 }) 45369 })] 45370 }); 45371 } 45372 45373 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-preview/index.js 45374 /** 45375 * External dependencies 45376 */ 45377 45378 45379 /** 45380 * WordPress dependencies 45381 */ 45382 45383 45384 45385 45386 45387 /** 45388 * Internal dependencies 45389 */ 45390 45391 45392 45393 45394 45395 45396 45397 const block_preview_EMPTY_ADDITIONAL_STYLES = []; 45398 function BlockPreview({ 45399 blocks, 45400 viewportWidth = 1200, 45401 minHeight, 45402 additionalStyles = block_preview_EMPTY_ADDITIONAL_STYLES, 45403 // Deprecated props: 45404 __experimentalMinHeight, 45405 __experimentalPadding 45406 }) { 45407 if (__experimentalMinHeight) { 45408 minHeight = __experimentalMinHeight; 45409 external_wp_deprecated_default()('The __experimentalMinHeight prop', { 45410 since: '6.2', 45411 version: '6.4', 45412 alternative: 'minHeight' 45413 }); 45414 } 45415 if (__experimentalPadding) { 45416 additionalStyles = [...additionalStyles, { 45417 css: `body { padding: $__experimentalPadding}px; }` 45418 }]; 45419 external_wp_deprecated_default()('The __experimentalPadding prop of BlockPreview', { 45420 since: '6.2', 45421 version: '6.4', 45422 alternative: 'additionalStyles' 45423 }); 45424 } 45425 const originalSettings = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSettings(), []); 45426 const settings = (0,external_wp_element_namespaceObject.useMemo)(() => ({ 45427 ...originalSettings, 45428 focusMode: false, 45429 // Disable "Spotlight mode". 45430 __unstableIsPreviewMode: true 45431 }), [originalSettings]); 45432 const renderedBlocks = (0,external_wp_element_namespaceObject.useMemo)(() => Array.isArray(blocks) ? blocks : [blocks], [blocks]); 45433 if (!blocks || blocks.length === 0) { 45434 return null; 45435 } 45436 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ExperimentalBlockEditorProvider, { 45437 value: renderedBlocks, 45438 settings: settings, 45439 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AutoBlockPreview, { 45440 viewportWidth: viewportWidth, 45441 minHeight: minHeight, 45442 additionalStyles: additionalStyles 45443 }) 45444 }); 45445 } 45446 45447 /** 45448 * BlockPreview renders a preview of a block or array of blocks. 45449 * 45450 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-preview/README.md 45451 * 45452 * @param {Object} preview options for how the preview should be shown 45453 * @param {Array|Object} preview.blocks A block instance (object) or an array of blocks to be previewed. 45454 * @param {number} preview.viewportWidth Width of the preview container in pixels. Controls at what size the blocks will be rendered inside the preview. Default: 700. 45455 * 45456 * @return {Component} The component to be rendered. 45457 */ 45458 /* harmony default export */ const block_preview = ((0,external_wp_element_namespaceObject.memo)(BlockPreview)); 45459 45460 /** 45461 * This hook is used to lightly mark an element as a block preview wrapper 45462 * element. Call this hook and pass the returned props to the element to mark as 45463 * a block preview wrapper, automatically rendering inner blocks as children. If 45464 * you define a ref for the element, it is important to pass the ref to this 45465 * hook, which the hook in turn will pass to the component through the props it 45466 * returns. Optionally, you can also pass any other props through this hook, and 45467 * they will be merged and returned. 45468 * 45469 * @param {Object} options Preview options. 45470 * @param {WPBlock[]} options.blocks Block objects. 45471 * @param {Object} options.props Optional. Props to pass to the element. Must contain 45472 * the ref if one is defined. 45473 * @param {Object} options.layout Layout settings to be used in the preview. 45474 */ 45475 function useBlockPreview({ 45476 blocks, 45477 props = {}, 45478 layout 45479 }) { 45480 const originalSettings = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSettings(), []); 45481 const settings = (0,external_wp_element_namespaceObject.useMemo)(() => ({ 45482 ...originalSettings, 45483 styles: undefined, 45484 // Clear styles included by the parent settings, as they are already output by the parent's EditorStyles. 45485 focusMode: false, 45486 // Disable "Spotlight mode". 45487 __unstableIsPreviewMode: true 45488 }), [originalSettings]); 45489 const disabledRef = (0,external_wp_compose_namespaceObject.useDisabled)(); 45490 const ref = (0,external_wp_compose_namespaceObject.useMergeRefs)([props.ref, disabledRef]); 45491 const renderedBlocks = (0,external_wp_element_namespaceObject.useMemo)(() => Array.isArray(blocks) ? blocks : [blocks], [blocks]); 45492 const children = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(ExperimentalBlockEditorProvider, { 45493 value: renderedBlocks, 45494 settings: settings, 45495 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editor_styles, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListItems, { 45496 renderAppender: false, 45497 layout: layout 45498 })] 45499 }); 45500 return { 45501 ...props, 45502 ref, 45503 className: dist_clsx(props.className, 'block-editor-block-preview__live-content', 'components-disabled'), 45504 children: blocks?.length ? children : null 45505 }; 45506 } 45507 45508 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/preview-panel.js 45509 /** 45510 * WordPress dependencies 45511 */ 45512 45513 45514 45515 45516 /** 45517 * Internal dependencies 45518 */ 45519 45520 45521 45522 45523 function InserterPreviewPanel({ 45524 item 45525 }) { 45526 var _example$viewportWidt; 45527 const { 45528 name, 45529 title, 45530 icon, 45531 description, 45532 initialAttributes, 45533 example 45534 } = item; 45535 const isReusable = (0,external_wp_blocks_namespaceObject.isReusableBlock)(item); 45536 const blocks = (0,external_wp_element_namespaceObject.useMemo)(() => { 45537 if (!example) { 45538 return (0,external_wp_blocks_namespaceObject.createBlock)(name, initialAttributes); 45539 } 45540 return (0,external_wp_blocks_namespaceObject.getBlockFromExample)(name, { 45541 attributes: { 45542 ...example.attributes, 45543 ...initialAttributes 45544 }, 45545 innerBlocks: example.innerBlocks 45546 }); 45547 }, [name, example, initialAttributes]); 45548 // Same as height of BlockPreviewPanel. 45549 const previewHeight = 144; 45550 const sidebarWidth = 280; 45551 const viewportWidth = (_example$viewportWidt = example?.viewportWidth) !== null && _example$viewportWidt !== void 0 ? _example$viewportWidt : 500; 45552 const scale = sidebarWidth / viewportWidth; 45553 const minHeight = scale !== 0 && scale < 1 && previewHeight ? previewHeight / scale : previewHeight; 45554 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 45555 className: "block-editor-inserter__preview-container", 45556 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 45557 className: "block-editor-inserter__preview", 45558 children: isReusable || example ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 45559 className: "block-editor-inserter__preview-content", 45560 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, { 45561 blocks: blocks, 45562 viewportWidth: viewportWidth, 45563 minHeight: previewHeight, 45564 additionalStyles: 45565 //We want this CSS to be in sync with the one in BlockPreviewPanel. 45566 [{ 45567 css: ` 45568 body { 45569 padding: 24px; 45570 min-height:$Math.round(minHeight)}px; 45571 display:flex; 45572 align-items:center; 45573 } 45574 .is-root-container { width: 100%; } 45575 ` 45576 }] 45577 }) 45578 }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 45579 className: "block-editor-inserter__preview-content-missing", 45580 children: (0,external_wp_i18n_namespaceObject.__)('No preview available.') 45581 }) 45582 }), !isReusable && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_card, { 45583 title: title, 45584 icon: icon, 45585 description: description 45586 })] 45587 }); 45588 } 45589 /* harmony default export */ const preview_panel = (InserterPreviewPanel); 45590 45591 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-listbox/item.js 45592 /** 45593 * WordPress dependencies 45594 */ 45595 45596 45597 45598 function InserterListboxItem({ 45599 isFirst, 45600 as: Component, 45601 children, 45602 ...props 45603 }, ref) { 45604 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite.Item, { 45605 ref: ref, 45606 role: "option" 45607 // Use the Composite.Item `accessibleWhenDisabled` prop 45608 // over Button's `isFocusable`. The latter was shown to 45609 // cause an issue with tab order in the inserter list. 45610 , 45611 accessibleWhenDisabled: true, 45612 ...props, 45613 render: htmlProps => { 45614 const propsWithTabIndex = { 45615 ...htmlProps, 45616 tabIndex: isFirst ? 0 : htmlProps.tabIndex 45617 }; 45618 if (Component) { 45619 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, { 45620 ...propsWithTabIndex, 45621 children: children 45622 }); 45623 } 45624 if (typeof children === 'function') { 45625 return children(propsWithTabIndex); 45626 } 45627 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 45628 __next40pxDefaultSize: true, 45629 ...propsWithTabIndex, 45630 children: children 45631 }); 45632 } 45633 }); 45634 } 45635 /* harmony default export */ const inserter_listbox_item = ((0,external_wp_element_namespaceObject.forwardRef)(InserterListboxItem)); 45636 45637 ;// ./node_modules/@wordpress/icons/build-module/library/drag-handle.js 45638 /** 45639 * WordPress dependencies 45640 */ 45641 45642 45643 const dragHandle = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 45644 width: "24", 45645 height: "24", 45646 xmlns: "http://www.w3.org/2000/svg", 45647 viewBox: "0 0 24 24", 45648 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 45649 d: "M8 7h2V5H8v2zm0 6h2v-2H8v2zm0 6h2v-2H8v2zm6-14v2h2V5h-2zm0 8h2v-2h-2v2zm0 6h2v-2h-2v2z" 45650 }) 45651 }); 45652 /* harmony default export */ const drag_handle = (dragHandle); 45653 45654 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-draggable/draggable-chip.js 45655 /** 45656 * WordPress dependencies 45657 */ 45658 45659 45660 45661 45662 /** 45663 * Internal dependencies 45664 */ 45665 45666 45667 45668 function BlockDraggableChip({ 45669 count, 45670 icon, 45671 isPattern, 45672 fadeWhenDisabled 45673 }) { 45674 const patternLabel = isPattern && (0,external_wp_i18n_namespaceObject.__)('Pattern'); 45675 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 45676 className: "block-editor-block-draggable-chip-wrapper", 45677 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 45678 className: "block-editor-block-draggable-chip", 45679 "data-testid": "block-draggable-chip", 45680 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, { 45681 justify: "center", 45682 className: "block-editor-block-draggable-chip__content", 45683 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 45684 children: icon ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 45685 icon: icon 45686 }) : patternLabel || (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %d: Number of blocks. */ 45687 (0,external_wp_i18n_namespaceObject._n)('%d block', '%d blocks', count), count) 45688 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 45689 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 45690 icon: drag_handle 45691 }) 45692 }), fadeWhenDisabled && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 45693 className: "block-editor-block-draggable-chip__disabled", 45694 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 45695 className: "block-editor-block-draggable-chip__disabled-icon" 45696 }) 45697 })] 45698 }) 45699 }) 45700 }); 45701 } 45702 45703 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-draggable-blocks/index.js 45704 /** 45705 * WordPress dependencies 45706 */ 45707 45708 45709 45710 45711 /** 45712 * Internal dependencies 45713 */ 45714 45715 45716 45717 45718 45719 const InserterDraggableBlocks = ({ 45720 isEnabled, 45721 blocks, 45722 icon, 45723 children, 45724 pattern 45725 }) => { 45726 const transferData = { 45727 type: 'inserter', 45728 blocks 45729 }; 45730 const blockTypeIcon = (0,external_wp_data_namespaceObject.useSelect)(select => { 45731 const { 45732 getBlockType 45733 } = select(external_wp_blocks_namespaceObject.store); 45734 return blocks.length === 1 && getBlockType(blocks[0].name)?.icon; 45735 }, [blocks]); 45736 const { 45737 startDragging, 45738 stopDragging 45739 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 45740 if (!isEnabled) { 45741 return children({ 45742 draggable: false, 45743 onDragStart: undefined, 45744 onDragEnd: undefined 45745 }); 45746 } 45747 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Draggable, { 45748 __experimentalTransferDataType: "wp-blocks", 45749 transferData: transferData, 45750 onDragStart: event => { 45751 startDragging(); 45752 const parsedBlocks = pattern?.type === INSERTER_PATTERN_TYPES.user && pattern?.syncStatus !== 'unsynced' ? [(0,external_wp_blocks_namespaceObject.createBlock)('core/block', { 45753 ref: pattern.id 45754 })] : blocks; 45755 event.dataTransfer.setData('text/html', (0,external_wp_blocks_namespaceObject.serialize)(parsedBlocks)); 45756 }, 45757 onDragEnd: () => { 45758 stopDragging(); 45759 }, 45760 __experimentalDragComponent: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockDraggableChip, { 45761 count: blocks.length, 45762 icon: icon || !pattern && blockTypeIcon, 45763 isPattern: !!pattern 45764 }), 45765 children: ({ 45766 onDraggableStart, 45767 onDraggableEnd 45768 }) => { 45769 return children({ 45770 draggable: true, 45771 onDragStart: onDraggableStart, 45772 onDragEnd: onDraggableEnd 45773 }); 45774 } 45775 }); 45776 }; 45777 /* harmony default export */ const inserter_draggable_blocks = (InserterDraggableBlocks); 45778 45779 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-list-item/index.js 45780 /** 45781 * External dependencies 45782 */ 45783 45784 45785 /** 45786 * WordPress dependencies 45787 */ 45788 45789 45790 45791 45792 45793 /** 45794 * Internal dependencies 45795 */ 45796 45797 45798 45799 45800 45801 function InserterListItem({ 45802 className, 45803 isFirst, 45804 item, 45805 onSelect, 45806 onHover, 45807 isDraggable, 45808 ...props 45809 }) { 45810 const isDraggingRef = (0,external_wp_element_namespaceObject.useRef)(false); 45811 const itemIconStyle = item.icon ? { 45812 backgroundColor: item.icon.background, 45813 color: item.icon.foreground 45814 } : {}; 45815 const blocks = (0,external_wp_element_namespaceObject.useMemo)(() => [(0,external_wp_blocks_namespaceObject.createBlock)(item.name, item.initialAttributes, (0,external_wp_blocks_namespaceObject.createBlocksFromInnerBlocksTemplate)(item.innerBlocks))], [item.name, item.initialAttributes, item.innerBlocks]); 45816 const isSynced = (0,external_wp_blocks_namespaceObject.isReusableBlock)(item) && item.syncStatus !== 'unsynced' || (0,external_wp_blocks_namespaceObject.isTemplatePart)(item); 45817 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_draggable_blocks, { 45818 isEnabled: isDraggable && !item.isDisabled, 45819 blocks: blocks, 45820 icon: item.icon, 45821 children: ({ 45822 draggable, 45823 onDragStart, 45824 onDragEnd 45825 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 45826 className: dist_clsx('block-editor-block-types-list__list-item', { 45827 'is-synced': isSynced 45828 }), 45829 draggable: draggable, 45830 onDragStart: event => { 45831 isDraggingRef.current = true; 45832 if (onDragStart) { 45833 onHover(null); 45834 onDragStart(event); 45835 } 45836 }, 45837 onDragEnd: event => { 45838 isDraggingRef.current = false; 45839 if (onDragEnd) { 45840 onDragEnd(event); 45841 } 45842 }, 45843 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(inserter_listbox_item, { 45844 isFirst: isFirst, 45845 className: dist_clsx('block-editor-block-types-list__item', className), 45846 disabled: item.isDisabled, 45847 onClick: event => { 45848 event.preventDefault(); 45849 onSelect(item, (0,external_wp_keycodes_namespaceObject.isAppleOS)() ? event.metaKey : event.ctrlKey); 45850 onHover(null); 45851 }, 45852 onKeyDown: event => { 45853 const { 45854 keyCode 45855 } = event; 45856 if (keyCode === external_wp_keycodes_namespaceObject.ENTER) { 45857 event.preventDefault(); 45858 onSelect(item, (0,external_wp_keycodes_namespaceObject.isAppleOS)() ? event.metaKey : event.ctrlKey); 45859 onHover(null); 45860 } 45861 }, 45862 onMouseEnter: () => { 45863 if (isDraggingRef.current) { 45864 return; 45865 } 45866 onHover(item); 45867 }, 45868 onMouseLeave: () => onHover(null), 45869 ...props, 45870 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 45871 className: "block-editor-block-types-list__item-icon", 45872 style: itemIconStyle, 45873 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 45874 icon: item.icon, 45875 showColors: true 45876 }) 45877 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 45878 className: "block-editor-block-types-list__item-title", 45879 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, { 45880 numberOfLines: 3, 45881 children: item.title 45882 }) 45883 })] 45884 }) 45885 }) 45886 }); 45887 } 45888 /* harmony default export */ const inserter_list_item = ((0,external_wp_element_namespaceObject.memo)(InserterListItem)); 45889 45890 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-listbox/group.js 45891 /** 45892 * WordPress dependencies 45893 */ 45894 45895 45896 45897 45898 function InserterListboxGroup(props, ref) { 45899 const [shouldSpeak, setShouldSpeak] = (0,external_wp_element_namespaceObject.useState)(false); 45900 (0,external_wp_element_namespaceObject.useEffect)(() => { 45901 if (shouldSpeak) { 45902 (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('Use left and right arrow keys to move through blocks')); 45903 } 45904 }, [shouldSpeak]); 45905 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 45906 ref: ref, 45907 role: "listbox", 45908 "aria-orientation": "horizontal", 45909 onFocus: () => { 45910 setShouldSpeak(true); 45911 }, 45912 onBlur: event => { 45913 const focusingOutsideGroup = !event.currentTarget.contains(event.relatedTarget); 45914 if (focusingOutsideGroup) { 45915 setShouldSpeak(false); 45916 } 45917 }, 45918 ...props 45919 }); 45920 } 45921 /* harmony default export */ const group = ((0,external_wp_element_namespaceObject.forwardRef)(InserterListboxGroup)); 45922 45923 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-listbox/row.js 45924 /** 45925 * WordPress dependencies 45926 */ 45927 45928 45929 45930 function InserterListboxRow(props, ref) { 45931 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite.Group, { 45932 role: "presentation", 45933 ref: ref, 45934 ...props 45935 }); 45936 } 45937 /* harmony default export */ const inserter_listbox_row = ((0,external_wp_element_namespaceObject.forwardRef)(InserterListboxRow)); 45938 45939 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-types-list/index.js 45940 /** 45941 * WordPress dependencies 45942 */ 45943 45944 45945 45946 /** 45947 * Internal dependencies 45948 */ 45949 45950 45951 45952 45953 function chunk(array, size) { 45954 const chunks = []; 45955 for (let i = 0, j = array.length; i < j; i += size) { 45956 chunks.push(array.slice(i, i + size)); 45957 } 45958 return chunks; 45959 } 45960 function BlockTypesList({ 45961 items = [], 45962 onSelect, 45963 onHover = () => {}, 45964 children, 45965 label, 45966 isDraggable = true 45967 }) { 45968 const className = 'block-editor-block-types-list'; 45969 const listId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockTypesList, className); 45970 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(group, { 45971 className: className, 45972 "aria-label": label, 45973 children: [chunk(items, 3).map((row, i) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_listbox_row, { 45974 children: row.map((item, j) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_list_item, { 45975 item: item, 45976 className: (0,external_wp_blocks_namespaceObject.getBlockMenuDefaultClassName)(item.id), 45977 onSelect: onSelect, 45978 onHover: onHover, 45979 isDraggable: isDraggable && !item.isDisabled, 45980 isFirst: i === 0 && j === 0, 45981 rowId: `$listId}-$i}` 45982 }, item.id)) 45983 }, i)), children] 45984 }); 45985 } 45986 /* harmony default export */ const block_types_list = (BlockTypesList); 45987 45988 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/panel.js 45989 /** 45990 * WordPress dependencies 45991 */ 45992 45993 45994 45995 45996 function InserterPanel({ 45997 title, 45998 icon, 45999 children 46000 }) { 46001 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 46002 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 46003 className: "block-editor-inserter__panel-header", 46004 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("h2", { 46005 className: "block-editor-inserter__panel-title", 46006 children: title 46007 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, { 46008 icon: icon 46009 })] 46010 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 46011 className: "block-editor-inserter__panel-content", 46012 children: children 46013 })] 46014 }); 46015 } 46016 /* harmony default export */ const panel = (InserterPanel); 46017 46018 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/hooks/use-block-types-state.js 46019 /** 46020 * WordPress dependencies 46021 */ 46022 46023 46024 46025 46026 /** 46027 * Internal dependencies 46028 */ 46029 46030 46031 46032 /** 46033 * Retrieves the block types inserter state. 46034 * 46035 * @param {string=} rootClientId Insertion's root client ID. 46036 * @param {Function} onInsert function called when inserter a list of blocks. 46037 * @param {boolean} isQuick 46038 * @return {Array} Returns the block types state. (block types, categories, collections, onSelect handler) 46039 */ 46040 const useBlockTypesState = (rootClientId, onInsert, isQuick) => { 46041 const options = (0,external_wp_element_namespaceObject.useMemo)(() => ({ 46042 [withRootClientIdOptionKey]: !isQuick 46043 }), [isQuick]); 46044 const [items] = (0,external_wp_data_namespaceObject.useSelect)(select => [select(store).getInserterItems(rootClientId, options)], [rootClientId, options]); 46045 const [categories, collections] = (0,external_wp_data_namespaceObject.useSelect)(select => { 46046 const { 46047 getCategories, 46048 getCollections 46049 } = select(external_wp_blocks_namespaceObject.store); 46050 return [getCategories(), getCollections()]; 46051 }, []); 46052 const onSelectItem = (0,external_wp_element_namespaceObject.useCallback)(({ 46053 name, 46054 initialAttributes, 46055 innerBlocks, 46056 syncStatus, 46057 content, 46058 rootClientId: _rootClientId 46059 }, shouldFocusBlock) => { 46060 const insertedBlock = syncStatus === 'unsynced' ? (0,external_wp_blocks_namespaceObject.parse)(content, { 46061 __unstableSkipMigrationLogs: true 46062 }) : (0,external_wp_blocks_namespaceObject.createBlock)(name, initialAttributes, (0,external_wp_blocks_namespaceObject.createBlocksFromInnerBlocksTemplate)(innerBlocks)); 46063 onInsert(insertedBlock, undefined, shouldFocusBlock, _rootClientId); 46064 }, [onInsert]); 46065 return [items, categories, collections, onSelectItem]; 46066 }; 46067 /* harmony default export */ const use_block_types_state = (useBlockTypesState); 46068 46069 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-listbox/index.js 46070 /** 46071 * WordPress dependencies 46072 */ 46073 46074 46075 /** 46076 * Internal dependencies 46077 */ 46078 46079 46080 46081 46082 46083 function InserterListbox({ 46084 children 46085 }) { 46086 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, { 46087 focusShift: true, 46088 focusWrap: "horizontal", 46089 render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {}), 46090 children: children 46091 }); 46092 } 46093 /* harmony default export */ const inserter_listbox = (InserterListbox); 46094 46095 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/no-results.js 46096 /** 46097 * WordPress dependencies 46098 */ 46099 46100 46101 46102 46103 function InserterNoResults() { 46104 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 46105 className: "block-editor-inserter__no-results", 46106 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 46107 className: "block-editor-inserter__no-results-icon", 46108 icon: block_default 46109 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 46110 children: (0,external_wp_i18n_namespaceObject.__)('No results found.') 46111 })] 46112 }); 46113 } 46114 /* harmony default export */ const no_results = (InserterNoResults); 46115 46116 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-types-tab.js 46117 /** 46118 * WordPress dependencies 46119 */ 46120 46121 46122 46123 46124 /** 46125 * Internal dependencies 46126 */ 46127 46128 46129 46130 46131 46132 46133 46134 46135 46136 const getBlockNamespace = item => item.name.split('/')[0]; 46137 const MAX_SUGGESTED_ITEMS = 6; 46138 46139 /** 46140 * Shared reference to an empty array for cases where it is important to avoid 46141 * returning a new array reference on every invocation and rerendering the component. 46142 * 46143 * @type {Array} 46144 */ 46145 const block_types_tab_EMPTY_ARRAY = []; 46146 function BlockTypesTabPanel({ 46147 items, 46148 collections, 46149 categories, 46150 onSelectItem, 46151 onHover, 46152 showMostUsedBlocks, 46153 className 46154 }) { 46155 const suggestedItems = (0,external_wp_element_namespaceObject.useMemo)(() => { 46156 return orderBy(items, 'frecency', 'desc').slice(0, MAX_SUGGESTED_ITEMS); 46157 }, [items]); 46158 const uncategorizedItems = (0,external_wp_element_namespaceObject.useMemo)(() => { 46159 return items.filter(item => !item.category); 46160 }, [items]); 46161 const itemsPerCollection = (0,external_wp_element_namespaceObject.useMemo)(() => { 46162 // Create a new Object to avoid mutating collection. 46163 const result = { 46164 ...collections 46165 }; 46166 Object.keys(collections).forEach(namespace => { 46167 result[namespace] = items.filter(item => getBlockNamespace(item) === namespace); 46168 if (result[namespace].length === 0) { 46169 delete result[namespace]; 46170 } 46171 }); 46172 return result; 46173 }, [items, collections]); 46174 46175 // Hide block preview on unmount. 46176 (0,external_wp_element_namespaceObject.useEffect)(() => () => onHover(null), []); 46177 46178 /** 46179 * The inserter contains a big number of blocks and opening it is a costful operation. 46180 * The rendering is the most costful part of it, in order to improve the responsiveness 46181 * of the "opening" action, these lazy lists allow us to render the inserter category per category, 46182 * once all the categories are rendered, we start rendering the collections and the uncategorized block types. 46183 */ 46184 const currentlyRenderedCategories = (0,external_wp_compose_namespaceObject.useAsyncList)(categories); 46185 const didRenderAllCategories = categories.length === currentlyRenderedCategories.length; 46186 46187 // Async List requires an array. 46188 const collectionEntries = (0,external_wp_element_namespaceObject.useMemo)(() => { 46189 return Object.entries(collections); 46190 }, [collections]); 46191 const currentlyRenderedCollections = (0,external_wp_compose_namespaceObject.useAsyncList)(didRenderAllCategories ? collectionEntries : block_types_tab_EMPTY_ARRAY); 46192 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 46193 className: className, 46194 children: [showMostUsedBlocks && 46195 // Only show the most used blocks if the total amount of block 46196 // is larger than 1 row, otherwise it is not so useful. 46197 items.length > 3 && !!suggestedItems.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, { 46198 title: (0,external_wp_i18n_namespaceObject._x)('Most used', 'blocks'), 46199 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, { 46200 items: suggestedItems, 46201 onSelect: onSelectItem, 46202 onHover: onHover, 46203 label: (0,external_wp_i18n_namespaceObject._x)('Most used', 'blocks') 46204 }) 46205 }), currentlyRenderedCategories.map(category => { 46206 const categoryItems = items.filter(item => item.category === category.slug); 46207 if (!categoryItems || !categoryItems.length) { 46208 return null; 46209 } 46210 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, { 46211 title: category.title, 46212 icon: category.icon, 46213 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, { 46214 items: categoryItems, 46215 onSelect: onSelectItem, 46216 onHover: onHover, 46217 label: category.title 46218 }) 46219 }, category.slug); 46220 }), didRenderAllCategories && uncategorizedItems.length > 0 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, { 46221 className: "block-editor-inserter__uncategorized-blocks-panel", 46222 title: (0,external_wp_i18n_namespaceObject.__)('Uncategorized'), 46223 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, { 46224 items: uncategorizedItems, 46225 onSelect: onSelectItem, 46226 onHover: onHover, 46227 label: (0,external_wp_i18n_namespaceObject.__)('Uncategorized') 46228 }) 46229 }), currentlyRenderedCollections.map(([namespace, collection]) => { 46230 const collectionItems = itemsPerCollection[namespace]; 46231 if (!collectionItems || !collectionItems.length) { 46232 return null; 46233 } 46234 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, { 46235 title: collection.title, 46236 icon: collection.icon, 46237 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, { 46238 items: collectionItems, 46239 onSelect: onSelectItem, 46240 onHover: onHover, 46241 label: collection.title 46242 }) 46243 }, namespace); 46244 })] 46245 }); 46246 } 46247 function BlockTypesTab({ 46248 rootClientId, 46249 onInsert, 46250 onHover, 46251 showMostUsedBlocks 46252 }, ref) { 46253 const [items, categories, collections, onSelectItem] = use_block_types_state(rootClientId, onInsert); 46254 if (!items.length) { 46255 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {}); 46256 } 46257 const itemsForCurrentRoot = []; 46258 const itemsRemaining = []; 46259 for (const item of items) { 46260 // Skip reusable blocks, they moved to the patterns tab. 46261 if (item.category === 'reusable') { 46262 continue; 46263 } 46264 if (rootClientId && item.rootClientId === rootClientId) { 46265 itemsForCurrentRoot.push(item); 46266 } else { 46267 itemsRemaining.push(item); 46268 } 46269 } 46270 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_listbox, { 46271 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 46272 ref: ref, 46273 children: [!!itemsForCurrentRoot.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 46274 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTypesTabPanel, { 46275 items: itemsForCurrentRoot, 46276 categories: categories, 46277 collections: collections, 46278 onSelectItem: onSelectItem, 46279 onHover: onHover, 46280 showMostUsedBlocks: showMostUsedBlocks, 46281 className: "block-editor-inserter__insertable-blocks-at-selection" 46282 }) 46283 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTypesTabPanel, { 46284 items: itemsRemaining, 46285 categories: categories, 46286 collections: collections, 46287 onSelectItem: onSelectItem, 46288 onHover: onHover, 46289 showMostUsedBlocks: showMostUsedBlocks, 46290 className: "block-editor-inserter__all-blocks" 46291 })] 46292 }) 46293 }); 46294 } 46295 /* harmony default export */ const block_types_tab = ((0,external_wp_element_namespaceObject.forwardRef)(BlockTypesTab)); 46296 46297 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-explorer/pattern-explorer-sidebar.js 46298 /** 46299 * WordPress dependencies 46300 */ 46301 46302 46303 46304 46305 function PatternCategoriesList({ 46306 selectedCategory, 46307 patternCategories, 46308 onClickCategory 46309 }) { 46310 const baseClassName = 'block-editor-block-patterns-explorer__sidebar'; 46311 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 46312 className: `$baseClassName}__categories-list`, 46313 children: patternCategories.map(({ 46314 name, 46315 label 46316 }) => { 46317 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 46318 __next40pxDefaultSize: true, 46319 label: label, 46320 className: `$baseClassName}__categories-list__item`, 46321 isPressed: selectedCategory === name, 46322 onClick: () => { 46323 onClickCategory(name); 46324 }, 46325 children: label 46326 }, name); 46327 }) 46328 }); 46329 } 46330 function PatternsExplorerSearch({ 46331 searchValue, 46332 setSearchValue 46333 }) { 46334 const baseClassName = 'block-editor-block-patterns-explorer__search'; 46335 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 46336 className: baseClassName, 46337 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, { 46338 __nextHasNoMarginBottom: true, 46339 onChange: setSearchValue, 46340 value: searchValue, 46341 label: (0,external_wp_i18n_namespaceObject.__)('Search for patterns'), 46342 placeholder: (0,external_wp_i18n_namespaceObject.__)('Search') 46343 }) 46344 }); 46345 } 46346 function PatternExplorerSidebar({ 46347 selectedCategory, 46348 patternCategories, 46349 onClickCategory, 46350 searchValue, 46351 setSearchValue 46352 }) { 46353 const baseClassName = 'block-editor-block-patterns-explorer__sidebar'; 46354 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 46355 className: baseClassName, 46356 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternsExplorerSearch, { 46357 searchValue: searchValue, 46358 setSearchValue: setSearchValue 46359 }), !searchValue && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternCategoriesList, { 46360 selectedCategory: selectedCategory, 46361 patternCategories: patternCategories, 46362 onClickCategory: onClickCategory 46363 })] 46364 }); 46365 } 46366 /* harmony default export */ const pattern_explorer_sidebar = (PatternExplorerSidebar); 46367 46368 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-patterns-paging/index.js 46369 /** 46370 * WordPress dependencies 46371 */ 46372 46373 46374 46375 46376 function Pagination({ 46377 currentPage, 46378 numPages, 46379 changePage, 46380 totalItems 46381 }) { 46382 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 46383 className: "block-editor-patterns__grid-pagination-wrapper", 46384 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, { 46385 variant: "muted", 46386 children: (0,external_wp_i18n_namespaceObject.sprintf)( 46387 // translators: %s: Total number of patterns. 46388 (0,external_wp_i18n_namespaceObject._n)('%s item', '%s items', totalItems), totalItems) 46389 }), numPages > 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 46390 expanded: false, 46391 spacing: 3, 46392 justify: "flex-start", 46393 className: "block-editor-patterns__grid-pagination", 46394 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 46395 expanded: false, 46396 spacing: 1, 46397 className: "block-editor-patterns__grid-pagination-previous", 46398 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button 46399 // TODO: Switch to `true` (40px size) if possible 46400 , { 46401 __next40pxDefaultSize: false, 46402 variant: "tertiary", 46403 onClick: () => changePage(1), 46404 disabled: currentPage === 1, 46405 "aria-label": (0,external_wp_i18n_namespaceObject.__)('First page'), 46406 accessibleWhenDisabled: true, 46407 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 46408 children: "\xAB" 46409 }) 46410 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button 46411 // TODO: Switch to `true` (40px size) if possible 46412 , { 46413 __next40pxDefaultSize: false, 46414 variant: "tertiary", 46415 onClick: () => changePage(currentPage - 1), 46416 disabled: currentPage === 1, 46417 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Previous page'), 46418 accessibleWhenDisabled: true, 46419 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 46420 children: "\u2039" 46421 }) 46422 })] 46423 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, { 46424 variant: "muted", 46425 children: (0,external_wp_i18n_namespaceObject.sprintf)( 46426 // translators: 1: Current page number. 2: Total number of pages. 46427 (0,external_wp_i18n_namespaceObject._x)('%1$s of %2$s', 'paging'), currentPage, numPages) 46428 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 46429 expanded: false, 46430 spacing: 1, 46431 className: "block-editor-patterns__grid-pagination-next", 46432 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button 46433 // TODO: Switch to `true` (40px size) if possible 46434 , { 46435 __next40pxDefaultSize: false, 46436 variant: "tertiary", 46437 onClick: () => changePage(currentPage + 1), 46438 disabled: currentPage === numPages, 46439 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Next page'), 46440 accessibleWhenDisabled: true, 46441 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 46442 children: "\u203A" 46443 }) 46444 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 46445 variant: "tertiary", 46446 onClick: () => changePage(numPages), 46447 disabled: currentPage === numPages, 46448 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Last page'), 46449 size: "default", 46450 accessibleWhenDisabled: true, 46451 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 46452 children: "\xBB" 46453 }) 46454 })] 46455 })] 46456 })] 46457 }); 46458 } 46459 46460 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-patterns-list/index.js 46461 /** 46462 * External dependencies 46463 */ 46464 46465 46466 /** 46467 * WordPress dependencies 46468 */ 46469 46470 46471 46472 46473 46474 46475 46476 /** 46477 * Internal dependencies 46478 */ 46479 46480 46481 46482 46483 46484 46485 46486 const WithToolTip = ({ 46487 showTooltip, 46488 title, 46489 children 46490 }) => { 46491 if (showTooltip) { 46492 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, { 46493 text: title, 46494 children: children 46495 }); 46496 } 46497 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 46498 children: children 46499 }); 46500 }; 46501 function BlockPattern({ 46502 id, 46503 isDraggable, 46504 pattern, 46505 onClick, 46506 onHover, 46507 showTitle = true, 46508 showTooltip, 46509 category 46510 }) { 46511 const [isDragging, setIsDragging] = (0,external_wp_element_namespaceObject.useState)(false); 46512 const { 46513 blocks, 46514 viewportWidth 46515 } = pattern; 46516 const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockPattern); 46517 const descriptionId = `block-editor-block-patterns-list__item-description-$instanceId}`; 46518 46519 // When we have a selected category and the pattern is draggable, we need to update the 46520 // pattern's categories in metadata to only contain the selected category, and pass this to 46521 // InserterDraggableBlocks component. We do that because we use this information for pattern 46522 // shuffling and it makes more sense to show only the ones from the initially selected category during insertion. 46523 const patternBlocks = (0,external_wp_element_namespaceObject.useMemo)(() => { 46524 if (!category || !isDraggable) { 46525 return blocks; 46526 } 46527 return (blocks !== null && blocks !== void 0 ? blocks : []).map(block => { 46528 const clonedBlock = (0,external_wp_blocks_namespaceObject.cloneBlock)(block); 46529 if (clonedBlock.attributes.metadata?.categories?.includes(category)) { 46530 clonedBlock.attributes.metadata.categories = [category]; 46531 } 46532 return clonedBlock; 46533 }); 46534 }, [blocks, isDraggable, category]); 46535 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_draggable_blocks, { 46536 isEnabled: isDraggable, 46537 blocks: patternBlocks, 46538 pattern: pattern, 46539 children: ({ 46540 draggable, 46541 onDragStart, 46542 onDragEnd 46543 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 46544 className: "block-editor-block-patterns-list__list-item", 46545 draggable: draggable, 46546 onDragStart: event => { 46547 setIsDragging(true); 46548 if (onDragStart) { 46549 onHover?.(null); 46550 onDragStart(event); 46551 } 46552 }, 46553 onDragEnd: event => { 46554 setIsDragging(false); 46555 if (onDragEnd) { 46556 onDragEnd(event); 46557 } 46558 }, 46559 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WithToolTip, { 46560 showTooltip: showTooltip && !pattern.type !== INSERTER_PATTERN_TYPES.user, 46561 title: pattern.title, 46562 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Composite.Item, { 46563 render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 46564 role: "option", 46565 "aria-label": pattern.title, 46566 "aria-describedby": pattern.description ? descriptionId : undefined, 46567 className: dist_clsx('block-editor-block-patterns-list__item', { 46568 'block-editor-block-patterns-list__list-item-synced': pattern.type === INSERTER_PATTERN_TYPES.user && !pattern.syncStatus 46569 }) 46570 }), 46571 id: id, 46572 onClick: () => { 46573 onClick(pattern, blocks); 46574 onHover?.(null); 46575 }, 46576 onMouseEnter: () => { 46577 if (isDragging) { 46578 return; 46579 } 46580 onHover?.(pattern); 46581 }, 46582 onMouseLeave: () => onHover?.(null), 46583 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, { 46584 blocks: blocks, 46585 viewportWidth: viewportWidth 46586 }), showTitle && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 46587 className: "block-editor-patterns__pattern-details", 46588 spacing: 2, 46589 children: [pattern.type === INSERTER_PATTERN_TYPES.user && !pattern.syncStatus && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 46590 className: "block-editor-patterns__pattern-icon-wrapper", 46591 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 46592 className: "block-editor-patterns__pattern-icon", 46593 icon: library_symbol 46594 }) 46595 }), (!showTooltip || pattern.type === INSERTER_PATTERN_TYPES.user) && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 46596 className: "block-editor-block-patterns-list__item-title", 46597 children: pattern.title 46598 })] 46599 }), !!pattern.description && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 46600 id: descriptionId, 46601 children: pattern.description 46602 })] 46603 }) 46604 }) 46605 }) 46606 }); 46607 } 46608 function BlockPatternPlaceholder() { 46609 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 46610 className: "block-editor-block-patterns-list__item is-placeholder" 46611 }); 46612 } 46613 function BlockPatternsList({ 46614 isDraggable, 46615 blockPatterns, 46616 shownPatterns, 46617 onHover, 46618 onClickPattern, 46619 orientation, 46620 label = (0,external_wp_i18n_namespaceObject.__)('Block patterns'), 46621 category, 46622 showTitle = true, 46623 showTitlesAsTooltip, 46624 pagingProps 46625 }, ref) { 46626 const [activeCompositeId, setActiveCompositeId] = (0,external_wp_element_namespaceObject.useState)(undefined); 46627 (0,external_wp_element_namespaceObject.useEffect)(() => { 46628 // Reset the active composite item whenever the available patterns change, 46629 // to make sure that Composite widget can receive focus correctly when its 46630 // composite items change. The first composite item will receive focus. 46631 const firstCompositeItemId = blockPatterns.find(pattern => shownPatterns.includes(pattern))?.name; 46632 setActiveCompositeId(firstCompositeItemId); 46633 }, [shownPatterns, blockPatterns]); 46634 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Composite, { 46635 orientation: orientation, 46636 activeId: activeCompositeId, 46637 setActiveId: setActiveCompositeId, 46638 role: "listbox", 46639 className: "block-editor-block-patterns-list", 46640 "aria-label": label, 46641 ref: ref, 46642 children: [blockPatterns.map(pattern => { 46643 const isShown = shownPatterns.includes(pattern); 46644 return isShown ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockPattern, { 46645 id: pattern.name, 46646 pattern: pattern, 46647 onClick: onClickPattern, 46648 onHover: onHover, 46649 isDraggable: isDraggable, 46650 showTitle: showTitle, 46651 showTooltip: showTitlesAsTooltip, 46652 category: category 46653 }, pattern.name) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockPatternPlaceholder, {}, pattern.name); 46654 }), pagingProps && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Pagination, { 46655 ...pagingProps 46656 })] 46657 }); 46658 } 46659 /* harmony default export */ const block_patterns_list = ((0,external_wp_element_namespaceObject.forwardRef)(BlockPatternsList)); 46660 46661 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/hooks/use-insertion-point.js 46662 /** 46663 * WordPress dependencies 46664 */ 46665 46666 46667 46668 46669 46670 46671 /** 46672 * Internal dependencies 46673 */ 46674 46675 46676 function getIndex({ 46677 destinationRootClientId, 46678 destinationIndex, 46679 rootClientId, 46680 registry 46681 }) { 46682 if (rootClientId === destinationRootClientId) { 46683 return destinationIndex; 46684 } 46685 const parents = ['', ...registry.select(store).getBlockParents(destinationRootClientId), destinationRootClientId]; 46686 const parentIndex = parents.indexOf(rootClientId); 46687 if (parentIndex !== -1) { 46688 return registry.select(store).getBlockIndex(parents[parentIndex + 1]) + 1; 46689 } 46690 return registry.select(store).getBlockOrder(rootClientId).length; 46691 } 46692 46693 /** 46694 * @typedef WPInserterConfig 46695 * 46696 * @property {string=} rootClientId If set, insertion will be into the 46697 * block with this ID. 46698 * @property {number=} insertionIndex If set, insertion will be into this 46699 * explicit position. 46700 * @property {string=} clientId If set, insertion will be after the 46701 * block with this ID. 46702 * @property {boolean=} isAppender Whether the inserter is an appender 46703 * or not. 46704 * @property {Function=} onSelect Called after insertion. 46705 */ 46706 46707 /** 46708 * Returns the insertion point state given the inserter config. 46709 * 46710 * @param {WPInserterConfig} config Inserter Config. 46711 * @return {Array} Insertion Point State (rootClientID, onInsertBlocks and onToggle). 46712 */ 46713 function useInsertionPoint({ 46714 rootClientId = '', 46715 insertionIndex, 46716 clientId, 46717 isAppender, 46718 onSelect, 46719 shouldFocusBlock = true, 46720 selectBlockOnInsert = true 46721 }) { 46722 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 46723 const { 46724 getSelectedBlock 46725 } = (0,external_wp_data_namespaceObject.useSelect)(store); 46726 const { 46727 destinationRootClientId, 46728 destinationIndex 46729 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 46730 const { 46731 getSelectedBlockClientId, 46732 getBlockRootClientId, 46733 getBlockIndex, 46734 getBlockOrder, 46735 getSectionRootClientId, 46736 __unstableGetEditorMode 46737 } = unlock(select(store)); 46738 const selectedBlockClientId = getSelectedBlockClientId(); 46739 let _destinationRootClientId = rootClientId; 46740 let _destinationIndex; 46741 if (insertionIndex !== undefined) { 46742 // Insert into a specific index. 46743 _destinationIndex = insertionIndex; 46744 } else if (clientId) { 46745 // Insert after a specific client ID. 46746 _destinationIndex = getBlockIndex(clientId); 46747 } else if (!isAppender && selectedBlockClientId) { 46748 const sectionRootClientId = getSectionRootClientId(); 46749 46750 // Avoids empty inserter when the selected block is acting 46751 // as the "root". 46752 // See https://github.com/WordPress/gutenberg/pull/66214. 46753 if (__unstableGetEditorMode() === 'zoom-out' && sectionRootClientId === selectedBlockClientId) { 46754 _destinationRootClientId = sectionRootClientId; 46755 _destinationIndex = getBlockOrder(_destinationRootClientId).length; 46756 } else { 46757 _destinationRootClientId = getBlockRootClientId(selectedBlockClientId); 46758 _destinationIndex = getBlockIndex(selectedBlockClientId) + 1; 46759 } 46760 } else { 46761 // Insert at the end of the list. 46762 _destinationIndex = getBlockOrder(_destinationRootClientId).length; 46763 } 46764 return { 46765 destinationRootClientId: _destinationRootClientId, 46766 destinationIndex: _destinationIndex 46767 }; 46768 }, [rootClientId, insertionIndex, clientId, isAppender]); 46769 const { 46770 replaceBlocks, 46771 insertBlocks, 46772 showInsertionPoint, 46773 hideInsertionPoint, 46774 setLastFocus 46775 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 46776 const onInsertBlocks = (0,external_wp_element_namespaceObject.useCallback)((blocks, meta, shouldForceFocusBlock = false, _rootClientId) => { 46777 // When we are trying to move focus or select a new block on insert, we also 46778 // need to clear the last focus to avoid the focus being set to the wrong block 46779 // when tabbing back into the canvas if the block was added from outside the 46780 // editor canvas. 46781 if (shouldForceFocusBlock || shouldFocusBlock || selectBlockOnInsert) { 46782 setLastFocus(null); 46783 } 46784 const selectedBlock = getSelectedBlock(); 46785 if (!isAppender && selectedBlock && (0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(selectedBlock)) { 46786 replaceBlocks(selectedBlock.clientId, blocks, null, shouldFocusBlock || shouldForceFocusBlock ? 0 : null, meta); 46787 } else { 46788 insertBlocks(blocks, isAppender || _rootClientId === undefined ? destinationIndex : getIndex({ 46789 destinationRootClientId, 46790 destinationIndex, 46791 rootClientId: _rootClientId, 46792 registry 46793 }), isAppender || _rootClientId === undefined ? destinationRootClientId : _rootClientId, selectBlockOnInsert, shouldFocusBlock || shouldForceFocusBlock ? 0 : null, meta); 46794 } 46795 const blockLength = Array.isArray(blocks) ? blocks.length : 1; 46796 const message = (0,external_wp_i18n_namespaceObject.sprintf)( 46797 // translators: %d: the name of the block that has been added 46798 (0,external_wp_i18n_namespaceObject._n)('%d block added.', '%d blocks added.', blockLength), blockLength); 46799 (0,external_wp_a11y_namespaceObject.speak)(message); 46800 if (onSelect) { 46801 onSelect(blocks); 46802 } 46803 }, [isAppender, getSelectedBlock, replaceBlocks, insertBlocks, destinationRootClientId, destinationIndex, onSelect, shouldFocusBlock, selectBlockOnInsert]); 46804 const onToggleInsertionPoint = (0,external_wp_element_namespaceObject.useCallback)(item => { 46805 if (item?.hasOwnProperty('rootClientId')) { 46806 showInsertionPoint(item.rootClientId, getIndex({ 46807 destinationRootClientId, 46808 destinationIndex, 46809 rootClientId: item.rootClientId, 46810 registry 46811 })); 46812 } else { 46813 hideInsertionPoint(); 46814 } 46815 }, [showInsertionPoint, hideInsertionPoint, destinationRootClientId, destinationIndex]); 46816 return [destinationRootClientId, onInsertBlocks, onToggleInsertionPoint]; 46817 } 46818 /* harmony default export */ const use_insertion_point = (useInsertionPoint); 46819 46820 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/hooks/use-patterns-state.js 46821 /** 46822 * WordPress dependencies 46823 */ 46824 46825 46826 46827 46828 46829 46830 /** 46831 * Internal dependencies 46832 */ 46833 46834 46835 46836 /** 46837 * Retrieves the block patterns inserter state. 46838 * 46839 * @param {Function} onInsert function called when inserter a list of blocks. 46840 * @param {string=} rootClientId Insertion's root client ID. 46841 * 46842 * @param {string} selectedCategory The selected pattern category. 46843 * @return {Array} Returns the patterns state. (patterns, categories, onSelect handler) 46844 */ 46845 const usePatternsState = (onInsert, rootClientId, selectedCategory) => { 46846 const { 46847 patternCategories, 46848 patterns, 46849 userPatternCategories 46850 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 46851 const { 46852 __experimentalGetAllowedPatterns, 46853 getSettings 46854 } = select(store); 46855 const { 46856 __experimentalUserPatternCategories, 46857 __experimentalBlockPatternCategories 46858 } = getSettings(); 46859 return { 46860 patterns: __experimentalGetAllowedPatterns(rootClientId), 46861 userPatternCategories: __experimentalUserPatternCategories, 46862 patternCategories: __experimentalBlockPatternCategories 46863 }; 46864 }, [rootClientId]); 46865 const allCategories = (0,external_wp_element_namespaceObject.useMemo)(() => { 46866 const categories = [...patternCategories]; 46867 userPatternCategories?.forEach(userCategory => { 46868 if (!categories.find(existingCategory => existingCategory.name === userCategory.name)) { 46869 categories.push(userCategory); 46870 } 46871 }); 46872 return categories; 46873 }, [patternCategories, userPatternCategories]); 46874 const { 46875 createSuccessNotice 46876 } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store); 46877 const onClickPattern = (0,external_wp_element_namespaceObject.useCallback)((pattern, blocks) => { 46878 const patternBlocks = pattern.type === INSERTER_PATTERN_TYPES.user && pattern.syncStatus !== 'unsynced' ? [(0,external_wp_blocks_namespaceObject.createBlock)('core/block', { 46879 ref: pattern.id 46880 })] : blocks; 46881 onInsert((patternBlocks !== null && patternBlocks !== void 0 ? patternBlocks : []).map(block => { 46882 const clonedBlock = (0,external_wp_blocks_namespaceObject.cloneBlock)(block); 46883 if (clonedBlock.attributes.metadata?.categories?.includes(selectedCategory)) { 46884 clonedBlock.attributes.metadata.categories = [selectedCategory]; 46885 } 46886 return clonedBlock; 46887 }), pattern.name); 46888 createSuccessNotice((0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: block pattern title. */ 46889 (0,external_wp_i18n_namespaceObject.__)('Block pattern "%s" inserted.'), pattern.title), { 46890 type: 'snackbar', 46891 id: 'block-pattern-inserted-notice' 46892 }); 46893 }, [createSuccessNotice, onInsert, selectedCategory]); 46894 return [patterns, allCategories, onClickPattern]; 46895 }; 46896 /* harmony default export */ const use_patterns_state = (usePatternsState); 46897 46898 // EXTERNAL MODULE: ./node_modules/remove-accents/index.js 46899 var remove_accents = __webpack_require__(9681); 46900 var remove_accents_default = /*#__PURE__*/__webpack_require__.n(remove_accents); 46901 ;// ./node_modules/lower-case/dist.es2015/index.js 46902 /** 46903 * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt 46904 */ 46905 var SUPPORTED_LOCALE = { 46906 tr: { 46907 regexp: /\u0130|\u0049|\u0049\u0307/g, 46908 map: { 46909 İ: "\u0069", 46910 I: "\u0131", 46911 İ: "\u0069", 46912 }, 46913 }, 46914 az: { 46915 regexp: /\u0130/g, 46916 map: { 46917 İ: "\u0069", 46918 I: "\u0131", 46919 İ: "\u0069", 46920 }, 46921 }, 46922 lt: { 46923 regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g, 46924 map: { 46925 I: "\u0069\u0307", 46926 J: "\u006A\u0307", 46927 Į: "\u012F\u0307", 46928 Ì: "\u0069\u0307\u0300", 46929 Í: "\u0069\u0307\u0301", 46930 Ĩ: "\u0069\u0307\u0303", 46931 }, 46932 }, 46933 }; 46934 /** 46935 * Localized lower case. 46936 */ 46937 function localeLowerCase(str, locale) { 46938 var lang = SUPPORTED_LOCALE[locale.toLowerCase()]; 46939 if (lang) 46940 return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; })); 46941 return lowerCase(str); 46942 } 46943 /** 46944 * Lower case as a function. 46945 */ 46946 function lowerCase(str) { 46947 return str.toLowerCase(); 46948 } 46949 46950 ;// ./node_modules/no-case/dist.es2015/index.js 46951 46952 // Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case"). 46953 var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g]; 46954 // Remove all non-word characters. 46955 var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi; 46956 /** 46957 * Normalize the string into something other libraries can manipulate easier. 46958 */ 46959 function noCase(input, options) { 46960 if (options === void 0) { options = {}; } 46961 var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d; 46962 var result = dist_es2015_replace(dist_es2015_replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0"); 46963 var start = 0; 46964 var end = result.length; 46965 // Trim the delimiter from around the output string. 46966 while (result.charAt(start) === "\0") 46967 start++; 46968 while (result.charAt(end - 1) === "\0") 46969 end--; 46970 // Transform each token independently. 46971 return result.slice(start, end).split("\0").map(transform).join(delimiter); 46972 } 46973 /** 46974 * Replace `re` in the input string with the replacement value. 46975 */ 46976 function dist_es2015_replace(input, re, value) { 46977 if (re instanceof RegExp) 46978 return input.replace(re, value); 46979 return re.reduce(function (input, re) { return input.replace(re, value); }, input); 46980 } 46981 46982 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/search-items.js 46983 /** 46984 * External dependencies 46985 */ 46986 46987 46988 46989 // Default search helpers. 46990 const defaultGetName = item => item.name || ''; 46991 const defaultGetTitle = item => item.title; 46992 const defaultGetDescription = item => item.description || ''; 46993 const defaultGetKeywords = item => item.keywords || []; 46994 const defaultGetCategory = item => item.category; 46995 const defaultGetCollection = () => null; 46996 46997 // Normalization regexes 46998 const splitRegexp = [/([\p{Ll}\p{Lo}\p{N}])([\p{Lu}\p{Lt}])/gu, 46999 // One lowercase or digit, followed by one uppercase. 47000 /([\p{Lu}\p{Lt}])([\p{Lu}\p{Lt}][\p{Ll}\p{Lo}])/gu // One uppercase followed by one uppercase and one lowercase. 47001 ]; 47002 const stripRegexp = /(\p{C}|\p{P}|\p{S})+/giu; // Anything that's not a punctuation, symbol or control/format character. 47003 47004 // Normalization cache 47005 const extractedWords = new Map(); 47006 const normalizedStrings = new Map(); 47007 47008 /** 47009 * Extracts words from an input string. 47010 * 47011 * @param {string} input The input string. 47012 * 47013 * @return {Array} Words, extracted from the input string. 47014 */ 47015 function extractWords(input = '') { 47016 if (extractedWords.has(input)) { 47017 return extractedWords.get(input); 47018 } 47019 const result = noCase(input, { 47020 splitRegexp, 47021 stripRegexp 47022 }).split(' ').filter(Boolean); 47023 extractedWords.set(input, result); 47024 return result; 47025 } 47026 47027 /** 47028 * Sanitizes the search input string. 47029 * 47030 * @param {string} input The search input to normalize. 47031 * 47032 * @return {string} The normalized search input. 47033 */ 47034 function normalizeString(input = '') { 47035 if (normalizedStrings.has(input)) { 47036 return normalizedStrings.get(input); 47037 } 47038 47039 // Disregard diacritics. 47040 // Input: "média" 47041 let result = remove_accents_default()(input); 47042 47043 // Accommodate leading slash, matching autocomplete expectations. 47044 // Input: "/media" 47045 result = result.replace(/^\//, ''); 47046 47047 // Lowercase. 47048 // Input: "MEDIA" 47049 result = result.toLowerCase(); 47050 normalizedStrings.set(input, result); 47051 return result; 47052 } 47053 47054 /** 47055 * Converts the search term into a list of normalized terms. 47056 * 47057 * @param {string} input The search term to normalize. 47058 * 47059 * @return {string[]} The normalized list of search terms. 47060 */ 47061 const getNormalizedSearchTerms = (input = '') => { 47062 return extractWords(normalizeString(input)); 47063 }; 47064 const removeMatchingTerms = (unmatchedTerms, unprocessedTerms) => { 47065 return unmatchedTerms.filter(term => !getNormalizedSearchTerms(unprocessedTerms).some(unprocessedTerm => unprocessedTerm.includes(term))); 47066 }; 47067 const searchBlockItems = (items, categories, collections, searchInput) => { 47068 const normalizedSearchTerms = getNormalizedSearchTerms(searchInput); 47069 if (normalizedSearchTerms.length === 0) { 47070 return items; 47071 } 47072 const config = { 47073 getCategory: item => categories.find(({ 47074 slug 47075 }) => slug === item.category)?.title, 47076 getCollection: item => collections[item.name.split('/')[0]]?.title 47077 }; 47078 return searchItems(items, searchInput, config); 47079 }; 47080 47081 /** 47082 * Filters an item list given a search term. 47083 * 47084 * @param {Array} items Item list 47085 * @param {string} searchInput Search input. 47086 * @param {Object} config Search Config. 47087 * 47088 * @return {Array} Filtered item list. 47089 */ 47090 const searchItems = (items = [], searchInput = '', config = {}) => { 47091 const normalizedSearchTerms = getNormalizedSearchTerms(searchInput); 47092 if (normalizedSearchTerms.length === 0) { 47093 return items; 47094 } 47095 const rankedItems = items.map(item => { 47096 return [item, getItemSearchRank(item, searchInput, config)]; 47097 }).filter(([, rank]) => rank > 0); 47098 rankedItems.sort(([, rank1], [, rank2]) => rank2 - rank1); 47099 return rankedItems.map(([item]) => item); 47100 }; 47101 47102 /** 47103 * Get the search rank for a given item and a specific search term. 47104 * The better the match, the higher the rank. 47105 * If the rank equals 0, it should be excluded from the results. 47106 * 47107 * @param {Object} item Item to filter. 47108 * @param {string} searchTerm Search term. 47109 * @param {Object} config Search Config. 47110 * 47111 * @return {number} Search Rank. 47112 */ 47113 function getItemSearchRank(item, searchTerm, config = {}) { 47114 const { 47115 getName = defaultGetName, 47116 getTitle = defaultGetTitle, 47117 getDescription = defaultGetDescription, 47118 getKeywords = defaultGetKeywords, 47119 getCategory = defaultGetCategory, 47120 getCollection = defaultGetCollection 47121 } = config; 47122 const name = getName(item); 47123 const title = getTitle(item); 47124 const description = getDescription(item); 47125 const keywords = getKeywords(item); 47126 const category = getCategory(item); 47127 const collection = getCollection(item); 47128 const normalizedSearchInput = normalizeString(searchTerm); 47129 const normalizedTitle = normalizeString(title); 47130 let rank = 0; 47131 47132 // Prefers exact matches 47133 // Then prefers if the beginning of the title matches the search term 47134 // name, keywords, categories, collection, variations match come later. 47135 if (normalizedSearchInput === normalizedTitle) { 47136 rank += 30; 47137 } else if (normalizedTitle.startsWith(normalizedSearchInput)) { 47138 rank += 20; 47139 } else { 47140 const terms = [name, title, description, ...keywords, category, collection].join(' '); 47141 const normalizedSearchTerms = extractWords(normalizedSearchInput); 47142 const unmatchedTerms = removeMatchingTerms(normalizedSearchTerms, terms); 47143 if (unmatchedTerms.length === 0) { 47144 rank += 10; 47145 } 47146 } 47147 47148 // Give a better rank to "core" namespaced items. 47149 if (rank !== 0 && name.startsWith('core/')) { 47150 const isCoreBlockVariation = name !== item.id; 47151 // Give a bit better rank to "core" blocks over "core" block variations. 47152 rank += isCoreBlockVariation ? 1 : 2; 47153 } 47154 return rank; 47155 } 47156 47157 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/hooks/use-patterns-paging.js 47158 /** 47159 * WordPress dependencies 47160 */ 47161 47162 47163 47164 const PAGE_SIZE = 20; 47165 const INITIAL_INSERTER_RESULTS = 5; 47166 47167 /** 47168 * Supplies values needed to page the patterns list client side. 47169 * 47170 * @param {Array} currentCategoryPatterns An array of the current patterns to display. 47171 * @param {string} currentCategory The currently selected category. 47172 * @param {Object} scrollContainerRef Ref of container to to find scroll container for when moving between pages. 47173 * @param {string} currentFilter The currently search filter. 47174 * 47175 * @return {Object} Returns the relevant paging values. (totalItems, categoryPatternsList, numPages, changePage, currentPage) 47176 */ 47177 function usePatternsPaging(currentCategoryPatterns, currentCategory, scrollContainerRef, currentFilter = '') { 47178 const [currentPage, setCurrentPage] = (0,external_wp_element_namespaceObject.useState)(1); 47179 const previousCategory = (0,external_wp_compose_namespaceObject.usePrevious)(currentCategory); 47180 const previousFilter = (0,external_wp_compose_namespaceObject.usePrevious)(currentFilter); 47181 if ((previousCategory !== currentCategory || previousFilter !== currentFilter) && currentPage !== 1) { 47182 setCurrentPage(1); 47183 } 47184 const totalItems = currentCategoryPatterns.length; 47185 const pageIndex = currentPage - 1; 47186 const categoryPatterns = (0,external_wp_element_namespaceObject.useMemo)(() => { 47187 return currentCategoryPatterns.slice(pageIndex * PAGE_SIZE, pageIndex * PAGE_SIZE + PAGE_SIZE); 47188 }, [pageIndex, currentCategoryPatterns]); 47189 const categoryPatternsAsyncList = (0,external_wp_compose_namespaceObject.useAsyncList)(categoryPatterns, { 47190 step: INITIAL_INSERTER_RESULTS 47191 }); 47192 const numPages = Math.ceil(currentCategoryPatterns.length / PAGE_SIZE); 47193 const changePage = page => { 47194 const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(scrollContainerRef?.current); 47195 scrollContainer?.scrollTo(0, 0); 47196 setCurrentPage(page); 47197 }; 47198 (0,external_wp_element_namespaceObject.useEffect)(function scrollToTopOnCategoryChange() { 47199 const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(scrollContainerRef?.current); 47200 scrollContainer?.scrollTo(0, 0); 47201 }, [currentCategory, scrollContainerRef]); 47202 return { 47203 totalItems, 47204 categoryPatterns, 47205 categoryPatternsAsyncList, 47206 numPages, 47207 changePage, 47208 currentPage 47209 }; 47210 } 47211 47212 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-explorer/pattern-list.js 47213 /** 47214 * WordPress dependencies 47215 */ 47216 47217 47218 47219 47220 47221 47222 /** 47223 * Internal dependencies 47224 */ 47225 47226 47227 47228 47229 47230 47231 47232 47233 47234 47235 47236 function PatternsListHeader({ 47237 filterValue, 47238 filteredBlockPatternsLength 47239 }) { 47240 if (!filterValue) { 47241 return null; 47242 } 47243 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, { 47244 level: 2, 47245 lineHeight: "48px", 47246 className: "block-editor-block-patterns-explorer__search-results-count", 47247 children: (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %d: number of patterns. */ 47248 (0,external_wp_i18n_namespaceObject._n)('%d pattern found', '%d patterns found', filteredBlockPatternsLength), filteredBlockPatternsLength) 47249 }); 47250 } 47251 function PatternList({ 47252 searchValue, 47253 selectedCategory, 47254 patternCategories, 47255 rootClientId 47256 }) { 47257 const container = (0,external_wp_element_namespaceObject.useRef)(); 47258 const debouncedSpeak = (0,external_wp_compose_namespaceObject.useDebounce)(external_wp_a11y_namespaceObject.speak, 500); 47259 const [destinationRootClientId, onInsertBlocks] = use_insertion_point({ 47260 rootClientId, 47261 shouldFocusBlock: true 47262 }); 47263 const [patterns,, onClickPattern] = use_patterns_state(onInsertBlocks, destinationRootClientId, selectedCategory); 47264 const registeredPatternCategories = (0,external_wp_element_namespaceObject.useMemo)(() => patternCategories.map(patternCategory => patternCategory.name), [patternCategories]); 47265 const filteredBlockPatterns = (0,external_wp_element_namespaceObject.useMemo)(() => { 47266 const filteredPatterns = patterns.filter(pattern => { 47267 if (selectedCategory === allPatternsCategory.name) { 47268 return true; 47269 } 47270 if (selectedCategory === myPatternsCategory.name && pattern.type === INSERTER_PATTERN_TYPES.user) { 47271 return true; 47272 } 47273 if (selectedCategory === 'uncategorized') { 47274 var _pattern$categories$s; 47275 const hasKnownCategory = (_pattern$categories$s = pattern.categories?.some(category => registeredPatternCategories.includes(category))) !== null && _pattern$categories$s !== void 0 ? _pattern$categories$s : false; 47276 return !pattern.categories?.length || !hasKnownCategory; 47277 } 47278 return pattern.categories?.includes(selectedCategory); 47279 }); 47280 if (!searchValue) { 47281 return filteredPatterns; 47282 } 47283 return searchItems(filteredPatterns, searchValue); 47284 }, [searchValue, patterns, selectedCategory, registeredPatternCategories]); 47285 47286 // Announce search results on change. 47287 (0,external_wp_element_namespaceObject.useEffect)(() => { 47288 if (!searchValue) { 47289 return; 47290 } 47291 const count = filteredBlockPatterns.length; 47292 const resultsFoundMessage = (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %d: number of results. */ 47293 (0,external_wp_i18n_namespaceObject._n)('%d result found.', '%d results found.', count), count); 47294 debouncedSpeak(resultsFoundMessage); 47295 }, [searchValue, debouncedSpeak, filteredBlockPatterns.length]); 47296 const pagingProps = usePatternsPaging(filteredBlockPatterns, selectedCategory, container); 47297 47298 // Reset page when search value changes. 47299 const [previousSearchValue, setPreviousSearchValue] = (0,external_wp_element_namespaceObject.useState)(searchValue); 47300 if (searchValue !== previousSearchValue) { 47301 setPreviousSearchValue(searchValue); 47302 pagingProps.changePage(1); 47303 } 47304 const hasItems = !!filteredBlockPatterns?.length; 47305 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 47306 className: "block-editor-block-patterns-explorer__list", 47307 ref: container, 47308 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternsListHeader, { 47309 filterValue: searchValue, 47310 filteredBlockPatternsLength: filteredBlockPatterns.length 47311 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_listbox, { 47312 children: hasItems && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 47313 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_list, { 47314 shownPatterns: pagingProps.categoryPatternsAsyncList, 47315 blockPatterns: pagingProps.categoryPatterns, 47316 onClickPattern: onClickPattern, 47317 isDraggable: false 47318 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Pagination, { 47319 ...pagingProps 47320 })] 47321 }) 47322 })] 47323 }); 47324 } 47325 /* harmony default export */ const pattern_list = (PatternList); 47326 47327 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/use-pattern-categories.js 47328 /** 47329 * WordPress dependencies 47330 */ 47331 47332 47333 47334 47335 /** 47336 * Internal dependencies 47337 */ 47338 47339 47340 function hasRegisteredCategory(pattern, allCategories) { 47341 if (!pattern.categories || !pattern.categories.length) { 47342 return false; 47343 } 47344 return pattern.categories.some(cat => allCategories.some(category => category.name === cat)); 47345 } 47346 function usePatternCategories(rootClientId, sourceFilter = 'all') { 47347 const [patterns, allCategories] = use_patterns_state(undefined, rootClientId); 47348 const filteredPatterns = (0,external_wp_element_namespaceObject.useMemo)(() => sourceFilter === 'all' ? patterns : patterns.filter(pattern => !isPatternFiltered(pattern, sourceFilter)), [sourceFilter, patterns]); 47349 47350 // Remove any empty categories. 47351 const populatedCategories = (0,external_wp_element_namespaceObject.useMemo)(() => { 47352 const categories = allCategories.filter(category => filteredPatterns.some(pattern => pattern.categories?.includes(category.name))).sort((a, b) => a.label.localeCompare(b.label)); 47353 if (filteredPatterns.some(pattern => !hasRegisteredCategory(pattern, allCategories)) && !categories.find(category => category.name === 'uncategorized')) { 47354 categories.push({ 47355 name: 'uncategorized', 47356 label: (0,external_wp_i18n_namespaceObject._x)('Uncategorized') 47357 }); 47358 } 47359 if (filteredPatterns.some(pattern => pattern.type === INSERTER_PATTERN_TYPES.user)) { 47360 categories.unshift(myPatternsCategory); 47361 } 47362 if (filteredPatterns.length > 0) { 47363 categories.unshift({ 47364 name: allPatternsCategory.name, 47365 label: allPatternsCategory.label 47366 }); 47367 } 47368 (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %d: number of categories . */ 47369 (0,external_wp_i18n_namespaceObject._n)('%d category button displayed.', '%d category buttons displayed.', categories.length), categories.length)); 47370 return categories; 47371 }, [allCategories, filteredPatterns]); 47372 return populatedCategories; 47373 } 47374 47375 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-explorer/index.js 47376 /** 47377 * WordPress dependencies 47378 */ 47379 47380 47381 47382 47383 /** 47384 * Internal dependencies 47385 */ 47386 47387 47388 47389 47390 47391 function PatternsExplorer({ 47392 initialCategory, 47393 rootClientId 47394 }) { 47395 const [searchValue, setSearchValue] = (0,external_wp_element_namespaceObject.useState)(''); 47396 const [selectedCategory, setSelectedCategory] = (0,external_wp_element_namespaceObject.useState)(initialCategory?.name); 47397 const patternCategories = usePatternCategories(rootClientId); 47398 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 47399 className: "block-editor-block-patterns-explorer", 47400 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_explorer_sidebar, { 47401 selectedCategory: selectedCategory, 47402 patternCategories: patternCategories, 47403 onClickCategory: setSelectedCategory, 47404 searchValue: searchValue, 47405 setSearchValue: setSearchValue 47406 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_list, { 47407 searchValue: searchValue, 47408 selectedCategory: selectedCategory, 47409 patternCategories: patternCategories, 47410 rootClientId: rootClientId 47411 })] 47412 }); 47413 } 47414 function PatternsExplorerModal({ 47415 onModalClose, 47416 ...restProps 47417 }) { 47418 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, { 47419 title: (0,external_wp_i18n_namespaceObject.__)('Patterns'), 47420 onRequestClose: onModalClose, 47421 isFullScreen: true, 47422 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternsExplorer, { 47423 ...restProps 47424 }) 47425 }); 47426 } 47427 /* harmony default export */ const block_patterns_explorer = (PatternsExplorerModal); 47428 47429 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/mobile-tab-navigation.js 47430 /** 47431 * WordPress dependencies 47432 */ 47433 47434 47435 47436 47437 47438 function ScreenHeader({ 47439 title 47440 }) { 47441 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalVStack, { 47442 spacing: 0, 47443 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalView, { 47444 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, { 47445 marginBottom: 0, 47446 paddingX: 4, 47447 paddingY: 3, 47448 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 47449 spacing: 2, 47450 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNavigatorBackButton, { 47451 style: 47452 // TODO: This style override is also used in ToolsPanelHeader. 47453 // It should be supported out-of-the-box by Button. 47454 { 47455 minWidth: 24, 47456 padding: 0 47457 }, 47458 icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left, 47459 size: "small", 47460 label: (0,external_wp_i18n_namespaceObject.__)('Back') 47461 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, { 47462 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, { 47463 level: 5, 47464 children: title 47465 }) 47466 })] 47467 }) 47468 }) 47469 }) 47470 }); 47471 } 47472 function MobileTabNavigation({ 47473 categories, 47474 children 47475 }) { 47476 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalNavigatorProvider, { 47477 initialPath: "/", 47478 className: "block-editor-inserter__mobile-tab-navigation", 47479 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNavigatorScreen, { 47480 path: "/", 47481 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, { 47482 children: categories.map(category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNavigatorButton, { 47483 path: `/category/$category.name}`, 47484 as: external_wp_components_namespaceObject.__experimentalItem, 47485 isAction: true, 47486 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 47487 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexBlock, { 47488 children: category.label 47489 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 47490 icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right 47491 })] 47492 }) 47493 }, category.name)) 47494 }) 47495 }), categories.map(category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalNavigatorScreen, { 47496 path: `/category/$category.name}`, 47497 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ScreenHeader, { 47498 title: (0,external_wp_i18n_namespaceObject.__)('Back') 47499 }), children(category)] 47500 }, category.name))] 47501 }); 47502 } 47503 47504 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/patterns-filter.js 47505 /** 47506 * WordPress dependencies 47507 */ 47508 47509 47510 47511 47512 47513 /** 47514 * Internal dependencies 47515 */ 47516 47517 47518 47519 47520 const getShouldDisableSyncFilter = sourceFilter => sourceFilter !== 'all' && sourceFilter !== 'user'; 47521 const getShouldHideSourcesFilter = category => { 47522 return category.name === myPatternsCategory.name; 47523 }; 47524 const PATTERN_SOURCE_MENU_OPTIONS = [{ 47525 value: 'all', 47526 label: (0,external_wp_i18n_namespaceObject._x)('All', 'patterns') 47527 }, { 47528 value: INSERTER_PATTERN_TYPES.directory, 47529 label: (0,external_wp_i18n_namespaceObject.__)('Pattern Directory') 47530 }, { 47531 value: INSERTER_PATTERN_TYPES.theme, 47532 label: (0,external_wp_i18n_namespaceObject.__)('Theme & Plugins') 47533 }, { 47534 value: INSERTER_PATTERN_TYPES.user, 47535 label: (0,external_wp_i18n_namespaceObject.__)('User') 47536 }]; 47537 function PatternsFilter({ 47538 setPatternSyncFilter, 47539 setPatternSourceFilter, 47540 patternSyncFilter, 47541 patternSourceFilter, 47542 scrollContainerRef, 47543 category 47544 }) { 47545 // If the category is `myPatterns` then we need to set the source filter to `user`, but 47546 // we do this by deriving from props rather than calling setPatternSourceFilter otherwise 47547 // the user may be confused when switching to another category if the haven't explicity set 47548 // this filter themselves. 47549 const currentPatternSourceFilter = category.name === myPatternsCategory.name ? INSERTER_PATTERN_TYPES.user : patternSourceFilter; 47550 47551 // We need to disable the sync filter option if the source filter is not 'all' or 'user' 47552 // otherwise applying them will just result in no patterns being shown. 47553 const shouldDisableSyncFilter = getShouldDisableSyncFilter(currentPatternSourceFilter); 47554 47555 // We also hide the directory and theme source filter if the category is `myPatterns` 47556 // otherwise there will only be one option available. 47557 const shouldHideSourcesFilter = getShouldHideSourcesFilter(category); 47558 const patternSyncMenuOptions = (0,external_wp_element_namespaceObject.useMemo)(() => [{ 47559 value: 'all', 47560 label: (0,external_wp_i18n_namespaceObject._x)('All', 'patterns') 47561 }, { 47562 value: INSERTER_SYNC_TYPES.full, 47563 label: (0,external_wp_i18n_namespaceObject._x)('Synced', 'patterns'), 47564 disabled: shouldDisableSyncFilter 47565 }, { 47566 value: INSERTER_SYNC_TYPES.unsynced, 47567 label: (0,external_wp_i18n_namespaceObject._x)('Not synced', 'patterns'), 47568 disabled: shouldDisableSyncFilter 47569 }], [shouldDisableSyncFilter]); 47570 function handleSetSourceFilterChange(newSourceFilter) { 47571 setPatternSourceFilter(newSourceFilter); 47572 if (getShouldDisableSyncFilter(newSourceFilter)) { 47573 setPatternSyncFilter('all'); 47574 } 47575 } 47576 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 47577 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, { 47578 popoverProps: { 47579 placement: 'right-end' 47580 }, 47581 label: (0,external_wp_i18n_namespaceObject.__)('Filter patterns'), 47582 toggleProps: { 47583 size: 'compact' 47584 }, 47585 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 47586 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, { 47587 width: "24", 47588 height: "24", 47589 viewBox: "0 0 24 24", 47590 fill: "none", 47591 xmlns: "http://www.w3.org/2000/svg", 47592 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, { 47593 d: "M10 17.5H14V16H10V17.5ZM6 6V7.5H18V6H6ZM8 12.5H16V11H8V12.5Z", 47594 fill: "currentColor" 47595 }) 47596 }) 47597 }), 47598 children: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 47599 children: [!shouldHideSourcesFilter && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, { 47600 label: (0,external_wp_i18n_namespaceObject.__)('Source'), 47601 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItemsChoice, { 47602 choices: PATTERN_SOURCE_MENU_OPTIONS, 47603 onSelect: value => { 47604 handleSetSourceFilterChange(value); 47605 scrollContainerRef.current?.scrollTo(0, 0); 47606 }, 47607 value: currentPatternSourceFilter 47608 }) 47609 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, { 47610 label: (0,external_wp_i18n_namespaceObject.__)('Type'), 47611 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItemsChoice, { 47612 choices: patternSyncMenuOptions, 47613 onSelect: value => { 47614 setPatternSyncFilter(value); 47615 scrollContainerRef.current?.scrollTo(0, 0); 47616 }, 47617 value: patternSyncFilter 47618 }) 47619 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 47620 className: "block-editor-tool-selector__help", 47621 children: (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)('Patterns are available from the <Link>WordPress.org Pattern Directory</Link>, bundled in the active theme, or created by users on this site. Only patterns created on this site can be synced.'), { 47622 Link: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, { 47623 href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/patterns/') 47624 }) 47625 }) 47626 })] 47627 }) 47628 }) 47629 }); 47630 } 47631 47632 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/pattern-category-previews.js 47633 /** 47634 * WordPress dependencies 47635 */ 47636 47637 47638 47639 47640 47641 /** 47642 * Internal dependencies 47643 */ 47644 47645 47646 47647 47648 47649 47650 47651 47652 47653 47654 const pattern_category_previews_noop = () => {}; 47655 function PatternCategoryPreviews({ 47656 rootClientId, 47657 onInsert, 47658 onHover = pattern_category_previews_noop, 47659 category, 47660 showTitlesAsTooltip 47661 }) { 47662 const isZoomOutMode = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).__unstableGetEditorMode() === 'zoom-out', []); 47663 const [allPatterns,, onClickPattern] = use_patterns_state(onInsert, rootClientId, category?.name); 47664 const [patternSyncFilter, setPatternSyncFilter] = (0,external_wp_element_namespaceObject.useState)('all'); 47665 const [patternSourceFilter, setPatternSourceFilter] = (0,external_wp_element_namespaceObject.useState)('all'); 47666 const availableCategories = usePatternCategories(rootClientId, patternSourceFilter); 47667 const scrollContainerRef = (0,external_wp_element_namespaceObject.useRef)(); 47668 const currentCategoryPatterns = (0,external_wp_element_namespaceObject.useMemo)(() => allPatterns.filter(pattern => { 47669 if (isPatternFiltered(pattern, patternSourceFilter, patternSyncFilter)) { 47670 return false; 47671 } 47672 if (category.name === allPatternsCategory.name) { 47673 return true; 47674 } 47675 if (category.name === myPatternsCategory.name && pattern.type === INSERTER_PATTERN_TYPES.user) { 47676 return true; 47677 } 47678 if (category.name === 'uncategorized') { 47679 // The uncategorized category should show all the patterns without any category... 47680 if (!pattern.categories) { 47681 return true; 47682 } 47683 47684 // ...or with no available category. 47685 return !pattern.categories.some(catName => availableCategories.some(c => c.name === catName)); 47686 } 47687 return pattern.categories?.includes(category.name); 47688 }), [allPatterns, availableCategories, category.name, patternSourceFilter, patternSyncFilter]); 47689 const pagingProps = usePatternsPaging(currentCategoryPatterns, category, scrollContainerRef); 47690 const { 47691 changePage 47692 } = pagingProps; 47693 47694 // Hide block pattern preview on unmount. 47695 // eslint-disable-next-line react-hooks/exhaustive-deps 47696 (0,external_wp_element_namespaceObject.useEffect)(() => () => onHover(null), []); 47697 const onSetPatternSyncFilter = (0,external_wp_element_namespaceObject.useCallback)(value => { 47698 setPatternSyncFilter(value); 47699 changePage(1); 47700 }, [setPatternSyncFilter, changePage]); 47701 const onSetPatternSourceFilter = (0,external_wp_element_namespaceObject.useCallback)(value => { 47702 setPatternSourceFilter(value); 47703 changePage(1); 47704 }, [setPatternSourceFilter, changePage]); 47705 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 47706 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 47707 spacing: 2, 47708 className: "block-editor-inserter__patterns-category-panel-header", 47709 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 47710 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexBlock, { 47711 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, { 47712 className: "block-editor-inserter__patterns-category-panel-title", 47713 size: 13, 47714 level: 4, 47715 as: "div", 47716 children: category.label 47717 }) 47718 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternsFilter, { 47719 patternSyncFilter: patternSyncFilter, 47720 patternSourceFilter: patternSourceFilter, 47721 setPatternSyncFilter: onSetPatternSyncFilter, 47722 setPatternSourceFilter: onSetPatternSourceFilter, 47723 scrollContainerRef: scrollContainerRef, 47724 category: category 47725 })] 47726 }), !currentCategoryPatterns.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, { 47727 variant: "muted", 47728 className: "block-editor-inserter__patterns-category-no-results", 47729 children: (0,external_wp_i18n_namespaceObject.__)('No results found') 47730 })] 47731 }), currentCategoryPatterns.length > 0 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 47732 children: [isZoomOutMode && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, { 47733 size: "12", 47734 as: "p", 47735 className: "block-editor-inserter__help-text", 47736 children: (0,external_wp_i18n_namespaceObject.__)('Drag and drop patterns into the canvas.') 47737 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_list, { 47738 ref: scrollContainerRef, 47739 shownPatterns: pagingProps.categoryPatternsAsyncList, 47740 blockPatterns: pagingProps.categoryPatterns, 47741 onClickPattern: onClickPattern, 47742 onHover: onHover, 47743 label: category.label, 47744 orientation: "vertical", 47745 category: category.name, 47746 isDraggable: true, 47747 showTitlesAsTooltip: showTitlesAsTooltip, 47748 patternFilter: patternSourceFilter, 47749 pagingProps: pagingProps 47750 })] 47751 })] 47752 }); 47753 } 47754 47755 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/category-tabs/index.js 47756 /** 47757 * WordPress dependencies 47758 */ 47759 47760 47761 47762 47763 47764 /** 47765 * Internal dependencies 47766 */ 47767 47768 47769 47770 const { 47771 Tabs: category_tabs_Tabs 47772 } = unlock(external_wp_components_namespaceObject.privateApis); 47773 function CategoryTabs({ 47774 categories, 47775 selectedCategory, 47776 onSelectCategory, 47777 children 47778 }) { 47779 // Copied from InterfaceSkeleton. 47780 const ANIMATION_DURATION = 0.25; 47781 const disableMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)(); 47782 const defaultTransition = { 47783 type: 'tween', 47784 duration: disableMotion ? 0 : ANIMATION_DURATION, 47785 ease: [0.6, 0, 0.4, 1] 47786 }; 47787 const previousSelectedCategory = (0,external_wp_compose_namespaceObject.usePrevious)(selectedCategory); 47788 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(category_tabs_Tabs, { 47789 className: "block-editor-inserter__category-tabs", 47790 selectOnMove: false, 47791 selectedTabId: selectedCategory ? selectedCategory.name : null, 47792 orientation: "vertical", 47793 onSelect: categoryId => { 47794 // Pass the full category object 47795 onSelectCategory(categories.find(category => category.name === categoryId)); 47796 }, 47797 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs_Tabs.TabList, { 47798 className: "block-editor-inserter__category-tablist", 47799 children: categories.map(category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs_Tabs.Tab, { 47800 tabId: category.name, 47801 className: "block-editor-inserter__category-tab", 47802 "aria-label": category.label, 47803 "aria-current": category === selectedCategory ? 'true' : undefined, 47804 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 47805 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexBlock, { 47806 children: category.label 47807 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 47808 icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right 47809 })] 47810 }) 47811 }, category.name)) 47812 }), categories.map(category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs_Tabs.TabPanel, { 47813 tabId: category.name, 47814 focusable: false, 47815 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, { 47816 className: "block-editor-inserter__category-panel", 47817 initial: !previousSelectedCategory ? 'closed' : 'open', 47818 animate: "open", 47819 variants: { 47820 open: { 47821 transform: 'translateX( 0 )', 47822 transitionEnd: { 47823 zIndex: '1' 47824 } 47825 }, 47826 closed: { 47827 transform: 'translateX( -100% )', 47828 zIndex: '-1' 47829 } 47830 }, 47831 transition: defaultTransition, 47832 children: children 47833 }) 47834 }, category.name))] 47835 }); 47836 } 47837 /* harmony default export */ const category_tabs = (CategoryTabs); 47838 47839 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/index.js 47840 /** 47841 * WordPress dependencies 47842 */ 47843 47844 47845 47846 47847 47848 47849 /** 47850 * Internal dependencies 47851 */ 47852 47853 47854 47855 47856 47857 47858 47859 47860 47861 47862 47863 function BlockPatternsTab({ 47864 onSelectCategory, 47865 selectedCategory, 47866 onInsert, 47867 rootClientId, 47868 setHasCategories, 47869 children 47870 }) { 47871 const [showPatternsExplorer, setShowPatternsExplorer] = (0,external_wp_element_namespaceObject.useState)(false); 47872 const categories = usePatternCategories(rootClientId); 47873 const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<'); 47874 const isResolvingPatterns = (0,external_wp_data_namespaceObject.useSelect)(select => unlock(select(store)).isResolvingPatterns(), []); 47875 (0,external_wp_element_namespaceObject.useEffect)(() => { 47876 setHasCategories(!!categories.length); 47877 }, [categories, setHasCategories]); 47878 if (isResolvingPatterns) { 47879 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 47880 className: "block-editor-inserter__patterns-loading", 47881 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {}) 47882 }); 47883 } 47884 if (!categories.length) { 47885 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {}); 47886 } 47887 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 47888 children: [!isMobile && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 47889 className: "block-editor-inserter__block-patterns-tabs-container", 47890 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs, { 47891 categories: categories, 47892 selectedCategory: selectedCategory, 47893 onSelectCategory: onSelectCategory, 47894 children: children 47895 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 47896 __next40pxDefaultSize: true, 47897 className: "block-editor-inserter__patterns-explore-button", 47898 onClick: () => setShowPatternsExplorer(true), 47899 variant: "secondary", 47900 children: (0,external_wp_i18n_namespaceObject.__)('Explore all patterns') 47901 })] 47902 }), isMobile && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MobileTabNavigation, { 47903 categories: categories, 47904 children: category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 47905 className: "block-editor-inserter__category-panel", 47906 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternCategoryPreviews, { 47907 onInsert: onInsert, 47908 rootClientId: rootClientId, 47909 category: category, 47910 showTitlesAsTooltip: false 47911 }, category.name) 47912 }) 47913 }), showPatternsExplorer && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_explorer, { 47914 initialCategory: selectedCategory || categories[0], 47915 patternCategories: categories, 47916 onModalClose: () => setShowPatternsExplorer(false), 47917 rootClientId: rootClientId 47918 })] 47919 }); 47920 } 47921 /* harmony default export */ const block_patterns_tab = (BlockPatternsTab); 47922 47923 ;// ./node_modules/@wordpress/icons/build-module/library/external.js 47924 /** 47925 * WordPress dependencies 47926 */ 47927 47928 47929 const external = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 47930 xmlns: "http://www.w3.org/2000/svg", 47931 viewBox: "0 0 24 24", 47932 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 47933 d: "M19.5 4.5h-7V6h4.44l-5.97 5.97 1.06 1.06L18 7.06v4.44h1.5v-7Zm-13 1a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2v-3H17v3a.5.5 0 0 1-.5.5h-10a.5.5 0 0 1-.5-.5v-10a.5.5 0 0 1 .5-.5h3V5.5h-3Z" 47934 }) 47935 }); 47936 /* harmony default export */ const library_external = (external); 47937 47938 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/utils.js 47939 /** 47940 * WordPress dependencies 47941 */ 47942 47943 47944 const mediaTypeTag = { 47945 image: 'img', 47946 video: 'video', 47947 audio: 'audio' 47948 }; 47949 47950 /** @typedef {import('./hooks').InserterMediaItem} InserterMediaItem */ 47951 47952 /** 47953 * Creates a block and a preview element from a media object. 47954 * 47955 * @param {InserterMediaItem} media The media object to create the block from. 47956 * @param {('image'|'audio'|'video')} mediaType The media type to create the block for. 47957 * @return {[WPBlock, JSX.Element]} An array containing the block and the preview element. 47958 */ 47959 function getBlockAndPreviewFromMedia(media, mediaType) { 47960 // Add the common attributes between the different media types. 47961 const attributes = { 47962 id: media.id || undefined, 47963 caption: media.caption || undefined 47964 }; 47965 const mediaSrc = media.url; 47966 const alt = media.alt || undefined; 47967 if (mediaType === 'image') { 47968 attributes.url = mediaSrc; 47969 attributes.alt = alt; 47970 } else if (['video', 'audio'].includes(mediaType)) { 47971 attributes.src = mediaSrc; 47972 } 47973 const PreviewTag = mediaTypeTag[mediaType]; 47974 const preview = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewTag, { 47975 src: media.previewUrl || mediaSrc, 47976 alt: alt, 47977 controls: mediaType === 'audio' ? true : undefined, 47978 inert: "true", 47979 onError: ({ 47980 currentTarget 47981 }) => { 47982 // Fall back to the media source if the preview cannot be loaded. 47983 if (currentTarget.src === media.previewUrl) { 47984 currentTarget.src = mediaSrc; 47985 } 47986 } 47987 }); 47988 return [(0,external_wp_blocks_namespaceObject.createBlock)(`core/$mediaType}`, attributes), preview]; 47989 } 47990 47991 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/media-preview.js 47992 /** 47993 * External dependencies 47994 */ 47995 47996 47997 /** 47998 * WordPress dependencies 47999 */ 48000 48001 48002 48003 48004 48005 48006 48007 48008 48009 /** 48010 * Internal dependencies 48011 */ 48012 48013 48014 48015 48016 48017 48018 const ALLOWED_MEDIA_TYPES = ['image']; 48019 const MAXIMUM_TITLE_LENGTH = 25; 48020 const MEDIA_OPTIONS_POPOVER_PROPS = { 48021 position: 'bottom left', 48022 className: 'block-editor-inserter__media-list__item-preview-options__popover' 48023 }; 48024 function MediaPreviewOptions({ 48025 category, 48026 media 48027 }) { 48028 if (!category.getReportUrl) { 48029 return null; 48030 } 48031 const reportUrl = category.getReportUrl(media); 48032 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, { 48033 className: "block-editor-inserter__media-list__item-preview-options", 48034 label: (0,external_wp_i18n_namespaceObject.__)('Options'), 48035 popoverProps: MEDIA_OPTIONS_POPOVER_PROPS, 48036 icon: more_vertical, 48037 children: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, { 48038 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 48039 onClick: () => window.open(reportUrl, '_blank').focus(), 48040 icon: library_external, 48041 children: (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: The media type to report e.g: "image", "video", "audio" */ 48042 (0,external_wp_i18n_namespaceObject.__)('Report %s'), category.mediaType) 48043 }) 48044 }) 48045 }); 48046 } 48047 function InsertExternalImageModal({ 48048 onClose, 48049 onSubmit 48050 }) { 48051 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Modal, { 48052 title: (0,external_wp_i18n_namespaceObject.__)('Insert external image'), 48053 onRequestClose: onClose, 48054 className: "block-editor-inserter-media-tab-media-preview-inserter-external-image-modal", 48055 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 48056 spacing: 3, 48057 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 48058 children: (0,external_wp_i18n_namespaceObject.__)('This image cannot be uploaded to your Media Library, but it can still be inserted as an external image.') 48059 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 48060 children: (0,external_wp_i18n_namespaceObject.__)('External images can be removed by the external provider without warning and could even have legal compliance issues related to privacy legislation.') 48061 })] 48062 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, { 48063 className: "block-editor-block-lock-modal__actions", 48064 justify: "flex-end", 48065 expanded: false, 48066 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 48067 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 48068 __next40pxDefaultSize: true, 48069 variant: "tertiary", 48070 onClick: onClose, 48071 children: (0,external_wp_i18n_namespaceObject.__)('Cancel') 48072 }) 48073 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 48074 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 48075 __next40pxDefaultSize: true, 48076 variant: "primary", 48077 onClick: onSubmit, 48078 children: (0,external_wp_i18n_namespaceObject.__)('Insert') 48079 }) 48080 })] 48081 })] 48082 }); 48083 } 48084 function MediaPreview({ 48085 media, 48086 onClick, 48087 category 48088 }) { 48089 const [showExternalUploadModal, setShowExternalUploadModal] = (0,external_wp_element_namespaceObject.useState)(false); 48090 const [isHovered, setIsHovered] = (0,external_wp_element_namespaceObject.useState)(false); 48091 const [isInserting, setIsInserting] = (0,external_wp_element_namespaceObject.useState)(false); 48092 const [block, preview] = (0,external_wp_element_namespaceObject.useMemo)(() => getBlockAndPreviewFromMedia(media, category.mediaType), [media, category.mediaType]); 48093 const { 48094 createErrorNotice, 48095 createSuccessNotice 48096 } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store); 48097 const { 48098 getSettings 48099 } = (0,external_wp_data_namespaceObject.useSelect)(store); 48100 const onMediaInsert = (0,external_wp_element_namespaceObject.useCallback)(previewBlock => { 48101 // Prevent multiple uploads when we're in the process of inserting. 48102 if (isInserting) { 48103 return; 48104 } 48105 const settings = getSettings(); 48106 const clonedBlock = (0,external_wp_blocks_namespaceObject.cloneBlock)(previewBlock); 48107 const { 48108 id, 48109 url, 48110 caption 48111 } = clonedBlock.attributes; 48112 48113 // User has no permission to upload media. 48114 if (!id && !settings.mediaUpload) { 48115 setShowExternalUploadModal(true); 48116 return; 48117 } 48118 48119 // Media item already exists in library, so just insert it. 48120 if (!!id) { 48121 onClick(clonedBlock); 48122 return; 48123 } 48124 setIsInserting(true); 48125 // Media item does not exist in library, so try to upload it. 48126 // Fist fetch the image data. This may fail if the image host 48127 // doesn't allow CORS with the domain. 48128 // If this happens, we insert the image block using the external 48129 // URL and let the user know about the possible implications. 48130 window.fetch(url).then(response => response.blob()).then(blob => { 48131 settings.mediaUpload({ 48132 filesList: [blob], 48133 additionalData: { 48134 caption 48135 }, 48136 onFileChange([img]) { 48137 if ((0,external_wp_blob_namespaceObject.isBlobURL)(img.url)) { 48138 return; 48139 } 48140 onClick({ 48141 ...clonedBlock, 48142 attributes: { 48143 ...clonedBlock.attributes, 48144 id: img.id, 48145 url: img.url 48146 } 48147 }); 48148 createSuccessNotice((0,external_wp_i18n_namespaceObject.__)('Image uploaded and inserted.'), { 48149 type: 'snackbar' 48150 }); 48151 setIsInserting(false); 48152 }, 48153 allowedTypes: ALLOWED_MEDIA_TYPES, 48154 onError(message) { 48155 createErrorNotice(message, { 48156 type: 'snackbar' 48157 }); 48158 setIsInserting(false); 48159 } 48160 }); 48161 }).catch(() => { 48162 setShowExternalUploadModal(true); 48163 setIsInserting(false); 48164 }); 48165 }, [isInserting, getSettings, onClick, createSuccessNotice, createErrorNotice]); 48166 const title = typeof media.title === 'string' ? media.title : media.title?.rendered || (0,external_wp_i18n_namespaceObject.__)('no title'); 48167 let truncatedTitle; 48168 if (title.length > MAXIMUM_TITLE_LENGTH) { 48169 const omission = '...'; 48170 truncatedTitle = title.slice(0, MAXIMUM_TITLE_LENGTH - omission.length) + omission; 48171 } 48172 const onMouseEnter = (0,external_wp_element_namespaceObject.useCallback)(() => setIsHovered(true), []); 48173 const onMouseLeave = (0,external_wp_element_namespaceObject.useCallback)(() => setIsHovered(false), []); 48174 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 48175 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_draggable_blocks, { 48176 isEnabled: true, 48177 blocks: [block], 48178 children: ({ 48179 draggable, 48180 onDragStart, 48181 onDragEnd 48182 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 48183 className: dist_clsx('block-editor-inserter__media-list__list-item', { 48184 'is-hovered': isHovered 48185 }), 48186 draggable: draggable, 48187 onDragStart: onDragStart, 48188 onDragEnd: onDragEnd, 48189 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 48190 onMouseEnter: onMouseEnter, 48191 onMouseLeave: onMouseLeave, 48192 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, { 48193 text: truncatedTitle || title, 48194 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite.Item, { 48195 render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 48196 "aria-label": title, 48197 role: "option", 48198 className: "block-editor-inserter__media-list__item" 48199 }), 48200 onClick: () => onMediaInsert(block), 48201 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 48202 className: "block-editor-inserter__media-list__item-preview", 48203 children: [preview, isInserting && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 48204 className: "block-editor-inserter__media-list__item-preview-spinner", 48205 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {}) 48206 })] 48207 }) 48208 }) 48209 }), !isInserting && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaPreviewOptions, { 48210 category: category, 48211 media: media 48212 })] 48213 }) 48214 }) 48215 }), showExternalUploadModal && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InsertExternalImageModal, { 48216 onClose: () => setShowExternalUploadModal(false), 48217 onSubmit: () => { 48218 onClick((0,external_wp_blocks_namespaceObject.cloneBlock)(block)); 48219 createSuccessNotice((0,external_wp_i18n_namespaceObject.__)('Image inserted.'), { 48220 type: 'snackbar' 48221 }); 48222 setShowExternalUploadModal(false); 48223 } 48224 })] 48225 }); 48226 } 48227 48228 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/media-list.js 48229 /** 48230 * WordPress dependencies 48231 */ 48232 48233 48234 48235 /** 48236 * Internal dependencies 48237 */ 48238 48239 48240 function MediaList({ 48241 mediaList, 48242 category, 48243 onClick, 48244 label = (0,external_wp_i18n_namespaceObject.__)('Media List') 48245 }) { 48246 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, { 48247 role: "listbox", 48248 className: "block-editor-inserter__media-list", 48249 "aria-label": label, 48250 children: mediaList.map((media, index) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaPreview, { 48251 media: media, 48252 category: category, 48253 onClick: onClick 48254 }, media.id || media.sourceId || index)) 48255 }); 48256 } 48257 /* harmony default export */ const media_list = (MediaList); 48258 48259 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/hooks.js 48260 /** 48261 * WordPress dependencies 48262 */ 48263 48264 48265 48266 /** 48267 * Internal dependencies 48268 */ 48269 48270 48271 48272 /** @typedef {import('../../../store/actions').InserterMediaRequest} InserterMediaRequest */ 48273 /** @typedef {import('../../../store/actions').InserterMediaItem} InserterMediaItem */ 48274 48275 /** 48276 * Fetches media items based on the provided category. 48277 * Each media category is responsible for providing a `fetch` function. 48278 * 48279 * @param {Object} category The media category to fetch results for. 48280 * @param {InserterMediaRequest} query The query args to use for the request. 48281 * @return {InserterMediaItem[]} The media results. 48282 */ 48283 function useMediaResults(category, query = {}) { 48284 const [mediaList, setMediaList] = (0,external_wp_element_namespaceObject.useState)(); 48285 const [isLoading, setIsLoading] = (0,external_wp_element_namespaceObject.useState)(false); 48286 // We need to keep track of the last request made because 48287 // multiple request can be fired without knowing the order 48288 // of resolution, and we need to ensure we are showing 48289 // the results of the last request. 48290 // In the future we could use AbortController to cancel previous 48291 // requests, but we don't for now as it involves adding support 48292 // for this to `core-data` package. 48293 const lastRequestRef = (0,external_wp_element_namespaceObject.useRef)(); 48294 (0,external_wp_element_namespaceObject.useEffect)(() => { 48295 (async () => { 48296 const key = JSON.stringify({ 48297 category: category.name, 48298 ...query 48299 }); 48300 lastRequestRef.current = key; 48301 setIsLoading(true); 48302 setMediaList([]); // Empty the previous results. 48303 const _media = await category.fetch?.(query); 48304 if (key === lastRequestRef.current) { 48305 setMediaList(_media); 48306 setIsLoading(false); 48307 } 48308 })(); 48309 }, [category.name, ...Object.values(query)]); 48310 return { 48311 mediaList, 48312 isLoading 48313 }; 48314 } 48315 function useMediaCategories(rootClientId) { 48316 const [categories, setCategories] = (0,external_wp_element_namespaceObject.useState)([]); 48317 const inserterMediaCategories = (0,external_wp_data_namespaceObject.useSelect)(select => unlock(select(store)).getInserterMediaCategories(), []); 48318 const { 48319 canInsertImage, 48320 canInsertVideo, 48321 canInsertAudio 48322 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 48323 const { 48324 canInsertBlockType 48325 } = select(store); 48326 return { 48327 canInsertImage: canInsertBlockType('core/image', rootClientId), 48328 canInsertVideo: canInsertBlockType('core/video', rootClientId), 48329 canInsertAudio: canInsertBlockType('core/audio', rootClientId) 48330 }; 48331 }, [rootClientId]); 48332 (0,external_wp_element_namespaceObject.useEffect)(() => { 48333 (async () => { 48334 const _categories = []; 48335 // If `inserterMediaCategories` is not defined in 48336 // block editor settings, do not show any media categories. 48337 if (!inserterMediaCategories) { 48338 return; 48339 } 48340 // Loop through categories to check if they have at least one media item. 48341 const categoriesHaveMedia = new Map(await Promise.all(inserterMediaCategories.map(async category => { 48342 // Some sources are external and we don't need to make a request. 48343 if (category.isExternalResource) { 48344 return [category.name, true]; 48345 } 48346 let results = []; 48347 try { 48348 results = await category.fetch({ 48349 per_page: 1 48350 }); 48351 } catch (e) { 48352 // If the request fails, we shallow the error and just don't show 48353 // the category, in order to not break the media tab. 48354 } 48355 return [category.name, !!results.length]; 48356 }))); 48357 // We need to filter out categories that don't have any media items or 48358 // whose corresponding block type is not allowed to be inserted, based 48359 // on the category's `mediaType`. 48360 const canInsertMediaType = { 48361 image: canInsertImage, 48362 video: canInsertVideo, 48363 audio: canInsertAudio 48364 }; 48365 inserterMediaCategories.forEach(category => { 48366 if (canInsertMediaType[category.mediaType] && categoriesHaveMedia.get(category.name)) { 48367 _categories.push(category); 48368 } 48369 }); 48370 if (!!_categories.length) { 48371 setCategories(_categories); 48372 } 48373 })(); 48374 }, [canInsertImage, canInsertVideo, canInsertAudio, inserterMediaCategories]); 48375 return categories; 48376 } 48377 48378 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/media-panel.js 48379 /** 48380 * WordPress dependencies 48381 */ 48382 48383 48384 48385 48386 /** 48387 * Internal dependencies 48388 */ 48389 48390 48391 48392 48393 48394 const INITIAL_MEDIA_ITEMS_PER_PAGE = 10; 48395 function MediaCategoryPanel({ 48396 rootClientId, 48397 onInsert, 48398 category 48399 }) { 48400 const [search, setSearch, debouncedSearch] = (0,external_wp_compose_namespaceObject.useDebouncedInput)(); 48401 const { 48402 mediaList, 48403 isLoading 48404 } = useMediaResults(category, { 48405 per_page: !!debouncedSearch ? 20 : INITIAL_MEDIA_ITEMS_PER_PAGE, 48406 search: debouncedSearch 48407 }); 48408 const baseCssClass = 'block-editor-inserter__media-panel'; 48409 const searchLabel = category.labels.search_items || (0,external_wp_i18n_namespaceObject.__)('Search'); 48410 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 48411 className: baseCssClass, 48412 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, { 48413 __nextHasNoMarginBottom: true, 48414 className: `$baseCssClass}-search`, 48415 onChange: setSearch, 48416 value: search, 48417 label: searchLabel, 48418 placeholder: searchLabel 48419 }), isLoading && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 48420 className: `$baseCssClass}-spinner`, 48421 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {}) 48422 }), !isLoading && !mediaList?.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {}), !isLoading && !!mediaList?.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_list, { 48423 rootClientId: rootClientId, 48424 onClick: onInsert, 48425 mediaList: mediaList, 48426 category: category 48427 })] 48428 }); 48429 } 48430 48431 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/media-tab.js 48432 /** 48433 * WordPress dependencies 48434 */ 48435 48436 48437 48438 48439 48440 /** 48441 * Internal dependencies 48442 */ 48443 48444 48445 48446 48447 48448 48449 48450 48451 48452 48453 48454 const media_tab_ALLOWED_MEDIA_TYPES = ['image', 'video', 'audio']; 48455 function MediaTab({ 48456 rootClientId, 48457 selectedCategory, 48458 onSelectCategory, 48459 setHasCategories, 48460 onInsert, 48461 children 48462 }) { 48463 const mediaCategories = useMediaCategories(rootClientId); 48464 const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<'); 48465 const baseCssClass = 'block-editor-inserter__media-tabs'; 48466 const onSelectMedia = (0,external_wp_element_namespaceObject.useCallback)(media => { 48467 if (!media?.url) { 48468 return; 48469 } 48470 const [block] = getBlockAndPreviewFromMedia(media, media.type); 48471 onInsert(block); 48472 }, [onInsert]); 48473 const categories = (0,external_wp_element_namespaceObject.useMemo)(() => mediaCategories.map(mediaCategory => ({ 48474 ...mediaCategory, 48475 label: mediaCategory.labels.name 48476 })), [mediaCategories]); 48477 (0,external_wp_element_namespaceObject.useEffect)(() => { 48478 setHasCategories(!!categories.length); 48479 }, [categories, setHasCategories]); 48480 if (!categories.length) { 48481 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {}); 48482 } 48483 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 48484 children: [!isMobile && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 48485 className: `$baseCssClass}-container`, 48486 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs, { 48487 categories: categories, 48488 selectedCategory: selectedCategory, 48489 onSelectCategory: onSelectCategory, 48490 children: children 48491 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(check, { 48492 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_upload, { 48493 multiple: false, 48494 onSelect: onSelectMedia, 48495 allowedTypes: media_tab_ALLOWED_MEDIA_TYPES, 48496 render: ({ 48497 open 48498 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 48499 __next40pxDefaultSize: true, 48500 onClick: event => { 48501 // Safari doesn't emit a focus event on button elements when 48502 // clicked and we need to manually focus the button here. 48503 // The reason is that core's Media Library modal explicitly triggers a 48504 // focus event and therefore a `blur` event is triggered on a different 48505 // element, which doesn't contain the `data-unstable-ignore-focus-outside-for-relatedtarget` 48506 // attribute making the Inserter dialog to close. 48507 event.target.focus(); 48508 open(); 48509 }, 48510 className: "block-editor-inserter__media-library-button", 48511 variant: "secondary", 48512 "data-unstable-ignore-focus-outside-for-relatedtarget": ".media-modal", 48513 children: (0,external_wp_i18n_namespaceObject.__)('Open Media Library') 48514 }) 48515 }) 48516 })] 48517 }), isMobile && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MobileTabNavigation, { 48518 categories: categories, 48519 children: category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaCategoryPanel, { 48520 onInsert: onInsert, 48521 rootClientId: rootClientId, 48522 category: category 48523 }) 48524 })] 48525 }); 48526 } 48527 /* harmony default export */ const media_tab = (MediaTab); 48528 48529 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-menu-extension/index.js 48530 /** 48531 * WordPress dependencies 48532 */ 48533 48534 const { 48535 Fill: __unstableInserterMenuExtension, 48536 Slot 48537 } = (0,external_wp_components_namespaceObject.createSlotFill)('__unstableInserterMenuExtension'); 48538 __unstableInserterMenuExtension.Slot = Slot; 48539 /* harmony default export */ const inserter_menu_extension = (__unstableInserterMenuExtension); 48540 48541 ;// ./node_modules/@wordpress/block-editor/build-module/utils/order-inserter-block-items.js 48542 /** @typedef {import('../store/selectors').WPEditorInserterItem} WPEditorInserterItem */ 48543 48544 /** 48545 * Helper function to order inserter block items according to a provided array of prioritized blocks. 48546 * 48547 * @param {WPEditorInserterItem[]} items The array of editor inserter block items to be sorted. 48548 * @param {string[]} priority The array of block names to be prioritized. 48549 * @return {WPEditorInserterItem[]} The sorted array of editor inserter block items. 48550 */ 48551 const orderInserterBlockItems = (items, priority) => { 48552 if (!priority) { 48553 return items; 48554 } 48555 items.sort(({ 48556 id: aName 48557 }, { 48558 id: bName 48559 }) => { 48560 // Sort block items according to `priority`. 48561 let aIndex = priority.indexOf(aName); 48562 let bIndex = priority.indexOf(bName); 48563 // All other block items should come after that. 48564 if (aIndex < 0) { 48565 aIndex = priority.length; 48566 } 48567 if (bIndex < 0) { 48568 bIndex = priority.length; 48569 } 48570 return aIndex - bIndex; 48571 }); 48572 return items; 48573 }; 48574 48575 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/search-results.js 48576 /** 48577 * WordPress dependencies 48578 */ 48579 48580 48581 48582 48583 48584 48585 48586 /** 48587 * Internal dependencies 48588 */ 48589 48590 48591 48592 48593 48594 48595 48596 48597 48598 48599 48600 48601 48602 48603 48604 const search_results_INITIAL_INSERTER_RESULTS = 9; 48605 /** 48606 * Shared reference to an empty array for cases where it is important to avoid 48607 * returning a new array reference on every invocation and rerendering the component. 48608 * 48609 * @type {Array} 48610 */ 48611 const search_results_EMPTY_ARRAY = []; 48612 function InserterSearchResults({ 48613 filterValue, 48614 onSelect, 48615 onHover, 48616 onHoverPattern, 48617 rootClientId, 48618 clientId, 48619 isAppender, 48620 __experimentalInsertionIndex, 48621 maxBlockPatterns, 48622 maxBlockTypes, 48623 showBlockDirectory = false, 48624 isDraggable = true, 48625 shouldFocusBlock = true, 48626 prioritizePatterns, 48627 selectBlockOnInsert, 48628 isQuick 48629 }) { 48630 const debouncedSpeak = (0,external_wp_compose_namespaceObject.useDebounce)(external_wp_a11y_namespaceObject.speak, 500); 48631 const { 48632 prioritizedBlocks 48633 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 48634 const blockListSettings = select(store).getBlockListSettings(rootClientId); 48635 return { 48636 prioritizedBlocks: blockListSettings?.prioritizedInserterBlocks || search_results_EMPTY_ARRAY 48637 }; 48638 }, [rootClientId]); 48639 const [destinationRootClientId, onInsertBlocks] = use_insertion_point({ 48640 onSelect, 48641 rootClientId, 48642 clientId, 48643 isAppender, 48644 insertionIndex: __experimentalInsertionIndex, 48645 shouldFocusBlock, 48646 selectBlockOnInsert 48647 }); 48648 const [blockTypes, blockTypeCategories, blockTypeCollections, onSelectBlockType] = use_block_types_state(destinationRootClientId, onInsertBlocks, isQuick); 48649 const [patterns,, onClickPattern] = use_patterns_state(onInsertBlocks, destinationRootClientId); 48650 const filteredBlockPatterns = (0,external_wp_element_namespaceObject.useMemo)(() => { 48651 if (maxBlockPatterns === 0) { 48652 return []; 48653 } 48654 const results = searchItems(patterns, filterValue); 48655 return maxBlockPatterns !== undefined ? results.slice(0, maxBlockPatterns) : results; 48656 }, [filterValue, patterns, maxBlockPatterns]); 48657 let maxBlockTypesToShow = maxBlockTypes; 48658 if (prioritizePatterns && filteredBlockPatterns.length > 2) { 48659 maxBlockTypesToShow = 0; 48660 } 48661 const filteredBlockTypes = (0,external_wp_element_namespaceObject.useMemo)(() => { 48662 if (maxBlockTypesToShow === 0) { 48663 return []; 48664 } 48665 const nonPatternBlockTypes = blockTypes.filter(blockType => blockType.name !== 'core/block'); 48666 let orderedItems = orderBy(nonPatternBlockTypes, 'frecency', 'desc'); 48667 if (!filterValue && prioritizedBlocks.length) { 48668 orderedItems = orderInserterBlockItems(orderedItems, prioritizedBlocks); 48669 } 48670 const results = searchBlockItems(orderedItems, blockTypeCategories, blockTypeCollections, filterValue); 48671 return maxBlockTypesToShow !== undefined ? results.slice(0, maxBlockTypesToShow) : results; 48672 }, [filterValue, blockTypes, blockTypeCategories, blockTypeCollections, maxBlockTypesToShow, prioritizedBlocks]); 48673 48674 // Announce search results on change. 48675 (0,external_wp_element_namespaceObject.useEffect)(() => { 48676 if (!filterValue) { 48677 return; 48678 } 48679 const count = filteredBlockTypes.length + filteredBlockPatterns.length; 48680 const resultsFoundMessage = (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %d: number of results. */ 48681 (0,external_wp_i18n_namespaceObject._n)('%d result found.', '%d results found.', count), count); 48682 debouncedSpeak(resultsFoundMessage); 48683 }, [filterValue, debouncedSpeak, filteredBlockTypes, filteredBlockPatterns]); 48684 const currentShownBlockTypes = (0,external_wp_compose_namespaceObject.useAsyncList)(filteredBlockTypes, { 48685 step: search_results_INITIAL_INSERTER_RESULTS 48686 }); 48687 const currentShownPatterns = (0,external_wp_compose_namespaceObject.useAsyncList)(currentShownBlockTypes.length === filteredBlockTypes.length ? filteredBlockPatterns : search_results_EMPTY_ARRAY); 48688 const hasItems = filteredBlockTypes.length > 0 || filteredBlockPatterns.length > 0; 48689 const blocksUI = !!filteredBlockTypes.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, { 48690 title: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 48691 children: (0,external_wp_i18n_namespaceObject.__)('Blocks') 48692 }), 48693 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, { 48694 items: currentShownBlockTypes, 48695 onSelect: onSelectBlockType, 48696 onHover: onHover, 48697 label: (0,external_wp_i18n_namespaceObject.__)('Blocks'), 48698 isDraggable: isDraggable 48699 }) 48700 }); 48701 const patternsUI = !!filteredBlockPatterns.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, { 48702 title: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 48703 children: (0,external_wp_i18n_namespaceObject.__)('Block patterns') 48704 }), 48705 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 48706 className: "block-editor-inserter__quick-inserter-patterns", 48707 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_list, { 48708 shownPatterns: currentShownPatterns, 48709 blockPatterns: filteredBlockPatterns, 48710 onClickPattern: onClickPattern, 48711 onHover: onHoverPattern, 48712 isDraggable: isDraggable 48713 }) 48714 }) 48715 }); 48716 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(inserter_listbox, { 48717 children: [!showBlockDirectory && !hasItems && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {}), prioritizePatterns ? patternsUI : blocksUI, !!filteredBlockTypes.length && !!filteredBlockPatterns.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 48718 className: "block-editor-inserter__quick-inserter-separator" 48719 }), prioritizePatterns ? blocksUI : patternsUI, showBlockDirectory && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_menu_extension.Slot, { 48720 fillProps: { 48721 onSelect: onSelectBlockType, 48722 onHover, 48723 filterValue, 48724 hasItems, 48725 rootClientId: destinationRootClientId 48726 }, 48727 children: fills => { 48728 if (fills.length) { 48729 return fills; 48730 } 48731 if (!hasItems) { 48732 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {}); 48733 } 48734 return null; 48735 } 48736 })] 48737 }); 48738 } 48739 /* harmony default export */ const search_results = (InserterSearchResults); 48740 48741 ;// ./node_modules/@wordpress/icons/build-module/library/close-small.js 48742 /** 48743 * WordPress dependencies 48744 */ 48745 48746 48747 const closeSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 48748 xmlns: "http://www.w3.org/2000/svg", 48749 viewBox: "0 0 24 24", 48750 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 48751 d: "M12 13.06l3.712 3.713 1.061-1.06L13.061 12l3.712-3.712-1.06-1.06L12 10.938 8.288 7.227l-1.061 1.06L10.939 12l-3.712 3.712 1.06 1.061L12 13.061z" 48752 }) 48753 }); 48754 /* harmony default export */ const close_small = (closeSmall); 48755 48756 ;// ./node_modules/@wordpress/block-editor/build-module/components/tabbed-sidebar/index.js 48757 /** 48758 * WordPress dependencies 48759 */ 48760 48761 48762 48763 48764 /** 48765 * Internal dependencies 48766 */ 48767 48768 48769 48770 const { 48771 Tabs: tabbed_sidebar_Tabs 48772 } = unlock(external_wp_components_namespaceObject.privateApis); 48773 function TabbedSidebar({ 48774 defaultTabId, 48775 onClose, 48776 onSelect, 48777 selectedTab, 48778 tabs, 48779 closeButtonLabel 48780 }, ref) { 48781 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 48782 className: "block-editor-tabbed-sidebar", 48783 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(tabbed_sidebar_Tabs, { 48784 selectOnMove: false, 48785 defaultTabId: defaultTabId, 48786 onSelect: onSelect, 48787 selectedTabId: selectedTab, 48788 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 48789 className: "block-editor-tabbed-sidebar__tablist-and-close-button", 48790 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 48791 className: "block-editor-tabbed-sidebar__close-button", 48792 icon: close_small, 48793 label: closeButtonLabel, 48794 onClick: () => onClose(), 48795 size: "small" 48796 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tabbed_sidebar_Tabs.TabList, { 48797 className: "block-editor-tabbed-sidebar__tablist", 48798 ref: ref, 48799 children: tabs.map(tab => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tabbed_sidebar_Tabs.Tab, { 48800 tabId: tab.name, 48801 className: "block-editor-tabbed-sidebar__tab", 48802 children: tab.title 48803 }, tab.name)) 48804 })] 48805 }), tabs.map(tab => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tabbed_sidebar_Tabs.TabPanel, { 48806 tabId: tab.name, 48807 focusable: false, 48808 className: "block-editor-tabbed-sidebar__tabpanel", 48809 ref: tab.panelRef, 48810 children: tab.panel 48811 }, tab.name))] 48812 }) 48813 }); 48814 } 48815 /* harmony default export */ const tabbed_sidebar = ((0,external_wp_element_namespaceObject.forwardRef)(TabbedSidebar)); 48816 48817 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-zoom-out.js 48818 /** 48819 * WordPress dependencies 48820 */ 48821 48822 48823 48824 /** 48825 * Internal dependencies 48826 */ 48827 48828 48829 /** 48830 * A hook used to set the editor mode to zoomed out mode, invoking the hook sets the mode. 48831 * 48832 * @param {boolean} zoomOut If we should enter into zoomOut mode or not 48833 */ 48834 function useZoomOut(zoomOut = true) { 48835 const { 48836 __unstableSetEditorMode, 48837 setZoomLevel 48838 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 48839 const { 48840 __unstableGetEditorMode 48841 } = unlock((0,external_wp_data_namespaceObject.useSelect)(store)); 48842 const originalEditingModeRef = (0,external_wp_element_namespaceObject.useRef)(null); 48843 const mode = __unstableGetEditorMode(); 48844 (0,external_wp_element_namespaceObject.useEffect)(() => { 48845 // Only set this on mount so we know what to return to when we unmount. 48846 if (!originalEditingModeRef.current) { 48847 originalEditingModeRef.current = mode; 48848 } 48849 return () => { 48850 // We need to use __unstableGetEditorMode() here and not `mode`, as mode may not update on unmount 48851 if (__unstableGetEditorMode() === 'zoom-out' && __unstableGetEditorMode() !== originalEditingModeRef.current) { 48852 __unstableSetEditorMode(originalEditingModeRef.current); 48853 setZoomLevel(100); 48854 } 48855 }; 48856 }, []); 48857 48858 // The effect opens the zoom-out view if we want it open and it's not currently in zoom-out mode. 48859 (0,external_wp_element_namespaceObject.useEffect)(() => { 48860 if (zoomOut && mode !== 'zoom-out') { 48861 __unstableSetEditorMode('zoom-out'); 48862 setZoomLevel(50); 48863 } else if (!zoomOut && __unstableGetEditorMode() === 'zoom-out' && originalEditingModeRef.current !== mode) { 48864 __unstableSetEditorMode(originalEditingModeRef.current); 48865 setZoomLevel(100); 48866 } 48867 }, [__unstableGetEditorMode, __unstableSetEditorMode, zoomOut, setZoomLevel]); // Mode is deliberately excluded from the dependencies so that the effect does not run when mode changes. 48868 } 48869 48870 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/menu.js 48871 /** 48872 * External dependencies 48873 */ 48874 48875 48876 /** 48877 * WordPress dependencies 48878 */ 48879 48880 48881 48882 48883 48884 48885 /** 48886 * Internal dependencies 48887 */ 48888 48889 48890 48891 48892 48893 48894 48895 48896 48897 48898 48899 48900 48901 48902 const NOOP = () => {}; 48903 function InserterMenu({ 48904 rootClientId, 48905 clientId, 48906 isAppender, 48907 __experimentalInsertionIndex, 48908 onSelect, 48909 showInserterHelpPanel, 48910 showMostUsedBlocks, 48911 __experimentalFilterValue = '', 48912 shouldFocusBlock = true, 48913 onPatternCategorySelection, 48914 onClose, 48915 __experimentalInitialTab, 48916 __experimentalInitialCategory 48917 }, ref) { 48918 const isZoomOutMode = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).__unstableGetEditorMode() === 'zoom-out', []); 48919 const [filterValue, setFilterValue, delayedFilterValue] = (0,external_wp_compose_namespaceObject.useDebouncedInput)(__experimentalFilterValue); 48920 const [hoveredItem, setHoveredItem] = (0,external_wp_element_namespaceObject.useState)(null); 48921 const [selectedPatternCategory, setSelectedPatternCategory] = (0,external_wp_element_namespaceObject.useState)(__experimentalInitialCategory); 48922 const [patternFilter, setPatternFilter] = (0,external_wp_element_namespaceObject.useState)('all'); 48923 const [selectedMediaCategory, setSelectedMediaCategory] = (0,external_wp_element_namespaceObject.useState)(null); 48924 const isLargeViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('large'); 48925 const [hasCategories, setHasCategories] = (0,external_wp_element_namespaceObject.useState)(true); 48926 function getInitialTab() { 48927 if (__experimentalInitialTab) { 48928 return __experimentalInitialTab; 48929 } 48930 if (isZoomOutMode) { 48931 return 'patterns'; 48932 } 48933 } 48934 const [selectedTab, setSelectedTab] = (0,external_wp_element_namespaceObject.useState)(getInitialTab()); 48935 const shouldUseZoomOut = selectedTab === 'patterns' || selectedTab === 'media'; 48936 useZoomOut(shouldUseZoomOut && isLargeViewport); 48937 const [destinationRootClientId, onInsertBlocks, onToggleInsertionPoint] = use_insertion_point({ 48938 rootClientId, 48939 clientId, 48940 isAppender, 48941 insertionIndex: __experimentalInsertionIndex, 48942 shouldFocusBlock 48943 }); 48944 const blockTypesTabRef = (0,external_wp_element_namespaceObject.useRef)(); 48945 const onInsert = (0,external_wp_element_namespaceObject.useCallback)((blocks, meta, shouldForceFocusBlock, _rootClientId) => { 48946 onInsertBlocks(blocks, meta, shouldForceFocusBlock, _rootClientId); 48947 onSelect(blocks); 48948 48949 // Check for focus loss due to filtering blocks by selected block type 48950 window.requestAnimationFrame(() => { 48951 if (!shouldFocusBlock && !blockTypesTabRef.current?.contains(ref.current.ownerDocument.activeElement)) { 48952 // There has been a focus loss, so focus the first button in the block types tab 48953 blockTypesTabRef.current?.querySelector('button').focus(); 48954 } 48955 }); 48956 }, [onInsertBlocks, onSelect, shouldFocusBlock]); 48957 const onInsertPattern = (0,external_wp_element_namespaceObject.useCallback)((blocks, patternName) => { 48958 onToggleInsertionPoint(false); 48959 onInsertBlocks(blocks, { 48960 patternName 48961 }); 48962 onSelect(); 48963 }, [onInsertBlocks, onSelect]); 48964 const onHover = (0,external_wp_element_namespaceObject.useCallback)(item => { 48965 onToggleInsertionPoint(item); 48966 setHoveredItem(item); 48967 }, [onToggleInsertionPoint, setHoveredItem]); 48968 const onClickPatternCategory = (0,external_wp_element_namespaceObject.useCallback)((patternCategory, filter) => { 48969 setSelectedPatternCategory(patternCategory); 48970 setPatternFilter(filter); 48971 onPatternCategorySelection?.(); 48972 }, [setSelectedPatternCategory, onPatternCategorySelection]); 48973 const showPatternPanel = selectedTab === 'patterns' && hasCategories && !delayedFilterValue && !!selectedPatternCategory; 48974 const showMediaPanel = selectedTab === 'media' && !!selectedMediaCategory && hasCategories; 48975 const inserterSearch = (0,external_wp_element_namespaceObject.useMemo)(() => { 48976 if (selectedTab === 'media') { 48977 return null; 48978 } 48979 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 48980 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, { 48981 __nextHasNoMarginBottom: true, 48982 className: "block-editor-inserter__search", 48983 onChange: value => { 48984 if (hoveredItem) { 48985 setHoveredItem(null); 48986 } 48987 setFilterValue(value); 48988 }, 48989 value: filterValue, 48990 label: (0,external_wp_i18n_namespaceObject.__)('Search for blocks and patterns'), 48991 placeholder: (0,external_wp_i18n_namespaceObject.__)('Search') 48992 }), !!delayedFilterValue && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_results, { 48993 filterValue: delayedFilterValue, 48994 onSelect: onSelect, 48995 onHover: onHover, 48996 rootClientId: rootClientId, 48997 clientId: clientId, 48998 isAppender: isAppender, 48999 __experimentalInsertionIndex: __experimentalInsertionIndex, 49000 showBlockDirectory: true, 49001 shouldFocusBlock: shouldFocusBlock, 49002 prioritizePatterns: selectedTab === 'patterns' 49003 })] 49004 }); 49005 }, [selectedTab, hoveredItem, setHoveredItem, setFilterValue, filterValue, delayedFilterValue, onSelect, onHover, shouldFocusBlock, clientId, rootClientId, __experimentalInsertionIndex, isAppender]); 49006 const blocksTab = (0,external_wp_element_namespaceObject.useMemo)(() => { 49007 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 49008 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 49009 className: "block-editor-inserter__block-list", 49010 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_tab, { 49011 ref: blockTypesTabRef, 49012 rootClientId: destinationRootClientId, 49013 onInsert: onInsert, 49014 onHover: onHover, 49015 showMostUsedBlocks: showMostUsedBlocks 49016 }) 49017 }), showInserterHelpPanel && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 49018 className: "block-editor-inserter__tips", 49019 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 49020 as: "h2", 49021 children: (0,external_wp_i18n_namespaceObject.__)('A tip for using the block editor') 49022 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tips, {})] 49023 })] 49024 }); 49025 }, [destinationRootClientId, onInsert, onHover, showMostUsedBlocks, showInserterHelpPanel]); 49026 const patternsTab = (0,external_wp_element_namespaceObject.useMemo)(() => { 49027 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_tab, { 49028 rootClientId: destinationRootClientId, 49029 onInsert: onInsertPattern, 49030 onSelectCategory: onClickPatternCategory, 49031 selectedCategory: selectedPatternCategory, 49032 setHasCategories: setHasCategories, 49033 children: showPatternPanel && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternCategoryPreviews, { 49034 rootClientId: destinationRootClientId, 49035 onInsert: onInsertPattern, 49036 category: selectedPatternCategory, 49037 patternFilter: patternFilter, 49038 showTitlesAsTooltip: true 49039 }) 49040 }); 49041 }, [destinationRootClientId, onInsertPattern, onClickPatternCategory, patternFilter, selectedPatternCategory, showPatternPanel]); 49042 const mediaTab = (0,external_wp_element_namespaceObject.useMemo)(() => { 49043 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_tab, { 49044 rootClientId: destinationRootClientId, 49045 selectedCategory: selectedMediaCategory, 49046 onSelectCategory: setSelectedMediaCategory, 49047 onInsert: onInsert, 49048 setHasCategories: setHasCategories, 49049 children: showMediaPanel && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaCategoryPanel, { 49050 rootClientId: destinationRootClientId, 49051 onInsert: onInsert, 49052 category: selectedMediaCategory 49053 }) 49054 }); 49055 }, [destinationRootClientId, onInsert, selectedMediaCategory, setSelectedMediaCategory, showMediaPanel]); 49056 const handleSetSelectedTab = value => { 49057 // If no longer on patterns tab remove the category setting. 49058 if (value !== 'patterns') { 49059 setSelectedPatternCategory(null); 49060 } 49061 setSelectedTab(value); 49062 }; 49063 49064 // Focus first active tab, if any 49065 const tabsRef = (0,external_wp_element_namespaceObject.useRef)(); 49066 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 49067 if (tabsRef.current) { 49068 window.requestAnimationFrame(() => { 49069 tabsRef.current.querySelector('[role="tab"][aria-selected="true"]')?.focus(); 49070 }); 49071 } 49072 }, []); 49073 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 49074 className: dist_clsx('block-editor-inserter__menu', { 49075 'show-panel': showPatternPanel || showMediaPanel, 49076 'is-zoom-out': isZoomOutMode 49077 }), 49078 ref: ref, 49079 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 49080 className: "block-editor-inserter__main-area", 49081 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tabbed_sidebar, { 49082 ref: tabsRef, 49083 onSelect: handleSetSelectedTab, 49084 onClose: onClose, 49085 selectedTab: selectedTab, 49086 closeButtonLabel: (0,external_wp_i18n_namespaceObject.__)('Close block inserter'), 49087 tabs: [{ 49088 name: 'blocks', 49089 title: (0,external_wp_i18n_namespaceObject.__)('Blocks'), 49090 panel: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 49091 children: [inserterSearch, selectedTab === 'blocks' && !delayedFilterValue && blocksTab] 49092 }) 49093 }, { 49094 name: 'patterns', 49095 title: (0,external_wp_i18n_namespaceObject.__)('Patterns'), 49096 panel: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 49097 children: [inserterSearch, selectedTab === 'patterns' && !delayedFilterValue && patternsTab] 49098 }) 49099 }, { 49100 name: 'media', 49101 title: (0,external_wp_i18n_namespaceObject.__)('Media'), 49102 panel: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 49103 children: [inserterSearch, mediaTab] 49104 }) 49105 }] 49106 }) 49107 }), showInserterHelpPanel && hoveredItem && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, { 49108 className: "block-editor-inserter__preview-container__popover", 49109 placement: "right-start", 49110 offset: 16, 49111 focusOnMount: false, 49112 animate: false, 49113 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(preview_panel, { 49114 item: hoveredItem 49115 }) 49116 })] 49117 }); 49118 } 49119 const PrivateInserterMenu = (0,external_wp_element_namespaceObject.forwardRef)(InserterMenu); 49120 function PublicInserterMenu(props, ref) { 49121 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateInserterMenu, { 49122 ...props, 49123 onPatternCategorySelection: NOOP, 49124 ref: ref 49125 }); 49126 } 49127 /* harmony default export */ const menu = ((0,external_wp_element_namespaceObject.forwardRef)(PublicInserterMenu)); 49128 49129 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/quick-inserter.js 49130 /** 49131 * External dependencies 49132 */ 49133 49134 49135 /** 49136 * WordPress dependencies 49137 */ 49138 49139 49140 49141 49142 49143 /** 49144 * Internal dependencies 49145 */ 49146 49147 49148 49149 49150 49151 49152 49153 const SEARCH_THRESHOLD = 6; 49154 const SHOWN_BLOCK_TYPES = 6; 49155 const SHOWN_BLOCK_PATTERNS = 2; 49156 const SHOWN_BLOCK_PATTERNS_WITH_PRIORITIZATION = 4; 49157 function QuickInserter({ 49158 onSelect, 49159 rootClientId, 49160 clientId, 49161 isAppender, 49162 prioritizePatterns, 49163 selectBlockOnInsert, 49164 hasSearch = true 49165 }) { 49166 const [filterValue, setFilterValue] = (0,external_wp_element_namespaceObject.useState)(''); 49167 const [destinationRootClientId, onInsertBlocks] = use_insertion_point({ 49168 onSelect, 49169 rootClientId, 49170 clientId, 49171 isAppender, 49172 selectBlockOnInsert 49173 }); 49174 const [blockTypes] = use_block_types_state(destinationRootClientId, onInsertBlocks, true); 49175 const [patterns] = use_patterns_state(onInsertBlocks, destinationRootClientId); 49176 const { 49177 setInserterIsOpened, 49178 insertionIndex 49179 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 49180 const { 49181 getSettings, 49182 getBlockIndex, 49183 getBlockCount 49184 } = select(store); 49185 const settings = getSettings(); 49186 const index = getBlockIndex(clientId); 49187 const blockCount = getBlockCount(); 49188 return { 49189 setInserterIsOpened: settings.__experimentalSetIsInserterOpened, 49190 insertionIndex: index === -1 ? blockCount : index 49191 }; 49192 }, [clientId]); 49193 const showPatterns = patterns.length && (!!filterValue || prioritizePatterns); 49194 const showSearch = hasSearch && (showPatterns && patterns.length > SEARCH_THRESHOLD || blockTypes.length > SEARCH_THRESHOLD); 49195 (0,external_wp_element_namespaceObject.useEffect)(() => { 49196 if (setInserterIsOpened) { 49197 setInserterIsOpened(false); 49198 } 49199 }, [setInserterIsOpened]); 49200 49201 // When clicking Browse All select the appropriate block so as 49202 // the insertion point can work as expected. 49203 const onBrowseAll = () => { 49204 setInserterIsOpened({ 49205 rootClientId, 49206 insertionIndex, 49207 filterValue, 49208 onSelect 49209 }); 49210 }; 49211 let maxBlockPatterns = 0; 49212 if (showPatterns) { 49213 maxBlockPatterns = prioritizePatterns ? SHOWN_BLOCK_PATTERNS_WITH_PRIORITIZATION : SHOWN_BLOCK_PATTERNS; 49214 } 49215 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 49216 className: dist_clsx('block-editor-inserter__quick-inserter', { 49217 'has-search': showSearch, 49218 'has-expand': setInserterIsOpened 49219 }), 49220 children: [showSearch && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, { 49221 __nextHasNoMarginBottom: true, 49222 className: "block-editor-inserter__search", 49223 value: filterValue, 49224 onChange: value => { 49225 setFilterValue(value); 49226 }, 49227 label: (0,external_wp_i18n_namespaceObject.__)('Search for blocks and patterns'), 49228 placeholder: (0,external_wp_i18n_namespaceObject.__)('Search') 49229 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 49230 className: "block-editor-inserter__quick-inserter-results", 49231 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_results, { 49232 filterValue: filterValue, 49233 onSelect: onSelect, 49234 rootClientId: rootClientId, 49235 clientId: clientId, 49236 isAppender: isAppender, 49237 maxBlockPatterns: maxBlockPatterns, 49238 maxBlockTypes: SHOWN_BLOCK_TYPES, 49239 isDraggable: false, 49240 prioritizePatterns: prioritizePatterns, 49241 selectBlockOnInsert: selectBlockOnInsert, 49242 isQuick: true 49243 }) 49244 }), setInserterIsOpened && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 49245 __next40pxDefaultSize: true, 49246 className: "block-editor-inserter__quick-inserter-expand", 49247 onClick: onBrowseAll, 49248 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Browse all. This will open the main inserter panel in the editor toolbar.'), 49249 children: (0,external_wp_i18n_namespaceObject.__)('Browse all') 49250 })] 49251 }); 49252 } 49253 49254 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/index.js 49255 /** 49256 * External dependencies 49257 */ 49258 49259 49260 /** 49261 * WordPress dependencies 49262 */ 49263 49264 49265 49266 49267 49268 49269 49270 49271 49272 /** 49273 * Internal dependencies 49274 */ 49275 49276 49277 49278 49279 const defaultRenderToggle = ({ 49280 onToggle, 49281 disabled, 49282 isOpen, 49283 blockTitle, 49284 hasSingleBlockType, 49285 toggleProps = {}, 49286 prioritizePatterns 49287 }) => { 49288 const { 49289 as: Wrapper = external_wp_components_namespaceObject.Button, 49290 label: labelProp, 49291 onClick, 49292 ...rest 49293 } = toggleProps; 49294 let label = labelProp; 49295 if (!label && hasSingleBlockType) { 49296 label = (0,external_wp_i18n_namespaceObject.sprintf)( 49297 // translators: %s: the name of the block when there is only one 49298 (0,external_wp_i18n_namespaceObject._x)('Add %s', 'directly add the only allowed block'), blockTitle); 49299 } else if (!label && prioritizePatterns) { 49300 label = (0,external_wp_i18n_namespaceObject.__)('Add pattern'); 49301 } else if (!label) { 49302 label = (0,external_wp_i18n_namespaceObject._x)('Add block', 'Generic label for block inserter button'); 49303 } 49304 49305 // Handle both onClick functions from the toggle and the parent component. 49306 function handleClick(event) { 49307 if (onToggle) { 49308 onToggle(event); 49309 } 49310 if (onClick) { 49311 onClick(event); 49312 } 49313 } 49314 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Wrapper, { 49315 icon: library_plus, 49316 label: label, 49317 tooltipPosition: "bottom", 49318 onClick: handleClick, 49319 className: "block-editor-inserter__toggle", 49320 "aria-haspopup": !hasSingleBlockType ? 'true' : false, 49321 "aria-expanded": !hasSingleBlockType ? isOpen : false, 49322 disabled: disabled, 49323 ...rest 49324 }); 49325 }; 49326 class Inserter extends external_wp_element_namespaceObject.Component { 49327 constructor() { 49328 super(...arguments); 49329 this.onToggle = this.onToggle.bind(this); 49330 this.renderToggle = this.renderToggle.bind(this); 49331 this.renderContent = this.renderContent.bind(this); 49332 } 49333 onToggle(isOpen) { 49334 const { 49335 onToggle 49336 } = this.props; 49337 49338 // Surface toggle callback to parent component. 49339 if (onToggle) { 49340 onToggle(isOpen); 49341 } 49342 } 49343 49344 /** 49345 * Render callback to display Dropdown toggle element. 49346 * 49347 * @param {Object} options 49348 * @param {Function} options.onToggle Callback to invoke when toggle is 49349 * pressed. 49350 * @param {boolean} options.isOpen Whether dropdown is currently open. 49351 * 49352 * @return {Element} Dropdown toggle element. 49353 */ 49354 renderToggle({ 49355 onToggle, 49356 isOpen 49357 }) { 49358 const { 49359 disabled, 49360 blockTitle, 49361 hasSingleBlockType, 49362 directInsertBlock, 49363 toggleProps, 49364 hasItems, 49365 renderToggle = defaultRenderToggle, 49366 prioritizePatterns 49367 } = this.props; 49368 return renderToggle({ 49369 onToggle, 49370 isOpen, 49371 disabled: disabled || !hasItems, 49372 blockTitle, 49373 hasSingleBlockType, 49374 directInsertBlock, 49375 toggleProps, 49376 prioritizePatterns 49377 }); 49378 } 49379 49380 /** 49381 * Render callback to display Dropdown content element. 49382 * 49383 * @param {Object} options 49384 * @param {Function} options.onClose Callback to invoke when dropdown is 49385 * closed. 49386 * 49387 * @return {Element} Dropdown content element. 49388 */ 49389 renderContent({ 49390 onClose 49391 }) { 49392 const { 49393 rootClientId, 49394 clientId, 49395 isAppender, 49396 showInserterHelpPanel, 49397 // This prop is experimental to give some time for the quick inserter to mature 49398 // Feel free to make them stable after a few releases. 49399 __experimentalIsQuick: isQuick, 49400 prioritizePatterns, 49401 onSelectOrClose, 49402 selectBlockOnInsert 49403 } = this.props; 49404 if (isQuick) { 49405 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(QuickInserter, { 49406 onSelect: blocks => { 49407 const firstBlock = Array.isArray(blocks) && blocks?.length ? blocks[0] : blocks; 49408 if (onSelectOrClose && typeof onSelectOrClose === 'function') { 49409 onSelectOrClose(firstBlock); 49410 } 49411 onClose(); 49412 }, 49413 rootClientId: rootClientId, 49414 clientId: clientId, 49415 isAppender: isAppender, 49416 prioritizePatterns: prioritizePatterns, 49417 selectBlockOnInsert: selectBlockOnInsert 49418 }); 49419 } 49420 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(menu, { 49421 onSelect: () => { 49422 onClose(); 49423 }, 49424 rootClientId: rootClientId, 49425 clientId: clientId, 49426 isAppender: isAppender, 49427 showInserterHelpPanel: showInserterHelpPanel 49428 }); 49429 } 49430 render() { 49431 const { 49432 position, 49433 hasSingleBlockType, 49434 directInsertBlock, 49435 insertOnlyAllowedBlock, 49436 __experimentalIsQuick: isQuick, 49437 onSelectOrClose 49438 } = this.props; 49439 if (hasSingleBlockType || directInsertBlock) { 49440 return this.renderToggle({ 49441 onToggle: insertOnlyAllowedBlock 49442 }); 49443 } 49444 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 49445 className: "block-editor-inserter", 49446 contentClassName: dist_clsx('block-editor-inserter__popover', { 49447 'is-quick': isQuick 49448 }), 49449 popoverProps: { 49450 position, 49451 shift: true 49452 }, 49453 onToggle: this.onToggle, 49454 expandOnMobile: true, 49455 headerTitle: (0,external_wp_i18n_namespaceObject.__)('Add a block'), 49456 renderToggle: this.renderToggle, 49457 renderContent: this.renderContent, 49458 onClose: onSelectOrClose 49459 }); 49460 } 49461 } 49462 /* harmony default export */ const inserter = ((0,external_wp_compose_namespaceObject.compose)([(0,external_wp_data_namespaceObject.withSelect)((select, { 49463 clientId, 49464 rootClientId, 49465 shouldDirectInsert = true 49466 }) => { 49467 const { 49468 getBlockRootClientId, 49469 hasInserterItems, 49470 getAllowedBlocks, 49471 getDirectInsertBlock, 49472 getSettings 49473 } = select(store); 49474 const { 49475 getBlockVariations 49476 } = select(external_wp_blocks_namespaceObject.store); 49477 rootClientId = rootClientId || getBlockRootClientId(clientId) || undefined; 49478 const allowedBlocks = getAllowedBlocks(rootClientId); 49479 const directInsertBlock = shouldDirectInsert && getDirectInsertBlock(rootClientId); 49480 const settings = getSettings(); 49481 const hasSingleBlockType = allowedBlocks?.length === 1 && getBlockVariations(allowedBlocks[0].name, 'inserter')?.length === 0; 49482 let allowedBlockType = false; 49483 if (hasSingleBlockType) { 49484 allowedBlockType = allowedBlocks[0]; 49485 } 49486 return { 49487 hasItems: hasInserterItems(rootClientId), 49488 hasSingleBlockType, 49489 blockTitle: allowedBlockType ? allowedBlockType.title : '', 49490 allowedBlockType, 49491 directInsertBlock, 49492 rootClientId, 49493 prioritizePatterns: settings.__experimentalPreferPatternsOnRoot && !rootClientId 49494 }; 49495 }), (0,external_wp_data_namespaceObject.withDispatch)((dispatch, ownProps, { 49496 select 49497 }) => { 49498 return { 49499 insertOnlyAllowedBlock() { 49500 const { 49501 rootClientId, 49502 clientId, 49503 isAppender, 49504 hasSingleBlockType, 49505 allowedBlockType, 49506 directInsertBlock, 49507 onSelectOrClose, 49508 selectBlockOnInsert 49509 } = ownProps; 49510 if (!hasSingleBlockType && !directInsertBlock) { 49511 return; 49512 } 49513 function getAdjacentBlockAttributes(attributesToCopy) { 49514 const { 49515 getBlock, 49516 getPreviousBlockClientId 49517 } = select(store); 49518 if (!attributesToCopy || !clientId && !rootClientId) { 49519 return {}; 49520 } 49521 const result = {}; 49522 let adjacentAttributes = {}; 49523 49524 // If there is no clientId, then attempt to get attributes 49525 // from the last block within innerBlocks of the root block. 49526 if (!clientId) { 49527 const parentBlock = getBlock(rootClientId); 49528 if (parentBlock?.innerBlocks?.length) { 49529 const lastInnerBlock = parentBlock.innerBlocks[parentBlock.innerBlocks.length - 1]; 49530 if (directInsertBlock && directInsertBlock?.name === lastInnerBlock.name) { 49531 adjacentAttributes = lastInnerBlock.attributes; 49532 } 49533 } 49534 } else { 49535 // Otherwise, attempt to get attributes from the 49536 // previous block relative to the current clientId. 49537 const currentBlock = getBlock(clientId); 49538 const previousBlock = getBlock(getPreviousBlockClientId(clientId)); 49539 if (currentBlock?.name === previousBlock?.name) { 49540 adjacentAttributes = previousBlock?.attributes || {}; 49541 } 49542 } 49543 49544 // Copy over only those attributes flagged to be copied. 49545 attributesToCopy.forEach(attribute => { 49546 if (adjacentAttributes.hasOwnProperty(attribute)) { 49547 result[attribute] = adjacentAttributes[attribute]; 49548 } 49549 }); 49550 return result; 49551 } 49552 function getInsertionIndex() { 49553 const { 49554 getBlockIndex, 49555 getBlockSelectionEnd, 49556 getBlockOrder, 49557 getBlockRootClientId 49558 } = select(store); 49559 49560 // If the clientId is defined, we insert at the position of the block. 49561 if (clientId) { 49562 return getBlockIndex(clientId); 49563 } 49564 49565 // If there a selected block, we insert after the selected block. 49566 const end = getBlockSelectionEnd(); 49567 if (!isAppender && end && getBlockRootClientId(end) === rootClientId) { 49568 return getBlockIndex(end) + 1; 49569 } 49570 49571 // Otherwise, we insert at the end of the current rootClientId. 49572 return getBlockOrder(rootClientId).length; 49573 } 49574 const { 49575 insertBlock 49576 } = dispatch(store); 49577 let blockToInsert; 49578 49579 // Attempt to augment the directInsertBlock with attributes from an adjacent block. 49580 // This ensures styling from nearby blocks is preserved in the newly inserted block. 49581 // See: https://github.com/WordPress/gutenberg/issues/37904 49582 if (directInsertBlock) { 49583 const newAttributes = getAdjacentBlockAttributes(directInsertBlock.attributesToCopy); 49584 blockToInsert = (0,external_wp_blocks_namespaceObject.createBlock)(directInsertBlock.name, { 49585 ...(directInsertBlock.attributes || {}), 49586 ...newAttributes 49587 }); 49588 } else { 49589 blockToInsert = (0,external_wp_blocks_namespaceObject.createBlock)(allowedBlockType.name); 49590 } 49591 insertBlock(blockToInsert, getInsertionIndex(), rootClientId, selectBlockOnInsert); 49592 if (onSelectOrClose) { 49593 onSelectOrClose({ 49594 clientId: blockToInsert?.clientId 49595 }); 49596 } 49597 const message = (0,external_wp_i18n_namespaceObject.sprintf)( 49598 // translators: %s: the name of the block that has been added 49599 (0,external_wp_i18n_namespaceObject.__)('%s block added'), allowedBlockType.title); 49600 (0,external_wp_a11y_namespaceObject.speak)(message); 49601 } 49602 }; 49603 }), 49604 // The global inserter should always be visible, we are using ( ! isAppender && ! rootClientId && ! clientId ) as 49605 // a way to detect the global Inserter. 49606 (0,external_wp_compose_namespaceObject.ifCondition)(({ 49607 hasItems, 49608 isAppender, 49609 rootClientId, 49610 clientId 49611 }) => hasItems || !isAppender && !rootClientId && !clientId)])(Inserter)); 49612 49613 ;// ./node_modules/@wordpress/block-editor/build-module/components/button-block-appender/index.js 49614 /** 49615 * External dependencies 49616 */ 49617 49618 49619 /** 49620 * WordPress dependencies 49621 */ 49622 49623 49624 49625 49626 49627 49628 /** 49629 * Internal dependencies 49630 */ 49631 49632 49633 49634 function button_block_appender_ButtonBlockAppender({ 49635 rootClientId, 49636 className, 49637 onFocus, 49638 tabIndex, 49639 onSelect 49640 }, ref) { 49641 const inserterButtonRef = (0,external_wp_element_namespaceObject.useRef)(); 49642 const mergedInserterButtonRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([inserterButtonRef, ref]); 49643 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, { 49644 position: "bottom center", 49645 rootClientId: rootClientId, 49646 __experimentalIsQuick: true, 49647 onSelectOrClose: (...args) => { 49648 if (onSelect && typeof onSelect === 'function') { 49649 onSelect(...args); 49650 } 49651 inserterButtonRef.current?.focus(); 49652 }, 49653 renderToggle: ({ 49654 onToggle, 49655 disabled, 49656 isOpen, 49657 blockTitle, 49658 hasSingleBlockType 49659 }) => { 49660 const isToggleButton = !hasSingleBlockType; 49661 const label = hasSingleBlockType ? (0,external_wp_i18n_namespaceObject.sprintf)( 49662 // translators: %s: the name of the block when there is only one 49663 (0,external_wp_i18n_namespaceObject._x)('Add %s', 'directly add the only allowed block'), blockTitle) : (0,external_wp_i18n_namespaceObject._x)('Add block', 'Generic label for block inserter button'); 49664 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 49665 __next40pxDefaultSize: true, 49666 ref: mergedInserterButtonRef, 49667 onFocus: onFocus, 49668 tabIndex: tabIndex, 49669 className: dist_clsx(className, 'block-editor-button-block-appender'), 49670 onClick: onToggle, 49671 "aria-haspopup": isToggleButton ? 'true' : undefined, 49672 "aria-expanded": isToggleButton ? isOpen : undefined 49673 // Disable reason: There shouldn't be a case where this button is disabled but not visually hidden. 49674 // eslint-disable-next-line no-restricted-syntax 49675 , 49676 disabled: disabled, 49677 label: label, 49678 showTooltip: true, 49679 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 49680 icon: library_plus 49681 }) 49682 }); 49683 }, 49684 isAppender: true 49685 }); 49686 } 49687 49688 /** 49689 * Use `ButtonBlockAppender` instead. 49690 * 49691 * @deprecated 49692 */ 49693 const ButtonBlockerAppender = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => { 49694 external_wp_deprecated_default()(`wp.blockEditor.ButtonBlockerAppender`, { 49695 alternative: 'wp.blockEditor.ButtonBlockAppender', 49696 since: '5.9' 49697 }); 49698 return button_block_appender_ButtonBlockAppender(props, ref); 49699 }); 49700 49701 /** 49702 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/button-block-appender/README.md 49703 */ 49704 /* harmony default export */ const button_block_appender = ((0,external_wp_element_namespaceObject.forwardRef)(button_block_appender_ButtonBlockAppender)); 49705 49706 ;// ./node_modules/@wordpress/block-editor/build-module/components/grid/grid-visualizer.js 49707 /** 49708 * External dependencies 49709 */ 49710 49711 49712 /** 49713 * WordPress dependencies 49714 */ 49715 49716 49717 49718 49719 /** 49720 * Internal dependencies 49721 */ 49722 49723 49724 49725 49726 49727 49728 49729 49730 function GridVisualizer({ 49731 clientId, 49732 contentRef, 49733 parentLayout 49734 }) { 49735 const isDistractionFree = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSettings().isDistractionFree, []); 49736 const gridElement = useBlockElement(clientId); 49737 if (isDistractionFree || !gridElement) { 49738 return null; 49739 } 49740 const isManualGrid = parentLayout?.isManualPlacement && window.__experimentalEnableGridInteractivity; 49741 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerGrid, { 49742 gridClientId: clientId, 49743 gridElement: gridElement, 49744 isManualGrid: isManualGrid, 49745 ref: contentRef 49746 }); 49747 } 49748 const GridVisualizerGrid = (0,external_wp_element_namespaceObject.forwardRef)(({ 49749 gridClientId, 49750 gridElement, 49751 isManualGrid 49752 }, ref) => { 49753 const [gridInfo, setGridInfo] = (0,external_wp_element_namespaceObject.useState)(() => getGridInfo(gridElement)); 49754 const [isDroppingAllowed, setIsDroppingAllowed] = (0,external_wp_element_namespaceObject.useState)(false); 49755 (0,external_wp_element_namespaceObject.useEffect)(() => { 49756 const observers = []; 49757 for (const element of [gridElement, ...gridElement.children]) { 49758 const observer = new window.ResizeObserver(() => { 49759 setGridInfo(getGridInfo(gridElement)); 49760 }); 49761 observer.observe(element); 49762 observers.push(observer); 49763 } 49764 return () => { 49765 for (const observer of observers) { 49766 observer.disconnect(); 49767 } 49768 }; 49769 }, [gridElement]); 49770 (0,external_wp_element_namespaceObject.useEffect)(() => { 49771 function onGlobalDrag() { 49772 setIsDroppingAllowed(true); 49773 } 49774 function onGlobalDragEnd() { 49775 setIsDroppingAllowed(false); 49776 } 49777 document.addEventListener('drag', onGlobalDrag); 49778 document.addEventListener('dragend', onGlobalDragEnd); 49779 return () => { 49780 document.removeEventListener('drag', onGlobalDrag); 49781 document.removeEventListener('dragend', onGlobalDragEnd); 49782 }; 49783 }, []); 49784 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, { 49785 className: dist_clsx('block-editor-grid-visualizer', { 49786 'is-dropping-allowed': isDroppingAllowed 49787 }), 49788 clientId: gridClientId, 49789 __unstablePopoverSlot: "__unstable-block-tools-after", 49790 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 49791 ref: ref, 49792 className: "block-editor-grid-visualizer__grid", 49793 style: gridInfo.style, 49794 children: isManualGrid ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ManualGridVisualizer, { 49795 gridClientId: gridClientId, 49796 gridInfo: gridInfo 49797 }) : Array.from({ 49798 length: gridInfo.numItems 49799 }, (_, i) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerCell, { 49800 color: gridInfo.currentColor 49801 }, i)) 49802 }) 49803 }); 49804 }); 49805 function ManualGridVisualizer({ 49806 gridClientId, 49807 gridInfo 49808 }) { 49809 const [highlightedRect, setHighlightedRect] = (0,external_wp_element_namespaceObject.useState)(null); 49810 const gridItemStyles = (0,external_wp_data_namespaceObject.useSelect)(select => { 49811 const { 49812 getBlockOrder, 49813 getBlockStyles 49814 } = unlock(select(store)); 49815 const blockOrder = getBlockOrder(gridClientId); 49816 return getBlockStyles(blockOrder); 49817 }, [gridClientId]); 49818 const occupiedRects = (0,external_wp_element_namespaceObject.useMemo)(() => { 49819 const rects = []; 49820 for (const style of Object.values(gridItemStyles)) { 49821 var _style$layout; 49822 const { 49823 columnStart, 49824 rowStart, 49825 columnSpan = 1, 49826 rowSpan = 1 49827 } = (_style$layout = style?.layout) !== null && _style$layout !== void 0 ? _style$layout : {}; 49828 if (!columnStart || !rowStart) { 49829 continue; 49830 } 49831 rects.push(new GridRect({ 49832 columnStart, 49833 rowStart, 49834 columnSpan, 49835 rowSpan 49836 })); 49837 } 49838 return rects; 49839 }, [gridItemStyles]); 49840 return range(1, gridInfo.numRows).map(row => range(1, gridInfo.numColumns).map(column => { 49841 var _highlightedRect$cont; 49842 const isCellOccupied = occupiedRects.some(rect => rect.contains(column, row)); 49843 const isHighlighted = (_highlightedRect$cont = highlightedRect?.contains(column, row)) !== null && _highlightedRect$cont !== void 0 ? _highlightedRect$cont : false; 49844 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerCell, { 49845 color: gridInfo.currentColor, 49846 className: isHighlighted && 'is-highlighted', 49847 children: isCellOccupied ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerDropZone, { 49848 column: column, 49849 row: row, 49850 gridClientId: gridClientId, 49851 gridInfo: gridInfo, 49852 setHighlightedRect: setHighlightedRect 49853 }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerAppender, { 49854 column: column, 49855 row: row, 49856 gridClientId: gridClientId, 49857 gridInfo: gridInfo, 49858 setHighlightedRect: setHighlightedRect 49859 }) 49860 }, `$row}-$column}`); 49861 })); 49862 } 49863 function GridVisualizerCell({ 49864 color, 49865 children, 49866 className 49867 }) { 49868 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 49869 className: dist_clsx('block-editor-grid-visualizer__cell', className), 49870 style: { 49871 boxShadow: `inset 0 0 0 1px color-mix(in srgb, $color} 20%, #0000)`, 49872 color 49873 }, 49874 children: children 49875 }); 49876 } 49877 function useGridVisualizerDropZone(column, row, gridClientId, gridInfo, setHighlightedRect) { 49878 const { 49879 getBlockAttributes, 49880 getBlockRootClientId, 49881 canInsertBlockType, 49882 getBlockName 49883 } = (0,external_wp_data_namespaceObject.useSelect)(store); 49884 const { 49885 updateBlockAttributes, 49886 moveBlocksToPosition, 49887 __unstableMarkNextChangeAsNotPersistent 49888 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 49889 const getNumberOfBlocksBeforeCell = useGetNumberOfBlocksBeforeCell(gridClientId, gridInfo.numColumns); 49890 return useDropZoneWithValidation({ 49891 validateDrag(srcClientId) { 49892 const blockName = getBlockName(srcClientId); 49893 if (!canInsertBlockType(blockName, gridClientId)) { 49894 return false; 49895 } 49896 const attributes = getBlockAttributes(srcClientId); 49897 const rect = new GridRect({ 49898 columnStart: column, 49899 rowStart: row, 49900 columnSpan: attributes.style?.layout?.columnSpan, 49901 rowSpan: attributes.style?.layout?.rowSpan 49902 }); 49903 const isInBounds = new GridRect({ 49904 columnSpan: gridInfo.numColumns, 49905 rowSpan: gridInfo.numRows 49906 }).containsRect(rect); 49907 return isInBounds; 49908 }, 49909 onDragEnter(srcClientId) { 49910 const attributes = getBlockAttributes(srcClientId); 49911 setHighlightedRect(new GridRect({ 49912 columnStart: column, 49913 rowStart: row, 49914 columnSpan: attributes.style?.layout?.columnSpan, 49915 rowSpan: attributes.style?.layout?.rowSpan 49916 })); 49917 }, 49918 onDragLeave() { 49919 // onDragEnter can be called before onDragLeave if the user moves 49920 // their mouse quickly, so only clear the highlight if it was set 49921 // by this cell. 49922 setHighlightedRect(prevHighlightedRect => prevHighlightedRect?.columnStart === column && prevHighlightedRect?.rowStart === row ? null : prevHighlightedRect); 49923 }, 49924 onDrop(srcClientId) { 49925 setHighlightedRect(null); 49926 const attributes = getBlockAttributes(srcClientId); 49927 updateBlockAttributes(srcClientId, { 49928 style: { 49929 ...attributes.style, 49930 layout: { 49931 ...attributes.style?.layout, 49932 columnStart: column, 49933 rowStart: row 49934 } 49935 } 49936 }); 49937 __unstableMarkNextChangeAsNotPersistent(); 49938 moveBlocksToPosition([srcClientId], getBlockRootClientId(srcClientId), gridClientId, getNumberOfBlocksBeforeCell(column, row)); 49939 } 49940 }); 49941 } 49942 function GridVisualizerDropZone({ 49943 column, 49944 row, 49945 gridClientId, 49946 gridInfo, 49947 setHighlightedRect 49948 }) { 49949 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 49950 className: "block-editor-grid-visualizer__drop-zone", 49951 ref: useGridVisualizerDropZone(column, row, gridClientId, gridInfo, setHighlightedRect) 49952 }); 49953 } 49954 function GridVisualizerAppender({ 49955 column, 49956 row, 49957 gridClientId, 49958 gridInfo, 49959 setHighlightedRect 49960 }) { 49961 const { 49962 updateBlockAttributes, 49963 moveBlocksToPosition, 49964 __unstableMarkNextChangeAsNotPersistent 49965 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 49966 const getNumberOfBlocksBeforeCell = useGetNumberOfBlocksBeforeCell(gridClientId, gridInfo.numColumns); 49967 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(button_block_appender, { 49968 rootClientId: gridClientId, 49969 className: "block-editor-grid-visualizer__appender", 49970 ref: useGridVisualizerDropZone(column, row, gridClientId, gridInfo, setHighlightedRect), 49971 style: { 49972 color: gridInfo.currentColor 49973 }, 49974 onSelect: block => { 49975 if (!block) { 49976 return; 49977 } 49978 updateBlockAttributes(block.clientId, { 49979 style: { 49980 layout: { 49981 columnStart: column, 49982 rowStart: row 49983 } 49984 } 49985 }); 49986 __unstableMarkNextChangeAsNotPersistent(); 49987 moveBlocksToPosition([block.clientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(column, row)); 49988 } 49989 }); 49990 } 49991 function useDropZoneWithValidation({ 49992 validateDrag, 49993 onDragEnter, 49994 onDragLeave, 49995 onDrop 49996 }) { 49997 const { 49998 getDraggedBlockClientIds 49999 } = (0,external_wp_data_namespaceObject.useSelect)(store); 50000 return (0,external_wp_compose_namespaceObject.__experimentalUseDropZone)({ 50001 onDragEnter() { 50002 const [srcClientId] = getDraggedBlockClientIds(); 50003 if (srcClientId && validateDrag(srcClientId)) { 50004 onDragEnter(srcClientId); 50005 } 50006 }, 50007 onDragLeave() { 50008 onDragLeave(); 50009 }, 50010 onDrop() { 50011 const [srcClientId] = getDraggedBlockClientIds(); 50012 if (srcClientId && validateDrag(srcClientId)) { 50013 onDrop(srcClientId); 50014 } 50015 } 50016 }); 50017 } 50018 50019 ;// ./node_modules/@wordpress/block-editor/build-module/components/grid/grid-item-resizer.js 50020 /** 50021 * WordPress dependencies 50022 */ 50023 50024 50025 50026 /** 50027 * Internal dependencies 50028 */ 50029 50030 50031 50032 50033 function GridItemResizer({ 50034 clientId, 50035 bounds, 50036 onChange, 50037 parentLayout 50038 }) { 50039 const blockElement = useBlockElement(clientId); 50040 const rootBlockElement = blockElement?.parentElement; 50041 const { 50042 isManualPlacement 50043 } = parentLayout; 50044 if (!blockElement || !rootBlockElement) { 50045 return null; 50046 } 50047 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemResizerInner, { 50048 clientId: clientId, 50049 bounds: bounds, 50050 blockElement: blockElement, 50051 rootBlockElement: rootBlockElement, 50052 onChange: onChange, 50053 isManualGrid: isManualPlacement && window.__experimentalEnableGridInteractivity 50054 }); 50055 } 50056 function GridItemResizerInner({ 50057 clientId, 50058 bounds, 50059 blockElement, 50060 rootBlockElement, 50061 onChange, 50062 isManualGrid 50063 }) { 50064 const [resizeDirection, setResizeDirection] = (0,external_wp_element_namespaceObject.useState)(null); 50065 const [enableSide, setEnableSide] = (0,external_wp_element_namespaceObject.useState)({ 50066 top: false, 50067 bottom: false, 50068 left: false, 50069 right: false 50070 }); 50071 (0,external_wp_element_namespaceObject.useEffect)(() => { 50072 const observer = new window.ResizeObserver(() => { 50073 const blockClientRect = blockElement.getBoundingClientRect(); 50074 const rootBlockClientRect = rootBlockElement.getBoundingClientRect(); 50075 setEnableSide({ 50076 top: blockClientRect.top > rootBlockClientRect.top, 50077 bottom: blockClientRect.bottom < rootBlockClientRect.bottom, 50078 left: blockClientRect.left > rootBlockClientRect.left, 50079 right: blockClientRect.right < rootBlockClientRect.right 50080 }); 50081 }); 50082 observer.observe(blockElement); 50083 return () => observer.disconnect(); 50084 }, [blockElement, rootBlockElement]); 50085 const justification = { 50086 right: 'left', 50087 left: 'right' 50088 }; 50089 const alignment = { 50090 top: 'flex-end', 50091 bottom: 'flex-start' 50092 }; 50093 const styles = { 50094 display: 'flex', 50095 justifyContent: 'center', 50096 alignItems: 'center', 50097 ...(justification[resizeDirection] && { 50098 justifyContent: justification[resizeDirection] 50099 }), 50100 ...(alignment[resizeDirection] && { 50101 alignItems: alignment[resizeDirection] 50102 }) 50103 }; 50104 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, { 50105 className: "block-editor-grid-item-resizer", 50106 clientId: clientId, 50107 __unstablePopoverSlot: "__unstable-block-tools-after", 50108 additionalStyles: styles, 50109 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ResizableBox, { 50110 className: "block-editor-grid-item-resizer__box", 50111 size: { 50112 width: '100%', 50113 height: '100%' 50114 }, 50115 enable: { 50116 bottom: enableSide.bottom, 50117 bottomLeft: false, 50118 bottomRight: false, 50119 left: enableSide.left, 50120 right: enableSide.right, 50121 top: enableSide.top, 50122 topLeft: false, 50123 topRight: false 50124 }, 50125 bounds: bounds, 50126 boundsByDirection: true, 50127 onPointerDown: ({ 50128 target, 50129 pointerId 50130 }) => { 50131 /* 50132 * Captures the pointer to avoid hiccups while dragging over objects 50133 * like iframes and ensures that the event to end the drag is 50134 * captured by the target (resize handle) whether or not it’s under 50135 * the pointer. 50136 */ 50137 target.setPointerCapture(pointerId); 50138 }, 50139 onResizeStart: (event, direction) => { 50140 /* 50141 * The container justification and alignment need to be set 50142 * according to the direction the resizer is being dragged in, 50143 * so that it resizes in the right direction. 50144 */ 50145 setResizeDirection(direction); 50146 }, 50147 onResizeStop: (event, direction, boxElement) => { 50148 const columnGap = parseFloat(utils_getComputedCSS(rootBlockElement, 'column-gap')); 50149 const rowGap = parseFloat(utils_getComputedCSS(rootBlockElement, 'row-gap')); 50150 const gridColumnTracks = getGridTracks(utils_getComputedCSS(rootBlockElement, 'grid-template-columns'), columnGap); 50151 const gridRowTracks = getGridTracks(utils_getComputedCSS(rootBlockElement, 'grid-template-rows'), rowGap); 50152 const rect = new window.DOMRect(blockElement.offsetLeft + boxElement.offsetLeft, blockElement.offsetTop + boxElement.offsetTop, boxElement.offsetWidth, boxElement.offsetHeight); 50153 const columnStart = getClosestTrack(gridColumnTracks, rect.left) + 1; 50154 const rowStart = getClosestTrack(gridRowTracks, rect.top) + 1; 50155 const columnEnd = getClosestTrack(gridColumnTracks, rect.right, 'end') + 1; 50156 const rowEnd = getClosestTrack(gridRowTracks, rect.bottom, 'end') + 1; 50157 onChange({ 50158 columnSpan: columnEnd - columnStart + 1, 50159 rowSpan: rowEnd - rowStart + 1, 50160 columnStart: isManualGrid ? columnStart : undefined, 50161 rowStart: isManualGrid ? rowStart : undefined 50162 }); 50163 } 50164 }) 50165 }); 50166 } 50167 50168 ;// ./node_modules/@wordpress/icons/build-module/library/chevron-up.js 50169 /** 50170 * WordPress dependencies 50171 */ 50172 50173 50174 const chevronUp = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 50175 viewBox: "0 0 24 24", 50176 xmlns: "http://www.w3.org/2000/svg", 50177 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 50178 d: "M6.5 12.4L12 8l5.5 4.4-.9 1.2L12 10l-4.5 3.6-1-1.2z" 50179 }) 50180 }); 50181 /* harmony default export */ const chevron_up = (chevronUp); 50182 50183 ;// ./node_modules/@wordpress/icons/build-module/library/chevron-down.js 50184 /** 50185 * WordPress dependencies 50186 */ 50187 50188 50189 const chevronDown = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 50190 viewBox: "0 0 24 24", 50191 xmlns: "http://www.w3.org/2000/svg", 50192 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 50193 d: "M17.5 11.6L12 16l-5.5-4.4.9-1.2L12 14l4.5-3.6 1 1.2z" 50194 }) 50195 }); 50196 /* harmony default export */ const chevron_down = (chevronDown); 50197 50198 ;// ./node_modules/@wordpress/block-editor/build-module/components/grid/grid-item-movers.js 50199 /** 50200 * External dependencies 50201 */ 50202 50203 50204 /** 50205 * WordPress dependencies 50206 */ 50207 50208 50209 50210 50211 50212 50213 /** 50214 * Internal dependencies 50215 */ 50216 50217 50218 50219 50220 50221 50222 function GridItemMovers({ 50223 layout, 50224 parentLayout, 50225 onChange, 50226 gridClientId, 50227 blockClientId 50228 }) { 50229 var _layout$columnStart, _layout$rowStart, _layout$columnSpan, _layout$rowSpan; 50230 const { 50231 moveBlocksToPosition, 50232 __unstableMarkNextChangeAsNotPersistent 50233 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 50234 const columnStart = (_layout$columnStart = layout?.columnStart) !== null && _layout$columnStart !== void 0 ? _layout$columnStart : 1; 50235 const rowStart = (_layout$rowStart = layout?.rowStart) !== null && _layout$rowStart !== void 0 ? _layout$rowStart : 1; 50236 const columnSpan = (_layout$columnSpan = layout?.columnSpan) !== null && _layout$columnSpan !== void 0 ? _layout$columnSpan : 1; 50237 const rowSpan = (_layout$rowSpan = layout?.rowSpan) !== null && _layout$rowSpan !== void 0 ? _layout$rowSpan : 1; 50238 const columnEnd = columnStart + columnSpan - 1; 50239 const rowEnd = rowStart + rowSpan - 1; 50240 const columnCount = parentLayout?.columnCount; 50241 const rowCount = parentLayout?.rowCount; 50242 const getNumberOfBlocksBeforeCell = useGetNumberOfBlocksBeforeCell(gridClientId, columnCount); 50243 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, { 50244 group: "parent", 50245 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, { 50246 className: "block-editor-grid-item-mover__move-button-container", 50247 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 50248 className: "block-editor-grid-item-mover__move-horizontal-button-container is-left", 50249 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMover, { 50250 icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left, 50251 label: (0,external_wp_i18n_namespaceObject.__)('Move left'), 50252 description: (0,external_wp_i18n_namespaceObject.__)('Move left'), 50253 isDisabled: columnStart <= 1, 50254 onClick: () => { 50255 onChange({ 50256 columnStart: columnStart - 1 50257 }); 50258 __unstableMarkNextChangeAsNotPersistent(); 50259 moveBlocksToPosition([blockClientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(columnStart - 1, rowStart)); 50260 } 50261 }) 50262 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 50263 className: "block-editor-grid-item-mover__move-vertical-button-container", 50264 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMover, { 50265 className: "is-up-button", 50266 icon: chevron_up, 50267 label: (0,external_wp_i18n_namespaceObject.__)('Move up'), 50268 description: (0,external_wp_i18n_namespaceObject.__)('Move up'), 50269 isDisabled: rowStart <= 1, 50270 onClick: () => { 50271 onChange({ 50272 rowStart: rowStart - 1 50273 }); 50274 __unstableMarkNextChangeAsNotPersistent(); 50275 moveBlocksToPosition([blockClientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(columnStart, rowStart - 1)); 50276 } 50277 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMover, { 50278 className: "is-down-button", 50279 icon: chevron_down, 50280 label: (0,external_wp_i18n_namespaceObject.__)('Move down'), 50281 description: (0,external_wp_i18n_namespaceObject.__)('Move down'), 50282 isDisabled: rowCount && rowEnd >= rowCount, 50283 onClick: () => { 50284 onChange({ 50285 rowStart: rowStart + 1 50286 }); 50287 __unstableMarkNextChangeAsNotPersistent(); 50288 moveBlocksToPosition([blockClientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(columnStart, rowStart + 1)); 50289 } 50290 })] 50291 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 50292 className: "block-editor-grid-item-mover__move-horizontal-button-container is-right", 50293 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMover, { 50294 icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right, 50295 label: (0,external_wp_i18n_namespaceObject.__)('Move right'), 50296 description: (0,external_wp_i18n_namespaceObject.__)('Move right'), 50297 isDisabled: columnCount && columnEnd >= columnCount, 50298 onClick: () => { 50299 onChange({ 50300 columnStart: columnStart + 1 50301 }); 50302 __unstableMarkNextChangeAsNotPersistent(); 50303 moveBlocksToPosition([blockClientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(columnStart + 1, rowStart)); 50304 } 50305 }) 50306 })] 50307 }) 50308 }); 50309 } 50310 function GridItemMover({ 50311 className, 50312 icon, 50313 label, 50314 isDisabled, 50315 onClick, 50316 description 50317 }) { 50318 const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(GridItemMover); 50319 const descriptionId = `block-editor-grid-item-mover-button__description-$instanceId}`; 50320 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 50321 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 50322 className: dist_clsx('block-editor-grid-item-mover-button', className), 50323 icon: icon, 50324 label: label, 50325 "aria-describedby": descriptionId, 50326 onClick: isDisabled ? null : onClick, 50327 disabled: isDisabled, 50328 accessibleWhenDisabled: true 50329 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 50330 id: descriptionId, 50331 children: description 50332 })] 50333 }); 50334 } 50335 50336 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/layout-child.js 50337 /** 50338 * WordPress dependencies 50339 */ 50340 50341 50342 50343 50344 /** 50345 * Internal dependencies 50346 */ 50347 50348 50349 50350 50351 50352 50353 50354 function useBlockPropsChildLayoutStyles({ 50355 style 50356 }) { 50357 var _style$layout; 50358 const shouldRenderChildLayoutStyles = (0,external_wp_data_namespaceObject.useSelect)(select => { 50359 return !select(store).getSettings().disableLayoutStyles; 50360 }); 50361 const layout = (_style$layout = style?.layout) !== null && _style$layout !== void 0 ? _style$layout : {}; 50362 const { 50363 selfStretch, 50364 flexSize, 50365 columnStart, 50366 rowStart, 50367 columnSpan, 50368 rowSpan 50369 } = layout; 50370 const parentLayout = useLayout() || {}; 50371 const { 50372 columnCount, 50373 minimumColumnWidth 50374 } = parentLayout; 50375 const id = (0,external_wp_compose_namespaceObject.useInstanceId)(useBlockPropsChildLayoutStyles); 50376 const selector = `.wp-container-content-$id}`; 50377 50378 // Check that the grid layout attributes are of the correct type, so that we don't accidentally 50379 // write code that stores a string attribute instead of a number. 50380 if (false) {} 50381 let css = ''; 50382 if (shouldRenderChildLayoutStyles) { 50383 if (selfStretch === 'fixed' && flexSize) { 50384 css = `$selector} { 50385 flex-basis: $flexSize}; 50386 box-sizing: border-box; 50387 }`; 50388 } else if (selfStretch === 'fill') { 50389 css = `$selector} { 50390 flex-grow: 1; 50391 }`; 50392 } else if (columnStart && columnSpan) { 50393 css = `$selector} { 50394 grid-column: $columnStart} / span $columnSpan}; 50395 }`; 50396 } else if (columnStart) { 50397 css = `$selector} { 50398 grid-column: $columnStart}; 50399 }`; 50400 } else if (columnSpan) { 50401 css = `$selector} { 50402 grid-column: span $columnSpan}; 50403 }`; 50404 } 50405 if (rowStart && rowSpan) { 50406 css += `$selector} { 50407 grid-row: $rowStart} / span $rowSpan}; 50408 }`; 50409 } else if (rowStart) { 50410 css += `$selector} { 50411 grid-row: $rowStart}; 50412 }`; 50413 } else if (rowSpan) { 50414 css += `$selector} { 50415 grid-row: span $rowSpan}; 50416 }`; 50417 } 50418 /** 50419 * If minimumColumnWidth is set on the parent, or if no 50420 * columnCount is set, the grid is responsive so a 50421 * container query is needed for the span to resize. 50422 */ 50423 if ((columnSpan || columnStart) && (minimumColumnWidth || !columnCount)) { 50424 let parentColumnValue = parseFloat(minimumColumnWidth); 50425 /** 50426 * 12rem is the default minimumColumnWidth value. 50427 * If parentColumnValue is not a number, default to 12. 50428 */ 50429 if (isNaN(parentColumnValue)) { 50430 parentColumnValue = 12; 50431 } 50432 let parentColumnUnit = minimumColumnWidth?.replace(parentColumnValue, ''); 50433 /** 50434 * Check that parent column unit is either 'px', 'rem' or 'em'. 50435 * If not, default to 'rem'. 50436 */ 50437 if (!['px', 'rem', 'em'].includes(parentColumnUnit)) { 50438 parentColumnUnit = 'rem'; 50439 } 50440 let numColsToBreakAt = 2; 50441 if (columnSpan && columnStart) { 50442 numColsToBreakAt = columnSpan + columnStart - 1; 50443 } else if (columnSpan) { 50444 numColsToBreakAt = columnSpan; 50445 } else { 50446 numColsToBreakAt = columnStart; 50447 } 50448 const defaultGapValue = parentColumnUnit === 'px' ? 24 : 1.5; 50449 const containerQueryValue = numColsToBreakAt * parentColumnValue + (numColsToBreakAt - 1) * defaultGapValue; 50450 // For blocks that only span one column, we want to remove any rowStart values as 50451 // the container reduces in size, so that blocks are still arranged in markup order. 50452 const minimumContainerQueryValue = parentColumnValue * 2 + defaultGapValue - 1; 50453 // If a span is set we want to preserve it as long as possible, otherwise we just reset the value. 50454 const gridColumnValue = columnSpan && columnSpan > 1 ? '1/-1' : 'auto'; 50455 css += `@container (max-width: $Math.max(containerQueryValue, minimumContainerQueryValue)}$parentColumnUnit}) { 50456 $selector} { 50457 grid-column: $gridColumnValue}; 50458 grid-row: auto; 50459 } 50460 }`; 50461 } 50462 } 50463 useStyleOverride({ 50464 css 50465 }); 50466 50467 // Only attach a container class if there is generated CSS to be attached. 50468 if (!css) { 50469 return; 50470 } 50471 50472 // Attach a `wp-container-content` id-based classname. 50473 return { 50474 className: `wp-container-content-$id}` 50475 }; 50476 } 50477 function ChildLayoutControlsPure({ 50478 clientId, 50479 style, 50480 setAttributes 50481 }) { 50482 const parentLayout = useLayout() || {}; 50483 const { 50484 type: parentLayoutType = 'default', 50485 allowSizingOnChildren = false, 50486 isManualPlacement 50487 } = parentLayout; 50488 if (parentLayoutType !== 'grid') { 50489 return null; 50490 } 50491 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridTools, { 50492 clientId: clientId, 50493 style: style, 50494 setAttributes: setAttributes, 50495 allowSizingOnChildren: allowSizingOnChildren, 50496 isManualPlacement: isManualPlacement, 50497 parentLayout: parentLayout 50498 }); 50499 } 50500 function GridTools({ 50501 clientId, 50502 style, 50503 setAttributes, 50504 allowSizingOnChildren, 50505 isManualPlacement, 50506 parentLayout 50507 }) { 50508 const { 50509 rootClientId, 50510 isVisible 50511 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 50512 const { 50513 getBlockRootClientId, 50514 getBlockEditingMode, 50515 getTemplateLock 50516 } = select(store); 50517 const _rootClientId = getBlockRootClientId(clientId); 50518 if (getTemplateLock(_rootClientId) || getBlockEditingMode(_rootClientId) !== 'default') { 50519 return { 50520 rootClientId: _rootClientId, 50521 isVisible: false 50522 }; 50523 } 50524 return { 50525 rootClientId: _rootClientId, 50526 isVisible: true 50527 }; 50528 }, [clientId]); 50529 50530 // Use useState() instead of useRef() so that GridItemResizer updates when ref is set. 50531 const [resizerBounds, setResizerBounds] = (0,external_wp_element_namespaceObject.useState)(); 50532 if (!isVisible) { 50533 return null; 50534 } 50535 function updateLayout(layout) { 50536 setAttributes({ 50537 style: { 50538 ...style, 50539 layout: { 50540 ...style?.layout, 50541 ...layout 50542 } 50543 } 50544 }); 50545 } 50546 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 50547 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizer, { 50548 clientId: rootClientId, 50549 contentRef: setResizerBounds, 50550 parentLayout: parentLayout 50551 }), allowSizingOnChildren && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemResizer, { 50552 clientId: clientId 50553 // Don't allow resizing beyond the grid visualizer. 50554 , 50555 bounds: resizerBounds, 50556 onChange: updateLayout, 50557 parentLayout: parentLayout 50558 }), isManualPlacement && window.__experimentalEnableGridInteractivity && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMovers, { 50559 layout: style?.layout, 50560 parentLayout: parentLayout, 50561 onChange: updateLayout, 50562 gridClientId: rootClientId, 50563 blockClientId: clientId 50564 })] 50565 }); 50566 } 50567 /* harmony default export */ const layout_child = ({ 50568 useBlockProps: useBlockPropsChildLayoutStyles, 50569 edit: ChildLayoutControlsPure, 50570 attributeKeys: ['style'], 50571 hasSupport() { 50572 return true; 50573 } 50574 }); 50575 50576 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/content-lock-ui.js 50577 /** 50578 * WordPress dependencies 50579 */ 50580 50581 50582 50583 50584 50585 /** 50586 * Internal dependencies 50587 */ 50588 50589 50590 50591 50592 // The implementation of content locking is mainly in this file, although the mechanism 50593 // to stop temporarily editing as blocks when an outside block is selected is on component StopEditingAsBlocksOnOutsideSelect 50594 // at block-editor/src/components/block-list/index.js. 50595 // Besides the components on this file and the file referenced above the implementation 50596 // also includes artifacts on the store (actions, reducers, and selector). 50597 50598 function ContentLockControlsPure({ 50599 clientId 50600 }) { 50601 const { 50602 templateLock, 50603 isLockedByParent, 50604 isEditingAsBlocks 50605 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 50606 const { 50607 getContentLockingParent, 50608 getTemplateLock, 50609 getTemporarilyEditingAsBlocks 50610 } = unlock(select(store)); 50611 return { 50612 templateLock: getTemplateLock(clientId), 50613 isLockedByParent: !!getContentLockingParent(clientId), 50614 isEditingAsBlocks: getTemporarilyEditingAsBlocks() === clientId 50615 }; 50616 }, [clientId]); 50617 const { 50618 stopEditingAsBlocks 50619 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 50620 const isContentLocked = !isLockedByParent && templateLock === 'contentOnly'; 50621 const stopEditingAsBlockCallback = (0,external_wp_element_namespaceObject.useCallback)(() => { 50622 stopEditingAsBlocks(clientId); 50623 }, [clientId, stopEditingAsBlocks]); 50624 if (!isContentLocked && !isEditingAsBlocks) { 50625 return null; 50626 } 50627 const showStopEditingAsBlocks = isEditingAsBlocks && !isContentLocked; 50628 return showStopEditingAsBlocks && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, { 50629 group: "other", 50630 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 50631 onClick: stopEditingAsBlockCallback, 50632 children: (0,external_wp_i18n_namespaceObject.__)('Done') 50633 }) 50634 }); 50635 } 50636 /* harmony default export */ const content_lock_ui = ({ 50637 edit: ContentLockControlsPure, 50638 hasSupport() { 50639 return true; 50640 } 50641 }); 50642 50643 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/metadata.js 50644 /** 50645 * WordPress dependencies 50646 */ 50647 50648 const META_ATTRIBUTE_NAME = 'metadata'; 50649 50650 /** 50651 * Filters registered block settings, extending attributes to include `metadata`. 50652 * 50653 * see: https://github.com/WordPress/gutenberg/pull/40393/files#r864632012 50654 * 50655 * @param {Object} blockTypeSettings Original block settings. 50656 * @return {Object} Filtered block settings. 50657 */ 50658 function addMetaAttribute(blockTypeSettings) { 50659 // Allow blocks to specify their own attribute definition with default values if needed. 50660 if (blockTypeSettings?.attributes?.[META_ATTRIBUTE_NAME]?.type) { 50661 return blockTypeSettings; 50662 } 50663 blockTypeSettings.attributes = { 50664 ...blockTypeSettings.attributes, 50665 [META_ATTRIBUTE_NAME]: { 50666 type: 'object' 50667 } 50668 }; 50669 return blockTypeSettings; 50670 } 50671 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/metadata/addMetaAttribute', addMetaAttribute); 50672 50673 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/block-hooks.js 50674 /** 50675 * WordPress dependencies 50676 */ 50677 50678 50679 50680 50681 50682 50683 /** 50684 * Internal dependencies 50685 */ 50686 50687 50688 50689 50690 const block_hooks_EMPTY_OBJECT = {}; 50691 function BlockHooksControlPure({ 50692 name, 50693 clientId, 50694 metadata: { 50695 ignoredHookedBlocks = [] 50696 } = {} 50697 }) { 50698 const blockTypes = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_blocks_namespaceObject.store).getBlockTypes(), []); 50699 50700 // A hooked block added via a filter will not be exposed through a block 50701 // type's `blockHooks` property; however, if the containing layout has been 50702 // modified, it will be present in the anchor block's `ignoredHookedBlocks` 50703 // metadata. 50704 const hookedBlocksForCurrentBlock = (0,external_wp_element_namespaceObject.useMemo)(() => blockTypes?.filter(({ 50705 name: blockName, 50706 blockHooks 50707 }) => blockHooks && name in blockHooks || ignoredHookedBlocks.includes(blockName)), [blockTypes, name, ignoredHookedBlocks]); 50708 const hookedBlockClientIds = (0,external_wp_data_namespaceObject.useSelect)(select => { 50709 const { 50710 getBlocks, 50711 getBlockRootClientId, 50712 getGlobalBlockCount 50713 } = select(store); 50714 const rootClientId = getBlockRootClientId(clientId); 50715 const _hookedBlockClientIds = hookedBlocksForCurrentBlock.reduce((clientIds, block) => { 50716 // If the block doesn't exist anywhere in the block tree, 50717 // we know that we have to set the toggle to disabled. 50718 if (getGlobalBlockCount(block.name) === 0) { 50719 return clientIds; 50720 } 50721 const relativePosition = block?.blockHooks?.[name]; 50722 let candidates; 50723 switch (relativePosition) { 50724 case 'before': 50725 case 'after': 50726 // Any of the current block's siblings (with the right block type) qualifies 50727 // as a hooked block (inserted `before` or `after` the current one), as the block 50728 // might've been automatically inserted and then moved around a bit by the user. 50729 candidates = getBlocks(rootClientId); 50730 break; 50731 case 'first_child': 50732 case 'last_child': 50733 // Any of the current block's child blocks (with the right block type) qualifies 50734 // as a hooked first or last child block, as the block might've been automatically 50735 // inserted and then moved around a bit by the user. 50736 candidates = getBlocks(clientId); 50737 break; 50738 case undefined: 50739 // If we haven't found a blockHooks field with a relative position for the hooked 50740 // block, it means that it was added by a filter. In this case, we look for the block 50741 // both among the current block's siblings and its children. 50742 candidates = [...getBlocks(rootClientId), ...getBlocks(clientId)]; 50743 break; 50744 } 50745 const hookedBlock = candidates?.find(candidate => candidate.name === block.name); 50746 50747 // If the block exists in the designated location, we consider it hooked 50748 // and show the toggle as enabled. 50749 if (hookedBlock) { 50750 return { 50751 ...clientIds, 50752 [block.name]: hookedBlock.clientId 50753 }; 50754 } 50755 50756 // If no hooked block was found in any of its designated locations, 50757 // we set the toggle to disabled. 50758 return clientIds; 50759 }, {}); 50760 if (Object.values(_hookedBlockClientIds).length > 0) { 50761 return _hookedBlockClientIds; 50762 } 50763 return block_hooks_EMPTY_OBJECT; 50764 }, [hookedBlocksForCurrentBlock, name, clientId]); 50765 const { 50766 getBlockIndex, 50767 getBlockCount, 50768 getBlockRootClientId 50769 } = (0,external_wp_data_namespaceObject.useSelect)(store); 50770 const { 50771 insertBlock, 50772 removeBlock 50773 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 50774 if (!hookedBlocksForCurrentBlock.length) { 50775 return null; 50776 } 50777 50778 // Group by block namespace (i.e. prefix before the slash). 50779 const groupedHookedBlocks = hookedBlocksForCurrentBlock.reduce((groups, block) => { 50780 const [namespace] = block.name.split('/'); 50781 if (!groups[namespace]) { 50782 groups[namespace] = []; 50783 } 50784 groups[namespace].push(block); 50785 return groups; 50786 }, {}); 50787 const insertBlockIntoDesignatedLocation = (block, relativePosition) => { 50788 const blockIndex = getBlockIndex(clientId); 50789 const innerBlocksLength = getBlockCount(clientId); 50790 const rootClientId = getBlockRootClientId(clientId); 50791 switch (relativePosition) { 50792 case 'before': 50793 case 'after': 50794 insertBlock(block, relativePosition === 'after' ? blockIndex + 1 : blockIndex, rootClientId, 50795 // Insert as a child of the current block's parent 50796 false); 50797 break; 50798 case 'first_child': 50799 case 'last_child': 50800 insertBlock(block, 50801 // TODO: It'd be great if insertBlock() would accept negative indices for insertion. 50802 relativePosition === 'first_child' ? 0 : innerBlocksLength, clientId, 50803 // Insert as a child of the current block. 50804 false); 50805 break; 50806 case undefined: 50807 // If we do not know the relative position, it is because the block was 50808 // added via a filter. In this case, we default to inserting it after the 50809 // current block. 50810 insertBlock(block, blockIndex + 1, rootClientId, 50811 // Insert as a child of the current block's parent 50812 false); 50813 break; 50814 } 50815 }; 50816 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, { 50817 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.PanelBody, { 50818 className: "block-editor-hooks__block-hooks", 50819 title: (0,external_wp_i18n_namespaceObject.__)('Plugins'), 50820 initialOpen: true, 50821 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 50822 className: "block-editor-hooks__block-hooks-helptext", 50823 children: (0,external_wp_i18n_namespaceObject.__)('Manage the inclusion of blocks added automatically by plugins.') 50824 }), Object.keys(groupedHookedBlocks).map(vendor => { 50825 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_element_namespaceObject.Fragment, { 50826 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("h3", { 50827 children: vendor 50828 }), groupedHookedBlocks[vendor].map(block => { 50829 const checked = (block.name in hookedBlockClientIds); 50830 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, { 50831 __nextHasNoMarginBottom: true, 50832 checked: checked, 50833 label: block.title, 50834 onChange: () => { 50835 if (!checked) { 50836 // Create and insert block. 50837 const relativePosition = block.blockHooks[name]; 50838 insertBlockIntoDesignatedLocation((0,external_wp_blocks_namespaceObject.createBlock)(block.name), relativePosition); 50839 return; 50840 } 50841 50842 // Remove block. 50843 removeBlock(hookedBlockClientIds[block.name], false); 50844 } 50845 }, block.title); 50846 })] 50847 }, vendor); 50848 })] 50849 }) 50850 }); 50851 } 50852 /* harmony default export */ const block_hooks = ({ 50853 edit: BlockHooksControlPure, 50854 attributeKeys: ['metadata'], 50855 hasSupport() { 50856 return true; 50857 } 50858 }); 50859 50860 ;// ./node_modules/@wordpress/block-editor/build-module/utils/block-bindings.js 50861 /** 50862 * WordPress dependencies 50863 */ 50864 50865 50866 /** 50867 * Internal dependencies 50868 */ 50869 50870 50871 function isObjectEmpty(object) { 50872 return !object || Object.keys(object).length === 0; 50873 } 50874 50875 /** 50876 * Contains utils to update the block `bindings` metadata. 50877 * 50878 * @typedef {Object} WPBlockBindingsUtils 50879 * 50880 * @property {Function} updateBlockBindings Updates the value of the bindings connected to block attributes. 50881 * @property {Function} removeAllBlockBindings Removes the bindings property of the `metadata` attribute. 50882 */ 50883 50884 /** 50885 * Retrieves the existing utils needed to update the block `bindings` metadata. 50886 * They can be used to create, modify, or remove connections from the existing block attributes. 50887 * 50888 * It contains the following utils: 50889 * - `updateBlockBindings`: Updates the value of the bindings connected to block attributes. It can be used to remove a specific binding by setting the value to `undefined`. 50890 * - `removeAllBlockBindings`: Removes the bindings property of the `metadata` attribute. 50891 * 50892 * @param {?string} clientId Optional block client ID. If not set, it will use the current block client ID from the context. 50893 * 50894 * @return {?WPBlockBindingsUtils} Object containing the block bindings utils. 50895 * 50896 * @example 50897 * ```js 50898 * import { useBlockBindingsUtils } from '@wordpress/block-editor' 50899 * const { updateBlockBindings, removeAllBlockBindings } = useBlockBindingsUtils(); 50900 * 50901 * // Update url and alt attributes. 50902 * updateBlockBindings( { 50903 * url: { 50904 * source: 'core/post-meta', 50905 * args: { 50906 * key: 'url_custom_field', 50907 * }, 50908 * }, 50909 * alt: { 50910 * source: 'core/post-meta', 50911 * args: { 50912 * key: 'text_custom_field', 50913 * }, 50914 * }, 50915 * } ); 50916 * 50917 * // Remove binding from url attribute. 50918 * updateBlockBindings( { url: undefined } ); 50919 * 50920 * // Remove bindings from all attributes. 50921 * removeAllBlockBindings(); 50922 * ``` 50923 */ 50924 function useBlockBindingsUtils(clientId) { 50925 const { 50926 clientId: contextClientId 50927 } = useBlockEditContext(); 50928 const blockClientId = clientId || contextClientId; 50929 const { 50930 updateBlockAttributes 50931 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 50932 const { 50933 getBlockAttributes 50934 } = (0,external_wp_data_namespaceObject.useRegistry)().select(store); 50935 50936 /** 50937 * Updates the value of the bindings connected to block attributes. 50938 * It removes the binding when the new value is `undefined`. 50939 * 50940 * @param {Object} bindings Bindings including the attributes to update and the new object. 50941 * @param {string} bindings.source The source name to connect to. 50942 * @param {Object} [bindings.args] Object containing the arguments needed by the source. 50943 * 50944 * @example 50945 * ```js 50946 * import { useBlockBindingsUtils } from '@wordpress/block-editor' 50947 * 50948 * const { updateBlockBindings } = useBlockBindingsUtils(); 50949 * updateBlockBindings( { 50950 * url: { 50951 * source: 'core/post-meta', 50952 * args: { 50953 * key: 'url_custom_field', 50954 * }, 50955 * }, 50956 * alt: { 50957 * source: 'core/post-meta', 50958 * args: { 50959 * key: 'text_custom_field', 50960 * }, 50961 * } 50962 * } ); 50963 * ``` 50964 */ 50965 const updateBlockBindings = bindings => { 50966 const { 50967 metadata: { 50968 bindings: currentBindings, 50969 ...metadata 50970 } = {} 50971 } = getBlockAttributes(blockClientId); 50972 const newBindings = { 50973 ...currentBindings 50974 }; 50975 Object.entries(bindings).forEach(([attribute, binding]) => { 50976 if (!binding && newBindings[attribute]) { 50977 delete newBindings[attribute]; 50978 return; 50979 } 50980 newBindings[attribute] = binding; 50981 }); 50982 const newMetadata = { 50983 ...metadata, 50984 bindings: newBindings 50985 }; 50986 if (isObjectEmpty(newMetadata.bindings)) { 50987 delete newMetadata.bindings; 50988 } 50989 updateBlockAttributes(blockClientId, { 50990 metadata: isObjectEmpty(newMetadata) ? undefined : newMetadata 50991 }); 50992 }; 50993 50994 /** 50995 * Removes the bindings property of the `metadata` attribute. 50996 * 50997 * @example 50998 * ```js 50999 * import { useBlockBindingsUtils } from '@wordpress/block-editor' 51000 * 51001 * const { removeAllBlockBindings } = useBlockBindingsUtils(); 51002 * removeAllBlockBindings(); 51003 * ``` 51004 */ 51005 const removeAllBlockBindings = () => { 51006 const { 51007 metadata: { 51008 bindings, 51009 ...metadata 51010 } = {} 51011 } = getBlockAttributes(blockClientId); 51012 updateBlockAttributes(blockClientId, { 51013 metadata: isObjectEmpty(metadata) ? undefined : metadata 51014 }); 51015 }; 51016 return { 51017 updateBlockBindings, 51018 removeAllBlockBindings 51019 }; 51020 } 51021 51022 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/block-bindings.js 51023 /** 51024 * WordPress dependencies 51025 */ 51026 51027 51028 51029 51030 51031 51032 51033 /** 51034 * Internal dependencies 51035 */ 51036 51037 51038 51039 51040 51041 51042 51043 51044 51045 51046 const { 51047 DropdownMenuV2 51048 } = unlock(external_wp_components_namespaceObject.privateApis); 51049 const block_bindings_EMPTY_OBJECT = {}; 51050 const block_bindings_useToolsPanelDropdownMenuProps = () => { 51051 const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<'); 51052 return !isMobile ? { 51053 popoverProps: { 51054 placement: 'left-start', 51055 // For non-mobile, inner sidebar width (248px) - button width (24px) - border (1px) + padding (16px) + spacing (20px) 51056 offset: 259 51057 } 51058 } : {}; 51059 }; 51060 function BlockBindingsPanelDropdown({ 51061 fieldsList, 51062 attribute, 51063 binding 51064 }) { 51065 const { 51066 clientId 51067 } = useBlockEditContext(); 51068 const registeredSources = (0,external_wp_blocks_namespaceObject.getBlockBindingsSources)(); 51069 const { 51070 updateBlockBindings 51071 } = useBlockBindingsUtils(); 51072 const currentKey = binding?.args?.key; 51073 const attributeType = (0,external_wp_data_namespaceObject.useSelect)(select => { 51074 const { 51075 name: blockName 51076 } = select(store).getBlock(clientId); 51077 const _attributeType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName).attributes?.[attribute]?.type; 51078 return _attributeType === 'rich-text' ? 'string' : _attributeType; 51079 }, [clientId, attribute]); 51080 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 51081 children: Object.entries(fieldsList).map(([name, fields], i) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_element_namespaceObject.Fragment, { 51082 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(DropdownMenuV2.Group, { 51083 children: [Object.keys(fieldsList).length > 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DropdownMenuV2.GroupLabel, { 51084 children: registeredSources[name].label 51085 }), Object.entries(fields).filter(([, args]) => args?.type === attributeType).map(([key, args]) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(DropdownMenuV2.RadioItem, { 51086 onChange: () => updateBlockBindings({ 51087 [attribute]: { 51088 source: name, 51089 args: { 51090 key 51091 } 51092 } 51093 }), 51094 name: attribute + '-binding', 51095 value: key, 51096 checked: key === currentKey, 51097 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DropdownMenuV2.ItemLabel, { 51098 children: args?.label 51099 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DropdownMenuV2.ItemHelpText, { 51100 children: args?.value 51101 })] 51102 }, key))] 51103 }), i !== Object.keys(fieldsList).length - 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DropdownMenuV2.Separator, {})] 51104 }, name)) 51105 }); 51106 } 51107 function BlockBindingsAttribute({ 51108 attribute, 51109 binding, 51110 fieldsList 51111 }) { 51112 const { 51113 source: sourceName, 51114 args 51115 } = binding || {}; 51116 const sourceProps = (0,external_wp_blocks_namespaceObject.getBlockBindingsSource)(sourceName); 51117 const isSourceInvalid = !sourceProps; 51118 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 51119 className: "block-editor-bindings__item", 51120 spacing: 0, 51121 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, { 51122 truncate: true, 51123 children: attribute 51124 }), !!binding && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, { 51125 truncate: true, 51126 variant: !isSourceInvalid && 'muted', 51127 isDestructive: isSourceInvalid, 51128 children: isSourceInvalid ? (0,external_wp_i18n_namespaceObject.__)('Invalid source') : fieldsList?.[sourceName]?.[args?.key]?.label || sourceProps?.label || sourceName 51129 })] 51130 }); 51131 } 51132 function ReadOnlyBlockBindingsPanelItems({ 51133 bindings, 51134 fieldsList 51135 }) { 51136 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 51137 children: Object.entries(bindings).map(([attribute, binding]) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItem, { 51138 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockBindingsAttribute, { 51139 attribute: attribute, 51140 binding: binding, 51141 fieldsList: fieldsList 51142 }) 51143 }, attribute)) 51144 }); 51145 } 51146 function EditableBlockBindingsPanelItems({ 51147 attributes, 51148 bindings, 51149 fieldsList 51150 }) { 51151 const { 51152 updateBlockBindings 51153 } = useBlockBindingsUtils(); 51154 const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<'); 51155 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 51156 children: attributes.map(attribute => { 51157 const binding = bindings[attribute]; 51158 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 51159 hasValue: () => !!binding, 51160 label: attribute, 51161 onDeselect: () => { 51162 updateBlockBindings({ 51163 [attribute]: undefined 51164 }); 51165 }, 51166 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DropdownMenuV2, { 51167 placement: isMobile ? 'bottom-start' : 'left-start', 51168 gutter: isMobile ? 8 : 36, 51169 trigger: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItem, { 51170 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockBindingsAttribute, { 51171 attribute: attribute, 51172 binding: binding, 51173 fieldsList: fieldsList 51174 }) 51175 }), 51176 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockBindingsPanelDropdown, { 51177 fieldsList: fieldsList, 51178 attribute: attribute, 51179 binding: binding 51180 }) 51181 }) 51182 }, attribute); 51183 }) 51184 }); 51185 } 51186 const BlockBindingsPanel = ({ 51187 name: blockName, 51188 metadata 51189 }) => { 51190 const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context); 51191 const { 51192 removeAllBlockBindings 51193 } = useBlockBindingsUtils(); 51194 const bindableAttributes = getBindableAttributes(blockName); 51195 const dropdownMenuProps = block_bindings_useToolsPanelDropdownMenuProps(); 51196 51197 // `useSelect` is used purposely here to ensure `getFieldsList` 51198 // is updated whenever there are updates in block context. 51199 // `source.getFieldsList` may also call a selector via `select`. 51200 const _fieldsList = {}; 51201 const { 51202 fieldsList, 51203 canUpdateBlockBindings 51204 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 51205 if (!bindableAttributes || bindableAttributes.length === 0) { 51206 return block_bindings_EMPTY_OBJECT; 51207 } 51208 const registeredSources = (0,external_wp_blocks_namespaceObject.getBlockBindingsSources)(); 51209 Object.entries(registeredSources).forEach(([sourceName, { 51210 getFieldsList, 51211 usesContext 51212 }]) => { 51213 if (getFieldsList) { 51214 // Populate context. 51215 const context = {}; 51216 if (usesContext?.length) { 51217 for (const key of usesContext) { 51218 context[key] = blockContext[key]; 51219 } 51220 } 51221 const sourceList = getFieldsList({ 51222 select, 51223 context 51224 }); 51225 // Only add source if the list is not empty. 51226 if (Object.keys(sourceList || {}).length) { 51227 _fieldsList[sourceName] = { 51228 ...sourceList 51229 }; 51230 } 51231 } 51232 }); 51233 return { 51234 fieldsList: Object.values(_fieldsList).length > 0 ? _fieldsList : block_bindings_EMPTY_OBJECT, 51235 canUpdateBlockBindings: select(store).getSettings().canUpdateBlockBindings 51236 }; 51237 }, [blockContext, bindableAttributes]); 51238 // Return early if there are no bindable attributes. 51239 if (!bindableAttributes || bindableAttributes.length === 0) { 51240 return null; 51241 } 51242 // Filter bindings to only show bindable attributes and remove pattern overrides. 51243 const { 51244 bindings 51245 } = metadata || {}; 51246 const filteredBindings = { 51247 ...bindings 51248 }; 51249 Object.keys(filteredBindings).forEach(key => { 51250 if (!canBindAttribute(blockName, key) || filteredBindings[key].source === 'core/pattern-overrides') { 51251 delete filteredBindings[key]; 51252 } 51253 }); 51254 51255 // Lock the UI when the user can't update bindings or there are no fields to connect to. 51256 const readOnly = !canUpdateBlockBindings || !Object.keys(fieldsList).length; 51257 if (readOnly && Object.keys(filteredBindings).length === 0) { 51258 return null; 51259 } 51260 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, { 51261 group: "bindings", 51262 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanel, { 51263 label: (0,external_wp_i18n_namespaceObject.__)('Attributes'), 51264 resetAll: () => { 51265 removeAllBlockBindings(); 51266 }, 51267 dropdownMenuProps: dropdownMenuProps, 51268 className: "block-editor-bindings__panel", 51269 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, { 51270 isBordered: true, 51271 isSeparated: true, 51272 children: readOnly ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ReadOnlyBlockBindingsPanelItems, { 51273 bindings: filteredBindings, 51274 fieldsList: fieldsList 51275 }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditableBlockBindingsPanelItems, { 51276 attributes: bindableAttributes, 51277 bindings: filteredBindings, 51278 fieldsList: fieldsList 51279 }) 51280 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, { 51281 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, { 51282 variant: "muted", 51283 children: (0,external_wp_i18n_namespaceObject.__)('Attributes connected to custom fields or other dynamic data.') 51284 }) 51285 })] 51286 }) 51287 }); 51288 }; 51289 /* harmony default export */ const block_bindings = ({ 51290 edit: BlockBindingsPanel, 51291 attributeKeys: ['metadata'], 51292 hasSupport() { 51293 return true; 51294 } 51295 }); 51296 51297 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/block-renaming.js 51298 /** 51299 * WordPress dependencies 51300 */ 51301 51302 51303 51304 /** 51305 * Filters registered block settings, adding an `__experimentalLabel` callback if one does not already exist. 51306 * 51307 * @param {Object} settings Original block settings. 51308 * 51309 * @return {Object} Filtered block settings. 51310 */ 51311 function addLabelCallback(settings) { 51312 // If blocks provide their own label callback, do not override it. 51313 if (settings.__experimentalLabel) { 51314 return settings; 51315 } 51316 const supportsBlockNaming = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'renaming', true // default value 51317 ); 51318 51319 // Check whether block metadata is supported before using it. 51320 if (supportsBlockNaming) { 51321 settings.__experimentalLabel = (attributes, { 51322 context 51323 }) => { 51324 const { 51325 metadata 51326 } = attributes; 51327 51328 // In the list view, use the block's name attribute as the label. 51329 if (context === 'list-view' && metadata?.name) { 51330 return metadata.name; 51331 } 51332 }; 51333 } 51334 return settings; 51335 } 51336 (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/metadata/addLabelCallback', addLabelCallback); 51337 51338 ;// ./node_modules/@wordpress/block-editor/build-module/components/grid/use-grid-layout-sync.js 51339 /** 51340 * WordPress dependencies 51341 */ 51342 51343 51344 51345 51346 /** 51347 * Internal dependencies 51348 */ 51349 51350 51351 51352 function useGridLayoutSync({ 51353 clientId: gridClientId 51354 }) { 51355 const { 51356 gridLayout, 51357 blockOrder, 51358 selectedBlockLayout 51359 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 51360 var _getBlockAttributes$l; 51361 const { 51362 getBlockAttributes, 51363 getBlockOrder 51364 } = select(store); 51365 const selectedBlock = select(store).getSelectedBlock(); 51366 return { 51367 gridLayout: (_getBlockAttributes$l = getBlockAttributes(gridClientId).layout) !== null && _getBlockAttributes$l !== void 0 ? _getBlockAttributes$l : {}, 51368 blockOrder: getBlockOrder(gridClientId), 51369 selectedBlockLayout: selectedBlock?.attributes.style?.layout 51370 }; 51371 }, [gridClientId]); 51372 const { 51373 getBlockAttributes, 51374 getBlockRootClientId 51375 } = (0,external_wp_data_namespaceObject.useSelect)(store); 51376 const { 51377 updateBlockAttributes, 51378 __unstableMarkNextChangeAsNotPersistent 51379 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 51380 const selectedBlockRect = (0,external_wp_element_namespaceObject.useMemo)(() => selectedBlockLayout ? new GridRect(selectedBlockLayout) : null, [selectedBlockLayout]); 51381 const previouslySelectedBlockRect = (0,external_wp_compose_namespaceObject.usePrevious)(selectedBlockRect); 51382 const previousIsManualPlacement = (0,external_wp_compose_namespaceObject.usePrevious)(gridLayout.isManualPlacement); 51383 const previousBlockOrder = (0,external_wp_compose_namespaceObject.usePrevious)(blockOrder); 51384 (0,external_wp_element_namespaceObject.useEffect)(() => { 51385 const updates = {}; 51386 if (gridLayout.isManualPlacement) { 51387 const occupiedRects = []; 51388 51389 // Respect the position of blocks that already have a columnStart and rowStart value. 51390 for (const clientId of blockOrder) { 51391 var _getBlockAttributes$s; 51392 const { 51393 columnStart, 51394 rowStart, 51395 columnSpan = 1, 51396 rowSpan = 1 51397 } = (_getBlockAttributes$s = getBlockAttributes(clientId).style?.layout) !== null && _getBlockAttributes$s !== void 0 ? _getBlockAttributes$s : {}; 51398 if (!columnStart || !rowStart) { 51399 continue; 51400 } 51401 occupiedRects.push(new GridRect({ 51402 columnStart, 51403 rowStart, 51404 columnSpan, 51405 rowSpan 51406 })); 51407 } 51408 51409 // When in manual mode, ensure that every block has a columnStart and rowStart value. 51410 for (const clientId of blockOrder) { 51411 var _attributes$style$lay; 51412 const attributes = getBlockAttributes(clientId); 51413 const { 51414 columnStart, 51415 rowStart, 51416 columnSpan = 1, 51417 rowSpan = 1 51418 } = (_attributes$style$lay = attributes.style?.layout) !== null && _attributes$style$lay !== void 0 ? _attributes$style$lay : {}; 51419 if (columnStart && rowStart) { 51420 continue; 51421 } 51422 const [newColumnStart, newRowStart] = placeBlock(occupiedRects, gridLayout.columnCount, columnSpan, rowSpan, previouslySelectedBlockRect?.columnEnd, previouslySelectedBlockRect?.rowEnd); 51423 occupiedRects.push(new GridRect({ 51424 columnStart: newColumnStart, 51425 rowStart: newRowStart, 51426 columnSpan, 51427 rowSpan 51428 })); 51429 updates[clientId] = { 51430 style: { 51431 ...attributes.style, 51432 layout: { 51433 ...attributes.style?.layout, 51434 columnStart: newColumnStart, 51435 rowStart: newRowStart 51436 } 51437 } 51438 }; 51439 } 51440 51441 // Ensure there's enough rows to fit all blocks. 51442 const bottomMostRow = Math.max(...occupiedRects.map(r => r.rowEnd)); 51443 if (!gridLayout.rowCount || gridLayout.rowCount < bottomMostRow) { 51444 updates[gridClientId] = { 51445 layout: { 51446 ...gridLayout, 51447 rowCount: bottomMostRow 51448 } 51449 }; 51450 } 51451 51452 // Unset grid layout attributes for blocks removed from the grid. 51453 for (const clientId of previousBlockOrder !== null && previousBlockOrder !== void 0 ? previousBlockOrder : []) { 51454 if (!blockOrder.includes(clientId)) { 51455 var _attributes$style$lay2; 51456 const rootClientId = getBlockRootClientId(clientId); 51457 51458 // Block was removed from the editor, so nothing to do. 51459 if (rootClientId === null) { 51460 continue; 51461 } 51462 51463 // Check if the block is being moved to another grid. 51464 // If so, do nothing and let the new grid parent handle 51465 // the attributes. 51466 const rootAttributes = getBlockAttributes(rootClientId); 51467 if (rootAttributes?.layout?.type === 'grid') { 51468 continue; 51469 } 51470 const attributes = getBlockAttributes(clientId); 51471 const { 51472 columnStart, 51473 rowStart, 51474 columnSpan, 51475 rowSpan, 51476 ...layout 51477 } = (_attributes$style$lay2 = attributes.style?.layout) !== null && _attributes$style$lay2 !== void 0 ? _attributes$style$lay2 : {}; 51478 if (columnStart || rowStart || columnSpan || rowSpan) { 51479 const hasEmptyLayoutAttribute = Object.keys(layout).length === 0; 51480 updates[clientId] = setImmutably(attributes, ['style', 'layout'], hasEmptyLayoutAttribute ? undefined : layout); 51481 } 51482 } 51483 } 51484 } else { 51485 // Remove all of the columnStart and rowStart values 51486 // when switching from manual to auto mode, 51487 if (previousIsManualPlacement === true) { 51488 for (const clientId of blockOrder) { 51489 var _attributes$style$lay3; 51490 const attributes = getBlockAttributes(clientId); 51491 const { 51492 columnStart, 51493 rowStart, 51494 ...layout 51495 } = (_attributes$style$lay3 = attributes.style?.layout) !== null && _attributes$style$lay3 !== void 0 ? _attributes$style$lay3 : {}; 51496 // Only update attributes if columnStart or rowStart are set. 51497 if (columnStart || rowStart) { 51498 const hasEmptyLayoutAttribute = Object.keys(layout).length === 0; 51499 updates[clientId] = setImmutably(attributes, ['style', 'layout'], hasEmptyLayoutAttribute ? undefined : layout); 51500 } 51501 } 51502 } 51503 51504 // Remove row styles in auto mode 51505 if (gridLayout.rowCount) { 51506 updates[gridClientId] = { 51507 layout: { 51508 ...gridLayout, 51509 rowCount: undefined 51510 } 51511 }; 51512 } 51513 } 51514 if (Object.keys(updates).length) { 51515 __unstableMarkNextChangeAsNotPersistent(); 51516 updateBlockAttributes(Object.keys(updates), updates, /* uniqueByBlock: */true); 51517 } 51518 }, [ 51519 // Actual deps to sync: 51520 gridClientId, gridLayout, previousBlockOrder, blockOrder, previouslySelectedBlockRect, previousIsManualPlacement, 51521 // These won't change, but the linter thinks they might: 51522 __unstableMarkNextChangeAsNotPersistent, getBlockAttributes, getBlockRootClientId, updateBlockAttributes]); 51523 } 51524 51525 /** 51526 * @param {GridRect[]} occupiedRects 51527 * @param {number} gridColumnCount 51528 * @param {number} blockColumnSpan 51529 * @param {number} blockRowSpan 51530 * @param {number?} startColumn 51531 * @param {number?} startRow 51532 */ 51533 function placeBlock(occupiedRects, gridColumnCount, blockColumnSpan, blockRowSpan, startColumn = 1, startRow = 1) { 51534 for (let row = startRow;; row++) { 51535 for (let column = row === startRow ? startColumn : 1; column <= gridColumnCount; column++) { 51536 const candidateRect = new GridRect({ 51537 columnStart: column, 51538 rowStart: row, 51539 columnSpan: blockColumnSpan, 51540 rowSpan: blockRowSpan 51541 }); 51542 if (!occupiedRects.some(r => r.intersectsRect(candidateRect))) { 51543 return [column, row]; 51544 } 51545 } 51546 } 51547 } 51548 51549 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/grid-visualizer.js 51550 /** 51551 * WordPress dependencies 51552 */ 51553 51554 51555 51556 51557 /** 51558 * Internal dependencies 51559 */ 51560 51561 51562 51563 51564 51565 function GridLayoutSync(props) { 51566 useGridLayoutSync(props); 51567 } 51568 function grid_visualizer_GridTools({ 51569 clientId, 51570 layout 51571 }) { 51572 const isVisible = (0,external_wp_data_namespaceObject.useSelect)(select => { 51573 const { 51574 isBlockSelected, 51575 isDraggingBlocks, 51576 getTemplateLock, 51577 getBlockEditingMode 51578 } = select(store); 51579 51580 // These calls are purposely ordered from least expensive to most expensive. 51581 // Hides the visualizer in cases where the user is not or cannot interact with it. 51582 if (!isDraggingBlocks() && !isBlockSelected(clientId) || getTemplateLock(clientId) || getBlockEditingMode(clientId) !== 'default') { 51583 return false; 51584 } 51585 return true; 51586 }, [clientId]); 51587 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 51588 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLayoutSync, { 51589 clientId: clientId 51590 }), isVisible && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizer, { 51591 clientId: clientId, 51592 parentLayout: layout 51593 })] 51594 }); 51595 } 51596 const addGridVisualizerToBlockEdit = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockEdit => props => { 51597 if (props.attributes.layout?.type !== 'grid') { 51598 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEdit, { 51599 ...props 51600 }, "edit"); 51601 } 51602 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 51603 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(grid_visualizer_GridTools, { 51604 clientId: props.clientId, 51605 layout: props.attributes.layout 51606 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEdit, { 51607 ...props 51608 }, "edit")] 51609 }); 51610 }, 'addGridVisualizerToBlockEdit'); 51611 (0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockEdit', 'core/editor/grid-visualizer', addGridVisualizerToBlockEdit); 51612 51613 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-border-props.js 51614 /** 51615 * Internal dependencies 51616 */ 51617 51618 51619 51620 51621 // This utility is intended to assist where the serialization of the border 51622 // block support is being skipped for a block but the border related CSS classes 51623 // & styles still need to be generated so they can be applied to inner elements. 51624 51625 /** 51626 * Provides the CSS class names and inline styles for a block's border support 51627 * attributes. 51628 * 51629 * @param {Object} attributes Block attributes. 51630 * @return {Object} Border block support derived CSS classes & styles. 51631 */ 51632 function getBorderClassesAndStyles(attributes) { 51633 const border = attributes.style?.border || {}; 51634 const className = getBorderClasses(attributes); 51635 return { 51636 className: className || undefined, 51637 style: getInlineStyles({ 51638 border 51639 }) 51640 }; 51641 } 51642 51643 /** 51644 * Derives the border related props for a block from its border block support 51645 * attributes. 51646 * 51647 * Inline styles are forced for named colors to ensure these selections are 51648 * reflected when themes do not load their color stylesheets in the editor. 51649 * 51650 * @param {Object} attributes Block attributes. 51651 * 51652 * @return {Object} ClassName & style props from border block support. 51653 */ 51654 function useBorderProps(attributes) { 51655 const { 51656 colors 51657 } = useMultipleOriginColorsAndGradients(); 51658 const borderProps = getBorderClassesAndStyles(attributes); 51659 const { 51660 borderColor 51661 } = attributes; 51662 51663 // Force inline styles to apply named border colors when themes do not load 51664 // their color stylesheets in the editor. 51665 if (borderColor) { 51666 const borderColorObject = getMultiOriginColor({ 51667 colors, 51668 namedColor: borderColor 51669 }); 51670 borderProps.style.borderColor = borderColorObject.color; 51671 } 51672 return borderProps; 51673 } 51674 51675 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-shadow-props.js 51676 /** 51677 * Internal dependencies 51678 */ 51679 51680 51681 // This utility is intended to assist where the serialization of the shadow 51682 // block support is being skipped for a block but the shadow related CSS classes 51683 // & styles still need to be generated so they can be applied to inner elements. 51684 51685 /** 51686 * Provides the CSS class names and inline styles for a block's shadow support 51687 * attributes. 51688 * 51689 * @param {Object} attributes Block attributes. 51690 * @return {Object} Shadow block support derived CSS classes & styles. 51691 */ 51692 function getShadowClassesAndStyles(attributes) { 51693 const shadow = attributes.style?.shadow || ''; 51694 return { 51695 style: getInlineStyles({ 51696 shadow 51697 }) 51698 }; 51699 } 51700 51701 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-color-props.js 51702 /** 51703 * External dependencies 51704 */ 51705 51706 51707 /** 51708 * WordPress dependencies 51709 */ 51710 51711 51712 /** 51713 * Internal dependencies 51714 */ 51715 51716 51717 51718 51719 51720 // The code in this file has largely been lifted from the color block support 51721 // hook. 51722 // 51723 // This utility is intended to assist where the serialization of the colors 51724 // block support is being skipped for a block but the color related CSS classes 51725 // & styles still need to be generated so they can be applied to inner elements. 51726 51727 /** 51728 * Provides the CSS class names and inline styles for a block's color support 51729 * attributes. 51730 * 51731 * @param {Object} attributes Block attributes. 51732 * 51733 * @return {Object} Color block support derived CSS classes & styles. 51734 */ 51735 function getColorClassesAndStyles(attributes) { 51736 const { 51737 backgroundColor, 51738 textColor, 51739 gradient, 51740 style 51741 } = attributes; 51742 51743 // Collect color CSS classes. 51744 const backgroundClass = getColorClassName('background-color', backgroundColor); 51745 const textClass = getColorClassName('color', textColor); 51746 const gradientClass = __experimentalGetGradientClass(gradient); 51747 const hasGradient = gradientClass || style?.color?.gradient; 51748 51749 // Determine color CSS class name list. 51750 const className = dist_clsx(textClass, gradientClass, { 51751 // Don't apply the background class if there's a gradient. 51752 [backgroundClass]: !hasGradient && !!backgroundClass, 51753 'has-text-color': textColor || style?.color?.text, 51754 'has-background': backgroundColor || style?.color?.background || gradient || style?.color?.gradient, 51755 'has-link-color': style?.elements?.link?.color 51756 }); 51757 51758 // Collect inline styles for colors. 51759 const colorStyles = style?.color || {}; 51760 const styleProp = getInlineStyles({ 51761 color: colorStyles 51762 }); 51763 return { 51764 className: className || undefined, 51765 style: styleProp 51766 }; 51767 } 51768 51769 /** 51770 * Determines the color related props for a block derived from its color block 51771 * support attributes. 51772 * 51773 * Inline styles are forced for named colors to ensure these selections are 51774 * reflected when themes do not load their color stylesheets in the editor. 51775 * 51776 * @param {Object} attributes Block attributes. 51777 * 51778 * @return {Object} ClassName & style props from colors block support. 51779 */ 51780 function useColorProps(attributes) { 51781 const { 51782 backgroundColor, 51783 textColor, 51784 gradient 51785 } = attributes; 51786 const [userPalette, themePalette, defaultPalette, userGradients, themeGradients, defaultGradients] = use_settings_useSettings('color.palette.custom', 'color.palette.theme', 'color.palette.default', 'color.gradients.custom', 'color.gradients.theme', 'color.gradients.default'); 51787 const colors = (0,external_wp_element_namespaceObject.useMemo)(() => [...(userPalette || []), ...(themePalette || []), ...(defaultPalette || [])], [userPalette, themePalette, defaultPalette]); 51788 const gradients = (0,external_wp_element_namespaceObject.useMemo)(() => [...(userGradients || []), ...(themeGradients || []), ...(defaultGradients || [])], [userGradients, themeGradients, defaultGradients]); 51789 const colorProps = getColorClassesAndStyles(attributes); 51790 51791 // Force inline styles to apply colors when themes do not load their color 51792 // stylesheets in the editor. 51793 if (backgroundColor) { 51794 const backgroundColorObject = getColorObjectByAttributeValues(colors, backgroundColor); 51795 colorProps.style.backgroundColor = backgroundColorObject.color; 51796 } 51797 if (gradient) { 51798 colorProps.style.background = getGradientValueBySlug(gradients, gradient); 51799 } 51800 if (textColor) { 51801 const textColorObject = getColorObjectByAttributeValues(colors, textColor); 51802 colorProps.style.color = textColorObject.color; 51803 } 51804 return colorProps; 51805 } 51806 51807 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-spacing-props.js 51808 /** 51809 * Internal dependencies 51810 */ 51811 51812 51813 // This utility is intended to assist where the serialization of the spacing 51814 // block support is being skipped for a block but the spacing related CSS 51815 // styles still need to be generated so they can be applied to inner elements. 51816 51817 /** 51818 * Provides the CSS class names and inline styles for a block's spacing support 51819 * attributes. 51820 * 51821 * @param {Object} attributes Block attributes. 51822 * 51823 * @return {Object} Spacing block support derived CSS classes & styles. 51824 */ 51825 function getSpacingClassesAndStyles(attributes) { 51826 const { 51827 style 51828 } = attributes; 51829 51830 // Collect inline styles for spacing. 51831 const spacingStyles = style?.spacing || {}; 51832 const styleProp = getInlineStyles({ 51833 spacing: spacingStyles 51834 }); 51835 return { 51836 style: styleProp 51837 }; 51838 } 51839 51840 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-typography-props.js 51841 /** 51842 * External dependencies 51843 */ 51844 51845 51846 /** 51847 * WordPress dependencies 51848 */ 51849 51850 51851 /** 51852 * Internal dependencies 51853 */ 51854 51855 51856 51857 51858 const { 51859 kebabCase: use_typography_props_kebabCase 51860 } = unlock(external_wp_components_namespaceObject.privateApis); 51861 51862 /* 51863 * This utility is intended to assist where the serialization of the typography 51864 * block support is being skipped for a block but the typography related CSS 51865 * styles still need to be generated so they can be applied to inner elements. 51866 */ 51867 /** 51868 * Provides the CSS class names and inline styles for a block's typography support 51869 * attributes. 51870 * 51871 * @param {Object} attributes Block attributes. 51872 * @param {Object|boolean} settings Merged theme.json settings 51873 * 51874 * @return {Object} Typography block support derived CSS classes & styles. 51875 */ 51876 function getTypographyClassesAndStyles(attributes, settings) { 51877 let typographyStyles = attributes?.style?.typography || {}; 51878 typographyStyles = { 51879 ...typographyStyles, 51880 fontSize: getTypographyFontSizeValue({ 51881 size: attributes?.style?.typography?.fontSize 51882 }, settings) 51883 }; 51884 const style = getInlineStyles({ 51885 typography: typographyStyles 51886 }); 51887 const fontFamilyClassName = !!attributes?.fontFamily ? `has-$use_typography_props_kebabCase(attributes.fontFamily)}-font-family` : ''; 51888 const textAlignClassName = !!attributes?.style?.typography?.textAlign ? `has-text-align-$attributes?.style?.typography?.textAlign}` : ''; 51889 const className = dist_clsx(fontFamilyClassName, textAlignClassName, getFontSizeClass(attributes?.fontSize)); 51890 return { 51891 className, 51892 style 51893 }; 51894 } 51895 51896 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-cached-truthy.js 51897 /** 51898 * WordPress dependencies 51899 */ 51900 51901 51902 /** 51903 * Keeps an up-to-date copy of the passed value and returns it. If value becomes falsy, it will return the last truthy copy. 51904 * 51905 * @param {any} value 51906 * @return {any} value 51907 */ 51908 function useCachedTruthy(value) { 51909 const [cachedValue, setCachedValue] = (0,external_wp_element_namespaceObject.useState)(value); 51910 (0,external_wp_element_namespaceObject.useEffect)(() => { 51911 if (value) { 51912 setCachedValue(value); 51913 } 51914 }, [value]); 51915 return cachedValue; 51916 } 51917 51918 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/index.js 51919 /** 51920 * Internal dependencies 51921 */ 51922 51923 51924 51925 51926 51927 51928 51929 51930 51931 51932 51933 51934 51935 51936 51937 51938 51939 51940 51941 51942 51943 51944 51945 51946 51947 51948 51949 51950 51951 createBlockEditFilter([align, text_align, hooks_anchor, custom_class_name, style, duotone, position, layout, content_lock_ui, block_hooks, block_bindings, layout_child].filter(Boolean)); 51952 createBlockListBlockFilter([align, text_align, background, style, color, dimensions, duotone, font_family, font_size, border, position, block_style_variation, layout_child]); 51953 createBlockSaveFilter([align, text_align, hooks_anchor, aria_label, custom_class_name, border, color, style, font_family, font_size]); 51954 51955 51956 51957 51958 51959 51960 51961 51962 51963 51964 51965 51966 51967 51968 ;// ./node_modules/@wordpress/block-editor/build-module/components/colors/with-colors.js 51969 /** 51970 * WordPress dependencies 51971 */ 51972 51973 51974 51975 51976 /** 51977 * Internal dependencies 51978 */ 51979 51980 51981 51982 51983 const { 51984 kebabCase: with_colors_kebabCase 51985 } = unlock(external_wp_components_namespaceObject.privateApis); 51986 51987 /** 51988 * Capitalizes the first letter in a string. 51989 * 51990 * @param {string} str The string whose first letter the function will capitalize. 51991 * 51992 * @return {string} Capitalized string. 51993 */ 51994 const upperFirst = ([firstLetter, ...rest]) => firstLetter.toUpperCase() + rest.join(''); 51995 51996 /** 51997 * Higher order component factory for injecting the `colorsArray` argument as 51998 * the colors prop in the `withCustomColors` HOC. 51999 * 52000 * @param {Array} colorsArray An array of color objects. 52001 * 52002 * @return {Function} The higher order component. 52003 */ 52004 const withCustomColorPalette = colorsArray => (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent => props => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { 52005 ...props, 52006 colors: colorsArray 52007 }), 'withCustomColorPalette'); 52008 52009 /** 52010 * Higher order component factory for injecting the editor colors as the 52011 * `colors` prop in the `withColors` HOC. 52012 * 52013 * @return {Function} The higher order component. 52014 */ 52015 const withEditorColorPalette = () => (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent => props => { 52016 const [userPalette, themePalette, defaultPalette] = use_settings_useSettings('color.palette.custom', 'color.palette.theme', 'color.palette.default'); 52017 const allColors = (0,external_wp_element_namespaceObject.useMemo)(() => [...(userPalette || []), ...(themePalette || []), ...(defaultPalette || [])], [userPalette, themePalette, defaultPalette]); 52018 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { 52019 ...props, 52020 colors: allColors 52021 }); 52022 }, 'withEditorColorPalette'); 52023 52024 /** 52025 * Helper function used with `createHigherOrderComponent` to create 52026 * higher order components for managing color logic. 52027 * 52028 * @param {Array} colorTypes An array of color types (e.g. 'backgroundColor, borderColor). 52029 * @param {Function} withColorPalette A HOC for injecting the 'colors' prop into the WrappedComponent. 52030 * 52031 * @return {Component} The component that can be used as a HOC. 52032 */ 52033 function createColorHOC(colorTypes, withColorPalette) { 52034 const colorMap = colorTypes.reduce((colorObject, colorType) => { 52035 return { 52036 ...colorObject, 52037 ...(typeof colorType === 'string' ? { 52038 [colorType]: with_colors_kebabCase(colorType) 52039 } : colorType) 52040 }; 52041 }, {}); 52042 return (0,external_wp_compose_namespaceObject.compose)([withColorPalette, WrappedComponent => { 52043 return class extends external_wp_element_namespaceObject.Component { 52044 constructor(props) { 52045 super(props); 52046 this.setters = this.createSetters(); 52047 this.colorUtils = { 52048 getMostReadableColor: this.getMostReadableColor.bind(this) 52049 }; 52050 this.state = {}; 52051 } 52052 getMostReadableColor(colorValue) { 52053 const { 52054 colors 52055 } = this.props; 52056 return getMostReadableColor(colors, colorValue); 52057 } 52058 createSetters() { 52059 return Object.keys(colorMap).reduce((settersAccumulator, colorAttributeName) => { 52060 const upperFirstColorAttributeName = upperFirst(colorAttributeName); 52061 const customColorAttributeName = `custom$upperFirstColorAttributeName}`; 52062 settersAccumulator[`set$upperFirstColorAttributeName}`] = this.createSetColor(colorAttributeName, customColorAttributeName); 52063 return settersAccumulator; 52064 }, {}); 52065 } 52066 createSetColor(colorAttributeName, customColorAttributeName) { 52067 return colorValue => { 52068 const colorObject = getColorObjectByColorValue(this.props.colors, colorValue); 52069 this.props.setAttributes({ 52070 [colorAttributeName]: colorObject && colorObject.slug ? colorObject.slug : undefined, 52071 [customColorAttributeName]: colorObject && colorObject.slug ? undefined : colorValue 52072 }); 52073 }; 52074 } 52075 static getDerivedStateFromProps({ 52076 attributes, 52077 colors 52078 }, previousState) { 52079 return Object.entries(colorMap).reduce((newState, [colorAttributeName, colorContext]) => { 52080 const colorObject = getColorObjectByAttributeValues(colors, attributes[colorAttributeName], attributes[`custom$upperFirst(colorAttributeName)}`]); 52081 const previousColorObject = previousState[colorAttributeName]; 52082 const previousColor = previousColorObject?.color; 52083 /** 52084 * The "and previousColorObject" condition checks that a previous color object was already computed. 52085 * At the start previousColorObject and colorValue are both equal to undefined 52086 * bus as previousColorObject does not exist we should compute the object. 52087 */ 52088 if (previousColor === colorObject.color && previousColorObject) { 52089 newState[colorAttributeName] = previousColorObject; 52090 } else { 52091 newState[colorAttributeName] = { 52092 ...colorObject, 52093 class: getColorClassName(colorContext, colorObject.slug) 52094 }; 52095 } 52096 return newState; 52097 }, {}); 52098 } 52099 render() { 52100 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { 52101 ...this.props, 52102 colors: undefined, 52103 ...this.state, 52104 ...this.setters, 52105 colorUtils: this.colorUtils 52106 }); 52107 } 52108 }; 52109 }]); 52110 } 52111 52112 /** 52113 * A higher-order component factory for creating a 'withCustomColors' HOC, which handles color logic 52114 * for class generation color value, retrieval and color attribute setting. 52115 * 52116 * Use this higher-order component to work with a custom set of colors. 52117 * 52118 * @example 52119 * 52120 * ```jsx 52121 * const CUSTOM_COLORS = [ { name: 'Red', slug: 'red', color: '#ff0000' }, { name: 'Blue', slug: 'blue', color: '#0000ff' } ]; 52122 * const withCustomColors = createCustomColorsHOC( CUSTOM_COLORS ); 52123 * // ... 52124 * export default compose( 52125 * withCustomColors( 'backgroundColor', 'borderColor' ), 52126 * MyColorfulComponent, 52127 * ); 52128 * ``` 52129 * 52130 * @param {Array} colorsArray The array of color objects (name, slug, color, etc... ). 52131 * 52132 * @return {Function} Higher-order component. 52133 */ 52134 function createCustomColorsHOC(colorsArray) { 52135 return (...colorTypes) => { 52136 const withColorPalette = withCustomColorPalette(colorsArray); 52137 return (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(createColorHOC(colorTypes, withColorPalette), 'withCustomColors'); 52138 }; 52139 } 52140 52141 /** 52142 * A higher-order component, which handles color logic for class generation color value, retrieval and color attribute setting. 52143 * 52144 * For use with the default editor/theme color palette. 52145 * 52146 * @example 52147 * 52148 * ```jsx 52149 * export default compose( 52150 * withColors( 'backgroundColor', { textColor: 'color' } ), 52151 * MyColorfulComponent, 52152 * ); 52153 * ``` 52154 * 52155 * @param {...(Object|string)} colorTypes The arguments can be strings or objects. If the argument is an object, 52156 * it should contain the color attribute name as key and the color context as value. 52157 * If the argument is a string the value should be the color attribute name, 52158 * the color context is computed by applying a kebab case transform to the value. 52159 * Color context represents the context/place where the color is going to be used. 52160 * The class name of the color is generated using 'has' followed by the color name 52161 * and ending with the color context all in kebab case e.g: has-green-background-color. 52162 * 52163 * @return {Function} Higher-order component. 52164 */ 52165 function withColors(...colorTypes) { 52166 const withColorPalette = withEditorColorPalette(); 52167 return (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(createColorHOC(colorTypes, withColorPalette), 'withColors'); 52168 } 52169 52170 ;// ./node_modules/@wordpress/block-editor/build-module/components/colors/index.js 52171 52172 52173 52174 ;// ./node_modules/@wordpress/block-editor/build-module/components/gradients/index.js 52175 52176 52177 ;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/font-size-picker.js 52178 /** 52179 * WordPress dependencies 52180 */ 52181 52182 52183 /** 52184 * Internal dependencies 52185 */ 52186 52187 52188 function font_size_picker_FontSizePicker(props) { 52189 const [fontSizes, customFontSize] = use_settings_useSettings('typography.fontSizes', 'typography.customFontSize'); 52190 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FontSizePicker, { 52191 ...props, 52192 fontSizes: fontSizes, 52193 disableCustomFontSizes: !customFontSize 52194 }); 52195 } 52196 52197 /** 52198 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/font-sizes/README.md 52199 */ 52200 /* harmony default export */ const font_size_picker = (font_size_picker_FontSizePicker); 52201 52202 ;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/with-font-sizes.js 52203 /** 52204 * WordPress dependencies 52205 */ 52206 52207 52208 52209 /** 52210 * Internal dependencies 52211 */ 52212 52213 52214 52215 const DEFAULT_FONT_SIZES = []; 52216 52217 /** 52218 * Capitalizes the first letter in a string. 52219 * 52220 * @param {string} str The string whose first letter the function will capitalize. 52221 * 52222 * @return {string} Capitalized string. 52223 */ 52224 const with_font_sizes_upperFirst = ([firstLetter, ...rest]) => firstLetter.toUpperCase() + rest.join(''); 52225 52226 /** 52227 * Higher-order component, which handles font size logic for class generation, 52228 * font size value retrieval, and font size change handling. 52229 * 52230 * @param {...(Object|string)} fontSizeNames The arguments should all be strings. 52231 * Each string contains the font size 52232 * attribute name e.g: 'fontSize'. 52233 * 52234 * @return {Function} Higher-order component. 52235 */ 52236 /* harmony default export */ const with_font_sizes = ((...fontSizeNames) => { 52237 /* 52238 * Computes an object whose key is the font size attribute name as passed in the array, 52239 * and the value is the custom font size attribute name. 52240 * Custom font size is automatically compted by appending custom followed by the font size attribute name in with the first letter capitalized. 52241 */ 52242 const fontSizeAttributeNames = fontSizeNames.reduce((fontSizeAttributeNamesAccumulator, fontSizeAttributeName) => { 52243 fontSizeAttributeNamesAccumulator[fontSizeAttributeName] = `custom$with_font_sizes_upperFirst(fontSizeAttributeName)}`; 52244 return fontSizeAttributeNamesAccumulator; 52245 }, {}); 52246 return (0,external_wp_compose_namespaceObject.createHigherOrderComponent)((0,external_wp_compose_namespaceObject.compose)([(0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent => props => { 52247 const [fontSizes] = use_settings_useSettings('typography.fontSizes'); 52248 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { 52249 ...props, 52250 fontSizes: fontSizes || DEFAULT_FONT_SIZES 52251 }); 52252 }, 'withFontSizes'), WrappedComponent => { 52253 return class extends external_wp_element_namespaceObject.Component { 52254 constructor(props) { 52255 super(props); 52256 this.setters = this.createSetters(); 52257 this.state = {}; 52258 } 52259 createSetters() { 52260 return Object.entries(fontSizeAttributeNames).reduce((settersAccumulator, [fontSizeAttributeName, customFontSizeAttributeName]) => { 52261 const upperFirstFontSizeAttributeName = with_font_sizes_upperFirst(fontSizeAttributeName); 52262 settersAccumulator[`set$upperFirstFontSizeAttributeName}`] = this.createSetFontSize(fontSizeAttributeName, customFontSizeAttributeName); 52263 return settersAccumulator; 52264 }, {}); 52265 } 52266 createSetFontSize(fontSizeAttributeName, customFontSizeAttributeName) { 52267 return fontSizeValue => { 52268 const fontSizeObject = this.props.fontSizes?.find(({ 52269 size 52270 }) => size === Number(fontSizeValue)); 52271 this.props.setAttributes({ 52272 [fontSizeAttributeName]: fontSizeObject && fontSizeObject.slug ? fontSizeObject.slug : undefined, 52273 [customFontSizeAttributeName]: fontSizeObject && fontSizeObject.slug ? undefined : fontSizeValue 52274 }); 52275 }; 52276 } 52277 static getDerivedStateFromProps({ 52278 attributes, 52279 fontSizes 52280 }, previousState) { 52281 const didAttributesChange = (customFontSizeAttributeName, fontSizeAttributeName) => { 52282 if (previousState[fontSizeAttributeName]) { 52283 // If new font size is name compare with the previous slug. 52284 if (attributes[fontSizeAttributeName]) { 52285 return attributes[fontSizeAttributeName] !== previousState[fontSizeAttributeName].slug; 52286 } 52287 // If font size is not named, update when the font size value changes. 52288 return previousState[fontSizeAttributeName].size !== attributes[customFontSizeAttributeName]; 52289 } 52290 // In this case we need to build the font size object. 52291 return true; 52292 }; 52293 if (!Object.values(fontSizeAttributeNames).some(didAttributesChange)) { 52294 return null; 52295 } 52296 const newState = Object.entries(fontSizeAttributeNames).filter(([key, value]) => didAttributesChange(value, key)).reduce((newStateAccumulator, [fontSizeAttributeName, customFontSizeAttributeName]) => { 52297 const fontSizeAttributeValue = attributes[fontSizeAttributeName]; 52298 const fontSizeObject = utils_getFontSize(fontSizes, fontSizeAttributeValue, attributes[customFontSizeAttributeName]); 52299 newStateAccumulator[fontSizeAttributeName] = { 52300 ...fontSizeObject, 52301 class: getFontSizeClass(fontSizeAttributeValue) 52302 }; 52303 return newStateAccumulator; 52304 }, {}); 52305 return { 52306 ...previousState, 52307 ...newState 52308 }; 52309 } 52310 render() { 52311 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { 52312 ...this.props, 52313 fontSizes: undefined, 52314 ...this.state, 52315 ...this.setters 52316 }); 52317 } 52318 }; 52319 }]), 'withFontSizes'); 52320 }); 52321 52322 ;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/index.js 52323 52324 52325 52326 52327 52328 ;// ./node_modules/@wordpress/block-editor/build-module/autocompleters/block.js 52329 /** 52330 * WordPress dependencies 52331 */ 52332 52333 52334 52335 52336 /** 52337 * Internal dependencies 52338 */ 52339 52340 52341 52342 52343 52344 52345 52346 52347 52348 const block_noop = () => {}; 52349 const block_SHOWN_BLOCK_TYPES = 9; 52350 52351 /** @typedef {import('@wordpress/components').WPCompleter} WPCompleter */ 52352 52353 /** 52354 * Creates a blocks repeater for replacing the current block with a selected block type. 52355 * 52356 * @return {WPCompleter} A blocks completer. 52357 */ 52358 function createBlockCompleter() { 52359 return { 52360 name: 'blocks', 52361 className: 'block-editor-autocompleters__block', 52362 triggerPrefix: '/', 52363 useItems(filterValue) { 52364 const { 52365 rootClientId, 52366 selectedBlockName, 52367 prioritizedBlocks 52368 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 52369 const { 52370 getSelectedBlockClientId, 52371 getBlockName, 52372 getBlockListSettings, 52373 getBlockRootClientId 52374 } = select(store); 52375 const selectedBlockClientId = getSelectedBlockClientId(); 52376 const _rootClientId = getBlockRootClientId(selectedBlockClientId); 52377 return { 52378 selectedBlockName: selectedBlockClientId ? getBlockName(selectedBlockClientId) : null, 52379 rootClientId: _rootClientId, 52380 prioritizedBlocks: getBlockListSettings(_rootClientId)?.prioritizedInserterBlocks 52381 }; 52382 }, []); 52383 const [items, categories, collections] = use_block_types_state(rootClientId, block_noop, true); 52384 const filteredItems = (0,external_wp_element_namespaceObject.useMemo)(() => { 52385 const initialFilteredItems = !!filterValue.trim() ? searchBlockItems(items, categories, collections, filterValue) : orderInserterBlockItems(orderBy(items, 'frecency', 'desc'), prioritizedBlocks); 52386 return initialFilteredItems.filter(item => item.name !== selectedBlockName).slice(0, block_SHOWN_BLOCK_TYPES); 52387 }, [filterValue, selectedBlockName, items, categories, collections, prioritizedBlocks]); 52388 const options = (0,external_wp_element_namespaceObject.useMemo)(() => filteredItems.map(blockItem => { 52389 const { 52390 title, 52391 icon, 52392 isDisabled 52393 } = blockItem; 52394 return { 52395 key: `block-$blockItem.id}`, 52396 value: blockItem, 52397 label: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 52398 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 52399 icon: icon, 52400 showColors: true 52401 }, "icon"), title] 52402 }), 52403 isDisabled 52404 }; 52405 }), [filteredItems]); 52406 return [options]; 52407 }, 52408 allowContext(before, after) { 52409 return !(/\S/.test(before) || /\S/.test(after)); 52410 }, 52411 getOptionCompletion(inserterItem) { 52412 const { 52413 name, 52414 initialAttributes, 52415 innerBlocks, 52416 syncStatus, 52417 content 52418 } = inserterItem; 52419 return { 52420 action: 'replace', 52421 value: syncStatus === 'unsynced' ? (0,external_wp_blocks_namespaceObject.parse)(content, { 52422 __unstableSkipMigrationLogs: true 52423 }) : (0,external_wp_blocks_namespaceObject.createBlock)(name, initialAttributes, (0,external_wp_blocks_namespaceObject.createBlocksFromInnerBlocksTemplate)(innerBlocks)) 52424 }; 52425 } 52426 }; 52427 } 52428 52429 /** 52430 * Creates a blocks repeater for replacing the current block with a selected block type. 52431 * 52432 * @return {WPCompleter} A blocks completer. 52433 */ 52434 /* harmony default export */ const autocompleters_block = (createBlockCompleter()); 52435 52436 ;// external ["wp","apiFetch"] 52437 const external_wp_apiFetch_namespaceObject = window["wp"]["apiFetch"]; 52438 var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_namespaceObject); 52439 ;// ./node_modules/@wordpress/icons/build-module/library/post.js 52440 /** 52441 * WordPress dependencies 52442 */ 52443 52444 52445 const post = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 52446 xmlns: "http://www.w3.org/2000/svg", 52447 viewBox: "0 0 24 24", 52448 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 52449 d: "m7.3 9.7 1.4 1.4c.2-.2.3-.3.4-.5 0 0 0-.1.1-.1.3-.5.4-1.1.3-1.6L12 7 9 4 7.2 6.5c-.6-.1-1.1 0-1.6.3 0 0-.1 0-.1.1-.3.1-.4.2-.6.4l1.4 1.4L4 11v1h1l2.3-2.3zM4 20h9v-1.5H4V20zm0-5.5V16h16v-1.5H4z" 52450 }) 52451 }); 52452 /* harmony default export */ const library_post = (post); 52453 52454 ;// ./node_modules/@wordpress/block-editor/build-module/autocompleters/link.js 52455 /** 52456 * WordPress dependencies 52457 */ 52458 // Disable Reason: Needs to be refactored. 52459 // eslint-disable-next-line no-restricted-imports 52460 52461 52462 52463 52464 52465 52466 const SHOWN_SUGGESTIONS = 10; 52467 52468 /** @typedef {import('@wordpress/components').WPCompleter} WPCompleter */ 52469 52470 /** 52471 * Creates a suggestion list for links to posts or pages. 52472 * 52473 * @return {WPCompleter} A links completer. 52474 */ 52475 function createLinkCompleter() { 52476 return { 52477 name: 'links', 52478 className: 'block-editor-autocompleters__link', 52479 triggerPrefix: '[[', 52480 options: async letters => { 52481 let options = await external_wp_apiFetch_default()({ 52482 path: (0,external_wp_url_namespaceObject.addQueryArgs)('/wp/v2/search', { 52483 per_page: SHOWN_SUGGESTIONS, 52484 search: letters, 52485 type: 'post', 52486 order_by: 'menu_order' 52487 }) 52488 }); 52489 options = options.filter(option => option.title !== ''); 52490 return options; 52491 }, 52492 getOptionKeywords(item) { 52493 const expansionWords = item.title.split(/\s+/); 52494 return [...expansionWords]; 52495 }, 52496 getOptionLabel(item) { 52497 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 52498 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 52499 icon: item.subtype === 'page' ? library_page : library_post 52500 }, "icon"), item.title] 52501 }); 52502 }, 52503 getOptionCompletion(item) { 52504 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("a", { 52505 href: item.url, 52506 children: item.title 52507 }); 52508 } 52509 }; 52510 } 52511 52512 /** 52513 * Creates a suggestion list for links to posts or pages.. 52514 * 52515 * @return {WPCompleter} A link completer. 52516 */ 52517 /* harmony default export */ const autocompleters_link = (createLinkCompleter()); 52518 52519 ;// ./node_modules/@wordpress/block-editor/build-module/components/autocomplete/index.js 52520 /** 52521 * WordPress dependencies 52522 */ 52523 52524 52525 52526 52527 52528 /** 52529 * Internal dependencies 52530 */ 52531 52532 52533 52534 52535 /** 52536 * Shared reference to an empty array for cases where it is important to avoid 52537 * returning a new array reference on every invocation. 52538 * 52539 * @type {Array} 52540 */ 52541 52542 const autocomplete_EMPTY_ARRAY = []; 52543 function useCompleters({ 52544 completers = autocomplete_EMPTY_ARRAY 52545 }) { 52546 const { 52547 name 52548 } = useBlockEditContext(); 52549 return (0,external_wp_element_namespaceObject.useMemo)(() => { 52550 let filteredCompleters = [...completers, autocompleters_link]; 52551 if (name === (0,external_wp_blocks_namespaceObject.getDefaultBlockName)() || (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, '__experimentalSlashInserter', false)) { 52552 filteredCompleters = [...filteredCompleters, autocompleters_block]; 52553 } 52554 if ((0,external_wp_hooks_namespaceObject.hasFilter)('editor.Autocomplete.completers')) { 52555 // Provide copies so filters may directly modify them. 52556 if (filteredCompleters === completers) { 52557 filteredCompleters = filteredCompleters.map(completer => ({ 52558 ...completer 52559 })); 52560 } 52561 filteredCompleters = (0,external_wp_hooks_namespaceObject.applyFilters)('editor.Autocomplete.completers', filteredCompleters, name); 52562 } 52563 return filteredCompleters; 52564 }, [completers, name]); 52565 } 52566 function useBlockEditorAutocompleteProps(props) { 52567 return (0,external_wp_components_namespaceObject.__unstableUseAutocompleteProps)({ 52568 ...props, 52569 completers: useCompleters(props) 52570 }); 52571 } 52572 52573 /** 52574 * Wrap the default Autocomplete component with one that supports a filter hook 52575 * for customizing its list of autocompleters. 52576 * 52577 * @type {import('react').FC} 52578 */ 52579 function BlockEditorAutocomplete(props) { 52580 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Autocomplete, { 52581 ...props, 52582 completers: useCompleters(props) 52583 }); 52584 } 52585 52586 /** 52587 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/autocomplete/README.md 52588 */ 52589 /* harmony default export */ const autocomplete = (BlockEditorAutocomplete); 52590 52591 ;// ./node_modules/@wordpress/icons/build-module/library/fullscreen.js 52592 /** 52593 * WordPress dependencies 52594 */ 52595 52596 52597 const fullscreen = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 52598 xmlns: "http://www.w3.org/2000/svg", 52599 viewBox: "0 0 24 24", 52600 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 52601 d: "M6 4a2 2 0 0 0-2 2v3h1.5V6a.5.5 0 0 1 .5-.5h3V4H6Zm3 14.5H6a.5.5 0 0 1-.5-.5v-3H4v3a2 2 0 0 0 2 2h3v-1.5Zm6 1.5v-1.5h3a.5.5 0 0 0 .5-.5v-3H20v3a2 2 0 0 1-2 2h-3Zm3-16a2 2 0 0 1 2 2v3h-1.5V6a.5.5 0 0 0-.5-.5h-3V4h3Z" 52602 }) 52603 }); 52604 /* harmony default export */ const library_fullscreen = (fullscreen); 52605 52606 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-full-height-alignment-control/index.js 52607 /** 52608 * WordPress dependencies 52609 */ 52610 52611 52612 52613 52614 function BlockFullHeightAlignmentControl({ 52615 isActive, 52616 label = (0,external_wp_i18n_namespaceObject.__)('Toggle full height'), 52617 onToggle, 52618 isDisabled 52619 }) { 52620 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 52621 isActive: isActive, 52622 icon: library_fullscreen, 52623 label: label, 52624 onClick: () => onToggle(!isActive), 52625 disabled: isDisabled 52626 }); 52627 } 52628 /* harmony default export */ const block_full_height_alignment_control = (BlockFullHeightAlignmentControl); 52629 52630 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-matrix-control/index.js 52631 /** 52632 * WordPress dependencies 52633 */ 52634 52635 52636 52637 52638 const block_alignment_matrix_control_noop = () => {}; 52639 function BlockAlignmentMatrixControl(props) { 52640 const { 52641 label = (0,external_wp_i18n_namespaceObject.__)('Change matrix alignment'), 52642 onChange = block_alignment_matrix_control_noop, 52643 value = 'center', 52644 isDisabled 52645 } = props; 52646 const icon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.AlignmentMatrixControl.Icon, { 52647 value: value 52648 }); 52649 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 52650 popoverProps: { 52651 placement: 'bottom-start' 52652 }, 52653 renderToggle: ({ 52654 onToggle, 52655 isOpen 52656 }) => { 52657 const openOnArrowDown = event => { 52658 if (!isOpen && event.keyCode === external_wp_keycodes_namespaceObject.DOWN) { 52659 event.preventDefault(); 52660 onToggle(); 52661 } 52662 }; 52663 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 52664 onClick: onToggle, 52665 "aria-haspopup": "true", 52666 "aria-expanded": isOpen, 52667 onKeyDown: openOnArrowDown, 52668 label: label, 52669 icon: icon, 52670 showTooltip: true, 52671 disabled: isDisabled 52672 }); 52673 }, 52674 renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.AlignmentMatrixControl, { 52675 hasFocusBorder: false, 52676 onChange: onChange, 52677 value: value 52678 }) 52679 }); 52680 } 52681 /* harmony default export */ const block_alignment_matrix_control = (BlockAlignmentMatrixControl); 52682 52683 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-title/use-block-display-title.js 52684 /** 52685 * WordPress dependencies 52686 */ 52687 52688 52689 52690 /** 52691 * Internal dependencies 52692 */ 52693 52694 52695 /** 52696 * Returns the block's configured title as a string, or empty if the title 52697 * cannot be determined. 52698 * 52699 * @example 52700 * 52701 * ```js 52702 * useBlockDisplayTitle( { clientId: 'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1', maximumLength: 17 } ); 52703 * ``` 52704 * 52705 * @param {Object} props 52706 * @param {string} props.clientId Client ID of block. 52707 * @param {number|undefined} props.maximumLength The maximum length that the block title string may be before truncated. 52708 * @param {string|undefined} props.context The context to pass to `getBlockLabel`. 52709 * @return {?string} Block title. 52710 */ 52711 function useBlockDisplayTitle({ 52712 clientId, 52713 maximumLength, 52714 context 52715 }) { 52716 const blockTitle = (0,external_wp_data_namespaceObject.useSelect)(select => { 52717 if (!clientId) { 52718 return null; 52719 } 52720 const { 52721 getBlockName, 52722 getBlockAttributes 52723 } = select(store); 52724 const { 52725 getBlockType, 52726 getActiveBlockVariation 52727 } = select(external_wp_blocks_namespaceObject.store); 52728 const blockName = getBlockName(clientId); 52729 const blockType = getBlockType(blockName); 52730 if (!blockType) { 52731 return null; 52732 } 52733 const attributes = getBlockAttributes(clientId); 52734 const label = (0,external_wp_blocks_namespaceObject.__experimentalGetBlockLabel)(blockType, attributes, context); 52735 // If the label is defined we prioritize it over a possible block variation title match. 52736 if (label !== blockType.title) { 52737 return label; 52738 } 52739 const match = getActiveBlockVariation(blockName, attributes); 52740 // Label will fallback to the title if no label is defined for the current label context. 52741 return match?.title || blockType.title; 52742 }, [clientId, context]); 52743 if (!blockTitle) { 52744 return null; 52745 } 52746 if (maximumLength && maximumLength > 0 && blockTitle.length > maximumLength) { 52747 const omission = '...'; 52748 return blockTitle.slice(0, maximumLength - omission.length) + omission; 52749 } 52750 return blockTitle; 52751 } 52752 52753 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-title/index.js 52754 /** 52755 * Internal dependencies 52756 */ 52757 52758 52759 52760 /** 52761 * Renders the block's configured title as a string, or empty if the title 52762 * cannot be determined. 52763 * 52764 * @example 52765 * 52766 * ```jsx 52767 * <BlockTitle clientId="afd1cb17-2c08-4e7a-91be-007ba7ddc3a1" maximumLength={ 17 }/> 52768 * ``` 52769 * 52770 * @param {Object} props 52771 * @param {string} props.clientId Client ID of block. 52772 * @param {number|undefined} props.maximumLength The maximum length that the block title string may be before truncated. 52773 * @param {string|undefined} props.context The context to pass to `getBlockLabel`. 52774 * 52775 * @return {JSX.Element} Block title. 52776 */ 52777 function BlockTitle({ 52778 clientId, 52779 maximumLength, 52780 context 52781 }) { 52782 return useBlockDisplayTitle({ 52783 clientId, 52784 maximumLength, 52785 context 52786 }); 52787 } 52788 52789 ;// ./node_modules/@wordpress/block-editor/build-module/utils/get-editor-region.js 52790 /** 52791 * Gets the editor region for a given editor canvas element or 52792 * returns the passed element if no region is found 52793 * 52794 * @param { Object } editor The editor canvas element. 52795 * @return { Object } The editor region or given editor element 52796 */ 52797 function getEditorRegion(editor) { 52798 var _Array$from$find, _editorCanvas$closest; 52799 if (!editor) { 52800 return null; 52801 } 52802 52803 // If there are multiple editors, we need to find the iframe that contains our contentRef to make sure 52804 // we're focusing the region that contains this editor. 52805 const editorCanvas = (_Array$from$find = Array.from(document.querySelectorAll('iframe[name="editor-canvas"]').values()).find(iframe => { 52806 // Find the iframe that contains our contentRef 52807 const iframeDocument = iframe.contentDocument || iframe.contentWindow.document; 52808 return iframeDocument === editor.ownerDocument; 52809 })) !== null && _Array$from$find !== void 0 ? _Array$from$find : editor; 52810 52811 // The region is provided by the editor, not the block-editor. 52812 // We should send focus to the region if one is available to reuse the 52813 // same interface for navigating landmarks. If no region is available, 52814 // use the canvas instead. 52815 return (_editorCanvas$closest = editorCanvas?.closest('[role="region"]')) !== null && _editorCanvas$closest !== void 0 ? _editorCanvas$closest : editorCanvas; 52816 } 52817 52818 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-breadcrumb/index.js 52819 /** 52820 * WordPress dependencies 52821 */ 52822 52823 52824 52825 52826 52827 52828 /** 52829 * Internal dependencies 52830 */ 52831 52832 52833 52834 52835 52836 52837 /** 52838 * Block breadcrumb component, displaying the hierarchy of the current block selection as a breadcrumb. 52839 * 52840 * @param {Object} props Component props. 52841 * @param {string} props.rootLabelText Translated label for the root element of the breadcrumb trail. 52842 * @return {Element} Block Breadcrumb. 52843 */ 52844 52845 52846 function BlockBreadcrumb({ 52847 rootLabelText 52848 }) { 52849 const { 52850 selectBlock, 52851 clearSelectedBlock 52852 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 52853 const { 52854 clientId, 52855 parents, 52856 hasSelection 52857 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 52858 const { 52859 getSelectionStart, 52860 getSelectedBlockClientId, 52861 getEnabledBlockParents 52862 } = unlock(select(store)); 52863 const selectedBlockClientId = getSelectedBlockClientId(); 52864 return { 52865 parents: getEnabledBlockParents(selectedBlockClientId), 52866 clientId: selectedBlockClientId, 52867 hasSelection: !!getSelectionStart().clientId 52868 }; 52869 }, []); 52870 const rootLabel = rootLabelText || (0,external_wp_i18n_namespaceObject.__)('Document'); 52871 52872 // We don't care about this specific ref, but this is a way 52873 // to get a ref within the editor canvas so we can focus it later. 52874 const blockRef = (0,external_wp_element_namespaceObject.useRef)(); 52875 useBlockElementRef(clientId, blockRef); 52876 52877 /* 52878 * Disable reason: The `list` ARIA role is redundant but 52879 * Safari+VoiceOver won't announce the list otherwise. 52880 */ 52881 /* eslint-disable jsx-a11y/no-redundant-roles */ 52882 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("ul", { 52883 className: "block-editor-block-breadcrumb", 52884 role: "list", 52885 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Block breadcrumb'), 52886 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", { 52887 className: !hasSelection ? 'block-editor-block-breadcrumb__current' : undefined, 52888 "aria-current": !hasSelection ? 'true' : undefined, 52889 children: [hasSelection && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 52890 size: "small", 52891 className: "block-editor-block-breadcrumb__button", 52892 onClick: () => { 52893 // Find the block editor wrapper for the selected block 52894 const blockEditor = blockRef.current?.closest('.editor-styles-wrapper'); 52895 clearSelectedBlock(); 52896 getEditorRegion(blockEditor)?.focus(); 52897 }, 52898 children: rootLabel 52899 }), !hasSelection && rootLabel, !!clientId && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 52900 icon: chevron_right_small, 52901 className: "block-editor-block-breadcrumb__separator" 52902 })] 52903 }), parents.map(parentClientId => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", { 52904 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 52905 size: "small", 52906 className: "block-editor-block-breadcrumb__button", 52907 onClick: () => selectBlock(parentClientId), 52908 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTitle, { 52909 clientId: parentClientId, 52910 maximumLength: 35 52911 }) 52912 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 52913 icon: chevron_right_small, 52914 className: "block-editor-block-breadcrumb__separator" 52915 })] 52916 }, parentClientId)), !!clientId && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("li", { 52917 className: "block-editor-block-breadcrumb__current", 52918 "aria-current": "true", 52919 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTitle, { 52920 clientId: clientId, 52921 maximumLength: 35 52922 }) 52923 })] 52924 }) 52925 /* eslint-enable jsx-a11y/no-redundant-roles */; 52926 } 52927 /* harmony default export */ const block_breadcrumb = (BlockBreadcrumb); 52928 52929 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-content-overlay/index.js 52930 /** 52931 * WordPress dependencies 52932 */ 52933 52934 52935 /** 52936 * Internal dependencies 52937 */ 52938 52939 function useBlockOverlayActive(clientId) { 52940 return (0,external_wp_data_namespaceObject.useSelect)(select => { 52941 const { 52942 __unstableHasActiveBlockOverlayActive 52943 } = select(store); 52944 return __unstableHasActiveBlockOverlayActive(clientId); 52945 }, [clientId]); 52946 } 52947 52948 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/use-block-toolbar-popover-props.js 52949 /** 52950 * WordPress dependencies 52951 */ 52952 52953 52954 52955 52956 52957 /** 52958 * Internal dependencies 52959 */ 52960 52961 52962 52963 52964 const COMMON_PROPS = { 52965 placement: 'top-start' 52966 }; 52967 52968 // By default the toolbar sets the `shift` prop. If the user scrolls the page 52969 // down the toolbar will stay on screen by adopting a sticky position at the 52970 // top of the viewport. 52971 const DEFAULT_PROPS = { 52972 ...COMMON_PROPS, 52973 flip: false, 52974 shift: true 52975 }; 52976 52977 // When there isn't enough height between the top of the block and the editor 52978 // canvas, the `shift` prop is set to `false`, as it will cause the block to be 52979 // obscured. The `flip` behavior is enabled, which positions the toolbar below 52980 // the block. This only happens if the block is smaller than the viewport, as 52981 // otherwise the toolbar will be off-screen. 52982 const RESTRICTED_HEIGHT_PROPS = { 52983 ...COMMON_PROPS, 52984 flip: true, 52985 shift: false 52986 }; 52987 52988 /** 52989 * Get the popover props for the block toolbar, determined by the space at the top of the canvas and the toolbar height. 52990 * 52991 * @param {Element} contentElement The DOM element that represents the editor content or canvas. 52992 * @param {Element} selectedBlockElement The outer DOM element of the first selected block. 52993 * @param {Element} scrollContainer The scrollable container for the contentElement. 52994 * @param {number} toolbarHeight The height of the toolbar in pixels. 52995 * @param {boolean} isSticky Whether or not the selected block is sticky or fixed. 52996 * 52997 * @return {Object} The popover props used to determine the position of the toolbar. 52998 */ 52999 function getProps(contentElement, selectedBlockElement, scrollContainer, toolbarHeight, isSticky) { 53000 if (!contentElement || !selectedBlockElement) { 53001 return DEFAULT_PROPS; 53002 } 53003 53004 // Get how far the content area has been scrolled. 53005 const scrollTop = scrollContainer?.scrollTop || 0; 53006 const blockRect = getElementBounds(selectedBlockElement); 53007 const contentRect = contentElement.getBoundingClientRect(); 53008 53009 // Get the vertical position of top of the visible content area. 53010 const topOfContentElementInViewport = scrollTop + contentRect.top; 53011 53012 // The document element's clientHeight represents the viewport height. 53013 const viewportHeight = contentElement.ownerDocument.documentElement.clientHeight; 53014 53015 // The restricted height area is calculated as the sum of the 53016 // vertical position of the visible content area, plus the height 53017 // of the block toolbar. 53018 const restrictedTopArea = topOfContentElementInViewport + toolbarHeight; 53019 const hasSpaceForToolbarAbove = blockRect.top > restrictedTopArea; 53020 const isBlockTallerThanViewport = blockRect.height > viewportHeight - toolbarHeight; 53021 53022 // Sticky blocks are treated as if they will never have enough space for the toolbar above. 53023 if (!isSticky && (hasSpaceForToolbarAbove || isBlockTallerThanViewport)) { 53024 return DEFAULT_PROPS; 53025 } 53026 return RESTRICTED_HEIGHT_PROPS; 53027 } 53028 53029 /** 53030 * Determines the desired popover positioning behavior, returning a set of appropriate props. 53031 * 53032 * @param {Object} elements 53033 * @param {Element} elements.contentElement The DOM element that represents the editor content or canvas. 53034 * @param {string} elements.clientId The clientId of the first selected block. 53035 * 53036 * @return {Object} The popover props used to determine the position of the toolbar. 53037 */ 53038 function useBlockToolbarPopoverProps({ 53039 contentElement, 53040 clientId 53041 }) { 53042 const selectedBlockElement = useBlockElement(clientId); 53043 const [toolbarHeight, setToolbarHeight] = (0,external_wp_element_namespaceObject.useState)(0); 53044 const { 53045 blockIndex, 53046 isSticky 53047 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 53048 const { 53049 getBlockIndex, 53050 getBlockAttributes 53051 } = select(store); 53052 return { 53053 blockIndex: getBlockIndex(clientId), 53054 isSticky: hasStickyOrFixedPositionValue(getBlockAttributes(clientId)) 53055 }; 53056 }, [clientId]); 53057 const scrollContainer = (0,external_wp_element_namespaceObject.useMemo)(() => { 53058 if (!contentElement) { 53059 return; 53060 } 53061 return (0,external_wp_dom_namespaceObject.getScrollContainer)(contentElement); 53062 }, [contentElement]); 53063 const [props, setProps] = (0,external_wp_element_namespaceObject.useState)(() => getProps(contentElement, selectedBlockElement, scrollContainer, toolbarHeight, isSticky)); 53064 const popoverRef = (0,external_wp_compose_namespaceObject.useRefEffect)(popoverNode => { 53065 setToolbarHeight(popoverNode.offsetHeight); 53066 }, []); 53067 const updateProps = (0,external_wp_element_namespaceObject.useCallback)(() => setProps(getProps(contentElement, selectedBlockElement, scrollContainer, toolbarHeight, isSticky)), [contentElement, selectedBlockElement, scrollContainer, toolbarHeight]); 53068 53069 // Update props when the block is moved. This also ensures the props are 53070 // correct on initial mount, and when the selected block or content element 53071 // changes (since the callback ref will update). 53072 (0,external_wp_element_namespaceObject.useLayoutEffect)(updateProps, [blockIndex, updateProps]); 53073 53074 // Update props when the viewport is resized or the block is resized. 53075 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 53076 if (!contentElement || !selectedBlockElement) { 53077 return; 53078 } 53079 53080 // Update the toolbar props on viewport resize. 53081 const contentView = contentElement?.ownerDocument?.defaultView; 53082 contentView?.addEventHandler?.('resize', updateProps); 53083 53084 // Update the toolbar props on block resize. 53085 let resizeObserver; 53086 const blockView = selectedBlockElement?.ownerDocument?.defaultView; 53087 if (blockView.ResizeObserver) { 53088 resizeObserver = new blockView.ResizeObserver(updateProps); 53089 resizeObserver.observe(selectedBlockElement); 53090 } 53091 return () => { 53092 contentView?.removeEventHandler?.('resize', updateProps); 53093 if (resizeObserver) { 53094 resizeObserver.disconnect(); 53095 } 53096 }; 53097 }, [updateProps, contentElement, selectedBlockElement]); 53098 return { 53099 ...props, 53100 ref: popoverRef 53101 }; 53102 } 53103 53104 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/use-selected-block-tool-props.js 53105 /** 53106 * WordPress dependencies 53107 */ 53108 53109 53110 /** 53111 * Internal dependencies 53112 */ 53113 53114 53115 /** 53116 * Returns props for the selected block tools and empty block inserter. 53117 * 53118 * @param {string} clientId Selected block client ID. 53119 */ 53120 function useSelectedBlockToolProps(clientId) { 53121 const selectedBlockProps = (0,external_wp_data_namespaceObject.useSelect)(select => { 53122 const { 53123 getBlockRootClientId, 53124 getBlockParents, 53125 __experimentalGetBlockListSettingsForBlocks, 53126 isBlockInsertionPointVisible, 53127 getBlockInsertionPoint, 53128 getBlockOrder, 53129 hasMultiSelection, 53130 getLastMultiSelectedBlockClientId 53131 } = select(store); 53132 const blockParentsClientIds = getBlockParents(clientId); 53133 53134 // Get Block List Settings for all ancestors of the current Block clientId. 53135 const parentBlockListSettings = __experimentalGetBlockListSettingsForBlocks(blockParentsClientIds); 53136 53137 // Get the clientId of the topmost parent with the capture toolbars setting. 53138 const capturingClientId = blockParentsClientIds.find(parentClientId => parentBlockListSettings[parentClientId]?.__experimentalCaptureToolbars); 53139 let isInsertionPointVisible = false; 53140 if (isBlockInsertionPointVisible()) { 53141 const insertionPoint = getBlockInsertionPoint(); 53142 const order = getBlockOrder(insertionPoint.rootClientId); 53143 isInsertionPointVisible = order[insertionPoint.index] === clientId; 53144 } 53145 return { 53146 capturingClientId, 53147 isInsertionPointVisible, 53148 lastClientId: hasMultiSelection() ? getLastMultiSelectedBlockClientId() : null, 53149 rootClientId: getBlockRootClientId(clientId) 53150 }; 53151 }, [clientId]); 53152 return selectedBlockProps; 53153 } 53154 53155 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/empty-block-inserter.js 53156 /** 53157 * External dependencies 53158 */ 53159 53160 53161 /** 53162 * Internal dependencies 53163 */ 53164 53165 53166 53167 53168 53169 function EmptyBlockInserter({ 53170 clientId, 53171 __unstableContentRef 53172 }) { 53173 const { 53174 capturingClientId, 53175 isInsertionPointVisible, 53176 lastClientId, 53177 rootClientId 53178 } = useSelectedBlockToolProps(clientId); 53179 const popoverProps = useBlockToolbarPopoverProps({ 53180 contentElement: __unstableContentRef?.current, 53181 clientId 53182 }); 53183 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, { 53184 clientId: capturingClientId || clientId, 53185 bottomClientId: lastClientId, 53186 className: dist_clsx('block-editor-block-list__block-side-inserter-popover', { 53187 'is-insertion-point-visible': isInsertionPointVisible 53188 }), 53189 __unstableContentRef: __unstableContentRef, 53190 ...popoverProps, 53191 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 53192 className: "block-editor-block-list__empty-block-inserter", 53193 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, { 53194 position: "bottom right", 53195 rootClientId: rootClientId, 53196 clientId: clientId, 53197 __experimentalIsQuick: true 53198 }) 53199 }) 53200 }); 53201 } 53202 53203 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-draggable/use-scroll-when-dragging.js 53204 /** 53205 * WordPress dependencies 53206 */ 53207 53208 53209 const SCROLL_INACTIVE_DISTANCE_PX = 50; 53210 const SCROLL_INTERVAL_MS = 25; 53211 const PIXELS_PER_SECOND_PER_PERCENTAGE = 1000; 53212 const VELOCITY_MULTIPLIER = PIXELS_PER_SECOND_PER_PERCENTAGE * (SCROLL_INTERVAL_MS / 1000); 53213 53214 /** 53215 * React hook that scrolls the scroll container when a block is being dragged. 53216 * 53217 * @return {Function[]} `startScrolling`, `scrollOnDragOver`, `stopScrolling` 53218 * functions to be called in `onDragStart`, `onDragOver` 53219 * and `onDragEnd` events respectively. 53220 */ 53221 function useScrollWhenDragging() { 53222 const dragStartYRef = (0,external_wp_element_namespaceObject.useRef)(null); 53223 const velocityYRef = (0,external_wp_element_namespaceObject.useRef)(null); 53224 const scrollParentYRef = (0,external_wp_element_namespaceObject.useRef)(null); 53225 const scrollEditorIntervalRef = (0,external_wp_element_namespaceObject.useRef)(null); 53226 53227 // Clear interval when unmounting. 53228 (0,external_wp_element_namespaceObject.useEffect)(() => () => { 53229 if (scrollEditorIntervalRef.current) { 53230 clearInterval(scrollEditorIntervalRef.current); 53231 scrollEditorIntervalRef.current = null; 53232 } 53233 }, []); 53234 const startScrolling = (0,external_wp_element_namespaceObject.useCallback)(event => { 53235 dragStartYRef.current = event.clientY; 53236 53237 // Find nearest parent(s) to scroll. 53238 scrollParentYRef.current = (0,external_wp_dom_namespaceObject.getScrollContainer)(event.target); 53239 scrollEditorIntervalRef.current = setInterval(() => { 53240 if (scrollParentYRef.current && velocityYRef.current) { 53241 const newTop = scrollParentYRef.current.scrollTop + velocityYRef.current; 53242 53243 // Setting `behavior: 'smooth'` as a scroll property seems to hurt performance. 53244 // Better to use a small scroll interval. 53245 scrollParentYRef.current.scroll({ 53246 top: newTop 53247 }); 53248 } 53249 }, SCROLL_INTERVAL_MS); 53250 }, []); 53251 const scrollOnDragOver = (0,external_wp_element_namespaceObject.useCallback)(event => { 53252 if (!scrollParentYRef.current) { 53253 return; 53254 } 53255 const scrollParentHeight = scrollParentYRef.current.offsetHeight; 53256 const offsetDragStartPosition = dragStartYRef.current - scrollParentYRef.current.offsetTop; 53257 const offsetDragPosition = event.clientY - scrollParentYRef.current.offsetTop; 53258 if (event.clientY > offsetDragStartPosition) { 53259 // User is dragging downwards. 53260 const moveableDistance = Math.max(scrollParentHeight - offsetDragStartPosition - SCROLL_INACTIVE_DISTANCE_PX, 0); 53261 const dragDistance = Math.max(offsetDragPosition - offsetDragStartPosition - SCROLL_INACTIVE_DISTANCE_PX, 0); 53262 const distancePercentage = moveableDistance === 0 || dragDistance === 0 ? 0 : dragDistance / moveableDistance; 53263 velocityYRef.current = VELOCITY_MULTIPLIER * distancePercentage; 53264 } else if (event.clientY < offsetDragStartPosition) { 53265 // User is dragging upwards. 53266 const moveableDistance = Math.max(offsetDragStartPosition - SCROLL_INACTIVE_DISTANCE_PX, 0); 53267 const dragDistance = Math.max(offsetDragStartPosition - offsetDragPosition - SCROLL_INACTIVE_DISTANCE_PX, 0); 53268 const distancePercentage = moveableDistance === 0 || dragDistance === 0 ? 0 : dragDistance / moveableDistance; 53269 velocityYRef.current = -VELOCITY_MULTIPLIER * distancePercentage; 53270 } else { 53271 velocityYRef.current = 0; 53272 } 53273 }, []); 53274 const stopScrolling = () => { 53275 dragStartYRef.current = null; 53276 scrollParentYRef.current = null; 53277 if (scrollEditorIntervalRef.current) { 53278 clearInterval(scrollEditorIntervalRef.current); 53279 scrollEditorIntervalRef.current = null; 53280 } 53281 }; 53282 return [startScrolling, scrollOnDragOver, stopScrolling]; 53283 } 53284 53285 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-draggable/index.js 53286 /** 53287 * WordPress dependencies 53288 */ 53289 53290 53291 53292 53293 53294 53295 /** 53296 * Internal dependencies 53297 */ 53298 53299 53300 53301 53302 53303 53304 const BlockDraggable = ({ 53305 appendToOwnerDocument, 53306 children, 53307 clientIds, 53308 cloneClassname, 53309 elementId, 53310 onDragStart, 53311 onDragEnd, 53312 fadeWhenDisabled = false, 53313 dragComponent 53314 }) => { 53315 const { 53316 srcRootClientId, 53317 isDraggable, 53318 icon, 53319 visibleInserter, 53320 getBlockType 53321 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 53322 const { 53323 canMoveBlocks, 53324 getBlockRootClientId, 53325 getBlockName, 53326 getBlockAttributes, 53327 isBlockInsertionPointVisible 53328 } = select(store); 53329 const { 53330 getBlockType: _getBlockType, 53331 getActiveBlockVariation 53332 } = select(external_wp_blocks_namespaceObject.store); 53333 const rootClientId = getBlockRootClientId(clientIds[0]); 53334 const blockName = getBlockName(clientIds[0]); 53335 const variation = getActiveBlockVariation(blockName, getBlockAttributes(clientIds[0])); 53336 return { 53337 srcRootClientId: rootClientId, 53338 isDraggable: canMoveBlocks(clientIds), 53339 icon: variation?.icon || _getBlockType(blockName)?.icon, 53340 visibleInserter: isBlockInsertionPointVisible(), 53341 getBlockType: _getBlockType 53342 }; 53343 }, [clientIds]); 53344 const isDraggingRef = (0,external_wp_element_namespaceObject.useRef)(false); 53345 const [startScrolling, scrollOnDragOver, stopScrolling] = useScrollWhenDragging(); 53346 const { 53347 getAllowedBlocks, 53348 getBlockNamesByClientId, 53349 getBlockRootClientId 53350 } = (0,external_wp_data_namespaceObject.useSelect)(store); 53351 const { 53352 startDraggingBlocks, 53353 stopDraggingBlocks 53354 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 53355 53356 // Stop dragging blocks if the block draggable is unmounted. 53357 (0,external_wp_element_namespaceObject.useEffect)(() => { 53358 return () => { 53359 if (isDraggingRef.current) { 53360 stopDraggingBlocks(); 53361 } 53362 }; 53363 }, []); 53364 53365 // Find the root of the editor iframe. 53366 const blockEl = useBlockElement(clientIds[0]); 53367 const editorRoot = blockEl?.closest('body'); 53368 53369 /* 53370 * Add a dragover event listener to the editor root to track the blocks being dragged over. 53371 * The listener has to be inside the editor iframe otherwise the target isn't accessible. 53372 */ 53373 (0,external_wp_element_namespaceObject.useEffect)(() => { 53374 if (!editorRoot || !fadeWhenDisabled) { 53375 return; 53376 } 53377 const onDragOver = event => { 53378 if (!event.target.closest('[data-block]')) { 53379 return; 53380 } 53381 const draggedBlockNames = getBlockNamesByClientId(clientIds); 53382 const targetClientId = event.target.closest('[data-block]').getAttribute('data-block'); 53383 const allowedBlocks = getAllowedBlocks(targetClientId); 53384 const targetBlockName = getBlockNamesByClientId([targetClientId])[0]; 53385 53386 /* 53387 * Check if the target is valid to drop in. 53388 * If the target's allowedBlocks is an empty array, 53389 * it isn't a container block, in which case we check 53390 * its parent's validity instead. 53391 */ 53392 let dropTargetValid; 53393 if (allowedBlocks?.length === 0) { 53394 const targetRootClientId = getBlockRootClientId(targetClientId); 53395 const targetRootBlockName = getBlockNamesByClientId([targetRootClientId])[0]; 53396 const rootAllowedBlocks = getAllowedBlocks(targetRootClientId); 53397 dropTargetValid = isDropTargetValid(getBlockType, rootAllowedBlocks, draggedBlockNames, targetRootBlockName); 53398 } else { 53399 dropTargetValid = isDropTargetValid(getBlockType, allowedBlocks, draggedBlockNames, targetBlockName); 53400 } 53401 53402 /* 53403 * Update the body class to reflect if drop target is valid. 53404 * This has to be done on the document body because the draggable 53405 * chip is rendered outside of the editor iframe. 53406 */ 53407 if (!dropTargetValid && !visibleInserter) { 53408 window?.document?.body?.classList?.add('block-draggable-invalid-drag-token'); 53409 } else { 53410 window?.document?.body?.classList?.remove('block-draggable-invalid-drag-token'); 53411 } 53412 }; 53413 const throttledOnDragOver = (0,external_wp_compose_namespaceObject.throttle)(onDragOver, 200); 53414 editorRoot.addEventListener('dragover', throttledOnDragOver); 53415 return () => { 53416 editorRoot.removeEventListener('dragover', throttledOnDragOver); 53417 }; 53418 }, [clientIds, editorRoot, fadeWhenDisabled, getAllowedBlocks, getBlockNamesByClientId, getBlockRootClientId, getBlockType, visibleInserter]); 53419 if (!isDraggable) { 53420 return children({ 53421 draggable: false 53422 }); 53423 } 53424 const transferData = { 53425 type: 'block', 53426 srcClientIds: clientIds, 53427 srcRootClientId 53428 }; 53429 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Draggable, { 53430 appendToOwnerDocument: appendToOwnerDocument, 53431 cloneClassname: cloneClassname, 53432 __experimentalTransferDataType: "wp-blocks", 53433 transferData: transferData, 53434 onDragStart: event => { 53435 // Defer hiding the dragged source element to the next 53436 // frame to enable dragging. 53437 window.requestAnimationFrame(() => { 53438 startDraggingBlocks(clientIds); 53439 isDraggingRef.current = true; 53440 startScrolling(event); 53441 if (onDragStart) { 53442 onDragStart(); 53443 } 53444 }); 53445 }, 53446 onDragOver: scrollOnDragOver, 53447 onDragEnd: () => { 53448 stopDraggingBlocks(); 53449 isDraggingRef.current = false; 53450 stopScrolling(); 53451 if (onDragEnd) { 53452 onDragEnd(); 53453 } 53454 }, 53455 __experimentalDragComponent: 53456 // Check against `undefined` so that `null` can be used to disable 53457 // the default drag component. 53458 dragComponent !== undefined ? dragComponent : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockDraggableChip, { 53459 count: clientIds.length, 53460 icon: icon, 53461 fadeWhenDisabled: true 53462 }), 53463 elementId: elementId, 53464 children: ({ 53465 onDraggableStart, 53466 onDraggableEnd 53467 }) => { 53468 return children({ 53469 draggable: true, 53470 onDragStart: onDraggableStart, 53471 onDragEnd: onDraggableEnd 53472 }); 53473 } 53474 }); 53475 }; 53476 /* harmony default export */ const block_draggable = (BlockDraggable); 53477 53478 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-mover/mover-description.js 53479 /** 53480 * WordPress dependencies 53481 */ 53482 53483 const getMovementDirection = (moveDirection, orientation) => { 53484 if (moveDirection === 'up') { 53485 if (orientation === 'horizontal') { 53486 return (0,external_wp_i18n_namespaceObject.isRTL)() ? 'right' : 'left'; 53487 } 53488 return 'up'; 53489 } else if (moveDirection === 'down') { 53490 if (orientation === 'horizontal') { 53491 return (0,external_wp_i18n_namespaceObject.isRTL)() ? 'left' : 'right'; 53492 } 53493 return 'down'; 53494 } 53495 return null; 53496 }; 53497 53498 /** 53499 * Return a label for the block movement controls depending on block position. 53500 * 53501 * @param {number} selectedCount Number of blocks selected. 53502 * @param {string} type Block type - in the case of a single block, should 53503 * define its 'type'. I.e. 'Text', 'Heading', 'Image' etc. 53504 * @param {number} firstIndex The index (position - 1) of the first block selected. 53505 * @param {boolean} isFirst This is the first block. 53506 * @param {boolean} isLast This is the last block. 53507 * @param {number} dir Direction of movement (> 0 is considered to be going 53508 * down, < 0 is up). 53509 * @param {string} orientation The orientation of the block movers, vertical or 53510 * horizontal. 53511 * 53512 * @return {string | undefined} Label for the block movement controls. 53513 */ 53514 function getBlockMoverDescription(selectedCount, type, firstIndex, isFirst, isLast, dir, orientation) { 53515 const position = firstIndex + 1; 53516 if (selectedCount > 1) { 53517 return getMultiBlockMoverDescription(selectedCount, firstIndex, isFirst, isLast, dir, orientation); 53518 } 53519 if (isFirst && isLast) { 53520 return (0,external_wp_i18n_namespaceObject.sprintf)( 53521 // translators: %s: Type of block (i.e. Text, Image etc) 53522 (0,external_wp_i18n_namespaceObject.__)('Block %s is the only block, and cannot be moved'), type); 53523 } 53524 if (dir > 0 && !isLast) { 53525 // Moving down. 53526 const movementDirection = getMovementDirection('down', orientation); 53527 if (movementDirection === 'down') { 53528 return (0,external_wp_i18n_namespaceObject.sprintf)( 53529 // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position 53530 (0,external_wp_i18n_namespaceObject.__)('Move %1$s block from position %2$d down to position %3$d'), type, position, position + 1); 53531 } 53532 if (movementDirection === 'left') { 53533 return (0,external_wp_i18n_namespaceObject.sprintf)( 53534 // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position 53535 (0,external_wp_i18n_namespaceObject.__)('Move %1$s block from position %2$d left to position %3$d'), type, position, position + 1); 53536 } 53537 if (movementDirection === 'right') { 53538 return (0,external_wp_i18n_namespaceObject.sprintf)( 53539 // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position 53540 (0,external_wp_i18n_namespaceObject.__)('Move %1$s block from position %2$d right to position %3$d'), type, position, position + 1); 53541 } 53542 } 53543 if (dir > 0 && isLast) { 53544 // Moving down, and is the last item. 53545 const movementDirection = getMovementDirection('down', orientation); 53546 if (movementDirection === 'down') { 53547 return (0,external_wp_i18n_namespaceObject.sprintf)( 53548 // translators: 1: Type of block (i.e. Text, Image etc) 53549 (0,external_wp_i18n_namespaceObject.__)('Block %1$s is at the end of the content and can’t be moved down'), type); 53550 } 53551 if (movementDirection === 'left') { 53552 return (0,external_wp_i18n_namespaceObject.sprintf)( 53553 // translators: 1: Type of block (i.e. Text, Image etc) 53554 (0,external_wp_i18n_namespaceObject.__)('Block %1$s is at the end of the content and can’t be moved left'), type); 53555 } 53556 if (movementDirection === 'right') { 53557 return (0,external_wp_i18n_namespaceObject.sprintf)( 53558 // translators: 1: Type of block (i.e. Text, Image etc) 53559 (0,external_wp_i18n_namespaceObject.__)('Block %1$s is at the end of the content and can’t be moved right'), type); 53560 } 53561 } 53562 if (dir < 0 && !isFirst) { 53563 // Moving up. 53564 const movementDirection = getMovementDirection('up', orientation); 53565 if (movementDirection === 'up') { 53566 return (0,external_wp_i18n_namespaceObject.sprintf)( 53567 // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position 53568 (0,external_wp_i18n_namespaceObject.__)('Move %1$s block from position %2$d up to position %3$d'), type, position, position - 1); 53569 } 53570 if (movementDirection === 'left') { 53571 return (0,external_wp_i18n_namespaceObject.sprintf)( 53572 // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position 53573 (0,external_wp_i18n_namespaceObject.__)('Move %1$s block from position %2$d left to position %3$d'), type, position, position - 1); 53574 } 53575 if (movementDirection === 'right') { 53576 return (0,external_wp_i18n_namespaceObject.sprintf)( 53577 // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position 53578 (0,external_wp_i18n_namespaceObject.__)('Move %1$s block from position %2$d right to position %3$d'), type, position, position - 1); 53579 } 53580 } 53581 if (dir < 0 && isFirst) { 53582 // Moving up, and is the first item. 53583 const movementDirection = getMovementDirection('up', orientation); 53584 if (movementDirection === 'up') { 53585 return (0,external_wp_i18n_namespaceObject.sprintf)( 53586 // translators: 1: Type of block (i.e. Text, Image etc) 53587 (0,external_wp_i18n_namespaceObject.__)('Block %1$s is at the beginning of the content and can’t be moved up'), type); 53588 } 53589 if (movementDirection === 'left') { 53590 return (0,external_wp_i18n_namespaceObject.sprintf)( 53591 // translators: 1: Type of block (i.e. Text, Image etc) 53592 (0,external_wp_i18n_namespaceObject.__)('Block %1$s is at the beginning of the content and can’t be moved left'), type); 53593 } 53594 if (movementDirection === 'right') { 53595 return (0,external_wp_i18n_namespaceObject.sprintf)( 53596 // translators: 1: Type of block (i.e. Text, Image etc) 53597 (0,external_wp_i18n_namespaceObject.__)('Block %1$s is at the beginning of the content and can’t be moved right'), type); 53598 } 53599 } 53600 } 53601 53602 /** 53603 * Return a label for the block movement controls depending on block position. 53604 * 53605 * @param {number} selectedCount Number of blocks selected. 53606 * @param {number} firstIndex The index (position - 1) of the first block selected. 53607 * @param {boolean} isFirst This is the first block. 53608 * @param {boolean} isLast This is the last block. 53609 * @param {number} dir Direction of movement (> 0 is considered to be going 53610 * down, < 0 is up). 53611 * @param {string} orientation The orientation of the block movers, vertical or 53612 * horizontal. 53613 * 53614 * @return {string | undefined} Label for the block movement controls. 53615 */ 53616 function getMultiBlockMoverDescription(selectedCount, firstIndex, isFirst, isLast, dir, orientation) { 53617 const position = firstIndex + 1; 53618 if (isFirst && isLast) { 53619 // All blocks are selected 53620 return (0,external_wp_i18n_namespaceObject.__)('All blocks are selected, and cannot be moved'); 53621 } 53622 if (dir > 0 && !isLast) { 53623 // moving down 53624 const movementDirection = getMovementDirection('down', orientation); 53625 if (movementDirection === 'down') { 53626 return (0,external_wp_i18n_namespaceObject.sprintf)( 53627 // translators: 1: Number of selected blocks, 2: Position of selected blocks 53628 (0,external_wp_i18n_namespaceObject.__)('Move %1$d blocks from position %2$d down by one place'), selectedCount, position); 53629 } 53630 if (movementDirection === 'left') { 53631 return (0,external_wp_i18n_namespaceObject.sprintf)( 53632 // translators: 1: Number of selected blocks, 2: Position of selected blocks 53633 (0,external_wp_i18n_namespaceObject.__)('Move %1$d blocks from position %2$d left by one place'), selectedCount, position); 53634 } 53635 if (movementDirection === 'right') { 53636 return (0,external_wp_i18n_namespaceObject.sprintf)( 53637 // translators: 1: Number of selected blocks, 2: Position of selected blocks 53638 (0,external_wp_i18n_namespaceObject.__)('Move %1$d blocks from position %2$d right by one place'), selectedCount, position); 53639 } 53640 } 53641 if (dir > 0 && isLast) { 53642 // moving down, and the selected blocks are the last item 53643 const movementDirection = getMovementDirection('down', orientation); 53644 if (movementDirection === 'down') { 53645 return (0,external_wp_i18n_namespaceObject.__)('Blocks cannot be moved down as they are already at the bottom'); 53646 } 53647 if (movementDirection === 'left') { 53648 return (0,external_wp_i18n_namespaceObject.__)('Blocks cannot be moved left as they are already are at the leftmost position'); 53649 } 53650 if (movementDirection === 'right') { 53651 return (0,external_wp_i18n_namespaceObject.__)('Blocks cannot be moved right as they are already are at the rightmost position'); 53652 } 53653 } 53654 if (dir < 0 && !isFirst) { 53655 // moving up 53656 const movementDirection = getMovementDirection('up', orientation); 53657 if (movementDirection === 'up') { 53658 return (0,external_wp_i18n_namespaceObject.sprintf)( 53659 // translators: 1: Number of selected blocks, 2: Position of selected blocks 53660 (0,external_wp_i18n_namespaceObject.__)('Move %1$d blocks from position %2$d up by one place'), selectedCount, position); 53661 } 53662 if (movementDirection === 'left') { 53663 return (0,external_wp_i18n_namespaceObject.sprintf)( 53664 // translators: 1: Number of selected blocks, 2: Position of selected blocks 53665 (0,external_wp_i18n_namespaceObject.__)('Move %1$d blocks from position %2$d left by one place'), selectedCount, position); 53666 } 53667 if (movementDirection === 'right') { 53668 return (0,external_wp_i18n_namespaceObject.sprintf)( 53669 // translators: 1: Number of selected blocks, 2: Position of selected blocks 53670 (0,external_wp_i18n_namespaceObject.__)('Move %1$d blocks from position %2$d right by one place'), selectedCount, position); 53671 } 53672 } 53673 if (dir < 0 && isFirst) { 53674 // moving up, and the selected blocks are the first item 53675 const movementDirection = getMovementDirection('up', orientation); 53676 if (movementDirection === 'up') { 53677 return (0,external_wp_i18n_namespaceObject.__)('Blocks cannot be moved up as they are already at the top'); 53678 } 53679 if (movementDirection === 'left') { 53680 return (0,external_wp_i18n_namespaceObject.__)('Blocks cannot be moved left as they are already are at the leftmost position'); 53681 } 53682 if (movementDirection === 'right') { 53683 return (0,external_wp_i18n_namespaceObject.__)('Blocks cannot be moved right as they are already are at the rightmost position'); 53684 } 53685 } 53686 } 53687 53688 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-mover/button.js 53689 /** 53690 * External dependencies 53691 */ 53692 53693 53694 /** 53695 * WordPress dependencies 53696 */ 53697 53698 53699 53700 53701 53702 53703 53704 /** 53705 * Internal dependencies 53706 */ 53707 53708 53709 53710 53711 53712 53713 const getArrowIcon = (direction, orientation) => { 53714 if (direction === 'up') { 53715 if (orientation === 'horizontal') { 53716 return (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left; 53717 } 53718 return chevron_up; 53719 } else if (direction === 'down') { 53720 if (orientation === 'horizontal') { 53721 return (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right; 53722 } 53723 return chevron_down; 53724 } 53725 return null; 53726 }; 53727 const getMovementDirectionLabel = (moveDirection, orientation) => { 53728 if (moveDirection === 'up') { 53729 if (orientation === 'horizontal') { 53730 return (0,external_wp_i18n_namespaceObject.isRTL)() ? (0,external_wp_i18n_namespaceObject.__)('Move right') : (0,external_wp_i18n_namespaceObject.__)('Move left'); 53731 } 53732 return (0,external_wp_i18n_namespaceObject.__)('Move up'); 53733 } else if (moveDirection === 'down') { 53734 if (orientation === 'horizontal') { 53735 return (0,external_wp_i18n_namespaceObject.isRTL)() ? (0,external_wp_i18n_namespaceObject.__)('Move left') : (0,external_wp_i18n_namespaceObject.__)('Move right'); 53736 } 53737 return (0,external_wp_i18n_namespaceObject.__)('Move down'); 53738 } 53739 return null; 53740 }; 53741 const BlockMoverButton = (0,external_wp_element_namespaceObject.forwardRef)(({ 53742 clientIds, 53743 direction, 53744 orientation: moverOrientation, 53745 ...props 53746 }, ref) => { 53747 const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockMoverButton); 53748 const normalizedClientIds = Array.isArray(clientIds) ? clientIds : [clientIds]; 53749 const blocksCount = normalizedClientIds.length; 53750 const { 53751 disabled 53752 } = props; 53753 const { 53754 blockType, 53755 isDisabled, 53756 rootClientId, 53757 isFirst, 53758 isLast, 53759 firstIndex, 53760 orientation = 'vertical' 53761 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 53762 const { 53763 getBlockIndex, 53764 getBlockRootClientId, 53765 getBlockOrder, 53766 getBlock, 53767 getBlockListSettings 53768 } = select(store); 53769 const firstClientId = normalizedClientIds[0]; 53770 const blockRootClientId = getBlockRootClientId(firstClientId); 53771 const firstBlockIndex = getBlockIndex(firstClientId); 53772 const lastBlockIndex = getBlockIndex(normalizedClientIds[normalizedClientIds.length - 1]); 53773 const blockOrder = getBlockOrder(blockRootClientId); 53774 const block = getBlock(firstClientId); 53775 const isFirstBlock = firstBlockIndex === 0; 53776 const isLastBlock = lastBlockIndex === blockOrder.length - 1; 53777 const { 53778 orientation: blockListOrientation 53779 } = getBlockListSettings(blockRootClientId) || {}; 53780 return { 53781 blockType: block ? (0,external_wp_blocks_namespaceObject.getBlockType)(block.name) : null, 53782 isDisabled: disabled || (direction === 'up' ? isFirstBlock : isLastBlock), 53783 rootClientId: blockRootClientId, 53784 firstIndex: firstBlockIndex, 53785 isFirst: isFirstBlock, 53786 isLast: isLastBlock, 53787 orientation: moverOrientation || blockListOrientation 53788 }; 53789 }, [clientIds, direction]); 53790 const { 53791 moveBlocksDown, 53792 moveBlocksUp 53793 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 53794 const moverFunction = direction === 'up' ? moveBlocksUp : moveBlocksDown; 53795 const onClick = event => { 53796 moverFunction(clientIds, rootClientId); 53797 if (props.onClick) { 53798 props.onClick(event); 53799 } 53800 }; 53801 const descriptionId = `block-editor-block-mover-button__description-$instanceId}`; 53802 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 53803 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 53804 __next40pxDefaultSize: true, 53805 ref: ref, 53806 className: dist_clsx('block-editor-block-mover-button', `is-$direction}-button`), 53807 icon: getArrowIcon(direction, orientation), 53808 label: getMovementDirectionLabel(direction, orientation), 53809 "aria-describedby": descriptionId, 53810 ...props, 53811 onClick: isDisabled ? null : onClick, 53812 disabled: isDisabled, 53813 accessibleWhenDisabled: true 53814 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 53815 id: descriptionId, 53816 children: getBlockMoverDescription(blocksCount, blockType && blockType.title, firstIndex, isFirst, isLast, direction === 'up' ? -1 : 1, orientation) 53817 })] 53818 }); 53819 }); 53820 const BlockMoverUpButton = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => { 53821 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverButton, { 53822 direction: "up", 53823 ref: ref, 53824 ...props 53825 }); 53826 }); 53827 const BlockMoverDownButton = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => { 53828 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverButton, { 53829 direction: "down", 53830 ref: ref, 53831 ...props 53832 }); 53833 }); 53834 53835 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-mover/index.js 53836 /** 53837 * External dependencies 53838 */ 53839 53840 53841 /** 53842 * WordPress dependencies 53843 */ 53844 53845 53846 53847 53848 53849 53850 /** 53851 * Internal dependencies 53852 */ 53853 53854 53855 53856 53857 53858 function BlockMover({ 53859 clientIds, 53860 hideDragHandle, 53861 isBlockMoverUpButtonDisabled, 53862 isBlockMoverDownButtonDisabled 53863 }) { 53864 const { 53865 canMove, 53866 rootClientId, 53867 isFirst, 53868 isLast, 53869 orientation, 53870 isManualGrid 53871 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 53872 var _getBlockAttributes; 53873 const { 53874 getBlockIndex, 53875 getBlockListSettings, 53876 canMoveBlocks, 53877 getBlockOrder, 53878 getBlockRootClientId, 53879 getBlockAttributes 53880 } = select(store); 53881 const normalizedClientIds = Array.isArray(clientIds) ? clientIds : [clientIds]; 53882 const firstClientId = normalizedClientIds[0]; 53883 const _rootClientId = getBlockRootClientId(firstClientId); 53884 const firstIndex = getBlockIndex(firstClientId); 53885 const lastIndex = getBlockIndex(normalizedClientIds[normalizedClientIds.length - 1]); 53886 const blockOrder = getBlockOrder(_rootClientId); 53887 const { 53888 layout = {} 53889 } = (_getBlockAttributes = getBlockAttributes(_rootClientId)) !== null && _getBlockAttributes !== void 0 ? _getBlockAttributes : {}; 53890 return { 53891 canMove: canMoveBlocks(clientIds), 53892 rootClientId: _rootClientId, 53893 isFirst: firstIndex === 0, 53894 isLast: lastIndex === blockOrder.length - 1, 53895 orientation: getBlockListSettings(_rootClientId)?.orientation, 53896 isManualGrid: layout.type === 'grid' && layout.isManualPlacement && window.__experimentalEnableGridInteractivity 53897 }; 53898 }, [clientIds]); 53899 if (!canMove || isFirst && isLast && !rootClientId || hideDragHandle && isManualGrid) { 53900 return null; 53901 } 53902 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, { 53903 className: dist_clsx('block-editor-block-mover', { 53904 'is-horizontal': orientation === 'horizontal' 53905 }), 53906 children: [!hideDragHandle && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_draggable, { 53907 clientIds: clientIds, 53908 fadeWhenDisabled: true, 53909 children: draggableProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 53910 __next40pxDefaultSize: true, 53911 icon: drag_handle, 53912 className: "block-editor-block-mover__drag-handle", 53913 label: (0,external_wp_i18n_namespaceObject.__)('Drag') 53914 // Should not be able to tab to drag handle as this 53915 // button can only be used with a pointer device. 53916 , 53917 tabIndex: "-1", 53918 ...draggableProps 53919 }) 53920 }), !isManualGrid && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 53921 className: "block-editor-block-mover__move-button-container", 53922 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, { 53923 children: itemProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverUpButton, { 53924 disabled: isBlockMoverUpButtonDisabled, 53925 clientIds: clientIds, 53926 ...itemProps 53927 }) 53928 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, { 53929 children: itemProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverDownButton, { 53930 disabled: isBlockMoverDownButtonDisabled, 53931 clientIds: clientIds, 53932 ...itemProps 53933 }) 53934 })] 53935 })] 53936 }); 53937 } 53938 53939 /** 53940 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-mover/README.md 53941 */ 53942 /* harmony default export */ const block_mover = (BlockMover); 53943 53944 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/utils.js 53945 /** 53946 * WordPress dependencies 53947 */ 53948 53949 53950 53951 /** 53952 * Internal dependencies 53953 */ 53954 53955 const { 53956 clearTimeout: utils_clearTimeout, 53957 setTimeout: utils_setTimeout 53958 } = window; 53959 const DEBOUNCE_TIMEOUT = 200; 53960 53961 /** 53962 * Hook that creates debounced callbacks when the node is hovered or focused. 53963 * 53964 * @param {Object} props Component props. 53965 * @param {Object} props.ref Element reference. 53966 * @param {boolean} props.isFocused Whether the component has current focus. 53967 * @param {number} props.highlightParent Whether to highlight the parent block. It defaults in highlighting the selected block. 53968 * @param {number} [props.debounceTimeout=250] Debounce timeout in milliseconds. 53969 */ 53970 function useDebouncedShowGestures({ 53971 ref, 53972 isFocused, 53973 highlightParent, 53974 debounceTimeout = DEBOUNCE_TIMEOUT 53975 }) { 53976 const { 53977 getSelectedBlockClientId, 53978 getBlockRootClientId 53979 } = (0,external_wp_data_namespaceObject.useSelect)(store); 53980 const { 53981 toggleBlockHighlight 53982 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 53983 const timeoutRef = (0,external_wp_element_namespaceObject.useRef)(); 53984 const isDistractionFree = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSettings().isDistractionFree, []); 53985 const handleOnChange = nextIsFocused => { 53986 if (nextIsFocused && isDistractionFree) { 53987 return; 53988 } 53989 const selectedBlockClientId = getSelectedBlockClientId(); 53990 const clientId = highlightParent ? getBlockRootClientId(selectedBlockClientId) : selectedBlockClientId; 53991 toggleBlockHighlight(clientId, nextIsFocused); 53992 }; 53993 const getIsHovered = () => { 53994 return ref?.current && ref.current.matches(':hover'); 53995 }; 53996 const shouldHideGestures = () => { 53997 const isHovered = getIsHovered(); 53998 return !isFocused && !isHovered; 53999 }; 54000 const clearTimeoutRef = () => { 54001 const timeout = timeoutRef.current; 54002 if (timeout && utils_clearTimeout) { 54003 utils_clearTimeout(timeout); 54004 } 54005 }; 54006 const debouncedShowGestures = event => { 54007 if (event) { 54008 event.stopPropagation(); 54009 } 54010 clearTimeoutRef(); 54011 handleOnChange(true); 54012 }; 54013 const debouncedHideGestures = event => { 54014 if (event) { 54015 event.stopPropagation(); 54016 } 54017 clearTimeoutRef(); 54018 timeoutRef.current = utils_setTimeout(() => { 54019 if (shouldHideGestures()) { 54020 handleOnChange(false); 54021 } 54022 }, debounceTimeout); 54023 }; 54024 (0,external_wp_element_namespaceObject.useEffect)(() => () => { 54025 /** 54026 * We need to call the change handler with `isFocused` 54027 * set to false on unmount because we also clear the 54028 * timeout that would handle that. 54029 */ 54030 handleOnChange(false); 54031 clearTimeoutRef(); 54032 }, []); 54033 return { 54034 debouncedShowGestures, 54035 debouncedHideGestures 54036 }; 54037 } 54038 54039 /** 54040 * Hook that provides gesture events for DOM elements 54041 * that interact with the isFocused state. 54042 * 54043 * @param {Object} props Component props. 54044 * @param {Object} props.ref Element reference. 54045 * @param {number} [props.highlightParent=false] Whether to highlight the parent block. It defaults to highlighting the selected block. 54046 * @param {number} [props.debounceTimeout=250] Debounce timeout in milliseconds. 54047 */ 54048 function useShowHoveredOrFocusedGestures({ 54049 ref, 54050 highlightParent = false, 54051 debounceTimeout = DEBOUNCE_TIMEOUT 54052 }) { 54053 const [isFocused, setIsFocused] = (0,external_wp_element_namespaceObject.useState)(false); 54054 const { 54055 debouncedShowGestures, 54056 debouncedHideGestures 54057 } = useDebouncedShowGestures({ 54058 ref, 54059 debounceTimeout, 54060 isFocused, 54061 highlightParent 54062 }); 54063 const registerRef = (0,external_wp_element_namespaceObject.useRef)(false); 54064 const isFocusedWithin = () => { 54065 return ref?.current && ref.current.contains(ref.current.ownerDocument.activeElement); 54066 }; 54067 (0,external_wp_element_namespaceObject.useEffect)(() => { 54068 const node = ref.current; 54069 const handleOnFocus = () => { 54070 if (isFocusedWithin()) { 54071 setIsFocused(true); 54072 debouncedShowGestures(); 54073 } 54074 }; 54075 const handleOnBlur = () => { 54076 if (!isFocusedWithin()) { 54077 setIsFocused(false); 54078 debouncedHideGestures(); 54079 } 54080 }; 54081 54082 /** 54083 * Events are added via DOM events (vs. React synthetic events), 54084 * as the child React components swallow mouse events. 54085 */ 54086 if (node && !registerRef.current) { 54087 node.addEventListener('focus', handleOnFocus, true); 54088 node.addEventListener('blur', handleOnBlur, true); 54089 registerRef.current = true; 54090 } 54091 return () => { 54092 if (node) { 54093 node.removeEventListener('focus', handleOnFocus); 54094 node.removeEventListener('blur', handleOnBlur); 54095 } 54096 }; 54097 }, [ref, registerRef, setIsFocused, debouncedShowGestures, debouncedHideGestures]); 54098 return { 54099 onMouseMove: debouncedShowGestures, 54100 onMouseLeave: debouncedHideGestures 54101 }; 54102 } 54103 54104 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-parent-selector/index.js 54105 /** 54106 * WordPress dependencies 54107 */ 54108 54109 54110 54111 54112 54113 54114 /** 54115 * Internal dependencies 54116 */ 54117 54118 54119 54120 54121 54122 /** 54123 * Block parent selector component, displaying the hierarchy of the 54124 * current block selection as a single icon to "go up" a level. 54125 * 54126 * @return {Component} Parent block selector. 54127 */ 54128 54129 function BlockParentSelector() { 54130 const { 54131 selectBlock 54132 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 54133 const { 54134 firstParentClientId, 54135 isVisible 54136 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 54137 const { 54138 getBlockName, 54139 getBlockParents, 54140 getSelectedBlockClientId, 54141 getBlockEditingMode 54142 } = select(store); 54143 const { 54144 hasBlockSupport 54145 } = select(external_wp_blocks_namespaceObject.store); 54146 const selectedBlockClientId = getSelectedBlockClientId(); 54147 const parents = getBlockParents(selectedBlockClientId); 54148 const _firstParentClientId = parents[parents.length - 1]; 54149 const parentBlockName = getBlockName(_firstParentClientId); 54150 const _parentBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(parentBlockName); 54151 return { 54152 firstParentClientId: _firstParentClientId, 54153 isVisible: _firstParentClientId && getBlockEditingMode(_firstParentClientId) === 'default' && hasBlockSupport(_parentBlockType, '__experimentalParentSelector', true) 54154 }; 54155 }, []); 54156 const blockInformation = useBlockDisplayInformation(firstParentClientId); 54157 54158 // Allows highlighting the parent block outline when focusing or hovering 54159 // the parent block selector within the child. 54160 const nodeRef = (0,external_wp_element_namespaceObject.useRef)(); 54161 const showHoveredOrFocusedGestures = useShowHoveredOrFocusedGestures({ 54162 ref: nodeRef, 54163 highlightParent: true 54164 }); 54165 if (!isVisible) { 54166 return null; 54167 } 54168 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 54169 className: "block-editor-block-parent-selector", 54170 ref: nodeRef, 54171 ...showHoveredOrFocusedGestures, 54172 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 54173 className: "block-editor-block-parent-selector__button", 54174 onClick: () => selectBlock(firstParentClientId), 54175 label: (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: Name of the block's parent. */ 54176 (0,external_wp_i18n_namespaceObject.__)('Select parent block: %s'), blockInformation?.title), 54177 showTooltip: true, 54178 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 54179 icon: blockInformation?.icon 54180 }) 54181 }) 54182 }, firstParentClientId); 54183 } 54184 54185 ;// ./node_modules/@wordpress/icons/build-module/library/copy.js 54186 /** 54187 * WordPress dependencies 54188 */ 54189 54190 54191 const copy_copy = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 54192 xmlns: "http://www.w3.org/2000/svg", 54193 viewBox: "0 0 24 24", 54194 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 54195 fillRule: "evenodd", 54196 clipRule: "evenodd", 54197 d: "M5 4.5h11a.5.5 0 0 1 .5.5v11a.5.5 0 0 1-.5.5H5a.5.5 0 0 1-.5-.5V5a.5.5 0 0 1 .5-.5ZM3 5a2 2 0 0 1 2-2h11a2 2 0 0 1 2 2v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5Zm17 3v10.75c0 .69-.56 1.25-1.25 1.25H6v1.5h12.75a2.75 2.75 0 0 0 2.75-2.75V8H20Z" 54198 }) 54199 }); 54200 /* harmony default export */ const library_copy = (copy_copy); 54201 54202 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/preview-block-popover.js 54203 /** 54204 * WordPress dependencies 54205 */ 54206 54207 54208 54209 54210 /** 54211 * Internal dependencies 54212 */ 54213 54214 54215 54216 function PreviewBlockPopover({ 54217 blocks 54218 }) { 54219 const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<'); 54220 if (isMobile) { 54221 return null; 54222 } 54223 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 54224 className: "block-editor-block-switcher__popover-preview-container", 54225 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, { 54226 className: "block-editor-block-switcher__popover-preview", 54227 placement: "right-start", 54228 focusOnMount: false, 54229 offset: 16, 54230 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 54231 className: "block-editor-block-switcher__preview", 54232 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 54233 className: "block-editor-block-switcher__preview-title", 54234 children: (0,external_wp_i18n_namespaceObject.__)('Preview') 54235 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, { 54236 viewportWidth: 500, 54237 blocks: blocks 54238 })] 54239 }) 54240 }) 54241 }); 54242 } 54243 54244 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/block-variation-transformations.js 54245 /** 54246 * WordPress dependencies 54247 */ 54248 54249 54250 54251 54252 54253 /** 54254 * Internal dependencies 54255 */ 54256 54257 54258 54259 54260 54261 54262 const block_variation_transformations_EMPTY_OBJECT = {}; 54263 function useBlockVariationTransforms({ 54264 clientIds, 54265 blocks 54266 }) { 54267 const { 54268 activeBlockVariation, 54269 blockVariationTransformations 54270 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 54271 const { 54272 getBlockAttributes, 54273 canRemoveBlocks 54274 } = select(store); 54275 const { 54276 getActiveBlockVariation, 54277 getBlockVariations 54278 } = select(external_wp_blocks_namespaceObject.store); 54279 const canRemove = canRemoveBlocks(clientIds); 54280 // Only handle single selected blocks for now. 54281 if (blocks.length !== 1 || !canRemove) { 54282 return block_variation_transformations_EMPTY_OBJECT; 54283 } 54284 const [firstBlock] = blocks; 54285 return { 54286 blockVariationTransformations: getBlockVariations(firstBlock.name, 'transform'), 54287 activeBlockVariation: getActiveBlockVariation(firstBlock.name, getBlockAttributes(firstBlock.clientId)) 54288 }; 54289 }, [clientIds, blocks]); 54290 const transformations = (0,external_wp_element_namespaceObject.useMemo)(() => { 54291 return blockVariationTransformations?.filter(({ 54292 name 54293 }) => name !== activeBlockVariation?.name); 54294 }, [blockVariationTransformations, activeBlockVariation]); 54295 return transformations; 54296 } 54297 const BlockVariationTransformations = ({ 54298 transformations, 54299 onSelect, 54300 blocks 54301 }) => { 54302 const [hoveredTransformItemName, setHoveredTransformItemName] = (0,external_wp_element_namespaceObject.useState)(); 54303 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 54304 children: [hoveredTransformItemName && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewBlockPopover, { 54305 blocks: (0,external_wp_blocks_namespaceObject.cloneBlock)(blocks[0], transformations.find(({ 54306 name 54307 }) => name === hoveredTransformItemName).attributes) 54308 }), transformations?.map(item => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockVariationTranformationItem, { 54309 item: item, 54310 onSelect: onSelect, 54311 setHoveredTransformItemName: setHoveredTransformItemName 54312 }, item.name))] 54313 }); 54314 }; 54315 function BlockVariationTranformationItem({ 54316 item, 54317 onSelect, 54318 setHoveredTransformItemName 54319 }) { 54320 const { 54321 name, 54322 icon, 54323 title 54324 } = item; 54325 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuItem, { 54326 className: (0,external_wp_blocks_namespaceObject.getBlockMenuDefaultClassName)(name), 54327 onClick: event => { 54328 event.preventDefault(); 54329 onSelect(name); 54330 }, 54331 onMouseLeave: () => setHoveredTransformItemName(null), 54332 onMouseEnter: () => setHoveredTransformItemName(name), 54333 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 54334 icon: icon, 54335 showColors: true 54336 }), title] 54337 }); 54338 } 54339 /* harmony default export */ const block_variation_transformations = (BlockVariationTransformations); 54340 54341 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/block-transformations-menu.js 54342 /** 54343 * WordPress dependencies 54344 */ 54345 54346 54347 54348 54349 54350 /** 54351 * Internal dependencies 54352 */ 54353 54354 54355 54356 54357 /** 54358 * Helper hook to group transformations to display them in a specific order in the UI. 54359 * For now we group only priority content driven transformations(ex. paragraph -> heading). 54360 * 54361 * Later on we could also group 'layout' transformations(ex. paragraph -> group) and 54362 * display them in different sections. 54363 * 54364 * @param {Object[]} possibleBlockTransformations The available block transformations. 54365 * @return {Record<string, Object[]>} The grouped block transformations. 54366 */ 54367 54368 54369 54370 function useGroupedTransforms(possibleBlockTransformations) { 54371 const priorityContentTranformationBlocks = { 54372 'core/paragraph': 1, 54373 'core/heading': 2, 54374 'core/list': 3, 54375 'core/quote': 4 54376 }; 54377 const transformations = (0,external_wp_element_namespaceObject.useMemo)(() => { 54378 const priorityTextTranformsNames = Object.keys(priorityContentTranformationBlocks); 54379 const groupedPossibleTransforms = possibleBlockTransformations.reduce((accumulator, item) => { 54380 const { 54381 name 54382 } = item; 54383 if (priorityTextTranformsNames.includes(name)) { 54384 accumulator.priorityTextTransformations.push(item); 54385 } else { 54386 accumulator.restTransformations.push(item); 54387 } 54388 return accumulator; 54389 }, { 54390 priorityTextTransformations: [], 54391 restTransformations: [] 54392 }); 54393 /** 54394 * If there is only one priority text transformation and it's a Quote, 54395 * is should move to the rest transformations. This is because Quote can 54396 * be a container for any block type, so in multi-block selection it will 54397 * always be suggested, even for non-text blocks. 54398 */ 54399 if (groupedPossibleTransforms.priorityTextTransformations.length === 1 && groupedPossibleTransforms.priorityTextTransformations[0].name === 'core/quote') { 54400 const singleQuote = groupedPossibleTransforms.priorityTextTransformations.pop(); 54401 groupedPossibleTransforms.restTransformations.push(singleQuote); 54402 } 54403 return groupedPossibleTransforms; 54404 }, [possibleBlockTransformations]); 54405 54406 // Order the priority text transformations. 54407 transformations.priorityTextTransformations.sort(({ 54408 name: currentName 54409 }, { 54410 name: nextName 54411 }) => { 54412 return priorityContentTranformationBlocks[currentName] < priorityContentTranformationBlocks[nextName] ? -1 : 1; 54413 }); 54414 return transformations; 54415 } 54416 const BlockTransformationsMenu = ({ 54417 className, 54418 possibleBlockTransformations, 54419 possibleBlockVariationTransformations, 54420 onSelect, 54421 onSelectVariation, 54422 blocks 54423 }) => { 54424 const [hoveredTransformItemName, setHoveredTransformItemName] = (0,external_wp_element_namespaceObject.useState)(); 54425 const { 54426 priorityTextTransformations, 54427 restTransformations 54428 } = useGroupedTransforms(possibleBlockTransformations); 54429 // We have to check if both content transformations(priority and rest) are set 54430 // in order to create a separate MenuGroup for them. 54431 const hasBothContentTransformations = priorityTextTransformations.length && restTransformations.length; 54432 const restTransformItems = !!restTransformations.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RestTransformationItems, { 54433 restTransformations: restTransformations, 54434 onSelect: onSelect, 54435 setHoveredTransformItemName: setHoveredTransformItemName 54436 }); 54437 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 54438 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, { 54439 label: (0,external_wp_i18n_namespaceObject.__)('Transform to'), 54440 className: className, 54441 children: [hoveredTransformItemName && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewBlockPopover, { 54442 blocks: (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, hoveredTransformItemName) 54443 }), !!possibleBlockVariationTransformations?.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_variation_transformations, { 54444 transformations: possibleBlockVariationTransformations, 54445 blocks: blocks, 54446 onSelect: onSelectVariation 54447 }), priorityTextTransformations.map(item => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTranformationItem, { 54448 item: item, 54449 onSelect: onSelect, 54450 setHoveredTransformItemName: setHoveredTransformItemName 54451 }, item.name)), !hasBothContentTransformations && restTransformItems] 54452 }), !!hasBothContentTransformations && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, { 54453 className: className, 54454 children: restTransformItems 54455 })] 54456 }); 54457 }; 54458 function RestTransformationItems({ 54459 restTransformations, 54460 onSelect, 54461 setHoveredTransformItemName 54462 }) { 54463 return restTransformations.map(item => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTranformationItem, { 54464 item: item, 54465 onSelect: onSelect, 54466 setHoveredTransformItemName: setHoveredTransformItemName 54467 }, item.name)); 54468 } 54469 function BlockTranformationItem({ 54470 item, 54471 onSelect, 54472 setHoveredTransformItemName 54473 }) { 54474 const { 54475 name, 54476 icon, 54477 title, 54478 isDisabled 54479 } = item; 54480 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuItem, { 54481 className: (0,external_wp_blocks_namespaceObject.getBlockMenuDefaultClassName)(name), 54482 onClick: event => { 54483 event.preventDefault(); 54484 onSelect(name); 54485 }, 54486 disabled: isDisabled, 54487 onMouseLeave: () => setHoveredTransformItemName(null), 54488 onMouseEnter: () => setHoveredTransformItemName(name), 54489 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 54490 icon: icon, 54491 showColors: true 54492 }), title] 54493 }); 54494 } 54495 /* harmony default export */ const block_transformations_menu = (BlockTransformationsMenu); 54496 54497 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/utils.js 54498 /** 54499 * WordPress dependencies 54500 */ 54501 54502 54503 54504 /** 54505 * Returns the active style from the given className. 54506 * 54507 * @param {Array} styles Block styles. 54508 * @param {string} className Class name 54509 * 54510 * @return {Object?} The active style. 54511 */ 54512 function getActiveStyle(styles, className) { 54513 for (const style of new (external_wp_tokenList_default())(className).values()) { 54514 if (style.indexOf('is-style-') === -1) { 54515 continue; 54516 } 54517 const potentialStyleName = style.substring(9); 54518 const activeStyle = styles?.find(({ 54519 name 54520 }) => name === potentialStyleName); 54521 if (activeStyle) { 54522 return activeStyle; 54523 } 54524 } 54525 return getDefaultStyle(styles); 54526 } 54527 54528 /** 54529 * Replaces the active style in the block's className. 54530 * 54531 * @param {string} className Class name. 54532 * @param {Object?} activeStyle The replaced style. 54533 * @param {Object} newStyle The replacing style. 54534 * 54535 * @return {string} The updated className. 54536 */ 54537 function replaceActiveStyle(className, activeStyle, newStyle) { 54538 const list = new (external_wp_tokenList_default())(className); 54539 if (activeStyle) { 54540 list.remove('is-style-' + activeStyle.name); 54541 } 54542 list.add('is-style-' + newStyle.name); 54543 return list.value; 54544 } 54545 54546 /** 54547 * Returns a collection of styles that can be represented on the frontend. 54548 * The function checks a style collection for a default style. If none is found, it adds one to 54549 * act as a fallback for when there is no active style applied to a block. The default item also serves 54550 * as a switch on the frontend to deactivate non-default styles. 54551 * 54552 * @param {Array} styles Block styles. 54553 * 54554 * @return {Array<Object?>} The style collection. 54555 */ 54556 function getRenderedStyles(styles) { 54557 if (!styles || styles.length === 0) { 54558 return []; 54559 } 54560 return getDefaultStyle(styles) ? styles : [{ 54561 name: 'default', 54562 label: (0,external_wp_i18n_namespaceObject._x)('Default', 'block style'), 54563 isDefault: true 54564 }, ...styles]; 54565 } 54566 54567 /** 54568 * Returns a style object from a collection of styles where that style object is the default block style. 54569 * 54570 * @param {Array} styles Block styles. 54571 * 54572 * @return {Object?} The default style object, if found. 54573 */ 54574 function getDefaultStyle(styles) { 54575 return styles?.find(style => style.isDefault); 54576 } 54577 54578 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/use-styles-for-block.js 54579 /** 54580 * WordPress dependencies 54581 */ 54582 54583 54584 54585 54586 /** 54587 * Internal dependencies 54588 */ 54589 54590 54591 54592 /** 54593 * 54594 * @param {WPBlock} block Block object. 54595 * @param {WPBlockType} type Block type settings. 54596 * @return {WPBlock} A generic block ready for styles preview. 54597 */ 54598 function useGenericPreviewBlock(block, type) { 54599 return (0,external_wp_element_namespaceObject.useMemo)(() => { 54600 const example = type?.example; 54601 const blockName = type?.name; 54602 if (example && blockName) { 54603 return (0,external_wp_blocks_namespaceObject.getBlockFromExample)(blockName, { 54604 attributes: example.attributes, 54605 innerBlocks: example.innerBlocks 54606 }); 54607 } 54608 if (block) { 54609 return (0,external_wp_blocks_namespaceObject.cloneBlock)(block); 54610 } 54611 }, [type?.example ? block?.name : block, type]); 54612 } 54613 54614 /** 54615 * @typedef useStylesForBlocksArguments 54616 * @property {string} clientId Block client ID. 54617 * @property {() => void} onSwitch Block style switch callback function. 54618 */ 54619 54620 /** 54621 * 54622 * @param {useStylesForBlocksArguments} useStylesForBlocks arguments. 54623 * @return {Object} Results of the select methods. 54624 */ 54625 function useStylesForBlocks({ 54626 clientId, 54627 onSwitch 54628 }) { 54629 const selector = select => { 54630 const { 54631 getBlock 54632 } = select(store); 54633 const block = getBlock(clientId); 54634 if (!block) { 54635 return {}; 54636 } 54637 const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(block.name); 54638 const { 54639 getBlockStyles 54640 } = select(external_wp_blocks_namespaceObject.store); 54641 return { 54642 block, 54643 blockType, 54644 styles: getBlockStyles(block.name), 54645 className: block.attributes.className || '' 54646 }; 54647 }; 54648 const { 54649 styles, 54650 block, 54651 blockType, 54652 className 54653 } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId]); 54654 const { 54655 updateBlockAttributes 54656 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 54657 const stylesToRender = getRenderedStyles(styles); 54658 const activeStyle = getActiveStyle(stylesToRender, className); 54659 const genericPreviewBlock = useGenericPreviewBlock(block, blockType); 54660 const onSelect = style => { 54661 const styleClassName = replaceActiveStyle(className, activeStyle, style); 54662 updateBlockAttributes(clientId, { 54663 className: styleClassName 54664 }); 54665 onSwitch(); 54666 }; 54667 return { 54668 onSelect, 54669 stylesToRender, 54670 activeStyle, 54671 genericPreviewBlock, 54672 className 54673 }; 54674 } 54675 54676 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/menu-items.js 54677 /** 54678 * WordPress dependencies 54679 */ 54680 54681 54682 54683 /** 54684 * Internal dependencies 54685 */ 54686 54687 54688 54689 const menu_items_noop = () => {}; 54690 function BlockStylesMenuItems({ 54691 clientId, 54692 onSwitch = menu_items_noop 54693 }) { 54694 const { 54695 onSelect, 54696 stylesToRender, 54697 activeStyle 54698 } = useStylesForBlocks({ 54699 clientId, 54700 onSwitch 54701 }); 54702 if (!stylesToRender || stylesToRender.length === 0) { 54703 return null; 54704 } 54705 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 54706 children: stylesToRender.map(style => { 54707 const menuItemText = style.label || style.name; 54708 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 54709 icon: activeStyle.name === style.name ? library_check : null, 54710 onClick: () => onSelect(style), 54711 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, { 54712 as: "span", 54713 limit: 18, 54714 ellipsizeMode: "tail", 54715 truncate: true, 54716 children: menuItemText 54717 }) 54718 }, style.name); 54719 }) 54720 }); 54721 } 54722 54723 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/block-styles-menu.js 54724 /** 54725 * WordPress dependencies 54726 */ 54727 54728 54729 54730 /** 54731 * Internal dependencies 54732 */ 54733 54734 54735 function BlockStylesMenu({ 54736 hoveredBlock, 54737 onSwitch 54738 }) { 54739 const { 54740 clientId 54741 } = hoveredBlock; 54742 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, { 54743 label: (0,external_wp_i18n_namespaceObject.__)('Styles'), 54744 className: "block-editor-block-switcher__styles__menugroup", 54745 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesMenuItems, { 54746 clientId: clientId, 54747 onSwitch: onSwitch 54748 }) 54749 }); 54750 } 54751 54752 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/utils.js 54753 /** 54754 * WordPress dependencies 54755 */ 54756 54757 54758 /** 54759 * Try to find a matching block by a block's name in a provided 54760 * block. We recurse through InnerBlocks and return the reference 54761 * of the matched block (it could be an InnerBlock). 54762 * If no match is found return nothing. 54763 * 54764 * @param {WPBlock} block The block to try to find a match. 54765 * @param {string} selectedBlockName The block's name to use for matching condition. 54766 * @param {Set} consumedBlocks A set holding the previously matched/consumed blocks. 54767 * 54768 * @return {WPBlock | undefined} The matched block if found or nothing(`undefined`). 54769 */ 54770 const getMatchingBlockByName = (block, selectedBlockName, consumedBlocks = new Set()) => { 54771 const { 54772 clientId, 54773 name, 54774 innerBlocks = [] 54775 } = block; 54776 // Check if block has been consumed already. 54777 if (consumedBlocks.has(clientId)) { 54778 return; 54779 } 54780 if (name === selectedBlockName) { 54781 return block; 54782 } 54783 // Try to find a matching block from InnerBlocks recursively. 54784 for (const innerBlock of innerBlocks) { 54785 const match = getMatchingBlockByName(innerBlock, selectedBlockName, consumedBlocks); 54786 if (match) { 54787 return match; 54788 } 54789 } 54790 }; 54791 54792 /** 54793 * Find and return the block attributes to retain through 54794 * the transformation, based on Block Type's `role:content` 54795 * attributes. If no `role:content` attributes exist, 54796 * return selected block's attributes. 54797 * 54798 * @param {string} name Block type's namespaced name. 54799 * @param {Object} attributes Selected block's attributes. 54800 * @return {Object} The block's attributes to retain. 54801 */ 54802 const getRetainedBlockAttributes = (name, attributes) => { 54803 const contentAttributes = (0,external_wp_blocks_namespaceObject.getBlockAttributesNamesByRole)(name, 'content'); 54804 if (!contentAttributes?.length) { 54805 return attributes; 54806 } 54807 return contentAttributes.reduce((_accumulator, attribute) => { 54808 if (attributes[attribute]) { 54809 _accumulator[attribute] = attributes[attribute]; 54810 } 54811 return _accumulator; 54812 }, {}); 54813 }; 54814 54815 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/use-transformed-patterns.js 54816 /** 54817 * WordPress dependencies 54818 */ 54819 54820 54821 54822 /** 54823 * Internal dependencies 54824 */ 54825 54826 54827 /** 54828 * Mutate the matched block's attributes by getting 54829 * which block type's attributes to retain and prioritize 54830 * them in the merging of the attributes. 54831 * 54832 * @param {WPBlock} match The matched block. 54833 * @param {WPBlock} selectedBlock The selected block. 54834 * @return {void} 54835 */ 54836 const transformMatchingBlock = (match, selectedBlock) => { 54837 // Get the block attributes to retain through the transformation. 54838 const retainedBlockAttributes = getRetainedBlockAttributes(selectedBlock.name, selectedBlock.attributes); 54839 match.attributes = { 54840 ...match.attributes, 54841 ...retainedBlockAttributes 54842 }; 54843 }; 54844 54845 /** 54846 * By providing the selected blocks and pattern's blocks 54847 * find the matching blocks, transform them and return them. 54848 * If not all selected blocks are matched, return nothing. 54849 * 54850 * @param {WPBlock[]} selectedBlocks The selected blocks. 54851 * @param {WPBlock[]} patternBlocks The pattern's blocks. 54852 * @return {WPBlock[]|void} The transformed pattern's blocks or undefined if not all selected blocks have been matched. 54853 */ 54854 const getPatternTransformedBlocks = (selectedBlocks, patternBlocks) => { 54855 // Clone Pattern's blocks to produce new clientIds and be able to mutate the matches. 54856 const _patternBlocks = patternBlocks.map(block => (0,external_wp_blocks_namespaceObject.cloneBlock)(block)); 54857 /** 54858 * Keep track of the consumed pattern blocks. 54859 * This is needed because we loop the selected blocks 54860 * and for example we may have selected two paragraphs and 54861 * the pattern's blocks could have more `paragraphs`. 54862 */ 54863 const consumedBlocks = new Set(); 54864 for (const selectedBlock of selectedBlocks) { 54865 let isMatch = false; 54866 for (const patternBlock of _patternBlocks) { 54867 const match = getMatchingBlockByName(patternBlock, selectedBlock.name, consumedBlocks); 54868 if (!match) { 54869 continue; 54870 } 54871 isMatch = true; 54872 consumedBlocks.add(match.clientId); 54873 // We update (mutate) the matching pattern block. 54874 transformMatchingBlock(match, selectedBlock); 54875 // No need to loop through other pattern's blocks. 54876 break; 54877 } 54878 // Bail eary if a selected block has not been matched. 54879 if (!isMatch) { 54880 return; 54881 } 54882 } 54883 return _patternBlocks; 54884 }; 54885 54886 /** 54887 * @typedef {WPBlockPattern & {transformedBlocks: WPBlock[]}} TransformedBlockPattern 54888 */ 54889 54890 /** 54891 * Custom hook that accepts patterns from state and the selected 54892 * blocks and tries to match these with the pattern's blocks. 54893 * If all selected blocks are matched with a Pattern's block, 54894 * we transform them by retaining block's attributes with `role:content`. 54895 * The transformed pattern's blocks are set to a new pattern 54896 * property `transformedBlocks`. 54897 * 54898 * @param {WPBlockPattern[]} patterns Patterns from state. 54899 * @param {WPBlock[]} selectedBlocks The currently selected blocks. 54900 * @return {TransformedBlockPattern[]} Returns the eligible matched patterns with all the selected blocks. 54901 */ 54902 const useTransformedPatterns = (patterns, selectedBlocks) => { 54903 return (0,external_wp_element_namespaceObject.useMemo)(() => patterns.reduce((accumulator, _pattern) => { 54904 const transformedBlocks = getPatternTransformedBlocks(selectedBlocks, _pattern.blocks); 54905 if (transformedBlocks) { 54906 accumulator.push({ 54907 ..._pattern, 54908 transformedBlocks 54909 }); 54910 } 54911 return accumulator; 54912 }, []), [patterns, selectedBlocks]); 54913 }; 54914 /* harmony default export */ const use_transformed_patterns = (useTransformedPatterns); 54915 54916 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/pattern-transformations-menu.js 54917 /** 54918 * WordPress dependencies 54919 */ 54920 54921 54922 54923 54924 54925 54926 /** 54927 * Internal dependencies 54928 */ 54929 54930 54931 54932 54933 function PatternTransformationsMenu({ 54934 blocks, 54935 patterns: statePatterns, 54936 onSelect 54937 }) { 54938 const [showTransforms, setShowTransforms] = (0,external_wp_element_namespaceObject.useState)(false); 54939 const patterns = use_transformed_patterns(statePatterns, blocks); 54940 if (!patterns.length) { 54941 return null; 54942 } 54943 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, { 54944 className: "block-editor-block-switcher__pattern__transforms__menugroup", 54945 children: [showTransforms && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewPatternsPopover, { 54946 patterns: patterns, 54947 onSelect: onSelect 54948 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 54949 onClick: event => { 54950 event.preventDefault(); 54951 setShowTransforms(!showTransforms); 54952 }, 54953 icon: chevron_right, 54954 children: (0,external_wp_i18n_namespaceObject.__)('Patterns') 54955 })] 54956 }); 54957 } 54958 function PreviewPatternsPopover({ 54959 patterns, 54960 onSelect 54961 }) { 54962 const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<'); 54963 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 54964 className: "block-editor-block-switcher__popover-preview-container", 54965 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, { 54966 className: "block-editor-block-switcher__popover-preview", 54967 placement: isMobile ? 'bottom' : 'right-start', 54968 offset: 16, 54969 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 54970 className: "block-editor-block-switcher__preview is-pattern-list-preview", 54971 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_transformations_menu_BlockPatternsList, { 54972 patterns: patterns, 54973 onSelect: onSelect 54974 }) 54975 }) 54976 }) 54977 }); 54978 } 54979 function pattern_transformations_menu_BlockPatternsList({ 54980 patterns, 54981 onSelect 54982 }) { 54983 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, { 54984 role: "listbox", 54985 className: "block-editor-block-switcher__preview-patterns-container", 54986 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Patterns list'), 54987 children: patterns.map(pattern => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_transformations_menu_BlockPattern, { 54988 pattern: pattern, 54989 onSelect: onSelect 54990 }, pattern.name)) 54991 }); 54992 } 54993 function pattern_transformations_menu_BlockPattern({ 54994 pattern, 54995 onSelect 54996 }) { 54997 // TODO check pattern/preview width... 54998 const baseClassName = 'block-editor-block-switcher__preview-patterns-container'; 54999 const descriptionId = (0,external_wp_compose_namespaceObject.useInstanceId)(pattern_transformations_menu_BlockPattern, `$baseClassName}-list__item-description`); 55000 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 55001 className: `$baseClassName}-list__list-item`, 55002 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Composite.Item, { 55003 render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 55004 role: "option", 55005 "aria-label": pattern.title, 55006 "aria-describedby": pattern.description ? descriptionId : undefined, 55007 className: `$baseClassName}-list__item` 55008 }), 55009 onClick: () => onSelect(pattern.transformedBlocks), 55010 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, { 55011 blocks: pattern.transformedBlocks, 55012 viewportWidth: pattern.viewportWidth || 500 55013 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 55014 className: `$baseClassName}-list__item-title`, 55015 children: pattern.title 55016 })] 55017 }), !!pattern.description && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 55018 id: descriptionId, 55019 children: pattern.description 55020 })] 55021 }); 55022 } 55023 /* harmony default export */ const pattern_transformations_menu = (PatternTransformationsMenu); 55024 55025 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/index.js 55026 /** 55027 * WordPress dependencies 55028 */ 55029 55030 55031 55032 55033 55034 55035 /** 55036 * Internal dependencies 55037 */ 55038 55039 55040 55041 55042 55043 55044 55045 55046 55047 55048 function BlockSwitcherDropdownMenuContents({ 55049 onClose, 55050 clientIds, 55051 hasBlockStyles, 55052 canRemove, 55053 isUsingBindings 55054 }) { 55055 const { 55056 replaceBlocks, 55057 multiSelect, 55058 updateBlockAttributes 55059 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 55060 const { 55061 possibleBlockTransformations, 55062 patterns, 55063 blocks 55064 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 55065 const { 55066 getBlocksByClientId, 55067 getBlockRootClientId, 55068 getBlockTransformItems, 55069 __experimentalGetPatternTransformItems 55070 } = select(store); 55071 const rootClientId = getBlockRootClientId(Array.isArray(clientIds) ? clientIds[0] : clientIds); 55072 const _blocks = getBlocksByClientId(clientIds); 55073 return { 55074 blocks: _blocks, 55075 possibleBlockTransformations: getBlockTransformItems(_blocks, rootClientId), 55076 patterns: __experimentalGetPatternTransformItems(_blocks, rootClientId) 55077 }; 55078 }, [clientIds]); 55079 const blockVariationTransformations = useBlockVariationTransforms({ 55080 clientIds, 55081 blocks 55082 }); 55083 function selectForMultipleBlocks(insertedBlocks) { 55084 if (insertedBlocks.length > 1) { 55085 multiSelect(insertedBlocks[0].clientId, insertedBlocks[insertedBlocks.length - 1].clientId); 55086 } 55087 } 55088 // Simple block tranformation based on the `Block Transforms` API. 55089 function onBlockTransform(name) { 55090 const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, name); 55091 replaceBlocks(clientIds, newBlocks); 55092 selectForMultipleBlocks(newBlocks); 55093 } 55094 function onBlockVariationTransform(name) { 55095 updateBlockAttributes(blocks[0].clientId, { 55096 ...blockVariationTransformations.find(({ 55097 name: variationName 55098 }) => variationName === name).attributes 55099 }); 55100 } 55101 // Pattern transformation through the `Patterns` API. 55102 function onPatternTransform(transformedBlocks) { 55103 replaceBlocks(clientIds, transformedBlocks); 55104 selectForMultipleBlocks(transformedBlocks); 55105 } 55106 /** 55107 * The `isTemplate` check is a stopgap solution here. 55108 * Ideally, the Transforms API should handle this 55109 * by allowing to exclude blocks from wildcard transformations. 55110 */ 55111 const isSingleBlock = blocks.length === 1; 55112 const isTemplate = isSingleBlock && (0,external_wp_blocks_namespaceObject.isTemplatePart)(blocks[0]); 55113 const hasPossibleBlockTransformations = !!possibleBlockTransformations.length && canRemove && !isTemplate; 55114 const hasPossibleBlockVariationTransformations = !!blockVariationTransformations?.length; 55115 const hasPatternTransformation = !!patterns?.length && canRemove; 55116 const hasBlockOrBlockVariationTransforms = hasPossibleBlockTransformations || hasPossibleBlockVariationTransformations; 55117 const hasContents = hasBlockStyles || hasBlockOrBlockVariationTransforms || hasPatternTransformation; 55118 if (!hasContents) { 55119 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 55120 className: "block-editor-block-switcher__no-transforms", 55121 children: (0,external_wp_i18n_namespaceObject.__)('No transforms.') 55122 }); 55123 } 55124 const connectedBlockDescription = isSingleBlock ? (0,external_wp_i18n_namespaceObject._x)('This block is connected.', 'block toolbar button label and description') : (0,external_wp_i18n_namespaceObject._x)('These blocks are connected.', 'block toolbar button label and description'); 55125 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 55126 className: "block-editor-block-switcher__container", 55127 children: [hasPatternTransformation && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_transformations_menu, { 55128 blocks: blocks, 55129 patterns: patterns, 55130 onSelect: transformedBlocks => { 55131 onPatternTransform(transformedBlocks); 55132 onClose(); 55133 } 55134 }), hasBlockOrBlockVariationTransforms && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_transformations_menu, { 55135 className: "block-editor-block-switcher__transforms__menugroup", 55136 possibleBlockTransformations: possibleBlockTransformations, 55137 possibleBlockVariationTransformations: blockVariationTransformations, 55138 blocks: blocks, 55139 onSelect: name => { 55140 onBlockTransform(name); 55141 onClose(); 55142 }, 55143 onSelectVariation: name => { 55144 onBlockVariationTransform(name); 55145 onClose(); 55146 } 55147 }), hasBlockStyles && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesMenu, { 55148 hoveredBlock: blocks[0], 55149 onSwitch: onClose 55150 }), isUsingBindings && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, { 55151 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, { 55152 className: "block-editor-block-switcher__binding-indicator", 55153 children: connectedBlockDescription 55154 }) 55155 })] 55156 }); 55157 } 55158 const BlockIndicator = ({ 55159 icon, 55160 showTitle, 55161 blockTitle 55162 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 55163 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 55164 className: "block-editor-block-switcher__toggle", 55165 icon: icon, 55166 showColors: true 55167 }), showTitle && blockTitle && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 55168 className: "block-editor-block-switcher__toggle-text", 55169 children: blockTitle 55170 })] 55171 }); 55172 const BlockSwitcher = ({ 55173 clientIds, 55174 disabled, 55175 isUsingBindings 55176 }) => { 55177 const { 55178 hasContentOnlyLocking, 55179 canRemove, 55180 hasBlockStyles, 55181 icon, 55182 invalidBlocks, 55183 isReusable, 55184 isTemplate 55185 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 55186 const { 55187 getTemplateLock, 55188 getBlocksByClientId, 55189 getBlockAttributes, 55190 canRemoveBlocks 55191 } = select(store); 55192 const { 55193 getBlockStyles, 55194 getBlockType, 55195 getActiveBlockVariation 55196 } = select(external_wp_blocks_namespaceObject.store); 55197 const _blocks = getBlocksByClientId(clientIds); 55198 if (!_blocks.length || _blocks.some(block => !block)) { 55199 return { 55200 invalidBlocks: true 55201 }; 55202 } 55203 const [{ 55204 name: firstBlockName 55205 }] = _blocks; 55206 const _isSingleBlockSelected = _blocks.length === 1; 55207 const blockType = getBlockType(firstBlockName); 55208 let _icon; 55209 let _hasTemplateLock; 55210 if (_isSingleBlockSelected) { 55211 const match = getActiveBlockVariation(firstBlockName, getBlockAttributes(clientIds[0])); 55212 // Take into account active block variations. 55213 _icon = match?.icon || blockType.icon; 55214 _hasTemplateLock = getTemplateLock(clientIds[0]) === 'contentOnly'; 55215 } else { 55216 const isSelectionOfSameType = new Set(_blocks.map(({ 55217 name 55218 }) => name)).size === 1; 55219 _hasTemplateLock = clientIds.some(id => getTemplateLock(id) === 'contentOnly'); 55220 // When selection consists of blocks of multiple types, display an 55221 // appropriate icon to communicate the non-uniformity. 55222 _icon = isSelectionOfSameType ? blockType.icon : library_copy; 55223 } 55224 return { 55225 canRemove: canRemoveBlocks(clientIds), 55226 hasBlockStyles: _isSingleBlockSelected && !!getBlockStyles(firstBlockName)?.length, 55227 icon: _icon, 55228 isReusable: _isSingleBlockSelected && (0,external_wp_blocks_namespaceObject.isReusableBlock)(_blocks[0]), 55229 isTemplate: _isSingleBlockSelected && (0,external_wp_blocks_namespaceObject.isTemplatePart)(_blocks[0]), 55230 hasContentOnlyLocking: _hasTemplateLock 55231 }; 55232 }, [clientIds]); 55233 const blockTitle = useBlockDisplayTitle({ 55234 clientId: clientIds?.[0], 55235 maximumLength: 35 55236 }); 55237 if (invalidBlocks) { 55238 return null; 55239 } 55240 const isSingleBlock = clientIds.length === 1; 55241 const blockSwitcherLabel = isSingleBlock ? blockTitle : (0,external_wp_i18n_namespaceObject.__)('Multiple blocks selected'); 55242 const hideDropdown = disabled || !hasBlockStyles && !canRemove || hasContentOnlyLocking; 55243 if (hideDropdown) { 55244 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, { 55245 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 55246 disabled: true, 55247 className: "block-editor-block-switcher__no-switcher-icon", 55248 title: blockSwitcherLabel, 55249 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockIndicator, { 55250 icon: icon, 55251 showTitle: isReusable || isTemplate, 55252 blockTitle: blockTitle 55253 }) 55254 }) 55255 }); 55256 } 55257 const blockSwitcherDescription = isSingleBlock ? (0,external_wp_i18n_namespaceObject.__)('Change block type or style') : (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %d: number of blocks. */ 55258 (0,external_wp_i18n_namespaceObject._n)('Change type of %d block', 'Change type of %d blocks', clientIds.length), clientIds.length); 55259 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, { 55260 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, { 55261 children: toggleProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, { 55262 className: "block-editor-block-switcher", 55263 label: blockSwitcherLabel, 55264 popoverProps: { 55265 placement: 'bottom-start', 55266 className: 'block-editor-block-switcher__popover' 55267 }, 55268 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockIndicator, { 55269 icon: icon, 55270 showTitle: isReusable || isTemplate, 55271 blockTitle: blockTitle 55272 }), 55273 toggleProps: { 55274 description: blockSwitcherDescription, 55275 ...toggleProps 55276 }, 55277 menuProps: { 55278 orientation: 'both' 55279 }, 55280 children: ({ 55281 onClose 55282 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockSwitcherDropdownMenuContents, { 55283 onClose: onClose, 55284 clientIds: clientIds, 55285 hasBlockStyles: hasBlockStyles, 55286 canRemove: canRemove, 55287 isUsingBindings: isUsingBindings 55288 }) 55289 }) 55290 }) 55291 }); 55292 }; 55293 /* harmony default export */ const block_switcher = (BlockSwitcher); 55294 55295 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/block-toolbar-last-item.js 55296 /** 55297 * WordPress dependencies 55298 */ 55299 55300 const { 55301 Fill: __unstableBlockToolbarLastItem, 55302 Slot: block_toolbar_last_item_Slot 55303 } = (0,external_wp_components_namespaceObject.createSlotFill)('__unstableBlockToolbarLastItem'); 55304 __unstableBlockToolbarLastItem.Slot = block_toolbar_last_item_Slot; 55305 /* harmony default export */ const block_toolbar_last_item = (__unstableBlockToolbarLastItem); 55306 55307 ;// ./node_modules/@wordpress/block-editor/build-module/hooks/supports.js 55308 /** 55309 * WordPress dependencies 55310 */ 55311 55312 55313 const ALIGN_SUPPORT_KEY = 'align'; 55314 const ALIGN_WIDE_SUPPORT_KEY = 'alignWide'; 55315 const supports_BORDER_SUPPORT_KEY = '__experimentalBorder'; 55316 const supports_COLOR_SUPPORT_KEY = 'color'; 55317 const CUSTOM_CLASS_NAME_SUPPORT_KEY = 'customClassName'; 55318 const supports_FONT_FAMILY_SUPPORT_KEY = 'typography.__experimentalFontFamily'; 55319 const supports_FONT_SIZE_SUPPORT_KEY = 'typography.fontSize'; 55320 const supports_LINE_HEIGHT_SUPPORT_KEY = 'typography.lineHeight'; 55321 /** 55322 * Key within block settings' support array indicating support for font style. 55323 */ 55324 const supports_FONT_STYLE_SUPPORT_KEY = 'typography.__experimentalFontStyle'; 55325 /** 55326 * Key within block settings' support array indicating support for font weight. 55327 */ 55328 const supports_FONT_WEIGHT_SUPPORT_KEY = 'typography.__experimentalFontWeight'; 55329 /** 55330 * Key within block settings' supports array indicating support for text 55331 * align e.g. settings found in `block.json`. 55332 */ 55333 const supports_TEXT_ALIGN_SUPPORT_KEY = 'typography.textAlign'; 55334 /** 55335 * Key within block settings' supports array indicating support for text 55336 * columns e.g. settings found in `block.json`. 55337 */ 55338 const supports_TEXT_COLUMNS_SUPPORT_KEY = 'typography.textColumns'; 55339 /** 55340 * Key within block settings' supports array indicating support for text 55341 * decorations e.g. settings found in `block.json`. 55342 */ 55343 const supports_TEXT_DECORATION_SUPPORT_KEY = 'typography.__experimentalTextDecoration'; 55344 /** 55345 * Key within block settings' supports array indicating support for writing mode 55346 * e.g. settings found in `block.json`. 55347 */ 55348 const supports_WRITING_MODE_SUPPORT_KEY = 'typography.__experimentalWritingMode'; 55349 /** 55350 * Key within block settings' supports array indicating support for text 55351 * transforms e.g. settings found in `block.json`. 55352 */ 55353 const supports_TEXT_TRANSFORM_SUPPORT_KEY = 'typography.__experimentalTextTransform'; 55354 55355 /** 55356 * Key within block settings' supports array indicating support for letter-spacing 55357 * e.g. settings found in `block.json`. 55358 */ 55359 const supports_LETTER_SPACING_SUPPORT_KEY = 'typography.__experimentalLetterSpacing'; 55360 const LAYOUT_SUPPORT_KEY = 'layout'; 55361 const supports_TYPOGRAPHY_SUPPORT_KEYS = [supports_LINE_HEIGHT_SUPPORT_KEY, supports_FONT_SIZE_SUPPORT_KEY, supports_FONT_STYLE_SUPPORT_KEY, supports_FONT_WEIGHT_SUPPORT_KEY, supports_FONT_FAMILY_SUPPORT_KEY, supports_TEXT_ALIGN_SUPPORT_KEY, supports_TEXT_COLUMNS_SUPPORT_KEY, supports_TEXT_DECORATION_SUPPORT_KEY, supports_TEXT_TRANSFORM_SUPPORT_KEY, supports_WRITING_MODE_SUPPORT_KEY, supports_LETTER_SPACING_SUPPORT_KEY]; 55362 const EFFECTS_SUPPORT_KEYS = ['shadow']; 55363 const supports_SPACING_SUPPORT_KEY = 'spacing'; 55364 const supports_styleSupportKeys = [...EFFECTS_SUPPORT_KEYS, ...supports_TYPOGRAPHY_SUPPORT_KEYS, supports_BORDER_SUPPORT_KEY, supports_COLOR_SUPPORT_KEY, supports_SPACING_SUPPORT_KEY]; 55365 55366 /** 55367 * Returns true if the block defines support for align. 55368 * 55369 * @param {string|Object} nameOrType Block name or type object. 55370 * @return {boolean} Whether the block supports the feature. 55371 */ 55372 const hasAlignSupport = nameOrType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, ALIGN_SUPPORT_KEY); 55373 55374 /** 55375 * Returns the block support value for align, if defined. 55376 * 55377 * @param {string|Object} nameOrType Block name or type object. 55378 * @return {unknown} The block support value. 55379 */ 55380 const getAlignSupport = nameOrType => getBlockSupport(nameOrType, ALIGN_SUPPORT_KEY); 55381 55382 /** 55383 * Returns true if the block defines support for align wide. 55384 * 55385 * @param {string|Object} nameOrType Block name or type object. 55386 * @return {boolean} Whether the block supports the feature. 55387 */ 55388 const hasAlignWideSupport = nameOrType => hasBlockSupport(nameOrType, ALIGN_WIDE_SUPPORT_KEY); 55389 55390 /** 55391 * Returns the block support value for align wide, if defined. 55392 * 55393 * @param {string|Object} nameOrType Block name or type object. 55394 * @return {unknown} The block support value. 55395 */ 55396 const getAlignWideSupport = nameOrType => getBlockSupport(nameOrType, ALIGN_WIDE_SUPPORT_KEY); 55397 55398 /** 55399 * Determine whether there is block support for border properties. 55400 * 55401 * @param {string|Object} nameOrType Block name or type object. 55402 * @param {string} feature Border feature to check support for. 55403 * 55404 * @return {boolean} Whether there is support. 55405 */ 55406 function supports_hasBorderSupport(nameOrType, feature = 'any') { 55407 if (external_wp_element_namespaceObject.Platform.OS !== 'web') { 55408 return false; 55409 } 55410 const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(nameOrType, supports_BORDER_SUPPORT_KEY); 55411 if (support === true) { 55412 return true; 55413 } 55414 if (feature === 'any') { 55415 return !!(support?.color || support?.radius || support?.width || support?.style); 55416 } 55417 return !!support?.[feature]; 55418 } 55419 55420 /** 55421 * Get block support for border properties. 55422 * 55423 * @param {string|Object} nameOrType Block name or type object. 55424 * @param {string} feature Border feature to get. 55425 * 55426 * @return {unknown} The block support. 55427 */ 55428 const getBorderSupport = (nameOrType, feature) => getBlockSupport(nameOrType, [supports_BORDER_SUPPORT_KEY, feature]); 55429 55430 /** 55431 * Returns true if the block defines support for color. 55432 * 55433 * @param {string|Object} nameOrType Block name or type object. 55434 * @return {boolean} Whether the block supports the feature. 55435 */ 55436 const supports_hasColorSupport = nameOrType => { 55437 const colorSupport = getBlockSupport(nameOrType, supports_COLOR_SUPPORT_KEY); 55438 return colorSupport && (colorSupport.link === true || colorSupport.gradient === true || colorSupport.background !== false || colorSupport.text !== false); 55439 }; 55440 55441 /** 55442 * Returns true if the block defines support for link color. 55443 * 55444 * @param {string|Object} nameOrType Block name or type object. 55445 * @return {boolean} Whether the block supports the feature. 55446 */ 55447 const supports_hasLinkColorSupport = nameOrType => { 55448 if (Platform.OS !== 'web') { 55449 return false; 55450 } 55451 const colorSupport = getBlockSupport(nameOrType, supports_COLOR_SUPPORT_KEY); 55452 return colorSupport !== null && typeof colorSupport === 'object' && !!colorSupport.link; 55453 }; 55454 55455 /** 55456 * Returns true if the block defines support for gradient color. 55457 * 55458 * @param {string|Object} nameOrType Block name or type object. 55459 * @return {boolean} Whether the block supports the feature. 55460 */ 55461 const supports_hasGradientSupport = nameOrType => { 55462 const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(nameOrType, supports_COLOR_SUPPORT_KEY); 55463 return colorSupport !== null && typeof colorSupport === 'object' && !!colorSupport.gradients; 55464 }; 55465 55466 /** 55467 * Returns true if the block defines support for background color. 55468 * 55469 * @param {string|Object} nameOrType Block name or type object. 55470 * @return {boolean} Whether the block supports the feature. 55471 */ 55472 const supports_hasBackgroundColorSupport = nameOrType => { 55473 const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(nameOrType, supports_COLOR_SUPPORT_KEY); 55474 return colorSupport && colorSupport.background !== false; 55475 }; 55476 55477 /** 55478 * Returns true if the block defines support for text-align. 55479 * 55480 * @param {string|Object} nameOrType Block name or type object. 55481 * @return {boolean} Whether the block supports the feature. 55482 */ 55483 const hasTextAlignSupport = nameOrType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, supports_TEXT_ALIGN_SUPPORT_KEY); 55484 55485 /** 55486 * Returns the block support value for text-align, if defined. 55487 * 55488 * @param {string|Object} nameOrType Block name or type object. 55489 * @return {unknown} The block support value. 55490 */ 55491 const getTextAlignSupport = nameOrType => getBlockSupport(nameOrType, supports_TEXT_ALIGN_SUPPORT_KEY); 55492 55493 /** 55494 * Returns true if the block defines support for background color. 55495 * 55496 * @param {string|Object} nameOrType Block name or type object. 55497 * @return {boolean} Whether the block supports the feature. 55498 */ 55499 const supports_hasTextColorSupport = nameOrType => { 55500 const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(nameOrType, supports_COLOR_SUPPORT_KEY); 55501 return colorSupport && colorSupport.text !== false; 55502 }; 55503 55504 /** 55505 * Get block support for color properties. 55506 * 55507 * @param {string|Object} nameOrType Block name or type object. 55508 * @param {string} feature Color feature to get. 55509 * 55510 * @return {unknown} The block support. 55511 */ 55512 const getColorSupport = (nameOrType, feature) => getBlockSupport(nameOrType, [supports_COLOR_SUPPORT_KEY, feature]); 55513 55514 /** 55515 * Returns true if the block defines support for custom class name. 55516 * 55517 * @param {string|Object} nameOrType Block name or type object. 55518 * @return {boolean} Whether the block supports the feature. 55519 */ 55520 const hasCustomClassNameSupport = nameOrType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, CUSTOM_CLASS_NAME_SUPPORT_KEY, true); 55521 55522 /** 55523 * Returns the block support value for custom class name, if defined. 55524 * 55525 * @param {string|Object} nameOrType Block name or type object. 55526 * @return {unknown} The block support value. 55527 */ 55528 const getCustomClassNameSupport = nameOrType => getBlockSupport(nameOrType, CUSTOM_CLASS_NAME_SUPPORT_KEY, true); 55529 55530 /** 55531 * Returns true if the block defines support for font family. 55532 * 55533 * @param {string|Object} nameOrType Block name or type object. 55534 * @return {boolean} Whether the block supports the feature. 55535 */ 55536 const hasFontFamilySupport = nameOrType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, supports_FONT_FAMILY_SUPPORT_KEY); 55537 55538 /** 55539 * Returns the block support value for font family, if defined. 55540 * 55541 * @param {string|Object} nameOrType Block name or type object. 55542 * @return {unknown} The block support value. 55543 */ 55544 const getFontFamilySupport = nameOrType => getBlockSupport(nameOrType, supports_FONT_FAMILY_SUPPORT_KEY); 55545 55546 /** 55547 * Returns true if the block defines support for font size. 55548 * 55549 * @param {string|Object} nameOrType Block name or type object. 55550 * @return {boolean} Whether the block supports the feature. 55551 */ 55552 const hasFontSizeSupport = nameOrType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, supports_FONT_SIZE_SUPPORT_KEY); 55553 55554 /** 55555 * Returns the block support value for font size, if defined. 55556 * 55557 * @param {string|Object} nameOrType Block name or type object. 55558 * @return {unknown} The block support value. 55559 */ 55560 const getFontSizeSupport = nameOrType => getBlockSupport(nameOrType, supports_FONT_SIZE_SUPPORT_KEY); 55561 55562 /** 55563 * Returns true if the block defines support for layout. 55564 * 55565 * @param {string|Object} nameOrType Block name or type object. 55566 * @return {boolean} Whether the block supports the feature. 55567 */ 55568 const hasLayoutSupport = nameOrType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, LAYOUT_SUPPORT_KEY); 55569 55570 /** 55571 * Returns the block support value for layout, if defined. 55572 * 55573 * @param {string|Object} nameOrType Block name or type object. 55574 * @return {unknown} The block support value. 55575 */ 55576 const getLayoutSupport = nameOrType => getBlockSupport(nameOrType, LAYOUT_SUPPORT_KEY); 55577 55578 /** 55579 * Returns true if the block defines support for style. 55580 * 55581 * @param {string|Object} nameOrType Block name or type object. 55582 * @return {boolean} Whether the block supports the feature. 55583 */ 55584 const supports_hasStyleSupport = nameOrType => supports_styleSupportKeys.some(key => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, key)); 55585 55586 ;// ./node_modules/@wordpress/block-editor/build-module/components/use-paste-styles/index.js 55587 /** 55588 * WordPress dependencies 55589 */ 55590 55591 55592 55593 55594 55595 55596 /** 55597 * Internal dependencies 55598 */ 55599 55600 55601 55602 /** 55603 * Determine if the copied text looks like serialized blocks or not. 55604 * Since plain text will always get parsed into a freeform block, 55605 * we check that if the parsed blocks is anything other than that. 55606 * 55607 * @param {string} text The copied text. 55608 * @return {boolean} True if the text looks like serialized blocks, false otherwise. 55609 */ 55610 function hasSerializedBlocks(text) { 55611 try { 55612 const blocks = (0,external_wp_blocks_namespaceObject.parse)(text, { 55613 __unstableSkipMigrationLogs: true, 55614 __unstableSkipAutop: true 55615 }); 55616 if (blocks.length === 1 && blocks[0].name === 'core/freeform') { 55617 // It's likely that the text is just plain text and not serialized blocks. 55618 return false; 55619 } 55620 return true; 55621 } catch (err) { 55622 // Parsing error, the text is not serialized blocks. 55623 // (Even though that it technically won't happen) 55624 return false; 55625 } 55626 } 55627 55628 /** 55629 * Style attributes are attributes being added in `block-editor/src/hooks/*`. 55630 * (Except for some unrelated to style like `anchor` or `settings`.) 55631 * They generally represent the default block supports. 55632 */ 55633 const STYLE_ATTRIBUTES = { 55634 align: hasAlignSupport, 55635 borderColor: nameOrType => supports_hasBorderSupport(nameOrType, 'color'), 55636 backgroundColor: supports_hasBackgroundColorSupport, 55637 textAlign: hasTextAlignSupport, 55638 textColor: supports_hasTextColorSupport, 55639 gradient: supports_hasGradientSupport, 55640 className: hasCustomClassNameSupport, 55641 fontFamily: hasFontFamilySupport, 55642 fontSize: hasFontSizeSupport, 55643 layout: hasLayoutSupport, 55644 style: supports_hasStyleSupport 55645 }; 55646 55647 /** 55648 * Get the "style attributes" from a given block to a target block. 55649 * 55650 * @param {WPBlock} sourceBlock The source block. 55651 * @param {WPBlock} targetBlock The target block. 55652 * @return {Object} the filtered attributes object. 55653 */ 55654 function getStyleAttributes(sourceBlock, targetBlock) { 55655 return Object.entries(STYLE_ATTRIBUTES).reduce((attributes, [attributeKey, hasSupport]) => { 55656 // Only apply the attribute if both blocks support it. 55657 if (hasSupport(sourceBlock.name) && hasSupport(targetBlock.name)) { 55658 // Override attributes that are not present in the block to their defaults. 55659 attributes[attributeKey] = sourceBlock.attributes[attributeKey]; 55660 } 55661 return attributes; 55662 }, {}); 55663 } 55664 55665 /** 55666 * Update the target blocks with style attributes recursively. 55667 * 55668 * @param {WPBlock[]} targetBlocks The target blocks to be updated. 55669 * @param {WPBlock[]} sourceBlocks The source blocks to get th style attributes from. 55670 * @param {Function} updateBlockAttributes The function to update the attributes. 55671 */ 55672 function recursivelyUpdateBlockAttributes(targetBlocks, sourceBlocks, updateBlockAttributes) { 55673 for (let index = 0; index < Math.min(sourceBlocks.length, targetBlocks.length); index += 1) { 55674 updateBlockAttributes(targetBlocks[index].clientId, getStyleAttributes(sourceBlocks[index], targetBlocks[index])); 55675 recursivelyUpdateBlockAttributes(targetBlocks[index].innerBlocks, sourceBlocks[index].innerBlocks, updateBlockAttributes); 55676 } 55677 } 55678 55679 /** 55680 * A hook to return a pasteStyles event function for handling pasting styles to blocks. 55681 * 55682 * @return {Function} A function to update the styles to the blocks. 55683 */ 55684 function usePasteStyles() { 55685 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 55686 const { 55687 updateBlockAttributes 55688 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 55689 const { 55690 createSuccessNotice, 55691 createWarningNotice, 55692 createErrorNotice 55693 } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store); 55694 return (0,external_wp_element_namespaceObject.useCallback)(async targetBlocks => { 55695 let html = ''; 55696 try { 55697 // `http:` sites won't have the clipboard property on navigator. 55698 // (with the exception of localhost.) 55699 if (!window.navigator.clipboard) { 55700 createErrorNotice((0,external_wp_i18n_namespaceObject.__)('Unable to paste styles. This feature is only available on secure (https) sites in supporting browsers.'), { 55701 type: 'snackbar' 55702 }); 55703 return; 55704 } 55705 html = await window.navigator.clipboard.readText(); 55706 } catch (error) { 55707 // Possibly the permission is denied. 55708 createErrorNotice((0,external_wp_i18n_namespaceObject.__)('Unable to paste styles. Please allow browser clipboard permissions before continuing.'), { 55709 type: 'snackbar' 55710 }); 55711 return; 55712 } 55713 55714 // Abort if the copied text is empty or doesn't look like serialized blocks. 55715 if (!html || !hasSerializedBlocks(html)) { 55716 createWarningNotice((0,external_wp_i18n_namespaceObject.__)("Unable to paste styles. Block styles couldn't be found within the copied content."), { 55717 type: 'snackbar' 55718 }); 55719 return; 55720 } 55721 const copiedBlocks = (0,external_wp_blocks_namespaceObject.parse)(html); 55722 if (copiedBlocks.length === 1) { 55723 // Apply styles of the block to all the target blocks. 55724 registry.batch(() => { 55725 recursivelyUpdateBlockAttributes(targetBlocks, targetBlocks.map(() => copiedBlocks[0]), updateBlockAttributes); 55726 }); 55727 } else { 55728 registry.batch(() => { 55729 recursivelyUpdateBlockAttributes(targetBlocks, copiedBlocks, updateBlockAttributes); 55730 }); 55731 } 55732 if (targetBlocks.length === 1) { 55733 const title = (0,external_wp_blocks_namespaceObject.getBlockType)(targetBlocks[0].name)?.title; 55734 createSuccessNotice((0,external_wp_i18n_namespaceObject.sprintf)( 55735 // Translators: Name of the block being pasted, e.g. "Paragraph". 55736 (0,external_wp_i18n_namespaceObject.__)('Pasted styles to %s.'), title), { 55737 type: 'snackbar' 55738 }); 55739 } else { 55740 createSuccessNotice((0,external_wp_i18n_namespaceObject.sprintf)( 55741 // Translators: The number of the blocks. 55742 (0,external_wp_i18n_namespaceObject.__)('Pasted styles to %d blocks.'), targetBlocks.length), { 55743 type: 'snackbar' 55744 }); 55745 } 55746 }, [registry.batch, updateBlockAttributes, createSuccessNotice, createWarningNotice, createErrorNotice]); 55747 } 55748 55749 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-actions/index.js 55750 /** 55751 * WordPress dependencies 55752 */ 55753 55754 55755 55756 /** 55757 * Internal dependencies 55758 */ 55759 55760 55761 55762 function BlockActions({ 55763 clientIds, 55764 children, 55765 __experimentalUpdateSelection: updateSelection 55766 }) { 55767 const { 55768 getDefaultBlockName, 55769 getGroupingBlockName 55770 } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store); 55771 const selected = (0,external_wp_data_namespaceObject.useSelect)(select => { 55772 const { 55773 canInsertBlockType, 55774 getBlockRootClientId, 55775 getBlocksByClientId, 55776 getDirectInsertBlock, 55777 canMoveBlocks, 55778 canRemoveBlocks 55779 } = select(store); 55780 const blocks = getBlocksByClientId(clientIds); 55781 const rootClientId = getBlockRootClientId(clientIds[0]); 55782 const canInsertDefaultBlock = canInsertBlockType(getDefaultBlockName(), rootClientId); 55783 const directInsertBlock = rootClientId ? getDirectInsertBlock(rootClientId) : null; 55784 return { 55785 canMove: canMoveBlocks(clientIds), 55786 canRemove: canRemoveBlocks(clientIds), 55787 canInsertBlock: canInsertDefaultBlock || !!directInsertBlock, 55788 canCopyStyles: blocks.every(block => { 55789 return !!block && ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(block.name, 'color') || (0,external_wp_blocks_namespaceObject.hasBlockSupport)(block.name, 'typography')); 55790 }), 55791 canDuplicate: blocks.every(block => { 55792 return !!block && (0,external_wp_blocks_namespaceObject.hasBlockSupport)(block.name, 'multiple', true) && canInsertBlockType(block.name, rootClientId); 55793 }) 55794 }; 55795 }, [clientIds, getDefaultBlockName]); 55796 const { 55797 getBlocksByClientId, 55798 getBlocks 55799 } = (0,external_wp_data_namespaceObject.useSelect)(store); 55800 const { 55801 canMove, 55802 canRemove, 55803 canInsertBlock, 55804 canCopyStyles, 55805 canDuplicate 55806 } = selected; 55807 const { 55808 removeBlocks, 55809 replaceBlocks, 55810 duplicateBlocks, 55811 insertAfterBlock, 55812 insertBeforeBlock, 55813 flashBlock, 55814 setBlockMovingClientId, 55815 setNavigationMode, 55816 selectBlock 55817 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 55818 const notifyCopy = useNotifyCopy(); 55819 const pasteStyles = usePasteStyles(); 55820 return children({ 55821 canCopyStyles, 55822 canDuplicate, 55823 canInsertBlock, 55824 canMove, 55825 canRemove, 55826 onDuplicate() { 55827 return duplicateBlocks(clientIds, updateSelection); 55828 }, 55829 onRemove() { 55830 return removeBlocks(clientIds, updateSelection); 55831 }, 55832 onInsertBefore() { 55833 insertBeforeBlock(clientIds[0]); 55834 }, 55835 onInsertAfter() { 55836 insertAfterBlock(clientIds[clientIds.length - 1]); 55837 }, 55838 onMoveTo() { 55839 setNavigationMode(true); 55840 selectBlock(clientIds[0]); 55841 setBlockMovingClientId(clientIds[0]); 55842 }, 55843 onGroup() { 55844 if (!clientIds.length) { 55845 return; 55846 } 55847 const groupingBlockName = getGroupingBlockName(); 55848 55849 // Activate the `transform` on `core/group` which does the conversion. 55850 const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(getBlocksByClientId(clientIds), groupingBlockName); 55851 if (!newBlocks) { 55852 return; 55853 } 55854 replaceBlocks(clientIds, newBlocks); 55855 }, 55856 onUngroup() { 55857 if (!clientIds.length) { 55858 return; 55859 } 55860 const innerBlocks = getBlocks(clientIds[0]); 55861 if (!innerBlocks.length) { 55862 return; 55863 } 55864 replaceBlocks(clientIds, innerBlocks); 55865 }, 55866 onCopy() { 55867 if (clientIds.length === 1) { 55868 flashBlock(clientIds[0]); 55869 } 55870 notifyCopy('copy', clientIds); 55871 }, 55872 async onPasteStyles() { 55873 await pasteStyles(getBlocksByClientId(clientIds)); 55874 } 55875 }); 55876 } 55877 55878 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-html-convert-button.js 55879 /** 55880 * WordPress dependencies 55881 */ 55882 55883 55884 55885 55886 55887 /** 55888 * Internal dependencies 55889 */ 55890 55891 55892 function BlockHTMLConvertButton({ 55893 clientId 55894 }) { 55895 const block = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getBlock(clientId), [clientId]); 55896 const { 55897 replaceBlocks 55898 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 55899 if (!block || block.name !== 'core/html') { 55900 return null; 55901 } 55902 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 55903 onClick: () => replaceBlocks(clientId, (0,external_wp_blocks_namespaceObject.rawHandler)({ 55904 HTML: (0,external_wp_blocks_namespaceObject.getBlockContent)(block) 55905 })), 55906 children: (0,external_wp_i18n_namespaceObject.__)('Convert to Blocks') 55907 }); 55908 } 55909 /* harmony default export */ const block_html_convert_button = (BlockHTMLConvertButton); 55910 55911 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-settings-menu-first-item.js 55912 /** 55913 * WordPress dependencies 55914 */ 55915 55916 const { 55917 Fill: __unstableBlockSettingsMenuFirstItem, 55918 Slot: block_settings_menu_first_item_Slot 55919 } = (0,external_wp_components_namespaceObject.createSlotFill)('__unstableBlockSettingsMenuFirstItem'); 55920 __unstableBlockSettingsMenuFirstItem.Slot = block_settings_menu_first_item_Slot; 55921 /* harmony default export */ const block_settings_menu_first_item = (__unstableBlockSettingsMenuFirstItem); 55922 55923 ;// ./node_modules/@wordpress/block-editor/build-module/components/convert-to-group-buttons/use-convert-to-group-button-props.js 55924 /** 55925 * WordPress dependencies 55926 */ 55927 55928 55929 55930 /** 55931 * Internal dependencies 55932 */ 55933 55934 55935 /** 55936 * Contains the properties `ConvertToGroupButton` component needs. 55937 * 55938 * @typedef {Object} ConvertToGroupButtonProps 55939 * @property {string[]} clientIds An array of the selected client ids. 55940 * @property {boolean} isGroupable Indicates if the selected blocks can be grouped. 55941 * @property {boolean} isUngroupable Indicates if the selected blocks can be ungrouped. 55942 * @property {WPBlock[]} blocksSelection An array of the selected blocks. 55943 * @property {string} groupingBlockName The name of block used for handling grouping interactions. 55944 */ 55945 55946 /** 55947 * Returns the properties `ConvertToGroupButton` component needs to work properly. 55948 * It is used in `BlockSettingsMenuControls` to know if `ConvertToGroupButton` 55949 * should be rendered, to avoid ending up with an empty MenuGroup. 55950 * 55951 * @param {?string[]} selectedClientIds An optional array of clientIds to group. The selected blocks 55952 * from the block editor store are used if this is not provided. 55953 * 55954 * @return {ConvertToGroupButtonProps} Returns the properties needed by `ConvertToGroupButton`. 55955 */ 55956 function useConvertToGroupButtonProps(selectedClientIds) { 55957 return (0,external_wp_data_namespaceObject.useSelect)(select => { 55958 const { 55959 getBlocksByClientId, 55960 getSelectedBlockClientIds, 55961 isUngroupable, 55962 isGroupable 55963 } = select(store); 55964 const { 55965 getGroupingBlockName, 55966 getBlockType 55967 } = select(external_wp_blocks_namespaceObject.store); 55968 const clientIds = selectedClientIds?.length ? selectedClientIds : getSelectedBlockClientIds(); 55969 const blocksSelection = getBlocksByClientId(clientIds); 55970 const [firstSelectedBlock] = blocksSelection; 55971 const _isUngroupable = clientIds.length === 1 && isUngroupable(clientIds[0]); 55972 return { 55973 clientIds, 55974 isGroupable: isGroupable(clientIds), 55975 isUngroupable: _isUngroupable, 55976 blocksSelection, 55977 groupingBlockName: getGroupingBlockName(), 55978 onUngroup: _isUngroupable && getBlockType(firstSelectedBlock.name)?.transforms?.ungroup 55979 }; 55980 }, [selectedClientIds]); 55981 } 55982 55983 ;// ./node_modules/@wordpress/block-editor/build-module/components/convert-to-group-buttons/index.js 55984 /** 55985 * WordPress dependencies 55986 */ 55987 55988 55989 55990 55991 55992 55993 /** 55994 * Internal dependencies 55995 */ 55996 55997 55998 55999 56000 56001 56002 function ConvertToGroupButton({ 56003 clientIds, 56004 isGroupable, 56005 isUngroupable, 56006 onUngroup, 56007 blocksSelection, 56008 groupingBlockName, 56009 onClose = () => {} 56010 }) { 56011 const { 56012 getSelectedBlockClientIds 56013 } = (0,external_wp_data_namespaceObject.useSelect)(store); 56014 const { 56015 replaceBlocks 56016 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 56017 const onConvertToGroup = () => { 56018 // Activate the `transform` on the Grouping Block which does the conversion. 56019 const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocksSelection, groupingBlockName); 56020 if (newBlocks) { 56021 replaceBlocks(clientIds, newBlocks); 56022 } 56023 }; 56024 const onConvertFromGroup = () => { 56025 let innerBlocks = blocksSelection[0].innerBlocks; 56026 if (!innerBlocks.length) { 56027 return; 56028 } 56029 if (onUngroup) { 56030 innerBlocks = onUngroup(blocksSelection[0].attributes, blocksSelection[0].innerBlocks); 56031 } 56032 replaceBlocks(clientIds, innerBlocks); 56033 }; 56034 if (!isGroupable && !isUngroupable) { 56035 return null; 56036 } 56037 const selectedBlockClientIds = getSelectedBlockClientIds(); 56038 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 56039 children: [isGroupable && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 56040 shortcut: selectedBlockClientIds.length > 1 ? external_wp_keycodes_namespaceObject.displayShortcut.primary('g') : undefined, 56041 onClick: () => { 56042 onConvertToGroup(); 56043 onClose(); 56044 }, 56045 children: (0,external_wp_i18n_namespaceObject._x)('Group', 'verb') 56046 }), isUngroupable && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 56047 onClick: () => { 56048 onConvertFromGroup(); 56049 onClose(); 56050 }, 56051 children: (0,external_wp_i18n_namespaceObject._x)('Ungroup', 'Ungrouping blocks from within a grouping block back into individual blocks within the Editor') 56052 })] 56053 }); 56054 } 56055 56056 56057 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-lock/use-block-lock.js 56058 /** 56059 * WordPress dependencies 56060 */ 56061 56062 56063 /** 56064 * Internal dependencies 56065 */ 56066 56067 56068 /** 56069 * Return details about the block lock status. 56070 * 56071 * @param {string} clientId The block client Id. 56072 * 56073 * @return {Object} Block lock status 56074 */ 56075 function useBlockLock(clientId) { 56076 return (0,external_wp_data_namespaceObject.useSelect)(select => { 56077 const { 56078 canEditBlock, 56079 canMoveBlock, 56080 canRemoveBlock, 56081 canLockBlockType, 56082 getBlockName, 56083 getTemplateLock 56084 } = select(store); 56085 const canEdit = canEditBlock(clientId); 56086 const canMove = canMoveBlock(clientId); 56087 const canRemove = canRemoveBlock(clientId); 56088 return { 56089 canEdit, 56090 canMove, 56091 canRemove, 56092 canLock: canLockBlockType(getBlockName(clientId)), 56093 isContentLocked: getTemplateLock(clientId) === 'contentOnly', 56094 isLocked: !canEdit || !canMove || !canRemove 56095 }; 56096 }, [clientId]); 56097 } 56098 56099 ;// ./node_modules/@wordpress/icons/build-module/library/unlock.js 56100 /** 56101 * WordPress dependencies 56102 */ 56103 56104 56105 const unlock_unlock = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 56106 viewBox: "0 0 24 24", 56107 xmlns: "http://www.w3.org/2000/svg", 56108 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 56109 d: "M17 10h-1.2V7c0-2.1-1.7-3.8-3.8-3.8-2.1 0-3.8 1.7-3.8 3.8h1.5c0-1.2 1-2.2 2.2-2.2s2.2 1 2.2 2.2v3H7c-.6 0-1 .4-1 1v8c0 .6.4 1 1 1h10c.6 0 1-.4 1-1v-8c0-.6-.4-1-1-1z" 56110 }) 56111 }); 56112 /* harmony default export */ const library_unlock = (unlock_unlock); 56113 56114 ;// ./node_modules/@wordpress/icons/build-module/library/lock-outline.js 56115 /** 56116 * WordPress dependencies 56117 */ 56118 56119 56120 const lockOutline = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 56121 viewBox: "0 0 24 24", 56122 xmlns: "http://www.w3.org/2000/svg", 56123 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 56124 d: "M17 10h-1.2V7c0-2.1-1.7-3.8-3.8-3.8-2.1 0-3.8 1.7-3.8 3.8v3H7c-.6 0-1 .4-1 1v8c0 .6.4 1 1 1h10c.6 0 1-.4 1-1v-8c0-.6-.4-1-1-1zM9.8 7c0-1.2 1-2.2 2.2-2.2 1.2 0 2.2 1 2.2 2.2v3H9.8V7zm6.7 11.5h-9v-7h9v7z" 56125 }) 56126 }); 56127 /* harmony default export */ const lock_outline = (lockOutline); 56128 56129 ;// ./node_modules/@wordpress/icons/build-module/library/lock.js 56130 /** 56131 * WordPress dependencies 56132 */ 56133 56134 56135 const lock_lock = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 56136 viewBox: "0 0 24 24", 56137 xmlns: "http://www.w3.org/2000/svg", 56138 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 56139 d: "M17 10h-1.2V7c0-2.1-1.7-3.8-3.8-3.8-2.1 0-3.8 1.7-3.8 3.8v3H7c-.6 0-1 .4-1 1v8c0 .6.4 1 1 1h10c.6 0 1-.4 1-1v-8c0-.6-.4-1-1-1zm-2.8 0H9.8V7c0-1.2 1-2.2 2.2-2.2s2.2 1 2.2 2.2v3z" 56140 }) 56141 }); 56142 /* harmony default export */ const library_lock = (lock_lock); 56143 56144 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-lock/modal.js 56145 /** 56146 * WordPress dependencies 56147 */ 56148 56149 56150 56151 56152 56153 56154 56155 /** 56156 * Internal dependencies 56157 */ 56158 56159 56160 56161 56162 // Entity based blocks which allow edit locking 56163 56164 56165 const ALLOWS_EDIT_LOCKING = ['core/block', 'core/navigation']; 56166 function getTemplateLockValue(lock) { 56167 // Prevents all operations. 56168 if (lock.remove && lock.move) { 56169 return 'all'; 56170 } 56171 56172 // Prevents inserting or removing blocks, but allows moving existing blocks. 56173 if (lock.remove && !lock.move) { 56174 return 'insert'; 56175 } 56176 return false; 56177 } 56178 function BlockLockModal({ 56179 clientId, 56180 onClose 56181 }) { 56182 const [lock, setLock] = (0,external_wp_element_namespaceObject.useState)({ 56183 move: false, 56184 remove: false 56185 }); 56186 const { 56187 canEdit, 56188 canMove, 56189 canRemove 56190 } = useBlockLock(clientId); 56191 const { 56192 allowsEditLocking, 56193 templateLock, 56194 hasTemplateLock 56195 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 56196 const { 56197 getBlockName, 56198 getBlockAttributes 56199 } = select(store); 56200 const blockName = getBlockName(clientId); 56201 const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName); 56202 return { 56203 allowsEditLocking: ALLOWS_EDIT_LOCKING.includes(blockName), 56204 templateLock: getBlockAttributes(clientId)?.templateLock, 56205 hasTemplateLock: !!blockType?.attributes?.templateLock 56206 }; 56207 }, [clientId]); 56208 const [applyTemplateLock, setApplyTemplateLock] = (0,external_wp_element_namespaceObject.useState)(!!templateLock); 56209 const { 56210 updateBlockAttributes 56211 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 56212 const blockInformation = useBlockDisplayInformation(clientId); 56213 (0,external_wp_element_namespaceObject.useEffect)(() => { 56214 setLock({ 56215 move: !canMove, 56216 remove: !canRemove, 56217 ...(allowsEditLocking ? { 56218 edit: !canEdit 56219 } : {}) 56220 }); 56221 }, [canEdit, canMove, canRemove, allowsEditLocking]); 56222 const isAllChecked = Object.values(lock).every(Boolean); 56223 const isMixed = Object.values(lock).some(Boolean) && !isAllChecked; 56224 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, { 56225 title: (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: Name of the block. */ 56226 (0,external_wp_i18n_namespaceObject.__)('Lock %s'), blockInformation.title), 56227 overlayClassName: "block-editor-block-lock-modal", 56228 onRequestClose: onClose, 56229 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("form", { 56230 onSubmit: event => { 56231 event.preventDefault(); 56232 updateBlockAttributes([clientId], { 56233 lock, 56234 templateLock: applyTemplateLock ? getTemplateLockValue(lock) : undefined 56235 }); 56236 onClose(); 56237 }, 56238 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", { 56239 className: "block-editor-block-lock-modal__options", 56240 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("legend", { 56241 children: (0,external_wp_i18n_namespaceObject.__)('Choose specific attributes to restrict or lock all available options.') 56242 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("ul", { 56243 role: "list", 56244 className: "block-editor-block-lock-modal__checklist", 56245 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", { 56246 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, { 56247 __nextHasNoMarginBottom: true, 56248 className: "block-editor-block-lock-modal__options-all", 56249 label: (0,external_wp_i18n_namespaceObject.__)('Lock all'), 56250 checked: isAllChecked, 56251 indeterminate: isMixed, 56252 onChange: newValue => setLock({ 56253 move: newValue, 56254 remove: newValue, 56255 ...(allowsEditLocking ? { 56256 edit: newValue 56257 } : {}) 56258 }) 56259 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("ul", { 56260 role: "list", 56261 className: "block-editor-block-lock-modal__checklist", 56262 children: [allowsEditLocking && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", { 56263 className: "block-editor-block-lock-modal__checklist-item", 56264 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, { 56265 __nextHasNoMarginBottom: true, 56266 label: (0,external_wp_i18n_namespaceObject.__)('Restrict editing'), 56267 checked: !!lock.edit, 56268 onChange: edit => setLock(prevLock => ({ 56269 ...prevLock, 56270 edit 56271 })) 56272 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, { 56273 className: "block-editor-block-lock-modal__lock-icon", 56274 icon: lock.edit ? library_lock : library_unlock 56275 })] 56276 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", { 56277 className: "block-editor-block-lock-modal__checklist-item", 56278 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, { 56279 __nextHasNoMarginBottom: true, 56280 label: (0,external_wp_i18n_namespaceObject.__)('Disable movement'), 56281 checked: lock.move, 56282 onChange: move => setLock(prevLock => ({ 56283 ...prevLock, 56284 move 56285 })) 56286 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, { 56287 className: "block-editor-block-lock-modal__lock-icon", 56288 icon: lock.move ? library_lock : library_unlock 56289 })] 56290 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", { 56291 className: "block-editor-block-lock-modal__checklist-item", 56292 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, { 56293 __nextHasNoMarginBottom: true, 56294 label: (0,external_wp_i18n_namespaceObject.__)('Prevent removal'), 56295 checked: lock.remove, 56296 onChange: remove => setLock(prevLock => ({ 56297 ...prevLock, 56298 remove 56299 })) 56300 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, { 56301 className: "block-editor-block-lock-modal__lock-icon", 56302 icon: lock.remove ? library_lock : library_unlock 56303 })] 56304 })] 56305 })] 56306 }) 56307 }), hasTemplateLock && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, { 56308 __nextHasNoMarginBottom: true, 56309 className: "block-editor-block-lock-modal__template-lock", 56310 label: (0,external_wp_i18n_namespaceObject.__)('Apply to all blocks inside'), 56311 checked: applyTemplateLock, 56312 disabled: lock.move && !lock.remove, 56313 onChange: () => setApplyTemplateLock(!applyTemplateLock) 56314 })] 56315 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, { 56316 className: "block-editor-block-lock-modal__actions", 56317 justify: "flex-end", 56318 expanded: false, 56319 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 56320 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 56321 variant: "tertiary", 56322 onClick: onClose, 56323 __next40pxDefaultSize: true, 56324 children: (0,external_wp_i18n_namespaceObject.__)('Cancel') 56325 }) 56326 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 56327 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 56328 variant: "primary", 56329 type: "submit", 56330 __next40pxDefaultSize: true, 56331 children: (0,external_wp_i18n_namespaceObject.__)('Apply') 56332 }) 56333 })] 56334 })] 56335 }) 56336 }); 56337 } 56338 56339 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-lock/menu-item.js 56340 /** 56341 * WordPress dependencies 56342 */ 56343 56344 56345 56346 56347 56348 /** 56349 * Internal dependencies 56350 */ 56351 56352 56353 56354 56355 56356 function BlockLockMenuItem({ 56357 clientId 56358 }) { 56359 const { 56360 canLock, 56361 isLocked 56362 } = useBlockLock(clientId); 56363 const [isModalOpen, toggleModal] = (0,external_wp_element_namespaceObject.useReducer)(isActive => !isActive, false); 56364 if (!canLock) { 56365 return null; 56366 } 56367 const label = isLocked ? (0,external_wp_i18n_namespaceObject.__)('Unlock') : (0,external_wp_i18n_namespaceObject.__)('Lock'); 56368 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 56369 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 56370 icon: isLocked ? library_unlock : lock_outline, 56371 onClick: toggleModal, 56372 "aria-expanded": isModalOpen, 56373 "aria-haspopup": "dialog", 56374 children: label 56375 }), isModalOpen && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockLockModal, { 56376 clientId: clientId, 56377 onClose: toggleModal 56378 })] 56379 }); 56380 } 56381 56382 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-mode-toggle.js 56383 /** 56384 * WordPress dependencies 56385 */ 56386 56387 56388 56389 56390 56391 /** 56392 * Internal dependencies 56393 */ 56394 56395 56396 const block_mode_toggle_noop = () => {}; 56397 function BlockModeToggle({ 56398 clientId, 56399 onToggle = block_mode_toggle_noop 56400 }) { 56401 const { 56402 blockType, 56403 mode, 56404 isCodeEditingEnabled 56405 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 56406 const { 56407 getBlock, 56408 getBlockMode, 56409 getSettings 56410 } = select(store); 56411 const block = getBlock(clientId); 56412 return { 56413 mode: getBlockMode(clientId), 56414 blockType: block ? (0,external_wp_blocks_namespaceObject.getBlockType)(block.name) : null, 56415 isCodeEditingEnabled: getSettings().codeEditingEnabled 56416 }; 56417 }, [clientId]); 56418 const { 56419 toggleBlockMode 56420 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 56421 if (!blockType || !(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'html', true) || !isCodeEditingEnabled) { 56422 return null; 56423 } 56424 const label = mode === 'visual' ? (0,external_wp_i18n_namespaceObject.__)('Edit as HTML') : (0,external_wp_i18n_namespaceObject.__)('Edit visually'); 56425 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 56426 onClick: () => { 56427 toggleBlockMode(clientId); 56428 onToggle(); 56429 }, 56430 children: label 56431 }); 56432 } 56433 56434 ;// ./node_modules/@wordpress/block-editor/build-module/components/content-lock/modify-content-lock-menu-item.js 56435 /** 56436 * WordPress dependencies 56437 */ 56438 56439 56440 56441 56442 /** 56443 * Internal dependencies 56444 */ 56445 56446 56447 56448 // The implementation of content locking is mainly in this file, although the mechanism 56449 // to stop temporarily editing as blocks when an outside block is selected is on component StopEditingAsBlocksOnOutsideSelect 56450 // at block-editor/src/components/block-list/index.js. 56451 // Besides the components on this file and the file referenced above the implementation 56452 // also includes artifacts on the store (actions, reducers, and selector). 56453 56454 function ModifyContentLockMenuItem({ 56455 clientId, 56456 onClose 56457 }) { 56458 const { 56459 templateLock, 56460 isLockedByParent, 56461 isEditingAsBlocks 56462 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 56463 const { 56464 getContentLockingParent, 56465 getTemplateLock, 56466 getTemporarilyEditingAsBlocks 56467 } = unlock(select(store)); 56468 return { 56469 templateLock: getTemplateLock(clientId), 56470 isLockedByParent: !!getContentLockingParent(clientId), 56471 isEditingAsBlocks: getTemporarilyEditingAsBlocks() === clientId 56472 }; 56473 }, [clientId]); 56474 const blockEditorActions = (0,external_wp_data_namespaceObject.useDispatch)(store); 56475 const isContentLocked = !isLockedByParent && templateLock === 'contentOnly'; 56476 if (!isContentLocked && !isEditingAsBlocks) { 56477 return null; 56478 } 56479 const { 56480 modifyContentLockBlock 56481 } = unlock(blockEditorActions); 56482 const showStartEditingAsBlocks = !isEditingAsBlocks && isContentLocked; 56483 return showStartEditingAsBlocks && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 56484 onClick: () => { 56485 modifyContentLockBlock(clientId); 56486 onClose(); 56487 }, 56488 children: (0,external_wp_i18n_namespaceObject._x)('Modify', 'Unlock content locked blocks') 56489 }); 56490 } 56491 56492 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-rename/use-block-rename.js 56493 /** 56494 * WordPress dependencies 56495 */ 56496 56497 function useBlockRename(name) { 56498 return { 56499 canRename: (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, 'renaming', true) 56500 }; 56501 } 56502 56503 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-rename/is-empty-string.js 56504 function isEmptyString(testString) { 56505 return testString?.trim()?.length === 0; 56506 } 56507 56508 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-rename/modal.js 56509 /** 56510 * WordPress dependencies 56511 */ 56512 56513 56514 56515 56516 56517 /** 56518 * Internal dependencies 56519 */ 56520 56521 56522 56523 function BlockRenameModal({ 56524 blockName, 56525 originalBlockName, 56526 onClose, 56527 onSave, 56528 // Pattern Overrides is a WordPress-only feature but it also uses the Block Binding API. 56529 // Ideally this should not be inside the block editor package, but we keep it here for simplicity. 56530 hasOverridesWarning 56531 }) { 56532 const [editedBlockName, setEditedBlockName] = (0,external_wp_element_namespaceObject.useState)(blockName); 56533 const nameHasChanged = editedBlockName !== blockName; 56534 const nameIsOriginal = editedBlockName === originalBlockName; 56535 const nameIsEmpty = isEmptyString(editedBlockName); 56536 const isNameValid = nameHasChanged || nameIsOriginal; 56537 const autoSelectInputText = event => event.target.select(); 56538 const handleSubmit = () => { 56539 const message = nameIsOriginal || nameIsEmpty ? (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: new name/label for the block */ 56540 (0,external_wp_i18n_namespaceObject.__)('Block name reset to: "%s".'), editedBlockName) : (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: new name/label for the block */ 56541 (0,external_wp_i18n_namespaceObject.__)('Block name changed to: "%s".'), editedBlockName); 56542 56543 // Must be assertive to immediately announce change. 56544 (0,external_wp_a11y_namespaceObject.speak)(message, 'assertive'); 56545 onSave(editedBlockName); 56546 56547 // Immediate close avoids ability to hit save multiple times. 56548 onClose(); 56549 }; 56550 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, { 56551 title: (0,external_wp_i18n_namespaceObject.__)('Rename'), 56552 onRequestClose: onClose, 56553 overlayClassName: "block-editor-block-rename-modal", 56554 focusOnMount: "firstContentElement", 56555 size: "small", 56556 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("form", { 56557 onSubmit: e => { 56558 e.preventDefault(); 56559 if (!isNameValid) { 56560 return; 56561 } 56562 handleSubmit(); 56563 }, 56564 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 56565 spacing: "3", 56566 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, { 56567 __nextHasNoMarginBottom: true, 56568 __next40pxDefaultSize: true, 56569 value: editedBlockName, 56570 label: (0,external_wp_i18n_namespaceObject.__)('Name'), 56571 help: hasOverridesWarning ? (0,external_wp_i18n_namespaceObject.__)('This block allows overrides. Changing the name can cause problems with content entered into instances of this pattern.') : undefined, 56572 placeholder: originalBlockName, 56573 onChange: setEditedBlockName, 56574 onFocus: autoSelectInputText 56575 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 56576 justify: "right", 56577 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 56578 __next40pxDefaultSize: true, 56579 variant: "tertiary", 56580 onClick: onClose, 56581 children: (0,external_wp_i18n_namespaceObject.__)('Cancel') 56582 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 56583 __next40pxDefaultSize: true, 56584 "aria-disabled": !isNameValid, 56585 variant: "primary", 56586 type: "submit", 56587 children: (0,external_wp_i18n_namespaceObject.__)('Save') 56588 })] 56589 })] 56590 }) 56591 }) 56592 }); 56593 } 56594 56595 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-rename/rename-control.js 56596 /** 56597 * WordPress dependencies 56598 */ 56599 56600 56601 56602 56603 56604 /** 56605 * Internal dependencies 56606 */ 56607 56608 56609 56610 56611 56612 56613 56614 function BlockRenameControl({ 56615 clientId 56616 }) { 56617 const [renamingBlock, setRenamingBlock] = (0,external_wp_element_namespaceObject.useState)(false); 56618 const { 56619 metadata 56620 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 56621 const { 56622 getBlockAttributes 56623 } = select(store); 56624 const _metadata = getBlockAttributes(clientId)?.metadata; 56625 return { 56626 metadata: _metadata 56627 }; 56628 }, [clientId]); 56629 const { 56630 updateBlockAttributes 56631 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 56632 const customName = metadata?.name; 56633 const hasPatternOverrides = !!customName && !!metadata?.bindings && Object.values(metadata.bindings).some(binding => binding.source === 'core/pattern-overrides'); 56634 function onChange(newName) { 56635 updateBlockAttributes([clientId], { 56636 metadata: { 56637 ...metadata, 56638 name: newName 56639 } 56640 }); 56641 } 56642 const blockInformation = useBlockDisplayInformation(clientId); 56643 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 56644 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 56645 onClick: () => { 56646 setRenamingBlock(true); 56647 }, 56648 "aria-expanded": renamingBlock, 56649 "aria-haspopup": "dialog", 56650 children: (0,external_wp_i18n_namespaceObject.__)('Rename') 56651 }), renamingBlock && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockRenameModal, { 56652 blockName: customName || '', 56653 originalBlockName: blockInformation?.title, 56654 hasOverridesWarning: hasPatternOverrides, 56655 onClose: () => setRenamingBlock(false), 56656 onSave: newName => { 56657 // If the new value is the block's original name (e.g. `Group`) 56658 // or it is an empty string then assume the intent is to reset 56659 // the value. Therefore reset the metadata. 56660 if (newName === blockInformation?.title || isEmptyString(newName)) { 56661 newName = undefined; 56662 } 56663 onChange(newName); 56664 } 56665 })] 56666 }); 56667 } 56668 56669 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu-controls/index.js 56670 /** 56671 * WordPress dependencies 56672 */ 56673 56674 56675 56676 56677 56678 /** 56679 * Internal dependencies 56680 */ 56681 56682 56683 56684 56685 56686 56687 56688 56689 const { 56690 Fill, 56691 Slot: block_settings_menu_controls_Slot 56692 } = (0,external_wp_components_namespaceObject.createSlotFill)('BlockSettingsMenuControls'); 56693 const BlockSettingsMenuControlsSlot = ({ 56694 fillProps, 56695 clientIds = null 56696 }) => { 56697 const { 56698 selectedBlocks, 56699 selectedClientIds, 56700 isContentOnly 56701 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 56702 const { 56703 getBlockNamesByClientId, 56704 getSelectedBlockClientIds, 56705 getBlockEditingMode 56706 } = select(store); 56707 const ids = clientIds !== null ? clientIds : getSelectedBlockClientIds(); 56708 return { 56709 selectedBlocks: getBlockNamesByClientId(ids), 56710 selectedClientIds: ids, 56711 isContentOnly: getBlockEditingMode(ids[0]) === 'contentOnly' 56712 }; 56713 }, [clientIds]); 56714 const { 56715 canLock 56716 } = useBlockLock(selectedClientIds[0]); 56717 const { 56718 canRename 56719 } = useBlockRename(selectedBlocks[0]); 56720 const showLockButton = selectedClientIds.length === 1 && canLock && !isContentOnly; 56721 const showRenameButton = selectedClientIds.length === 1 && canRename && !isContentOnly; 56722 56723 // Check if current selection of blocks is Groupable or Ungroupable 56724 // and pass this props down to ConvertToGroupButton. 56725 const convertToGroupButtonProps = useConvertToGroupButtonProps(selectedClientIds); 56726 const { 56727 isGroupable, 56728 isUngroupable 56729 } = convertToGroupButtonProps; 56730 const showConvertToGroupButton = (isGroupable || isUngroupable) && !isContentOnly; 56731 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_menu_controls_Slot, { 56732 fillProps: { 56733 ...fillProps, 56734 selectedBlocks, 56735 selectedClientIds 56736 }, 56737 children: fills => { 56738 if (!fills?.length > 0 && !showConvertToGroupButton && !showLockButton) { 56739 return null; 56740 } 56741 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, { 56742 children: [showConvertToGroupButton && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ConvertToGroupButton, { 56743 ...convertToGroupButtonProps, 56744 onClose: fillProps?.onClose 56745 }), showLockButton && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockLockMenuItem, { 56746 clientId: selectedClientIds[0] 56747 }), showRenameButton && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockRenameControl, { 56748 clientId: selectedClientIds[0] 56749 }), fills, fillProps?.canMove && !fillProps?.onlyBlock && !isContentOnly && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 56750 onClick: (0,external_wp_compose_namespaceObject.pipe)(fillProps?.onClose, fillProps?.onMoveTo), 56751 children: (0,external_wp_i18n_namespaceObject.__)('Move to') 56752 }), selectedClientIds.length === 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ModifyContentLockMenuItem, { 56753 clientId: selectedClientIds[0], 56754 onClose: fillProps?.onClose 56755 }), fillProps?.count === 1 && !isContentOnly && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockModeToggle, { 56756 clientId: fillProps?.firstBlockClientId, 56757 onToggle: fillProps?.onClose 56758 })] 56759 }); 56760 } 56761 }); 56762 }; 56763 56764 /** 56765 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-settings-menu-controls/README.md 56766 * 56767 * @param {Object} props Fill props. 56768 * @return {Element} Element. 56769 */ 56770 function BlockSettingsMenuControls({ 56771 ...props 56772 }) { 56773 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalStyleProvider, { 56774 document: document, 56775 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Fill, { 56776 ...props 56777 }) 56778 }); 56779 } 56780 BlockSettingsMenuControls.Slot = BlockSettingsMenuControlsSlot; 56781 /* harmony default export */ const block_settings_menu_controls = (BlockSettingsMenuControls); 56782 56783 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-parent-selector-menu-item.js 56784 /** 56785 * WordPress dependencies 56786 */ 56787 56788 56789 56790 56791 56792 56793 /** 56794 * Internal dependencies 56795 */ 56796 56797 56798 56799 56800 function BlockParentSelectorMenuItem({ 56801 parentClientId, 56802 parentBlockType 56803 }) { 56804 const isSmallViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<'); 56805 const { 56806 selectBlock 56807 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 56808 56809 // Allows highlighting the parent block outline when focusing or hovering 56810 // the parent block selector within the child. 56811 const menuItemRef = (0,external_wp_element_namespaceObject.useRef)(); 56812 const gesturesProps = useShowHoveredOrFocusedGestures({ 56813 ref: menuItemRef, 56814 highlightParent: true 56815 }); 56816 if (!isSmallViewport) { 56817 return null; 56818 } 56819 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 56820 ...gesturesProps, 56821 ref: menuItemRef, 56822 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 56823 icon: parentBlockType.icon 56824 }), 56825 onClick: () => selectBlock(parentClientId), 56826 children: (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: Name of the block's parent. */ 56827 (0,external_wp_i18n_namespaceObject.__)('Select parent block (%s)'), parentBlockType.title) 56828 }); 56829 } 56830 56831 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-settings-dropdown.js 56832 /** 56833 * WordPress dependencies 56834 */ 56835 56836 56837 56838 56839 56840 56841 56842 56843 56844 56845 /** 56846 * Internal dependencies 56847 */ 56848 56849 56850 56851 56852 56853 56854 56855 56856 56857 56858 const block_settings_dropdown_POPOVER_PROPS = { 56859 className: 'block-editor-block-settings-menu__popover', 56860 placement: 'bottom-start' 56861 }; 56862 function CopyMenuItem({ 56863 clientIds, 56864 onCopy, 56865 label, 56866 shortcut 56867 }) { 56868 const { 56869 getBlocksByClientId 56870 } = (0,external_wp_data_namespaceObject.useSelect)(store); 56871 const ref = (0,external_wp_compose_namespaceObject.useCopyToClipboard)(() => (0,external_wp_blocks_namespaceObject.serialize)(getBlocksByClientId(clientIds)), onCopy); 56872 const copyMenuItemLabel = label ? label : (0,external_wp_i18n_namespaceObject.__)('Copy'); 56873 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 56874 ref: ref, 56875 shortcut: shortcut, 56876 children: copyMenuItemLabel 56877 }); 56878 } 56879 function BlockSettingsDropdown({ 56880 block, 56881 clientIds, 56882 children, 56883 __experimentalSelectBlock, 56884 ...props 56885 }) { 56886 // Get the client id of the current block for this menu, if one is set. 56887 const currentClientId = block?.clientId; 56888 const count = clientIds.length; 56889 const firstBlockClientId = clientIds[0]; 56890 const isZoomOut = (0,external_wp_data_namespaceObject.useSelect)(select => { 56891 const { 56892 __unstableGetEditorMode 56893 } = unlock(select(store)); 56894 return __unstableGetEditorMode() === 'zoom-out'; 56895 }); 56896 const { 56897 firstParentClientId, 56898 onlyBlock, 56899 parentBlockType, 56900 previousBlockClientId, 56901 selectedBlockClientIds, 56902 openedBlockSettingsMenu, 56903 isContentOnly 56904 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 56905 const { 56906 getBlockCount, 56907 getBlockName, 56908 getBlockRootClientId, 56909 getPreviousBlockClientId, 56910 getSelectedBlockClientIds, 56911 getBlockAttributes, 56912 getOpenedBlockSettingsMenu, 56913 getBlockEditingMode 56914 } = unlock(select(store)); 56915 const { 56916 getActiveBlockVariation 56917 } = select(external_wp_blocks_namespaceObject.store); 56918 const _firstParentClientId = getBlockRootClientId(firstBlockClientId); 56919 const parentBlockName = _firstParentClientId && getBlockName(_firstParentClientId); 56920 return { 56921 firstParentClientId: _firstParentClientId, 56922 onlyBlock: 1 === getBlockCount(_firstParentClientId), 56923 parentBlockType: _firstParentClientId && (getActiveBlockVariation(parentBlockName, getBlockAttributes(_firstParentClientId)) || (0,external_wp_blocks_namespaceObject.getBlockType)(parentBlockName)), 56924 previousBlockClientId: getPreviousBlockClientId(firstBlockClientId), 56925 selectedBlockClientIds: getSelectedBlockClientIds(), 56926 openedBlockSettingsMenu: getOpenedBlockSettingsMenu(), 56927 isContentOnly: getBlockEditingMode(firstBlockClientId) === 'contentOnly' 56928 }; 56929 }, [firstBlockClientId]); 56930 const { 56931 getBlockOrder, 56932 getSelectedBlockClientIds 56933 } = (0,external_wp_data_namespaceObject.useSelect)(store); 56934 const { 56935 setOpenedBlockSettingsMenu 56936 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 56937 const shortcuts = (0,external_wp_data_namespaceObject.useSelect)(select => { 56938 const { 56939 getShortcutRepresentation 56940 } = select(external_wp_keyboardShortcuts_namespaceObject.store); 56941 return { 56942 duplicate: getShortcutRepresentation('core/block-editor/duplicate'), 56943 remove: getShortcutRepresentation('core/block-editor/remove'), 56944 insertAfter: getShortcutRepresentation('core/block-editor/insert-after'), 56945 insertBefore: getShortcutRepresentation('core/block-editor/insert-before') 56946 }; 56947 }, []); 56948 const hasSelectedBlocks = selectedBlockClientIds.length > 0; 56949 async function updateSelectionAfterDuplicate(clientIdsPromise) { 56950 if (!__experimentalSelectBlock) { 56951 return; 56952 } 56953 const ids = await clientIdsPromise; 56954 if (ids && ids[0]) { 56955 __experimentalSelectBlock(ids[0], false); 56956 } 56957 } 56958 function updateSelectionAfterRemove() { 56959 if (!__experimentalSelectBlock) { 56960 return; 56961 } 56962 let blockToFocus = previousBlockClientId || firstParentClientId; 56963 56964 // Focus the first block if there's no previous block nor parent block. 56965 if (!blockToFocus) { 56966 blockToFocus = getBlockOrder()[0]; 56967 } 56968 56969 // Only update the selection if the original selection is removed. 56970 const shouldUpdateSelection = hasSelectedBlocks && getSelectedBlockClientIds().length === 0; 56971 __experimentalSelectBlock(blockToFocus, shouldUpdateSelection); 56972 } 56973 56974 // This can occur when the selected block (the parent) 56975 // displays child blocks within a List View. 56976 const parentBlockIsSelected = selectedBlockClientIds?.includes(firstParentClientId); 56977 56978 // When a currentClientId is in use, treat the menu as a controlled component. 56979 // This ensures that only one block settings menu is open at a time. 56980 // This is a temporary solution to work around an issue with `onFocusOutside` 56981 // where it does not allow a dropdown to be closed if focus was never within 56982 // the dropdown to begin with. Examples include a user either CMD+Clicking or 56983 // right clicking into an inactive window. 56984 // See: https://github.com/WordPress/gutenberg/pull/54083 56985 const open = !currentClientId ? undefined : openedBlockSettingsMenu === currentClientId || false; 56986 function onToggle(localOpen) { 56987 if (localOpen && openedBlockSettingsMenu !== currentClientId) { 56988 setOpenedBlockSettingsMenu(currentClientId); 56989 } else if (!localOpen && openedBlockSettingsMenu && openedBlockSettingsMenu === currentClientId) { 56990 setOpenedBlockSettingsMenu(undefined); 56991 } 56992 } 56993 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockActions, { 56994 clientIds: clientIds, 56995 __experimentalUpdateSelection: !__experimentalSelectBlock, 56996 children: ({ 56997 canCopyStyles, 56998 canDuplicate, 56999 canInsertBlock, 57000 canMove, 57001 canRemove, 57002 onDuplicate, 57003 onInsertAfter, 57004 onInsertBefore, 57005 onRemove, 57006 onCopy, 57007 onPasteStyles, 57008 onMoveTo 57009 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, { 57010 icon: more_vertical, 57011 label: (0,external_wp_i18n_namespaceObject.__)('Options'), 57012 className: "block-editor-block-settings-menu", 57013 popoverProps: block_settings_dropdown_POPOVER_PROPS, 57014 open: open, 57015 onToggle: onToggle, 57016 noIcons: true, 57017 ...props, 57018 children: ({ 57019 onClose 57020 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 57021 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, { 57022 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_menu_first_item.Slot, { 57023 fillProps: { 57024 onClose 57025 } 57026 }), !parentBlockIsSelected && !!firstParentClientId && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockParentSelectorMenuItem, { 57027 parentClientId: firstParentClientId, 57028 parentBlockType: parentBlockType 57029 }), count === 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_html_convert_button, { 57030 clientId: firstBlockClientId 57031 }), (!isContentOnly || isZoomOut) && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CopyMenuItem, { 57032 clientIds: clientIds, 57033 onCopy: onCopy, 57034 shortcut: external_wp_keycodes_namespaceObject.displayShortcut.primary('c') 57035 }), canDuplicate && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 57036 onClick: (0,external_wp_compose_namespaceObject.pipe)(onClose, onDuplicate, updateSelectionAfterDuplicate), 57037 shortcut: shortcuts.duplicate, 57038 children: (0,external_wp_i18n_namespaceObject.__)('Duplicate') 57039 }), canInsertBlock && !isContentOnly && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 57040 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 57041 onClick: (0,external_wp_compose_namespaceObject.pipe)(onClose, onInsertBefore), 57042 shortcut: shortcuts.insertBefore, 57043 children: (0,external_wp_i18n_namespaceObject.__)('Add before') 57044 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 57045 onClick: (0,external_wp_compose_namespaceObject.pipe)(onClose, onInsertAfter), 57046 shortcut: shortcuts.insertAfter, 57047 children: (0,external_wp_i18n_namespaceObject.__)('Add after') 57048 })] 57049 })] 57050 }), canCopyStyles && !isContentOnly && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, { 57051 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CopyMenuItem, { 57052 clientIds: clientIds, 57053 onCopy: onCopy, 57054 label: (0,external_wp_i18n_namespaceObject.__)('Copy styles') 57055 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 57056 onClick: onPasteStyles, 57057 children: (0,external_wp_i18n_namespaceObject.__)('Paste styles') 57058 })] 57059 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_menu_controls.Slot, { 57060 fillProps: { 57061 onClose, 57062 canMove, 57063 onMoveTo, 57064 onlyBlock, 57065 count, 57066 firstBlockClientId 57067 }, 57068 clientIds: clientIds 57069 }), typeof children === 'function' ? children({ 57070 onClose 57071 }) : external_wp_element_namespaceObject.Children.map(child => (0,external_wp_element_namespaceObject.cloneElement)(child, { 57072 onClose 57073 })), canRemove && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, { 57074 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 57075 onClick: (0,external_wp_compose_namespaceObject.pipe)(onClose, onRemove, updateSelectionAfterRemove), 57076 shortcut: shortcuts.remove, 57077 children: (0,external_wp_i18n_namespaceObject.__)('Delete') 57078 }) 57079 })] 57080 }) 57081 }) 57082 }); 57083 } 57084 /* harmony default export */ const block_settings_dropdown = (BlockSettingsDropdown); 57085 57086 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/index.js 57087 /** 57088 * WordPress dependencies 57089 */ 57090 57091 57092 /** 57093 * Internal dependencies 57094 */ 57095 57096 57097 function BlockSettingsMenu({ 57098 clientIds, 57099 ...props 57100 }) { 57101 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, { 57102 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, { 57103 children: toggleProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_dropdown, { 57104 clientIds: clientIds, 57105 toggleProps: toggleProps, 57106 ...props 57107 }) 57108 }) 57109 }); 57110 } 57111 /* harmony default export */ const block_settings_menu = (BlockSettingsMenu); 57112 57113 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-lock/toolbar.js 57114 /** 57115 * WordPress dependencies 57116 */ 57117 57118 57119 57120 57121 57122 /** 57123 * Internal dependencies 57124 */ 57125 57126 57127 57128 57129 57130 function BlockLockToolbar({ 57131 clientId 57132 }) { 57133 const { 57134 canLock, 57135 isLocked 57136 } = useBlockLock(clientId); 57137 const [isModalOpen, toggleModal] = (0,external_wp_element_namespaceObject.useReducer)(isActive => !isActive, false); 57138 const hasLockButtonShownRef = (0,external_wp_element_namespaceObject.useRef)(false); 57139 57140 // If the block lock button has been shown, we don't want to remove it 57141 // from the toolbar until the toolbar is rendered again without it. 57142 // Removing it beforehand can cause focus loss issues, such as when 57143 // unlocking the block from the modal. It needs to return focus from 57144 // whence it came, and to do that, we need to leave the button in the toolbar. 57145 (0,external_wp_element_namespaceObject.useEffect)(() => { 57146 if (isLocked) { 57147 hasLockButtonShownRef.current = true; 57148 } 57149 }, [isLocked]); 57150 if (!isLocked && !hasLockButtonShownRef.current) { 57151 return null; 57152 } 57153 let label = isLocked ? (0,external_wp_i18n_namespaceObject.__)('Unlock') : (0,external_wp_i18n_namespaceObject.__)('Lock'); 57154 if (!canLock && isLocked) { 57155 label = (0,external_wp_i18n_namespaceObject.__)('Locked'); 57156 } 57157 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 57158 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, { 57159 className: "block-editor-block-lock-toolbar", 57160 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 57161 disabled: !canLock, 57162 icon: isLocked ? library_lock : library_unlock, 57163 label: label, 57164 onClick: toggleModal, 57165 "aria-expanded": isModalOpen, 57166 "aria-haspopup": "dialog" 57167 }) 57168 }), isModalOpen && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockLockModal, { 57169 clientId: clientId, 57170 onClose: toggleModal 57171 })] 57172 }); 57173 } 57174 57175 ;// ./node_modules/@wordpress/icons/build-module/library/group.js 57176 /** 57177 * WordPress dependencies 57178 */ 57179 57180 57181 const group_group = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 57182 viewBox: "0 0 24 24", 57183 xmlns: "http://www.w3.org/2000/svg", 57184 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 57185 d: "M18 4h-7c-1.1 0-2 .9-2 2v3H6c-1.1 0-2 .9-2 2v7c0 1.1.9 2 2 2h7c1.1 0 2-.9 2-2v-3h3c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-4.5 14c0 .3-.2.5-.5.5H6c-.3 0-.5-.2-.5-.5v-7c0-.3.2-.5.5-.5h3V13c0 1.1.9 2 2 2h2.5v3zm0-4.5H11c-.3 0-.5-.2-.5-.5v-2.5H13c.3 0 .5.2.5.5v2.5zm5-.5c0 .3-.2.5-.5.5h-3V11c0-1.1-.9-2-2-2h-2.5V6c0-.3.2-.5.5-.5h7c.3 0 .5.2.5.5v7z" 57186 }) 57187 }); 57188 /* harmony default export */ const library_group = (group_group); 57189 57190 ;// ./node_modules/@wordpress/icons/build-module/library/row.js 57191 /** 57192 * WordPress dependencies 57193 */ 57194 57195 57196 const row = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 57197 xmlns: "http://www.w3.org/2000/svg", 57198 viewBox: "0 0 24 24", 57199 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 57200 d: "M4 6.5h5a2 2 0 0 1 2 2v7a2 2 0 0 1-2 2H4V16h5a.5.5 0 0 0 .5-.5v-7A.5.5 0 0 0 9 8H4V6.5Zm16 0h-5a2 2 0 0 0-2 2v7a2 2 0 0 0 2 2h5V16h-5a.5.5 0 0 1-.5-.5v-7A.5.5 0 0 1 15 8h5V6.5Z" 57201 }) 57202 }); 57203 /* harmony default export */ const library_row = (row); 57204 57205 ;// ./node_modules/@wordpress/icons/build-module/library/stack.js 57206 /** 57207 * WordPress dependencies 57208 */ 57209 57210 57211 const stack = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 57212 xmlns: "http://www.w3.org/2000/svg", 57213 viewBox: "0 0 24 24", 57214 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 57215 d: "M17.5 4v5a2 2 0 0 1-2 2h-7a2 2 0 0 1-2-2V4H8v5a.5.5 0 0 0 .5.5h7A.5.5 0 0 0 16 9V4h1.5Zm0 16v-5a2 2 0 0 0-2-2h-7a2 2 0 0 0-2 2v5H8v-5a.5.5 0 0 1 .5-.5h7a.5.5 0 0 1 .5.5v5h1.5Z" 57216 }) 57217 }); 57218 /* harmony default export */ const library_stack = (stack); 57219 57220 ;// ./node_modules/@wordpress/icons/build-module/library/grid.js 57221 /** 57222 * WordPress dependencies 57223 */ 57224 57225 57226 const grid_grid = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 57227 xmlns: "http://www.w3.org/2000/svg", 57228 viewBox: "0 0 24 24", 57229 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 57230 d: "m3 5c0-1.10457.89543-2 2-2h13.5c1.1046 0 2 .89543 2 2v13.5c0 1.1046-.8954 2-2 2h-13.5c-1.10457 0-2-.8954-2-2zm2-.5h6v6.5h-6.5v-6c0-.27614.22386-.5.5-.5zm-.5 8v6c0 .2761.22386.5.5.5h6v-6.5zm8 0v6.5h6c.2761 0 .5-.2239.5-.5v-6zm0-8v6.5h6.5v-6c0-.27614-.2239-.5-.5-.5z", 57231 fillRule: "evenodd", 57232 clipRule: "evenodd" 57233 }) 57234 }); 57235 /* harmony default export */ const library_grid = (grid_grid); 57236 57237 ;// ./node_modules/@wordpress/block-editor/build-module/components/convert-to-group-buttons/toolbar.js 57238 /** 57239 * WordPress dependencies 57240 */ 57241 57242 57243 57244 57245 57246 57247 /** 57248 * Internal dependencies 57249 */ 57250 57251 57252 57253 57254 const layouts = { 57255 group: { 57256 type: 'constrained' 57257 }, 57258 row: { 57259 type: 'flex', 57260 flexWrap: 'nowrap' 57261 }, 57262 stack: { 57263 type: 'flex', 57264 orientation: 'vertical' 57265 }, 57266 grid: { 57267 type: 'grid' 57268 } 57269 }; 57270 function BlockGroupToolbar() { 57271 const { 57272 blocksSelection, 57273 clientIds, 57274 groupingBlockName, 57275 isGroupable 57276 } = useConvertToGroupButtonProps(); 57277 const { 57278 replaceBlocks 57279 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 57280 const { 57281 canRemove, 57282 variations 57283 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 57284 const { 57285 canRemoveBlocks 57286 } = select(store); 57287 const { 57288 getBlockVariations 57289 } = select(external_wp_blocks_namespaceObject.store); 57290 return { 57291 canRemove: canRemoveBlocks(clientIds), 57292 variations: getBlockVariations(groupingBlockName, 'transform') 57293 }; 57294 }, [clientIds, groupingBlockName]); 57295 const onConvertToGroup = layout => { 57296 const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocksSelection, groupingBlockName); 57297 if (typeof layout !== 'string') { 57298 layout = 'group'; 57299 } 57300 if (newBlocks && newBlocks.length > 0) { 57301 // Because the block is not in the store yet we can't use 57302 // updateBlockAttributes so need to manually update attributes. 57303 newBlocks[0].attributes.layout = layouts[layout]; 57304 replaceBlocks(clientIds, newBlocks); 57305 } 57306 }; 57307 const onConvertToRow = () => onConvertToGroup('row'); 57308 const onConvertToStack = () => onConvertToGroup('stack'); 57309 const onConvertToGrid = () => onConvertToGroup('grid'); 57310 57311 // Don't render the button if the current selection cannot be grouped. 57312 // A good example is selecting multiple button blocks within a Buttons block: 57313 // The group block is not a valid child of Buttons, so we should not show the button. 57314 // Any blocks that are locked against removal also cannot be grouped. 57315 if (!isGroupable || !canRemove) { 57316 return null; 57317 } 57318 const canInsertRow = !!variations.find(({ 57319 name 57320 }) => name === 'group-row'); 57321 const canInsertStack = !!variations.find(({ 57322 name 57323 }) => name === 'group-stack'); 57324 const canInsertGrid = !!variations.find(({ 57325 name 57326 }) => name === 'group-grid'); 57327 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, { 57328 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 57329 icon: library_group, 57330 label: (0,external_wp_i18n_namespaceObject._x)('Group', 'verb'), 57331 onClick: onConvertToGroup 57332 }), canInsertRow && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 57333 icon: library_row, 57334 label: (0,external_wp_i18n_namespaceObject._x)('Row', 'single horizontal line'), 57335 onClick: onConvertToRow 57336 }), canInsertStack && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 57337 icon: library_stack, 57338 label: (0,external_wp_i18n_namespaceObject._x)('Stack', 'verb'), 57339 onClick: onConvertToStack 57340 }), canInsertGrid && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 57341 icon: library_grid, 57342 label: (0,external_wp_i18n_namespaceObject._x)('Grid', 'verb'), 57343 onClick: onConvertToGrid 57344 })] 57345 }); 57346 } 57347 /* harmony default export */ const toolbar = (BlockGroupToolbar); 57348 57349 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit-visually-button/index.js 57350 /** 57351 * WordPress dependencies 57352 */ 57353 57354 57355 57356 57357 /** 57358 * Internal dependencies 57359 */ 57360 57361 57362 function BlockEditVisuallyButton({ 57363 clientIds 57364 }) { 57365 // Edit visually only works for single block selection. 57366 const clientId = clientIds.length === 1 ? clientIds[0] : undefined; 57367 const canEditVisually = (0,external_wp_data_namespaceObject.useSelect)(select => !!clientId && select(store).getBlockMode(clientId) === 'html', [clientId]); 57368 const { 57369 toggleBlockMode 57370 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 57371 if (!canEditVisually) { 57372 return null; 57373 } 57374 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, { 57375 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 57376 onClick: () => { 57377 toggleBlockMode(clientId); 57378 }, 57379 children: (0,external_wp_i18n_namespaceObject.__)('Edit visually') 57380 }) 57381 }); 57382 } 57383 57384 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/block-name-context.js 57385 /** 57386 * WordPress dependencies 57387 */ 57388 57389 const __unstableBlockNameContext = (0,external_wp_element_namespaceObject.createContext)(''); 57390 /* harmony default export */ const block_name_context = (__unstableBlockNameContext); 57391 57392 ;// ./node_modules/@wordpress/block-editor/build-module/components/navigable-toolbar/index.js 57393 /** 57394 * WordPress dependencies 57395 */ 57396 57397 57398 57399 57400 57401 57402 57403 57404 /** 57405 * Internal dependencies 57406 */ 57407 57408 57409 57410 function hasOnlyToolbarItem(elements) { 57411 const dataProp = 'toolbarItem'; 57412 return !elements.some(element => !(dataProp in element.dataset)); 57413 } 57414 function getAllFocusableToolbarItemsIn(container) { 57415 return Array.from(container.querySelectorAll('[data-toolbar-item]:not([disabled])')); 57416 } 57417 function hasFocusWithin(container) { 57418 return container.contains(container.ownerDocument.activeElement); 57419 } 57420 function focusFirstTabbableIn(container) { 57421 const [firstTabbable] = external_wp_dom_namespaceObject.focus.tabbable.find(container); 57422 if (firstTabbable) { 57423 firstTabbable.focus({ 57424 // When focusing newly mounted toolbars, 57425 // the position of the popover is often not right on the first render 57426 // This prevents the layout shifts when focusing the dialogs. 57427 preventScroll: true 57428 }); 57429 } 57430 } 57431 function useIsAccessibleToolbar(toolbarRef) { 57432 /* 57433 * By default, we'll assume the starting accessible state of the Toolbar 57434 * is true, as it seems to be the most common case. 57435 * 57436 * Transitioning from an (initial) false to true state causes the 57437 * <Toolbar /> component to mount twice, which is causing undesired 57438 * side-effects. These side-effects appear to only affect certain 57439 * E2E tests. 57440 * 57441 * This was initial discovered in this pull-request: 57442 * https://github.com/WordPress/gutenberg/pull/23425 57443 */ 57444 const initialAccessibleToolbarState = true; 57445 57446 // By default, it's gonna render NavigableMenu. If all the tabbable elements 57447 // inside the toolbar are ToolbarItem components (or derived components like 57448 // ToolbarButton), then we can wrap them with the accessible Toolbar 57449 // component. 57450 const [isAccessibleToolbar, setIsAccessibleToolbar] = (0,external_wp_element_namespaceObject.useState)(initialAccessibleToolbarState); 57451 const determineIsAccessibleToolbar = (0,external_wp_element_namespaceObject.useCallback)(() => { 57452 const tabbables = external_wp_dom_namespaceObject.focus.tabbable.find(toolbarRef.current); 57453 const onlyToolbarItem = hasOnlyToolbarItem(tabbables); 57454 if (!onlyToolbarItem) { 57455 external_wp_deprecated_default()('Using custom components as toolbar controls', { 57456 since: '5.6', 57457 alternative: 'ToolbarItem, ToolbarButton or ToolbarDropdownMenu components', 57458 link: 'https://developer.wordpress.org/block-editor/components/toolbar-button/#inside-blockcontrols' 57459 }); 57460 } 57461 setIsAccessibleToolbar(onlyToolbarItem); 57462 }, [toolbarRef]); 57463 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 57464 // Toolbar buttons may be rendered asynchronously, so we use 57465 // MutationObserver to check if the toolbar subtree has been modified. 57466 const observer = new window.MutationObserver(determineIsAccessibleToolbar); 57467 observer.observe(toolbarRef.current, { 57468 childList: true, 57469 subtree: true 57470 }); 57471 return () => observer.disconnect(); 57472 }, [determineIsAccessibleToolbar, isAccessibleToolbar, toolbarRef]); 57473 return isAccessibleToolbar; 57474 } 57475 function useToolbarFocus({ 57476 toolbarRef, 57477 focusOnMount, 57478 isAccessibleToolbar, 57479 defaultIndex, 57480 onIndexChange, 57481 shouldUseKeyboardFocusShortcut, 57482 focusEditorOnEscape 57483 }) { 57484 // Make sure we don't use modified versions of this prop. 57485 const [initialFocusOnMount] = (0,external_wp_element_namespaceObject.useState)(focusOnMount); 57486 const [initialIndex] = (0,external_wp_element_namespaceObject.useState)(defaultIndex); 57487 const focusToolbar = (0,external_wp_element_namespaceObject.useCallback)(() => { 57488 focusFirstTabbableIn(toolbarRef.current); 57489 }, [toolbarRef]); 57490 const focusToolbarViaShortcut = () => { 57491 if (shouldUseKeyboardFocusShortcut) { 57492 focusToolbar(); 57493 } 57494 }; 57495 57496 // Focus on toolbar when pressing alt+F10 when the toolbar is visible. 57497 (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/block-editor/focus-toolbar', focusToolbarViaShortcut); 57498 (0,external_wp_element_namespaceObject.useEffect)(() => { 57499 if (initialFocusOnMount) { 57500 focusToolbar(); 57501 } 57502 }, [isAccessibleToolbar, initialFocusOnMount, focusToolbar]); 57503 (0,external_wp_element_namespaceObject.useEffect)(() => { 57504 // Store ref so we have access on useEffect cleanup: https://legacy.reactjs.org/blog/2020/08/10/react-v17-rc.html#effect-cleanup-timing 57505 const navigableToolbarRef = toolbarRef.current; 57506 // If initialIndex is passed, we focus on that toolbar item when the 57507 // toolbar gets mounted and initial focus is not forced. 57508 // We have to wait for the next browser paint because block controls aren't 57509 // rendered right away when the toolbar gets mounted. 57510 let raf = 0; 57511 57512 // If the toolbar already had focus before the render, we don't want to move it. 57513 // https://github.com/WordPress/gutenberg/issues/58511 57514 if (!initialFocusOnMount && !hasFocusWithin(navigableToolbarRef)) { 57515 raf = window.requestAnimationFrame(() => { 57516 const items = getAllFocusableToolbarItemsIn(navigableToolbarRef); 57517 const index = initialIndex || 0; 57518 if (items[index] && hasFocusWithin(navigableToolbarRef)) { 57519 items[index].focus({ 57520 // When focusing newly mounted toolbars, 57521 // the position of the popover is often not right on the first render 57522 // This prevents the layout shifts when focusing the dialogs. 57523 preventScroll: true 57524 }); 57525 } 57526 }); 57527 } 57528 return () => { 57529 window.cancelAnimationFrame(raf); 57530 if (!onIndexChange || !navigableToolbarRef) { 57531 return; 57532 } 57533 // When the toolbar element is unmounted and onIndexChange is passed, we 57534 // pass the focused toolbar item index so it can be hydrated later. 57535 const items = getAllFocusableToolbarItemsIn(navigableToolbarRef); 57536 const index = items.findIndex(item => item.tabIndex === 0); 57537 onIndexChange(index); 57538 }; 57539 }, [initialIndex, initialFocusOnMount, onIndexChange, toolbarRef]); 57540 const { 57541 getLastFocus 57542 } = unlock((0,external_wp_data_namespaceObject.useSelect)(store)); 57543 /** 57544 * Handles returning focus to the block editor canvas when pressing escape. 57545 */ 57546 (0,external_wp_element_namespaceObject.useEffect)(() => { 57547 const navigableToolbarRef = toolbarRef.current; 57548 if (focusEditorOnEscape) { 57549 const handleKeyDown = event => { 57550 const lastFocus = getLastFocus(); 57551 if (event.keyCode === external_wp_keycodes_namespaceObject.ESCAPE && lastFocus?.current) { 57552 // Focus the last focused element when pressing escape. 57553 event.preventDefault(); 57554 lastFocus.current.focus(); 57555 } 57556 }; 57557 navigableToolbarRef.addEventListener('keydown', handleKeyDown); 57558 return () => { 57559 navigableToolbarRef.removeEventListener('keydown', handleKeyDown); 57560 }; 57561 } 57562 }, [focusEditorOnEscape, getLastFocus, toolbarRef]); 57563 } 57564 function NavigableToolbar({ 57565 children, 57566 focusOnMount, 57567 focusEditorOnEscape = false, 57568 shouldUseKeyboardFocusShortcut = true, 57569 __experimentalInitialIndex: initialIndex, 57570 __experimentalOnIndexChange: onIndexChange, 57571 orientation = 'horizontal', 57572 ...props 57573 }) { 57574 const toolbarRef = (0,external_wp_element_namespaceObject.useRef)(); 57575 const isAccessibleToolbar = useIsAccessibleToolbar(toolbarRef); 57576 useToolbarFocus({ 57577 toolbarRef, 57578 focusOnMount, 57579 defaultIndex: initialIndex, 57580 onIndexChange, 57581 isAccessibleToolbar, 57582 shouldUseKeyboardFocusShortcut, 57583 focusEditorOnEscape 57584 }); 57585 if (isAccessibleToolbar) { 57586 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Toolbar, { 57587 label: props['aria-label'], 57588 ref: toolbarRef, 57589 orientation: orientation, 57590 ...props, 57591 children: children 57592 }); 57593 } 57594 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.NavigableMenu, { 57595 orientation: orientation, 57596 role: "toolbar", 57597 ref: toolbarRef, 57598 ...props, 57599 children: children 57600 }); 57601 } 57602 57603 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/use-has-block-controls.js 57604 /** 57605 * WordPress dependencies 57606 */ 57607 57608 57609 57610 /** 57611 * Internal dependencies 57612 */ 57613 57614 function useHasAnyBlockControls() { 57615 let hasAnyBlockControls = false; 57616 for (const group in block_controls_groups) { 57617 // It is safe to violate the rules of hooks here as the `groups` object 57618 // is static and will not change length between renders. Do not return 57619 // early as that will cause the hook to be called a different number of 57620 // times between renders. 57621 // eslint-disable-next-line react-hooks/rules-of-hooks 57622 if (useHasBlockControls(group)) { 57623 hasAnyBlockControls = true; 57624 } 57625 } 57626 return hasAnyBlockControls; 57627 } 57628 function useHasBlockControls(group = 'default') { 57629 const Slot = block_controls_groups[group]?.Slot; 57630 const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(Slot?.__unstableName); 57631 if (!Slot) { 57632 true ? external_wp_warning_default()(`Unknown BlockControls group "$group}" provided.`) : 0; 57633 return null; 57634 } 57635 return !!fills?.length; 57636 } 57637 57638 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/use-has-block-toolbar.js 57639 /** 57640 * WordPress dependencies 57641 */ 57642 57643 57644 /** 57645 * Internal dependencies 57646 */ 57647 57648 57649 57650 /** 57651 * Returns true if the block toolbar should be shown. 57652 * 57653 * @return {boolean} Whether the block toolbar component will be rendered. 57654 */ 57655 function useHasBlockToolbar() { 57656 const { 57657 isToolbarEnabled, 57658 isBlockDisabled 57659 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 57660 const { 57661 getBlockEditingMode, 57662 getBlockName, 57663 getBlockSelectionStart 57664 } = select(store); 57665 57666 // we only care about the 1st selected block 57667 // for the toolbar, so we use getBlockSelectionStart 57668 // instead of getSelectedBlockClientIds 57669 const selectedBlockClientId = getBlockSelectionStart(); 57670 const blockType = selectedBlockClientId && (0,external_wp_blocks_namespaceObject.getBlockType)(getBlockName(selectedBlockClientId)); 57671 return { 57672 isToolbarEnabled: blockType && (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, '__experimentalToolbar', true), 57673 isBlockDisabled: getBlockEditingMode(selectedBlockClientId) === 'disabled' 57674 }; 57675 }, []); 57676 const hasAnyBlockControls = useHasAnyBlockControls(); 57677 if (!isToolbarEnabled || isBlockDisabled && !hasAnyBlockControls) { 57678 return false; 57679 } 57680 return true; 57681 } 57682 57683 ;// ./node_modules/@wordpress/icons/build-module/library/shuffle.js 57684 /** 57685 * WordPress dependencies 57686 */ 57687 57688 57689 const shuffle = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 57690 viewBox: "0 0 24 24", 57691 xmlns: "http://www.w3.org/2000/SVG", 57692 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 57693 d: "M17.192 6.75L15.47 5.03l1.06-1.06 3.537 3.53-3.537 3.53-1.06-1.06 1.723-1.72h-3.19c-.602 0-.993.202-1.28.498-.309.319-.538.792-.695 1.383-.13.488-.222 1.023-.296 1.508-.034.664-.116 1.413-.303 2.117-.193.721-.513 1.467-1.068 2.04-.575.594-1.359.954-2.357.954H4v-1.5h4.003c.601 0 .993-.202 1.28-.498.308-.319.538-.792.695-1.383.149-.557.216-1.093.288-1.662l.039-.31a9.653 9.653 0 0 1 .272-1.653c.193-.722.513-1.467 1.067-2.04.576-.594 1.36-.954 2.358-.954h3.19zM8.004 6.75c.8 0 1.46.23 1.988.628a6.24 6.24 0 0 0-.684 1.396 1.725 1.725 0 0 0-.024-.026c-.287-.296-.679-.498-1.28-.498H4v-1.5h4.003zM12.699 14.726c-.161.459-.38.94-.684 1.396.527.397 1.188.628 1.988.628h3.19l-1.722 1.72 1.06 1.06L20.067 16l-3.537-3.53-1.06 1.06 1.723 1.72h-3.19c-.602 0-.993-.202-1.28-.498a1.96 1.96 0 0 1-.024-.026z" 57694 }) 57695 }); 57696 /* harmony default export */ const library_shuffle = (shuffle); 57697 57698 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/shuffle.js 57699 /** 57700 * WordPress dependencies 57701 */ 57702 57703 57704 57705 57706 57707 57708 /** 57709 * Internal dependencies 57710 */ 57711 57712 57713 const shuffle_EMPTY_ARRAY = []; 57714 function shuffle_Container(props) { 57715 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, { 57716 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 57717 ...props 57718 }) 57719 }); 57720 } 57721 function Shuffle({ 57722 clientId, 57723 as = shuffle_Container 57724 }) { 57725 const { 57726 categories, 57727 patterns, 57728 patternName 57729 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 57730 const { 57731 getBlockAttributes, 57732 getBlockRootClientId, 57733 __experimentalGetAllowedPatterns 57734 } = select(store); 57735 const attributes = getBlockAttributes(clientId); 57736 const _categories = attributes?.metadata?.categories || shuffle_EMPTY_ARRAY; 57737 const _patternName = attributes?.metadata?.patternName; 57738 const rootBlock = getBlockRootClientId(clientId); 57739 57740 // Calling `__experimentalGetAllowedPatterns` is expensive. 57741 // Checking if the block can be shuffled prevents unnecessary selector calls. 57742 // See: https://github.com/WordPress/gutenberg/pull/64736. 57743 const _patterns = _categories.length > 0 ? __experimentalGetAllowedPatterns(rootBlock) : shuffle_EMPTY_ARRAY; 57744 return { 57745 categories: _categories, 57746 patterns: _patterns, 57747 patternName: _patternName 57748 }; 57749 }, [clientId]); 57750 const { 57751 replaceBlocks 57752 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 57753 const sameCategoryPatternsWithSingleWrapper = (0,external_wp_element_namespaceObject.useMemo)(() => { 57754 if (categories.length === 0 || !patterns || patterns.length === 0) { 57755 return shuffle_EMPTY_ARRAY; 57756 } 57757 return patterns.filter(pattern => { 57758 const isCorePattern = pattern.source === 'core' || pattern.source?.startsWith('pattern-directory') && pattern.source !== 'pattern-directory/theme'; 57759 return ( 57760 // Check if the pattern has only one top level block, 57761 // otherwise we may shuffle to pattern that will not allow to continue shuffling. 57762 pattern.blocks.length === 1 && 57763 // We exclude the core patterns and pattern directory patterns that are not theme patterns. 57764 !isCorePattern && pattern.categories?.some(category => { 57765 return categories.includes(category); 57766 }) && ( 57767 // Check if the pattern is not a synced pattern. 57768 pattern.syncStatus === 'unsynced' || !pattern.id) 57769 ); 57770 }); 57771 }, [categories, patterns]); 57772 if (sameCategoryPatternsWithSingleWrapper.length < 2) { 57773 return null; 57774 } 57775 function getNextPattern() { 57776 const numberOfPatterns = sameCategoryPatternsWithSingleWrapper.length; 57777 const patternIndex = sameCategoryPatternsWithSingleWrapper.findIndex(({ 57778 name 57779 }) => name === patternName); 57780 const nextPatternIndex = patternIndex + 1 < numberOfPatterns ? patternIndex + 1 : 0; 57781 return sameCategoryPatternsWithSingleWrapper[nextPatternIndex]; 57782 } 57783 const ComponentToUse = as; 57784 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ComponentToUse, { 57785 label: (0,external_wp_i18n_namespaceObject.__)('Shuffle'), 57786 icon: library_shuffle, 57787 className: "block-editor-block-toolbar-shuffle", 57788 onClick: () => { 57789 const nextPattern = getNextPattern(); 57790 nextPattern.blocks[0].attributes = { 57791 ...nextPattern.blocks[0].attributes, 57792 metadata: { 57793 ...nextPattern.blocks[0].attributes.metadata, 57794 categories 57795 } 57796 }; 57797 replaceBlocks(clientId, nextPattern.blocks); 57798 } 57799 }); 57800 } 57801 57802 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/index.js 57803 /** 57804 * External dependencies 57805 */ 57806 57807 57808 /** 57809 * WordPress dependencies 57810 */ 57811 57812 57813 57814 57815 57816 57817 57818 /** 57819 * Internal dependencies 57820 */ 57821 57822 57823 57824 57825 57826 57827 57828 57829 57830 57831 57832 57833 57834 57835 57836 57837 57838 /** 57839 * Renders the block toolbar. 57840 * 57841 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-toolbar/README.md 57842 * 57843 * @param {Object} props Components props. 57844 * @param {boolean} props.hideDragHandle Show or hide the Drag Handle for drag and drop functionality. 57845 * @param {boolean} props.focusOnMount Focus the toolbar when mounted. 57846 * @param {number} props.__experimentalInitialIndex The initial index of the toolbar item to focus. 57847 * @param {Function} props.__experimentalOnIndexChange Callback function to be called when the index of the focused toolbar item changes. 57848 * @param {string} props.variant Style variant of the toolbar, also passed to the Dropdowns rendered from Block Toolbar Buttons. 57849 */ 57850 57851 57852 57853 function PrivateBlockToolbar({ 57854 hideDragHandle, 57855 focusOnMount, 57856 __experimentalInitialIndex, 57857 __experimentalOnIndexChange, 57858 variant = 'unstyled' 57859 }) { 57860 const { 57861 blockClientId, 57862 blockClientIds, 57863 isDefaultEditingMode, 57864 blockType, 57865 toolbarKey, 57866 shouldShowVisualToolbar, 57867 showParentSelector, 57868 isUsingBindings, 57869 hasParentPattern, 57870 hasContentOnlyLocking, 57871 showShuffleButton, 57872 showSlots, 57873 showGroupButtons, 57874 showLockButtons 57875 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 57876 const { 57877 getBlockName, 57878 getBlockMode, 57879 getBlockParents, 57880 getSelectedBlockClientIds, 57881 isBlockValid, 57882 getBlockEditingMode, 57883 getBlockAttributes, 57884 getBlockParentsByBlockName, 57885 getTemplateLock, 57886 isZoomOutMode 57887 } = unlock(select(store)); 57888 const selectedBlockClientIds = getSelectedBlockClientIds(); 57889 const selectedBlockClientId = selectedBlockClientIds[0]; 57890 const parents = getBlockParents(selectedBlockClientId); 57891 const firstParentClientId = parents[parents.length - 1]; 57892 const parentBlockName = getBlockName(firstParentClientId); 57893 const parentBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(parentBlockName); 57894 const editingMode = getBlockEditingMode(selectedBlockClientId); 57895 const _isDefaultEditingMode = editingMode === 'default'; 57896 const _blockName = getBlockName(selectedBlockClientId); 57897 const isValid = selectedBlockClientIds.every(id => isBlockValid(id)); 57898 const isVisual = selectedBlockClientIds.every(id => getBlockMode(id) === 'visual'); 57899 const _isUsingBindings = selectedBlockClientIds.every(clientId => !!getBlockAttributes(clientId)?.metadata?.bindings); 57900 const _hasParentPattern = selectedBlockClientIds.every(clientId => getBlockParentsByBlockName(clientId, 'core/block', true).length > 0); 57901 57902 // If one or more selected blocks are locked, do not show the BlockGroupToolbar. 57903 const _hasTemplateLock = selectedBlockClientIds.some(id => getTemplateLock(id) === 'contentOnly'); 57904 return { 57905 blockClientId: selectedBlockClientId, 57906 blockClientIds: selectedBlockClientIds, 57907 isDefaultEditingMode: _isDefaultEditingMode, 57908 blockType: selectedBlockClientId && (0,external_wp_blocks_namespaceObject.getBlockType)(_blockName), 57909 shouldShowVisualToolbar: isValid && isVisual, 57910 toolbarKey: `$selectedBlockClientId}$firstParentClientId}`, 57911 showParentSelector: !isZoomOutMode() && parentBlockType && getBlockEditingMode(firstParentClientId) === 'default' && (0,external_wp_blocks_namespaceObject.hasBlockSupport)(parentBlockType, '__experimentalParentSelector', true) && selectedBlockClientIds.length === 1 && _isDefaultEditingMode, 57912 isUsingBindings: _isUsingBindings, 57913 hasParentPattern: _hasParentPattern, 57914 hasContentOnlyLocking: _hasTemplateLock, 57915 showShuffleButton: isZoomOutMode(), 57916 showSlots: !isZoomOutMode(), 57917 showGroupButtons: !isZoomOutMode(), 57918 showLockButtons: !isZoomOutMode() 57919 }; 57920 }, []); 57921 const toolbarWrapperRef = (0,external_wp_element_namespaceObject.useRef)(null); 57922 57923 // Handles highlighting the current block outline on hover or focus of the 57924 // block type toolbar area. 57925 const nodeRef = (0,external_wp_element_namespaceObject.useRef)(); 57926 const showHoveredOrFocusedGestures = useShowHoveredOrFocusedGestures({ 57927 ref: nodeRef 57928 }); 57929 const isLargeViewport = !(0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<'); 57930 const hasBlockToolbar = useHasBlockToolbar(); 57931 if (!hasBlockToolbar) { 57932 return null; 57933 } 57934 const isMultiToolbar = blockClientIds.length > 1; 57935 const isSynced = (0,external_wp_blocks_namespaceObject.isReusableBlock)(blockType) || (0,external_wp_blocks_namespaceObject.isTemplatePart)(blockType); 57936 57937 // Shifts the toolbar to make room for the parent block selector. 57938 const classes = dist_clsx('block-editor-block-contextual-toolbar', { 57939 'has-parent': showParentSelector 57940 }); 57941 const innerClasses = dist_clsx('block-editor-block-toolbar', { 57942 'is-synced': isSynced, 57943 'is-connected': isUsingBindings 57944 }); 57945 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigableToolbar, { 57946 focusEditorOnEscape: true, 57947 className: classes 57948 /* translators: accessibility text for the block toolbar */, 57949 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Block tools') 57950 // The variant is applied as "toolbar" when undefined, which is the black border style of the dropdown from the toolbar popover. 57951 , 57952 variant: variant === 'toolbar' ? undefined : variant, 57953 focusOnMount: focusOnMount, 57954 __experimentalInitialIndex: __experimentalInitialIndex, 57955 __experimentalOnIndexChange: __experimentalOnIndexChange 57956 // Resets the index whenever the active block changes so 57957 // this is not persisted. See https://github.com/WordPress/gutenberg/pull/25760#issuecomment-717906169 57958 , 57959 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 57960 ref: toolbarWrapperRef, 57961 className: innerClasses, 57962 children: [showParentSelector && !isMultiToolbar && isLargeViewport && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockParentSelector, {}), (shouldShowVisualToolbar || isMultiToolbar) && !hasParentPattern && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 57963 ref: nodeRef, 57964 ...showHoveredOrFocusedGestures, 57965 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, { 57966 className: "block-editor-block-toolbar__block-controls", 57967 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_switcher, { 57968 clientIds: blockClientIds, 57969 disabled: !isDefaultEditingMode, 57970 isUsingBindings: isUsingBindings 57971 }), !isMultiToolbar && showLockButtons && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockLockToolbar, { 57972 clientId: blockClientId 57973 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_mover, { 57974 clientIds: blockClientIds, 57975 hideDragHandle: hideDragHandle 57976 })] 57977 }) 57978 }), !hasContentOnlyLocking && shouldShowVisualToolbar && isMultiToolbar && showGroupButtons && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(toolbar, {}), showShuffleButton && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, { 57979 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Shuffle, { 57980 clientId: blockClientIds[0], 57981 as: external_wp_components_namespaceObject.ToolbarButton 57982 }) 57983 }), shouldShowVisualToolbar && showSlots && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 57984 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, { 57985 group: "parent", 57986 className: "block-editor-block-toolbar__slot" 57987 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, { 57988 group: "block", 57989 className: "block-editor-block-toolbar__slot" 57990 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, { 57991 className: "block-editor-block-toolbar__slot" 57992 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, { 57993 group: "inline", 57994 className: "block-editor-block-toolbar__slot" 57995 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, { 57996 group: "other", 57997 className: "block-editor-block-toolbar__slot" 57998 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_name_context.Provider, { 57999 value: blockType?.name, 58000 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_toolbar_last_item.Slot, {}) 58001 })] 58002 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEditVisuallyButton, { 58003 clientIds: blockClientIds 58004 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_menu, { 58005 clientIds: blockClientIds 58006 })] 58007 }) 58008 }, toolbarKey); 58009 } 58010 58011 /** 58012 * Renders the block toolbar. 58013 * 58014 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-toolbar/README.md 58015 * 58016 * @param {Object} props Components props. 58017 * @param {boolean} props.hideDragHandle Show or hide the Drag Handle for drag and drop functionality. 58018 * @param {string} props.variant Style variant of the toolbar, also passed to the Dropdowns rendered from Block Toolbar Buttons. 58019 */ 58020 function BlockToolbar({ 58021 hideDragHandle, 58022 variant 58023 }) { 58024 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockToolbar, { 58025 hideDragHandle: hideDragHandle, 58026 variant: variant, 58027 focusOnMount: undefined, 58028 __experimentalInitialIndex: undefined, 58029 __experimentalOnIndexChange: undefined 58030 }); 58031 } 58032 58033 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/block-toolbar-popover.js 58034 /** 58035 * External dependencies 58036 */ 58037 58038 /** 58039 * WordPress dependencies 58040 */ 58041 58042 58043 58044 /** 58045 * Internal dependencies 58046 */ 58047 58048 58049 58050 58051 58052 58053 function BlockToolbarPopover({ 58054 clientId, 58055 isTyping, 58056 __unstableContentRef 58057 }) { 58058 const { 58059 capturingClientId, 58060 isInsertionPointVisible, 58061 lastClientId 58062 } = useSelectedBlockToolProps(clientId); 58063 58064 // Stores the active toolbar item index so the block toolbar can return focus 58065 // to it when re-mounting. 58066 const initialToolbarItemIndexRef = (0,external_wp_element_namespaceObject.useRef)(); 58067 (0,external_wp_element_namespaceObject.useEffect)(() => { 58068 // Resets the index whenever the active block changes so this is not 58069 // persisted. See https://github.com/WordPress/gutenberg/pull/25760#issuecomment-717906169 58070 initialToolbarItemIndexRef.current = undefined; 58071 }, [clientId]); 58072 const { 58073 stopTyping 58074 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 58075 const isToolbarForcedRef = (0,external_wp_element_namespaceObject.useRef)(false); 58076 (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/block-editor/focus-toolbar', () => { 58077 isToolbarForcedRef.current = true; 58078 stopTyping(true); 58079 }); 58080 (0,external_wp_element_namespaceObject.useEffect)(() => { 58081 isToolbarForcedRef.current = false; 58082 }); 58083 58084 // If the block has a parent with __experimentalCaptureToolbars enabled, 58085 // the toolbar should be positioned over the topmost capturing parent. 58086 const clientIdToPositionOver = capturingClientId || clientId; 58087 const popoverProps = useBlockToolbarPopoverProps({ 58088 contentElement: __unstableContentRef?.current, 58089 clientId: clientIdToPositionOver 58090 }); 58091 return !isTyping && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_popover, { 58092 clientId: clientIdToPositionOver, 58093 bottomClientId: lastClientId, 58094 className: dist_clsx('block-editor-block-list__block-popover', { 58095 'is-insertion-point-visible': isInsertionPointVisible 58096 }), 58097 resize: false, 58098 ...popoverProps, 58099 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockToolbar 58100 // If the toolbar is being shown because of being forced 58101 // it should focus the toolbar right after the mount. 58102 , { 58103 focusOnMount: isToolbarForcedRef.current, 58104 __experimentalInitialIndex: initialToolbarItemIndexRef.current, 58105 __experimentalOnIndexChange: index => { 58106 initialToolbarItemIndexRef.current = index; 58107 }, 58108 variant: "toolbar" 58109 }) 58110 }); 58111 } 58112 58113 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/block-selection-button.js 58114 /** 58115 * External dependencies 58116 */ 58117 58118 58119 /** 58120 * WordPress dependencies 58121 */ 58122 58123 58124 58125 58126 58127 58128 58129 58130 58131 58132 /** 58133 * Internal dependencies 58134 */ 58135 58136 58137 58138 58139 58140 58141 /** 58142 * Block selection button component, displaying the label of the block. If the block 58143 * descends from a root block, a button is displayed enabling the user to select 58144 * the root block. 58145 * 58146 * @param {string} props Component props. 58147 * @param {string} props.clientId Client ID of block. 58148 * @param {Object} ref Reference to the component. 58149 * 58150 * @return {Component} The component to be rendered. 58151 */ 58152 58153 58154 function BlockSelectionButton({ 58155 clientId, 58156 rootClientId 58157 }, ref) { 58158 const selected = (0,external_wp_data_namespaceObject.useSelect)(select => { 58159 const { 58160 getBlock, 58161 getBlockIndex, 58162 hasBlockMovingClientId, 58163 getBlockListSettings, 58164 __unstableGetEditorMode, 58165 getNextBlockClientId, 58166 getPreviousBlockClientId, 58167 canMoveBlock 58168 } = select(store); 58169 const { 58170 getActiveBlockVariation, 58171 getBlockType 58172 } = select(external_wp_blocks_namespaceObject.store); 58173 const index = getBlockIndex(clientId); 58174 const { 58175 name, 58176 attributes 58177 } = getBlock(clientId); 58178 const blockType = getBlockType(name); 58179 const orientation = getBlockListSettings(rootClientId)?.orientation; 58180 const match = getActiveBlockVariation(name, attributes); 58181 return { 58182 blockMovingMode: hasBlockMovingClientId(), 58183 editorMode: __unstableGetEditorMode(), 58184 icon: match?.icon || blockType.icon, 58185 label: (0,external_wp_blocks_namespaceObject.__experimentalGetAccessibleBlockLabel)(blockType, attributes, index + 1, orientation), 58186 canMove: canMoveBlock(clientId, rootClientId), 58187 getNextBlockClientId, 58188 getPreviousBlockClientId 58189 }; 58190 }, [clientId, rootClientId]); 58191 const { 58192 label, 58193 icon, 58194 blockMovingMode, 58195 editorMode, 58196 canMove 58197 } = selected; 58198 const { 58199 setNavigationMode, 58200 removeBlock 58201 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 58202 58203 // Focus the breadcrumb in navigation mode. 58204 (0,external_wp_element_namespaceObject.useEffect)(() => { 58205 if (editorMode === 'navigation') { 58206 ref.current.focus(); 58207 (0,external_wp_a11y_namespaceObject.speak)(label); 58208 } 58209 }, [label, editorMode]); 58210 const blockElement = useBlockElement(clientId); 58211 const { 58212 hasBlockMovingClientId, 58213 getBlockIndex, 58214 getBlockRootClientId, 58215 getClientIdsOfDescendants, 58216 getSelectedBlockClientId, 58217 getMultiSelectedBlocksEndClientId, 58218 getPreviousBlockClientId, 58219 getNextBlockClientId 58220 } = (0,external_wp_data_namespaceObject.useSelect)(store); 58221 const { 58222 selectBlock, 58223 clearSelectedBlock, 58224 setBlockMovingClientId, 58225 moveBlockToPosition 58226 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 58227 function onKeyDown(event) { 58228 const { 58229 keyCode 58230 } = event; 58231 const isUp = keyCode === external_wp_keycodes_namespaceObject.UP; 58232 const isDown = keyCode === external_wp_keycodes_namespaceObject.DOWN; 58233 const isLeft = keyCode === external_wp_keycodes_namespaceObject.LEFT; 58234 const isRight = keyCode === external_wp_keycodes_namespaceObject.RIGHT; 58235 const isTab = keyCode === external_wp_keycodes_namespaceObject.TAB; 58236 const isEscape = keyCode === external_wp_keycodes_namespaceObject.ESCAPE; 58237 const isEnter = keyCode === external_wp_keycodes_namespaceObject.ENTER; 58238 const isSpace = keyCode === external_wp_keycodes_namespaceObject.SPACE; 58239 const isShift = event.shiftKey; 58240 if (keyCode === external_wp_keycodes_namespaceObject.BACKSPACE || keyCode === external_wp_keycodes_namespaceObject.DELETE) { 58241 removeBlock(clientId); 58242 event.preventDefault(); 58243 return; 58244 } 58245 const selectedBlockClientId = getSelectedBlockClientId(); 58246 const selectionEndClientId = getMultiSelectedBlocksEndClientId(); 58247 const selectionBeforeEndClientId = getPreviousBlockClientId(selectionEndClientId || selectedBlockClientId); 58248 const selectionAfterEndClientId = getNextBlockClientId(selectionEndClientId || selectedBlockClientId); 58249 const navigateUp = isTab && isShift || isUp; 58250 const navigateDown = isTab && !isShift || isDown; 58251 // Move out of current nesting level (no effect if at root level). 58252 const navigateOut = isLeft; 58253 // Move into next nesting level (no effect if the current block has no innerBlocks). 58254 const navigateIn = isRight; 58255 let focusedBlockUid; 58256 if (navigateUp) { 58257 focusedBlockUid = selectionBeforeEndClientId; 58258 } else if (navigateDown) { 58259 focusedBlockUid = selectionAfterEndClientId; 58260 } else if (navigateOut) { 58261 var _getBlockRootClientId; 58262 focusedBlockUid = (_getBlockRootClientId = getBlockRootClientId(selectedBlockClientId)) !== null && _getBlockRootClientId !== void 0 ? _getBlockRootClientId : selectedBlockClientId; 58263 } else if (navigateIn) { 58264 var _getClientIdsOfDescen; 58265 focusedBlockUid = (_getClientIdsOfDescen = getClientIdsOfDescendants(selectedBlockClientId)[0]) !== null && _getClientIdsOfDescen !== void 0 ? _getClientIdsOfDescen : selectedBlockClientId; 58266 } 58267 const startingBlockClientId = hasBlockMovingClientId(); 58268 if (isEscape && startingBlockClientId && !event.defaultPrevented) { 58269 setBlockMovingClientId(null); 58270 event.preventDefault(); 58271 } 58272 if ((isEnter || isSpace) && startingBlockClientId) { 58273 const sourceRoot = getBlockRootClientId(startingBlockClientId); 58274 const destRoot = getBlockRootClientId(selectedBlockClientId); 58275 const sourceBlockIndex = getBlockIndex(startingBlockClientId); 58276 let destinationBlockIndex = getBlockIndex(selectedBlockClientId); 58277 if (sourceBlockIndex < destinationBlockIndex && sourceRoot === destRoot) { 58278 destinationBlockIndex -= 1; 58279 } 58280 moveBlockToPosition(startingBlockClientId, sourceRoot, destRoot, destinationBlockIndex); 58281 selectBlock(startingBlockClientId); 58282 setBlockMovingClientId(null); 58283 } 58284 // Prevent the block from being moved into itself. 58285 if (startingBlockClientId && selectedBlockClientId === startingBlockClientId && navigateIn) { 58286 return; 58287 } 58288 if (navigateDown || navigateUp || navigateOut || navigateIn) { 58289 if (focusedBlockUid) { 58290 event.preventDefault(); 58291 selectBlock(focusedBlockUid); 58292 } else if (isTab && selectedBlockClientId) { 58293 let nextTabbable; 58294 if (navigateDown) { 58295 nextTabbable = blockElement; 58296 do { 58297 nextTabbable = external_wp_dom_namespaceObject.focus.tabbable.findNext(nextTabbable); 58298 } while (nextTabbable && blockElement.contains(nextTabbable)); 58299 if (!nextTabbable) { 58300 nextTabbable = blockElement.ownerDocument.defaultView.frameElement; 58301 nextTabbable = external_wp_dom_namespaceObject.focus.tabbable.findNext(nextTabbable); 58302 } 58303 } else { 58304 nextTabbable = external_wp_dom_namespaceObject.focus.tabbable.findPrevious(blockElement); 58305 } 58306 if (nextTabbable) { 58307 event.preventDefault(); 58308 nextTabbable.focus(); 58309 clearSelectedBlock(); 58310 } 58311 } 58312 } 58313 } 58314 const classNames = dist_clsx('block-editor-block-list__block-selection-button', { 58315 'is-block-moving-mode': !!blockMovingMode 58316 }); 58317 const dragHandleLabel = (0,external_wp_i18n_namespaceObject.__)('Drag'); 58318 const showBlockDraggable = canMove && editorMode === 'navigation'; 58319 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 58320 className: classNames, 58321 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, { 58322 justify: "center", 58323 className: "block-editor-block-list__block-selection-button__content", 58324 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 58325 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 58326 icon: icon, 58327 showColors: true 58328 }) 58329 }), showBlockDraggable && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 58330 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_draggable, { 58331 clientIds: [clientId], 58332 children: draggableProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button 58333 // TODO: Switch to `true` (40px size) if possible 58334 , { 58335 __next40pxDefaultSize: false, 58336 icon: drag_handle, 58337 className: "block-selection-button_drag-handle", 58338 label: dragHandleLabel 58339 // Should not be able to tab to drag handle as this 58340 // button can only be used with a pointer device. 58341 , 58342 tabIndex: "-1", 58343 ...draggableProps 58344 }) 58345 }) 58346 }), editorMode === 'navigation' && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 58347 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button 58348 // TODO: Switch to `true` (40px size) if possible 58349 , { 58350 __next40pxDefaultSize: false, 58351 ref: ref, 58352 onClick: editorMode === 'navigation' ? () => setNavigationMode(false) : undefined, 58353 onKeyDown: onKeyDown, 58354 label: label, 58355 showTooltip: false, 58356 className: "block-selection-button_select-button", 58357 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTitle, { 58358 clientId: clientId, 58359 maximumLength: 35 58360 }) 58361 }) 58362 })] 58363 }) 58364 }); 58365 } 58366 /* harmony default export */ const block_selection_button = ((0,external_wp_element_namespaceObject.forwardRef)(BlockSelectionButton)); 58367 58368 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/block-toolbar-breadcrumb.js 58369 /** 58370 * External dependencies 58371 */ 58372 58373 58374 /** 58375 * WordPress dependencies 58376 */ 58377 58378 58379 /** 58380 * Internal dependencies 58381 */ 58382 58383 58384 58385 58386 58387 function BlockToolbarBreadcrumb({ 58388 clientId, 58389 __unstableContentRef 58390 }, ref) { 58391 const { 58392 capturingClientId, 58393 isInsertionPointVisible, 58394 lastClientId, 58395 rootClientId 58396 } = useSelectedBlockToolProps(clientId); 58397 const popoverProps = useBlockToolbarPopoverProps({ 58398 contentElement: __unstableContentRef?.current, 58399 clientId 58400 }); 58401 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockPopover, { 58402 clientId: capturingClientId || clientId, 58403 bottomClientId: lastClientId, 58404 className: dist_clsx('block-editor-block-list__block-popover', { 58405 'is-insertion-point-visible': isInsertionPointVisible 58406 }), 58407 resize: false, 58408 ...popoverProps, 58409 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_selection_button, { 58410 ref: ref, 58411 clientId: clientId, 58412 rootClientId: rootClientId 58413 }) 58414 }); 58415 } 58416 /* harmony default export */ const block_toolbar_breadcrumb = ((0,external_wp_element_namespaceObject.forwardRef)(BlockToolbarBreadcrumb)); 58417 58418 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/zoom-out-mode-inserter-button.js 58419 /** 58420 * External dependencies 58421 */ 58422 58423 58424 /** 58425 * WordPress dependencies 58426 */ 58427 58428 58429 58430 58431 58432 function ZoomOutModeInserterButton({ 58433 isVisible, 58434 onClick 58435 }) { 58436 const [zoomOutModeInserterButtonHovered, setZoomOutModeInserterButtonHovered] = (0,external_wp_element_namespaceObject.useState)(false); 58437 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 58438 variant: "primary", 58439 icon: library_plus, 58440 size: "compact", 58441 className: dist_clsx('block-editor-button-pattern-inserter__button', 'block-editor-block-tools__zoom-out-mode-inserter-button', { 58442 'is-visible': isVisible || zoomOutModeInserterButtonHovered 58443 }), 58444 onClick: onClick, 58445 onMouseOver: () => { 58446 setZoomOutModeInserterButtonHovered(true); 58447 }, 58448 onMouseOut: () => { 58449 setZoomOutModeInserterButtonHovered(false); 58450 }, 58451 label: (0,external_wp_i18n_namespaceObject._x)('Add pattern', 'Generic label for pattern inserter button') 58452 }); 58453 } 58454 /* harmony default export */ const zoom_out_mode_inserter_button = (ZoomOutModeInserterButton); 58455 58456 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/zoom-out-mode-inserters.js 58457 /** 58458 * WordPress dependencies 58459 */ 58460 58461 58462 58463 /** 58464 * Internal dependencies 58465 */ 58466 58467 58468 58469 58470 58471 function ZoomOutModeInserters() { 58472 const [isReady, setIsReady] = (0,external_wp_element_namespaceObject.useState)(false); 58473 const { 58474 hasSelection, 58475 blockOrder, 58476 setInserterIsOpened, 58477 sectionRootClientId, 58478 selectedBlockClientId 58479 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 58480 const { 58481 getSettings, 58482 getBlockOrder, 58483 getSelectionStart, 58484 getSelectedBlockClientId, 58485 getSectionRootClientId 58486 } = unlock(select(store)); 58487 const root = getSectionRootClientId(); 58488 return { 58489 hasSelection: !!getSelectionStart().clientId, 58490 blockOrder: getBlockOrder(root), 58491 sectionRootClientId: root, 58492 setInserterIsOpened: getSettings().__experimentalSetIsInserterOpened, 58493 selectedBlockClientId: getSelectedBlockClientId() 58494 }; 58495 }, []); 58496 const { 58497 showInsertionPoint 58498 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 58499 58500 // Defer the initial rendering to avoid the jumps due to the animation. 58501 (0,external_wp_element_namespaceObject.useEffect)(() => { 58502 const timeout = setTimeout(() => { 58503 setIsReady(true); 58504 }, 500); 58505 return () => { 58506 clearTimeout(timeout); 58507 }; 58508 }, []); 58509 if (!isReady || !hasSelection) { 58510 return null; 58511 } 58512 const previousClientId = selectedBlockClientId; 58513 const index = blockOrder.findIndex(clientId => selectedBlockClientId === clientId); 58514 const nextClientId = blockOrder[index + 1]; 58515 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inbetween, { 58516 previousClientId: previousClientId, 58517 nextClientId: nextClientId, 58518 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(zoom_out_mode_inserter_button, { 58519 onClick: () => { 58520 // Hotfix for wp/6.7 where focus is not transferred to the sidebar if the 58521 // block library is already open. 58522 const blockLibrary = document.querySelector('[aria-label="Block Library"]'); 58523 setInserterIsOpened({ 58524 rootClientId: sectionRootClientId, 58525 insertionIndex: index + 1, 58526 tab: 'patterns', 58527 category: 'all' 58528 }); 58529 showInsertionPoint(sectionRootClientId, index + 1, { 58530 operation: 'insert' 58531 }); 58532 58533 // If the block library was available before we opened it with `setInserterIsOpened`, we need to 58534 // send focus to the block library. 58535 if (blockLibrary) { 58536 blockLibrary.focus(); 58537 } 58538 } 58539 }) 58540 }); 58541 } 58542 /* harmony default export */ const zoom_out_mode_inserters = (ZoomOutModeInserters); 58543 58544 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/use-show-block-tools.js 58545 /** 58546 * WordPress dependencies 58547 */ 58548 58549 58550 58551 /** 58552 * Internal dependencies 58553 */ 58554 58555 58556 58557 /** 58558 * Source of truth for which block tools are showing in the block editor. 58559 * 58560 * @return {Object} Object of which block tools will be shown. 58561 */ 58562 function useShowBlockTools() { 58563 return (0,external_wp_data_namespaceObject.useSelect)(select => { 58564 const { 58565 getSelectedBlockClientId, 58566 getFirstMultiSelectedBlockClientId, 58567 getBlock, 58568 getBlockMode, 58569 getSettings, 58570 hasMultiSelection, 58571 __unstableGetEditorMode, 58572 isTyping 58573 } = unlock(select(store)); 58574 const clientId = getSelectedBlockClientId() || getFirstMultiSelectedBlockClientId(); 58575 const block = getBlock(clientId); 58576 const editorMode = __unstableGetEditorMode(); 58577 const hasSelectedBlock = !!clientId && !!block; 58578 const isEmptyDefaultBlock = hasSelectedBlock && (0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(block) && getBlockMode(clientId) !== 'html'; 58579 const _showEmptyBlockSideInserter = clientId && !isTyping() && editorMode === 'edit' && isEmptyDefaultBlock; 58580 const maybeShowBreadcrumb = hasSelectedBlock && !hasMultiSelection() && editorMode === 'navigation'; 58581 const _showBlockToolbarPopover = !getSettings().hasFixedToolbar && !_showEmptyBlockSideInserter && hasSelectedBlock && !isEmptyDefaultBlock && !maybeShowBreadcrumb; 58582 return { 58583 showEmptyBlockSideInserter: _showEmptyBlockSideInserter, 58584 showBreadcrumb: !_showEmptyBlockSideInserter && maybeShowBreadcrumb, 58585 showBlockToolbarPopover: _showBlockToolbarPopover 58586 }; 58587 }, []); 58588 } 58589 58590 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/index.js 58591 /** 58592 * WordPress dependencies 58593 */ 58594 58595 58596 58597 58598 58599 58600 58601 58602 58603 /** 58604 * Internal dependencies 58605 */ 58606 58607 58608 58609 58610 58611 58612 58613 58614 58615 58616 58617 58618 function block_tools_selector(select) { 58619 const { 58620 getSelectedBlockClientId, 58621 getFirstMultiSelectedBlockClientId, 58622 getSettings, 58623 __unstableGetEditorMode, 58624 isTyping 58625 } = select(store); 58626 const clientId = getSelectedBlockClientId() || getFirstMultiSelectedBlockClientId(); 58627 const editorMode = __unstableGetEditorMode(); 58628 return { 58629 clientId, 58630 hasFixedToolbar: getSettings().hasFixedToolbar, 58631 isTyping: isTyping(), 58632 isZoomOutMode: editorMode === 'zoom-out' 58633 }; 58634 } 58635 58636 /** 58637 * Renders block tools (the block toolbar, select/navigation mode toolbar, the 58638 * insertion point and a slot for the inline rich text toolbar). Must be wrapped 58639 * around the block content and editor styles wrapper or iframe. 58640 * 58641 * @param {Object} $0 Props. 58642 * @param {Object} $0.children The block content and style container. 58643 * @param {Object} $0.__unstableContentRef Ref holding the content scroll container. 58644 */ 58645 function BlockTools({ 58646 children, 58647 __unstableContentRef, 58648 ...props 58649 }) { 58650 const { 58651 clientId, 58652 hasFixedToolbar, 58653 isTyping, 58654 isZoomOutMode 58655 } = (0,external_wp_data_namespaceObject.useSelect)(block_tools_selector, []); 58656 const isMatch = (0,external_wp_keyboardShortcuts_namespaceObject.__unstableUseShortcutEventMatch)(); 58657 const { 58658 getBlocksByClientId, 58659 getSelectedBlockClientIds, 58660 getBlockRootClientId, 58661 isGroupable 58662 } = (0,external_wp_data_namespaceObject.useSelect)(store); 58663 const { 58664 getGroupingBlockName 58665 } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store); 58666 const { 58667 showEmptyBlockSideInserter, 58668 showBreadcrumb, 58669 showBlockToolbarPopover 58670 } = useShowBlockTools(); 58671 const { 58672 clearSelectedBlock, 58673 duplicateBlocks, 58674 removeBlocks, 58675 replaceBlocks, 58676 insertAfterBlock, 58677 insertBeforeBlock, 58678 selectBlock, 58679 moveBlocksUp, 58680 moveBlocksDown, 58681 expandBlock 58682 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 58683 const blockSelectionButtonRef = (0,external_wp_element_namespaceObject.useRef)(); 58684 function onKeyDown(event) { 58685 if (event.defaultPrevented) { 58686 return; 58687 } 58688 if (isMatch('core/block-editor/move-up', event)) { 58689 const clientIds = getSelectedBlockClientIds(); 58690 if (clientIds.length) { 58691 event.preventDefault(); 58692 const rootClientId = getBlockRootClientId(clientIds[0]); 58693 moveBlocksUp(clientIds, rootClientId); 58694 } 58695 } else if (isMatch('core/block-editor/move-down', event)) { 58696 const clientIds = getSelectedBlockClientIds(); 58697 if (clientIds.length) { 58698 event.preventDefault(); 58699 const rootClientId = getBlockRootClientId(clientIds[0]); 58700 moveBlocksDown(clientIds, rootClientId); 58701 } 58702 } else if (isMatch('core/block-editor/duplicate', event)) { 58703 const clientIds = getSelectedBlockClientIds(); 58704 if (clientIds.length) { 58705 event.preventDefault(); 58706 duplicateBlocks(clientIds); 58707 } 58708 } else if (isMatch('core/block-editor/remove', event)) { 58709 const clientIds = getSelectedBlockClientIds(); 58710 if (clientIds.length) { 58711 event.preventDefault(); 58712 removeBlocks(clientIds); 58713 } 58714 } else if (isMatch('core/block-editor/insert-after', event)) { 58715 const clientIds = getSelectedBlockClientIds(); 58716 if (clientIds.length) { 58717 event.preventDefault(); 58718 insertAfterBlock(clientIds[clientIds.length - 1]); 58719 } 58720 } else if (isMatch('core/block-editor/insert-before', event)) { 58721 const clientIds = getSelectedBlockClientIds(); 58722 if (clientIds.length) { 58723 event.preventDefault(); 58724 insertBeforeBlock(clientIds[0]); 58725 } 58726 } else if (isMatch('core/block-editor/unselect', event)) { 58727 if (event.target.closest('[role=toolbar]')) { 58728 // This shouldn't be necessary, but we have a combination of a few things all combining to create a situation where: 58729 // - Because the block toolbar uses createPortal to populate the block toolbar fills, we can't rely on the React event bubbling to hit the onKeyDown listener for the block toolbar 58730 // - Since we can't use the React tree, we use the DOM tree which _should_ handle the event bubbling correctly from a `createPortal` element. 58731 // - This bubbles via the React tree, which hits this `unselect` escape keypress before the block toolbar DOM event listener has access to it. 58732 // An alternative would be to remove the addEventListener on the navigableToolbar and use this event to handle it directly right here. That feels hacky too though. 58733 return; 58734 } 58735 const clientIds = getSelectedBlockClientIds(); 58736 if (clientIds.length > 1) { 58737 event.preventDefault(); 58738 // If there is more than one block selected, select the first 58739 // block so that focus is directed back to the beginning of the selection. 58740 // In effect, to the user this feels like deselecting the multi-selection. 58741 selectBlock(clientIds[0]); 58742 } else if (clientIds.length === 1 && event.target === blockSelectionButtonRef?.current) { 58743 event.preventDefault(); 58744 clearSelectedBlock(); 58745 getEditorRegion(__unstableContentRef.current)?.focus(); 58746 } 58747 } else if (isMatch('core/block-editor/collapse-list-view', event)) { 58748 // If focus is currently within a text field, such as a rich text block or other editable field, 58749 // skip collapsing the list view, and allow the keyboard shortcut to be handled by the text field. 58750 // This condition checks for both the active element and the active element within an iframed editor. 58751 if ((0,external_wp_dom_namespaceObject.isTextField)(event.target) || (0,external_wp_dom_namespaceObject.isTextField)(event.target?.contentWindow?.document?.activeElement)) { 58752 return; 58753 } 58754 event.preventDefault(); 58755 expandBlock(clientId); 58756 } else if (isMatch('core/block-editor/group', event)) { 58757 const clientIds = getSelectedBlockClientIds(); 58758 if (clientIds.length > 1 && isGroupable(clientIds)) { 58759 event.preventDefault(); 58760 const blocks = getBlocksByClientId(clientIds); 58761 const groupingBlockName = getGroupingBlockName(); 58762 const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, groupingBlockName); 58763 replaceBlocks(clientIds, newBlocks); 58764 (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('Selected blocks are grouped.')); 58765 } 58766 } 58767 } 58768 const blockToolbarRef = use_popover_scroll(__unstableContentRef); 58769 const blockToolbarAfterRef = use_popover_scroll(__unstableContentRef); 58770 return ( 58771 /*#__PURE__*/ 58772 // eslint-disable-next-line jsx-a11y/no-static-element-interactions 58773 (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 58774 ...props, 58775 onKeyDown: onKeyDown, 58776 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(insertion_point_InsertionPointOpenRef.Provider, { 58777 value: (0,external_wp_element_namespaceObject.useRef)(false), 58778 children: [!isTyping && !isZoomOutMode && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InsertionPoint, { 58779 __unstableContentRef: __unstableContentRef 58780 }), showEmptyBlockSideInserter && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EmptyBlockInserter, { 58781 __unstableContentRef: __unstableContentRef, 58782 clientId: clientId 58783 }), showBlockToolbarPopover && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockToolbarPopover, { 58784 __unstableContentRef: __unstableContentRef, 58785 clientId: clientId, 58786 isTyping: isTyping 58787 }), showBreadcrumb && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_toolbar_breadcrumb, { 58788 ref: blockSelectionButtonRef, 58789 __unstableContentRef: __unstableContentRef, 58790 clientId: clientId 58791 }), !isZoomOutMode && !hasFixedToolbar && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover.Slot, { 58792 name: "block-toolbar", 58793 ref: blockToolbarRef 58794 }), children, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover.Slot, { 58795 name: "__unstable-block-tools-after", 58796 ref: blockToolbarAfterRef 58797 }), isZoomOutMode && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(zoom_out_mode_inserters, { 58798 __unstableContentRef: __unstableContentRef 58799 })] 58800 }) 58801 }) 58802 ); 58803 } 58804 58805 ;// external ["wp","commands"] 58806 const external_wp_commands_namespaceObject = window["wp"]["commands"]; 58807 ;// ./node_modules/@wordpress/icons/build-module/library/move-to.js 58808 /** 58809 * WordPress dependencies 58810 */ 58811 58812 58813 const move_to_moveTo = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 58814 xmlns: "http://www.w3.org/2000/svg", 58815 viewBox: "0 0 24 24", 58816 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 58817 d: "M19.75 9c0-1.257-.565-2.197-1.39-2.858-.797-.64-1.827-1.017-2.815-1.247-1.802-.42-3.703-.403-4.383-.396L11 4.5V6l.177-.001c.696-.006 2.416-.02 4.028.356.887.207 1.67.518 2.216.957.52.416.829.945.829 1.688 0 .592-.167.966-.407 1.23-.255.281-.656.508-1.236.674-1.19.34-2.82.346-4.607.346h-.077c-1.692 0-3.527 0-4.942.404-.732.209-1.424.545-1.935 1.108-.526.579-.796 1.33-.796 2.238 0 1.257.565 2.197 1.39 2.858.797.64 1.827 1.017 2.815 1.247 1.802.42 3.703.403 4.383.396L13 19.5h.714V22L18 18.5 13.714 15v3H13l-.177.001c-.696.006-2.416.02-4.028-.356-.887-.207-1.67-.518-2.216-.957-.52-.416-.829-.945-.829-1.688 0-.592.167-.966.407-1.23.255-.281.656-.508 1.237-.674 1.189-.34 2.819-.346 4.606-.346h.077c1.692 0 3.527 0 4.941-.404.732-.209 1.425-.545 1.936-1.108.526-.579.796-1.33.796-2.238z" 58818 }) 58819 }); 58820 /* harmony default export */ const move_to = (move_to_moveTo); 58821 58822 ;// ./node_modules/@wordpress/icons/build-module/library/ungroup.js 58823 /** 58824 * WordPress dependencies 58825 */ 58826 58827 58828 const ungroup = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 58829 xmlns: "http://www.w3.org/2000/svg", 58830 viewBox: "0 0 24 24", 58831 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 58832 d: "M18 4h-7c-1.1 0-2 .9-2 2v7c0 1.1.9 2 2 2h7c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm.5 9c0 .3-.2.5-.5.5h-7c-.3 0-.5-.2-.5-.5V6c0-.3.2-.5.5-.5h7c.3 0 .5.2.5.5v7zm-5 5c0 .3-.2.5-.5.5H6c-.3 0-.5-.2-.5-.5v-7c0-.3.2-.5.5-.5h1V9H6c-1.1 0-2 .9-2 2v7c0 1.1.9 2 2 2h7c1.1 0 2-.9 2-2v-1h-1.5v1z" 58833 }) 58834 }); 58835 /* harmony default export */ const library_ungroup = (ungroup); 58836 58837 ;// ./node_modules/@wordpress/icons/build-module/library/trash.js 58838 /** 58839 * WordPress dependencies 58840 */ 58841 58842 58843 const trash = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 58844 xmlns: "http://www.w3.org/2000/svg", 58845 viewBox: "0 0 24 24", 58846 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 58847 fillRule: "evenodd", 58848 clipRule: "evenodd", 58849 d: "M12 5.5A2.25 2.25 0 0 0 9.878 7h4.244A2.251 2.251 0 0 0 12 5.5ZM12 4a3.751 3.751 0 0 0-3.675 3H5v1.5h1.27l.818 8.997a2.75 2.75 0 0 0 2.739 2.501h4.347a2.75 2.75 0 0 0 2.738-2.5L17.73 8.5H19V7h-3.325A3.751 3.751 0 0 0 12 4Zm4.224 4.5H7.776l.806 8.861a1.25 1.25 0 0 0 1.245 1.137h4.347a1.25 1.25 0 0 0 1.245-1.137l.805-8.861Z" 58850 }) 58851 }); 58852 /* harmony default export */ const library_trash = (trash); 58853 58854 ;// ./node_modules/@wordpress/block-editor/build-module/components/use-block-commands/index.js 58855 /** 58856 * WordPress dependencies 58857 */ 58858 58859 58860 58861 58862 58863 58864 /** 58865 * Internal dependencies 58866 */ 58867 58868 58869 58870 const useTransformCommands = () => { 58871 const { 58872 replaceBlocks, 58873 multiSelect 58874 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 58875 const { 58876 blocks, 58877 clientIds, 58878 canRemove, 58879 possibleBlockTransformations, 58880 invalidSelection 58881 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 58882 const { 58883 getBlockRootClientId, 58884 getBlockTransformItems, 58885 getSelectedBlockClientIds, 58886 getBlocksByClientId, 58887 canRemoveBlocks 58888 } = select(store); 58889 const selectedBlockClientIds = getSelectedBlockClientIds(); 58890 const selectedBlocks = getBlocksByClientId(selectedBlockClientIds); 58891 58892 // selectedBlocks can have `null`s when something tries to call `selectBlock` with an inexistent clientId. 58893 // These nulls will cause fatal errors down the line. 58894 // In order to prevent discrepancies between selectedBlockClientIds and selectedBlocks, we effectively treat the entire selection as invalid. 58895 // @see https://github.com/WordPress/gutenberg/pull/59410#issuecomment-2006304536 58896 if (selectedBlocks.filter(block => !block).length > 0) { 58897 return { 58898 invalidSelection: true 58899 }; 58900 } 58901 const rootClientId = getBlockRootClientId(selectedBlockClientIds[0]); 58902 return { 58903 blocks: selectedBlocks, 58904 clientIds: selectedBlockClientIds, 58905 possibleBlockTransformations: getBlockTransformItems(selectedBlocks, rootClientId), 58906 canRemove: canRemoveBlocks(selectedBlockClientIds), 58907 invalidSelection: false 58908 }; 58909 }, []); 58910 if (invalidSelection) { 58911 return { 58912 isLoading: false, 58913 commands: [] 58914 }; 58915 } 58916 const isTemplate = blocks.length === 1 && (0,external_wp_blocks_namespaceObject.isTemplatePart)(blocks[0]); 58917 function selectForMultipleBlocks(insertedBlocks) { 58918 if (insertedBlocks.length > 1) { 58919 multiSelect(insertedBlocks[0].clientId, insertedBlocks[insertedBlocks.length - 1].clientId); 58920 } 58921 } 58922 58923 // Simple block tranformation based on the `Block Transforms` API. 58924 function onBlockTransform(name) { 58925 const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, name); 58926 replaceBlocks(clientIds, newBlocks); 58927 selectForMultipleBlocks(newBlocks); 58928 } 58929 58930 /** 58931 * The `isTemplate` check is a stopgap solution here. 58932 * Ideally, the Transforms API should handle this 58933 * by allowing to exclude blocks from wildcard transformations. 58934 */ 58935 const hasPossibleBlockTransformations = !!possibleBlockTransformations.length && canRemove && !isTemplate; 58936 if (!clientIds || clientIds.length < 1 || !hasPossibleBlockTransformations) { 58937 return { 58938 isLoading: false, 58939 commands: [] 58940 }; 58941 } 58942 const commands = possibleBlockTransformations.map(transformation => { 58943 const { 58944 name, 58945 title, 58946 icon 58947 } = transformation; 58948 return { 58949 name: 'core/block-editor/transform-to-' + name.replace('/', '-'), 58950 /* translators: %s: Block or block variation name. */ 58951 label: (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)('Transform to %s'), title), 58952 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 58953 icon: icon 58954 }), 58955 callback: ({ 58956 close 58957 }) => { 58958 onBlockTransform(name); 58959 close(); 58960 } 58961 }; 58962 }); 58963 return { 58964 isLoading: false, 58965 commands 58966 }; 58967 }; 58968 const useActionsCommands = () => { 58969 const { 58970 clientIds 58971 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 58972 const { 58973 getSelectedBlockClientIds 58974 } = select(store); 58975 const selectedBlockClientIds = getSelectedBlockClientIds(); 58976 return { 58977 clientIds: selectedBlockClientIds 58978 }; 58979 }, []); 58980 const { 58981 getBlockRootClientId, 58982 canMoveBlocks, 58983 getBlockCount 58984 } = (0,external_wp_data_namespaceObject.useSelect)(store); 58985 const { 58986 setBlockMovingClientId, 58987 setNavigationMode, 58988 selectBlock 58989 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 58990 if (!clientIds || clientIds.length < 1) { 58991 return { 58992 isLoading: false, 58993 commands: [] 58994 }; 58995 } 58996 const rootClientId = getBlockRootClientId(clientIds[0]); 58997 const canMove = canMoveBlocks(clientIds) && getBlockCount(rootClientId) !== 1; 58998 const commands = []; 58999 if (canMove) { 59000 commands.push({ 59001 name: 'move-to', 59002 label: (0,external_wp_i18n_namespaceObject.__)('Move to'), 59003 callback: () => { 59004 setNavigationMode(true); 59005 selectBlock(clientIds[0]); 59006 setBlockMovingClientId(clientIds[0]); 59007 }, 59008 icon: move_to 59009 }); 59010 } 59011 return { 59012 isLoading: false, 59013 commands: commands.map(command => ({ 59014 ...command, 59015 name: 'core/block-editor/action-' + command.name, 59016 callback: ({ 59017 close 59018 }) => { 59019 command.callback(); 59020 close(); 59021 } 59022 })) 59023 }; 59024 }; 59025 const useQuickActionsCommands = () => { 59026 const { 59027 clientIds, 59028 isUngroupable, 59029 isGroupable 59030 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 59031 const { 59032 getSelectedBlockClientIds, 59033 isUngroupable: _isUngroupable, 59034 isGroupable: _isGroupable 59035 } = select(store); 59036 const selectedBlockClientIds = getSelectedBlockClientIds(); 59037 return { 59038 clientIds: selectedBlockClientIds, 59039 isUngroupable: _isUngroupable(), 59040 isGroupable: _isGroupable() 59041 }; 59042 }, []); 59043 const { 59044 canInsertBlockType, 59045 getBlockRootClientId, 59046 getBlocksByClientId, 59047 canRemoveBlocks 59048 } = (0,external_wp_data_namespaceObject.useSelect)(store); 59049 const { 59050 getDefaultBlockName, 59051 getGroupingBlockName 59052 } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store); 59053 const blocks = getBlocksByClientId(clientIds); 59054 const { 59055 removeBlocks, 59056 replaceBlocks, 59057 duplicateBlocks, 59058 insertAfterBlock, 59059 insertBeforeBlock 59060 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 59061 const onGroup = () => { 59062 if (!blocks.length) { 59063 return; 59064 } 59065 const groupingBlockName = getGroupingBlockName(); 59066 59067 // Activate the `transform` on `core/group` which does the conversion. 59068 const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, groupingBlockName); 59069 if (!newBlocks) { 59070 return; 59071 } 59072 replaceBlocks(clientIds, newBlocks); 59073 }; 59074 const onUngroup = () => { 59075 if (!blocks.length) { 59076 return; 59077 } 59078 const innerBlocks = blocks[0].innerBlocks; 59079 if (!innerBlocks.length) { 59080 return; 59081 } 59082 replaceBlocks(clientIds, innerBlocks); 59083 }; 59084 if (!clientIds || clientIds.length < 1) { 59085 return { 59086 isLoading: false, 59087 commands: [] 59088 }; 59089 } 59090 const rootClientId = getBlockRootClientId(clientIds[0]); 59091 const canInsertDefaultBlock = canInsertBlockType(getDefaultBlockName(), rootClientId); 59092 const canDuplicate = blocks.every(block => { 59093 return !!block && (0,external_wp_blocks_namespaceObject.hasBlockSupport)(block.name, 'multiple', true) && canInsertBlockType(block.name, rootClientId); 59094 }); 59095 const canRemove = canRemoveBlocks(clientIds); 59096 const commands = []; 59097 if (canDuplicate) { 59098 commands.push({ 59099 name: 'duplicate', 59100 label: (0,external_wp_i18n_namespaceObject.__)('Duplicate'), 59101 callback: () => duplicateBlocks(clientIds, true), 59102 icon: library_copy 59103 }); 59104 } 59105 if (canInsertDefaultBlock) { 59106 commands.push({ 59107 name: 'add-before', 59108 label: (0,external_wp_i18n_namespaceObject.__)('Add before'), 59109 callback: () => { 59110 const clientId = Array.isArray(clientIds) ? clientIds[0] : clientId; 59111 insertBeforeBlock(clientId); 59112 }, 59113 icon: library_plus 59114 }, { 59115 name: 'add-after', 59116 label: (0,external_wp_i18n_namespaceObject.__)('Add after'), 59117 callback: () => { 59118 const clientId = Array.isArray(clientIds) ? clientIds[clientIds.length - 1] : clientId; 59119 insertAfterBlock(clientId); 59120 }, 59121 icon: library_plus 59122 }); 59123 } 59124 if (isGroupable) { 59125 commands.push({ 59126 name: 'Group', 59127 label: (0,external_wp_i18n_namespaceObject.__)('Group'), 59128 callback: onGroup, 59129 icon: library_group 59130 }); 59131 } 59132 if (isUngroupable) { 59133 commands.push({ 59134 name: 'ungroup', 59135 label: (0,external_wp_i18n_namespaceObject.__)('Ungroup'), 59136 callback: onUngroup, 59137 icon: library_ungroup 59138 }); 59139 } 59140 if (canRemove) { 59141 commands.push({ 59142 name: 'remove', 59143 label: (0,external_wp_i18n_namespaceObject.__)('Delete'), 59144 callback: () => removeBlocks(clientIds, true), 59145 icon: library_trash 59146 }); 59147 } 59148 return { 59149 isLoading: false, 59150 commands: commands.map(command => ({ 59151 ...command, 59152 name: 'core/block-editor/action-' + command.name, 59153 callback: ({ 59154 close 59155 }) => { 59156 command.callback(); 59157 close(); 59158 } 59159 })) 59160 }; 59161 }; 59162 const useBlockCommands = () => { 59163 (0,external_wp_commands_namespaceObject.useCommandLoader)({ 59164 name: 'core/block-editor/blockTransforms', 59165 hook: useTransformCommands 59166 }); 59167 (0,external_wp_commands_namespaceObject.useCommandLoader)({ 59168 name: 'core/block-editor/blockActions', 59169 hook: useActionsCommands 59170 }); 59171 (0,external_wp_commands_namespaceObject.useCommandLoader)({ 59172 name: 'core/block-editor/blockQuickActions', 59173 hook: useQuickActionsCommands, 59174 context: 'block-selection-edit' 59175 }); 59176 }; 59177 59178 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-canvas/index.js 59179 /** 59180 * WordPress dependencies 59181 */ 59182 59183 59184 59185 /** 59186 * Internal dependencies 59187 */ 59188 59189 59190 59191 59192 59193 59194 59195 59196 59197 // EditorStyles is a memoized component, so avoid passing a new 59198 // object reference on each render. 59199 59200 59201 const EDITOR_STYLE_TRANSFORM_OPTIONS = { 59202 // Don't transform selectors that already specify `.editor-styles-wrapper`. 59203 ignoredSelectors: [/\.editor-styles-wrapper/gi] 59204 }; 59205 function ExperimentalBlockCanvas({ 59206 shouldIframe = true, 59207 height = '300px', 59208 children = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockList, {}), 59209 styles, 59210 contentRef: contentRefProp, 59211 iframeProps 59212 }) { 59213 useBlockCommands(); 59214 const resetTypingRef = useMouseMoveTypingReset(); 59215 const clearerRef = useBlockSelectionClearer(); 59216 const localRef = (0,external_wp_element_namespaceObject.useRef)(); 59217 const contentRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([contentRefProp, clearerRef, localRef]); 59218 if (!shouldIframe) { 59219 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(BlockTools, { 59220 __unstableContentRef: localRef, 59221 style: { 59222 height, 59223 display: 'flex' 59224 }, 59225 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editor_styles, { 59226 styles: styles, 59227 scope: ":where(.editor-styles-wrapper)", 59228 transformOptions: EDITOR_STYLE_TRANSFORM_OPTIONS 59229 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(writing_flow, { 59230 ref: contentRef, 59231 className: "editor-styles-wrapper", 59232 tabIndex: -1, 59233 style: { 59234 height: '100%', 59235 width: '100%' 59236 }, 59237 children: children 59238 })] 59239 }); 59240 } 59241 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTools, { 59242 __unstableContentRef: localRef, 59243 style: { 59244 height, 59245 display: 'flex' 59246 }, 59247 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(iframe, { 59248 ...iframeProps, 59249 ref: resetTypingRef, 59250 contentRef: contentRef, 59251 style: { 59252 ...iframeProps?.style 59253 }, 59254 name: "editor-canvas", 59255 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editor_styles, { 59256 styles: styles 59257 }), children] 59258 }) 59259 }); 59260 } 59261 59262 /** 59263 * BlockCanvas component is a component used to display the canvas of the block editor. 59264 * What we call the canvas is an iframe containing the block list that you can manipulate. 59265 * The component is also responsible of wiring up all the necessary hooks to enable 59266 * the keyboard navigation across blocks in the editor and inject content styles into the iframe. 59267 * 59268 * @example 59269 * 59270 * ```jsx 59271 * function MyBlockEditor() { 59272 * const [ blocks, updateBlocks ] = useState([]); 59273 * return ( 59274 * <BlockEditorProvider 59275 * value={ blocks } 59276 * onInput={ updateBlocks } 59277 * onChange={ persistBlocks } 59278 * > 59279 * <BlockCanvas height="400px" /> 59280 * </BlockEditorProvider> 59281 * ); 59282 * } 59283 * ``` 59284 * 59285 * @param {Object} props Component props. 59286 * @param {string} props.height Canvas height, defaults to 300px. 59287 * @param {Array} props.styles Content styles to inject into the iframe. 59288 * @param {Element} props.children Content of the canvas, defaults to the BlockList component. 59289 * @return {Element} Block Breadcrumb. 59290 */ 59291 function BlockCanvas({ 59292 children, 59293 height, 59294 styles 59295 }) { 59296 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ExperimentalBlockCanvas, { 59297 height: height, 59298 styles: styles, 59299 children: children 59300 }); 59301 } 59302 /* harmony default export */ const block_canvas = (BlockCanvas); 59303 59304 ;// ./node_modules/@wordpress/block-editor/build-module/components/color-style-selector/index.js 59305 /** 59306 * WordPress dependencies 59307 */ 59308 59309 59310 59311 59312 59313 const ColorSelectorSVGIcon = () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, { 59314 xmlns: "http://www.w3.org/2000/svg", 59315 viewBox: "0 0 20 20", 59316 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, { 59317 d: "M7.434 5l3.18 9.16H8.538l-.692-2.184H4.628l-.705 2.184H2L5.18 5h2.254zm-1.13 1.904h-.115l-1.148 3.593H7.44L6.304 6.904zM14.348 7.006c1.853 0 2.9.876 2.9 2.374v4.78h-1.79v-.914h-.114c-.362.64-1.123 1.022-2.031 1.022-1.346 0-2.292-.826-2.292-2.108 0-1.27.972-2.006 2.71-2.107l1.696-.102V9.38c0-.584-.42-.914-1.18-.914-.667 0-1.112.228-1.264.647h-1.701c.12-1.295 1.307-2.107 3.066-2.107zm1.079 4.1l-1.416.09c-.793.056-1.18.342-1.18.844 0 .52.45.837 1.091.837.857 0 1.505-.545 1.505-1.256v-.515z" 59318 }) 59319 }); 59320 59321 /** 59322 * Color Selector Icon component. 59323 * 59324 * @param {Object} props Component properties. 59325 * @param {Object} props.style Style object. 59326 * @param {string} props.className Class name for component. 59327 * 59328 * @return {*} React Icon component. 59329 */ 59330 const ColorSelectorIcon = ({ 59331 style, 59332 className 59333 }) => { 59334 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 59335 className: "block-library-colors-selector__icon-container", 59336 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 59337 className: `$className} block-library-colors-selector__state-selection`, 59338 style: style, 59339 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorSelectorSVGIcon, {}) 59340 }) 59341 }); 59342 }; 59343 59344 /** 59345 * Renders the Colors Selector Toolbar with the icon button. 59346 * 59347 * @param {Object} props Component properties. 59348 * @param {Object} props.TextColor Text color component that wraps icon. 59349 * @param {Object} props.BackgroundColor Background color component that wraps icon. 59350 * 59351 * @return {*} React toggle button component. 59352 */ 59353 const renderToggleComponent = ({ 59354 TextColor, 59355 BackgroundColor 59356 }) => ({ 59357 onToggle, 59358 isOpen 59359 }) => { 59360 const openOnArrowDown = event => { 59361 if (!isOpen && event.keyCode === external_wp_keycodes_namespaceObject.DOWN) { 59362 event.preventDefault(); 59363 onToggle(); 59364 } 59365 }; 59366 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, { 59367 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 59368 className: "components-toolbar__control block-library-colors-selector__toggle", 59369 label: (0,external_wp_i18n_namespaceObject.__)('Open Colors Selector'), 59370 onClick: onToggle, 59371 onKeyDown: openOnArrowDown, 59372 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundColor, { 59373 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TextColor, { 59374 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorSelectorIcon, {}) 59375 }) 59376 }) 59377 }) 59378 }); 59379 }; 59380 const BlockColorsStyleSelector = ({ 59381 children, 59382 ...other 59383 }) => { 59384 external_wp_deprecated_default()(`wp.blockEditor.BlockColorsStyleSelector`, { 59385 alternative: 'block supports API', 59386 since: '6.1', 59387 version: '6.3' 59388 }); 59389 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 59390 popoverProps: { 59391 placement: 'bottom-start' 59392 }, 59393 className: "block-library-colors-selector", 59394 contentClassName: "block-library-colors-selector__popover", 59395 renderToggle: renderToggleComponent(other), 59396 renderContent: () => children 59397 }); 59398 }; 59399 /* harmony default export */ const color_style_selector = (BlockColorsStyleSelector); 59400 59401 ;// ./node_modules/@wordpress/icons/build-module/library/list-view.js 59402 /** 59403 * WordPress dependencies 59404 */ 59405 59406 59407 const listView = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 59408 viewBox: "0 0 24 24", 59409 xmlns: "http://www.w3.org/2000/svg", 59410 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 59411 d: "M3 6h11v1.5H3V6Zm3.5 5.5h11V13h-11v-1.5ZM21 17H10v1.5h11V17Z" 59412 }) 59413 }); 59414 /* harmony default export */ const list_view = (listView); 59415 59416 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/context.js 59417 /** 59418 * WordPress dependencies 59419 */ 59420 59421 const ListViewContext = (0,external_wp_element_namespaceObject.createContext)({}); 59422 const useListViewContext = () => (0,external_wp_element_namespaceObject.useContext)(ListViewContext); 59423 59424 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/aria-referenced-text.js 59425 /** 59426 * WordPress dependencies 59427 */ 59428 59429 59430 /** 59431 * A component specifically designed to be used as an element referenced 59432 * by ARIA attributes such as `aria-labelledby` or `aria-describedby`. 59433 * 59434 * @param {Object} props Props. 59435 * @param {import('react').ReactNode} props.children 59436 */ 59437 59438 function AriaReferencedText({ 59439 children, 59440 ...props 59441 }) { 59442 const ref = (0,external_wp_element_namespaceObject.useRef)(); 59443 (0,external_wp_element_namespaceObject.useEffect)(() => { 59444 if (ref.current) { 59445 // This seems like a no-op, but it fixes a bug in Firefox where 59446 // it fails to recompute the text when only the text node changes. 59447 // @see https://github.com/WordPress/gutenberg/pull/51035 59448 ref.current.textContent = ref.current.textContent; 59449 } 59450 }, [children]); 59451 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 59452 hidden: true, 59453 ...props, 59454 ref: ref, 59455 children: children 59456 }); 59457 } 59458 59459 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/appender.js 59460 /** 59461 * WordPress dependencies 59462 */ 59463 59464 59465 59466 59467 59468 59469 /** 59470 * Internal dependencies 59471 */ 59472 59473 59474 59475 59476 59477 59478 59479 const Appender = (0,external_wp_element_namespaceObject.forwardRef)(({ 59480 nestingLevel, 59481 blockCount, 59482 clientId, 59483 ...props 59484 }, ref) => { 59485 const { 59486 insertedBlock, 59487 setInsertedBlock 59488 } = useListViewContext(); 59489 const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(Appender); 59490 const hideInserter = (0,external_wp_data_namespaceObject.useSelect)(select => { 59491 const { 59492 getTemplateLock, 59493 __unstableGetEditorMode 59494 } = select(store); 59495 return !!getTemplateLock(clientId) || __unstableGetEditorMode() === 'zoom-out'; 59496 }, [clientId]); 59497 const blockTitle = useBlockDisplayTitle({ 59498 clientId, 59499 context: 'list-view' 59500 }); 59501 const insertedBlockTitle = useBlockDisplayTitle({ 59502 clientId: insertedBlock?.clientId, 59503 context: 'list-view' 59504 }); 59505 (0,external_wp_element_namespaceObject.useEffect)(() => { 59506 if (!insertedBlockTitle?.length) { 59507 return; 59508 } 59509 (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)( 59510 // translators: %s: name of block being inserted (i.e. Paragraph, Image, Group etc) 59511 (0,external_wp_i18n_namespaceObject.__)('%s block inserted'), insertedBlockTitle), 'assertive'); 59512 }, [insertedBlockTitle]); 59513 if (hideInserter) { 59514 return null; 59515 } 59516 const descriptionId = `list-view-appender__$instanceId}`; 59517 const description = (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: 1: The name of the block. 2: The numerical position of the block. 3: The level of nesting for the block. */ 59518 (0,external_wp_i18n_namespaceObject.__)('Append to %1$s block at position %2$d, Level %3$d'), blockTitle, blockCount + 1, nestingLevel); 59519 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 59520 className: "list-view-appender", 59521 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, { 59522 ref: ref, 59523 rootClientId: clientId, 59524 position: "bottom right", 59525 isAppender: true, 59526 selectBlockOnInsert: false, 59527 shouldDirectInsert: false, 59528 __experimentalIsQuick: true, 59529 ...props, 59530 toggleProps: { 59531 'aria-describedby': descriptionId 59532 }, 59533 onSelectOrClose: maybeInsertedBlock => { 59534 if (maybeInsertedBlock?.clientId) { 59535 setInsertedBlock(maybeInsertedBlock); 59536 } 59537 } 59538 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AriaReferencedText, { 59539 id: descriptionId, 59540 children: description 59541 })] 59542 }); 59543 }); 59544 59545 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/leaf.js 59546 /** 59547 * External dependencies 59548 */ 59549 59550 59551 59552 /** 59553 * WordPress dependencies 59554 */ 59555 59556 59557 59558 59559 /** 59560 * Internal dependencies 59561 */ 59562 59563 59564 const AnimatedTreeGridRow = dist_esm_it(external_wp_components_namespaceObject.__experimentalTreeGridRow); 59565 const ListViewLeaf = (0,external_wp_element_namespaceObject.forwardRef)(({ 59566 isDragged, 59567 isSelected, 59568 position, 59569 level, 59570 rowCount, 59571 children, 59572 className, 59573 path, 59574 ...props 59575 }, ref) => { 59576 const animationRef = use_moving_animation({ 59577 clientId: props['data-block'], 59578 enableAnimation: true, 59579 triggerAnimationOnChange: path 59580 }); 59581 const mergedRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, animationRef]); 59582 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AnimatedTreeGridRow, { 59583 ref: mergedRef, 59584 className: dist_clsx('block-editor-list-view-leaf', className), 59585 level: level, 59586 positionInSet: position, 59587 setSize: rowCount, 59588 isExpanded: undefined, 59589 ...props, 59590 children: children 59591 }); 59592 }); 59593 /* harmony default export */ const leaf = (ListViewLeaf); 59594 59595 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-scroll-into-view.js 59596 /** 59597 * WordPress dependencies 59598 */ 59599 59600 59601 function useListViewScrollIntoView({ 59602 isSelected, 59603 selectedClientIds, 59604 rowItemRef 59605 }) { 59606 const isSingleSelection = selectedClientIds.length === 1; 59607 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 59608 // Skip scrolling into view if this particular block isn't selected, 59609 // or if more than one block is selected overall. This is to avoid 59610 // scrolling the view in a multi selection where the user has intentionally 59611 // selected multiple blocks within the list view, but the initially 59612 // selected block may be out of view. 59613 if (!isSelected || !isSingleSelection || !rowItemRef.current) { 59614 return; 59615 } 59616 const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(rowItemRef.current); 59617 const { 59618 ownerDocument 59619 } = rowItemRef.current; 59620 const windowScroll = scrollContainer === ownerDocument.body || scrollContainer === ownerDocument.documentElement; 59621 59622 // If the there is no scroll container, of if the scroll container is the window, 59623 // do not scroll into view, as the block is already in view. 59624 if (windowScroll || !scrollContainer) { 59625 return; 59626 } 59627 const rowRect = rowItemRef.current.getBoundingClientRect(); 59628 const scrollContainerRect = scrollContainer.getBoundingClientRect(); 59629 59630 // If the selected block is not currently visible, scroll to it. 59631 if (rowRect.top < scrollContainerRect.top || rowRect.bottom > scrollContainerRect.bottom) { 59632 rowItemRef.current.scrollIntoView(); 59633 } 59634 }, [isSelected, isSingleSelection, rowItemRef]); 59635 } 59636 59637 ;// ./node_modules/@wordpress/icons/build-module/library/pin-small.js 59638 /** 59639 * WordPress dependencies 59640 */ 59641 59642 59643 const pinSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 59644 width: "24", 59645 height: "24", 59646 viewBox: "0 0 24 24", 59647 xmlns: "http://www.w3.org/2000/svg", 59648 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 59649 d: "M10.97 10.159a3.382 3.382 0 0 0-2.857.955l1.724 1.723-2.836 2.913L7 17h1.25l2.913-2.837 1.723 1.723a3.38 3.38 0 0 0 .606-.825c.33-.63.446-1.343.35-2.032L17 10.695 13.305 7l-2.334 3.159Z" 59650 }) 59651 }); 59652 /* harmony default export */ const pin_small = (pinSmall); 59653 59654 ;// ./node_modules/@wordpress/icons/build-module/library/lock-small.js 59655 /** 59656 * WordPress dependencies 59657 */ 59658 59659 59660 const lockSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 59661 viewBox: "0 0 24 24", 59662 xmlns: "http://www.w3.org/2000/svg", 59663 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 59664 fillRule: "evenodd", 59665 clipRule: "evenodd", 59666 d: "M15 11h-.2V9c0-1.5-1.2-2.8-2.8-2.8S9.2 7.5 9.2 9v2H9c-.6 0-1 .4-1 1v4c0 .6.4 1 1 1h6c.6 0 1-.4 1-1v-4c0-.6-.4-1-1-1zm-1.8 0h-2.5V9c0-.7.6-1.2 1.2-1.2s1.2.6 1.2 1.2v2z" 59667 }) 59668 }); 59669 /* harmony default export */ const lock_small = (lockSmall); 59670 59671 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/expander.js 59672 /** 59673 * WordPress dependencies 59674 */ 59675 59676 59677 59678 function ListViewExpander({ 59679 onClick 59680 }) { 59681 return ( 59682 /*#__PURE__*/ 59683 // Keyboard events are handled by TreeGrid see: components/src/tree-grid/index.js 59684 // 59685 // The expander component is implemented as a pseudo element in the w3 example 59686 // https://www.w3.org/TR/wai-aria-practices/examples/treegrid/treegrid-1.html 59687 // 59688 // We've mimicked this by adding an icon with aria-hidden set to true to hide this from the accessibility tree. 59689 // For the current tree grid implementation, please do not try to make this a button. 59690 // 59691 // eslint-disable-next-line jsx-a11y/click-events-have-key-events,jsx-a11y/no-static-element-interactions 59692 (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 59693 className: "block-editor-list-view__expander", 59694 onClick: event => onClick(event, { 59695 forceToggle: true 59696 }), 59697 "aria-hidden": "true", 59698 "data-testid": "list-view-expander", 59699 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 59700 icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left_small : chevron_right_small 59701 }) 59702 }) 59703 ); 59704 } 59705 59706 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-images.js 59707 /** 59708 * WordPress dependencies 59709 */ 59710 59711 59712 59713 /** 59714 * Internal dependencies 59715 */ 59716 59717 59718 // Maximum number of images to display in a list view row. 59719 const MAX_IMAGES = 3; 59720 function getImage(block) { 59721 if (block.name !== 'core/image') { 59722 return; 59723 } 59724 if (block.attributes?.url) { 59725 return { 59726 url: block.attributes.url, 59727 alt: block.attributes.alt, 59728 clientId: block.clientId 59729 }; 59730 } 59731 } 59732 function getImagesFromGallery(block) { 59733 if (block.name !== 'core/gallery' || !block.innerBlocks) { 59734 return []; 59735 } 59736 const images = []; 59737 for (const innerBlock of block.innerBlocks) { 59738 const img = getImage(innerBlock); 59739 if (img) { 59740 images.push(img); 59741 } 59742 if (images.length >= MAX_IMAGES) { 59743 return images; 59744 } 59745 } 59746 return images; 59747 } 59748 function getImagesFromBlock(block, isExpanded) { 59749 const img = getImage(block); 59750 if (img) { 59751 return [img]; 59752 } 59753 return isExpanded ? [] : getImagesFromGallery(block); 59754 } 59755 59756 /** 59757 * Get a block's preview images for display within a list view row. 59758 * 59759 * TODO: Currently only supports images from the core/image and core/gallery 59760 * blocks. This should be expanded to support other blocks that have images, 59761 * potentially via an API that blocks can opt into / provide their own logic. 59762 * 59763 * @param {Object} props Hook properties. 59764 * @param {string} props.clientId The block's clientId. 59765 * @param {boolean} props.isExpanded Whether or not the block is expanded in the list view. 59766 * @return {Array} Images. 59767 */ 59768 function useListViewImages({ 59769 clientId, 59770 isExpanded 59771 }) { 59772 const { 59773 block 59774 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 59775 const _block = select(store).getBlock(clientId); 59776 return { 59777 block: _block 59778 }; 59779 }, [clientId]); 59780 const images = (0,external_wp_element_namespaceObject.useMemo)(() => { 59781 return getImagesFromBlock(block, isExpanded); 59782 }, [block, isExpanded]); 59783 return images; 59784 } 59785 59786 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/block-select-button.js 59787 /** 59788 * External dependencies 59789 */ 59790 59791 59792 /** 59793 * WordPress dependencies 59794 */ 59795 59796 59797 59798 59799 59800 59801 /** 59802 * Internal dependencies 59803 */ 59804 59805 59806 59807 59808 59809 59810 59811 59812 59813 function ListViewBlockSelectButton({ 59814 className, 59815 block: { 59816 clientId 59817 }, 59818 onClick, 59819 onContextMenu, 59820 onMouseDown, 59821 onToggleExpanded, 59822 tabIndex, 59823 onFocus, 59824 onDragStart, 59825 onDragEnd, 59826 draggable, 59827 isExpanded, 59828 ariaDescribedBy 59829 }, ref) { 59830 const blockInformation = useBlockDisplayInformation(clientId); 59831 const blockTitle = useBlockDisplayTitle({ 59832 clientId, 59833 context: 'list-view' 59834 }); 59835 const { 59836 isLocked 59837 } = useBlockLock(clientId); 59838 const { 59839 isContentOnly 59840 } = (0,external_wp_data_namespaceObject.useSelect)(select => ({ 59841 isContentOnly: select(store).getBlockEditingMode(clientId) === 'contentOnly' 59842 }), [clientId]); 59843 const shouldShowLockIcon = isLocked && !isContentOnly; 59844 const isSticky = blockInformation?.positionType === 'sticky'; 59845 const images = useListViewImages({ 59846 clientId, 59847 isExpanded 59848 }); 59849 59850 // The `href` attribute triggers the browser's native HTML drag operations. 59851 // When the link is dragged, the element's outerHTML is set in DataTransfer object as text/html. 59852 // We need to clear any HTML drag data to prevent `pasteHandler` from firing 59853 // inside the `useOnBlockDrop` hook. 59854 const onDragStartHandler = event => { 59855 event.dataTransfer.clearData(); 59856 onDragStart?.(event); 59857 }; 59858 59859 /** 59860 * @param {KeyboardEvent} event 59861 */ 59862 function onKeyDown(event) { 59863 if (event.keyCode === external_wp_keycodes_namespaceObject.ENTER || event.keyCode === external_wp_keycodes_namespaceObject.SPACE) { 59864 onClick(event); 59865 } 59866 } 59867 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("a", { 59868 className: dist_clsx('block-editor-list-view-block-select-button', className), 59869 onClick: onClick, 59870 onContextMenu: onContextMenu, 59871 onKeyDown: onKeyDown, 59872 onMouseDown: onMouseDown, 59873 ref: ref, 59874 tabIndex: tabIndex, 59875 onFocus: onFocus, 59876 onDragStart: onDragStartHandler, 59877 onDragEnd: onDragEnd, 59878 draggable: draggable, 59879 href: `#block-$clientId}`, 59880 "aria-describedby": ariaDescribedBy, 59881 "aria-expanded": isExpanded, 59882 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewExpander, { 59883 onClick: onToggleExpanded 59884 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 59885 icon: blockInformation?.icon, 59886 showColors: true, 59887 context: "list-view" 59888 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 59889 alignment: "center", 59890 className: "block-editor-list-view-block-select-button__label-wrapper", 59891 justify: "flex-start", 59892 spacing: 1, 59893 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 59894 className: "block-editor-list-view-block-select-button__title", 59895 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, { 59896 ellipsizeMode: "auto", 59897 children: blockTitle 59898 }) 59899 }), blockInformation?.anchor && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 59900 className: "block-editor-list-view-block-select-button__anchor-wrapper", 59901 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, { 59902 className: "block-editor-list-view-block-select-button__anchor", 59903 ellipsizeMode: "auto", 59904 children: blockInformation.anchor 59905 }) 59906 }), isSticky && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 59907 className: "block-editor-list-view-block-select-button__sticky", 59908 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 59909 icon: pin_small 59910 }) 59911 }), images.length ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 59912 className: "block-editor-list-view-block-select-button__images", 59913 "aria-hidden": true, 59914 children: images.map((image, index) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 59915 className: "block-editor-list-view-block-select-button__image", 59916 style: { 59917 backgroundImage: `url($image.url})`, 59918 zIndex: images.length - index // Ensure the first image is on top, and subsequent images are behind. 59919 } 59920 }, image.clientId)) 59921 }) : null, shouldShowLockIcon && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 59922 className: "block-editor-list-view-block-select-button__lock", 59923 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 59924 icon: lock_small 59925 }) 59926 })] 59927 })] 59928 }); 59929 } 59930 /* harmony default export */ const block_select_button = ((0,external_wp_element_namespaceObject.forwardRef)(ListViewBlockSelectButton)); 59931 59932 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/block-contents.js 59933 /** 59934 * External dependencies 59935 */ 59936 59937 59938 /** 59939 * WordPress dependencies 59940 */ 59941 59942 59943 59944 /** 59945 * Internal dependencies 59946 */ 59947 59948 59949 59950 59951 59952 59953 59954 const ListViewBlockContents = (0,external_wp_element_namespaceObject.forwardRef)(({ 59955 onClick, 59956 onToggleExpanded, 59957 block, 59958 isSelected, 59959 position, 59960 siblingBlockCount, 59961 level, 59962 isExpanded, 59963 selectedClientIds, 59964 ...props 59965 }, ref) => { 59966 const { 59967 clientId 59968 } = block; 59969 const { 59970 blockMovingClientId, 59971 selectedBlockInBlockEditor 59972 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 59973 const { 59974 hasBlockMovingClientId, 59975 getSelectedBlockClientId 59976 } = select(store); 59977 return { 59978 blockMovingClientId: hasBlockMovingClientId(), 59979 selectedBlockInBlockEditor: getSelectedBlockClientId() 59980 }; 59981 }, []); 59982 const { 59983 AdditionalBlockContent, 59984 insertedBlock, 59985 setInsertedBlock 59986 } = useListViewContext(); 59987 const isBlockMoveTarget = blockMovingClientId && selectedBlockInBlockEditor === clientId; 59988 const className = dist_clsx('block-editor-list-view-block-contents', { 59989 'is-dropping-before': isBlockMoveTarget 59990 }); 59991 59992 // Only include all selected blocks if the currently clicked on block 59993 // is one of the selected blocks. This ensures that if a user attempts 59994 // to drag a block that isn't part of the selection, they're still able 59995 // to drag it and rearrange its position. 59996 const draggableClientIds = selectedClientIds.includes(clientId) ? selectedClientIds : [clientId]; 59997 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 59998 children: [AdditionalBlockContent && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AdditionalBlockContent, { 59999 block: block, 60000 insertedBlock: insertedBlock, 60001 setInsertedBlock: setInsertedBlock 60002 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_draggable, { 60003 appendToOwnerDocument: true, 60004 clientIds: draggableClientIds, 60005 cloneClassname: "block-editor-list-view-draggable-chip", 60006 children: ({ 60007 draggable, 60008 onDragStart, 60009 onDragEnd 60010 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_select_button, { 60011 ref: ref, 60012 className: className, 60013 block: block, 60014 onClick: onClick, 60015 onToggleExpanded: onToggleExpanded, 60016 isSelected: isSelected, 60017 position: position, 60018 siblingBlockCount: siblingBlockCount, 60019 level: level, 60020 draggable: draggable, 60021 onDragStart: onDragStart, 60022 onDragEnd: onDragEnd, 60023 isExpanded: isExpanded, 60024 ...props 60025 }) 60026 })] 60027 }); 60028 }); 60029 /* harmony default export */ const block_contents = (ListViewBlockContents); 60030 60031 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/utils.js 60032 /** 60033 * WordPress dependencies 60034 */ 60035 60036 60037 const getBlockPositionDescription = (position, siblingCount, level) => (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: 1: The numerical position of the block. 2: The total number of blocks. 3. The level of nesting for the block. */ 60038 (0,external_wp_i18n_namespaceObject.__)('Block %1$d of %2$d, Level %3$d.'), position, siblingCount, level); 60039 const getBlockPropertiesDescription = (blockInformation, isLocked) => [blockInformation?.positionLabel ? `${(0,external_wp_i18n_namespaceObject.sprintf)( 60040 // translators: %s: Position of selected block, e.g. "Sticky" or "Fixed". 60041 (0,external_wp_i18n_namespaceObject.__)('Position: %s'), blockInformation.positionLabel)}.` : undefined, isLocked ? (0,external_wp_i18n_namespaceObject.__)('This block is locked.') : undefined].filter(Boolean).join(' '); 60042 60043 /** 60044 * Returns true if the client ID occurs within the block selection or multi-selection, 60045 * or false otherwise. 60046 * 60047 * @param {string} clientId Block client ID. 60048 * @param {string|string[]} selectedBlockClientIds Selected block client ID, or an array of multi-selected blocks client IDs. 60049 * 60050 * @return {boolean} Whether the block is in multi-selection set. 60051 */ 60052 const isClientIdSelected = (clientId, selectedBlockClientIds) => Array.isArray(selectedBlockClientIds) && selectedBlockClientIds.length ? selectedBlockClientIds.indexOf(clientId) !== -1 : selectedBlockClientIds === clientId; 60053 60054 /** 60055 * From a start and end clientId of potentially different nesting levels, 60056 * return the nearest-depth ids that have a common level of depth in the 60057 * nesting hierarchy. For multiple block selection, this ensure that the 60058 * selection is always at the same nesting level, and not split across 60059 * separate levels. 60060 * 60061 * @param {string} startId The first id of a selection. 60062 * @param {string} endId The end id of a selection, usually one that has been clicked on. 60063 * @param {string[]} startParents An array of ancestor ids for the start id, in descending order. 60064 * @param {string[]} endParents An array of ancestor ids for the end id, in descending order. 60065 * @return {Object} An object containing the start and end ids. 60066 */ 60067 function getCommonDepthClientIds(startId, endId, startParents, endParents) { 60068 const startPath = [...startParents, startId]; 60069 const endPath = [...endParents, endId]; 60070 const depth = Math.min(startPath.length, endPath.length) - 1; 60071 const start = startPath[depth]; 60072 const end = endPath[depth]; 60073 return { 60074 start, 60075 end 60076 }; 60077 } 60078 60079 /** 60080 * Shift focus to the list view item associated with a particular clientId. 60081 * 60082 * @typedef {import('@wordpress/element').RefObject} RefObject 60083 * 60084 * @param {string} focusClientId The client ID of the block to focus. 60085 * @param {?HTMLElement} treeGridElement The container element to search within. 60086 */ 60087 function focusListItem(focusClientId, treeGridElement) { 60088 const getFocusElement = () => { 60089 const row = treeGridElement?.querySelector(`[role=row][data-block="$focusClientId}"]`); 60090 if (!row) { 60091 return null; 60092 } 60093 // Focus the first focusable in the row, which is the ListViewBlockSelectButton. 60094 return external_wp_dom_namespaceObject.focus.focusable.find(row)[0]; 60095 }; 60096 let focusElement = getFocusElement(); 60097 if (focusElement) { 60098 focusElement.focus(); 60099 } else { 60100 // The element hasn't been painted yet. Defer focusing on the next frame. 60101 // This could happen when all blocks have been deleted and the default block 60102 // hasn't been added to the editor yet. 60103 window.requestAnimationFrame(() => { 60104 focusElement = getFocusElement(); 60105 60106 // Ignore if the element still doesn't exist. 60107 if (focusElement) { 60108 focusElement.focus(); 60109 } 60110 }); 60111 } 60112 } 60113 60114 /** 60115 * Get values for the block that flag whether the block should be displaced up or down, 60116 * whether the block is being nested, and whether the block appears after the dragged 60117 * blocks. These values are used to determine the class names to apply to the block. 60118 * The list view rows are displaced visually via CSS rules. Displacement rules: 60119 * - `normal`: no displacement — used to apply a translateY of `0` so that the block 60120 * appears in its original position, and moves to that position smoothly when dragging 60121 * outside of the list view area. 60122 * - `up`: the block should be displaced up, creating room beneath the block for the drop indicator. 60123 * - `down`: the block should be displaced down, creating room above the block for the drop indicator. 60124 * 60125 * @param {Object} props 60126 * @param {Object} props.blockIndexes The indexes of all the blocks in the list view, keyed by clientId. 60127 * @param {number|null|undefined} props.blockDropTargetIndex The index of the block that the user is dropping to. 60128 * @param {?string} props.blockDropPosition The position relative to the block that the user is dropping to. 60129 * @param {string} props.clientId The client id for the current block. 60130 * @param {?number} props.firstDraggedBlockIndex The index of the first dragged block. 60131 * @param {?boolean} props.isDragged Whether the current block is being dragged. Dragged blocks skip displacement. 60132 * @return {Object} An object containing the `displacement`, `isAfterDraggedBlocks` and `isNesting` values. 60133 */ 60134 function getDragDisplacementValues({ 60135 blockIndexes, 60136 blockDropTargetIndex, 60137 blockDropPosition, 60138 clientId, 60139 firstDraggedBlockIndex, 60140 isDragged 60141 }) { 60142 let displacement; 60143 let isNesting; 60144 let isAfterDraggedBlocks; 60145 if (!isDragged) { 60146 isNesting = false; 60147 const thisBlockIndex = blockIndexes[clientId]; 60148 isAfterDraggedBlocks = thisBlockIndex > firstDraggedBlockIndex; 60149 60150 // Determine where to displace the position of the current block, relative 60151 // to the blocks being dragged (in their original position) and the drop target 60152 // (the position where a user is currently dragging the blocks to). 60153 if (blockDropTargetIndex !== undefined && blockDropTargetIndex !== null && firstDraggedBlockIndex !== undefined) { 60154 // If the block is being dragged and there is a valid drop target, 60155 // determine if the block being rendered should be displaced up or down. 60156 60157 if (thisBlockIndex !== undefined) { 60158 if (thisBlockIndex >= firstDraggedBlockIndex && thisBlockIndex < blockDropTargetIndex) { 60159 // If the current block appears after the set of dragged blocks 60160 // (in their original position), but is before the drop target, 60161 // then the current block should be displaced up. 60162 displacement = 'up'; 60163 } else if (thisBlockIndex < firstDraggedBlockIndex && thisBlockIndex >= blockDropTargetIndex) { 60164 // If the current block appears before the set of dragged blocks 60165 // (in their original position), but is after the drop target, 60166 // then the current block should be displaced down. 60167 displacement = 'down'; 60168 } else { 60169 displacement = 'normal'; 60170 } 60171 isNesting = typeof blockDropTargetIndex === 'number' && blockDropTargetIndex - 1 === thisBlockIndex && blockDropPosition === 'inside'; 60172 } 60173 } else if (blockDropTargetIndex === null && firstDraggedBlockIndex !== undefined) { 60174 // A `null` value for `blockDropTargetIndex` indicates that the 60175 // drop target is outside of the valid areas within the list view. 60176 // In this case, the drag is still active, but as there is no 60177 // valid drop target, we should remove the gap indicating where 60178 // the block would be inserted. 60179 if (thisBlockIndex !== undefined && thisBlockIndex >= firstDraggedBlockIndex) { 60180 displacement = 'up'; 60181 } else { 60182 displacement = 'normal'; 60183 } 60184 } else if (blockDropTargetIndex !== undefined && blockDropTargetIndex !== null && firstDraggedBlockIndex === undefined) { 60185 // If the blockdrop target is defined, but there are no dragged blocks, 60186 // then the block should be displaced relative to the drop target. 60187 if (thisBlockIndex !== undefined) { 60188 if (thisBlockIndex < blockDropTargetIndex) { 60189 displacement = 'normal'; 60190 } else { 60191 displacement = 'down'; 60192 } 60193 } 60194 } else if (blockDropTargetIndex === null) { 60195 displacement = 'normal'; 60196 } 60197 } 60198 return { 60199 displacement, 60200 isNesting, 60201 isAfterDraggedBlocks 60202 }; 60203 } 60204 60205 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/block.js 60206 /** 60207 * External dependencies 60208 */ 60209 60210 60211 /** 60212 * WordPress dependencies 60213 */ 60214 60215 60216 60217 60218 60219 60220 60221 60222 60223 60224 60225 60226 /** 60227 * Internal dependencies 60228 */ 60229 60230 60231 60232 60233 60234 60235 60236 60237 60238 60239 60240 60241 60242 60243 function ListViewBlock({ 60244 block: { 60245 clientId 60246 }, 60247 displacement, 60248 isAfterDraggedBlocks, 60249 isDragged, 60250 isNesting, 60251 isSelected, 60252 isBranchSelected, 60253 selectBlock, 60254 position, 60255 level, 60256 rowCount, 60257 siblingBlockCount, 60258 showBlockMovers, 60259 path, 60260 isExpanded, 60261 selectedClientIds, 60262 isSyncedBranch 60263 }) { 60264 const cellRef = (0,external_wp_element_namespaceObject.useRef)(null); 60265 const rowRef = (0,external_wp_element_namespaceObject.useRef)(null); 60266 const settingsRef = (0,external_wp_element_namespaceObject.useRef)(null); 60267 const [isHovered, setIsHovered] = (0,external_wp_element_namespaceObject.useState)(false); 60268 const [settingsAnchorRect, setSettingsAnchorRect] = (0,external_wp_element_namespaceObject.useState)(); 60269 const { 60270 isLocked, 60271 canEdit, 60272 canMove 60273 } = useBlockLock(clientId); 60274 const isFirstSelectedBlock = isSelected && selectedClientIds[0] === clientId; 60275 const isLastSelectedBlock = isSelected && selectedClientIds[selectedClientIds.length - 1] === clientId; 60276 const { 60277 toggleBlockHighlight, 60278 duplicateBlocks, 60279 multiSelect, 60280 replaceBlocks, 60281 removeBlocks, 60282 insertAfterBlock, 60283 insertBeforeBlock, 60284 setOpenedBlockSettingsMenu 60285 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 60286 const { 60287 canInsertBlockType, 60288 getSelectedBlockClientIds, 60289 getPreviousBlockClientId, 60290 getBlockRootClientId, 60291 getBlockOrder, 60292 getBlockParents, 60293 getBlocksByClientId, 60294 canRemoveBlocks, 60295 isGroupable 60296 } = (0,external_wp_data_namespaceObject.useSelect)(store); 60297 const { 60298 getGroupingBlockName 60299 } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store); 60300 const blockInformation = useBlockDisplayInformation(clientId); 60301 const { 60302 block, 60303 blockName, 60304 allowRightClickOverrides 60305 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 60306 const { 60307 getBlock, 60308 getBlockName, 60309 getSettings 60310 } = select(store); 60311 return { 60312 block: getBlock(clientId), 60313 blockName: getBlockName(clientId), 60314 allowRightClickOverrides: getSettings().allowRightClickOverrides 60315 }; 60316 }, [clientId]); 60317 const showBlockActions = 60318 // When a block hides its toolbar it also hides the block settings menu, 60319 // since that menu is part of the toolbar in the editor canvas. 60320 // List View respects this by also hiding the block settings menu. 60321 (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, '__experimentalToolbar', true); 60322 const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(ListViewBlock); 60323 const descriptionId = `list-view-block-select-button__description-$instanceId}`; 60324 const { 60325 expand, 60326 collapse, 60327 collapseAll, 60328 BlockSettingsMenu, 60329 listViewInstanceId, 60330 expandedState, 60331 setInsertedBlock, 60332 treeGridElementRef, 60333 rootClientId 60334 } = useListViewContext(); 60335 const isMatch = (0,external_wp_keyboardShortcuts_namespaceObject.__unstableUseShortcutEventMatch)(); 60336 60337 // Determine which blocks to update: 60338 // If the current (focused) block is part of the block selection, use the whole selection. 60339 // If the focused block is not part of the block selection, only update the focused block. 60340 function getBlocksToUpdate() { 60341 const selectedBlockClientIds = getSelectedBlockClientIds(); 60342 const isUpdatingSelectedBlocks = selectedBlockClientIds.includes(clientId); 60343 const firstBlockClientId = isUpdatingSelectedBlocks ? selectedBlockClientIds[0] : clientId; 60344 const firstBlockRootClientId = getBlockRootClientId(firstBlockClientId); 60345 const blocksToUpdate = isUpdatingSelectedBlocks ? selectedBlockClientIds : [clientId]; 60346 return { 60347 blocksToUpdate, 60348 firstBlockClientId, 60349 firstBlockRootClientId, 60350 selectedBlockClientIds 60351 }; 60352 } 60353 60354 /** 60355 * @param {KeyboardEvent} event 60356 */ 60357 async function onKeyDown(event) { 60358 if (event.defaultPrevented) { 60359 return; 60360 } 60361 60362 // Do not handle events if it comes from modals; 60363 // retain the default behavior for these keys. 60364 if (event.target.closest('[role=dialog]')) { 60365 return; 60366 } 60367 const isDeleteKey = [external_wp_keycodes_namespaceObject.BACKSPACE, external_wp_keycodes_namespaceObject.DELETE].includes(event.keyCode); 60368 60369 // If multiple blocks are selected, deselect all blocks when the user 60370 // presses the escape key. 60371 if (isMatch('core/block-editor/unselect', event) && selectedClientIds.length > 0) { 60372 event.stopPropagation(); 60373 event.preventDefault(); 60374 selectBlock(event, undefined); 60375 } else if (isDeleteKey || isMatch('core/block-editor/remove', event)) { 60376 var _getPreviousBlockClie; 60377 const { 60378 blocksToUpdate: blocksToDelete, 60379 firstBlockClientId, 60380 firstBlockRootClientId, 60381 selectedBlockClientIds 60382 } = getBlocksToUpdate(); 60383 60384 // Don't update the selection if the blocks cannot be deleted. 60385 if (!canRemoveBlocks(blocksToDelete)) { 60386 return; 60387 } 60388 let blockToFocus = (_getPreviousBlockClie = getPreviousBlockClientId(firstBlockClientId)) !== null && _getPreviousBlockClie !== void 0 ? _getPreviousBlockClie : 60389 // If the previous block is not found (when the first block is deleted), 60390 // fallback to focus the parent block. 60391 firstBlockRootClientId; 60392 removeBlocks(blocksToDelete, false); 60393 60394 // Update the selection if the original selection has been removed. 60395 const shouldUpdateSelection = selectedBlockClientIds.length > 0 && getSelectedBlockClientIds().length === 0; 60396 60397 // If there's no previous block nor parent block, focus the first block. 60398 if (!blockToFocus) { 60399 blockToFocus = getBlockOrder()[0]; 60400 } 60401 updateFocusAndSelection(blockToFocus, shouldUpdateSelection); 60402 } else if (isMatch('core/block-editor/duplicate', event)) { 60403 event.preventDefault(); 60404 const { 60405 blocksToUpdate, 60406 firstBlockRootClientId 60407 } = getBlocksToUpdate(); 60408 const canDuplicate = getBlocksByClientId(blocksToUpdate).every(blockToUpdate => { 60409 return !!blockToUpdate && (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockToUpdate.name, 'multiple', true) && canInsertBlockType(blockToUpdate.name, firstBlockRootClientId); 60410 }); 60411 if (canDuplicate) { 60412 const updatedBlocks = await duplicateBlocks(blocksToUpdate, false); 60413 if (updatedBlocks?.length) { 60414 // If blocks have been duplicated, focus the first duplicated block. 60415 updateFocusAndSelection(updatedBlocks[0], false); 60416 } 60417 } 60418 } else if (isMatch('core/block-editor/insert-before', event)) { 60419 event.preventDefault(); 60420 const { 60421 blocksToUpdate 60422 } = getBlocksToUpdate(); 60423 await insertBeforeBlock(blocksToUpdate[0]); 60424 const newlySelectedBlocks = getSelectedBlockClientIds(); 60425 60426 // Focus the first block of the newly inserted blocks, to keep focus within the list view. 60427 setOpenedBlockSettingsMenu(undefined); 60428 updateFocusAndSelection(newlySelectedBlocks[0], false); 60429 } else if (isMatch('core/block-editor/insert-after', event)) { 60430 event.preventDefault(); 60431 const { 60432 blocksToUpdate 60433 } = getBlocksToUpdate(); 60434 await insertAfterBlock(blocksToUpdate.at(-1)); 60435 const newlySelectedBlocks = getSelectedBlockClientIds(); 60436 60437 // Focus the first block of the newly inserted blocks, to keep focus within the list view. 60438 setOpenedBlockSettingsMenu(undefined); 60439 updateFocusAndSelection(newlySelectedBlocks[0], false); 60440 } else if (isMatch('core/block-editor/select-all', event)) { 60441 event.preventDefault(); 60442 const { 60443 firstBlockRootClientId, 60444 selectedBlockClientIds 60445 } = getBlocksToUpdate(); 60446 const blockClientIds = getBlockOrder(firstBlockRootClientId); 60447 if (!blockClientIds.length) { 60448 return; 60449 } 60450 60451 // If we have selected all sibling nested blocks, try selecting up a level. 60452 // This is a similar implementation to that used by `useSelectAll`. 60453 // `isShallowEqual` is used for the list view instead of a length check, 60454 // as the array of siblings of the currently focused block may be a different 60455 // set of blocks from the current block selection if the user is focused 60456 // on a different part of the list view from the block selection. 60457 if (external_wp_isShallowEqual_default()(selectedBlockClientIds, blockClientIds)) { 60458 // Only select up a level if the first block is not the root block. 60459 // This ensures that the block selection can't break out of the root block 60460 // used by the list view, if the list view is only showing a partial hierarchy. 60461 if (firstBlockRootClientId && firstBlockRootClientId !== rootClientId) { 60462 updateFocusAndSelection(firstBlockRootClientId, true); 60463 return; 60464 } 60465 } 60466 60467 // Select all while passing `null` to skip focusing to the editor canvas, 60468 // and retain focus within the list view. 60469 multiSelect(blockClientIds[0], blockClientIds[blockClientIds.length - 1], null); 60470 } else if (isMatch('core/block-editor/collapse-list-view', event)) { 60471 event.preventDefault(); 60472 const { 60473 firstBlockClientId 60474 } = getBlocksToUpdate(); 60475 const blockParents = getBlockParents(firstBlockClientId, false); 60476 // Collapse all blocks. 60477 collapseAll(); 60478 // Expand all parents of the current block. 60479 expand(blockParents); 60480 } else if (isMatch('core/block-editor/group', event)) { 60481 const { 60482 blocksToUpdate 60483 } = getBlocksToUpdate(); 60484 if (blocksToUpdate.length > 1 && isGroupable(blocksToUpdate)) { 60485 event.preventDefault(); 60486 const blocks = getBlocksByClientId(blocksToUpdate); 60487 const groupingBlockName = getGroupingBlockName(); 60488 const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, groupingBlockName); 60489 replaceBlocks(blocksToUpdate, newBlocks); 60490 (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('Selected blocks are grouped.')); 60491 const newlySelectedBlocks = getSelectedBlockClientIds(); 60492 // Focus the first block of the newly inserted blocks, to keep focus within the list view. 60493 setOpenedBlockSettingsMenu(undefined); 60494 updateFocusAndSelection(newlySelectedBlocks[0], false); 60495 } 60496 } 60497 } 60498 const onMouseEnter = (0,external_wp_element_namespaceObject.useCallback)(() => { 60499 setIsHovered(true); 60500 toggleBlockHighlight(clientId, true); 60501 }, [clientId, setIsHovered, toggleBlockHighlight]); 60502 const onMouseLeave = (0,external_wp_element_namespaceObject.useCallback)(() => { 60503 setIsHovered(false); 60504 toggleBlockHighlight(clientId, false); 60505 }, [clientId, setIsHovered, toggleBlockHighlight]); 60506 const selectEditorBlock = (0,external_wp_element_namespaceObject.useCallback)(event => { 60507 selectBlock(event, clientId); 60508 event.preventDefault(); 60509 }, [clientId, selectBlock]); 60510 const updateFocusAndSelection = (0,external_wp_element_namespaceObject.useCallback)((focusClientId, shouldSelectBlock) => { 60511 if (shouldSelectBlock) { 60512 selectBlock(undefined, focusClientId, null, null); 60513 } 60514 focusListItem(focusClientId, treeGridElementRef?.current); 60515 }, [selectBlock, treeGridElementRef]); 60516 const toggleExpanded = (0,external_wp_element_namespaceObject.useCallback)(event => { 60517 // Prevent shift+click from opening link in a new window when toggling. 60518 event.preventDefault(); 60519 event.stopPropagation(); 60520 if (isExpanded === true) { 60521 collapse(clientId); 60522 } else if (isExpanded === false) { 60523 expand(clientId); 60524 } 60525 }, [clientId, expand, collapse, isExpanded]); 60526 60527 // Allow right-clicking an item in the List View to open up the block settings dropdown. 60528 const onContextMenu = (0,external_wp_element_namespaceObject.useCallback)(event => { 60529 if (showBlockActions && allowRightClickOverrides) { 60530 settingsRef.current?.click(); 60531 // Ensure the position of the settings dropdown is at the cursor. 60532 setSettingsAnchorRect(new window.DOMRect(event.clientX, event.clientY, 0, 0)); 60533 event.preventDefault(); 60534 } 60535 }, [allowRightClickOverrides, settingsRef, showBlockActions]); 60536 const onMouseDown = (0,external_wp_element_namespaceObject.useCallback)(event => { 60537 // Prevent right-click from focusing the block, 60538 // because focus will be handled when opening the block settings dropdown. 60539 if (allowRightClickOverrides && event.button === 2) { 60540 event.preventDefault(); 60541 } 60542 }, [allowRightClickOverrides]); 60543 const settingsPopoverAnchor = (0,external_wp_element_namespaceObject.useMemo)(() => { 60544 const { 60545 ownerDocument 60546 } = rowRef?.current || {}; 60547 60548 // If no custom position is set, the settings dropdown will be anchored to the 60549 // DropdownMenu toggle button. 60550 if (!settingsAnchorRect || !ownerDocument) { 60551 return undefined; 60552 } 60553 60554 // Position the settings dropdown at the cursor when right-clicking a block. 60555 return { 60556 ownerDocument, 60557 getBoundingClientRect() { 60558 return settingsAnchorRect; 60559 } 60560 }; 60561 }, [settingsAnchorRect]); 60562 const clearSettingsAnchorRect = (0,external_wp_element_namespaceObject.useCallback)(() => { 60563 // Clear the custom position for the settings dropdown so that it is restored back 60564 // to being anchored to the DropdownMenu toggle button. 60565 setSettingsAnchorRect(undefined); 60566 }, [setSettingsAnchorRect]); 60567 60568 // Pass in a ref to the row, so that it can be scrolled 60569 // into view when selected. For long lists, the placeholder for the 60570 // selected block is also observed, within ListViewLeafPlaceholder. 60571 useListViewScrollIntoView({ 60572 isSelected, 60573 rowItemRef: rowRef, 60574 selectedClientIds 60575 }); 60576 60577 // When switching between rendering modes (such as template preview and content only), 60578 // it is possible for a block to temporarily be unavailable. In this case, we should not 60579 // render the leaf, to avoid errors further down the tree. 60580 if (!block) { 60581 return null; 60582 } 60583 const blockPositionDescription = getBlockPositionDescription(position, siblingBlockCount, level); 60584 const blockPropertiesDescription = getBlockPropertiesDescription(blockInformation, isLocked); 60585 const hasSiblings = siblingBlockCount > 0; 60586 const hasRenderedMovers = showBlockMovers && hasSiblings; 60587 const moverCellClassName = dist_clsx('block-editor-list-view-block__mover-cell', { 60588 'is-visible': isHovered || isSelected 60589 }); 60590 const listViewBlockSettingsClassName = dist_clsx('block-editor-list-view-block__menu-cell', { 60591 'is-visible': isHovered || isFirstSelectedBlock 60592 }); 60593 let colSpan; 60594 if (hasRenderedMovers) { 60595 colSpan = 2; 60596 } else if (!showBlockActions) { 60597 colSpan = 3; 60598 } 60599 const classes = dist_clsx({ 60600 'is-selected': isSelected, 60601 'is-first-selected': isFirstSelectedBlock, 60602 'is-last-selected': isLastSelectedBlock, 60603 'is-branch-selected': isBranchSelected, 60604 'is-synced-branch': isSyncedBranch, 60605 'is-dragging': isDragged, 60606 'has-single-cell': !showBlockActions, 60607 'is-synced': blockInformation?.isSynced, 60608 'is-draggable': canMove, 60609 'is-displacement-normal': displacement === 'normal', 60610 'is-displacement-up': displacement === 'up', 60611 'is-displacement-down': displacement === 'down', 60612 'is-after-dragged-blocks': isAfterDraggedBlocks, 60613 'is-nesting': isNesting 60614 }); 60615 60616 // Only include all selected blocks if the currently clicked on block 60617 // is one of the selected blocks. This ensures that if a user attempts 60618 // to alter a block that isn't part of the selection, they're still able 60619 // to do so. 60620 const dropdownClientIds = selectedClientIds.includes(clientId) ? selectedClientIds : [clientId]; 60621 60622 // Detect if there is a block in the canvas currently being edited and multi-selection is not happening. 60623 const currentlyEditingBlockInCanvas = isSelected && selectedClientIds.length === 1; 60624 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(leaf, { 60625 className: classes, 60626 isDragged: isDragged, 60627 onKeyDown: onKeyDown, 60628 onMouseEnter: onMouseEnter, 60629 onMouseLeave: onMouseLeave, 60630 onFocus: onMouseEnter, 60631 onBlur: onMouseLeave, 60632 level: level, 60633 position: position, 60634 rowCount: rowCount, 60635 path: path, 60636 id: `list-view-$listViewInstanceId}-block-$clientId}`, 60637 "data-block": clientId, 60638 "data-expanded": canEdit ? isExpanded : undefined, 60639 ref: rowRef, 60640 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridCell, { 60641 className: "block-editor-list-view-block__contents-cell", 60642 colSpan: colSpan, 60643 ref: cellRef, 60644 "aria-selected": !!isSelected, 60645 children: ({ 60646 ref, 60647 tabIndex, 60648 onFocus 60649 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 60650 className: "block-editor-list-view-block__contents-container", 60651 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_contents, { 60652 block: block, 60653 onClick: selectEditorBlock, 60654 onContextMenu: onContextMenu, 60655 onMouseDown: onMouseDown, 60656 onToggleExpanded: toggleExpanded, 60657 isSelected: isSelected, 60658 position: position, 60659 siblingBlockCount: siblingBlockCount, 60660 level: level, 60661 ref: ref, 60662 tabIndex: currentlyEditingBlockInCanvas ? 0 : tabIndex, 60663 onFocus: onFocus, 60664 isExpanded: canEdit ? isExpanded : undefined, 60665 selectedClientIds: selectedClientIds, 60666 ariaDescribedBy: descriptionId 60667 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AriaReferencedText, { 60668 id: descriptionId, 60669 children: [blockPositionDescription, blockPropertiesDescription].filter(Boolean).join(' ') 60670 })] 60671 }) 60672 }), hasRenderedMovers && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 60673 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalTreeGridCell, { 60674 className: moverCellClassName, 60675 withoutGridItem: true, 60676 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridItem, { 60677 children: ({ 60678 ref, 60679 tabIndex, 60680 onFocus 60681 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverUpButton, { 60682 orientation: "vertical", 60683 clientIds: [clientId], 60684 ref: ref, 60685 tabIndex: tabIndex, 60686 onFocus: onFocus 60687 }) 60688 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridItem, { 60689 children: ({ 60690 ref, 60691 tabIndex, 60692 onFocus 60693 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverDownButton, { 60694 orientation: "vertical", 60695 clientIds: [clientId], 60696 ref: ref, 60697 tabIndex: tabIndex, 60698 onFocus: onFocus 60699 }) 60700 })] 60701 }) 60702 }), showBlockActions && BlockSettingsMenu && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridCell, { 60703 className: listViewBlockSettingsClassName, 60704 "aria-selected": !!isSelected, 60705 ref: settingsRef, 60706 children: ({ 60707 ref, 60708 tabIndex, 60709 onFocus 60710 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockSettingsMenu, { 60711 clientIds: dropdownClientIds, 60712 block: block, 60713 icon: more_vertical, 60714 label: (0,external_wp_i18n_namespaceObject.__)('Options'), 60715 popoverProps: { 60716 anchor: settingsPopoverAnchor // Used to position the settings at the cursor on right-click. 60717 }, 60718 toggleProps: { 60719 ref, 60720 className: 'block-editor-list-view-block__menu', 60721 tabIndex, 60722 onClick: clearSettingsAnchorRect, 60723 onFocus 60724 }, 60725 disableOpenOnArrowDown: true, 60726 expand: expand, 60727 expandedState: expandedState, 60728 setInsertedBlock: setInsertedBlock, 60729 __experimentalSelectBlock: updateFocusAndSelection 60730 }) 60731 })] 60732 }); 60733 } 60734 /* harmony default export */ const list_view_block = ((0,external_wp_element_namespaceObject.memo)(ListViewBlock)); 60735 60736 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/branch.js 60737 /** 60738 * WordPress dependencies 60739 */ 60740 60741 60742 60743 60744 /** 60745 * Internal dependencies 60746 */ 60747 60748 60749 60750 60751 60752 60753 60754 /** 60755 * Given a block, returns the total number of blocks in that subtree. This is used to help determine 60756 * the list position of a block. 60757 * 60758 * When a block is collapsed, we do not count their children as part of that total. In the current drag 60759 * implementation dragged blocks and their children are not counted. 60760 * 60761 * @param {Object} block block tree 60762 * @param {Object} expandedState state that notes which branches are collapsed 60763 * @param {Array} draggedClientIds a list of dragged client ids 60764 * @param {boolean} isExpandedByDefault flag to determine the default fallback expanded state. 60765 * @return {number} block count 60766 */ 60767 60768 60769 60770 function countBlocks(block, expandedState, draggedClientIds, isExpandedByDefault) { 60771 var _expandedState$block$; 60772 const isDragged = draggedClientIds?.includes(block.clientId); 60773 if (isDragged) { 60774 return 0; 60775 } 60776 const isExpanded = (_expandedState$block$ = expandedState[block.clientId]) !== null && _expandedState$block$ !== void 0 ? _expandedState$block$ : isExpandedByDefault; 60777 if (isExpanded) { 60778 return 1 + block.innerBlocks.reduce(countReducer(expandedState, draggedClientIds, isExpandedByDefault), 0); 60779 } 60780 return 1; 60781 } 60782 const countReducer = (expandedState, draggedClientIds, isExpandedByDefault) => (count, block) => { 60783 var _expandedState$block$2; 60784 const isDragged = draggedClientIds?.includes(block.clientId); 60785 if (isDragged) { 60786 return count; 60787 } 60788 const isExpanded = (_expandedState$block$2 = expandedState[block.clientId]) !== null && _expandedState$block$2 !== void 0 ? _expandedState$block$2 : isExpandedByDefault; 60789 if (isExpanded && block.innerBlocks.length > 0) { 60790 return count + countBlocks(block, expandedState, draggedClientIds, isExpandedByDefault); 60791 } 60792 return count + 1; 60793 }; 60794 const branch_noop = () => {}; 60795 function ListViewBranch(props) { 60796 const { 60797 blocks, 60798 selectBlock = branch_noop, 60799 showBlockMovers, 60800 selectedClientIds, 60801 level = 1, 60802 path = '', 60803 isBranchSelected = false, 60804 listPosition = 0, 60805 fixedListWindow, 60806 isExpanded, 60807 parentId, 60808 shouldShowInnerBlocks = true, 60809 isSyncedBranch = false, 60810 showAppender: showAppenderProp = true 60811 } = props; 60812 const parentBlockInformation = useBlockDisplayInformation(parentId); 60813 const syncedBranch = isSyncedBranch || !!parentBlockInformation?.isSynced; 60814 const canParentExpand = (0,external_wp_data_namespaceObject.useSelect)(select => { 60815 if (!parentId) { 60816 return true; 60817 } 60818 return select(store).canEditBlock(parentId); 60819 }, [parentId]); 60820 const { 60821 blockDropPosition, 60822 blockDropTargetIndex, 60823 firstDraggedBlockIndex, 60824 blockIndexes, 60825 expandedState, 60826 draggedClientIds 60827 } = useListViewContext(); 60828 if (!canParentExpand) { 60829 return null; 60830 } 60831 60832 // Only show the appender at the first level. 60833 const showAppender = showAppenderProp && level === 1; 60834 const filteredBlocks = blocks.filter(Boolean); 60835 const blockCount = filteredBlocks.length; 60836 // The appender means an extra row in List View, so add 1 to the row count. 60837 const rowCount = showAppender ? blockCount + 1 : blockCount; 60838 let nextPosition = listPosition; 60839 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 60840 children: [filteredBlocks.map((block, index) => { 60841 var _expandedState$client; 60842 const { 60843 clientId, 60844 innerBlocks 60845 } = block; 60846 if (index > 0) { 60847 nextPosition += countBlocks(filteredBlocks[index - 1], expandedState, draggedClientIds, isExpanded); 60848 } 60849 const isDragged = !!draggedClientIds?.includes(clientId); 60850 60851 // Determine the displacement of the block while dragging. This 60852 // works out whether the current block should be displaced up or 60853 // down, relative to the dragged blocks and the drop target. 60854 const { 60855 displacement, 60856 isAfterDraggedBlocks, 60857 isNesting 60858 } = getDragDisplacementValues({ 60859 blockIndexes, 60860 blockDropTargetIndex, 60861 blockDropPosition, 60862 clientId, 60863 firstDraggedBlockIndex, 60864 isDragged 60865 }); 60866 const { 60867 itemInView 60868 } = fixedListWindow; 60869 const blockInView = itemInView(nextPosition); 60870 const position = index + 1; 60871 const updatedPath = path.length > 0 ? `$path}_$position}` : `$position}`; 60872 const hasNestedBlocks = !!innerBlocks?.length; 60873 const shouldExpand = hasNestedBlocks && shouldShowInnerBlocks ? (_expandedState$client = expandedState[clientId]) !== null && _expandedState$client !== void 0 ? _expandedState$client : isExpanded : undefined; 60874 60875 // Make updates to the selected or dragged blocks synchronous, 60876 // but asynchronous for any other block. 60877 const isSelected = isClientIdSelected(clientId, selectedClientIds); 60878 const isSelectedBranch = isBranchSelected || isSelected && hasNestedBlocks; 60879 60880 // To avoid performance issues, we only render blocks that are in view, 60881 // or blocks that are selected or dragged. If a block is selected, 60882 // it is only counted if it is the first of the block selection. 60883 // This prevents the entire tree from being rendered when a branch is 60884 // selected, or a user selects all blocks, while still enabling scroll 60885 // into view behavior when selecting a block or opening the list view. 60886 // The first and last blocks of the list are always rendered, to ensure 60887 // that Home and End keys work as expected. 60888 const showBlock = isDragged || blockInView || isSelected && clientId === selectedClientIds[0] || index === 0 || index === blockCount - 1; 60889 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_data_namespaceObject.AsyncModeProvider, { 60890 value: !isSelected, 60891 children: [showBlock && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(list_view_block, { 60892 block: block, 60893 selectBlock: selectBlock, 60894 isSelected: isSelected, 60895 isBranchSelected: isSelectedBranch, 60896 isDragged: isDragged, 60897 level: level, 60898 position: position, 60899 rowCount: rowCount, 60900 siblingBlockCount: blockCount, 60901 showBlockMovers: showBlockMovers, 60902 path: updatedPath, 60903 isExpanded: isDragged ? false : shouldExpand, 60904 listPosition: nextPosition, 60905 selectedClientIds: selectedClientIds, 60906 isSyncedBranch: syncedBranch, 60907 displacement: displacement, 60908 isAfterDraggedBlocks: isAfterDraggedBlocks, 60909 isNesting: isNesting 60910 }), !showBlock && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("tr", { 60911 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("td", { 60912 className: "block-editor-list-view-placeholder" 60913 }) 60914 }), hasNestedBlocks && shouldExpand && !isDragged && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewBranch, { 60915 parentId: clientId, 60916 blocks: innerBlocks, 60917 selectBlock: selectBlock, 60918 showBlockMovers: showBlockMovers, 60919 level: level + 1, 60920 path: updatedPath, 60921 listPosition: nextPosition + 1, 60922 fixedListWindow: fixedListWindow, 60923 isBranchSelected: isSelectedBranch, 60924 selectedClientIds: selectedClientIds, 60925 isExpanded: isExpanded, 60926 isSyncedBranch: syncedBranch 60927 })] 60928 }, clientId); 60929 }), showAppender && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridRow, { 60930 level: level, 60931 setSize: rowCount, 60932 positionInSet: rowCount, 60933 isExpanded: true, 60934 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridCell, { 60935 children: treeGridCellProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Appender, { 60936 clientId: parentId, 60937 nestingLevel: level, 60938 blockCount: blockCount, 60939 ...treeGridCellProps 60940 }) 60941 }) 60942 })] 60943 }); 60944 } 60945 /* harmony default export */ const branch = ((0,external_wp_element_namespaceObject.memo)(ListViewBranch)); 60946 60947 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/drop-indicator.js 60948 /** 60949 * External dependencies 60950 */ 60951 60952 60953 /** 60954 * WordPress dependencies 60955 */ 60956 60957 60958 60959 60960 60961 /** 60962 * Internal dependencies 60963 */ 60964 60965 60966 60967 60968 60969 60970 function ListViewDropIndicatorPreview({ 60971 draggedBlockClientId, 60972 listViewRef, 60973 blockDropTarget 60974 }) { 60975 const blockInformation = useBlockDisplayInformation(draggedBlockClientId); 60976 const blockTitle = useBlockDisplayTitle({ 60977 clientId: draggedBlockClientId, 60978 context: 'list-view' 60979 }); 60980 const { 60981 rootClientId, 60982 clientId, 60983 dropPosition 60984 } = blockDropTarget || {}; 60985 const [rootBlockElement, blockElement] = (0,external_wp_element_namespaceObject.useMemo)(() => { 60986 if (!listViewRef.current) { 60987 return []; 60988 } 60989 60990 // The rootClientId will be defined whenever dropping into inner 60991 // block lists, but is undefined when dropping at the root level. 60992 const _rootBlockElement = rootClientId ? listViewRef.current.querySelector(`[data-block="$rootClientId}"]`) : undefined; 60993 60994 // The clientId represents the sibling block, the dragged block will 60995 // usually be inserted adjacent to it. It will be undefined when 60996 // dropping a block into an empty block list. 60997 const _blockElement = clientId ? listViewRef.current.querySelector(`[data-block="$clientId}"]`) : undefined; 60998 return [_rootBlockElement, _blockElement]; 60999 }, [listViewRef, rootClientId, clientId]); 61000 61001 // The targetElement is the element that the drop indicator will appear 61002 // before or after. When dropping into an empty block list, blockElement 61003 // is undefined, so the indicator will appear after the rootBlockElement. 61004 const targetElement = blockElement || rootBlockElement; 61005 const rtl = (0,external_wp_i18n_namespaceObject.isRTL)(); 61006 const getDropIndicatorWidth = (0,external_wp_element_namespaceObject.useCallback)((targetElementRect, indent) => { 61007 if (!targetElement) { 61008 return 0; 61009 } 61010 61011 // Default to assuming that the width of the drop indicator 61012 // should be the same as the target element. 61013 let width = targetElement.offsetWidth; 61014 61015 // In deeply nested lists, where a scrollbar is present, 61016 // the width of the drop indicator should be the width of 61017 // the scroll container, minus the distance from the left 61018 // edge of the scroll container to the left edge of the 61019 // target element. 61020 const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(targetElement, 'horizontal'); 61021 const ownerDocument = targetElement.ownerDocument; 61022 const windowScroll = scrollContainer === ownerDocument.body || scrollContainer === ownerDocument.documentElement; 61023 if (scrollContainer && !windowScroll) { 61024 const scrollContainerRect = scrollContainer.getBoundingClientRect(); 61025 const distanceBetweenContainerAndTarget = (0,external_wp_i18n_namespaceObject.isRTL)() ? scrollContainerRect.right - targetElementRect.right : targetElementRect.left - scrollContainerRect.left; 61026 const scrollContainerWidth = scrollContainer.clientWidth; 61027 if (scrollContainerWidth < width + distanceBetweenContainerAndTarget) { 61028 width = scrollContainerWidth - distanceBetweenContainerAndTarget; 61029 } 61030 61031 // LTR logic for ensuring the drop indicator does not extend 61032 // beyond the right edge of the scroll container. 61033 if (!rtl && targetElementRect.left + indent < scrollContainerRect.left) { 61034 width -= scrollContainerRect.left - targetElementRect.left; 61035 return width; 61036 } 61037 61038 // RTL logic for ensuring the drop indicator does not extend 61039 // beyond the right edge of the scroll container. 61040 if (rtl && targetElementRect.right - indent > scrollContainerRect.right) { 61041 width -= targetElementRect.right - scrollContainerRect.right; 61042 return width; 61043 } 61044 } 61045 61046 // Subtract the indent from the final width of the indicator. 61047 return width - indent; 61048 }, [rtl, targetElement]); 61049 const style = (0,external_wp_element_namespaceObject.useMemo)(() => { 61050 if (!targetElement) { 61051 return {}; 61052 } 61053 const targetElementRect = targetElement.getBoundingClientRect(); 61054 return { 61055 width: getDropIndicatorWidth(targetElementRect, 0) 61056 }; 61057 }, [getDropIndicatorWidth, targetElement]); 61058 const horizontalScrollOffsetStyle = (0,external_wp_element_namespaceObject.useMemo)(() => { 61059 if (!targetElement) { 61060 return {}; 61061 } 61062 const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(targetElement); 61063 const ownerDocument = targetElement.ownerDocument; 61064 const windowScroll = scrollContainer === ownerDocument.body || scrollContainer === ownerDocument.documentElement; 61065 if (scrollContainer && !windowScroll) { 61066 const scrollContainerRect = scrollContainer.getBoundingClientRect(); 61067 const targetElementRect = targetElement.getBoundingClientRect(); 61068 const distanceBetweenContainerAndTarget = rtl ? scrollContainerRect.right - targetElementRect.right : targetElementRect.left - scrollContainerRect.left; 61069 if (!rtl && scrollContainerRect.left > targetElementRect.left) { 61070 return { 61071 transform: `translateX( $distanceBetweenContainerAndTarget}px )` 61072 }; 61073 } 61074 if (rtl && scrollContainerRect.right < targetElementRect.right) { 61075 return { 61076 transform: `translateX( $distanceBetweenContainerAndTarget * -1}px )` 61077 }; 61078 } 61079 } 61080 return {}; 61081 }, [rtl, targetElement]); 61082 const ariaLevel = (0,external_wp_element_namespaceObject.useMemo)(() => { 61083 if (!rootBlockElement) { 61084 return 1; 61085 } 61086 const _ariaLevel = parseInt(rootBlockElement.getAttribute('aria-level'), 10); 61087 return _ariaLevel ? _ariaLevel + 1 : 1; 61088 }, [rootBlockElement]); 61089 const hasAdjacentSelectedBranch = (0,external_wp_element_namespaceObject.useMemo)(() => { 61090 if (!targetElement) { 61091 return false; 61092 } 61093 return targetElement.classList.contains('is-branch-selected'); 61094 }, [targetElement]); 61095 const popoverAnchor = (0,external_wp_element_namespaceObject.useMemo)(() => { 61096 const isValidDropPosition = dropPosition === 'top' || dropPosition === 'bottom' || dropPosition === 'inside'; 61097 if (!targetElement || !isValidDropPosition) { 61098 return undefined; 61099 } 61100 return { 61101 contextElement: targetElement, 61102 getBoundingClientRect() { 61103 const rect = targetElement.getBoundingClientRect(); 61104 // In RTL languages, the drop indicator should be positioned 61105 // to the left of the target element, with the width of the 61106 // indicator determining the indent at the right edge of the 61107 // target element. In LTR languages, the drop indicator should 61108 // end at the right edge of the target element, with the indent 61109 // added to the position of the left edge of the target element. 61110 // let left = rtl ? rect.left : rect.left + indent; 61111 let left = rect.left; 61112 let top = 0; 61113 61114 // In deeply nested lists, where a scrollbar is present, 61115 // the width of the drop indicator should be the width of 61116 // the visible area of the scroll container. Additionally, 61117 // the left edge of the drop indicator line needs to be 61118 // offset by the distance the left edge of the target element 61119 // and the left edge of the scroll container. The ensures 61120 // that the drop indicator position never breaks out of the 61121 // visible area of the scroll container. 61122 const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(targetElement, 'horizontal'); 61123 const doc = targetElement.ownerDocument; 61124 const windowScroll = scrollContainer === doc.body || scrollContainer === doc.documentElement; 61125 61126 // If the scroll container is not the window, offset the left position, if need be. 61127 if (scrollContainer && !windowScroll) { 61128 const scrollContainerRect = scrollContainer.getBoundingClientRect(); 61129 61130 // In RTL languages, a vertical scrollbar is present on the 61131 // left edge of the scroll container. The width of the 61132 // scrollbar needs to be accounted for when positioning the 61133 // drop indicator. 61134 const scrollbarWidth = rtl ? scrollContainer.offsetWidth - scrollContainer.clientWidth : 0; 61135 if (left < scrollContainerRect.left + scrollbarWidth) { 61136 left = scrollContainerRect.left + scrollbarWidth; 61137 } 61138 } 61139 if (dropPosition === 'top') { 61140 top = rect.top - rect.height * 2; 61141 } else { 61142 // `dropPosition` is either `bottom` or `inside` 61143 top = rect.top; 61144 } 61145 const width = getDropIndicatorWidth(rect, 0); 61146 const height = rect.height; 61147 return new window.DOMRect(left, top, width, height); 61148 } 61149 }; 61150 }, [targetElement, dropPosition, getDropIndicatorWidth, rtl]); 61151 if (!targetElement) { 61152 return null; 61153 } 61154 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, { 61155 animate: false, 61156 anchor: popoverAnchor, 61157 focusOnMount: false, 61158 className: "block-editor-list-view-drop-indicator--preview", 61159 variant: "unstyled", 61160 flip: false, 61161 resize: true, 61162 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 61163 style: style, 61164 className: dist_clsx('block-editor-list-view-drop-indicator__line', { 61165 'block-editor-list-view-drop-indicator__line--darker': hasAdjacentSelectedBranch 61166 }), 61167 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 61168 className: "block-editor-list-view-leaf", 61169 "aria-level": ariaLevel, 61170 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 61171 className: dist_clsx('block-editor-list-view-block-select-button', 'block-editor-list-view-block-contents'), 61172 style: horizontalScrollOffsetStyle, 61173 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewExpander, { 61174 onClick: () => {} 61175 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 61176 icon: blockInformation?.icon, 61177 showColors: true, 61178 context: "list-view" 61179 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHStack, { 61180 alignment: "center", 61181 className: "block-editor-list-view-block-select-button__label-wrapper", 61182 justify: "flex-start", 61183 spacing: 1, 61184 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 61185 className: "block-editor-list-view-block-select-button__title", 61186 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, { 61187 ellipsizeMode: "auto", 61188 children: blockTitle 61189 }) 61190 }) 61191 })] 61192 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 61193 className: "block-editor-list-view-block__menu-cell" 61194 })] 61195 }) 61196 }) 61197 }); 61198 } 61199 61200 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-block-selection.js 61201 /** 61202 * WordPress dependencies 61203 */ 61204 61205 61206 61207 61208 61209 61210 61211 /** 61212 * Internal dependencies 61213 */ 61214 61215 61216 function useBlockSelection() { 61217 const { 61218 clearSelectedBlock, 61219 multiSelect, 61220 selectBlock 61221 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 61222 const { 61223 getBlockName, 61224 getBlockParents, 61225 getBlockSelectionStart, 61226 getSelectedBlockClientIds, 61227 hasMultiSelection, 61228 hasSelectedBlock 61229 } = (0,external_wp_data_namespaceObject.useSelect)(store); 61230 const { 61231 getBlockType 61232 } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store); 61233 const updateBlockSelection = (0,external_wp_element_namespaceObject.useCallback)(async (event, clientId, destinationClientId, focusPosition) => { 61234 if (!event?.shiftKey && event?.keyCode !== external_wp_keycodes_namespaceObject.ESCAPE) { 61235 selectBlock(clientId, focusPosition); 61236 return; 61237 } 61238 61239 // To handle multiple block selection via the `SHIFT` key, prevent 61240 // the browser default behavior of opening the link in a new window. 61241 event.preventDefault(); 61242 const isOnlyDeselection = event.type === 'keydown' && event.keyCode === external_wp_keycodes_namespaceObject.ESCAPE; 61243 const isKeyPress = event.type === 'keydown' && (event.keyCode === external_wp_keycodes_namespaceObject.UP || event.keyCode === external_wp_keycodes_namespaceObject.DOWN || event.keyCode === external_wp_keycodes_namespaceObject.HOME || event.keyCode === external_wp_keycodes_namespaceObject.END); 61244 61245 // Handle clicking on a block when no blocks are selected, and return early. 61246 if (!isKeyPress && !hasSelectedBlock() && !hasMultiSelection()) { 61247 selectBlock(clientId, null); 61248 return; 61249 } 61250 const selectedBlocks = getSelectedBlockClientIds(); 61251 const clientIdWithParents = [...getBlockParents(clientId), clientId]; 61252 if (isOnlyDeselection || isKeyPress && !selectedBlocks.some(blockId => clientIdWithParents.includes(blockId))) { 61253 // Ensure that shift-selecting blocks via the keyboard only 61254 // expands the current selection if focusing over already 61255 // selected blocks. Otherwise, clear the selection so that 61256 // a user can create a new selection entirely by keyboard. 61257 await clearSelectedBlock(); 61258 } 61259 61260 // Update selection, if not only clearing the selection. 61261 if (!isOnlyDeselection) { 61262 let startTarget = getBlockSelectionStart(); 61263 let endTarget = clientId; 61264 61265 // Handle keyboard behavior for selecting multiple blocks. 61266 if (isKeyPress) { 61267 if (!hasSelectedBlock() && !hasMultiSelection()) { 61268 // Set the starting point of the selection to the currently 61269 // focused block, if there are no blocks currently selected. 61270 // This ensures that as the selection is expanded or contracted, 61271 // the starting point of the selection is anchored to that block. 61272 startTarget = clientId; 61273 } 61274 if (destinationClientId) { 61275 // If the user presses UP or DOWN, we want to ensure that the block they're 61276 // moving to is the target for selection, and not the currently focused one. 61277 endTarget = destinationClientId; 61278 } 61279 } 61280 const startParents = getBlockParents(startTarget); 61281 const endParents = getBlockParents(endTarget); 61282 const { 61283 start, 61284 end 61285 } = getCommonDepthClientIds(startTarget, endTarget, startParents, endParents); 61286 await multiSelect(start, end, null); 61287 } 61288 61289 // Announce deselected block, or number of deselected blocks if 61290 // the total number of blocks deselected is greater than one. 61291 const updatedSelectedBlocks = getSelectedBlockClientIds(); 61292 61293 // If the selection is greater than 1 and the Home or End keys 61294 // were used to generate the selection, then skip announcing the 61295 // deselected blocks. 61296 if ((event.keyCode === external_wp_keycodes_namespaceObject.HOME || event.keyCode === external_wp_keycodes_namespaceObject.END) && updatedSelectedBlocks.length > 1) { 61297 return; 61298 } 61299 const selectionDiff = selectedBlocks.filter(blockId => !updatedSelectedBlocks.includes(blockId)); 61300 let label; 61301 if (selectionDiff.length === 1) { 61302 const title = getBlockType(getBlockName(selectionDiff[0]))?.title; 61303 if (title) { 61304 label = (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: block name */ 61305 (0,external_wp_i18n_namespaceObject.__)('%s deselected.'), title); 61306 } 61307 } else if (selectionDiff.length > 1) { 61308 label = (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: number of deselected blocks */ 61309 (0,external_wp_i18n_namespaceObject.__)('%s blocks deselected.'), selectionDiff.length); 61310 } 61311 if (label) { 61312 (0,external_wp_a11y_namespaceObject.speak)(label, 'assertive'); 61313 } 61314 }, [clearSelectedBlock, getBlockName, getBlockType, getBlockParents, getBlockSelectionStart, getSelectedBlockClientIds, hasMultiSelection, hasSelectedBlock, multiSelect, selectBlock]); 61315 return { 61316 updateBlockSelection 61317 }; 61318 } 61319 61320 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-block-indexes.js 61321 /** 61322 * WordPress dependencies 61323 */ 61324 61325 function useListViewBlockIndexes(blocks) { 61326 const blockIndexes = (0,external_wp_element_namespaceObject.useMemo)(() => { 61327 const indexes = {}; 61328 let currentGlobalIndex = 0; 61329 const traverseBlocks = blockList => { 61330 blockList.forEach(block => { 61331 indexes[block.clientId] = currentGlobalIndex; 61332 currentGlobalIndex++; 61333 if (block.innerBlocks.length > 0) { 61334 traverseBlocks(block.innerBlocks); 61335 } 61336 }); 61337 }; 61338 traverseBlocks(blocks); 61339 return indexes; 61340 }, [blocks]); 61341 return blockIndexes; 61342 } 61343 61344 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-client-ids.js 61345 /** 61346 * WordPress dependencies 61347 */ 61348 61349 61350 61351 /** 61352 * Internal dependencies 61353 */ 61354 61355 61356 function useListViewClientIds({ 61357 blocks, 61358 rootClientId 61359 }) { 61360 return (0,external_wp_data_namespaceObject.useSelect)(select => { 61361 const { 61362 getDraggedBlockClientIds, 61363 getSelectedBlockClientIds, 61364 getEnabledClientIdsTree 61365 } = unlock(select(store)); 61366 return { 61367 selectedClientIds: getSelectedBlockClientIds(), 61368 draggedClientIds: getDraggedBlockClientIds(), 61369 clientIdsTree: blocks !== null && blocks !== void 0 ? blocks : getEnabledClientIdsTree(rootClientId) 61370 }; 61371 }, [blocks, rootClientId]); 61372 } 61373 61374 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-collapse-items.js 61375 /** 61376 * WordPress dependencies 61377 */ 61378 61379 61380 61381 /** 61382 * Internal dependencies 61383 */ 61384 61385 61386 function useListViewCollapseItems({ 61387 collapseAll, 61388 expand 61389 }) { 61390 const { 61391 expandedBlock, 61392 getBlockParents 61393 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 61394 const { 61395 getBlockParents: _getBlockParents, 61396 getExpandedBlock 61397 } = unlock(select(store)); 61398 return { 61399 expandedBlock: getExpandedBlock(), 61400 getBlockParents: _getBlockParents 61401 }; 61402 }, []); 61403 61404 // Collapse all but the specified block when the expanded block client Id changes. 61405 (0,external_wp_element_namespaceObject.useEffect)(() => { 61406 if (expandedBlock) { 61407 const blockParents = getBlockParents(expandedBlock, false); 61408 // Collapse all blocks and expand the block's parents. 61409 collapseAll(); 61410 expand(blockParents); 61411 } 61412 }, [collapseAll, expand, expandedBlock, getBlockParents]); 61413 } 61414 61415 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-drop-zone.js 61416 /** 61417 * WordPress dependencies 61418 */ 61419 61420 61421 61422 61423 61424 /** 61425 * Internal dependencies 61426 */ 61427 61428 61429 61430 61431 /** @typedef {import('../../utils/math').WPPoint} WPPoint */ 61432 61433 /** 61434 * The type of a drag event. 61435 * 61436 * @typedef {'default'|'file'|'html'} WPDragEventType 61437 */ 61438 61439 /** 61440 * An object representing data for blocks in the DOM used by drag and drop. 61441 * 61442 * @typedef {Object} WPListViewDropZoneBlock 61443 * @property {string} clientId The client id for the block. 61444 * @property {string} rootClientId The root client id for the block. 61445 * @property {number} blockIndex The block's index. 61446 * @property {Element} element The DOM element representing the block. 61447 * @property {number} innerBlockCount The number of inner blocks the block has. 61448 * @property {boolean} isDraggedBlock Whether the block is currently being dragged. 61449 * @property {boolean} isExpanded Whether the block is expanded in the UI. 61450 * @property {boolean} canInsertDraggedBlocksAsSibling Whether the dragged block can be a sibling of this block. 61451 * @property {boolean} canInsertDraggedBlocksAsChild Whether the dragged block can be a child of this block. 61452 */ 61453 61454 /** 61455 * An array representing data for blocks in the DOM used by drag and drop. 61456 * 61457 * @typedef {WPListViewDropZoneBlock[]} WPListViewDropZoneBlocks 61458 */ 61459 61460 /** 61461 * An object containing details of a drop target. 61462 * 61463 * @typedef {Object} WPListViewDropZoneTarget 61464 * @property {string} blockIndex The insertion index. 61465 * @property {string} rootClientId The root client id for the block. 61466 * @property {string|undefined} clientId The client id for the block. 61467 * @property {'top'|'bottom'|'inside'} dropPosition The position relative to the block that the user is dropping to. 61468 * 'inside' refers to nesting as an inner block. 61469 */ 61470 61471 // When the indentation level, the corresponding left margin in `style.scss` 61472 // must be updated as well to ensure the drop zone is aligned with the indentation. 61473 const NESTING_LEVEL_INDENTATION = 24; 61474 61475 /** 61476 * Determines whether the user is positioning the dragged block to be 61477 * moved up to a parent level. 61478 * 61479 * Determined based on nesting level indentation of the current block. 61480 * 61481 * @param {WPPoint} point The point representing the cursor position when dragging. 61482 * @param {DOMRect} rect The rectangle. 61483 * @param {number} nestingLevel The nesting level of the block. 61484 * @param {boolean} rtl Whether the editor is in RTL mode. 61485 * @return {boolean} Whether the gesture is an upward gesture. 61486 */ 61487 function isUpGesture(point, rect, nestingLevel = 1, rtl = false) { 61488 // If the block is nested, and the user is dragging to the bottom 61489 // left of the block (or bottom right in RTL languages), then it is an upward gesture. 61490 const blockIndentPosition = rtl ? rect.right - nestingLevel * NESTING_LEVEL_INDENTATION : rect.left + nestingLevel * NESTING_LEVEL_INDENTATION; 61491 return rtl ? point.x > blockIndentPosition : point.x < blockIndentPosition; 61492 } 61493 61494 /** 61495 * Returns how many nesting levels up the user is attempting to drag to. 61496 * 61497 * The relative parent level is calculated based on how far 61498 * the cursor is from the provided nesting level (e.g. of a candidate block 61499 * that the user is hovering over). The nesting level is considered "desired" 61500 * because it is not guaranteed that the user will be able to drag to the desired level. 61501 * 61502 * The returned integer can be used to access an ascending array 61503 * of parent blocks, where the first item is the block the user 61504 * is hovering over, and the last item is the root block. 61505 * 61506 * @param {WPPoint} point The point representing the cursor position when dragging. 61507 * @param {DOMRect} rect The rectangle. 61508 * @param {number} nestingLevel The nesting level of the block. 61509 * @param {boolean} rtl Whether the editor is in RTL mode. 61510 * @return {number} The desired relative parent level. 61511 */ 61512 function getDesiredRelativeParentLevel(point, rect, nestingLevel = 1, rtl = false) { 61513 // In RTL languages, the block indent position is from the right edge of the block. 61514 // In LTR languages, the block indent position is from the left edge of the block. 61515 const blockIndentPosition = rtl ? rect.right - nestingLevel * NESTING_LEVEL_INDENTATION : rect.left + nestingLevel * NESTING_LEVEL_INDENTATION; 61516 const distanceBetweenPointAndBlockIndentPosition = rtl ? blockIndentPosition - point.x : point.x - blockIndentPosition; 61517 const desiredParentLevel = Math.round(distanceBetweenPointAndBlockIndentPosition / NESTING_LEVEL_INDENTATION); 61518 return Math.abs(desiredParentLevel); 61519 } 61520 61521 /** 61522 * Returns an array of the parent blocks of the block the user is dropping to. 61523 * 61524 * @param {WPListViewDropZoneBlock} candidateBlockData The block the user is dropping to. 61525 * @param {WPListViewDropZoneBlocks} blocksData Data about the blocks in list view. 61526 * @return {WPListViewDropZoneBlocks} An array of block parents, including the block the user is dropping to. 61527 */ 61528 function getCandidateBlockParents(candidateBlockData, blocksData) { 61529 const candidateBlockParents = []; 61530 let currentBlockData = candidateBlockData; 61531 while (currentBlockData) { 61532 candidateBlockParents.push({ 61533 ...currentBlockData 61534 }); 61535 currentBlockData = blocksData.find(blockData => blockData.clientId === currentBlockData.rootClientId); 61536 } 61537 return candidateBlockParents; 61538 } 61539 61540 /** 61541 * Given a list of blocks data and a block index, return the next non-dragged 61542 * block. This is used to determine the block that the user is dropping to, 61543 * while ignoring the dragged block. 61544 * 61545 * @param {WPListViewDropZoneBlocks} blocksData Data about the blocks in list view. 61546 * @param {number} index The index to begin searching from. 61547 * @return {WPListViewDropZoneBlock | undefined} The next non-dragged block. 61548 */ 61549 function getNextNonDraggedBlock(blocksData, index) { 61550 const nextBlockData = blocksData[index + 1]; 61551 if (nextBlockData && nextBlockData.isDraggedBlock) { 61552 return getNextNonDraggedBlock(blocksData, index + 1); 61553 } 61554 return nextBlockData; 61555 } 61556 61557 /** 61558 * Determines whether the user positioning the dragged block to nest as an 61559 * inner block. 61560 * 61561 * Determined based on nesting level indentation of the current block, plus 61562 * the indentation of the next level of nesting. The vertical position of the 61563 * cursor must also be within the block. 61564 * 61565 * @param {WPPoint} point The point representing the cursor position when dragging. 61566 * @param {DOMRect} rect The rectangle. 61567 * @param {number} nestingLevel The nesting level of the block. 61568 * @param {boolean} rtl Whether the editor is in RTL mode. 61569 */ 61570 function isNestingGesture(point, rect, nestingLevel = 1, rtl = false) { 61571 const blockIndentPosition = rtl ? rect.right - nestingLevel * NESTING_LEVEL_INDENTATION : rect.left + nestingLevel * NESTING_LEVEL_INDENTATION; 61572 const isNestingHorizontalGesture = rtl ? point.x < blockIndentPosition - NESTING_LEVEL_INDENTATION : point.x > blockIndentPosition + NESTING_LEVEL_INDENTATION; 61573 return isNestingHorizontalGesture && point.y < rect.bottom; 61574 } 61575 61576 // Block navigation is always a vertical list, so only allow dropping 61577 // to the above or below a block. 61578 const ALLOWED_DROP_EDGES = ['top', 'bottom']; 61579 61580 /** 61581 * Given blocks data and the cursor position, compute the drop target. 61582 * 61583 * @param {WPListViewDropZoneBlocks} blocksData Data about the blocks in list view. 61584 * @param {WPPoint} position The point representing the cursor position when dragging. 61585 * @param {boolean} rtl Whether the editor is in RTL mode. 61586 * 61587 * @return {WPListViewDropZoneTarget | undefined} An object containing data about the drop target. 61588 */ 61589 function getListViewDropTarget(blocksData, position, rtl = false) { 61590 let candidateEdge; 61591 let candidateBlockData; 61592 let candidateDistance; 61593 let candidateRect; 61594 let candidateBlockIndex; 61595 for (let i = 0; i < blocksData.length; i++) { 61596 const blockData = blocksData[i]; 61597 if (blockData.isDraggedBlock) { 61598 continue; 61599 } 61600 const rect = blockData.element.getBoundingClientRect(); 61601 const [distance, edge] = getDistanceToNearestEdge(position, rect, ALLOWED_DROP_EDGES); 61602 const isCursorWithinBlock = isPointContainedByRect(position, rect); 61603 if (candidateDistance === undefined || distance < candidateDistance || isCursorWithinBlock) { 61604 candidateDistance = distance; 61605 const index = blocksData.indexOf(blockData); 61606 const previousBlockData = blocksData[index - 1]; 61607 61608 // If dragging near the top of a block and the preceding block 61609 // is at the same level, use the preceding block as the candidate 61610 // instead, as later it makes determining a nesting drop easier. 61611 if (edge === 'top' && previousBlockData && previousBlockData.rootClientId === blockData.rootClientId && !previousBlockData.isDraggedBlock) { 61612 candidateBlockData = previousBlockData; 61613 candidateEdge = 'bottom'; 61614 candidateRect = previousBlockData.element.getBoundingClientRect(); 61615 candidateBlockIndex = index - 1; 61616 } else { 61617 candidateBlockData = blockData; 61618 candidateEdge = edge; 61619 candidateRect = rect; 61620 candidateBlockIndex = index; 61621 } 61622 61623 // If the mouse position is within the block, break early 61624 // as the user would intend to drop either before or after 61625 // this block. 61626 // 61627 // This solves an issue where some rows in the list view 61628 // tree overlap slightly due to sub-pixel rendering. 61629 if (isCursorWithinBlock) { 61630 break; 61631 } 61632 } 61633 } 61634 if (!candidateBlockData) { 61635 return; 61636 } 61637 const candidateBlockParents = getCandidateBlockParents(candidateBlockData, blocksData); 61638 const isDraggingBelow = candidateEdge === 'bottom'; 61639 61640 // If the user is dragging towards the bottom of the block check whether 61641 // they might be trying to nest the block as a child. 61642 // If the block already has inner blocks, and is expanded, this should be treated 61643 // as nesting since the next block in the tree will be the first child. 61644 // However, if the block is collapsed, dragging beneath the block should 61645 // still be allowed, as the next visible block in the tree will be a sibling. 61646 if (isDraggingBelow && candidateBlockData.canInsertDraggedBlocksAsChild && (candidateBlockData.innerBlockCount > 0 && candidateBlockData.isExpanded || isNestingGesture(position, candidateRect, candidateBlockParents.length, rtl))) { 61647 // If the block is expanded, insert the block as the first child. 61648 // Otherwise, for collapsed blocks, insert the block as the last child. 61649 const newBlockIndex = candidateBlockData.isExpanded ? 0 : candidateBlockData.innerBlockCount || 0; 61650 return { 61651 rootClientId: candidateBlockData.clientId, 61652 clientId: candidateBlockData.clientId, 61653 blockIndex: newBlockIndex, 61654 dropPosition: 'inside' 61655 }; 61656 } 61657 61658 // If the user is dragging towards the bottom of the block check whether 61659 // they might be trying to move the block to be at a parent level. 61660 if (isDraggingBelow && candidateBlockData.rootClientId && isUpGesture(position, candidateRect, candidateBlockParents.length, rtl)) { 61661 const nextBlock = getNextNonDraggedBlock(blocksData, candidateBlockIndex); 61662 const currentLevel = candidateBlockData.nestingLevel; 61663 const nextLevel = nextBlock ? nextBlock.nestingLevel : 1; 61664 if (currentLevel && nextLevel) { 61665 // Determine the desired relative level of the block to be dropped. 61666 const desiredRelativeLevel = getDesiredRelativeParentLevel(position, candidateRect, candidateBlockParents.length, rtl); 61667 const targetParentIndex = Math.max(Math.min(desiredRelativeLevel, currentLevel - nextLevel), 0); 61668 if (candidateBlockParents[targetParentIndex]) { 61669 // Default to the block index of the candidate block. 61670 let newBlockIndex = candidateBlockData.blockIndex; 61671 61672 // If the next block is at the same level, use that as the default 61673 // block index. This ensures that the block is dropped in the correct 61674 // position when dragging to the bottom of a block. 61675 if (candidateBlockParents[targetParentIndex].nestingLevel === nextBlock?.nestingLevel) { 61676 newBlockIndex = nextBlock?.blockIndex; 61677 } else { 61678 // Otherwise, search from the current block index back 61679 // to find the last block index within the same target parent. 61680 for (let i = candidateBlockIndex; i >= 0; i--) { 61681 const blockData = blocksData[i]; 61682 if (blockData.rootClientId === candidateBlockParents[targetParentIndex].rootClientId) { 61683 newBlockIndex = blockData.blockIndex + 1; 61684 break; 61685 } 61686 } 61687 } 61688 return { 61689 rootClientId: candidateBlockParents[targetParentIndex].rootClientId, 61690 clientId: candidateBlockData.clientId, 61691 blockIndex: newBlockIndex, 61692 dropPosition: candidateEdge 61693 }; 61694 } 61695 } 61696 } 61697 61698 // If dropping as a sibling, but block cannot be inserted in 61699 // this context, return early. 61700 if (!candidateBlockData.canInsertDraggedBlocksAsSibling) { 61701 return; 61702 } 61703 const offset = isDraggingBelow ? 1 : 0; 61704 return { 61705 rootClientId: candidateBlockData.rootClientId, 61706 clientId: candidateBlockData.clientId, 61707 blockIndex: candidateBlockData.blockIndex + offset, 61708 dropPosition: candidateEdge 61709 }; 61710 } 61711 61712 // Throttle options need to be defined outside of the hook to avoid 61713 // re-creating the object on every render. This is due to a limitation 61714 // of the `useThrottle` hook, where the options object is included 61715 // in the dependency array for memoization. 61716 const EXPAND_THROTTLE_OPTIONS = { 61717 leading: false, 61718 // Don't call the function immediately on the first call. 61719 trailing: true // Do call the function on the last call. 61720 }; 61721 61722 /** 61723 * A react hook for implementing a drop zone in list view. 61724 * 61725 * @param {Object} props Named parameters. 61726 * @param {?HTMLElement} [props.dropZoneElement] Optional element to be used as the drop zone. 61727 * @param {Object} [props.expandedState] The expanded state of the blocks in the list view. 61728 * @param {Function} [props.setExpandedState] Function to set the expanded state of a list of block clientIds. 61729 * 61730 * @return {WPListViewDropZoneTarget} The drop target. 61731 */ 61732 function useListViewDropZone({ 61733 dropZoneElement, 61734 expandedState, 61735 setExpandedState 61736 }) { 61737 const { 61738 getBlockRootClientId, 61739 getBlockIndex, 61740 getBlockCount, 61741 getDraggedBlockClientIds, 61742 canInsertBlocks 61743 } = (0,external_wp_data_namespaceObject.useSelect)(store); 61744 const [target, setTarget] = (0,external_wp_element_namespaceObject.useState)(); 61745 const { 61746 rootClientId: targetRootClientId, 61747 blockIndex: targetBlockIndex 61748 } = target || {}; 61749 const onBlockDrop = useOnBlockDrop(targetRootClientId, targetBlockIndex); 61750 const rtl = (0,external_wp_i18n_namespaceObject.isRTL)(); 61751 const previousRootClientId = (0,external_wp_compose_namespaceObject.usePrevious)(targetRootClientId); 61752 const maybeExpandBlock = (0,external_wp_element_namespaceObject.useCallback)((_expandedState, _target) => { 61753 // If the user is attempting to drop a block inside a collapsed block, 61754 // that is, using a nesting gesture flagged by 'inside' dropPosition, 61755 // expand the block within the list view, if it isn't already. 61756 const { 61757 rootClientId 61758 } = _target || {}; 61759 if (!rootClientId) { 61760 return; 61761 } 61762 if (_target?.dropPosition === 'inside' && !_expandedState[rootClientId]) { 61763 setExpandedState({ 61764 type: 'expand', 61765 clientIds: [rootClientId] 61766 }); 61767 } 61768 }, [setExpandedState]); 61769 61770 // Throttle the maybeExpandBlock function to avoid expanding the block 61771 // too quickly when the user is dragging over the block. This is to 61772 // avoid expanding the block when the user is just passing over it. 61773 const throttledMaybeExpandBlock = (0,external_wp_compose_namespaceObject.useThrottle)(maybeExpandBlock, 500, EXPAND_THROTTLE_OPTIONS); 61774 (0,external_wp_element_namespaceObject.useEffect)(() => { 61775 if (target?.dropPosition !== 'inside' || previousRootClientId !== target?.rootClientId) { 61776 throttledMaybeExpandBlock.cancel(); 61777 return; 61778 } 61779 throttledMaybeExpandBlock(expandedState, target); 61780 }, [expandedState, previousRootClientId, target, throttledMaybeExpandBlock]); 61781 const draggedBlockClientIds = getDraggedBlockClientIds(); 61782 const throttled = (0,external_wp_compose_namespaceObject.useThrottle)((0,external_wp_element_namespaceObject.useCallback)((event, currentTarget) => { 61783 const position = { 61784 x: event.clientX, 61785 y: event.clientY 61786 }; 61787 const isBlockDrag = !!draggedBlockClientIds?.length; 61788 const blockElements = Array.from(currentTarget.querySelectorAll('[data-block]')); 61789 const blocksData = blockElements.map(blockElement => { 61790 const clientId = blockElement.dataset.block; 61791 const isExpanded = blockElement.dataset.expanded === 'true'; 61792 const isDraggedBlock = blockElement.classList.contains('is-dragging'); 61793 61794 // Get nesting level from `aria-level` attribute because Firefox does not support `element.ariaLevel`. 61795 const nestingLevel = parseInt(blockElement.getAttribute('aria-level'), 10); 61796 const rootClientId = getBlockRootClientId(clientId); 61797 return { 61798 clientId, 61799 isExpanded, 61800 rootClientId, 61801 blockIndex: getBlockIndex(clientId), 61802 element: blockElement, 61803 nestingLevel: nestingLevel || undefined, 61804 isDraggedBlock: isBlockDrag ? isDraggedBlock : false, 61805 innerBlockCount: getBlockCount(clientId), 61806 canInsertDraggedBlocksAsSibling: isBlockDrag ? canInsertBlocks(draggedBlockClientIds, rootClientId) : true, 61807 canInsertDraggedBlocksAsChild: isBlockDrag ? canInsertBlocks(draggedBlockClientIds, clientId) : true 61808 }; 61809 }); 61810 const newTarget = getListViewDropTarget(blocksData, position, rtl); 61811 if (newTarget) { 61812 setTarget(newTarget); 61813 } 61814 }, [canInsertBlocks, draggedBlockClientIds, getBlockCount, getBlockIndex, getBlockRootClientId, rtl]), 50); 61815 const ref = (0,external_wp_compose_namespaceObject.__experimentalUseDropZone)({ 61816 dropZoneElement, 61817 onDrop(event) { 61818 throttled.cancel(); 61819 if (target) { 61820 onBlockDrop(event); 61821 } 61822 // Use `undefined` value to indicate that the drag has concluded. 61823 // This allows styling rules that are active only when a user is 61824 // dragging to be removed. 61825 setTarget(undefined); 61826 }, 61827 onDragLeave() { 61828 throttled.cancel(); 61829 // Use `null` value to indicate that the drop target is not valid, 61830 // but that the drag is still active. This allows for styling rules 61831 // that are active only when a user drags outside of the list view. 61832 setTarget(null); 61833 }, 61834 onDragOver(event) { 61835 // `currentTarget` is only available while the event is being 61836 // handled, so get it now and pass it to the thottled function. 61837 // https://developer.mozilla.org/en-US/docs/Web/API/Event/currentTarget 61838 throttled(event, event.currentTarget); 61839 }, 61840 onDragEnd() { 61841 throttled.cancel(); 61842 // Use `undefined` value to indicate that the drag has concluded. 61843 // This allows styling rules that are active only when a user is 61844 // dragging to be removed. 61845 setTarget(undefined); 61846 } 61847 }); 61848 return { 61849 ref, 61850 target 61851 }; 61852 } 61853 61854 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-expand-selected-item.js 61855 /** 61856 * WordPress dependencies 61857 */ 61858 61859 61860 61861 /** 61862 * Internal dependencies 61863 */ 61864 61865 function useListViewExpandSelectedItem({ 61866 firstSelectedBlockClientId, 61867 setExpandedState 61868 }) { 61869 const [selectedTreeId, setSelectedTreeId] = (0,external_wp_element_namespaceObject.useState)(null); 61870 const { 61871 selectedBlockParentClientIds 61872 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 61873 const { 61874 getBlockParents 61875 } = select(store); 61876 return { 61877 selectedBlockParentClientIds: getBlockParents(firstSelectedBlockClientId, false) 61878 }; 61879 }, [firstSelectedBlockClientId]); 61880 61881 // Expand tree when a block is selected. 61882 (0,external_wp_element_namespaceObject.useEffect)(() => { 61883 // If the selectedTreeId is the same as the selected block, 61884 // it means that the block was selected using the block list tree. 61885 if (selectedTreeId === firstSelectedBlockClientId) { 61886 return; 61887 } 61888 61889 // If the selected block has parents, get the top-level parent. 61890 if (selectedBlockParentClientIds?.length) { 61891 // If the selected block has parents, 61892 // expand the tree branch. 61893 setExpandedState({ 61894 type: 'expand', 61895 clientIds: selectedBlockParentClientIds 61896 }); 61897 } 61898 }, [firstSelectedBlockClientId, selectedBlockParentClientIds, selectedTreeId, setExpandedState]); 61899 return { 61900 setSelectedTreeId 61901 }; 61902 } 61903 61904 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-clipboard-handler.js 61905 /** 61906 * WordPress dependencies 61907 */ 61908 61909 61910 61911 /** 61912 * Internal dependencies 61913 */ 61914 61915 61916 61917 61918 61919 // This hook borrows from useClipboardHandler in ../writing-flow/use-clipboard-handler.js 61920 // and adds behaviour for the list view, while skipping partial selection. 61921 function use_clipboard_handler_useClipboardHandler({ 61922 selectBlock 61923 }) { 61924 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 61925 const { 61926 getBlockOrder, 61927 getBlockRootClientId, 61928 getBlocksByClientId, 61929 getPreviousBlockClientId, 61930 getSelectedBlockClientIds, 61931 getSettings, 61932 canInsertBlockType, 61933 canRemoveBlocks 61934 } = (0,external_wp_data_namespaceObject.useSelect)(store); 61935 const { 61936 flashBlock, 61937 removeBlocks, 61938 replaceBlocks, 61939 insertBlocks 61940 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 61941 const notifyCopy = useNotifyCopy(); 61942 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 61943 function updateFocusAndSelection(focusClientId, shouldSelectBlock) { 61944 if (shouldSelectBlock) { 61945 selectBlock(undefined, focusClientId, null, null); 61946 } 61947 focusListItem(focusClientId, node); 61948 } 61949 61950 // Determine which blocks to update: 61951 // If the current (focused) block is part of the block selection, use the whole selection. 61952 // If the focused block is not part of the block selection, only update the focused block. 61953 function getBlocksToUpdate(clientId) { 61954 const selectedBlockClientIds = getSelectedBlockClientIds(); 61955 const isUpdatingSelectedBlocks = selectedBlockClientIds.includes(clientId); 61956 const firstBlockClientId = isUpdatingSelectedBlocks ? selectedBlockClientIds[0] : clientId; 61957 const firstBlockRootClientId = getBlockRootClientId(firstBlockClientId); 61958 const blocksToUpdate = isUpdatingSelectedBlocks ? selectedBlockClientIds : [clientId]; 61959 return { 61960 blocksToUpdate, 61961 firstBlockClientId, 61962 firstBlockRootClientId, 61963 originallySelectedBlockClientIds: selectedBlockClientIds 61964 }; 61965 } 61966 function handler(event) { 61967 if (event.defaultPrevented) { 61968 // This was possibly already handled in rich-text/use-paste-handler.js. 61969 return; 61970 } 61971 61972 // Only handle events that occur within the list view. 61973 if (!node.contains(event.target.ownerDocument.activeElement)) { 61974 return; 61975 } 61976 61977 // Retrieve the block clientId associated with the focused list view row. 61978 // This enables applying copy / cut / paste behavior to the focused block, 61979 // rather than just the blocks that are currently selected. 61980 const listViewRow = event.target.ownerDocument.activeElement?.closest('[role=row]'); 61981 const clientId = listViewRow?.dataset?.block; 61982 if (!clientId) { 61983 return; 61984 } 61985 const { 61986 blocksToUpdate: selectedBlockClientIds, 61987 firstBlockClientId, 61988 firstBlockRootClientId, 61989 originallySelectedBlockClientIds 61990 } = getBlocksToUpdate(clientId); 61991 if (selectedBlockClientIds.length === 0) { 61992 return; 61993 } 61994 event.preventDefault(); 61995 if (event.type === 'copy' || event.type === 'cut') { 61996 if (selectedBlockClientIds.length === 1) { 61997 flashBlock(selectedBlockClientIds[0]); 61998 } 61999 notifyCopy(event.type, selectedBlockClientIds); 62000 const blocks = getBlocksByClientId(selectedBlockClientIds); 62001 setClipboardBlocks(event, blocks, registry); 62002 } 62003 if (event.type === 'cut') { 62004 var _getPreviousBlockClie; 62005 // Don't update the selection if the blocks cannot be deleted. 62006 if (!canRemoveBlocks(selectedBlockClientIds)) { 62007 return; 62008 } 62009 let blockToFocus = (_getPreviousBlockClie = getPreviousBlockClientId(firstBlockClientId)) !== null && _getPreviousBlockClie !== void 0 ? _getPreviousBlockClie : 62010 // If the previous block is not found (when the first block is deleted), 62011 // fallback to focus the parent block. 62012 firstBlockRootClientId; 62013 62014 // Remove blocks, but don't update selection, and it will be handled below. 62015 removeBlocks(selectedBlockClientIds, false); 62016 62017 // Update the selection if the original selection has been removed. 62018 const shouldUpdateSelection = originallySelectedBlockClientIds.length > 0 && getSelectedBlockClientIds().length === 0; 62019 62020 // If there's no previous block nor parent block, focus the first block. 62021 if (!blockToFocus) { 62022 blockToFocus = getBlockOrder()[0]; 62023 } 62024 updateFocusAndSelection(blockToFocus, shouldUpdateSelection); 62025 } else if (event.type === 'paste') { 62026 const { 62027 __experimentalCanUserUseUnfilteredHTML: canUserUseUnfilteredHTML 62028 } = getSettings(); 62029 const blocks = getPasteBlocks(event, canUserUseUnfilteredHTML); 62030 if (selectedBlockClientIds.length === 1) { 62031 const [selectedBlockClientId] = selectedBlockClientIds; 62032 62033 // If a single block is focused, and the blocks to be posted can 62034 // be inserted within the block, then append the pasted blocks 62035 // within the focused block. For example, if you have copied a paragraph 62036 // block and paste it within a single Group block, this will append 62037 // the paragraph block within the Group block. 62038 if (blocks.every(block => canInsertBlockType(block.name, selectedBlockClientId))) { 62039 insertBlocks(blocks, undefined, selectedBlockClientId); 62040 updateFocusAndSelection(blocks[0]?.clientId, false); 62041 return; 62042 } 62043 } 62044 replaceBlocks(selectedBlockClientIds, blocks, blocks.length - 1, -1); 62045 updateFocusAndSelection(blocks[0]?.clientId, false); 62046 } 62047 } 62048 node.ownerDocument.addEventListener('copy', handler); 62049 node.ownerDocument.addEventListener('cut', handler); 62050 node.ownerDocument.addEventListener('paste', handler); 62051 return () => { 62052 node.ownerDocument.removeEventListener('copy', handler); 62053 node.ownerDocument.removeEventListener('cut', handler); 62054 node.ownerDocument.removeEventListener('paste', handler); 62055 }; 62056 }, []); 62057 } 62058 62059 ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/index.js 62060 /** 62061 * External dependencies 62062 */ 62063 62064 62065 /** 62066 * WordPress dependencies 62067 */ 62068 62069 62070 62071 62072 62073 62074 62075 /** 62076 * Internal dependencies 62077 */ 62078 62079 62080 62081 62082 62083 62084 62085 62086 62087 62088 62089 62090 62091 62092 62093 const expanded = (state, action) => { 62094 if (action.type === 'clear') { 62095 return {}; 62096 } 62097 if (Array.isArray(action.clientIds)) { 62098 return { 62099 ...state, 62100 ...action.clientIds.reduce((newState, id) => ({ 62101 ...newState, 62102 [id]: action.type === 'expand' 62103 }), {}) 62104 }; 62105 } 62106 return state; 62107 }; 62108 const BLOCK_LIST_ITEM_HEIGHT = 32; 62109 62110 /** @typedef {import('react').ComponentType} ComponentType */ 62111 /** @typedef {import('react').Ref<HTMLElement>} Ref */ 62112 62113 /** 62114 * Show a hierarchical list of blocks. 62115 * 62116 * @param {Object} props Components props. 62117 * @param {string} props.id An HTML element id for the root element of ListView. 62118 * @param {Array} props.blocks _deprecated_ Custom subset of block client IDs to be used instead of the default hierarchy. 62119 * @param {?HTMLElement} props.dropZoneElement Optional element to be used as the drop zone. 62120 * @param {?boolean} props.showBlockMovers Flag to enable block movers. Defaults to `false`. 62121 * @param {?boolean} props.isExpanded Flag to determine whether nested levels are expanded by default. Defaults to `false`. 62122 * @param {?boolean} props.showAppender Flag to show or hide the block appender. Defaults to `false`. 62123 * @param {?ComponentType} props.blockSettingsMenu Optional more menu substitution. Defaults to the standard `BlockSettingsDropdown` component. 62124 * @param {string} props.rootClientId The client id of the root block from which we determine the blocks to show in the list. 62125 * @param {string} props.description Optional accessible description for the tree grid component. 62126 * @param {?Function} props.onSelect Optional callback to be invoked when a block is selected. Receives the block object that was selected. 62127 * @param {?ComponentType} props.additionalBlockContent Component that renders additional block content UI. 62128 * @param {Ref} ref Forwarded ref 62129 */ 62130 function ListViewComponent({ 62131 id, 62132 blocks, 62133 dropZoneElement, 62134 showBlockMovers = false, 62135 isExpanded = false, 62136 showAppender = false, 62137 blockSettingsMenu: BlockSettingsMenu = BlockSettingsDropdown, 62138 rootClientId, 62139 description, 62140 onSelect, 62141 additionalBlockContent: AdditionalBlockContent 62142 }, ref) { 62143 // This can be removed once we no longer need to support the blocks prop. 62144 if (blocks) { 62145 external_wp_deprecated_default()('`blocks` property in `wp.blockEditor.__experimentalListView`', { 62146 since: '6.3', 62147 alternative: '`rootClientId` property' 62148 }); 62149 } 62150 const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(ListViewComponent); 62151 const { 62152 clientIdsTree, 62153 draggedClientIds, 62154 selectedClientIds 62155 } = useListViewClientIds({ 62156 blocks, 62157 rootClientId 62158 }); 62159 const blockIndexes = useListViewBlockIndexes(clientIdsTree); 62160 const { 62161 getBlock 62162 } = (0,external_wp_data_namespaceObject.useSelect)(store); 62163 const { 62164 visibleBlockCount 62165 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 62166 const { 62167 getGlobalBlockCount, 62168 getClientIdsOfDescendants 62169 } = select(store); 62170 const draggedBlockCount = draggedClientIds?.length > 0 ? getClientIdsOfDescendants(draggedClientIds).length + 1 : 0; 62171 return { 62172 visibleBlockCount: getGlobalBlockCount() - draggedBlockCount 62173 }; 62174 }, [draggedClientIds]); 62175 const { 62176 updateBlockSelection 62177 } = useBlockSelection(); 62178 const [expandedState, setExpandedState] = (0,external_wp_element_namespaceObject.useReducer)(expanded, {}); 62179 const [insertedBlock, setInsertedBlock] = (0,external_wp_element_namespaceObject.useState)(null); 62180 const { 62181 setSelectedTreeId 62182 } = useListViewExpandSelectedItem({ 62183 firstSelectedBlockClientId: selectedClientIds[0], 62184 setExpandedState 62185 }); 62186 const selectEditorBlock = (0,external_wp_element_namespaceObject.useCallback)( 62187 /** 62188 * @param {MouseEvent | KeyboardEvent | undefined} event 62189 * @param {string} blockClientId 62190 * @param {null | undefined | -1 | 1} focusPosition 62191 */ 62192 (event, blockClientId, focusPosition) => { 62193 updateBlockSelection(event, blockClientId, null, focusPosition); 62194 setSelectedTreeId(blockClientId); 62195 if (onSelect) { 62196 onSelect(getBlock(blockClientId)); 62197 } 62198 }, [setSelectedTreeId, updateBlockSelection, onSelect, getBlock]); 62199 const { 62200 ref: dropZoneRef, 62201 target: blockDropTarget 62202 } = useListViewDropZone({ 62203 dropZoneElement, 62204 expandedState, 62205 setExpandedState 62206 }); 62207 const elementRef = (0,external_wp_element_namespaceObject.useRef)(); 62208 62209 // Allow handling of copy, cut, and paste events. 62210 const clipBoardRef = use_clipboard_handler_useClipboardHandler({ 62211 selectBlock: selectEditorBlock 62212 }); 62213 const treeGridRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([clipBoardRef, elementRef, dropZoneRef, ref]); 62214 (0,external_wp_element_namespaceObject.useEffect)(() => { 62215 // If a blocks are already selected when the list view is initially 62216 // mounted, shift focus to the first selected block. 62217 if (selectedClientIds?.length) { 62218 focusListItem(selectedClientIds[0], elementRef?.current); 62219 } 62220 // Disable reason: Only focus on the selected item when the list view is mounted. 62221 // eslint-disable-next-line react-hooks/exhaustive-deps 62222 }, []); 62223 const expand = (0,external_wp_element_namespaceObject.useCallback)(clientId => { 62224 if (!clientId) { 62225 return; 62226 } 62227 const clientIds = Array.isArray(clientId) ? clientId : [clientId]; 62228 setExpandedState({ 62229 type: 'expand', 62230 clientIds 62231 }); 62232 }, [setExpandedState]); 62233 const collapse = (0,external_wp_element_namespaceObject.useCallback)(clientId => { 62234 if (!clientId) { 62235 return; 62236 } 62237 setExpandedState({ 62238 type: 'collapse', 62239 clientIds: [clientId] 62240 }); 62241 }, [setExpandedState]); 62242 const collapseAll = (0,external_wp_element_namespaceObject.useCallback)(() => { 62243 setExpandedState({ 62244 type: 'clear' 62245 }); 62246 }, [setExpandedState]); 62247 const expandRow = (0,external_wp_element_namespaceObject.useCallback)(row => { 62248 expand(row?.dataset?.block); 62249 }, [expand]); 62250 const collapseRow = (0,external_wp_element_namespaceObject.useCallback)(row => { 62251 collapse(row?.dataset?.block); 62252 }, [collapse]); 62253 const focusRow = (0,external_wp_element_namespaceObject.useCallback)((event, startRow, endRow) => { 62254 if (event.shiftKey) { 62255 updateBlockSelection(event, startRow?.dataset?.block, endRow?.dataset?.block); 62256 } 62257 }, [updateBlockSelection]); 62258 useListViewCollapseItems({ 62259 collapseAll, 62260 expand 62261 }); 62262 const firstDraggedBlockClientId = draggedClientIds?.[0]; 62263 62264 // Convert a blockDropTarget into indexes relative to the blocks in the list view. 62265 // These values are used to determine which blocks should be displaced to make room 62266 // for the drop indicator. See `ListViewBranch` and `getDragDisplacementValues`. 62267 const { 62268 blockDropTargetIndex, 62269 blockDropPosition, 62270 firstDraggedBlockIndex 62271 } = (0,external_wp_element_namespaceObject.useMemo)(() => { 62272 let _blockDropTargetIndex, _firstDraggedBlockIndex; 62273 if (blockDropTarget?.clientId) { 62274 const foundBlockIndex = blockIndexes[blockDropTarget.clientId]; 62275 // If dragging below or inside the block, treat the drop target as the next block. 62276 _blockDropTargetIndex = foundBlockIndex === undefined || blockDropTarget?.dropPosition === 'top' ? foundBlockIndex : foundBlockIndex + 1; 62277 } else if (blockDropTarget === null) { 62278 // A `null` value is used to indicate that the user is dragging outside of the list view. 62279 _blockDropTargetIndex = null; 62280 } 62281 if (firstDraggedBlockClientId) { 62282 const foundBlockIndex = blockIndexes[firstDraggedBlockClientId]; 62283 _firstDraggedBlockIndex = foundBlockIndex === undefined || blockDropTarget?.dropPosition === 'top' ? foundBlockIndex : foundBlockIndex + 1; 62284 } 62285 return { 62286 blockDropTargetIndex: _blockDropTargetIndex, 62287 blockDropPosition: blockDropTarget?.dropPosition, 62288 firstDraggedBlockIndex: _firstDraggedBlockIndex 62289 }; 62290 }, [blockDropTarget, blockIndexes, firstDraggedBlockClientId]); 62291 const contextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({ 62292 blockDropPosition, 62293 blockDropTargetIndex, 62294 blockIndexes, 62295 draggedClientIds, 62296 expandedState, 62297 expand, 62298 firstDraggedBlockIndex, 62299 collapse, 62300 collapseAll, 62301 BlockSettingsMenu, 62302 listViewInstanceId: instanceId, 62303 AdditionalBlockContent, 62304 insertedBlock, 62305 setInsertedBlock, 62306 treeGridElementRef: elementRef, 62307 rootClientId 62308 }), [blockDropPosition, blockDropTargetIndex, blockIndexes, draggedClientIds, expandedState, expand, firstDraggedBlockIndex, collapse, collapseAll, BlockSettingsMenu, instanceId, AdditionalBlockContent, insertedBlock, setInsertedBlock, rootClientId]); 62309 62310 // List View renders a fixed number of items and relies on each having a fixed item height of 36px. 62311 // If this value changes, we should also change the itemHeight value set in useFixedWindowList. 62312 // See: https://github.com/WordPress/gutenberg/pull/35230 for additional context. 62313 const [fixedListWindow] = (0,external_wp_compose_namespaceObject.__experimentalUseFixedWindowList)(elementRef, BLOCK_LIST_ITEM_HEIGHT, visibleBlockCount, { 62314 // Ensure that the windowing logic is recalculated when the expanded state changes. 62315 // This is necessary because expanding a collapsed block in a short list view can 62316 // switch the list view to a tall list view with a scrollbar, and vice versa. 62317 // When this happens, the windowing logic needs to be recalculated to ensure that 62318 // the correct number of blocks are rendered, by rechecking for a scroll container. 62319 expandedState, 62320 useWindowing: true, 62321 windowOverscan: 40 62322 }); 62323 62324 // If there are no blocks to show and we're not showing the appender, do not render the list view. 62325 if (!clientIdsTree.length && !showAppender) { 62326 return null; 62327 } 62328 const describedById = description && `block-editor-list-view-description-$instanceId}`; 62329 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_data_namespaceObject.AsyncModeProvider, { 62330 value: true, 62331 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewDropIndicatorPreview, { 62332 draggedBlockClientId: firstDraggedBlockClientId, 62333 listViewRef: elementRef, 62334 blockDropTarget: blockDropTarget 62335 }), description && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 62336 id: describedById, 62337 children: description 62338 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGrid, { 62339 id: id, 62340 className: dist_clsx('block-editor-list-view-tree', { 62341 'is-dragging': draggedClientIds?.length > 0 && blockDropTargetIndex !== undefined 62342 }), 62343 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Block navigation structure'), 62344 ref: treeGridRef, 62345 onCollapseRow: collapseRow, 62346 onExpandRow: expandRow, 62347 onFocusRow: focusRow, 62348 applicationAriaLabel: (0,external_wp_i18n_namespaceObject.__)('Block navigation structure'), 62349 "aria-describedby": describedById, 62350 style: { 62351 '--wp-admin--list-view-dragged-items-height': draggedClientIds?.length ? `$BLOCK_LIST_ITEM_HEIGHT * (draggedClientIds.length - 1)}px` : null 62352 }, 62353 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewContext.Provider, { 62354 value: contextValue, 62355 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(branch, { 62356 blocks: clientIdsTree, 62357 parentId: rootClientId, 62358 selectBlock: selectEditorBlock, 62359 showBlockMovers: showBlockMovers, 62360 fixedListWindow: fixedListWindow, 62361 selectedClientIds: selectedClientIds, 62362 isExpanded: isExpanded, 62363 showAppender: showAppender 62364 }) 62365 }) 62366 })] 62367 }); 62368 } 62369 62370 // This is the private API for the ListView component. 62371 // It allows access to all props, not just the public ones. 62372 const PrivateListView = (0,external_wp_element_namespaceObject.forwardRef)(ListViewComponent); 62373 62374 // This is the public API for the ListView component. 62375 // We wrap the PrivateListView component to hide some props from the public API. 62376 /* harmony default export */ const components_list_view = ((0,external_wp_element_namespaceObject.forwardRef)((props, ref) => { 62377 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateListView, { 62378 ref: ref, 62379 ...props, 62380 showAppender: false, 62381 rootClientId: null, 62382 onSelect: null, 62383 additionalBlockContent: null, 62384 blockSettingsMenu: undefined 62385 }); 62386 })); 62387 62388 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-navigation/dropdown.js 62389 /** 62390 * WordPress dependencies 62391 */ 62392 62393 62394 /** 62395 * WordPress dependencies 62396 */ 62397 62398 62399 62400 62401 62402 62403 /** 62404 * Internal dependencies 62405 */ 62406 62407 62408 62409 62410 function BlockNavigationDropdownToggle({ 62411 isEnabled, 62412 onToggle, 62413 isOpen, 62414 innerRef, 62415 ...props 62416 }) { 62417 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button 62418 // TODO: Switch to `true` (40px size) if possible 62419 , { 62420 __next40pxDefaultSize: false, 62421 ...props, 62422 ref: innerRef, 62423 icon: list_view, 62424 "aria-expanded": isOpen, 62425 "aria-haspopup": "true", 62426 onClick: isEnabled ? onToggle : undefined 62427 /* translators: button label text should, if possible, be under 16 characters. */, 62428 label: (0,external_wp_i18n_namespaceObject.__)('List view'), 62429 className: "block-editor-block-navigation", 62430 "aria-disabled": !isEnabled 62431 }); 62432 } 62433 function BlockNavigationDropdown({ 62434 isDisabled, 62435 ...props 62436 }, ref) { 62437 external_wp_deprecated_default()('wp.blockEditor.BlockNavigationDropdown', { 62438 since: '6.1', 62439 alternative: 'wp.components.Dropdown and wp.blockEditor.ListView' 62440 }); 62441 const hasBlocks = (0,external_wp_data_namespaceObject.useSelect)(select => !!select(store).getBlockCount(), []); 62442 const isEnabled = hasBlocks && !isDisabled; 62443 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 62444 contentClassName: "block-editor-block-navigation__popover", 62445 popoverProps: { 62446 placement: 'bottom-start' 62447 }, 62448 renderToggle: ({ 62449 isOpen, 62450 onToggle 62451 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockNavigationDropdownToggle, { 62452 ...props, 62453 innerRef: ref, 62454 isOpen: isOpen, 62455 onToggle: onToggle, 62456 isEnabled: isEnabled 62457 }), 62458 renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 62459 className: "block-editor-block-navigation__container", 62460 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 62461 className: "block-editor-block-navigation__label", 62462 children: (0,external_wp_i18n_namespaceObject.__)('List view') 62463 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(components_list_view, {})] 62464 }) 62465 }); 62466 } 62467 /* harmony default export */ const dropdown = ((0,external_wp_element_namespaceObject.forwardRef)(BlockNavigationDropdown)); 62468 62469 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/preview-panel.js 62470 /** 62471 * WordPress dependencies 62472 */ 62473 62474 62475 62476 /** 62477 * Internal dependencies 62478 */ 62479 62480 62481 62482 function BlockStylesPreviewPanel({ 62483 genericPreviewBlock, 62484 style, 62485 className, 62486 activeStyle 62487 }) { 62488 const example = (0,external_wp_blocks_namespaceObject.getBlockType)(genericPreviewBlock.name)?.example; 62489 const styleClassName = replaceActiveStyle(className, activeStyle, style); 62490 const previewBlocks = (0,external_wp_element_namespaceObject.useMemo)(() => { 62491 return { 62492 ...genericPreviewBlock, 62493 title: style.label || style.name, 62494 description: style.description, 62495 initialAttributes: { 62496 ...genericPreviewBlock.attributes, 62497 className: styleClassName + ' block-editor-block-styles__block-preview-container' 62498 }, 62499 example 62500 }; 62501 }, [genericPreviewBlock, styleClassName]); 62502 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(preview_panel, { 62503 item: previewBlocks 62504 }); 62505 } 62506 62507 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/index.js 62508 /** 62509 * External dependencies 62510 */ 62511 62512 62513 /** 62514 * WordPress dependencies 62515 */ 62516 62517 62518 62519 62520 /** 62521 * Internal dependencies 62522 */ 62523 62524 62525 62526 62527 const block_styles_noop = () => {}; 62528 62529 // Block Styles component for the Settings Sidebar. 62530 function BlockStyles({ 62531 clientId, 62532 onSwitch = block_styles_noop, 62533 onHoverClassName = block_styles_noop 62534 }) { 62535 const { 62536 onSelect, 62537 stylesToRender, 62538 activeStyle, 62539 genericPreviewBlock, 62540 className: previewClassName 62541 } = useStylesForBlocks({ 62542 clientId, 62543 onSwitch 62544 }); 62545 const [hoveredStyle, setHoveredStyle] = (0,external_wp_element_namespaceObject.useState)(null); 62546 const isMobileViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<'); 62547 if (!stylesToRender || stylesToRender.length === 0) { 62548 return null; 62549 } 62550 const debouncedSetHoveredStyle = (0,external_wp_compose_namespaceObject.debounce)(setHoveredStyle, 250); 62551 const onSelectStylePreview = style => { 62552 onSelect(style); 62553 onHoverClassName(null); 62554 setHoveredStyle(null); 62555 debouncedSetHoveredStyle.cancel(); 62556 }; 62557 const styleItemHandler = item => { 62558 var _item$name; 62559 if (hoveredStyle === item) { 62560 debouncedSetHoveredStyle.cancel(); 62561 return; 62562 } 62563 debouncedSetHoveredStyle(item); 62564 onHoverClassName((_item$name = item?.name) !== null && _item$name !== void 0 ? _item$name : null); 62565 }; 62566 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 62567 className: "block-editor-block-styles", 62568 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 62569 className: "block-editor-block-styles__variants", 62570 children: stylesToRender.map(style => { 62571 const buttonText = style.label || style.name; 62572 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 62573 __next40pxDefaultSize: true, 62574 className: dist_clsx('block-editor-block-styles__item', { 62575 'is-active': activeStyle.name === style.name 62576 }), 62577 variant: "secondary", 62578 label: buttonText, 62579 onMouseEnter: () => styleItemHandler(style), 62580 onFocus: () => styleItemHandler(style), 62581 onMouseLeave: () => styleItemHandler(null), 62582 onBlur: () => styleItemHandler(null), 62583 onClick: () => onSelectStylePreview(style), 62584 "aria-current": activeStyle.name === style.name, 62585 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, { 62586 numberOfLines: 1, 62587 className: "block-editor-block-styles__item-text", 62588 children: buttonText 62589 }) 62590 }, style.name); 62591 }) 62592 }), hoveredStyle && !isMobileViewport && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, { 62593 placement: "left-start", 62594 offset: 34, 62595 focusOnMount: false, 62596 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 62597 className: "block-editor-block-styles__preview-panel", 62598 onMouseLeave: () => styleItemHandler(null), 62599 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesPreviewPanel, { 62600 activeStyle: activeStyle, 62601 className: previewClassName, 62602 genericPreviewBlock: genericPreviewBlock, 62603 style: hoveredStyle 62604 }) 62605 }) 62606 })] 62607 }); 62608 } 62609 /* harmony default export */ const block_styles = (BlockStyles); 62610 62611 ;// ./node_modules/@wordpress/icons/build-module/library/paragraph.js 62612 /** 62613 * WordPress dependencies 62614 */ 62615 62616 62617 const paragraph = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 62618 xmlns: "http://www.w3.org/2000/svg", 62619 viewBox: "0 0 24 24", 62620 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 62621 d: "m9.99609 14v-.2251l.00391.0001v6.225h1.5v-14.5h2.5v14.5h1.5v-14.5h3v-1.5h-8.50391c-2.76142 0-5 2.23858-5 5 0 2.7614 2.23858 5 5 5z" 62622 }) 62623 }); 62624 /* harmony default export */ const library_paragraph = (paragraph); 62625 62626 ;// ./node_modules/@wordpress/icons/build-module/library/heading-level-1.js 62627 /** 62628 * WordPress dependencies 62629 */ 62630 62631 62632 const headingLevel1 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 62633 xmlns: "http://www.w3.org/2000/svg", 62634 viewBox: "0 0 24 24", 62635 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 62636 d: "M17.6 7c-.6.9-1.5 1.7-2.6 2v1h2v7h2V7h-1.4zM11 11H7V7H5v10h2v-4h4v4h2V7h-2v4z" 62637 }) 62638 }); 62639 /* harmony default export */ const heading_level_1 = (headingLevel1); 62640 62641 ;// ./node_modules/@wordpress/icons/build-module/library/heading-level-2.js 62642 /** 62643 * WordPress dependencies 62644 */ 62645 62646 62647 const headingLevel2 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 62648 xmlns: "http://www.w3.org/2000/svg", 62649 viewBox: "0 0 24 24", 62650 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 62651 d: "M9 11.1H5v-4H3v10h2v-4h4v4h2v-10H9v4zm8 4c.5-.4.6-.6 1.1-1.1.4-.4.8-.8 1.2-1.3.3-.4.6-.8.9-1.3.2-.4.3-.8.3-1.3 0-.4-.1-.9-.3-1.3-.2-.4-.4-.7-.8-1-.3-.3-.7-.5-1.2-.6-.5-.2-1-.2-1.5-.2-.4 0-.7 0-1.1.1-.3.1-.7.2-1 .3-.3.1-.6.3-.9.5-.3.2-.6.4-.8.7l1.2 1.2c.3-.3.6-.5 1-.7.4-.2.7-.3 1.2-.3s.9.1 1.3.4c.3.3.5.7.5 1.1 0 .4-.1.8-.4 1.1-.3.5-.6.9-1 1.2-.4.4-1 .9-1.6 1.4-.6.5-1.4 1.1-2.2 1.6v1.5h8v-2H17z" 62652 }) 62653 }); 62654 /* harmony default export */ const heading_level_2 = (headingLevel2); 62655 62656 ;// ./node_modules/@wordpress/icons/build-module/library/heading-level-3.js 62657 /** 62658 * WordPress dependencies 62659 */ 62660 62661 62662 const headingLevel3 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 62663 xmlns: "http://www.w3.org/2000/svg", 62664 viewBox: "0 0 24 24", 62665 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 62666 d: "M9 11H5V7H3v10h2v-4h4v4h2V7H9v4zm11.3 1.7c-.4-.4-1-.7-1.6-.8v-.1c.6-.2 1.1-.5 1.5-.9.3-.4.5-.8.5-1.3 0-.4-.1-.8-.3-1.1-.2-.3-.5-.6-.8-.8-.4-.2-.8-.4-1.2-.5-.6-.1-1.1-.2-1.6-.2-.6 0-1.3.1-1.8.3s-1.1.5-1.6.9l1.2 1.4c.4-.2.7-.4 1.1-.6.3-.2.7-.3 1.1-.3.4 0 .8.1 1.1.3.3.2.4.5.4.8 0 .4-.2.7-.6.9-.7.3-1.5.5-2.2.4v1.6c.5 0 1 0 1.5.1.3.1.7.2 1 .3.2.1.4.2.5.4s.1.4.1.6c0 .3-.2.7-.5.8-.4.2-.9.3-1.4.3s-1-.1-1.4-.3c-.4-.2-.8-.4-1.2-.7L13 15.6c.5.4 1 .8 1.6 1 .7.3 1.5.4 2.3.4.6 0 1.1-.1 1.6-.2.4-.1.9-.2 1.3-.5.4-.2.7-.5.9-.9.2-.4.3-.8.3-1.2 0-.6-.3-1.1-.7-1.5z" 62667 }) 62668 }); 62669 /* harmony default export */ const heading_level_3 = (headingLevel3); 62670 62671 ;// ./node_modules/@wordpress/icons/build-module/library/heading-level-4.js 62672 /** 62673 * WordPress dependencies 62674 */ 62675 62676 62677 const headingLevel4 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 62678 xmlns: "http://www.w3.org/2000/svg", 62679 viewBox: "0 0 24 24", 62680 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 62681 d: "M20 13V7h-3l-4 6v2h5v2h2v-2h1v-2h-1zm-2 0h-2.8L18 9v4zm-9-2H5V7H3v10h2v-4h4v4h2V7H9v4z" 62682 }) 62683 }); 62684 /* harmony default export */ const heading_level_4 = (headingLevel4); 62685 62686 ;// ./node_modules/@wordpress/icons/build-module/library/heading-level-5.js 62687 /** 62688 * WordPress dependencies 62689 */ 62690 62691 62692 const headingLevel5 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 62693 xmlns: "http://www.w3.org/2000/svg", 62694 viewBox: "0 0 24 24", 62695 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 62696 d: "M9 11H5V7H3v10h2v-4h4v4h2V7H9v4zm11.7 1.2c-.2-.3-.5-.7-.8-.9-.3-.3-.7-.5-1.1-.6-.5-.1-.9-.2-1.4-.2-.2 0-.5.1-.7.1-.2.1-.5.1-.7.2l.1-1.9h4.3V7H14l-.3 5 1 .6.5-.2.4-.1c.1-.1.3-.1.4-.1h.5c.5 0 1 .1 1.4.4.4.2.6.7.6 1.1 0 .4-.2.8-.6 1.1-.4.3-.9.4-1.4.4-.4 0-.9-.1-1.3-.3-.4-.2-.7-.4-1.1-.7 0 0-1.1 1.4-1 1.5.5.4 1 .8 1.6 1 .7.3 1.5.4 2.3.4.5 0 1-.1 1.5-.3s.9-.4 1.3-.7c.4-.3.7-.7.9-1.1s.3-.9.3-1.4-.1-1-.3-1.4z" 62697 }) 62698 }); 62699 /* harmony default export */ const heading_level_5 = (headingLevel5); 62700 62701 ;// ./node_modules/@wordpress/icons/build-module/library/heading-level-6.js 62702 /** 62703 * WordPress dependencies 62704 */ 62705 62706 62707 const headingLevel6 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 62708 xmlns: "http://www.w3.org/2000/svg", 62709 viewBox: "0 0 24 24", 62710 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 62711 d: "M20.7 12.4c-.2-.3-.4-.6-.7-.9s-.6-.5-1-.6c-.4-.2-.8-.2-1.2-.2-.5 0-.9.1-1.3.3s-.8.5-1.2.8c0-.5 0-.9.2-1.4l.6-.9c.2-.2.5-.4.8-.5.6-.2 1.3-.2 1.9 0 .3.1.6.3.8.5 0 0 1.3-1.3 1.3-1.4-.4-.3-.9-.6-1.4-.8-.6-.2-1.3-.3-2-.3-.6 0-1.1.1-1.7.4-.5.2-1 .5-1.4.9-.4.4-.8 1-1 1.6-.3.7-.4 1.5-.4 2.3s.1 1.5.3 2.1c.2.6.6 1.1 1 1.5.4.4.9.7 1.4.9 1 .3 2 .3 3 0 .4-.1.8-.3 1.2-.6.3-.3.6-.6.8-1 .2-.5.3-.9.3-1.4s-.1-.9-.3-1.3zm-2 2.1c-.1.2-.3.4-.4.5-.1.1-.3.2-.5.2-.2.1-.4.1-.6.1-.2.1-.5 0-.7-.1-.2 0-.3-.2-.5-.3-.1-.2-.3-.4-.4-.6-.2-.3-.3-.7-.3-1 .3-.3.6-.5 1-.7.3-.1.7-.2 1-.2.4 0 .8.1 1.1.3.3.3.4.7.4 1.1 0 .2 0 .5-.1.7zM9 11H5V7H3v10h2v-4h4v4h2V7H9v4z" 62712 }) 62713 }); 62714 /* harmony default export */ const heading_level_6 = (headingLevel6); 62715 62716 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-heading-level-dropdown/heading-level-icon.js 62717 /** 62718 * WordPress dependencies 62719 */ 62720 62721 62722 62723 /** @typedef {import('react').ComponentType} ComponentType */ 62724 62725 /** 62726 * HeadingLevelIcon props. 62727 * 62728 * @typedef WPHeadingLevelIconProps 62729 * 62730 * @property {number} level The heading level to show an icon for. 62731 */ 62732 62733 const LEVEL_TO_PATH = { 62734 0: library_paragraph, 62735 1: heading_level_1, 62736 2: heading_level_2, 62737 3: heading_level_3, 62738 4: heading_level_4, 62739 5: heading_level_5, 62740 6: heading_level_6 62741 }; 62742 62743 /** 62744 * Heading level icon. 62745 * 62746 * @param {WPHeadingLevelIconProps} props Component props. 62747 * 62748 * @return {?ComponentType} The icon. 62749 */ 62750 function HeadingLevelIcon({ 62751 level 62752 }) { 62753 if (LEVEL_TO_PATH[level]) { 62754 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, { 62755 icon: LEVEL_TO_PATH[level] 62756 }); 62757 } 62758 return null; 62759 } 62760 62761 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-heading-level-dropdown/index.js 62762 /** 62763 * WordPress dependencies 62764 */ 62765 62766 62767 62768 /** 62769 * Internal dependencies 62770 */ 62771 62772 62773 const HEADING_LEVELS = [1, 2, 3, 4, 5, 6]; 62774 const block_heading_level_dropdown_POPOVER_PROPS = { 62775 className: 'block-library-heading-level-dropdown' 62776 }; 62777 62778 /** @typedef {import('react').ComponentType} ComponentType */ 62779 62780 /** 62781 * HeadingLevelDropdown props. 62782 * 62783 * @typedef WPHeadingLevelDropdownProps 62784 * 62785 * @property {number} value The chosen heading level. 62786 * @property {number[]} options An array of supported heading levels. 62787 * @property {()=>number} onChange Function called with 62788 * the selected value changes. 62789 */ 62790 62791 /** 62792 * Dropdown for selecting a heading level (1 through 6) or paragraph (0). 62793 * 62794 * @param {WPHeadingLevelDropdownProps} props Component props. 62795 * 62796 * @return {ComponentType} The toolbar. 62797 */ 62798 function HeadingLevelDropdown({ 62799 options = HEADING_LEVELS, 62800 value, 62801 onChange 62802 }) { 62803 const validOptions = options.filter(option => option === 0 || HEADING_LEVELS.includes(option)).sort((a, b) => a - b); // Sorts numerically in ascending order; 62804 62805 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarDropdownMenu, { 62806 popoverProps: block_heading_level_dropdown_POPOVER_PROPS, 62807 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(HeadingLevelIcon, { 62808 level: value 62809 }), 62810 label: (0,external_wp_i18n_namespaceObject.__)('Change level'), 62811 controls: validOptions.map(targetLevel => { 62812 const isActive = targetLevel === value; 62813 return { 62814 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(HeadingLevelIcon, { 62815 level: targetLevel 62816 }), 62817 title: targetLevel === 0 ? (0,external_wp_i18n_namespaceObject.__)('Paragraph') : (0,external_wp_i18n_namespaceObject.sprintf)( 62818 // translators: %d: heading level e.g: "1", "2", "3" 62819 (0,external_wp_i18n_namespaceObject.__)('Heading %d'), targetLevel), 62820 isActive, 62821 onClick() { 62822 onChange(targetLevel); 62823 }, 62824 role: 'menuitemradio' 62825 }; 62826 }) 62827 }); 62828 } 62829 62830 ;// ./node_modules/@wordpress/icons/build-module/library/layout.js 62831 /** 62832 * WordPress dependencies 62833 */ 62834 62835 62836 const layout_layout = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 62837 xmlns: "http://www.w3.org/2000/svg", 62838 viewBox: "0 0 24 24", 62839 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 62840 d: "M18 5.5H6a.5.5 0 00-.5.5v3h13V6a.5.5 0 00-.5-.5zm.5 5H10v8h8a.5.5 0 00.5-.5v-7.5zm-10 0h-3V18a.5.5 0 00.5.5h2.5v-8zM6 4h12a2 2 0 012 2v12a2 2 0 01-2 2H6a2 2 0 01-2-2V6a2 2 0 012-2z" 62841 }) 62842 }); 62843 /* harmony default export */ const library_layout = (layout_layout); 62844 62845 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-variation-picker/index.js 62846 /** 62847 * External dependencies 62848 */ 62849 62850 62851 /** 62852 * WordPress dependencies 62853 */ 62854 62855 62856 62857 62858 62859 function BlockVariationPicker({ 62860 icon = library_layout, 62861 label = (0,external_wp_i18n_namespaceObject.__)('Choose variation'), 62862 instructions = (0,external_wp_i18n_namespaceObject.__)('Select a variation to start with:'), 62863 variations, 62864 onSelect, 62865 allowSkip 62866 }) { 62867 const classes = dist_clsx('block-editor-block-variation-picker', { 62868 'has-many-variations': variations.length > 4 62869 }); 62870 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Placeholder, { 62871 icon: icon, 62872 label: label, 62873 instructions: instructions, 62874 className: classes, 62875 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("ul", { 62876 className: "block-editor-block-variation-picker__variations", 62877 role: "list", 62878 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Block variations'), 62879 children: variations.map(variation => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", { 62880 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 62881 __next40pxDefaultSize: true, 62882 variant: "tertiary", 62883 icon: variation.icon && variation.icon.src ? variation.icon.src : variation.icon, 62884 iconSize: 48, 62885 onClick: () => onSelect(variation), 62886 className: "block-editor-block-variation-picker__variation", 62887 label: variation.description || variation.title 62888 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 62889 className: "block-editor-block-variation-picker__variation-label", 62890 children: variation.title 62891 })] 62892 }, variation.name)) 62893 }), allowSkip && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 62894 className: "block-editor-block-variation-picker__skip", 62895 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 62896 __next40pxDefaultSize: true, 62897 variant: "link", 62898 onClick: () => onSelect(), 62899 children: (0,external_wp_i18n_namespaceObject.__)('Skip') 62900 }) 62901 })] 62902 }); 62903 } 62904 /* harmony default export */ const block_variation_picker = (BlockVariationPicker); 62905 62906 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-pattern-setup/constants.js 62907 const VIEWMODES = { 62908 carousel: 'carousel', 62909 grid: 'grid' 62910 }; 62911 62912 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-pattern-setup/setup-toolbar.js 62913 /** 62914 * WordPress dependencies 62915 */ 62916 62917 62918 62919 62920 /** 62921 * Internal dependencies 62922 */ 62923 62924 62925 62926 const Actions = ({ 62927 onBlockPatternSelect 62928 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 62929 className: "block-editor-block-pattern-setup__actions", 62930 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button 62931 // TODO: Switch to `true` (40px size) if possible 62932 , { 62933 __next40pxDefaultSize: false, 62934 variant: "primary", 62935 onClick: onBlockPatternSelect, 62936 children: (0,external_wp_i18n_namespaceObject.__)('Choose') 62937 }) 62938 }); 62939 const CarouselNavigation = ({ 62940 handlePrevious, 62941 handleNext, 62942 activeSlide, 62943 totalSlides 62944 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 62945 className: "block-editor-block-pattern-setup__navigation", 62946 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button 62947 // TODO: Switch to `true` (40px size) if possible 62948 , { 62949 __next40pxDefaultSize: false, 62950 icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left, 62951 label: (0,external_wp_i18n_namespaceObject.__)('Previous pattern'), 62952 onClick: handlePrevious, 62953 disabled: activeSlide === 0, 62954 accessibleWhenDisabled: true 62955 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button 62956 // TODO: Switch to `true` (40px size) if possible 62957 , { 62958 __next40pxDefaultSize: false, 62959 icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right, 62960 label: (0,external_wp_i18n_namespaceObject.__)('Next pattern'), 62961 onClick: handleNext, 62962 disabled: activeSlide === totalSlides - 1, 62963 accessibleWhenDisabled: true 62964 })] 62965 }); 62966 const SetupToolbar = ({ 62967 viewMode, 62968 setViewMode, 62969 handlePrevious, 62970 handleNext, 62971 activeSlide, 62972 totalSlides, 62973 onBlockPatternSelect 62974 }) => { 62975 const isCarouselView = viewMode === VIEWMODES.carousel; 62976 const displayControls = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 62977 className: "block-editor-block-pattern-setup__display-controls", 62978 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button 62979 // TODO: Switch to `true` (40px size) if possible 62980 , { 62981 __next40pxDefaultSize: false, 62982 icon: stretch_full_width, 62983 label: (0,external_wp_i18n_namespaceObject.__)('Carousel view'), 62984 onClick: () => setViewMode(VIEWMODES.carousel), 62985 isPressed: isCarouselView 62986 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button 62987 // TODO: Switch to `true` (40px size) if possible 62988 , { 62989 __next40pxDefaultSize: false, 62990 icon: library_grid, 62991 label: (0,external_wp_i18n_namespaceObject.__)('Grid view'), 62992 onClick: () => setViewMode(VIEWMODES.grid), 62993 isPressed: viewMode === VIEWMODES.grid 62994 })] 62995 }); 62996 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 62997 className: "block-editor-block-pattern-setup__toolbar", 62998 children: [isCarouselView && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CarouselNavigation, { 62999 handlePrevious: handlePrevious, 63000 handleNext: handleNext, 63001 activeSlide: activeSlide, 63002 totalSlides: totalSlides 63003 }), displayControls, isCarouselView && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Actions, { 63004 onBlockPatternSelect: onBlockPatternSelect 63005 })] 63006 }); 63007 }; 63008 /* harmony default export */ const setup_toolbar = (SetupToolbar); 63009 63010 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-pattern-setup/use-patterns-setup.js 63011 /** 63012 * WordPress dependencies 63013 */ 63014 63015 63016 /** 63017 * Internal dependencies 63018 */ 63019 63020 function usePatternsSetup(clientId, blockName, filterPatternsFn) { 63021 return (0,external_wp_data_namespaceObject.useSelect)(select => { 63022 const { 63023 getBlockRootClientId, 63024 getPatternsByBlockTypes, 63025 __experimentalGetAllowedPatterns 63026 } = select(store); 63027 const rootClientId = getBlockRootClientId(clientId); 63028 if (filterPatternsFn) { 63029 return __experimentalGetAllowedPatterns(rootClientId).filter(filterPatternsFn); 63030 } 63031 return getPatternsByBlockTypes(blockName, rootClientId); 63032 }, [clientId, blockName, filterPatternsFn]); 63033 } 63034 /* harmony default export */ const use_patterns_setup = (usePatternsSetup); 63035 63036 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-pattern-setup/index.js 63037 /** 63038 * WordPress dependencies 63039 */ 63040 63041 63042 63043 63044 63045 63046 63047 /** 63048 * Internal dependencies 63049 */ 63050 63051 63052 63053 63054 63055 63056 63057 63058 const SetupContent = ({ 63059 viewMode, 63060 activeSlide, 63061 patterns, 63062 onBlockPatternSelect, 63063 showTitles 63064 }) => { 63065 const containerClass = 'block-editor-block-pattern-setup__container'; 63066 if (viewMode === VIEWMODES.carousel) { 63067 const slideClass = new Map([[activeSlide, 'active-slide'], [activeSlide - 1, 'previous-slide'], [activeSlide + 1, 'next-slide']]); 63068 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 63069 className: "block-editor-block-pattern-setup__carousel", 63070 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 63071 className: containerClass, 63072 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 63073 className: "carousel-container", 63074 children: patterns.map((pattern, index) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockPatternSlide, { 63075 active: index === activeSlide, 63076 className: slideClass.get(index) || '', 63077 pattern: pattern 63078 }, pattern.name)) 63079 }) 63080 }) 63081 }); 63082 } 63083 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 63084 className: "block-editor-block-pattern-setup__grid", 63085 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, { 63086 role: "listbox", 63087 className: containerClass, 63088 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Patterns list'), 63089 children: patterns.map(pattern => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_pattern_setup_BlockPattern, { 63090 pattern: pattern, 63091 onSelect: onBlockPatternSelect, 63092 showTitles: showTitles 63093 }, pattern.name)) 63094 }) 63095 }); 63096 }; 63097 function block_pattern_setup_BlockPattern({ 63098 pattern, 63099 onSelect, 63100 showTitles 63101 }) { 63102 const baseClassName = 'block-editor-block-pattern-setup-list'; 63103 const { 63104 blocks, 63105 description, 63106 viewportWidth = 700 63107 } = pattern; 63108 const descriptionId = (0,external_wp_compose_namespaceObject.useInstanceId)(block_pattern_setup_BlockPattern, `$baseClassName}__item-description`); 63109 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 63110 className: `$baseClassName}__list-item`, 63111 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Composite.Item, { 63112 render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 63113 "aria-describedby": description ? descriptionId : undefined, 63114 "aria-label": pattern.title, 63115 className: `$baseClassName}__item` 63116 }), 63117 id: `$baseClassName}__pattern__$pattern.name}`, 63118 role: "option", 63119 onClick: () => onSelect(blocks), 63120 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, { 63121 blocks: blocks, 63122 viewportWidth: viewportWidth 63123 }), showTitles && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 63124 className: `$baseClassName}__item-title`, 63125 children: pattern.title 63126 }), !!description && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 63127 id: descriptionId, 63128 children: description 63129 })] 63130 }) 63131 }); 63132 } 63133 function BlockPatternSlide({ 63134 active, 63135 className, 63136 pattern, 63137 minHeight 63138 }) { 63139 const { 63140 blocks, 63141 title, 63142 description 63143 } = pattern; 63144 const descriptionId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockPatternSlide, 'block-editor-block-pattern-setup-list__item-description'); 63145 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 63146 "aria-hidden": !active, 63147 role: "img", 63148 className: `pattern-slide $className}`, 63149 "aria-label": title, 63150 "aria-describedby": description ? descriptionId : undefined, 63151 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, { 63152 blocks: blocks, 63153 minHeight: minHeight 63154 }), !!description && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 63155 id: descriptionId, 63156 children: description 63157 })] 63158 }); 63159 } 63160 const BlockPatternSetup = ({ 63161 clientId, 63162 blockName, 63163 filterPatternsFn, 63164 onBlockPatternSelect, 63165 initialViewMode = VIEWMODES.carousel, 63166 showTitles = false 63167 }) => { 63168 const [viewMode, setViewMode] = (0,external_wp_element_namespaceObject.useState)(initialViewMode); 63169 const [activeSlide, setActiveSlide] = (0,external_wp_element_namespaceObject.useState)(0); 63170 const { 63171 replaceBlock 63172 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 63173 const patterns = use_patterns_setup(clientId, blockName, filterPatternsFn); 63174 if (!patterns?.length) { 63175 return null; 63176 } 63177 const onBlockPatternSelectDefault = blocks => { 63178 const clonedBlocks = blocks.map(block => (0,external_wp_blocks_namespaceObject.cloneBlock)(block)); 63179 replaceBlock(clientId, clonedBlocks); 63180 }; 63181 const onPatternSelectCallback = onBlockPatternSelect || onBlockPatternSelectDefault; 63182 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 63183 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 63184 className: `block-editor-block-pattern-setup view-mode-$viewMode}`, 63185 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SetupContent, { 63186 viewMode: viewMode, 63187 activeSlide: activeSlide, 63188 patterns: patterns, 63189 onBlockPatternSelect: onPatternSelectCallback, 63190 showTitles: showTitles 63191 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(setup_toolbar, { 63192 viewMode: viewMode, 63193 setViewMode: setViewMode, 63194 activeSlide: activeSlide, 63195 totalSlides: patterns.length, 63196 handleNext: () => { 63197 setActiveSlide(active => Math.min(active + 1, patterns.length - 1)); 63198 }, 63199 handlePrevious: () => { 63200 setActiveSlide(active => Math.max(active - 1, 0)); 63201 }, 63202 onBlockPatternSelect: () => { 63203 onPatternSelectCallback(patterns[activeSlide].blocks); 63204 } 63205 })] 63206 }) 63207 }); 63208 }; 63209 /* harmony default export */ const block_pattern_setup = (BlockPatternSetup); 63210 63211 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-variation-transforms/index.js 63212 /** 63213 * WordPress dependencies 63214 */ 63215 63216 63217 63218 63219 63220 63221 63222 /** 63223 * Internal dependencies 63224 */ 63225 63226 63227 63228 63229 63230 function VariationsButtons({ 63231 className, 63232 onSelectVariation, 63233 selectedValue, 63234 variations 63235 }) { 63236 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", { 63237 className: className, 63238 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 63239 as: "legend", 63240 children: (0,external_wp_i18n_namespaceObject.__)('Transform to variation') 63241 }), variations.map(variation => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 63242 __next40pxDefaultSize: true, 63243 size: "compact", 63244 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 63245 icon: variation.icon, 63246 showColors: true 63247 }), 63248 isPressed: selectedValue === variation.name, 63249 label: selectedValue === variation.name ? variation.title : (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: Block or block variation name. */ 63250 (0,external_wp_i18n_namespaceObject.__)('Transform to %s'), variation.title), 63251 onClick: () => onSelectVariation(variation.name), 63252 "aria-label": variation.title, 63253 showTooltip: true 63254 }, variation.name))] 63255 }); 63256 } 63257 function VariationsDropdown({ 63258 className, 63259 onSelectVariation, 63260 selectedValue, 63261 variations 63262 }) { 63263 const selectOptions = variations.map(({ 63264 name, 63265 title, 63266 description 63267 }) => ({ 63268 value: name, 63269 label: title, 63270 info: description 63271 })); 63272 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, { 63273 className: className, 63274 label: (0,external_wp_i18n_namespaceObject.__)('Transform to variation'), 63275 text: (0,external_wp_i18n_namespaceObject.__)('Transform to variation'), 63276 popoverProps: { 63277 position: 'bottom center', 63278 className: `$className}__popover` 63279 }, 63280 icon: chevron_down, 63281 toggleProps: { 63282 iconPosition: 'right' 63283 }, 63284 children: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 63285 className: `$className}__container`, 63286 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, { 63287 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItemsChoice, { 63288 choices: selectOptions, 63289 value: selectedValue, 63290 onSelect: onSelectVariation 63291 }) 63292 }) 63293 }) 63294 }); 63295 } 63296 function VariationsToggleGroupControl({ 63297 className, 63298 onSelectVariation, 63299 selectedValue, 63300 variations 63301 }) { 63302 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 63303 className: className, 63304 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 63305 label: (0,external_wp_i18n_namespaceObject.__)('Transform to variation'), 63306 value: selectedValue, 63307 hideLabelFromVision: true, 63308 onChange: onSelectVariation, 63309 __next40pxDefaultSize: true, 63310 __nextHasNoMarginBottom: true, 63311 children: variations.map(variation => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, { 63312 icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 63313 icon: variation.icon, 63314 showColors: true 63315 }), 63316 value: variation.name, 63317 label: selectedValue === variation.name ? variation.title : (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: Block or block variation name. */ 63318 (0,external_wp_i18n_namespaceObject.__)('Transform to %s'), variation.title) 63319 }, variation.name)) 63320 }) 63321 }); 63322 } 63323 function __experimentalBlockVariationTransforms({ 63324 blockClientId 63325 }) { 63326 const { 63327 updateBlockAttributes 63328 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 63329 const { 63330 activeBlockVariation, 63331 variations, 63332 isContentOnly 63333 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 63334 const { 63335 getActiveBlockVariation, 63336 getBlockVariations 63337 } = select(external_wp_blocks_namespaceObject.store); 63338 const { 63339 getBlockName, 63340 getBlockAttributes, 63341 getBlockEditingMode 63342 } = select(store); 63343 const name = blockClientId && getBlockName(blockClientId); 63344 const { 63345 hasContentRoleAttribute 63346 } = unlock(select(external_wp_blocks_namespaceObject.store)); 63347 const isContentBlock = hasContentRoleAttribute(name); 63348 return { 63349 activeBlockVariation: getActiveBlockVariation(name, getBlockAttributes(blockClientId)), 63350 variations: name && getBlockVariations(name, 'transform'), 63351 isContentOnly: getBlockEditingMode(blockClientId) === 'contentOnly' && !isContentBlock 63352 }; 63353 }, [blockClientId]); 63354 const selectedValue = activeBlockVariation?.name; 63355 63356 // Check if each variation has a unique icon. 63357 const hasUniqueIcons = (0,external_wp_element_namespaceObject.useMemo)(() => { 63358 const variationIcons = new Set(); 63359 if (!variations) { 63360 return false; 63361 } 63362 variations.forEach(variation => { 63363 if (variation.icon) { 63364 variationIcons.add(variation.icon?.src || variation.icon); 63365 } 63366 }); 63367 return variationIcons.size === variations.length; 63368 }, [variations]); 63369 const onSelectVariation = variationName => { 63370 updateBlockAttributes(blockClientId, { 63371 ...variations.find(({ 63372 name 63373 }) => name === variationName).attributes 63374 }); 63375 }; 63376 if (!variations?.length || isContentOnly) { 63377 return null; 63378 } 63379 const baseClass = 'block-editor-block-variation-transforms'; 63380 63381 // Show buttons if there are more than 5 variations because the ToggleGroupControl does not wrap 63382 const showButtons = variations.length > 5; 63383 const ButtonComponent = showButtons ? VariationsButtons : VariationsToggleGroupControl; 63384 const Component = hasUniqueIcons ? ButtonComponent : VariationsDropdown; 63385 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, { 63386 className: baseClass, 63387 onSelectVariation: onSelectVariation, 63388 selectedValue: selectedValue, 63389 variations: variations 63390 }); 63391 } 63392 /* harmony default export */ const block_variation_transforms = (__experimentalBlockVariationTransforms); 63393 63394 ;// ./node_modules/@wordpress/block-editor/build-module/components/color-palette/with-color-context.js 63395 /** 63396 * WordPress dependencies 63397 */ 63398 63399 63400 /** 63401 * Internal dependencies 63402 */ 63403 63404 63405 /* harmony default export */ const with_color_context = ((0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent => { 63406 return props => { 63407 const [colorsFeature, enableCustomColors] = use_settings_useSettings('color.palette', 'color.custom'); 63408 const { 63409 colors = colorsFeature, 63410 disableCustomColors = !enableCustomColors 63411 } = props; 63412 const hasColorsToChoose = colors && colors.length > 0 || !disableCustomColors; 63413 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { 63414 ...props, 63415 colors, 63416 disableCustomColors, 63417 hasColorsToChoose 63418 }); 63419 }; 63420 }, 'withColorContext')); 63421 63422 ;// ./node_modules/@wordpress/block-editor/build-module/components/color-palette/index.js 63423 /** 63424 * WordPress dependencies 63425 */ 63426 63427 63428 /** 63429 * Internal dependencies 63430 */ 63431 63432 /* harmony default export */ const color_palette = (with_color_context(external_wp_components_namespaceObject.ColorPalette)); 63433 63434 ;// ./node_modules/@wordpress/block-editor/build-module/components/color-palette/control.js 63435 /** 63436 * Internal dependencies 63437 */ 63438 63439 63440 function ColorPaletteControl({ 63441 onChange, 63442 value, 63443 ...otherProps 63444 }) { 63445 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(control, { 63446 ...otherProps, 63447 onColorChange: onChange, 63448 colorValue: value, 63449 gradients: [], 63450 disableCustomGradients: true 63451 }); 63452 } 63453 63454 ;// external ["wp","date"] 63455 const external_wp_date_namespaceObject = window["wp"]["date"]; 63456 ;// ./node_modules/@wordpress/block-editor/build-module/components/date-format-picker/index.js 63457 /** 63458 * WordPress dependencies 63459 */ 63460 63461 63462 63463 63464 63465 // So that we illustrate the different formats in the dropdown properly, show a date that is 63466 // somwhat recent, has a day greater than 12, and a month with more than three letters. 63467 63468 63469 const exampleDate = new Date(); 63470 exampleDate.setDate(20); 63471 exampleDate.setMonth(exampleDate.getMonth() - 3); 63472 if (exampleDate.getMonth() === 4) { 63473 // May has three letters, so use March. 63474 exampleDate.setMonth(3); 63475 } 63476 63477 /** 63478 * The `DateFormatPicker` component renders controls that let the user choose a 63479 * _date format_. That is, how they want their dates to be formatted. 63480 * 63481 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/date-format-picker/README.md 63482 * 63483 * @param {Object} props 63484 * @param {string|null} props.format The selected date 63485 * format. If 63486 * `null`, 63487 * _Default_ is 63488 * selected. 63489 * @param {string} props.defaultFormat The date format that 63490 * will be used if the 63491 * user selects 63492 * 'Default'. 63493 * @param {( format: string|null ) => void} props.onChange Called when a 63494 * selection is 63495 * made. If `null`, 63496 * _Default_ is 63497 * selected. 63498 */ 63499 function DateFormatPicker({ 63500 format, 63501 defaultFormat, 63502 onChange 63503 }) { 63504 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", { 63505 className: "block-editor-date-format-picker", 63506 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 63507 as: "legend", 63508 children: (0,external_wp_i18n_namespaceObject.__)('Date format') 63509 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, { 63510 __nextHasNoMarginBottom: true, 63511 label: (0,external_wp_i18n_namespaceObject.__)('Default format'), 63512 help: `${(0,external_wp_i18n_namespaceObject.__)('Example:')} ${(0,external_wp_date_namespaceObject.dateI18n)(defaultFormat, exampleDate)}`, 63513 checked: !format, 63514 onChange: checked => onChange(checked ? null : defaultFormat) 63515 }), format && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(NonDefaultControls, { 63516 format: format, 63517 onChange: onChange 63518 })] 63519 }); 63520 } 63521 function NonDefaultControls({ 63522 format, 63523 onChange 63524 }) { 63525 var _suggestedOptions$fin; 63526 // Suggest a short format, medium format, long format, and a standardised 63527 // (YYYY-MM-DD) format. The short, medium, and long formats are localised as 63528 // different languages have different ways of writing these. For example, 'F 63529 // j, Y' (April 20, 2022) in American English (en_US) is 'j. F Y' (20. April 63530 // 2022) in German (de). The resultant array is de-duplicated as some 63531 // languages will use the same format string for short, medium, and long 63532 // formats. 63533 const suggestedFormats = [...new Set([/* translators: See https://www.php.net/manual/datetime.format.php */ 63534 'Y-m-d', /* translators: See https://www.php.net/manual/datetime.format.php */ 63535 (0,external_wp_i18n_namespaceObject._x)('n/j/Y', 'short date format'), /* translators: See https://www.php.net/manual/datetime.format.php */ 63536 (0,external_wp_i18n_namespaceObject._x)('n/j/Y g:i A', 'short date format with time'), /* translators: See https://www.php.net/manual/datetime.format.php */ 63537 (0,external_wp_i18n_namespaceObject._x)('M j, Y', 'medium date format'), /* translators: See https://www.php.net/manual/datetime.format.php */ 63538 (0,external_wp_i18n_namespaceObject._x)('M j, Y g:i A', 'medium date format with time'), /* translators: See https://www.php.net/manual/datetime.format.php */ 63539 (0,external_wp_i18n_namespaceObject._x)('F j, Y', 'long date format'), /* translators: See https://www.php.net/manual/datetime.format.php */ 63540 (0,external_wp_i18n_namespaceObject._x)('M j', 'short date format without the year')])]; 63541 const suggestedOptions = [...suggestedFormats.map((suggestedFormat, index) => ({ 63542 key: `suggested-$index}`, 63543 name: (0,external_wp_date_namespaceObject.dateI18n)(suggestedFormat, exampleDate), 63544 format: suggestedFormat 63545 })), { 63546 key: 'human-diff', 63547 name: (0,external_wp_date_namespaceObject.humanTimeDiff)(exampleDate), 63548 format: 'human-diff' 63549 }]; 63550 const customOption = { 63551 key: 'custom', 63552 name: (0,external_wp_i18n_namespaceObject.__)('Custom'), 63553 className: 'block-editor-date-format-picker__custom-format-select-control__custom-option', 63554 hint: (0,external_wp_i18n_namespaceObject.__)('Enter your own date format') 63555 }; 63556 const [isCustom, setIsCustom] = (0,external_wp_element_namespaceObject.useState)(() => !!format && !suggestedOptions.some(option => option.format === format)); 63557 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 63558 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, { 63559 __next40pxDefaultSize: true, 63560 label: (0,external_wp_i18n_namespaceObject.__)('Choose a format'), 63561 options: [...suggestedOptions, customOption], 63562 value: isCustom ? customOption : (_suggestedOptions$fin = suggestedOptions.find(option => option.format === format)) !== null && _suggestedOptions$fin !== void 0 ? _suggestedOptions$fin : customOption, 63563 onChange: ({ 63564 selectedItem 63565 }) => { 63566 if (selectedItem === customOption) { 63567 setIsCustom(true); 63568 } else { 63569 setIsCustom(false); 63570 onChange(selectedItem.format); 63571 } 63572 } 63573 }), isCustom && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, { 63574 __next40pxDefaultSize: true, 63575 __nextHasNoMarginBottom: true, 63576 label: (0,external_wp_i18n_namespaceObject.__)('Custom format'), 63577 hideLabelFromVision: true, 63578 help: (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)('Enter a date or time <Link>format string</Link>.'), { 63579 Link: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, { 63580 href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/documentation/article/customize-date-and-time-format/') 63581 }) 63582 }), 63583 value: format, 63584 onChange: value => onChange(value) 63585 })] 63586 }); 63587 } 63588 63589 ;// ./node_modules/@wordpress/block-editor/build-module/components/colors-gradients/dropdown.js 63590 /** 63591 * External dependencies 63592 */ 63593 63594 63595 /** 63596 * WordPress dependencies 63597 */ 63598 63599 63600 /** 63601 * Internal dependencies 63602 */ 63603 63604 63605 // When the `ColorGradientSettingsDropdown` controls are being rendered to a 63606 // `ToolsPanel` they must be wrapped in a `ToolsPanelItem`. 63607 63608 63609 63610 const WithToolsPanelItem = ({ 63611 setting, 63612 children, 63613 panelId, 63614 ...props 63615 }) => { 63616 const clearValue = () => { 63617 if (setting.colorValue) { 63618 setting.onColorChange(); 63619 } else if (setting.gradientValue) { 63620 setting.onGradientChange(); 63621 } 63622 }; 63623 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 63624 hasValue: () => { 63625 return !!setting.colorValue || !!setting.gradientValue; 63626 }, 63627 label: setting.label, 63628 onDeselect: clearValue, 63629 isShownByDefault: setting.isShownByDefault !== undefined ? setting.isShownByDefault : true, 63630 ...props, 63631 className: "block-editor-tools-panel-color-gradient-settings__item", 63632 panelId: panelId 63633 // Pass resetAllFilter if supplied due to rendering via SlotFill 63634 // into parent ToolsPanel. 63635 , 63636 resetAllFilter: setting.resetAllFilter, 63637 children: children 63638 }); 63639 }; 63640 const dropdown_LabeledColorIndicator = ({ 63641 colorValue, 63642 label 63643 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 63644 justify: "flex-start", 63645 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorIndicator, { 63646 className: "block-editor-panel-color-gradient-settings__color-indicator", 63647 colorValue: colorValue 63648 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 63649 className: "block-editor-panel-color-gradient-settings__color-name", 63650 title: label, 63651 children: label 63652 })] 63653 }); 63654 63655 // Renders a color dropdown's toggle as an `Item` if it is within an `ItemGroup` 63656 // or as a `Button` if it isn't e.g. the controls are being rendered in 63657 // a `ToolsPanel`. 63658 const renderToggle = settings => ({ 63659 onToggle, 63660 isOpen 63661 }) => { 63662 const { 63663 colorValue, 63664 label 63665 } = settings; 63666 const toggleProps = { 63667 onClick: onToggle, 63668 className: dist_clsx('block-editor-panel-color-gradient-settings__dropdown', { 63669 'is-open': isOpen 63670 }), 63671 'aria-expanded': isOpen 63672 }; 63673 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 63674 __next40pxDefaultSize: true, 63675 ...toggleProps, 63676 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_LabeledColorIndicator, { 63677 colorValue: colorValue, 63678 label: label 63679 }) 63680 }); 63681 }; 63682 63683 // Renders a collection of color controls as dropdowns. Depending upon the 63684 // context in which these dropdowns are being rendered, they may be wrapped 63685 // in an `ItemGroup` with each dropdown's toggle as an `Item`, or alternatively, 63686 // the may be individually wrapped in a `ToolsPanelItem` with the toggle as 63687 // a regular `Button`. 63688 // 63689 // For more context see: https://github.com/WordPress/gutenberg/pull/40084 63690 function ColorGradientSettingsDropdown({ 63691 colors, 63692 disableCustomColors, 63693 disableCustomGradients, 63694 enableAlpha, 63695 gradients, 63696 settings, 63697 __experimentalIsRenderedInSidebar, 63698 ...props 63699 }) { 63700 let popoverProps; 63701 if (__experimentalIsRenderedInSidebar) { 63702 popoverProps = { 63703 placement: 'left-start', 63704 offset: 36, 63705 shift: true 63706 }; 63707 } 63708 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 63709 children: settings.map((setting, index) => { 63710 var _setting$gradientValu; 63711 const controlProps = { 63712 clearable: false, 63713 colorValue: setting.colorValue, 63714 colors, 63715 disableCustomColors, 63716 disableCustomGradients, 63717 enableAlpha, 63718 gradientValue: setting.gradientValue, 63719 gradients, 63720 label: setting.label, 63721 onColorChange: setting.onColorChange, 63722 onGradientChange: setting.onGradientChange, 63723 showTitle: false, 63724 __experimentalIsRenderedInSidebar, 63725 ...setting 63726 }; 63727 const toggleSettings = { 63728 colorValue: (_setting$gradientValu = setting.gradientValue) !== null && _setting$gradientValu !== void 0 ? _setting$gradientValu : setting.colorValue, 63729 label: setting.label 63730 }; 63731 return setting && 63732 /*#__PURE__*/ 63733 // If not in an `ItemGroup` wrap the dropdown in a 63734 // `ToolsPanelItem` 63735 (0,external_ReactJSXRuntime_namespaceObject.jsx)(WithToolsPanelItem, { 63736 setting: setting, 63737 ...props, 63738 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 63739 popoverProps: popoverProps, 63740 className: "block-editor-tools-panel-color-gradient-settings__dropdown", 63741 renderToggle: renderToggle(toggleSettings), 63742 renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, { 63743 paddingSize: "none", 63744 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 63745 className: "block-editor-panel-color-gradient-settings__dropdown-content", 63746 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(control, { 63747 ...controlProps 63748 }) 63749 }) 63750 }) 63751 }) 63752 }, index); 63753 }) 63754 }); 63755 } 63756 63757 ;// ./node_modules/@wordpress/block-editor/build-module/components/colors-gradients/panel-color-gradient-settings.js 63758 /** 63759 * External dependencies 63760 */ 63761 63762 63763 /** 63764 * WordPress dependencies 63765 */ 63766 63767 63768 63769 63770 /** 63771 * Internal dependencies 63772 */ 63773 63774 63775 63776 63777 63778 const panel_color_gradient_settings_colorsAndGradientKeys = ['colors', 'disableCustomColors', 'gradients', 'disableCustomGradients']; 63779 const PanelColorGradientSettingsInner = ({ 63780 className, 63781 colors, 63782 gradients, 63783 disableCustomColors, 63784 disableCustomGradients, 63785 children, 63786 settings, 63787 title, 63788 showTitle = true, 63789 __experimentalIsRenderedInSidebar, 63790 enableAlpha 63791 }) => { 63792 const panelId = (0,external_wp_compose_namespaceObject.useInstanceId)(PanelColorGradientSettingsInner); 63793 const { 63794 batch 63795 } = (0,external_wp_data_namespaceObject.useRegistry)(); 63796 if ((!colors || colors.length === 0) && (!gradients || gradients.length === 0) && disableCustomColors && disableCustomGradients && settings?.every(setting => (!setting.colors || setting.colors.length === 0) && (!setting.gradients || setting.gradients.length === 0) && (setting.disableCustomColors === undefined || setting.disableCustomColors) && (setting.disableCustomGradients === undefined || setting.disableCustomGradients))) { 63797 return null; 63798 } 63799 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanel, { 63800 className: dist_clsx('block-editor-panel-color-gradient-settings', className), 63801 label: showTitle ? title : undefined, 63802 resetAll: () => { 63803 batch(() => { 63804 settings.forEach(({ 63805 colorValue, 63806 gradientValue, 63807 onColorChange, 63808 onGradientChange 63809 }) => { 63810 if (colorValue) { 63811 onColorChange(); 63812 } else if (gradientValue) { 63813 onGradientChange(); 63814 } 63815 }); 63816 }); 63817 }, 63818 panelId: panelId, 63819 __experimentalFirstVisibleItemClass: "first", 63820 __experimentalLastVisibleItemClass: "last", 63821 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorGradientSettingsDropdown, { 63822 settings: settings, 63823 panelId: panelId, 63824 colors, 63825 gradients, 63826 disableCustomColors, 63827 disableCustomGradients, 63828 __experimentalIsRenderedInSidebar, 63829 enableAlpha 63830 }), !!children && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 63831 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, { 63832 marginY: 4 63833 }), " ", children] 63834 })] 63835 }); 63836 }; 63837 const PanelColorGradientSettingsSelect = props => { 63838 const colorGradientSettings = useMultipleOriginColorsAndGradients(); 63839 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PanelColorGradientSettingsInner, { 63840 ...colorGradientSettings, 63841 ...props 63842 }); 63843 }; 63844 const PanelColorGradientSettings = props => { 63845 if (panel_color_gradient_settings_colorsAndGradientKeys.every(key => props.hasOwnProperty(key))) { 63846 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PanelColorGradientSettingsInner, { 63847 ...props 63848 }); 63849 } 63850 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PanelColorGradientSettingsSelect, { 63851 ...props 63852 }); 63853 }; 63854 /* harmony default export */ const panel_color_gradient_settings = (PanelColorGradientSettings); 63855 63856 ;// ./node_modules/@wordpress/icons/build-module/library/aspect-ratio.js 63857 /** 63858 * WordPress dependencies 63859 */ 63860 63861 63862 const aspectRatio = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 63863 xmlns: "http://www.w3.org/2000/svg", 63864 viewBox: "0 0 24 24", 63865 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 63866 d: "M18.5 5.5h-13c-1.1 0-2 .9-2 2v9c0 1.1.9 2 2 2h13c1.1 0 2-.9 2-2v-9c0-1.1-.9-2-2-2zm.5 11c0 .3-.2.5-.5.5h-13c-.3 0-.5-.2-.5-.5v-9c0-.3.2-.5.5-.5h13c.3 0 .5.2.5.5v9zM6.5 12H8v-2h2V8.5H6.5V12zm9.5 2h-2v1.5h3.5V12H16v2z" 63867 }) 63868 }); 63869 /* harmony default export */ const aspect_ratio = (aspectRatio); 63870 63871 ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/constants.js 63872 const MIN_ZOOM = 100; 63873 const MAX_ZOOM = 300; 63874 const constants_POPOVER_PROPS = { 63875 placement: 'bottom-start' 63876 }; 63877 63878 ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/use-save-image.js 63879 /** 63880 * WordPress dependencies 63881 */ 63882 // Disable Reason: Needs to be refactored. 63883 // eslint-disable-next-line no-restricted-imports 63884 63885 63886 63887 63888 63889 63890 function useSaveImage({ 63891 crop, 63892 rotation, 63893 url, 63894 id, 63895 onSaveImage, 63896 onFinishEditing 63897 }) { 63898 const { 63899 createErrorNotice 63900 } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store); 63901 const [isInProgress, setIsInProgress] = (0,external_wp_element_namespaceObject.useState)(false); 63902 const cancel = (0,external_wp_element_namespaceObject.useCallback)(() => { 63903 setIsInProgress(false); 63904 onFinishEditing(); 63905 }, [onFinishEditing]); 63906 const apply = (0,external_wp_element_namespaceObject.useCallback)(() => { 63907 setIsInProgress(true); 63908 const modifiers = []; 63909 if (rotation > 0) { 63910 modifiers.push({ 63911 type: 'rotate', 63912 args: { 63913 angle: rotation 63914 } 63915 }); 63916 } 63917 63918 // The crop script may return some very small, sub-pixel values when the image was not cropped. 63919 // Crop only when the new size has changed by more than 0.1%. 63920 if (crop.width < 99.9 || crop.height < 99.9) { 63921 modifiers.push({ 63922 type: 'crop', 63923 args: { 63924 left: crop.x, 63925 top: crop.y, 63926 width: crop.width, 63927 height: crop.height 63928 } 63929 }); 63930 } 63931 if (modifiers.length === 0) { 63932 // No changes to apply. 63933 setIsInProgress(false); 63934 onFinishEditing(); 63935 return; 63936 } 63937 external_wp_apiFetch_default()({ 63938 path: `/wp/v2/media/$id}/edit`, 63939 method: 'POST', 63940 data: { 63941 src: url, 63942 modifiers 63943 } 63944 }).then(response => { 63945 onSaveImage({ 63946 id: response.id, 63947 url: response.source_url 63948 }); 63949 }).catch(error => { 63950 createErrorNotice((0,external_wp_i18n_namespaceObject.sprintf)( /* translators: 1. Error message */ 63951 (0,external_wp_i18n_namespaceObject.__)('Could not edit image. %s'), (0,external_wp_dom_namespaceObject.__unstableStripHTML)(error.message)), { 63952 id: 'image-editing-error', 63953 type: 'snackbar' 63954 }); 63955 }).finally(() => { 63956 setIsInProgress(false); 63957 onFinishEditing(); 63958 }); 63959 }, [crop, rotation, id, url, onSaveImage, createErrorNotice, onFinishEditing]); 63960 return (0,external_wp_element_namespaceObject.useMemo)(() => ({ 63961 isInProgress, 63962 apply, 63963 cancel 63964 }), [isInProgress, apply, cancel]); 63965 } 63966 63967 ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/use-transform-image.js 63968 /* wp:polyfill */ 63969 /** 63970 * WordPress dependencies 63971 */ 63972 63973 63974 function useTransformImage({ 63975 url, 63976 naturalWidth, 63977 naturalHeight 63978 }) { 63979 const [editedUrl, setEditedUrl] = (0,external_wp_element_namespaceObject.useState)(); 63980 const [crop, setCrop] = (0,external_wp_element_namespaceObject.useState)(); 63981 const [position, setPosition] = (0,external_wp_element_namespaceObject.useState)({ 63982 x: 0, 63983 y: 0 63984 }); 63985 const [zoom, setZoom] = (0,external_wp_element_namespaceObject.useState)(100); 63986 const [rotation, setRotation] = (0,external_wp_element_namespaceObject.useState)(0); 63987 const defaultAspect = naturalWidth / naturalHeight; 63988 const [aspect, setAspect] = (0,external_wp_element_namespaceObject.useState)(defaultAspect); 63989 const rotateClockwise = (0,external_wp_element_namespaceObject.useCallback)(() => { 63990 const angle = (rotation + 90) % 360; 63991 let naturalAspectRatio = defaultAspect; 63992 if (rotation % 180 === 90) { 63993 naturalAspectRatio = 1 / defaultAspect; 63994 } 63995 if (angle === 0) { 63996 setEditedUrl(); 63997 setRotation(angle); 63998 setAspect(defaultAspect); 63999 setPosition(prevPosition => ({ 64000 x: -(prevPosition.y * naturalAspectRatio), 64001 y: prevPosition.x * naturalAspectRatio 64002 })); 64003 return; 64004 } 64005 function editImage(event) { 64006 const canvas = document.createElement('canvas'); 64007 let translateX = 0; 64008 let translateY = 0; 64009 if (angle % 180) { 64010 canvas.width = event.target.height; 64011 canvas.height = event.target.width; 64012 } else { 64013 canvas.width = event.target.width; 64014 canvas.height = event.target.height; 64015 } 64016 if (angle === 90 || angle === 180) { 64017 translateX = canvas.width; 64018 } 64019 if (angle === 270 || angle === 180) { 64020 translateY = canvas.height; 64021 } 64022 const context = canvas.getContext('2d'); 64023 context.translate(translateX, translateY); 64024 context.rotate(angle * Math.PI / 180); 64025 context.drawImage(event.target, 0, 0); 64026 canvas.toBlob(blob => { 64027 setEditedUrl(URL.createObjectURL(blob)); 64028 setRotation(angle); 64029 setAspect(canvas.width / canvas.height); 64030 setPosition(prevPosition => ({ 64031 x: -(prevPosition.y * naturalAspectRatio), 64032 y: prevPosition.x * naturalAspectRatio 64033 })); 64034 }); 64035 } 64036 const el = new window.Image(); 64037 el.src = url; 64038 el.onload = editImage; 64039 const imgCrossOrigin = (0,external_wp_hooks_namespaceObject.applyFilters)('media.crossOrigin', undefined, url); 64040 if (typeof imgCrossOrigin === 'string') { 64041 el.crossOrigin = imgCrossOrigin; 64042 } 64043 }, [rotation, defaultAspect, url]); 64044 return (0,external_wp_element_namespaceObject.useMemo)(() => ({ 64045 editedUrl, 64046 setEditedUrl, 64047 crop, 64048 setCrop, 64049 position, 64050 setPosition, 64051 zoom, 64052 setZoom, 64053 rotation, 64054 setRotation, 64055 rotateClockwise, 64056 aspect, 64057 setAspect, 64058 defaultAspect 64059 }), [editedUrl, crop, position, zoom, rotation, rotateClockwise, aspect, defaultAspect]); 64060 } 64061 64062 ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/context.js 64063 /** 64064 * WordPress dependencies 64065 */ 64066 64067 64068 /** 64069 * Internal dependencies 64070 */ 64071 64072 64073 64074 const ImageEditingContext = (0,external_wp_element_namespaceObject.createContext)({}); 64075 const useImageEditingContext = () => (0,external_wp_element_namespaceObject.useContext)(ImageEditingContext); 64076 function ImageEditingProvider({ 64077 id, 64078 url, 64079 naturalWidth, 64080 naturalHeight, 64081 onFinishEditing, 64082 onSaveImage, 64083 children 64084 }) { 64085 const transformImage = useTransformImage({ 64086 url, 64087 naturalWidth, 64088 naturalHeight 64089 }); 64090 const saveImage = useSaveImage({ 64091 id, 64092 url, 64093 onSaveImage, 64094 onFinishEditing, 64095 ...transformImage 64096 }); 64097 const providerValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({ 64098 ...transformImage, 64099 ...saveImage 64100 }), [transformImage, saveImage]); 64101 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ImageEditingContext.Provider, { 64102 value: providerValue, 64103 children: children 64104 }); 64105 } 64106 64107 ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/aspect-ratio-dropdown.js 64108 /** 64109 * WordPress dependencies 64110 */ 64111 64112 64113 64114 64115 /** 64116 * Internal dependencies 64117 */ 64118 64119 64120 64121 64122 64123 64124 function AspectRatioGroup({ 64125 aspectRatios, 64126 isDisabled, 64127 label, 64128 onClick, 64129 value 64130 }) { 64131 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, { 64132 label: label, 64133 children: aspectRatios.map(({ 64134 name, 64135 slug, 64136 ratio 64137 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 64138 disabled: isDisabled, 64139 onClick: () => { 64140 onClick(ratio); 64141 }, 64142 role: "menuitemradio", 64143 isSelected: ratio === value, 64144 icon: ratio === value ? library_check : undefined, 64145 children: name 64146 }, slug)) 64147 }); 64148 } 64149 function ratioToNumber(str) { 64150 // TODO: support two-value aspect ratio? 64151 // https://css-tricks.com/almanac/properties/a/aspect-ratio/#aa-it-can-take-two-values 64152 const [a, b, ...rest] = str.split('/').map(Number); 64153 if (a <= 0 || b <= 0 || Number.isNaN(a) || Number.isNaN(b) || rest.length) { 64154 return NaN; 64155 } 64156 return b ? a / b : a; 64157 } 64158 function presetRatioAsNumber({ 64159 ratio, 64160 ...rest 64161 }) { 64162 return { 64163 ratio: ratioToNumber(ratio), 64164 ...rest 64165 }; 64166 } 64167 function AspectRatioDropdown({ 64168 toggleProps 64169 }) { 64170 const { 64171 isInProgress, 64172 aspect, 64173 setAspect, 64174 defaultAspect 64175 } = useImageEditingContext(); 64176 const [defaultRatios, themeRatios, showDefaultRatios] = use_settings_useSettings('dimensions.aspectRatios.default', 'dimensions.aspectRatios.theme', 'dimensions.defaultAspectRatios'); 64177 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, { 64178 icon: aspect_ratio, 64179 label: (0,external_wp_i18n_namespaceObject.__)('Aspect Ratio'), 64180 popoverProps: constants_POPOVER_PROPS, 64181 toggleProps: toggleProps, 64182 children: ({ 64183 onClose 64184 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 64185 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioGroup, { 64186 isDisabled: isInProgress, 64187 onClick: newAspect => { 64188 setAspect(newAspect); 64189 onClose(); 64190 }, 64191 value: aspect, 64192 aspectRatios: [ 64193 // All ratios should be mirrored in AspectRatioTool in @wordpress/block-editor. 64194 { 64195 slug: 'original', 64196 name: (0,external_wp_i18n_namespaceObject.__)('Original'), 64197 aspect: defaultAspect 64198 }, ...(showDefaultRatios ? defaultRatios.map(presetRatioAsNumber).filter(({ 64199 ratio 64200 }) => ratio === 1) : [])] 64201 }), themeRatios?.length > 0 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioGroup, { 64202 label: (0,external_wp_i18n_namespaceObject.__)('Theme'), 64203 isDisabled: isInProgress, 64204 onClick: newAspect => { 64205 setAspect(newAspect); 64206 onClose(); 64207 }, 64208 value: aspect, 64209 aspectRatios: themeRatios 64210 }), showDefaultRatios && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioGroup, { 64211 label: (0,external_wp_i18n_namespaceObject.__)('Landscape'), 64212 isDisabled: isInProgress, 64213 onClick: newAspect => { 64214 setAspect(newAspect); 64215 onClose(); 64216 }, 64217 value: aspect, 64218 aspectRatios: defaultRatios.map(presetRatioAsNumber).filter(({ 64219 ratio 64220 }) => ratio > 1) 64221 }), showDefaultRatios && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioGroup, { 64222 label: (0,external_wp_i18n_namespaceObject.__)('Portrait'), 64223 isDisabled: isInProgress, 64224 onClick: newAspect => { 64225 setAspect(newAspect); 64226 onClose(); 64227 }, 64228 value: aspect, 64229 aspectRatios: defaultRatios.map(presetRatioAsNumber).filter(({ 64230 ratio 64231 }) => ratio < 1) 64232 })] 64233 }) 64234 }); 64235 } 64236 64237 ;// ./node_modules/tslib/tslib.es6.mjs 64238 /****************************************************************************** 64239 Copyright (c) Microsoft Corporation. 64240 64241 Permission to use, copy, modify, and/or distribute this software for any 64242 purpose with or without fee is hereby granted. 64243 64244 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH 64245 REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 64246 AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, 64247 INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 64248 LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 64249 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 64250 PERFORMANCE OF THIS SOFTWARE. 64251 ***************************************************************************** */ 64252 /* global Reflect, Promise, SuppressedError, Symbol, Iterator */ 64253 64254 var extendStatics = function(d, b) { 64255 extendStatics = Object.setPrototypeOf || 64256 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 64257 function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; 64258 return extendStatics(d, b); 64259 }; 64260 64261 function __extends(d, b) { 64262 if (typeof b !== "function" && b !== null) 64263 throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); 64264 extendStatics(d, b); 64265 function __() { this.constructor = d; } 64266 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 64267 } 64268 64269 var __assign = function() { 64270 __assign = Object.assign || function __assign(t) { 64271 for (var s, i = 1, n = arguments.length; i < n; i++) { 64272 s = arguments[i]; 64273 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; 64274 } 64275 return t; 64276 } 64277 return __assign.apply(this, arguments); 64278 } 64279 64280 function __rest(s, e) { 64281 var t = {}; 64282 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) 64283 t[p] = s[p]; 64284 if (s != null && typeof Object.getOwnPropertySymbols === "function") 64285 for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { 64286 if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) 64287 t[p[i]] = s[p[i]]; 64288 } 64289 return t; 64290 } 64291 64292 function __decorate(decorators, target, key, desc) { 64293 var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; 64294 if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); 64295 else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; 64296 return c > 3 && r && Object.defineProperty(target, key, r), r; 64297 } 64298 64299 function __param(paramIndex, decorator) { 64300 return function (target, key) { decorator(target, key, paramIndex); } 64301 } 64302 64303 function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) { 64304 function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; } 64305 var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value"; 64306 var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null; 64307 var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {}); 64308 var _, done = false; 64309 for (var i = decorators.length - 1; i >= 0; i--) { 64310 var context = {}; 64311 for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p]; 64312 for (var p in contextIn.access) context.access[p] = contextIn.access[p]; 64313 context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); }; 64314 var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context); 64315 if (kind === "accessor") { 64316 if (result === void 0) continue; 64317 if (result === null || typeof result !== "object") throw new TypeError("Object expected"); 64318 if (_ = accept(result.get)) descriptor.get = _; 64319 if (_ = accept(result.set)) descriptor.set = _; 64320 if (_ = accept(result.init)) initializers.unshift(_); 64321 } 64322 else if (_ = accept(result)) { 64323 if (kind === "field") initializers.unshift(_); 64324 else descriptor[key] = _; 64325 } 64326 } 64327 if (target) Object.defineProperty(target, contextIn.name, descriptor); 64328 done = true; 64329 }; 64330 64331 function __runInitializers(thisArg, initializers, value) { 64332 var useValue = arguments.length > 2; 64333 for (var i = 0; i < initializers.length; i++) { 64334 value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg); 64335 } 64336 return useValue ? value : void 0; 64337 }; 64338 64339 function __propKey(x) { 64340 return typeof x === "symbol" ? x : "".concat(x); 64341 }; 64342 64343 function __setFunctionName(f, name, prefix) { 64344 if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : ""; 64345 return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); 64346 }; 64347 64348 function __metadata(metadataKey, metadataValue) { 64349 if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue); 64350 } 64351 64352 function __awaiter(thisArg, _arguments, P, generator) { 64353 function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } 64354 return new (P || (P = Promise))(function (resolve, reject) { 64355 function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } 64356 function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } 64357 function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } 64358 step((generator = generator.apply(thisArg, _arguments || [])).next()); 64359 }); 64360 } 64361 64362 function __generator(thisArg, body) { 64363 var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype); 64364 return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; 64365 function verb(n) { return function (v) { return step([n, v]); }; } 64366 function step(op) { 64367 if (f) throw new TypeError("Generator is already executing."); 64368 while (g && (g = 0, op[0] && (_ = 0)), _) try { 64369 if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; 64370 if (y = 0, t) op = [op[0] & 2, t.value]; 64371 switch (op[0]) { 64372 case 0: case 1: t = op; break; 64373 case 4: _.label++; return { value: op[1], done: false }; 64374 case 5: _.label++; y = op[1]; op = [0]; continue; 64375 case 7: op = _.ops.pop(); _.trys.pop(); continue; 64376 default: 64377 if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } 64378 if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } 64379 if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } 64380 if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } 64381 if (t[2]) _.ops.pop(); 64382 _.trys.pop(); continue; 64383 } 64384 op = body.call(thisArg, _); 64385 } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } 64386 if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; 64387 } 64388 } 64389 64390 var __createBinding = Object.create ? (function(o, m, k, k2) { 64391 if (k2 === undefined) k2 = k; 64392 var desc = Object.getOwnPropertyDescriptor(m, k); 64393 if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { 64394 desc = { enumerable: true, get: function() { return m[k]; } }; 64395 } 64396 Object.defineProperty(o, k2, desc); 64397 }) : (function(o, m, k, k2) { 64398 if (k2 === undefined) k2 = k; 64399 o[k2] = m[k]; 64400 }); 64401 64402 function __exportStar(m, o) { 64403 for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p); 64404 } 64405 64406 function __values(o) { 64407 var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; 64408 if (m) return m.call(o); 64409 if (o && typeof o.length === "number") return { 64410 next: function () { 64411 if (o && i >= o.length) o = void 0; 64412 return { value: o && o[i++], done: !o }; 64413 } 64414 }; 64415 throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); 64416 } 64417 64418 function __read(o, n) { 64419 var m = typeof Symbol === "function" && o[Symbol.iterator]; 64420 if (!m) return o; 64421 var i = m.call(o), r, ar = [], e; 64422 try { 64423 while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); 64424 } 64425 catch (error) { e = { error: error }; } 64426 finally { 64427 try { 64428 if (r && !r.done && (m = i["return"])) m.call(i); 64429 } 64430 finally { if (e) throw e.error; } 64431 } 64432 return ar; 64433 } 64434 64435 /** @deprecated */ 64436 function __spread() { 64437 for (var ar = [], i = 0; i < arguments.length; i++) 64438 ar = ar.concat(__read(arguments[i])); 64439 return ar; 64440 } 64441 64442 /** @deprecated */ 64443 function __spreadArrays() { 64444 for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 64445 for (var r = Array(s), k = 0, i = 0; i < il; i++) 64446 for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 64447 r[k] = a[j]; 64448 return r; 64449 } 64450 64451 function __spreadArray(to, from, pack) { 64452 if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { 64453 if (ar || !(i in from)) { 64454 if (!ar) ar = Array.prototype.slice.call(from, 0, i); 64455 ar[i] = from[i]; 64456 } 64457 } 64458 return to.concat(ar || Array.prototype.slice.call(from)); 64459 } 64460 64461 function __await(v) { 64462 return this instanceof __await ? (this.v = v, this) : new __await(v); 64463 } 64464 64465 function __asyncGenerator(thisArg, _arguments, generator) { 64466 if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); 64467 var g = generator.apply(thisArg, _arguments || []), i, q = []; 64468 return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i; 64469 function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; } 64470 function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } } 64471 function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } 64472 function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } 64473 function fulfill(value) { resume("next", value); } 64474 function reject(value) { resume("throw", value); } 64475 function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } 64476 } 64477 64478 function __asyncDelegator(o) { 64479 var i, p; 64480 return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; 64481 function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; } 64482 } 64483 64484 function __asyncValues(o) { 64485 if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); 64486 var m = o[Symbol.asyncIterator], i; 64487 return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); 64488 function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } 64489 function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } 64490 } 64491 64492 function __makeTemplateObject(cooked, raw) { 64493 if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } 64494 return cooked; 64495 }; 64496 64497 var __setModuleDefault = Object.create ? (function(o, v) { 64498 Object.defineProperty(o, "default", { enumerable: true, value: v }); 64499 }) : function(o, v) { 64500 o["default"] = v; 64501 }; 64502 64503 function __importStar(mod) { 64504 if (mod && mod.__esModule) return mod; 64505 var result = {}; 64506 if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); 64507 __setModuleDefault(result, mod); 64508 return result; 64509 } 64510 64511 function __importDefault(mod) { 64512 return (mod && mod.__esModule) ? mod : { default: mod }; 64513 } 64514 64515 function __classPrivateFieldGet(receiver, state, kind, f) { 64516 if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); 64517 if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); 64518 return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); 64519 } 64520 64521 function __classPrivateFieldSet(receiver, state, value, kind, f) { 64522 if (kind === "m") throw new TypeError("Private method is not writable"); 64523 if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); 64524 if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); 64525 return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; 64526 } 64527 64528 function __classPrivateFieldIn(state, receiver) { 64529 if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object"); 64530 return typeof state === "function" ? receiver === state : state.has(receiver); 64531 } 64532 64533 function __addDisposableResource(env, value, async) { 64534 if (value !== null && value !== void 0) { 64535 if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected."); 64536 var dispose, inner; 64537 if (async) { 64538 if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined."); 64539 dispose = value[Symbol.asyncDispose]; 64540 } 64541 if (dispose === void 0) { 64542 if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined."); 64543 dispose = value[Symbol.dispose]; 64544 if (async) inner = dispose; 64545 } 64546 if (typeof dispose !== "function") throw new TypeError("Object not disposable."); 64547 if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } }; 64548 env.stack.push({ value: value, dispose: dispose, async: async }); 64549 } 64550 else if (async) { 64551 env.stack.push({ async: true }); 64552 } 64553 return value; 64554 } 64555 64556 var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { 64557 var e = new Error(message); 64558 return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; 64559 }; 64560 64561 function __disposeResources(env) { 64562 function fail(e) { 64563 env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e; 64564 env.hasError = true; 64565 } 64566 var r, s = 0; 64567 function next() { 64568 while (r = env.stack.pop()) { 64569 try { 64570 if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next); 64571 if (r.dispose) { 64572 var result = r.dispose.call(r.value); 64573 if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); }); 64574 } 64575 else s |= 1; 64576 } 64577 catch (e) { 64578 fail(e); 64579 } 64580 } 64581 if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve(); 64582 if (env.hasError) throw env.error; 64583 } 64584 return next(); 64585 } 64586 64587 /* harmony default export */ const tslib_es6 = ({ 64588 __extends, 64589 __assign, 64590 __rest, 64591 __decorate, 64592 __param, 64593 __metadata, 64594 __awaiter, 64595 __generator, 64596 __createBinding, 64597 __exportStar, 64598 __values, 64599 __read, 64600 __spread, 64601 __spreadArrays, 64602 __spreadArray, 64603 __await, 64604 __asyncGenerator, 64605 __asyncDelegator, 64606 __asyncValues, 64607 __makeTemplateObject, 64608 __importStar, 64609 __importDefault, 64610 __classPrivateFieldGet, 64611 __classPrivateFieldSet, 64612 __classPrivateFieldIn, 64613 __addDisposableResource, 64614 __disposeResources, 64615 }); 64616 64617 // EXTERNAL MODULE: ./node_modules/normalize-wheel/index.js 64618 var normalize_wheel = __webpack_require__(7520); 64619 var normalize_wheel_default = /*#__PURE__*/__webpack_require__.n(normalize_wheel); 64620 ;// ./node_modules/react-easy-crop/index.module.js 64621 64622 64623 64624 64625 /** 64626 * Compute the dimension of the crop area based on media size, 64627 * aspect ratio and optionally rotation 64628 */ 64629 function getCropSize(mediaWidth, mediaHeight, containerWidth, containerHeight, aspect, rotation) { 64630 if (rotation === void 0) { 64631 rotation = 0; 64632 } 64633 var _a = rotateSize(mediaWidth, mediaHeight, rotation), 64634 width = _a.width, 64635 height = _a.height; 64636 var fittingWidth = Math.min(width, containerWidth); 64637 var fittingHeight = Math.min(height, containerHeight); 64638 if (fittingWidth > fittingHeight * aspect) { 64639 return { 64640 width: fittingHeight * aspect, 64641 height: fittingHeight 64642 }; 64643 } 64644 return { 64645 width: fittingWidth, 64646 height: fittingWidth / aspect 64647 }; 64648 } 64649 /** 64650 * Compute media zoom. 64651 * We fit the media into the container with "max-width: 100%; max-height: 100%;" 64652 */ 64653 function getMediaZoom(mediaSize) { 64654 // Take the axis with more pixels to improve accuracy 64655 return mediaSize.width > mediaSize.height ? mediaSize.width / mediaSize.naturalWidth : mediaSize.height / mediaSize.naturalHeight; 64656 } 64657 /** 64658 * Ensure a new media position stays in the crop area. 64659 */ 64660 function restrictPosition(position, mediaSize, cropSize, zoom, rotation) { 64661 if (rotation === void 0) { 64662 rotation = 0; 64663 } 64664 var _a = rotateSize(mediaSize.width, mediaSize.height, rotation), 64665 width = _a.width, 64666 height = _a.height; 64667 return { 64668 x: restrictPositionCoord(position.x, width, cropSize.width, zoom), 64669 y: restrictPositionCoord(position.y, height, cropSize.height, zoom) 64670 }; 64671 } 64672 function restrictPositionCoord(position, mediaSize, cropSize, zoom) { 64673 var maxPosition = mediaSize * zoom / 2 - cropSize / 2; 64674 return clamp(position, -maxPosition, maxPosition); 64675 } 64676 function getDistanceBetweenPoints(pointA, pointB) { 64677 return Math.sqrt(Math.pow(pointA.y - pointB.y, 2) + Math.pow(pointA.x - pointB.x, 2)); 64678 } 64679 function getRotationBetweenPoints(pointA, pointB) { 64680 return Math.atan2(pointB.y - pointA.y, pointB.x - pointA.x) * 180 / Math.PI; 64681 } 64682 /** 64683 * Compute the output cropped area of the media in percentages and pixels. 64684 * x/y are the top-left coordinates on the src media 64685 */ 64686 function computeCroppedArea(crop, mediaSize, cropSize, aspect, zoom, rotation, restrictPosition) { 64687 if (rotation === void 0) { 64688 rotation = 0; 64689 } 64690 if (restrictPosition === void 0) { 64691 restrictPosition = true; 64692 } 64693 // if the media is rotated by the user, we cannot limit the position anymore 64694 // as it might need to be negative. 64695 var limitAreaFn = restrictPosition ? limitArea : noOp; 64696 var mediaBBoxSize = rotateSize(mediaSize.width, mediaSize.height, rotation); 64697 var mediaNaturalBBoxSize = rotateSize(mediaSize.naturalWidth, mediaSize.naturalHeight, rotation); 64698 // calculate the crop area in percentages 64699 // in the rotated space 64700 var croppedAreaPercentages = { 64701 x: limitAreaFn(100, ((mediaBBoxSize.width - cropSize.width / zoom) / 2 - crop.x / zoom) / mediaBBoxSize.width * 100), 64702 y: limitAreaFn(100, ((mediaBBoxSize.height - cropSize.height / zoom) / 2 - crop.y / zoom) / mediaBBoxSize.height * 100), 64703 width: limitAreaFn(100, cropSize.width / mediaBBoxSize.width * 100 / zoom), 64704 height: limitAreaFn(100, cropSize.height / mediaBBoxSize.height * 100 / zoom) 64705 }; 64706 // we compute the pixels size naively 64707 var widthInPixels = Math.round(limitAreaFn(mediaNaturalBBoxSize.width, croppedAreaPercentages.width * mediaNaturalBBoxSize.width / 100)); 64708 var heightInPixels = Math.round(limitAreaFn(mediaNaturalBBoxSize.height, croppedAreaPercentages.height * mediaNaturalBBoxSize.height / 100)); 64709 var isImgWiderThanHigh = mediaNaturalBBoxSize.width >= mediaNaturalBBoxSize.height * aspect; 64710 // then we ensure the width and height exactly match the aspect (to avoid rounding approximations) 64711 // if the media is wider than high, when zoom is 0, the crop height will be equals to image height 64712 // thus we want to compute the width from the height and aspect for accuracy. 64713 // Otherwise, we compute the height from width and aspect. 64714 var sizePixels = isImgWiderThanHigh ? { 64715 width: Math.round(heightInPixels * aspect), 64716 height: heightInPixels 64717 } : { 64718 width: widthInPixels, 64719 height: Math.round(widthInPixels / aspect) 64720 }; 64721 var croppedAreaPixels = __assign(__assign({}, sizePixels), { 64722 x: Math.round(limitAreaFn(mediaNaturalBBoxSize.width - sizePixels.width, croppedAreaPercentages.x * mediaNaturalBBoxSize.width / 100)), 64723 y: Math.round(limitAreaFn(mediaNaturalBBoxSize.height - sizePixels.height, croppedAreaPercentages.y * mediaNaturalBBoxSize.height / 100)) 64724 }); 64725 return { 64726 croppedAreaPercentages: croppedAreaPercentages, 64727 croppedAreaPixels: croppedAreaPixels 64728 }; 64729 } 64730 /** 64731 * Ensure the returned value is between 0 and max 64732 */ 64733 function limitArea(max, value) { 64734 return Math.min(max, Math.max(0, value)); 64735 } 64736 function noOp(_max, value) { 64737 return value; 64738 } 64739 /** 64740 * Compute crop and zoom from the croppedAreaPercentages. 64741 */ 64742 function getInitialCropFromCroppedAreaPercentages(croppedAreaPercentages, mediaSize, rotation, cropSize, minZoom, maxZoom) { 64743 var mediaBBoxSize = rotateSize(mediaSize.width, mediaSize.height, rotation); 64744 // This is the inverse process of computeCroppedArea 64745 var zoom = clamp(cropSize.width / mediaBBoxSize.width * (100 / croppedAreaPercentages.width), minZoom, maxZoom); 64746 var crop = { 64747 x: zoom * mediaBBoxSize.width / 2 - cropSize.width / 2 - mediaBBoxSize.width * zoom * (croppedAreaPercentages.x / 100), 64748 y: zoom * mediaBBoxSize.height / 2 - cropSize.height / 2 - mediaBBoxSize.height * zoom * (croppedAreaPercentages.y / 100) 64749 }; 64750 return { 64751 crop: crop, 64752 zoom: zoom 64753 }; 64754 } 64755 /** 64756 * Compute zoom from the croppedAreaPixels 64757 */ 64758 function getZoomFromCroppedAreaPixels(croppedAreaPixels, mediaSize, cropSize) { 64759 var mediaZoom = getMediaZoom(mediaSize); 64760 return cropSize.height > cropSize.width ? cropSize.height / (croppedAreaPixels.height * mediaZoom) : cropSize.width / (croppedAreaPixels.width * mediaZoom); 64761 } 64762 /** 64763 * Compute crop and zoom from the croppedAreaPixels 64764 */ 64765 function getInitialCropFromCroppedAreaPixels(croppedAreaPixels, mediaSize, rotation, cropSize, minZoom, maxZoom) { 64766 if (rotation === void 0) { 64767 rotation = 0; 64768 } 64769 var mediaNaturalBBoxSize = rotateSize(mediaSize.naturalWidth, mediaSize.naturalHeight, rotation); 64770 var zoom = clamp(getZoomFromCroppedAreaPixels(croppedAreaPixels, mediaSize, cropSize), minZoom, maxZoom); 64771 var cropZoom = cropSize.height > cropSize.width ? cropSize.height / croppedAreaPixels.height : cropSize.width / croppedAreaPixels.width; 64772 var crop = { 64773 x: ((mediaNaturalBBoxSize.width - croppedAreaPixels.width) / 2 - croppedAreaPixels.x) * cropZoom, 64774 y: ((mediaNaturalBBoxSize.height - croppedAreaPixels.height) / 2 - croppedAreaPixels.y) * cropZoom 64775 }; 64776 return { 64777 crop: crop, 64778 zoom: zoom 64779 }; 64780 } 64781 /** 64782 * Return the point that is the center of point a and b 64783 */ 64784 function getCenter(a, b) { 64785 return { 64786 x: (b.x + a.x) / 2, 64787 y: (b.y + a.y) / 2 64788 }; 64789 } 64790 function getRadianAngle(degreeValue) { 64791 return degreeValue * Math.PI / 180; 64792 } 64793 /** 64794 * Returns the new bounding area of a rotated rectangle. 64795 */ 64796 function rotateSize(width, height, rotation) { 64797 var rotRad = getRadianAngle(rotation); 64798 return { 64799 width: Math.abs(Math.cos(rotRad) * width) + Math.abs(Math.sin(rotRad) * height), 64800 height: Math.abs(Math.sin(rotRad) * width) + Math.abs(Math.cos(rotRad) * height) 64801 }; 64802 } 64803 /** 64804 * Clamp value between min and max 64805 */ 64806 function clamp(value, min, max) { 64807 return Math.min(Math.max(value, min), max); 64808 } 64809 /** 64810 * Combine multiple class names into a single string. 64811 */ 64812 function classNames() { 64813 var args = []; 64814 for (var _i = 0; _i < arguments.length; _i++) { 64815 args[_i] = arguments[_i]; 64816 } 64817 return args.filter(function (value) { 64818 if (typeof value === 'string' && value.length > 0) { 64819 return true; 64820 } 64821 return false; 64822 }).join(' ').trim(); 64823 } 64824 64825 var css_248z = ".reactEasyCrop_Container {\n position: absolute;\n top: 0;\n left: 0;\n right: 0;\n bottom: 0;\n overflow: hidden;\n user-select: none;\n touch-action: none;\n cursor: move;\n display: flex;\n justify-content: center;\n align-items: center;\n}\n\n.reactEasyCrop_Image,\n.reactEasyCrop_Video {\n will-change: transform; /* this improves performances and prevent painting issues on iOS Chrome */\n}\n\n.reactEasyCrop_Contain {\n max-width: 100%;\n max-height: 100%;\n margin: auto;\n position: absolute;\n top: 0;\n bottom: 0;\n left: 0;\n right: 0;\n}\n.reactEasyCrop_Cover_Horizontal {\n width: 100%;\n height: auto;\n}\n.reactEasyCrop_Cover_Vertical {\n width: auto;\n height: 100%;\n}\n\n.reactEasyCrop_CropArea {\n position: absolute;\n left: 50%;\n top: 50%;\n transform: translate(-50%, -50%);\n border: 1px solid rgba(255, 255, 255, 0.5);\n box-sizing: border-box;\n box-shadow: 0 0 0 9999em;\n color: rgba(0, 0, 0, 0.5);\n overflow: hidden;\n}\n\n.reactEasyCrop_CropAreaRound {\n border-radius: 50%;\n}\n\n.reactEasyCrop_CropAreaGrid::before {\n content: ' ';\n box-sizing: border-box;\n position: absolute;\n border: 1px solid rgba(255, 255, 255, 0.5);\n top: 0;\n bottom: 0;\n left: 33.33%;\n right: 33.33%;\n border-top: 0;\n border-bottom: 0;\n}\n\n.reactEasyCrop_CropAreaGrid::after {\n content: ' ';\n box-sizing: border-box;\n position: absolute;\n border: 1px solid rgba(255, 255, 255, 0.5);\n top: 33.33%;\n bottom: 33.33%;\n left: 0;\n right: 0;\n border-left: 0;\n border-right: 0;\n}\n"; 64826 64827 var index_module_MIN_ZOOM = 1; 64828 var index_module_MAX_ZOOM = 3; 64829 var Cropper = /** @class */function (_super) { 64830 __extends(Cropper, _super); 64831 function Cropper() { 64832 var _this = _super !== null && _super.apply(this, arguments) || this; 64833 _this.imageRef = external_React_.createRef(); 64834 _this.videoRef = external_React_.createRef(); 64835 _this.containerPosition = { 64836 x: 0, 64837 y: 0 64838 }; 64839 _this.containerRef = null; 64840 _this.styleRef = null; 64841 _this.containerRect = null; 64842 _this.mediaSize = { 64843 width: 0, 64844 height: 0, 64845 naturalWidth: 0, 64846 naturalHeight: 0 64847 }; 64848 _this.dragStartPosition = { 64849 x: 0, 64850 y: 0 64851 }; 64852 _this.dragStartCrop = { 64853 x: 0, 64854 y: 0 64855 }; 64856 _this.gestureZoomStart = 0; 64857 _this.gestureRotationStart = 0; 64858 _this.isTouching = false; 64859 _this.lastPinchDistance = 0; 64860 _this.lastPinchRotation = 0; 64861 _this.rafDragTimeout = null; 64862 _this.rafPinchTimeout = null; 64863 _this.wheelTimer = null; 64864 _this.currentDoc = typeof document !== 'undefined' ? document : null; 64865 _this.currentWindow = typeof window !== 'undefined' ? window : null; 64866 _this.resizeObserver = null; 64867 _this.state = { 64868 cropSize: null, 64869 hasWheelJustStarted: false, 64870 mediaObjectFit: undefined 64871 }; 64872 _this.initResizeObserver = function () { 64873 if (typeof window.ResizeObserver === 'undefined' || !_this.containerRef) { 64874 return; 64875 } 64876 var isFirstResize = true; 64877 _this.resizeObserver = new window.ResizeObserver(function (entries) { 64878 if (isFirstResize) { 64879 isFirstResize = false; // observe() is called on mount, we don't want to trigger a recompute on mount 64880 return; 64881 } 64882 _this.computeSizes(); 64883 }); 64884 _this.resizeObserver.observe(_this.containerRef); 64885 }; 64886 // this is to prevent Safari on iOS >= 10 to zoom the page 64887 _this.preventZoomSafari = function (e) { 64888 return e.preventDefault(); 64889 }; 64890 _this.cleanEvents = function () { 64891 if (!_this.currentDoc) return; 64892 _this.currentDoc.removeEventListener('mousemove', _this.onMouseMove); 64893 _this.currentDoc.removeEventListener('mouseup', _this.onDragStopped); 64894 _this.currentDoc.removeEventListener('touchmove', _this.onTouchMove); 64895 _this.currentDoc.removeEventListener('touchend', _this.onDragStopped); 64896 _this.currentDoc.removeEventListener('gesturemove', _this.onGestureMove); 64897 _this.currentDoc.removeEventListener('gestureend', _this.onGestureEnd); 64898 _this.currentDoc.removeEventListener('scroll', _this.onScroll); 64899 }; 64900 _this.clearScrollEvent = function () { 64901 if (_this.containerRef) _this.containerRef.removeEventListener('wheel', _this.onWheel); 64902 if (_this.wheelTimer) { 64903 clearTimeout(_this.wheelTimer); 64904 } 64905 }; 64906 _this.onMediaLoad = function () { 64907 var cropSize = _this.computeSizes(); 64908 if (cropSize) { 64909 _this.emitCropData(); 64910 _this.setInitialCrop(cropSize); 64911 } 64912 if (_this.props.onMediaLoaded) { 64913 _this.props.onMediaLoaded(_this.mediaSize); 64914 } 64915 }; 64916 _this.setInitialCrop = function (cropSize) { 64917 if (_this.props.initialCroppedAreaPercentages) { 64918 var _a = getInitialCropFromCroppedAreaPercentages(_this.props.initialCroppedAreaPercentages, _this.mediaSize, _this.props.rotation, cropSize, _this.props.minZoom, _this.props.maxZoom), 64919 crop = _a.crop, 64920 zoom = _a.zoom; 64921 _this.props.onCropChange(crop); 64922 _this.props.onZoomChange && _this.props.onZoomChange(zoom); 64923 } else if (_this.props.initialCroppedAreaPixels) { 64924 var _b = getInitialCropFromCroppedAreaPixels(_this.props.initialCroppedAreaPixels, _this.mediaSize, _this.props.rotation, cropSize, _this.props.minZoom, _this.props.maxZoom), 64925 crop = _b.crop, 64926 zoom = _b.zoom; 64927 _this.props.onCropChange(crop); 64928 _this.props.onZoomChange && _this.props.onZoomChange(zoom); 64929 } 64930 }; 64931 _this.computeSizes = function () { 64932 var _a, _b, _c, _d, _e, _f; 64933 var mediaRef = _this.imageRef.current || _this.videoRef.current; 64934 if (mediaRef && _this.containerRef) { 64935 _this.containerRect = _this.containerRef.getBoundingClientRect(); 64936 _this.saveContainerPosition(); 64937 var containerAspect = _this.containerRect.width / _this.containerRect.height; 64938 var naturalWidth = ((_a = _this.imageRef.current) === null || _a === void 0 ? void 0 : _a.naturalWidth) || ((_b = _this.videoRef.current) === null || _b === void 0 ? void 0 : _b.videoWidth) || 0; 64939 var naturalHeight = ((_c = _this.imageRef.current) === null || _c === void 0 ? void 0 : _c.naturalHeight) || ((_d = _this.videoRef.current) === null || _d === void 0 ? void 0 : _d.videoHeight) || 0; 64940 var isMediaScaledDown = mediaRef.offsetWidth < naturalWidth || mediaRef.offsetHeight < naturalHeight; 64941 var mediaAspect = naturalWidth / naturalHeight; 64942 // We do not rely on the offsetWidth/offsetHeight if the media is scaled down 64943 // as the values they report are rounded. That will result in precision losses 64944 // when calculating zoom. We use the fact that the media is positionned relative 64945 // to the container. That allows us to use the container's dimensions 64946 // and natural aspect ratio of the media to calculate accurate media size. 64947 // However, for this to work, the container should not be rotated 64948 var renderedMediaSize = void 0; 64949 if (isMediaScaledDown) { 64950 switch (_this.state.mediaObjectFit) { 64951 default: 64952 case 'contain': 64953 renderedMediaSize = containerAspect > mediaAspect ? { 64954 width: _this.containerRect.height * mediaAspect, 64955 height: _this.containerRect.height 64956 } : { 64957 width: _this.containerRect.width, 64958 height: _this.containerRect.width / mediaAspect 64959 }; 64960 break; 64961 case 'horizontal-cover': 64962 renderedMediaSize = { 64963 width: _this.containerRect.width, 64964 height: _this.containerRect.width / mediaAspect 64965 }; 64966 break; 64967 case 'vertical-cover': 64968 renderedMediaSize = { 64969 width: _this.containerRect.height * mediaAspect, 64970 height: _this.containerRect.height 64971 }; 64972 break; 64973 } 64974 } else { 64975 renderedMediaSize = { 64976 width: mediaRef.offsetWidth, 64977 height: mediaRef.offsetHeight 64978 }; 64979 } 64980 _this.mediaSize = __assign(__assign({}, renderedMediaSize), { 64981 naturalWidth: naturalWidth, 64982 naturalHeight: naturalHeight 64983 }); 64984 // set media size in the parent 64985 if (_this.props.setMediaSize) { 64986 _this.props.setMediaSize(_this.mediaSize); 64987 } 64988 var cropSize = _this.props.cropSize ? _this.props.cropSize : getCropSize(_this.mediaSize.width, _this.mediaSize.height, _this.containerRect.width, _this.containerRect.height, _this.props.aspect, _this.props.rotation); 64989 if (((_e = _this.state.cropSize) === null || _e === void 0 ? void 0 : _e.height) !== cropSize.height || ((_f = _this.state.cropSize) === null || _f === void 0 ? void 0 : _f.width) !== cropSize.width) { 64990 _this.props.onCropSizeChange && _this.props.onCropSizeChange(cropSize); 64991 } 64992 _this.setState({ 64993 cropSize: cropSize 64994 }, _this.recomputeCropPosition); 64995 // pass crop size to parent 64996 if (_this.props.setCropSize) { 64997 _this.props.setCropSize(cropSize); 64998 } 64999 return cropSize; 65000 } 65001 }; 65002 _this.saveContainerPosition = function () { 65003 if (_this.containerRef) { 65004 var bounds = _this.containerRef.getBoundingClientRect(); 65005 _this.containerPosition = { 65006 x: bounds.left, 65007 y: bounds.top 65008 }; 65009 } 65010 }; 65011 _this.onMouseDown = function (e) { 65012 if (!_this.currentDoc) return; 65013 e.preventDefault(); 65014 _this.currentDoc.addEventListener('mousemove', _this.onMouseMove); 65015 _this.currentDoc.addEventListener('mouseup', _this.onDragStopped); 65016 _this.saveContainerPosition(); 65017 _this.onDragStart(Cropper.getMousePoint(e)); 65018 }; 65019 _this.onMouseMove = function (e) { 65020 return _this.onDrag(Cropper.getMousePoint(e)); 65021 }; 65022 _this.onScroll = function (e) { 65023 if (!_this.currentDoc) return; 65024 e.preventDefault(); 65025 _this.saveContainerPosition(); 65026 }; 65027 _this.onTouchStart = function (e) { 65028 if (!_this.currentDoc) return; 65029 _this.isTouching = true; 65030 if (_this.props.onTouchRequest && !_this.props.onTouchRequest(e)) { 65031 return; 65032 } 65033 _this.currentDoc.addEventListener('touchmove', _this.onTouchMove, { 65034 passive: false 65035 }); // iOS 11 now defaults to passive: true 65036 _this.currentDoc.addEventListener('touchend', _this.onDragStopped); 65037 _this.saveContainerPosition(); 65038 if (e.touches.length === 2) { 65039 _this.onPinchStart(e); 65040 } else if (e.touches.length === 1) { 65041 _this.onDragStart(Cropper.getTouchPoint(e.touches[0])); 65042 } 65043 }; 65044 _this.onTouchMove = function (e) { 65045 // Prevent whole page from scrolling on iOS. 65046 e.preventDefault(); 65047 if (e.touches.length === 2) { 65048 _this.onPinchMove(e); 65049 } else if (e.touches.length === 1) { 65050 _this.onDrag(Cropper.getTouchPoint(e.touches[0])); 65051 } 65052 }; 65053 _this.onGestureStart = function (e) { 65054 if (!_this.currentDoc) return; 65055 e.preventDefault(); 65056 _this.currentDoc.addEventListener('gesturechange', _this.onGestureMove); 65057 _this.currentDoc.addEventListener('gestureend', _this.onGestureEnd); 65058 _this.gestureZoomStart = _this.props.zoom; 65059 _this.gestureRotationStart = _this.props.rotation; 65060 }; 65061 _this.onGestureMove = function (e) { 65062 e.preventDefault(); 65063 if (_this.isTouching) { 65064 // this is to avoid conflict between gesture and touch events 65065 return; 65066 } 65067 var point = Cropper.getMousePoint(e); 65068 var newZoom = _this.gestureZoomStart - 1 + e.scale; 65069 _this.setNewZoom(newZoom, point, { 65070 shouldUpdatePosition: true 65071 }); 65072 if (_this.props.onRotationChange) { 65073 var newRotation = _this.gestureRotationStart + e.rotation; 65074 _this.props.onRotationChange(newRotation); 65075 } 65076 }; 65077 _this.onGestureEnd = function (e) { 65078 _this.cleanEvents(); 65079 }; 65080 _this.onDragStart = function (_a) { 65081 var _b, _c; 65082 var x = _a.x, 65083 y = _a.y; 65084 _this.dragStartPosition = { 65085 x: x, 65086 y: y 65087 }; 65088 _this.dragStartCrop = __assign({}, _this.props.crop); 65089 (_c = (_b = _this.props).onInteractionStart) === null || _c === void 0 ? void 0 : _c.call(_b); 65090 }; 65091 _this.onDrag = function (_a) { 65092 var x = _a.x, 65093 y = _a.y; 65094 if (!_this.currentWindow) return; 65095 if (_this.rafDragTimeout) _this.currentWindow.cancelAnimationFrame(_this.rafDragTimeout); 65096 _this.rafDragTimeout = _this.currentWindow.requestAnimationFrame(function () { 65097 if (!_this.state.cropSize) return; 65098 if (x === undefined || y === undefined) return; 65099 var offsetX = x - _this.dragStartPosition.x; 65100 var offsetY = y - _this.dragStartPosition.y; 65101 var requestedPosition = { 65102 x: _this.dragStartCrop.x + offsetX, 65103 y: _this.dragStartCrop.y + offsetY 65104 }; 65105 var newPosition = _this.props.restrictPosition ? restrictPosition(requestedPosition, _this.mediaSize, _this.state.cropSize, _this.props.zoom, _this.props.rotation) : requestedPosition; 65106 _this.props.onCropChange(newPosition); 65107 }); 65108 }; 65109 _this.onDragStopped = function () { 65110 var _a, _b; 65111 _this.isTouching = false; 65112 _this.cleanEvents(); 65113 _this.emitCropData(); 65114 (_b = (_a = _this.props).onInteractionEnd) === null || _b === void 0 ? void 0 : _b.call(_a); 65115 }; 65116 _this.onWheel = function (e) { 65117 if (!_this.currentWindow) return; 65118 if (_this.props.onWheelRequest && !_this.props.onWheelRequest(e)) { 65119 return; 65120 } 65121 e.preventDefault(); 65122 var point = Cropper.getMousePoint(e); 65123 var pixelY = normalize_wheel_default()(e).pixelY; 65124 var newZoom = _this.props.zoom - pixelY * _this.props.zoomSpeed / 200; 65125 _this.setNewZoom(newZoom, point, { 65126 shouldUpdatePosition: true 65127 }); 65128 if (!_this.state.hasWheelJustStarted) { 65129 _this.setState({ 65130 hasWheelJustStarted: true 65131 }, function () { 65132 var _a, _b; 65133 return (_b = (_a = _this.props).onInteractionStart) === null || _b === void 0 ? void 0 : _b.call(_a); 65134 }); 65135 } 65136 if (_this.wheelTimer) { 65137 clearTimeout(_this.wheelTimer); 65138 } 65139 _this.wheelTimer = _this.currentWindow.setTimeout(function () { 65140 return _this.setState({ 65141 hasWheelJustStarted: false 65142 }, function () { 65143 var _a, _b; 65144 return (_b = (_a = _this.props).onInteractionEnd) === null || _b === void 0 ? void 0 : _b.call(_a); 65145 }); 65146 }, 250); 65147 }; 65148 _this.getPointOnContainer = function (_a, containerTopLeft) { 65149 var x = _a.x, 65150 y = _a.y; 65151 if (!_this.containerRect) { 65152 throw new Error('The Cropper is not mounted'); 65153 } 65154 return { 65155 x: _this.containerRect.width / 2 - (x - containerTopLeft.x), 65156 y: _this.containerRect.height / 2 - (y - containerTopLeft.y) 65157 }; 65158 }; 65159 _this.getPointOnMedia = function (_a) { 65160 var x = _a.x, 65161 y = _a.y; 65162 var _b = _this.props, 65163 crop = _b.crop, 65164 zoom = _b.zoom; 65165 return { 65166 x: (x + crop.x) / zoom, 65167 y: (y + crop.y) / zoom 65168 }; 65169 }; 65170 _this.setNewZoom = function (zoom, point, _a) { 65171 var _b = _a === void 0 ? {} : _a, 65172 _c = _b.shouldUpdatePosition, 65173 shouldUpdatePosition = _c === void 0 ? true : _c; 65174 if (!_this.state.cropSize || !_this.props.onZoomChange) return; 65175 var newZoom = clamp(zoom, _this.props.minZoom, _this.props.maxZoom); 65176 if (shouldUpdatePosition) { 65177 var zoomPoint = _this.getPointOnContainer(point, _this.containerPosition); 65178 var zoomTarget = _this.getPointOnMedia(zoomPoint); 65179 var requestedPosition = { 65180 x: zoomTarget.x * newZoom - zoomPoint.x, 65181 y: zoomTarget.y * newZoom - zoomPoint.y 65182 }; 65183 var newPosition = _this.props.restrictPosition ? restrictPosition(requestedPosition, _this.mediaSize, _this.state.cropSize, newZoom, _this.props.rotation) : requestedPosition; 65184 _this.props.onCropChange(newPosition); 65185 } 65186 _this.props.onZoomChange(newZoom); 65187 }; 65188 _this.getCropData = function () { 65189 if (!_this.state.cropSize) { 65190 return null; 65191 } 65192 // this is to ensure the crop is correctly restricted after a zoom back (https://github.com/ValentinH/react-easy-crop/issues/6) 65193 var restrictedPosition = _this.props.restrictPosition ? restrictPosition(_this.props.crop, _this.mediaSize, _this.state.cropSize, _this.props.zoom, _this.props.rotation) : _this.props.crop; 65194 return computeCroppedArea(restrictedPosition, _this.mediaSize, _this.state.cropSize, _this.getAspect(), _this.props.zoom, _this.props.rotation, _this.props.restrictPosition); 65195 }; 65196 _this.emitCropData = function () { 65197 var cropData = _this.getCropData(); 65198 if (!cropData) return; 65199 var croppedAreaPercentages = cropData.croppedAreaPercentages, 65200 croppedAreaPixels = cropData.croppedAreaPixels; 65201 if (_this.props.onCropComplete) { 65202 _this.props.onCropComplete(croppedAreaPercentages, croppedAreaPixels); 65203 } 65204 if (_this.props.onCropAreaChange) { 65205 _this.props.onCropAreaChange(croppedAreaPercentages, croppedAreaPixels); 65206 } 65207 }; 65208 _this.emitCropAreaChange = function () { 65209 var cropData = _this.getCropData(); 65210 if (!cropData) return; 65211 var croppedAreaPercentages = cropData.croppedAreaPercentages, 65212 croppedAreaPixels = cropData.croppedAreaPixels; 65213 if (_this.props.onCropAreaChange) { 65214 _this.props.onCropAreaChange(croppedAreaPercentages, croppedAreaPixels); 65215 } 65216 }; 65217 _this.recomputeCropPosition = function () { 65218 if (!_this.state.cropSize) return; 65219 var newPosition = _this.props.restrictPosition ? restrictPosition(_this.props.crop, _this.mediaSize, _this.state.cropSize, _this.props.zoom, _this.props.rotation) : _this.props.crop; 65220 _this.props.onCropChange(newPosition); 65221 _this.emitCropData(); 65222 }; 65223 return _this; 65224 } 65225 Cropper.prototype.componentDidMount = function () { 65226 if (!this.currentDoc || !this.currentWindow) return; 65227 if (this.containerRef) { 65228 if (this.containerRef.ownerDocument) { 65229 this.currentDoc = this.containerRef.ownerDocument; 65230 } 65231 if (this.currentDoc.defaultView) { 65232 this.currentWindow = this.currentDoc.defaultView; 65233 } 65234 this.initResizeObserver(); 65235 // only add window resize listener if ResizeObserver is not supported. Otherwise, it would be redundant 65236 if (typeof window.ResizeObserver === 'undefined') { 65237 this.currentWindow.addEventListener('resize', this.computeSizes); 65238 } 65239 this.props.zoomWithScroll && this.containerRef.addEventListener('wheel', this.onWheel, { 65240 passive: false 65241 }); 65242 this.containerRef.addEventListener('gesturestart', this.onGestureStart); 65243 } 65244 this.currentDoc.addEventListener('scroll', this.onScroll); 65245 if (!this.props.disableAutomaticStylesInjection) { 65246 this.styleRef = this.currentDoc.createElement('style'); 65247 this.styleRef.setAttribute('type', 'text/css'); 65248 if (this.props.nonce) { 65249 this.styleRef.setAttribute('nonce', this.props.nonce); 65250 } 65251 this.styleRef.innerHTML = css_248z; 65252 this.currentDoc.head.appendChild(this.styleRef); 65253 } 65254 // when rendered via SSR, the image can already be loaded and its onLoad callback will never be called 65255 if (this.imageRef.current && this.imageRef.current.complete) { 65256 this.onMediaLoad(); 65257 } 65258 // set image and video refs in the parent if the callbacks exist 65259 if (this.props.setImageRef) { 65260 this.props.setImageRef(this.imageRef); 65261 } 65262 if (this.props.setVideoRef) { 65263 this.props.setVideoRef(this.videoRef); 65264 } 65265 }; 65266 Cropper.prototype.componentWillUnmount = function () { 65267 var _a, _b; 65268 if (!this.currentDoc || !this.currentWindow) return; 65269 if (typeof window.ResizeObserver === 'undefined') { 65270 this.currentWindow.removeEventListener('resize', this.computeSizes); 65271 } 65272 (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect(); 65273 if (this.containerRef) { 65274 this.containerRef.removeEventListener('gesturestart', this.preventZoomSafari); 65275 } 65276 if (this.styleRef) { 65277 (_b = this.styleRef.parentNode) === null || _b === void 0 ? void 0 : _b.removeChild(this.styleRef); 65278 } 65279 this.cleanEvents(); 65280 this.props.zoomWithScroll && this.clearScrollEvent(); 65281 }; 65282 Cropper.prototype.componentDidUpdate = function (prevProps) { 65283 var _a, _b, _c, _d, _e, _f, _g, _h, _j; 65284 if (prevProps.rotation !== this.props.rotation) { 65285 this.computeSizes(); 65286 this.recomputeCropPosition(); 65287 } else if (prevProps.aspect !== this.props.aspect) { 65288 this.computeSizes(); 65289 } else if (prevProps.objectFit !== this.props.objectFit) { 65290 this.computeSizes(); 65291 } else if (prevProps.zoom !== this.props.zoom) { 65292 this.recomputeCropPosition(); 65293 } else if (((_a = prevProps.cropSize) === null || _a === void 0 ? void 0 : _a.height) !== ((_b = this.props.cropSize) === null || _b === void 0 ? void 0 : _b.height) || ((_c = prevProps.cropSize) === null || _c === void 0 ? void 0 : _c.width) !== ((_d = this.props.cropSize) === null || _d === void 0 ? void 0 : _d.width)) { 65294 this.computeSizes(); 65295 } else if (((_e = prevProps.crop) === null || _e === void 0 ? void 0 : _e.x) !== ((_f = this.props.crop) === null || _f === void 0 ? void 0 : _f.x) || ((_g = prevProps.crop) === null || _g === void 0 ? void 0 : _g.y) !== ((_h = this.props.crop) === null || _h === void 0 ? void 0 : _h.y)) { 65296 this.emitCropAreaChange(); 65297 } 65298 if (prevProps.zoomWithScroll !== this.props.zoomWithScroll && this.containerRef) { 65299 this.props.zoomWithScroll ? this.containerRef.addEventListener('wheel', this.onWheel, { 65300 passive: false 65301 }) : this.clearScrollEvent(); 65302 } 65303 if (prevProps.video !== this.props.video) { 65304 (_j = this.videoRef.current) === null || _j === void 0 ? void 0 : _j.load(); 65305 } 65306 var objectFit = this.getObjectFit(); 65307 if (objectFit !== this.state.mediaObjectFit) { 65308 this.setState({ 65309 mediaObjectFit: objectFit 65310 }, this.computeSizes); 65311 } 65312 }; 65313 Cropper.prototype.getAspect = function () { 65314 var _a = this.props, 65315 cropSize = _a.cropSize, 65316 aspect = _a.aspect; 65317 if (cropSize) { 65318 return cropSize.width / cropSize.height; 65319 } 65320 return aspect; 65321 }; 65322 Cropper.prototype.getObjectFit = function () { 65323 var _a, _b, _c, _d; 65324 if (this.props.objectFit === 'cover') { 65325 var mediaRef = this.imageRef.current || this.videoRef.current; 65326 if (mediaRef && this.containerRef) { 65327 this.containerRect = this.containerRef.getBoundingClientRect(); 65328 var containerAspect = this.containerRect.width / this.containerRect.height; 65329 var naturalWidth = ((_a = this.imageRef.current) === null || _a === void 0 ? void 0 : _a.naturalWidth) || ((_b = this.videoRef.current) === null || _b === void 0 ? void 0 : _b.videoWidth) || 0; 65330 var naturalHeight = ((_c = this.imageRef.current) === null || _c === void 0 ? void 0 : _c.naturalHeight) || ((_d = this.videoRef.current) === null || _d === void 0 ? void 0 : _d.videoHeight) || 0; 65331 var mediaAspect = naturalWidth / naturalHeight; 65332 return mediaAspect < containerAspect ? 'horizontal-cover' : 'vertical-cover'; 65333 } 65334 return 'horizontal-cover'; 65335 } 65336 return this.props.objectFit; 65337 }; 65338 Cropper.prototype.onPinchStart = function (e) { 65339 var pointA = Cropper.getTouchPoint(e.touches[0]); 65340 var pointB = Cropper.getTouchPoint(e.touches[1]); 65341 this.lastPinchDistance = getDistanceBetweenPoints(pointA, pointB); 65342 this.lastPinchRotation = getRotationBetweenPoints(pointA, pointB); 65343 this.onDragStart(getCenter(pointA, pointB)); 65344 }; 65345 Cropper.prototype.onPinchMove = function (e) { 65346 var _this = this; 65347 if (!this.currentDoc || !this.currentWindow) return; 65348 var pointA = Cropper.getTouchPoint(e.touches[0]); 65349 var pointB = Cropper.getTouchPoint(e.touches[1]); 65350 var center = getCenter(pointA, pointB); 65351 this.onDrag(center); 65352 if (this.rafPinchTimeout) this.currentWindow.cancelAnimationFrame(this.rafPinchTimeout); 65353 this.rafPinchTimeout = this.currentWindow.requestAnimationFrame(function () { 65354 var distance = getDistanceBetweenPoints(pointA, pointB); 65355 var newZoom = _this.props.zoom * (distance / _this.lastPinchDistance); 65356 _this.setNewZoom(newZoom, center, { 65357 shouldUpdatePosition: false 65358 }); 65359 _this.lastPinchDistance = distance; 65360 var rotation = getRotationBetweenPoints(pointA, pointB); 65361 var newRotation = _this.props.rotation + (rotation - _this.lastPinchRotation); 65362 _this.props.onRotationChange && _this.props.onRotationChange(newRotation); 65363 _this.lastPinchRotation = rotation; 65364 }); 65365 }; 65366 Cropper.prototype.render = function () { 65367 var _this = this; 65368 var _a = this.props, 65369 image = _a.image, 65370 video = _a.video, 65371 mediaProps = _a.mediaProps, 65372 transform = _a.transform, 65373 _b = _a.crop, 65374 x = _b.x, 65375 y = _b.y, 65376 rotation = _a.rotation, 65377 zoom = _a.zoom, 65378 cropShape = _a.cropShape, 65379 showGrid = _a.showGrid, 65380 _c = _a.style, 65381 containerStyle = _c.containerStyle, 65382 cropAreaStyle = _c.cropAreaStyle, 65383 mediaStyle = _c.mediaStyle, 65384 _d = _a.classes, 65385 containerClassName = _d.containerClassName, 65386 cropAreaClassName = _d.cropAreaClassName, 65387 mediaClassName = _d.mediaClassName; 65388 var objectFit = this.state.mediaObjectFit; 65389 return external_React_.createElement("div", { 65390 onMouseDown: this.onMouseDown, 65391 onTouchStart: this.onTouchStart, 65392 ref: function ref(el) { 65393 return _this.containerRef = el; 65394 }, 65395 "data-testid": "container", 65396 style: containerStyle, 65397 className: classNames('reactEasyCrop_Container', containerClassName) 65398 }, image ? external_React_.createElement("img", __assign({ 65399 alt: "", 65400 className: classNames('reactEasyCrop_Image', objectFit === 'contain' && 'reactEasyCrop_Contain', objectFit === 'horizontal-cover' && 'reactEasyCrop_Cover_Horizontal', objectFit === 'vertical-cover' && 'reactEasyCrop_Cover_Vertical', mediaClassName) 65401 }, mediaProps, { 65402 src: image, 65403 ref: this.imageRef, 65404 style: __assign(__assign({}, mediaStyle), { 65405 transform: transform || "translate(".concat(x, "px, ").concat(y, "px) rotate(").concat(rotation, "deg) scale(").concat(zoom, ")") 65406 }), 65407 onLoad: this.onMediaLoad 65408 })) : video && external_React_.createElement("video", __assign({ 65409 autoPlay: true, 65410 loop: true, 65411 muted: true, 65412 className: classNames('reactEasyCrop_Video', objectFit === 'contain' && 'reactEasyCrop_Contain', objectFit === 'horizontal-cover' && 'reactEasyCrop_Cover_Horizontal', objectFit === 'vertical-cover' && 'reactEasyCrop_Cover_Vertical', mediaClassName) 65413 }, mediaProps, { 65414 ref: this.videoRef, 65415 onLoadedMetadata: this.onMediaLoad, 65416 style: __assign(__assign({}, mediaStyle), { 65417 transform: transform || "translate(".concat(x, "px, ").concat(y, "px) rotate(").concat(rotation, "deg) scale(").concat(zoom, ")") 65418 }), 65419 controls: false 65420 }), (Array.isArray(video) ? video : [{ 65421 src: video 65422 }]).map(function (item) { 65423 return external_React_.createElement("source", __assign({ 65424 key: item.src 65425 }, item)); 65426 })), this.state.cropSize && external_React_.createElement("div", { 65427 style: __assign(__assign({}, cropAreaStyle), { 65428 width: this.state.cropSize.width, 65429 height: this.state.cropSize.height 65430 }), 65431 "data-testid": "cropper", 65432 className: classNames('reactEasyCrop_CropArea', cropShape === 'round' && 'reactEasyCrop_CropAreaRound', showGrid && 'reactEasyCrop_CropAreaGrid', cropAreaClassName) 65433 })); 65434 }; 65435 Cropper.defaultProps = { 65436 zoom: 1, 65437 rotation: 0, 65438 aspect: 4 / 3, 65439 maxZoom: index_module_MAX_ZOOM, 65440 minZoom: index_module_MIN_ZOOM, 65441 cropShape: 'rect', 65442 objectFit: 'contain', 65443 showGrid: true, 65444 style: {}, 65445 classes: {}, 65446 mediaProps: {}, 65447 zoomSpeed: 1, 65448 restrictPosition: true, 65449 zoomWithScroll: true 65450 }; 65451 Cropper.getMousePoint = function (e) { 65452 return { 65453 x: Number(e.clientX), 65454 y: Number(e.clientY) 65455 }; 65456 }; 65457 Cropper.getTouchPoint = function (touch) { 65458 return { 65459 x: Number(touch.clientX), 65460 y: Number(touch.clientY) 65461 }; 65462 }; 65463 return Cropper; 65464 }(external_React_.Component); 65465 65466 65467 65468 ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/cropper.js 65469 /** 65470 * External dependencies 65471 */ 65472 65473 65474 65475 /** 65476 * WordPress dependencies 65477 */ 65478 65479 65480 65481 /** 65482 * Internal dependencies 65483 */ 65484 65485 65486 65487 65488 65489 function ImageCropper({ 65490 url, 65491 width, 65492 height, 65493 naturalHeight, 65494 naturalWidth, 65495 borderProps 65496 }) { 65497 const { 65498 isInProgress, 65499 editedUrl, 65500 position, 65501 zoom, 65502 aspect, 65503 setPosition, 65504 setCrop, 65505 setZoom, 65506 rotation 65507 } = useImageEditingContext(); 65508 const [contentResizeListener, { 65509 width: clientWidth 65510 }] = (0,external_wp_compose_namespaceObject.useResizeObserver)(); 65511 let editedHeight = height || clientWidth * naturalHeight / naturalWidth; 65512 if (rotation % 180 === 90) { 65513 editedHeight = clientWidth * naturalWidth / naturalHeight; 65514 } 65515 const area = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 65516 className: dist_clsx('wp-block-image__crop-area', borderProps?.className, { 65517 'is-applying': isInProgress 65518 }), 65519 style: { 65520 ...borderProps?.style, 65521 width: width || clientWidth, 65522 height: editedHeight 65523 }, 65524 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Cropper, { 65525 image: editedUrl || url, 65526 disabled: isInProgress, 65527 minZoom: MIN_ZOOM / 100, 65528 maxZoom: MAX_ZOOM / 100, 65529 crop: position, 65530 zoom: zoom / 100, 65531 aspect: aspect, 65532 onCropChange: pos => { 65533 setPosition(pos); 65534 }, 65535 onCropComplete: newCropPercent => { 65536 setCrop(newCropPercent); 65537 }, 65538 onZoomChange: newZoom => { 65539 setZoom(newZoom * 100); 65540 } 65541 }), isInProgress && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {})] 65542 }); 65543 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 65544 children: [contentResizeListener, area] 65545 }); 65546 } 65547 65548 ;// ./node_modules/@wordpress/icons/build-module/library/search.js 65549 /** 65550 * WordPress dependencies 65551 */ 65552 65553 65554 const search = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 65555 xmlns: "http://www.w3.org/2000/svg", 65556 viewBox: "0 0 24 24", 65557 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 65558 d: "M13 5c-3.3 0-6 2.7-6 6 0 1.4.5 2.7 1.3 3.7l-3.8 3.8 1.1 1.1 3.8-3.8c1 .8 2.3 1.3 3.7 1.3 3.3 0 6-2.7 6-6S16.3 5 13 5zm0 10.5c-2.5 0-4.5-2-4.5-4.5s2-4.5 4.5-4.5 4.5 2 4.5 4.5-2 4.5-4.5 4.5z" 65559 }) 65560 }); 65561 /* harmony default export */ const library_search = (search); 65562 65563 ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/zoom-dropdown.js 65564 /** 65565 * WordPress dependencies 65566 */ 65567 65568 65569 65570 65571 /** 65572 * Internal dependencies 65573 */ 65574 65575 65576 65577 function ZoomDropdown() { 65578 const { 65579 isInProgress, 65580 zoom, 65581 setZoom 65582 } = useImageEditingContext(); 65583 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 65584 contentClassName: "wp-block-image__zoom", 65585 popoverProps: constants_POPOVER_PROPS, 65586 renderToggle: ({ 65587 isOpen, 65588 onToggle 65589 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 65590 icon: library_search, 65591 label: (0,external_wp_i18n_namespaceObject.__)('Zoom'), 65592 onClick: onToggle, 65593 "aria-expanded": isOpen, 65594 disabled: isInProgress 65595 }), 65596 renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, { 65597 paddingSize: "medium", 65598 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, { 65599 __next40pxDefaultSize: true, 65600 __nextHasNoMarginBottom: true, 65601 label: (0,external_wp_i18n_namespaceObject.__)('Zoom'), 65602 min: MIN_ZOOM, 65603 max: MAX_ZOOM, 65604 value: Math.round(zoom), 65605 onChange: setZoom 65606 }) 65607 }) 65608 }); 65609 } 65610 65611 ;// ./node_modules/@wordpress/icons/build-module/library/rotate-right.js 65612 /** 65613 * WordPress dependencies 65614 */ 65615 65616 65617 const rotateRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 65618 xmlns: "http://www.w3.org/2000/svg", 65619 viewBox: "0 0 24 24", 65620 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 65621 d: "M15.1 4.8l-3-2.5V4c-4.4 0-8 3.6-8 8 0 3.7 2.5 6.9 6 7.7.3.1.6.1 1 .2l.2-1.5c-.4 0-.7-.1-1.1-.2l-.1.2v-.2c-2.6-.8-4.5-3.3-4.5-6.2 0-3.6 2.9-6.5 6.5-6.5v1.8l3-2.5zM20 11c-.2-1.4-.7-2.7-1.6-3.8l-1.2.8c.7.9 1.1 2 1.3 3.1L20 11zm-1.5 1.8c-.1.5-.2 1.1-.4 1.6s-.5 1-.8 1.5l1.2.9c.4-.5.8-1.1 1-1.8s.5-1.3.5-2l-1.5-.2zm-5.6 5.6l.2 1.5c1.4-.2 2.7-.7 3.8-1.6l-.9-1.1c-.9.7-2 1.1-3.1 1.2z" 65622 }) 65623 }); 65624 /* harmony default export */ const rotate_right = (rotateRight); 65625 65626 ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/rotation-button.js 65627 /** 65628 * WordPress dependencies 65629 */ 65630 65631 65632 65633 65634 65635 /** 65636 * Internal dependencies 65637 */ 65638 65639 65640 function RotationButton() { 65641 const { 65642 isInProgress, 65643 rotateClockwise 65644 } = useImageEditingContext(); 65645 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 65646 icon: rotate_right, 65647 label: (0,external_wp_i18n_namespaceObject.__)('Rotate'), 65648 onClick: rotateClockwise, 65649 disabled: isInProgress 65650 }); 65651 } 65652 65653 ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/form-controls.js 65654 /** 65655 * WordPress dependencies 65656 */ 65657 65658 65659 65660 /** 65661 * Internal dependencies 65662 */ 65663 65664 65665 65666 65667 function FormControls() { 65668 const { 65669 isInProgress, 65670 apply, 65671 cancel 65672 } = useImageEditingContext(); 65673 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 65674 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 65675 onClick: apply, 65676 disabled: isInProgress, 65677 children: (0,external_wp_i18n_namespaceObject.__)('Apply') 65678 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 65679 onClick: cancel, 65680 children: (0,external_wp_i18n_namespaceObject.__)('Cancel') 65681 })] 65682 }); 65683 } 65684 65685 ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/index.js 65686 /** 65687 * WordPress dependencies 65688 */ 65689 65690 65691 /** 65692 * Internal dependencies 65693 */ 65694 65695 65696 65697 65698 65699 65700 65701 65702 65703 function ImageEditor({ 65704 id, 65705 url, 65706 width, 65707 height, 65708 naturalHeight, 65709 naturalWidth, 65710 onSaveImage, 65711 onFinishEditing, 65712 borderProps 65713 }) { 65714 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(ImageEditingProvider, { 65715 id: id, 65716 url: url, 65717 naturalWidth: naturalWidth, 65718 naturalHeight: naturalHeight, 65719 onSaveImage: onSaveImage, 65720 onFinishEditing: onFinishEditing, 65721 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ImageCropper, { 65722 borderProps: borderProps, 65723 url: url, 65724 width: width, 65725 height: height, 65726 naturalHeight: naturalHeight, 65727 naturalWidth: naturalWidth 65728 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(block_controls, { 65729 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, { 65730 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ZoomDropdown, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, { 65731 children: toggleProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioDropdown, { 65732 toggleProps: toggleProps 65733 }) 65734 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RotationButton, {})] 65735 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, { 65736 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FormControls, {}) 65737 })] 65738 })] 65739 }); 65740 } 65741 65742 ;// ./node_modules/@wordpress/block-editor/build-module/components/image-size-control/use-dimension-handler.js 65743 /** 65744 * WordPress dependencies 65745 */ 65746 65747 function useDimensionHandler(customHeight, customWidth, defaultHeight, defaultWidth, onChange) { 65748 var _ref, _ref2; 65749 const [currentWidth, setCurrentWidth] = (0,external_wp_element_namespaceObject.useState)((_ref = customWidth !== null && customWidth !== void 0 ? customWidth : defaultWidth) !== null && _ref !== void 0 ? _ref : ''); 65750 const [currentHeight, setCurrentHeight] = (0,external_wp_element_namespaceObject.useState)((_ref2 = customHeight !== null && customHeight !== void 0 ? customHeight : defaultHeight) !== null && _ref2 !== void 0 ? _ref2 : ''); 65751 65752 // When an image is first inserted, the default dimensions are initially 65753 // undefined. This effect updates the dimensions when the default values 65754 // come through. 65755 (0,external_wp_element_namespaceObject.useEffect)(() => { 65756 if (customWidth === undefined && defaultWidth !== undefined) { 65757 setCurrentWidth(defaultWidth); 65758 } 65759 if (customHeight === undefined && defaultHeight !== undefined) { 65760 setCurrentHeight(defaultHeight); 65761 } 65762 }, [defaultWidth, defaultHeight]); 65763 65764 // If custom values change, it means an outsider has resized the image using some other method (eg resize box) 65765 // this keeps track of these values too. We need to parse before comparing; custom values can be strings. 65766 (0,external_wp_element_namespaceObject.useEffect)(() => { 65767 if (customWidth !== undefined && Number.parseInt(customWidth) !== Number.parseInt(currentWidth)) { 65768 setCurrentWidth(customWidth); 65769 } 65770 if (customHeight !== undefined && Number.parseInt(customHeight) !== Number.parseInt(currentHeight)) { 65771 setCurrentHeight(customHeight); 65772 } 65773 }, [customWidth, customHeight]); 65774 const updateDimension = (dimension, value) => { 65775 const parsedValue = value === '' ? undefined : parseInt(value, 10); 65776 if (dimension === 'width') { 65777 setCurrentWidth(parsedValue); 65778 } else { 65779 setCurrentHeight(parsedValue); 65780 } 65781 onChange({ 65782 [dimension]: parsedValue 65783 }); 65784 }; 65785 const updateDimensions = (nextHeight, nextWidth) => { 65786 setCurrentHeight(nextHeight !== null && nextHeight !== void 0 ? nextHeight : defaultHeight); 65787 setCurrentWidth(nextWidth !== null && nextWidth !== void 0 ? nextWidth : defaultWidth); 65788 onChange({ 65789 height: nextHeight, 65790 width: nextWidth 65791 }); 65792 }; 65793 return { 65794 currentHeight, 65795 currentWidth, 65796 updateDimension, 65797 updateDimensions 65798 }; 65799 } 65800 65801 ;// ./node_modules/@wordpress/block-editor/build-module/components/image-size-control/index.js 65802 /** 65803 * WordPress dependencies 65804 */ 65805 65806 65807 65808 /** 65809 * Internal dependencies 65810 */ 65811 65812 65813 65814 65815 const IMAGE_SIZE_PRESETS = [25, 50, 75, 100]; 65816 const image_size_control_noop = () => {}; 65817 function ImageSizeControl({ 65818 imageSizeHelp, 65819 imageWidth, 65820 imageHeight, 65821 imageSizeOptions = [], 65822 isResizable = true, 65823 slug, 65824 width, 65825 height, 65826 onChange, 65827 onChangeImage = image_size_control_noop 65828 }) { 65829 const { 65830 currentHeight, 65831 currentWidth, 65832 updateDimension, 65833 updateDimensions 65834 } = useDimensionHandler(height, width, imageHeight, imageWidth, onChange); 65835 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 65836 children: [imageSizeOptions && imageSizeOptions.length > 0 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SelectControl, { 65837 __nextHasNoMarginBottom: true, 65838 label: (0,external_wp_i18n_namespaceObject.__)('Resolution'), 65839 value: slug, 65840 options: imageSizeOptions, 65841 onChange: onChangeImage, 65842 help: imageSizeHelp, 65843 size: "__unstable-large" 65844 }), isResizable && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 65845 className: "block-editor-image-size-control", 65846 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 65847 align: "baseline", 65848 spacing: "3", 65849 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, { 65850 className: "block-editor-image-size-control__width", 65851 label: (0,external_wp_i18n_namespaceObject.__)('Width'), 65852 value: currentWidth, 65853 min: 1, 65854 onChange: value => updateDimension('width', value), 65855 size: "__unstable-large" 65856 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, { 65857 className: "block-editor-image-size-control__height", 65858 label: (0,external_wp_i18n_namespaceObject.__)('Height'), 65859 value: currentHeight, 65860 min: 1, 65861 onChange: value => updateDimension('height', value), 65862 size: "__unstable-large" 65863 })] 65864 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 65865 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ButtonGroup, { 65866 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Image size presets'), 65867 children: IMAGE_SIZE_PRESETS.map(scale => { 65868 const scaledWidth = Math.round(imageWidth * (scale / 100)); 65869 const scaledHeight = Math.round(imageHeight * (scale / 100)); 65870 const isCurrent = currentWidth === scaledWidth && currentHeight === scaledHeight; 65871 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Button, { 65872 size: "small", 65873 variant: isCurrent ? 'primary' : undefined, 65874 isPressed: isCurrent, 65875 onClick: () => updateDimensions(scaledHeight, scaledWidth), 65876 children: [scale, "%"] 65877 }, scale); 65878 }) 65879 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 65880 size: "small", 65881 onClick: () => updateDimensions(), 65882 children: (0,external_wp_i18n_namespaceObject.__)('Reset') 65883 })] 65884 })] 65885 })] 65886 }); 65887 } 65888 65889 ;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/link-viewer-url.js 65890 /** 65891 * External dependencies 65892 */ 65893 65894 65895 /** 65896 * WordPress dependencies 65897 */ 65898 65899 65900 65901 function LinkViewerURL({ 65902 url, 65903 urlLabel, 65904 className 65905 }) { 65906 const linkClassName = dist_clsx(className, 'block-editor-url-popover__link-viewer-url'); 65907 if (!url) { 65908 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 65909 className: linkClassName 65910 }); 65911 } 65912 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, { 65913 className: linkClassName, 65914 href: url, 65915 children: urlLabel || (0,external_wp_url_namespaceObject.filterURLForDisplay)((0,external_wp_url_namespaceObject.safeDecodeURI)(url)) 65916 }); 65917 } 65918 65919 ;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/link-viewer.js 65920 /** 65921 * External dependencies 65922 */ 65923 65924 65925 /** 65926 * WordPress dependencies 65927 */ 65928 65929 65930 65931 65932 /** 65933 * Internal dependencies 65934 */ 65935 65936 65937 65938 function LinkViewer({ 65939 className, 65940 linkClassName, 65941 onEditLinkClick, 65942 url, 65943 urlLabel, 65944 ...props 65945 }) { 65946 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 65947 className: dist_clsx('block-editor-url-popover__link-viewer', className), 65948 ...props, 65949 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkViewerURL, { 65950 url: url, 65951 urlLabel: urlLabel, 65952 className: linkClassName 65953 }), onEditLinkClick && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 65954 icon: edit, 65955 label: (0,external_wp_i18n_namespaceObject.__)('Edit'), 65956 onClick: onEditLinkClick, 65957 size: "compact" 65958 })] 65959 }); 65960 } 65961 65962 ;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/link-editor.js 65963 /** 65964 * External dependencies 65965 */ 65966 65967 65968 /** 65969 * WordPress dependencies 65970 */ 65971 65972 65973 65974 65975 /** 65976 * Internal dependencies 65977 */ 65978 65979 65980 65981 function LinkEditor({ 65982 autocompleteRef, 65983 className, 65984 onChangeInputValue, 65985 value, 65986 ...props 65987 }) { 65988 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("form", { 65989 className: dist_clsx('block-editor-url-popover__link-editor', className), 65990 ...props, 65991 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_input, { 65992 value: value, 65993 onChange: onChangeInputValue, 65994 autocompleteRef: autocompleteRef 65995 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 65996 icon: keyboard_return, 65997 label: (0,external_wp_i18n_namespaceObject.__)('Apply'), 65998 type: "submit", 65999 size: "compact" 66000 })] 66001 }); 66002 } 66003 66004 ;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/index.js 66005 /** 66006 * WordPress dependencies 66007 */ 66008 66009 66010 66011 66012 66013 66014 /** 66015 * Internal dependencies 66016 */ 66017 66018 66019 66020 66021 66022 const { 66023 __experimentalPopoverLegacyPositionToPlacement 66024 } = unlock(external_wp_components_namespaceObject.privateApis); 66025 const DEFAULT_PLACEMENT = 'bottom'; 66026 const URLPopover = (0,external_wp_element_namespaceObject.forwardRef)(({ 66027 additionalControls, 66028 children, 66029 renderSettings, 66030 // The DEFAULT_PLACEMENT value is assigned inside the function's body 66031 placement, 66032 focusOnMount = 'firstElement', 66033 // Deprecated 66034 position, 66035 // Rest 66036 ...popoverProps 66037 }, ref) => { 66038 if (position !== undefined) { 66039 external_wp_deprecated_default()('`position` prop in wp.blockEditor.URLPopover', { 66040 since: '6.2', 66041 alternative: '`placement` prop' 66042 }); 66043 } 66044 66045 // Compute popover's placement: 66046 // - give priority to `placement` prop, if defined 66047 // - otherwise, compute it from the legacy `position` prop (if defined) 66048 // - finally, fallback to the DEFAULT_PLACEMENT. 66049 let computedPlacement; 66050 if (placement !== undefined) { 66051 computedPlacement = placement; 66052 } else if (position !== undefined) { 66053 computedPlacement = __experimentalPopoverLegacyPositionToPlacement(position); 66054 } 66055 computedPlacement = computedPlacement || DEFAULT_PLACEMENT; 66056 const [isSettingsExpanded, setIsSettingsExpanded] = (0,external_wp_element_namespaceObject.useState)(false); 66057 const showSettings = !!renderSettings && isSettingsExpanded; 66058 const toggleSettingsVisibility = () => { 66059 setIsSettingsExpanded(!isSettingsExpanded); 66060 }; 66061 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Popover, { 66062 ref: ref, 66063 role: "dialog", 66064 "aria-modal": "true", 66065 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Edit URL'), 66066 className: "block-editor-url-popover", 66067 focusOnMount: focusOnMount, 66068 placement: computedPlacement, 66069 shift: true, 66070 variant: "toolbar", 66071 ...popoverProps, 66072 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 66073 className: "block-editor-url-popover__input-container", 66074 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 66075 className: "block-editor-url-popover__row", 66076 children: [children, !!renderSettings && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 66077 className: "block-editor-url-popover__settings-toggle", 66078 icon: chevron_down, 66079 label: (0,external_wp_i18n_namespaceObject.__)('Link settings'), 66080 onClick: toggleSettingsVisibility, 66081 "aria-expanded": isSettingsExpanded, 66082 size: "compact" 66083 })] 66084 }) 66085 }), showSettings && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 66086 className: "block-editor-url-popover__settings", 66087 children: renderSettings() 66088 }), additionalControls && !showSettings && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 66089 className: "block-editor-url-popover__additional-controls", 66090 children: additionalControls 66091 })] 66092 }); 66093 }); 66094 URLPopover.LinkEditor = LinkEditor; 66095 URLPopover.LinkViewer = LinkViewer; 66096 66097 /** 66098 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/url-popover/README.md 66099 */ 66100 /* harmony default export */ const url_popover = (URLPopover); 66101 66102 ;// ./node_modules/@wordpress/block-editor/build-module/components/media-placeholder/index.js 66103 /** 66104 * External dependencies 66105 */ 66106 66107 66108 /** 66109 * WordPress dependencies 66110 */ 66111 66112 66113 66114 66115 66116 66117 66118 66119 /** 66120 * Internal dependencies 66121 */ 66122 66123 66124 66125 66126 66127 66128 66129 const media_placeholder_noop = () => {}; 66130 const InsertFromURLPopover = ({ 66131 src, 66132 onChange, 66133 onSubmit, 66134 onClose, 66135 popoverAnchor 66136 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_popover, { 66137 anchor: popoverAnchor, 66138 onClose: onClose, 66139 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("form", { 66140 className: "block-editor-media-placeholder__url-input-form", 66141 onSubmit: onSubmit, 66142 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, { 66143 __next40pxDefaultSize: true, 66144 label: (0,external_wp_i18n_namespaceObject.__)('URL'), 66145 hideLabelFromVision: true, 66146 placeholder: (0,external_wp_i18n_namespaceObject.__)('Paste or type URL'), 66147 onChange: onChange, 66148 value: src, 66149 suffix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlSuffixWrapper, { 66150 variant: "control", 66151 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 66152 size: "small", 66153 icon: keyboard_return, 66154 label: (0,external_wp_i18n_namespaceObject.__)('Apply'), 66155 type: "submit" 66156 }) 66157 }) 66158 }) 66159 }) 66160 }); 66161 const URLSelectionUI = ({ 66162 src, 66163 onChangeSrc, 66164 onSelectURL 66165 }) => { 66166 // Use internal state instead of a ref to make sure that the component 66167 // re-renders when the popover's anchor updates. 66168 const [popoverAnchor, setPopoverAnchor] = (0,external_wp_element_namespaceObject.useState)(null); 66169 const [isURLInputVisible, setIsURLInputVisible] = (0,external_wp_element_namespaceObject.useState)(false); 66170 const openURLInput = () => { 66171 setIsURLInputVisible(true); 66172 }; 66173 const closeURLInput = () => { 66174 setIsURLInputVisible(false); 66175 popoverAnchor?.focus(); 66176 }; 66177 const onSubmitSrc = event => { 66178 event.preventDefault(); 66179 if (src && onSelectURL) { 66180 onSelectURL(src); 66181 closeURLInput(); 66182 } 66183 }; 66184 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 66185 className: "block-editor-media-placeholder__url-input-container", 66186 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 66187 __next40pxDefaultSize: true, 66188 className: "block-editor-media-placeholder__button", 66189 onClick: openURLInput, 66190 isPressed: isURLInputVisible, 66191 variant: "secondary", 66192 "aria-haspopup": "dialog", 66193 ref: setPopoverAnchor, 66194 children: (0,external_wp_i18n_namespaceObject.__)('Insert from URL') 66195 }), isURLInputVisible && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InsertFromURLPopover, { 66196 src: src, 66197 onChange: onChangeSrc, 66198 onSubmit: onSubmitSrc, 66199 onClose: closeURLInput, 66200 popoverAnchor: popoverAnchor 66201 })] 66202 }); 66203 }; 66204 function MediaPlaceholder({ 66205 value = {}, 66206 allowedTypes, 66207 className, 66208 icon, 66209 labels = {}, 66210 mediaPreview, 66211 notices, 66212 isAppender, 66213 accept, 66214 addToGallery, 66215 multiple = false, 66216 handleUpload = true, 66217 disableDropZone, 66218 disableMediaButtons, 66219 onError, 66220 onSelect, 66221 onCancel, 66222 onSelectURL, 66223 onToggleFeaturedImage, 66224 onDoubleClick, 66225 onFilesPreUpload = media_placeholder_noop, 66226 onHTMLDrop: deprecatedOnHTMLDrop, 66227 children, 66228 mediaLibraryButton, 66229 placeholder, 66230 style 66231 }) { 66232 if (deprecatedOnHTMLDrop) { 66233 external_wp_deprecated_default()('wp.blockEditor.MediaPlaceholder onHTMLDrop prop', { 66234 since: '6.2', 66235 version: '6.4' 66236 }); 66237 } 66238 const mediaUpload = (0,external_wp_data_namespaceObject.useSelect)(select => { 66239 const { 66240 getSettings 66241 } = select(store); 66242 return getSettings().mediaUpload; 66243 }, []); 66244 const [src, setSrc] = (0,external_wp_element_namespaceObject.useState)(''); 66245 (0,external_wp_element_namespaceObject.useEffect)(() => { 66246 var _value$src; 66247 setSrc((_value$src = value?.src) !== null && _value$src !== void 0 ? _value$src : ''); 66248 }, [value?.src]); 66249 const onlyAllowsImages = () => { 66250 if (!allowedTypes || allowedTypes.length === 0) { 66251 return false; 66252 } 66253 return allowedTypes.every(allowedType => allowedType === 'image' || allowedType.startsWith('image/')); 66254 }; 66255 const onFilesUpload = files => { 66256 if (!handleUpload || typeof handleUpload === 'function' && !handleUpload(files)) { 66257 return onSelect(files); 66258 } 66259 onFilesPreUpload(files); 66260 let setMedia; 66261 if (multiple) { 66262 if (addToGallery) { 66263 // Since the setMedia function runs multiple times per upload group 66264 // and is passed newMedia containing every item in its group each time, we must 66265 // filter out whatever this upload group had previously returned to the 66266 // gallery before adding and returning the image array with replacement newMedia 66267 // values. 66268 66269 // Define an array to store urls from newMedia between subsequent function calls. 66270 let lastMediaPassed = []; 66271 setMedia = newMedia => { 66272 // Remove any images this upload group is responsible for (lastMediaPassed). 66273 // Their replacements are contained in newMedia. 66274 const filteredMedia = (value !== null && value !== void 0 ? value : []).filter(item => { 66275 // If Item has id, only remove it if lastMediaPassed has an item with that id. 66276 if (item.id) { 66277 return !lastMediaPassed.some( 66278 // Be sure to convert to number for comparison. 66279 ({ 66280 id 66281 }) => Number(id) === Number(item.id)); 66282 } 66283 // Compare transient images via .includes since gallery may append extra info onto the url. 66284 return !lastMediaPassed.some(({ 66285 urlSlug 66286 }) => item.url.includes(urlSlug)); 66287 }); 66288 // Return the filtered media array along with newMedia. 66289 onSelect(filteredMedia.concat(newMedia)); 66290 // Reset lastMediaPassed and set it with ids and urls from newMedia. 66291 lastMediaPassed = newMedia.map(media => { 66292 // Add everything up to '.fileType' to compare via .includes. 66293 const cutOffIndex = media.url.lastIndexOf('.'); 66294 const urlSlug = media.url.slice(0, cutOffIndex); 66295 return { 66296 id: media.id, 66297 urlSlug 66298 }; 66299 }); 66300 }; 66301 } else { 66302 setMedia = onSelect; 66303 } 66304 } else { 66305 setMedia = ([media]) => onSelect(media); 66306 } 66307 mediaUpload({ 66308 allowedTypes, 66309 filesList: files, 66310 onFileChange: setMedia, 66311 onError 66312 }); 66313 }; 66314 async function handleBlocksDrop(blocks) { 66315 if (!blocks || !Array.isArray(blocks)) { 66316 return; 66317 } 66318 function recursivelyFindMediaFromBlocks(_blocks) { 66319 return _blocks.flatMap(block => (block.name === 'core/image' || block.name === 'core/audio' || block.name === 'core/video') && block.attributes.url ? [block] : recursivelyFindMediaFromBlocks(block.innerBlocks)); 66320 } 66321 const mediaBlocks = recursivelyFindMediaFromBlocks(blocks); 66322 if (!mediaBlocks.length) { 66323 return; 66324 } 66325 const uploadedMediaList = await Promise.all(mediaBlocks.map(block => block.attributes.id ? block.attributes : new Promise((resolve, reject) => { 66326 window.fetch(block.attributes.url).then(response => response.blob()).then(blob => mediaUpload({ 66327 filesList: [blob], 66328 additionalData: { 66329 title: block.attributes.title, 66330 alt_text: block.attributes.alt, 66331 caption: block.attributes.caption 66332 }, 66333 onFileChange: ([media]) => { 66334 if (media.id) { 66335 resolve(media); 66336 } 66337 }, 66338 allowedTypes, 66339 onError: reject 66340 })).catch(() => resolve(block.attributes.url)); 66341 }))).catch(err => onError(err)); 66342 if (multiple) { 66343 onSelect(uploadedMediaList); 66344 } else { 66345 onSelect(uploadedMediaList[0]); 66346 } 66347 } 66348 async function onHTMLDrop(HTML) { 66349 const blocks = (0,external_wp_blocks_namespaceObject.pasteHandler)({ 66350 HTML 66351 }); 66352 return await handleBlocksDrop(blocks); 66353 } 66354 const onUpload = event => { 66355 onFilesUpload(event.target.files); 66356 }; 66357 const defaultRenderPlaceholder = content => { 66358 let { 66359 instructions, 66360 title 66361 } = labels; 66362 if (!mediaUpload && !onSelectURL) { 66363 instructions = (0,external_wp_i18n_namespaceObject.__)('To edit this block, you need permission to upload media.'); 66364 } 66365 if (instructions === undefined || title === undefined) { 66366 const typesAllowed = allowedTypes !== null && allowedTypes !== void 0 ? allowedTypes : []; 66367 const [firstAllowedType] = typesAllowed; 66368 const isOneType = 1 === typesAllowed.length; 66369 const isAudio = isOneType && 'audio' === firstAllowedType; 66370 const isImage = isOneType && 'image' === firstAllowedType; 66371 const isVideo = isOneType && 'video' === firstAllowedType; 66372 if (instructions === undefined && mediaUpload) { 66373 instructions = (0,external_wp_i18n_namespaceObject.__)('Upload a media file or pick one from your media library.'); 66374 if (isAudio) { 66375 instructions = (0,external_wp_i18n_namespaceObject.__)('Upload or drag an audio file here, or pick one from your library.'); 66376 } else if (isImage) { 66377 instructions = (0,external_wp_i18n_namespaceObject.__)('Upload or drag an image file here, or pick one from your library.'); 66378 } else if (isVideo) { 66379 instructions = (0,external_wp_i18n_namespaceObject.__)('Upload or drag a video file here, or pick one from your library.'); 66380 } 66381 } 66382 if (title === undefined) { 66383 title = (0,external_wp_i18n_namespaceObject.__)('Media'); 66384 if (isAudio) { 66385 title = (0,external_wp_i18n_namespaceObject.__)('Audio'); 66386 } else if (isImage) { 66387 title = (0,external_wp_i18n_namespaceObject.__)('Image'); 66388 } else if (isVideo) { 66389 title = (0,external_wp_i18n_namespaceObject.__)('Video'); 66390 } 66391 } 66392 } 66393 const placeholderClassName = dist_clsx('block-editor-media-placeholder', className, { 66394 'is-appender': isAppender 66395 }); 66396 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Placeholder, { 66397 icon: icon, 66398 label: title, 66399 instructions: instructions, 66400 className: placeholderClassName, 66401 notices: notices, 66402 onDoubleClick: onDoubleClick, 66403 preview: mediaPreview, 66404 style: style, 66405 children: [content, children] 66406 }); 66407 }; 66408 const renderPlaceholder = placeholder !== null && placeholder !== void 0 ? placeholder : defaultRenderPlaceholder; 66409 const renderDropZone = () => { 66410 if (disableDropZone) { 66411 return null; 66412 } 66413 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropZone, { 66414 onFilesDrop: onFilesUpload, 66415 onHTMLDrop: onHTMLDrop 66416 }); 66417 }; 66418 const renderCancelLink = () => { 66419 return onCancel && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 66420 __next40pxDefaultSize: true, 66421 className: "block-editor-media-placeholder__cancel-button", 66422 title: (0,external_wp_i18n_namespaceObject.__)('Cancel'), 66423 variant: "link", 66424 onClick: onCancel, 66425 children: (0,external_wp_i18n_namespaceObject.__)('Cancel') 66426 }); 66427 }; 66428 const renderUrlSelectionUI = () => { 66429 return onSelectURL && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(URLSelectionUI, { 66430 src: src, 66431 onChangeSrc: setSrc, 66432 onSelectURL: onSelectURL 66433 }); 66434 }; 66435 const renderFeaturedImageToggle = () => { 66436 return onToggleFeaturedImage && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 66437 className: "block-editor-media-placeholder__url-input-container", 66438 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 66439 __next40pxDefaultSize: true, 66440 className: "block-editor-media-placeholder__button", 66441 onClick: onToggleFeaturedImage, 66442 variant: "secondary", 66443 children: (0,external_wp_i18n_namespaceObject.__)('Use featured image') 66444 }) 66445 }); 66446 }; 66447 const renderMediaUploadChecked = () => { 66448 const defaultButton = ({ 66449 open 66450 }) => { 66451 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 66452 __next40pxDefaultSize: true, 66453 variant: "secondary", 66454 onClick: () => { 66455 open(); 66456 }, 66457 children: (0,external_wp_i18n_namespaceObject.__)('Media Library') 66458 }); 66459 }; 66460 const libraryButton = mediaLibraryButton !== null && mediaLibraryButton !== void 0 ? mediaLibraryButton : defaultButton; 66461 const uploadMediaLibraryButton = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_upload, { 66462 addToGallery: addToGallery, 66463 gallery: multiple && onlyAllowsImages(), 66464 multiple: multiple, 66465 onSelect: onSelect, 66466 allowedTypes: allowedTypes, 66467 mode: "browse", 66468 value: Array.isArray(value) ? value.map(({ 66469 id 66470 }) => id) : value.id, 66471 render: libraryButton 66472 }); 66473 if (mediaUpload && isAppender) { 66474 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 66475 children: [renderDropZone(), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FormFileUpload, { 66476 onChange: onUpload, 66477 accept: accept, 66478 multiple: !!multiple, 66479 render: ({ 66480 openFileDialog 66481 }) => { 66482 const content = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 66483 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 66484 __next40pxDefaultSize: true, 66485 variant: "primary", 66486 className: dist_clsx('block-editor-media-placeholder__button', 'block-editor-media-placeholder__upload-button'), 66487 onClick: openFileDialog, 66488 children: (0,external_wp_i18n_namespaceObject.__)('Upload') 66489 }), uploadMediaLibraryButton, renderUrlSelectionUI(), renderFeaturedImageToggle(), renderCancelLink()] 66490 }); 66491 return renderPlaceholder(content); 66492 } 66493 })] 66494 }); 66495 } 66496 if (mediaUpload) { 66497 const content = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 66498 children: [renderDropZone(), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FormFileUpload, { 66499 render: ({ 66500 openFileDialog 66501 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 66502 __next40pxDefaultSize: true, 66503 onClick: openFileDialog, 66504 variant: "primary", 66505 className: dist_clsx('block-editor-media-placeholder__button', 'block-editor-media-placeholder__upload-button'), 66506 children: (0,external_wp_i18n_namespaceObject.__)('Upload') 66507 }), 66508 onChange: onUpload, 66509 accept: accept, 66510 multiple: !!multiple 66511 }), uploadMediaLibraryButton, renderUrlSelectionUI(), renderFeaturedImageToggle(), renderCancelLink()] 66512 }); 66513 return renderPlaceholder(content); 66514 } 66515 return renderPlaceholder(uploadMediaLibraryButton); 66516 }; 66517 if (disableMediaButtons) { 66518 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(check, { 66519 children: renderDropZone() 66520 }); 66521 } 66522 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(check, { 66523 fallback: renderPlaceholder(renderUrlSelectionUI()), 66524 children: renderMediaUploadChecked() 66525 }); 66526 } 66527 66528 /** 66529 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/media-placeholder/README.md 66530 */ 66531 /* harmony default export */ const media_placeholder = ((0,external_wp_components_namespaceObject.withFilters)('editor.MediaPlaceholder')(MediaPlaceholder)); 66532 66533 ;// ./node_modules/@wordpress/block-editor/build-module/components/panel-color-settings/index.js 66534 /** 66535 * Internal dependencies 66536 */ 66537 66538 66539 const PanelColorSettings = ({ 66540 colorSettings, 66541 ...props 66542 }) => { 66543 const settings = colorSettings.map(setting => { 66544 if (!setting) { 66545 return setting; 66546 } 66547 const { 66548 value, 66549 onChange, 66550 ...otherSettings 66551 } = setting; 66552 return { 66553 ...otherSettings, 66554 colorValue: value, 66555 onColorChange: onChange 66556 }; 66557 }); 66558 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel_color_gradient_settings, { 66559 settings: settings, 66560 gradients: [], 66561 disableCustomGradients: true, 66562 ...props 66563 }); 66564 }; 66565 /* harmony default export */ const panel_color_settings = (PanelColorSettings); 66566 66567 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/format-toolbar/index.js 66568 /** 66569 * External dependencies 66570 */ 66571 66572 66573 /** 66574 * WordPress dependencies 66575 */ 66576 66577 66578 66579 66580 /** 66581 * Internal dependencies 66582 */ 66583 66584 66585 66586 66587 const format_toolbar_POPOVER_PROPS = { 66588 placement: 'bottom-start' 66589 }; 66590 const FormatToolbar = () => { 66591 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 66592 children: [['bold', 'italic', 'link', 'unknown'].map(format => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Slot, { 66593 name: `RichText.ToolbarControls.$format}` 66594 }, format)), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Slot, { 66595 name: "RichText.ToolbarControls", 66596 children: fills => { 66597 if (!fills.length) { 66598 return null; 66599 } 66600 const allProps = fills.map(([{ 66601 props 66602 }]) => props); 66603 const hasActive = allProps.some(({ 66604 isActive 66605 }) => isActive); 66606 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, { 66607 children: toggleProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, { 66608 icon: chevron_down 66609 /* translators: button label text should, if possible, be under 16 characters. */, 66610 label: (0,external_wp_i18n_namespaceObject.__)('More'), 66611 toggleProps: { 66612 ...toggleProps, 66613 className: dist_clsx(toggleProps.className, { 66614 'is-pressed': hasActive 66615 }), 66616 description: (0,external_wp_i18n_namespaceObject.__)('Displays more block tools') 66617 }, 66618 controls: orderBy(fills.map(([{ 66619 props 66620 }]) => props), 'title'), 66621 popoverProps: format_toolbar_POPOVER_PROPS 66622 }) 66623 }); 66624 } 66625 })] 66626 }); 66627 }; 66628 /* harmony default export */ const format_toolbar = (FormatToolbar); 66629 66630 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/format-toolbar-container.js 66631 /** 66632 * WordPress dependencies 66633 */ 66634 66635 66636 66637 /** 66638 * Internal dependencies 66639 */ 66640 66641 66642 66643 66644 function InlineToolbar({ 66645 popoverAnchor 66646 }) { 66647 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, { 66648 placement: "top", 66649 focusOnMount: false, 66650 anchor: popoverAnchor, 66651 className: "block-editor-rich-text__inline-format-toolbar", 66652 __unstableSlotName: "block-toolbar", 66653 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigableToolbar, { 66654 className: "block-editor-rich-text__inline-format-toolbar-group" 66655 /* translators: accessibility text for the inline format toolbar */, 66656 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Format tools'), 66657 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, { 66658 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(format_toolbar, {}) 66659 }) 66660 }) 66661 }); 66662 } 66663 const FormatToolbarContainer = ({ 66664 inline, 66665 editableContentElement 66666 }) => { 66667 if (inline) { 66668 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InlineToolbar, { 66669 popoverAnchor: editableContentElement 66670 }); 66671 } 66672 66673 // Render regular toolbar. 66674 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, { 66675 group: "inline", 66676 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(format_toolbar, {}) 66677 }); 66678 }; 66679 /* harmony default export */ const format_toolbar_container = (FormatToolbarContainer); 66680 66681 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/use-mark-persistent.js 66682 /** 66683 * WordPress dependencies 66684 */ 66685 66686 66687 66688 /** 66689 * Internal dependencies 66690 */ 66691 66692 function useMarkPersistent({ 66693 html, 66694 value 66695 }) { 66696 const previousTextRef = (0,external_wp_element_namespaceObject.useRef)(); 66697 const hasActiveFormats = !!value.activeFormats?.length; 66698 const { 66699 __unstableMarkLastChangeAsPersistent 66700 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 66701 66702 // Must be set synchronously to make sure it applies to the last change. 66703 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 66704 // Ignore mount. 66705 if (!previousTextRef.current) { 66706 previousTextRef.current = value.text; 66707 return; 66708 } 66709 66710 // Text input, so don't create an undo level for every character. 66711 // Create an undo level after 1 second of no input. 66712 if (previousTextRef.current !== value.text) { 66713 const timeout = window.setTimeout(() => { 66714 __unstableMarkLastChangeAsPersistent(); 66715 }, 1000); 66716 previousTextRef.current = value.text; 66717 return () => { 66718 window.clearTimeout(timeout); 66719 }; 66720 } 66721 __unstableMarkLastChangeAsPersistent(); 66722 }, [html, hasActiveFormats]); 66723 } 66724 66725 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/use-format-types.js 66726 /** 66727 * WordPress dependencies 66728 */ 66729 66730 66731 66732 function formatTypesSelector(select) { 66733 return select(external_wp_richText_namespaceObject.store).getFormatTypes(); 66734 } 66735 66736 /** 66737 * Set of all interactive content tags. 66738 * 66739 * @see https://html.spec.whatwg.org/multipage/dom.html#interactive-content 66740 */ 66741 const interactiveContentTags = new Set(['a', 'audio', 'button', 'details', 'embed', 'iframe', 'input', 'label', 'select', 'textarea', 'video']); 66742 function prefixSelectKeys(selected, prefix) { 66743 if (typeof selected !== 'object') { 66744 return { 66745 [prefix]: selected 66746 }; 66747 } 66748 return Object.fromEntries(Object.entries(selected).map(([key, value]) => [`$prefix}.$key}`, value])); 66749 } 66750 function getPrefixedSelectKeys(selected, prefix) { 66751 if (selected[prefix]) { 66752 return selected[prefix]; 66753 } 66754 return Object.keys(selected).filter(key => key.startsWith(prefix + '.')).reduce((accumulator, key) => { 66755 accumulator[key.slice(prefix.length + 1)] = selected[key]; 66756 return accumulator; 66757 }, {}); 66758 } 66759 66760 /** 66761 * This hook provides RichText with the `formatTypes` and its derived props from 66762 * experimental format type settings. 66763 * 66764 * @param {Object} $0 Options 66765 * @param {string} $0.clientId Block client ID. 66766 * @param {string} $0.identifier Block attribute. 66767 * @param {boolean} $0.withoutInteractiveFormatting Whether to clean the interactive formattings or not. 66768 * @param {Array} $0.allowedFormats Allowed formats 66769 */ 66770 function useFormatTypes({ 66771 clientId, 66772 identifier, 66773 withoutInteractiveFormatting, 66774 allowedFormats 66775 }) { 66776 const allFormatTypes = (0,external_wp_data_namespaceObject.useSelect)(formatTypesSelector, []); 66777 const formatTypes = (0,external_wp_element_namespaceObject.useMemo)(() => { 66778 return allFormatTypes.filter(({ 66779 name, 66780 interactive, 66781 tagName 66782 }) => { 66783 if (allowedFormats && !allowedFormats.includes(name)) { 66784 return false; 66785 } 66786 if (withoutInteractiveFormatting && (interactive || interactiveContentTags.has(tagName))) { 66787 return false; 66788 } 66789 return true; 66790 }); 66791 }, [allFormatTypes, allowedFormats, withoutInteractiveFormatting]); 66792 const keyedSelected = (0,external_wp_data_namespaceObject.useSelect)(select => formatTypes.reduce((accumulator, type) => { 66793 if (!type.__experimentalGetPropsForEditableTreePreparation) { 66794 return accumulator; 66795 } 66796 return { 66797 ...accumulator, 66798 ...prefixSelectKeys(type.__experimentalGetPropsForEditableTreePreparation(select, { 66799 richTextIdentifier: identifier, 66800 blockClientId: clientId 66801 }), type.name) 66802 }; 66803 }, {}), [formatTypes, clientId, identifier]); 66804 const dispatch = (0,external_wp_data_namespaceObject.useDispatch)(); 66805 const prepareHandlers = []; 66806 const valueHandlers = []; 66807 const changeHandlers = []; 66808 const dependencies = []; 66809 for (const key in keyedSelected) { 66810 dependencies.push(keyedSelected[key]); 66811 } 66812 formatTypes.forEach(type => { 66813 if (type.__experimentalCreatePrepareEditableTree) { 66814 const handler = type.__experimentalCreatePrepareEditableTree(getPrefixedSelectKeys(keyedSelected, type.name), { 66815 richTextIdentifier: identifier, 66816 blockClientId: clientId 66817 }); 66818 if (type.__experimentalCreateOnChangeEditableValue) { 66819 valueHandlers.push(handler); 66820 } else { 66821 prepareHandlers.push(handler); 66822 } 66823 } 66824 if (type.__experimentalCreateOnChangeEditableValue) { 66825 let dispatchers = {}; 66826 if (type.__experimentalGetPropsForEditableTreeChangeHandler) { 66827 dispatchers = type.__experimentalGetPropsForEditableTreeChangeHandler(dispatch, { 66828 richTextIdentifier: identifier, 66829 blockClientId: clientId 66830 }); 66831 } 66832 const selected = getPrefixedSelectKeys(keyedSelected, type.name); 66833 changeHandlers.push(type.__experimentalCreateOnChangeEditableValue({ 66834 ...(typeof selected === 'object' ? selected : {}), 66835 ...dispatchers 66836 }, { 66837 richTextIdentifier: identifier, 66838 blockClientId: clientId 66839 })); 66840 } 66841 }); 66842 return { 66843 formatTypes, 66844 prepareHandlers, 66845 valueHandlers, 66846 changeHandlers, 66847 dependencies 66848 }; 66849 } 66850 66851 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/before-input-rules.js 66852 /** 66853 * WordPress dependencies 66854 */ 66855 66856 66857 66858 /** 66859 * Internal dependencies 66860 */ 66861 66862 66863 /** 66864 * When typing over a selection, the selection will we wrapped by a matching 66865 * character pair. The second character is optional, it defaults to the first 66866 * character. 66867 * 66868 * @type {string[]} Array of character pairs. 66869 */ 66870 const wrapSelectionSettings = ['`', '"', "'", '“”', '‘’']; 66871 /* harmony default export */ const before_input_rules = (props => element => { 66872 function onInput(event) { 66873 const { 66874 inputType, 66875 data 66876 } = event; 66877 const { 66878 value, 66879 onChange, 66880 registry 66881 } = props.current; 66882 66883 // Only run the rules when inserting text. 66884 if (inputType !== 'insertText') { 66885 return; 66886 } 66887 if ((0,external_wp_richText_namespaceObject.isCollapsed)(value)) { 66888 return; 66889 } 66890 const pair = (0,external_wp_hooks_namespaceObject.applyFilters)('blockEditor.wrapSelectionSettings', wrapSelectionSettings).find(([startChar, endChar]) => startChar === data || endChar === data); 66891 if (!pair) { 66892 return; 66893 } 66894 const [startChar, endChar = startChar] = pair; 66895 const start = value.start; 66896 const end = value.end + startChar.length; 66897 let newValue = (0,external_wp_richText_namespaceObject.insert)(value, startChar, start, start); 66898 newValue = (0,external_wp_richText_namespaceObject.insert)(newValue, endChar, end, end); 66899 const { 66900 __unstableMarkLastChangeAsPersistent, 66901 __unstableMarkAutomaticChange 66902 } = registry.dispatch(store); 66903 __unstableMarkLastChangeAsPersistent(); 66904 onChange(newValue); 66905 __unstableMarkAutomaticChange(); 66906 const init = {}; 66907 for (const key in event) { 66908 init[key] = event[key]; 66909 } 66910 init.data = endChar; 66911 const { 66912 ownerDocument 66913 } = element; 66914 const { 66915 defaultView 66916 } = ownerDocument; 66917 const newEvent = new defaultView.InputEvent('input', init); 66918 66919 // Dispatch an `input` event with the new data. This will trigger the 66920 // input rules. 66921 // Postpone the `input` to the next event loop tick so that the dispatch 66922 // doesn't happen synchronously in the middle of `beforeinput` dispatch. 66923 // This is closer to how native `input` event would be timed, and also 66924 // makes sure that the `input` event is dispatched only after the `onChange` 66925 // call few lines above has fully updated the data store state and rerendered 66926 // all affected components. 66927 window.queueMicrotask(() => { 66928 event.target.dispatchEvent(newEvent); 66929 }); 66930 event.preventDefault(); 66931 } 66932 element.addEventListener('beforeinput', onInput); 66933 return () => { 66934 element.removeEventListener('beforeinput', onInput); 66935 }; 66936 }); 66937 66938 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/prevent-event-discovery.js 66939 /** 66940 * WordPress dependencies 66941 */ 66942 66943 function preventEventDiscovery(value) { 66944 const searchText = 'tales of gutenberg'; 66945 const addText = ' 🐡🐢🦀🐤🦋🐘🐧🐹🦁🦄🦍🐼🐿🎃🐴🐝🐆🦕🦔🌱🍇π🍌🐉💧🥨🌌🍂🍠🥦🥚🥝🎟🥥🥒🛵🥖🍒🍯🎾🎲🐺🐚🐮⌛️'; 66946 const { 66947 start, 66948 text 66949 } = value; 66950 if (start < searchText.length) { 66951 return value; 66952 } 66953 const charactersBefore = text.slice(start - searchText.length, start); 66954 if (charactersBefore.toLowerCase() !== searchText) { 66955 return value; 66956 } 66957 return (0,external_wp_richText_namespaceObject.insert)(value, addText); 66958 } 66959 66960 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/input-rules.js 66961 /** 66962 * WordPress dependencies 66963 */ 66964 66965 66966 66967 /** 66968 * Internal dependencies 66969 */ 66970 66971 66972 66973 function findSelection(blocks) { 66974 let i = blocks.length; 66975 while (i--) { 66976 const attributeKey = retrieveSelectedAttribute(blocks[i].attributes); 66977 if (attributeKey) { 66978 blocks[i].attributes[attributeKey] = blocks[i].attributes[attributeKey] 66979 // To do: refactor this to use rich text's selection instead, so 66980 // we no longer have to use on this hack inserting a special 66981 // character. 66982 .toString().replace(START_OF_SELECTED_AREA, ''); 66983 return [blocks[i].clientId, attributeKey, 0, 0]; 66984 } 66985 const nestedSelection = findSelection(blocks[i].innerBlocks); 66986 if (nestedSelection) { 66987 return nestedSelection; 66988 } 66989 } 66990 return []; 66991 } 66992 /* harmony default export */ const input_rules = (props => element => { 66993 function inputRule() { 66994 const { 66995 getValue, 66996 onReplace, 66997 selectionChange, 66998 registry 66999 } = props.current; 67000 if (!onReplace) { 67001 return; 67002 } 67003 67004 // We must use getValue() here because value may be update 67005 // asynchronously. 67006 const value = getValue(); 67007 const { 67008 start, 67009 text 67010 } = value; 67011 const characterBefore = text.slice(start - 1, start); 67012 67013 // The character right before the caret must be a plain space. 67014 if (characterBefore !== ' ') { 67015 return; 67016 } 67017 const trimmedTextBefore = text.slice(0, start).trim(); 67018 const prefixTransforms = (0,external_wp_blocks_namespaceObject.getBlockTransforms)('from').filter(({ 67019 type 67020 }) => type === 'prefix'); 67021 const transformation = (0,external_wp_blocks_namespaceObject.findTransform)(prefixTransforms, ({ 67022 prefix 67023 }) => { 67024 return trimmedTextBefore === prefix; 67025 }); 67026 if (!transformation) { 67027 return; 67028 } 67029 const content = (0,external_wp_richText_namespaceObject.toHTMLString)({ 67030 value: (0,external_wp_richText_namespaceObject.insert)(value, START_OF_SELECTED_AREA, 0, start) 67031 }); 67032 const block = transformation.transform(content); 67033 selectionChange(...findSelection([block])); 67034 onReplace([block]); 67035 registry.dispatch(store).__unstableMarkAutomaticChange(); 67036 return true; 67037 } 67038 function onInput(event) { 67039 const { 67040 inputType, 67041 type 67042 } = event; 67043 const { 67044 getValue, 67045 onChange, 67046 __unstableAllowPrefixTransformations, 67047 formatTypes, 67048 registry 67049 } = props.current; 67050 67051 // Only run input rules when inserting text. 67052 if (inputType !== 'insertText' && type !== 'compositionend') { 67053 return; 67054 } 67055 if (__unstableAllowPrefixTransformations && inputRule()) { 67056 return; 67057 } 67058 const value = getValue(); 67059 const transformed = formatTypes.reduce((accumlator, { 67060 __unstableInputRule 67061 }) => { 67062 if (__unstableInputRule) { 67063 accumlator = __unstableInputRule(accumlator); 67064 } 67065 return accumlator; 67066 }, preventEventDiscovery(value)); 67067 const { 67068 __unstableMarkLastChangeAsPersistent, 67069 __unstableMarkAutomaticChange 67070 } = registry.dispatch(store); 67071 if (transformed !== value) { 67072 __unstableMarkLastChangeAsPersistent(); 67073 onChange({ 67074 ...transformed, 67075 activeFormats: value.activeFormats 67076 }); 67077 __unstableMarkAutomaticChange(); 67078 } 67079 } 67080 element.addEventListener('input', onInput); 67081 element.addEventListener('compositionend', onInput); 67082 return () => { 67083 element.removeEventListener('input', onInput); 67084 element.removeEventListener('compositionend', onInput); 67085 }; 67086 }); 67087 67088 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/insert-replacement-text.js 67089 /** 67090 * Internal dependencies 67091 */ 67092 67093 67094 /** 67095 * When the browser is about to auto correct, add an undo level so the user can 67096 * revert the change. 67097 * 67098 * @param {Object} props 67099 */ 67100 /* harmony default export */ const insert_replacement_text = (props => element => { 67101 function onInput(event) { 67102 if (event.inputType !== 'insertReplacementText') { 67103 return; 67104 } 67105 const { 67106 registry 67107 } = props.current; 67108 registry.dispatch(store).__unstableMarkLastChangeAsPersistent(); 67109 } 67110 element.addEventListener('beforeinput', onInput); 67111 return () => { 67112 element.removeEventListener('beforeinput', onInput); 67113 }; 67114 }); 67115 67116 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/remove-browser-shortcuts.js 67117 /** 67118 * WordPress dependencies 67119 */ 67120 67121 67122 /** 67123 * Hook to prevent default behaviors for key combinations otherwise handled 67124 * internally by RichText. 67125 */ 67126 /* harmony default export */ const remove_browser_shortcuts = (() => node => { 67127 function onKeydown(event) { 67128 if (external_wp_keycodes_namespaceObject.isKeyboardEvent.primary(event, 'z') || external_wp_keycodes_namespaceObject.isKeyboardEvent.primary(event, 'y') || external_wp_keycodes_namespaceObject.isKeyboardEvent.primaryShift(event, 'z')) { 67129 event.preventDefault(); 67130 } 67131 } 67132 node.addEventListener('keydown', onKeydown); 67133 return () => { 67134 node.removeEventListener('keydown', onKeydown); 67135 }; 67136 }); 67137 67138 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/shortcuts.js 67139 /* harmony default export */ const shortcuts = (props => element => { 67140 const { 67141 keyboardShortcuts 67142 } = props.current; 67143 function onKeyDown(event) { 67144 for (const keyboardShortcut of keyboardShortcuts.current) { 67145 keyboardShortcut(event); 67146 } 67147 } 67148 element.addEventListener('keydown', onKeyDown); 67149 return () => { 67150 element.removeEventListener('keydown', onKeyDown); 67151 }; 67152 }); 67153 67154 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/input-events.js 67155 /* harmony default export */ const input_events = (props => element => { 67156 const { 67157 inputEvents 67158 } = props.current; 67159 function onInput(event) { 67160 for (const keyboardShortcut of inputEvents.current) { 67161 keyboardShortcut(event); 67162 } 67163 } 67164 element.addEventListener('input', onInput); 67165 return () => { 67166 element.removeEventListener('input', onInput); 67167 }; 67168 }); 67169 67170 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/undo-automatic-change.js 67171 /** 67172 * WordPress dependencies 67173 */ 67174 67175 67176 /** 67177 * Internal dependencies 67178 */ 67179 67180 /* harmony default export */ const undo_automatic_change = (props => element => { 67181 function onKeyDown(event) { 67182 const { 67183 keyCode 67184 } = event; 67185 if (event.defaultPrevented) { 67186 return; 67187 } 67188 if (keyCode !== external_wp_keycodes_namespaceObject.BACKSPACE && keyCode !== external_wp_keycodes_namespaceObject.ESCAPE) { 67189 return; 67190 } 67191 const { 67192 registry 67193 } = props.current; 67194 const { 67195 didAutomaticChange, 67196 getSettings 67197 } = registry.select(store); 67198 const { 67199 __experimentalUndo 67200 } = getSettings(); 67201 if (!__experimentalUndo) { 67202 return; 67203 } 67204 if (!didAutomaticChange()) { 67205 return; 67206 } 67207 event.preventDefault(); 67208 __experimentalUndo(); 67209 } 67210 element.addEventListener('keydown', onKeyDown); 67211 return () => { 67212 element.removeEventListener('keydown', onKeyDown); 67213 }; 67214 }); 67215 67216 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/utils.js 67217 /** 67218 * WordPress dependencies 67219 */ 67220 67221 67222 67223 function addActiveFormats(value, activeFormats) { 67224 if (activeFormats?.length) { 67225 let index = value.formats.length; 67226 while (index--) { 67227 value.formats[index] = [...activeFormats, ...(value.formats[index] || [])]; 67228 } 67229 } 67230 } 67231 67232 /** 67233 * Get the multiline tag based on the multiline prop. 67234 * 67235 * @param {?(string|boolean)} multiline The multiline prop. 67236 * 67237 * @return {string | undefined} The multiline tag. 67238 */ 67239 function getMultilineTag(multiline) { 67240 if (multiline !== true && multiline !== 'p' && multiline !== 'li') { 67241 return; 67242 } 67243 return multiline === true ? 'p' : multiline; 67244 } 67245 function getAllowedFormats({ 67246 allowedFormats, 67247 disableFormats 67248 }) { 67249 if (disableFormats) { 67250 return getAllowedFormats.EMPTY_ARRAY; 67251 } 67252 return allowedFormats; 67253 } 67254 getAllowedFormats.EMPTY_ARRAY = []; 67255 67256 /** 67257 * Creates a link from pasted URL. 67258 * Creates a paragraph block containing a link to the URL, and calls `onReplace`. 67259 * 67260 * @param {string} url The URL that could not be embedded. 67261 * @param {Function} onReplace Function to call with the created fallback block. 67262 */ 67263 function createLinkInParagraph(url, onReplace) { 67264 const link = /*#__PURE__*/_jsx("a", { 67265 href: url, 67266 children: url 67267 }); 67268 onReplace(createBlock('core/paragraph', { 67269 content: renderToString(link) 67270 })); 67271 } 67272 67273 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/paste-handler.js 67274 /** 67275 * WordPress dependencies 67276 */ 67277 67278 67279 67280 67281 /** 67282 * Internal dependencies 67283 */ 67284 67285 67286 67287 /** @typedef {import('@wordpress/rich-text').RichTextValue} RichTextValue */ 67288 67289 /* harmony default export */ const paste_handler = (props => element => { 67290 function _onPaste(event) { 67291 const { 67292 disableFormats, 67293 onChange, 67294 value, 67295 formatTypes, 67296 tagName, 67297 onReplace, 67298 __unstableEmbedURLOnPaste, 67299 preserveWhiteSpace, 67300 pastePlainText 67301 } = props.current; 67302 67303 // The event listener is attached to the window, so we need to check if 67304 // the target is the element or inside the element. 67305 if (!element.contains(event.target)) { 67306 return; 67307 } 67308 if (event.defaultPrevented) { 67309 return; 67310 } 67311 const { 67312 plainText, 67313 html 67314 } = getPasteEventData(event); 67315 event.preventDefault(); 67316 67317 // Allows us to ask for this information when we get a report. 67318 window.console.log('Received HTML:\n\n', html); 67319 window.console.log('Received plain text:\n\n', plainText); 67320 if (disableFormats) { 67321 onChange((0,external_wp_richText_namespaceObject.insert)(value, plainText)); 67322 return; 67323 } 67324 const isInternal = event.clipboardData.getData('rich-text') === 'true'; 67325 function pasteInline(content) { 67326 const transformed = formatTypes.reduce((accumulator, { 67327 __unstablePasteRule 67328 }) => { 67329 // Only allow one transform. 67330 if (__unstablePasteRule && accumulator === value) { 67331 accumulator = __unstablePasteRule(value, { 67332 html, 67333 plainText 67334 }); 67335 } 67336 return accumulator; 67337 }, value); 67338 if (transformed !== value) { 67339 onChange(transformed); 67340 } else { 67341 const valueToInsert = (0,external_wp_richText_namespaceObject.create)({ 67342 html: content 67343 }); 67344 addActiveFormats(valueToInsert, value.activeFormats); 67345 onChange((0,external_wp_richText_namespaceObject.insert)(value, valueToInsert)); 67346 } 67347 } 67348 67349 // If the data comes from a rich text instance, we can directly use it 67350 // without filtering the data. The filters are only meant for externally 67351 // pasted content and remove inline styles. 67352 if (isInternal) { 67353 pasteInline(html); 67354 return; 67355 } 67356 if (pastePlainText) { 67357 onChange((0,external_wp_richText_namespaceObject.insert)(value, (0,external_wp_richText_namespaceObject.create)({ 67358 text: plainText 67359 }))); 67360 return; 67361 } 67362 let mode = 'INLINE'; 67363 const trimmedPlainText = plainText.trim(); 67364 if (__unstableEmbedURLOnPaste && (0,external_wp_richText_namespaceObject.isEmpty)(value) && (0,external_wp_url_namespaceObject.isURL)(trimmedPlainText) && 67365 // For the link pasting feature, allow only http(s) protocols. 67366 /^https?:/.test(trimmedPlainText)) { 67367 mode = 'BLOCKS'; 67368 } 67369 const content = (0,external_wp_blocks_namespaceObject.pasteHandler)({ 67370 HTML: html, 67371 plainText, 67372 mode, 67373 tagName, 67374 preserveWhiteSpace 67375 }); 67376 if (typeof content === 'string') { 67377 pasteInline(content); 67378 } else if (content.length > 0) { 67379 if (onReplace && (0,external_wp_richText_namespaceObject.isEmpty)(value)) { 67380 onReplace(content, content.length - 1, -1); 67381 } 67382 } 67383 } 67384 const { 67385 defaultView 67386 } = element.ownerDocument; 67387 67388 // Attach the listener to the window so parent elements have the chance to 67389 // prevent the default behavior. 67390 defaultView.addEventListener('paste', _onPaste); 67391 return () => { 67392 defaultView.removeEventListener('paste', _onPaste); 67393 }; 67394 }); 67395 67396 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/delete.js 67397 /** 67398 * WordPress dependencies 67399 */ 67400 67401 67402 /* harmony default export */ const event_listeners_delete = (props => element => { 67403 function onKeyDown(event) { 67404 const { 67405 keyCode 67406 } = event; 67407 if (event.defaultPrevented) { 67408 return; 67409 } 67410 const { 67411 value, 67412 onMerge, 67413 onRemove 67414 } = props.current; 67415 if (keyCode === external_wp_keycodes_namespaceObject.DELETE || keyCode === external_wp_keycodes_namespaceObject.BACKSPACE) { 67416 const { 67417 start, 67418 end, 67419 text 67420 } = value; 67421 const isReverse = keyCode === external_wp_keycodes_namespaceObject.BACKSPACE; 67422 const hasActiveFormats = value.activeFormats && !!value.activeFormats.length; 67423 67424 // Only process delete if the key press occurs at an uncollapsed edge. 67425 if (!(0,external_wp_richText_namespaceObject.isCollapsed)(value) || hasActiveFormats || isReverse && start !== 0 || !isReverse && end !== text.length) { 67426 return; 67427 } 67428 if (onMerge) { 67429 onMerge(!isReverse); 67430 } 67431 67432 // Only handle remove on Backspace. This serves dual-purpose of being 67433 // an intentional user interaction distinguishing between Backspace and 67434 // Delete to remove the empty field, but also to avoid merge & remove 67435 // causing destruction of two fields (merge, then removed merged). 67436 else if (onRemove && (0,external_wp_richText_namespaceObject.isEmpty)(value) && isReverse) { 67437 onRemove(!isReverse); 67438 } 67439 event.preventDefault(); 67440 } 67441 } 67442 element.addEventListener('keydown', onKeyDown); 67443 return () => { 67444 element.removeEventListener('keydown', onKeyDown); 67445 }; 67446 }); 67447 67448 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/enter.js 67449 /** 67450 * WordPress dependencies 67451 */ 67452 67453 67454 /* harmony default export */ const enter = (props => element => { 67455 function onKeyDownDeprecated(event) { 67456 if (event.keyCode !== external_wp_keycodes_namespaceObject.ENTER) { 67457 return; 67458 } 67459 const { 67460 onReplace, 67461 onSplit 67462 } = props.current; 67463 if (onReplace && onSplit) { 67464 event.__deprecatedOnSplit = true; 67465 } 67466 } 67467 function onKeyDown(event) { 67468 if (event.defaultPrevented) { 67469 return; 67470 } 67471 67472 // The event listener is attached to the window, so we need to check if 67473 // the target is the element. 67474 if (event.target !== element) { 67475 return; 67476 } 67477 if (event.keyCode !== external_wp_keycodes_namespaceObject.ENTER) { 67478 return; 67479 } 67480 const { 67481 value, 67482 onChange, 67483 disableLineBreaks, 67484 onSplitAtEnd, 67485 onSplitAtDoubleLineEnd, 67486 registry 67487 } = props.current; 67488 event.preventDefault(); 67489 const { 67490 text, 67491 start, 67492 end 67493 } = value; 67494 if (event.shiftKey) { 67495 if (!disableLineBreaks) { 67496 onChange((0,external_wp_richText_namespaceObject.insert)(value, '\n')); 67497 } 67498 } else if (onSplitAtEnd && start === end && end === text.length) { 67499 onSplitAtEnd(); 67500 } else if ( 67501 // For some blocks it's desirable to split at the end of the 67502 // block when there are two line breaks at the end of the 67503 // block, so triple Enter exits the block. 67504 onSplitAtDoubleLineEnd && start === end && end === text.length && text.slice(-2) === '\n\n') { 67505 registry.batch(() => { 67506 const _value = { 67507 ...value 67508 }; 67509 _value.start = _value.end - 2; 67510 onChange((0,external_wp_richText_namespaceObject.remove)(_value)); 67511 onSplitAtDoubleLineEnd(); 67512 }); 67513 } else if (!disableLineBreaks) { 67514 onChange((0,external_wp_richText_namespaceObject.insert)(value, '\n')); 67515 } 67516 } 67517 const { 67518 defaultView 67519 } = element.ownerDocument; 67520 67521 // Attach the listener to the window so parent elements have the chance to 67522 // prevent the default behavior. 67523 defaultView.addEventListener('keydown', onKeyDown); 67524 element.addEventListener('keydown', onKeyDownDeprecated); 67525 return () => { 67526 defaultView.removeEventListener('keydown', onKeyDown); 67527 element.removeEventListener('keydown', onKeyDownDeprecated); 67528 }; 67529 }); 67530 67531 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/firefox-compat.js 67532 /** 67533 * Internal dependencies 67534 */ 67535 67536 /* harmony default export */ const firefox_compat = (props => element => { 67537 function onFocus() { 67538 const { 67539 registry 67540 } = props.current; 67541 if (!registry.select(store).isMultiSelecting()) { 67542 return; 67543 } 67544 67545 // This is a little hack to work around focus issues with nested 67546 // editable elements in Firefox. For some reason the editable child 67547 // element sometimes regains focus, while it should not be focusable 67548 // and focus should remain on the editable parent element. 67549 // To do: try to find the cause of the shifting focus. 67550 const parentEditable = element.parentElement.closest('[contenteditable="true"]'); 67551 if (parentEditable) { 67552 parentEditable.focus(); 67553 } 67554 } 67555 element.addEventListener('focus', onFocus); 67556 return () => { 67557 element.removeEventListener('focus', onFocus); 67558 }; 67559 }); 67560 67561 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/index.js 67562 /** 67563 * WordPress dependencies 67564 */ 67565 67566 67567 67568 /** 67569 * Internal dependencies 67570 */ 67571 67572 67573 67574 67575 67576 67577 67578 67579 67580 67581 67582 const allEventListeners = [before_input_rules, input_rules, insert_replacement_text, remove_browser_shortcuts, shortcuts, input_events, undo_automatic_change, paste_handler, event_listeners_delete, enter, firefox_compat]; 67583 function useEventListeners(props) { 67584 const propsRef = (0,external_wp_element_namespaceObject.useRef)(props); 67585 propsRef.current = props; 67586 const refEffects = (0,external_wp_element_namespaceObject.useMemo)(() => allEventListeners.map(refEffect => refEffect(propsRef)), [propsRef]); 67587 return (0,external_wp_compose_namespaceObject.useRefEffect)(element => { 67588 if (!props.isSelected) { 67589 return; 67590 } 67591 const cleanups = refEffects.map(effect => effect(element)); 67592 return () => { 67593 cleanups.forEach(cleanup => cleanup()); 67594 }; 67595 }, [refEffects, props.isSelected]); 67596 } 67597 67598 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/format-edit.js 67599 /** 67600 * WordPress dependencies 67601 */ 67602 67603 67604 67605 /** 67606 * Internal dependencies 67607 */ 67608 67609 67610 67611 const format_edit_DEFAULT_BLOCK_CONTEXT = {}; 67612 const usesContextKey = Symbol('usesContext'); 67613 function format_edit_Edit({ 67614 onChange, 67615 onFocus, 67616 value, 67617 forwardedRef, 67618 settings 67619 }) { 67620 const { 67621 name, 67622 edit: EditFunction, 67623 [usesContextKey]: usesContext 67624 } = settings; 67625 const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context); 67626 67627 // Assign context values using the block type's declared context needs. 67628 const context = (0,external_wp_element_namespaceObject.useMemo)(() => { 67629 return usesContext ? Object.fromEntries(Object.entries(blockContext).filter(([key]) => usesContext.includes(key))) : format_edit_DEFAULT_BLOCK_CONTEXT; 67630 }, [usesContext, blockContext]); 67631 if (!EditFunction) { 67632 return null; 67633 } 67634 const activeFormat = (0,external_wp_richText_namespaceObject.getActiveFormat)(value, name); 67635 const isActive = activeFormat !== undefined; 67636 const activeObject = (0,external_wp_richText_namespaceObject.getActiveObject)(value); 67637 const isObjectActive = activeObject !== undefined && activeObject.type === name; 67638 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditFunction, { 67639 isActive: isActive, 67640 activeAttributes: isActive ? activeFormat.attributes || {} : {}, 67641 isObjectActive: isObjectActive, 67642 activeObjectAttributes: isObjectActive ? activeObject.attributes || {} : {}, 67643 value: value, 67644 onChange: onChange, 67645 onFocus: onFocus, 67646 contentRef: forwardedRef, 67647 context: context 67648 }, name); 67649 } 67650 function FormatEdit({ 67651 formatTypes, 67652 ...props 67653 }) { 67654 return formatTypes.map(settings => /*#__PURE__*/(0,external_React_.createElement)(format_edit_Edit, { 67655 settings: settings, 67656 ...props, 67657 key: settings.name 67658 })); 67659 } 67660 67661 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/content.js 67662 /** 67663 * WordPress dependencies 67664 */ 67665 67666 67667 67668 67669 /** 67670 * Internal dependencies 67671 */ 67672 67673 67674 /** 67675 * Internal dependencies 67676 */ 67677 67678 67679 function valueToHTMLString(value, multiline) { 67680 if (rich_text.isEmpty(value)) { 67681 const multilineTag = getMultilineTag(multiline); 67682 return multilineTag ? `<$multilineTag}></$multilineTag}>` : ''; 67683 } 67684 if (Array.isArray(value)) { 67685 external_wp_deprecated_default()('wp.blockEditor.RichText value prop as children type', { 67686 since: '6.1', 67687 version: '6.3', 67688 alternative: 'value prop as string', 67689 link: 'https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/' 67690 }); 67691 return external_wp_blocks_namespaceObject.children.toHTML(value); 67692 } 67693 67694 // To do: deprecate string type. 67695 if (typeof value === 'string') { 67696 return value; 67697 } 67698 67699 // To do: create a toReactComponent method on RichTextData, which we 67700 // might in the future also use for the editable tree. See 67701 // https://github.com/WordPress/gutenberg/pull/41655. 67702 return value.toHTMLString(); 67703 } 67704 function Content({ 67705 value, 67706 tagName: Tag, 67707 multiline, 67708 format, 67709 ...props 67710 }) { 67711 value = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.RawHTML, { 67712 children: valueToHTMLString(value, multiline) 67713 }); 67714 return Tag ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tag, { 67715 ...props, 67716 children: value 67717 }) : value; 67718 } 67719 67720 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/multiline.js 67721 /** 67722 * WordPress dependencies 67723 */ 67724 67725 67726 67727 67728 67729 67730 /** 67731 * Internal dependencies 67732 */ 67733 67734 67735 67736 67737 67738 function RichTextMultiline({ 67739 children, 67740 identifier, 67741 tagName: TagName = 'div', 67742 value = '', 67743 onChange, 67744 multiline, 67745 ...props 67746 }, forwardedRef) { 67747 external_wp_deprecated_default()('wp.blockEditor.RichText multiline prop', { 67748 since: '6.1', 67749 version: '6.3', 67750 alternative: 'nested blocks (InnerBlocks)', 67751 link: 'https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/nested-blocks-inner-blocks/' 67752 }); 67753 const { 67754 clientId 67755 } = useBlockEditContext(); 67756 const { 67757 getSelectionStart, 67758 getSelectionEnd 67759 } = (0,external_wp_data_namespaceObject.useSelect)(store); 67760 const { 67761 selectionChange 67762 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 67763 const multilineTagName = getMultilineTag(multiline); 67764 value = value || `<$multilineTagName}></$multilineTagName}>`; 67765 const padded = `</$multilineTagName}>$value}<$multilineTagName}>`; 67766 const values = padded.split(`</$multilineTagName}><$multilineTagName}>`); 67767 values.shift(); 67768 values.pop(); 67769 function _onChange(newValues) { 67770 onChange(`<$multilineTagName}>$newValues.join(`</$multilineTagName}><$multilineTagName}>`)}</$multilineTagName}>`); 67771 } 67772 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TagName, { 67773 ref: forwardedRef, 67774 children: values.map((_value, index) => { 67775 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RichTextWrapper, { 67776 identifier: `$identifier}-$index}`, 67777 tagName: multilineTagName, 67778 value: _value, 67779 onChange: newValue => { 67780 const newValues = values.slice(); 67781 newValues[index] = newValue; 67782 _onChange(newValues); 67783 }, 67784 isSelected: undefined, 67785 onKeyDown: event => { 67786 if (event.keyCode !== external_wp_keycodes_namespaceObject.ENTER) { 67787 return; 67788 } 67789 event.preventDefault(); 67790 const { 67791 offset: start 67792 } = getSelectionStart(); 67793 const { 67794 offset: end 67795 } = getSelectionEnd(); 67796 67797 // Cannot split if there is no selection. 67798 if (typeof start !== 'number' || typeof end !== 'number') { 67799 return; 67800 } 67801 const richTextValue = (0,external_wp_richText_namespaceObject.create)({ 67802 html: _value 67803 }); 67804 richTextValue.start = start; 67805 richTextValue.end = end; 67806 const array = (0,external_wp_richText_namespaceObject.split)(richTextValue).map(v => (0,external_wp_richText_namespaceObject.toHTMLString)({ 67807 value: v 67808 })); 67809 const newValues = values.slice(); 67810 newValues.splice(index, 1, ...array); 67811 _onChange(newValues); 67812 selectionChange(clientId, `$identifier}-$index + 1}`, 0, 0); 67813 }, 67814 onMerge: forward => { 67815 const newValues = values.slice(); 67816 let offset = 0; 67817 if (forward) { 67818 if (!newValues[index + 1]) { 67819 return; 67820 } 67821 newValues.splice(index, 2, newValues[index] + newValues[index + 1]); 67822 offset = newValues[index].length - 1; 67823 } else { 67824 if (!newValues[index - 1]) { 67825 return; 67826 } 67827 newValues.splice(index - 1, 2, newValues[index - 1] + newValues[index]); 67828 offset = newValues[index - 1].length - 1; 67829 } 67830 _onChange(newValues); 67831 selectionChange(clientId, `$identifier}-$index - (forward ? 0 : 1)}`, offset, offset); 67832 }, 67833 ...props 67834 }, index); 67835 }) 67836 }); 67837 } 67838 /* harmony default export */ const multiline = ((0,external_wp_element_namespaceObject.forwardRef)(RichTextMultiline)); 67839 67840 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/with-deprecations.js 67841 /** 67842 * WordPress dependencies 67843 */ 67844 67845 67846 67847 67848 67849 /** 67850 * Internal dependencies 67851 */ 67852 67853 67854 function withDeprecations(Component) { 67855 return (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => { 67856 let value = props.value; 67857 let onChange = props.onChange; 67858 67859 // Handle deprecated format. 67860 if (Array.isArray(value)) { 67861 external_wp_deprecated_default()('wp.blockEditor.RichText value prop as children type', { 67862 since: '6.1', 67863 version: '6.3', 67864 alternative: 'value prop as string', 67865 link: 'https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/' 67866 }); 67867 value = external_wp_blocks_namespaceObject.children.toHTML(props.value); 67868 onChange = newValue => props.onChange(external_wp_blocks_namespaceObject.children.fromDOM((0,external_wp_richText_namespaceObject.__unstableCreateElement)(document, newValue).childNodes)); 67869 } 67870 const NewComponent = props.multiline ? multiline : Component; 67871 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(NewComponent, { 67872 ...props, 67873 value: value, 67874 onChange: onChange, 67875 ref: ref 67876 }); 67877 }); 67878 } 67879 67880 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/index.js 67881 /** 67882 * External dependencies 67883 */ 67884 67885 67886 /** 67887 * WordPress dependencies 67888 */ 67889 67890 67891 67892 67893 67894 67895 67896 67897 67898 /** 67899 * Internal dependencies 67900 */ 67901 67902 67903 67904 67905 67906 67907 67908 67909 67910 67911 67912 67913 67914 67915 67916 67917 67918 const keyboardShortcutContext = (0,external_wp_element_namespaceObject.createContext)(); 67919 const inputEventContext = (0,external_wp_element_namespaceObject.createContext)(); 67920 const instanceIdKey = Symbol('instanceId'); 67921 67922 /** 67923 * Removes props used for the native version of RichText so that they are not 67924 * passed to the DOM element and log warnings. 67925 * 67926 * @param {Object} props Props to filter. 67927 * 67928 * @return {Object} Filtered props. 67929 */ 67930 function removeNativeProps(props) { 67931 const { 67932 __unstableMobileNoFocusOnMount, 67933 deleteEnter, 67934 placeholderTextColor, 67935 textAlign, 67936 selectionColor, 67937 tagsToEliminate, 67938 disableEditingMenu, 67939 fontSize, 67940 fontFamily, 67941 fontWeight, 67942 fontStyle, 67943 minWidth, 67944 maxWidth, 67945 disableSuggestions, 67946 disableAutocorrection, 67947 ...restProps 67948 } = props; 67949 return restProps; 67950 } 67951 function RichTextWrapper({ 67952 children, 67953 tagName = 'div', 67954 value: adjustedValue = '', 67955 onChange: adjustedOnChange, 67956 isSelected: originalIsSelected, 67957 multiline, 67958 inlineToolbar, 67959 wrapperClassName, 67960 autocompleters, 67961 onReplace, 67962 placeholder, 67963 allowedFormats, 67964 withoutInteractiveFormatting, 67965 onRemove, 67966 onMerge, 67967 onSplit, 67968 __unstableOnSplitAtEnd: onSplitAtEnd, 67969 __unstableOnSplitAtDoubleLineEnd: onSplitAtDoubleLineEnd, 67970 identifier, 67971 preserveWhiteSpace, 67972 __unstablePastePlainText: pastePlainText, 67973 __unstableEmbedURLOnPaste, 67974 __unstableDisableFormats: disableFormats, 67975 disableLineBreaks, 67976 __unstableAllowPrefixTransformations, 67977 readOnly, 67978 ...props 67979 }, forwardedRef) { 67980 props = removeNativeProps(props); 67981 if (onSplit) { 67982 external_wp_deprecated_default()('wp.blockEditor.RichText onSplit prop', { 67983 since: '6.4', 67984 alternative: 'block.json support key: "splitting"' 67985 }); 67986 } 67987 const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(RichTextWrapper); 67988 const anchorRef = (0,external_wp_element_namespaceObject.useRef)(); 67989 const context = useBlockEditContext(); 67990 const { 67991 clientId, 67992 isSelected: isBlockSelected, 67993 name: blockName 67994 } = context; 67995 const blockBindings = context[blockBindingsKey]; 67996 const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context); 67997 const registry = (0,external_wp_data_namespaceObject.useRegistry)(); 67998 const selector = select => { 67999 // Avoid subscribing to the block editor store if the block is not 68000 // selected. 68001 if (!isBlockSelected) { 68002 return { 68003 isSelected: false 68004 }; 68005 } 68006 const { 68007 getSelectionStart, 68008 getSelectionEnd 68009 } = select(store); 68010 const selectionStart = getSelectionStart(); 68011 const selectionEnd = getSelectionEnd(); 68012 let isSelected; 68013 if (originalIsSelected === undefined) { 68014 isSelected = selectionStart.clientId === clientId && selectionEnd.clientId === clientId && (identifier ? selectionStart.attributeKey === identifier : selectionStart[instanceIdKey] === instanceId); 68015 } else if (originalIsSelected) { 68016 isSelected = selectionStart.clientId === clientId; 68017 } 68018 return { 68019 selectionStart: isSelected ? selectionStart.offset : undefined, 68020 selectionEnd: isSelected ? selectionEnd.offset : undefined, 68021 isSelected 68022 }; 68023 }; 68024 const { 68025 selectionStart, 68026 selectionEnd, 68027 isSelected 68028 } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId, identifier, instanceId, originalIsSelected, isBlockSelected]); 68029 const { 68030 disableBoundBlock, 68031 bindingsPlaceholder, 68032 bindingsLabel 68033 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 68034 var _fieldsList$relatedBi; 68035 if (!blockBindings?.[identifier] || !canBindBlock(blockName)) { 68036 return {}; 68037 } 68038 const relatedBinding = blockBindings[identifier]; 68039 const blockBindingsSource = (0,external_wp_blocks_namespaceObject.getBlockBindingsSource)(relatedBinding.source); 68040 const blockBindingsContext = {}; 68041 if (blockBindingsSource?.usesContext?.length) { 68042 for (const key of blockBindingsSource.usesContext) { 68043 blockBindingsContext[key] = blockContext[key]; 68044 } 68045 } 68046 const _disableBoundBlock = !blockBindingsSource?.canUserEditValue?.({ 68047 select, 68048 context: blockBindingsContext, 68049 args: relatedBinding.args 68050 }); 68051 68052 // Don't modify placeholders if value is not empty. 68053 if (adjustedValue.length > 0) { 68054 return { 68055 disableBoundBlock: _disableBoundBlock, 68056 // Null values will make them fall back to the default behavior. 68057 bindingsPlaceholder: null, 68058 bindingsLabel: null 68059 }; 68060 } 68061 const { 68062 getBlockAttributes 68063 } = select(store); 68064 const blockAttributes = getBlockAttributes(clientId); 68065 const fieldsList = blockBindingsSource?.getFieldsList?.({ 68066 select, 68067 context: blockBindingsContext 68068 }); 68069 const bindingKey = (_fieldsList$relatedBi = fieldsList?.[relatedBinding?.args?.key]?.label) !== null && _fieldsList$relatedBi !== void 0 ? _fieldsList$relatedBi : blockBindingsSource?.label; 68070 const _bindingsPlaceholder = _disableBoundBlock ? bindingKey : (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: connected field label or source label */ 68071 (0,external_wp_i18n_namespaceObject.__)('Add %s'), bindingKey); 68072 const _bindingsLabel = _disableBoundBlock ? relatedBinding?.args?.key || blockBindingsSource?.label : (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: source label or key */ 68073 (0,external_wp_i18n_namespaceObject.__)('Empty %s; start writing to edit its value'), relatedBinding?.args?.key || blockBindingsSource?.label); 68074 return { 68075 disableBoundBlock: _disableBoundBlock, 68076 bindingsPlaceholder: blockAttributes?.placeholder || _bindingsPlaceholder, 68077 bindingsLabel: _bindingsLabel 68078 }; 68079 }, [blockBindings, identifier, blockName, blockContext, adjustedValue]); 68080 const shouldDisableEditing = readOnly || disableBoundBlock; 68081 const { 68082 getSelectionStart, 68083 getSelectionEnd, 68084 getBlockRootClientId 68085 } = (0,external_wp_data_namespaceObject.useSelect)(store); 68086 const { 68087 selectionChange 68088 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 68089 const adjustedAllowedFormats = getAllowedFormats({ 68090 allowedFormats, 68091 disableFormats 68092 }); 68093 const hasFormats = !adjustedAllowedFormats || adjustedAllowedFormats.length > 0; 68094 const onSelectionChange = (0,external_wp_element_namespaceObject.useCallback)((start, end) => { 68095 const selection = {}; 68096 const unset = start === undefined && end === undefined; 68097 const baseSelection = { 68098 clientId, 68099 [identifier ? 'attributeKey' : instanceIdKey]: identifier ? identifier : instanceId 68100 }; 68101 if (typeof start === 'number' || unset) { 68102 // If we are only setting the start (or the end below), which 68103 // means a partial selection, and we're not updating a selection 68104 // with the same client ID, abort. This means the selected block 68105 // is a parent block. 68106 if (end === undefined && getBlockRootClientId(clientId) !== getBlockRootClientId(getSelectionEnd().clientId)) { 68107 return; 68108 } 68109 selection.start = { 68110 ...baseSelection, 68111 offset: start 68112 }; 68113 } 68114 if (typeof end === 'number' || unset) { 68115 if (start === undefined && getBlockRootClientId(clientId) !== getBlockRootClientId(getSelectionStart().clientId)) { 68116 return; 68117 } 68118 selection.end = { 68119 ...baseSelection, 68120 offset: end 68121 }; 68122 } 68123 selectionChange(selection); 68124 }, [clientId, getBlockRootClientId, getSelectionEnd, getSelectionStart, identifier, instanceId, selectionChange]); 68125 const { 68126 formatTypes, 68127 prepareHandlers, 68128 valueHandlers, 68129 changeHandlers, 68130 dependencies 68131 } = useFormatTypes({ 68132 clientId, 68133 identifier, 68134 withoutInteractiveFormatting, 68135 allowedFormats: adjustedAllowedFormats 68136 }); 68137 function addEditorOnlyFormats(value) { 68138 return valueHandlers.reduce((accumulator, fn) => fn(accumulator, value.text), value.formats); 68139 } 68140 function removeEditorOnlyFormats(value) { 68141 formatTypes.forEach(formatType => { 68142 // Remove formats created by prepareEditableTree, because they are editor only. 68143 if (formatType.__experimentalCreatePrepareEditableTree) { 68144 value = (0,external_wp_richText_namespaceObject.removeFormat)(value, formatType.name, 0, value.text.length); 68145 } 68146 }); 68147 return value.formats; 68148 } 68149 function addInvisibleFormats(value) { 68150 return prepareHandlers.reduce((accumulator, fn) => fn(accumulator, value.text), value.formats); 68151 } 68152 const { 68153 value, 68154 getValue, 68155 onChange, 68156 ref: richTextRef 68157 } = (0,external_wp_richText_namespaceObject.__unstableUseRichText)({ 68158 value: adjustedValue, 68159 onChange(html, { 68160 __unstableFormats, 68161 __unstableText 68162 }) { 68163 adjustedOnChange(html); 68164 Object.values(changeHandlers).forEach(changeHandler => { 68165 changeHandler(__unstableFormats, __unstableText); 68166 }); 68167 }, 68168 selectionStart, 68169 selectionEnd, 68170 onSelectionChange, 68171 placeholder: bindingsPlaceholder || placeholder, 68172 __unstableIsSelected: isSelected, 68173 __unstableDisableFormats: disableFormats, 68174 preserveWhiteSpace, 68175 __unstableDependencies: [...dependencies, tagName], 68176 __unstableAfterParse: addEditorOnlyFormats, 68177 __unstableBeforeSerialize: removeEditorOnlyFormats, 68178 __unstableAddInvisibleFormats: addInvisibleFormats 68179 }); 68180 const autocompleteProps = useBlockEditorAutocompleteProps({ 68181 onReplace, 68182 completers: autocompleters, 68183 record: value, 68184 onChange 68185 }); 68186 useMarkPersistent({ 68187 html: adjustedValue, 68188 value 68189 }); 68190 const keyboardShortcuts = (0,external_wp_element_namespaceObject.useRef)(new Set()); 68191 const inputEvents = (0,external_wp_element_namespaceObject.useRef)(new Set()); 68192 function onFocus() { 68193 anchorRef.current?.focus(); 68194 } 68195 const TagName = tagName; 68196 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 68197 children: [isSelected && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(keyboardShortcutContext.Provider, { 68198 value: keyboardShortcuts, 68199 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inputEventContext.Provider, { 68200 value: inputEvents, 68201 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Popover.__unstableSlotNameProvider, { 68202 value: "__unstable-block-tools-after", 68203 children: [children && children({ 68204 value, 68205 onChange, 68206 onFocus 68207 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FormatEdit, { 68208 value: value, 68209 onChange: onChange, 68210 onFocus: onFocus, 68211 formatTypes: formatTypes, 68212 forwardedRef: anchorRef 68213 })] 68214 }) 68215 }) 68216 }), isSelected && hasFormats && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(format_toolbar_container, { 68217 inline: inlineToolbar, 68218 editableContentElement: anchorRef.current 68219 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TagName 68220 // Overridable props. 68221 , { 68222 role: "textbox", 68223 "aria-multiline": !disableLineBreaks, 68224 "aria-readonly": shouldDisableEditing, 68225 ...props, 68226 "aria-label": bindingsLabel || props['aria-label'] || placeholder, 68227 ...autocompleteProps, 68228 ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([ 68229 // Rich text ref must be first because its focus listener 68230 // must be set up before any other ref calls .focus() on 68231 // mount. 68232 richTextRef, forwardedRef, autocompleteProps.ref, props.ref, useEventListeners({ 68233 registry, 68234 getValue, 68235 onChange, 68236 __unstableAllowPrefixTransformations, 68237 formatTypes, 68238 onReplace, 68239 selectionChange, 68240 isSelected, 68241 disableFormats, 68242 value, 68243 tagName, 68244 onSplit, 68245 __unstableEmbedURLOnPaste, 68246 pastePlainText, 68247 onMerge, 68248 onRemove, 68249 removeEditorOnlyFormats, 68250 disableLineBreaks, 68251 onSplitAtEnd, 68252 onSplitAtDoubleLineEnd, 68253 keyboardShortcuts, 68254 inputEvents 68255 }), anchorRef]), 68256 contentEditable: !shouldDisableEditing, 68257 suppressContentEditableWarning: true, 68258 className: dist_clsx('block-editor-rich-text__editable', props.className, 'rich-text') 68259 // Setting tabIndex to 0 is unnecessary, the element is already 68260 // focusable because it's contentEditable. This also fixes a 68261 // Safari bug where it's not possible to Shift+Click multi 68262 // select blocks when Shift Clicking into an element with 68263 // tabIndex because Safari will focus the element. However, 68264 // Safari will correctly ignore nested contentEditable elements. 68265 , 68266 tabIndex: props.tabIndex === 0 && !shouldDisableEditing ? null : props.tabIndex, 68267 "data-wp-block-attribute-key": identifier 68268 })] 68269 }); 68270 } 68271 68272 // This is the private API for the RichText component. 68273 // It allows access to all props, not just the public ones. 68274 const PrivateRichText = withDeprecations((0,external_wp_element_namespaceObject.forwardRef)(RichTextWrapper)); 68275 PrivateRichText.Content = Content; 68276 PrivateRichText.isEmpty = value => { 68277 return !value || value.length === 0; 68278 }; 68279 68280 // This is the public API for the RichText component. 68281 // We wrap the PrivateRichText component to hide some props from the public API. 68282 /** 68283 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/rich-text/README.md 68284 */ 68285 const PublicForwardedRichTextContainer = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => { 68286 const context = useBlockEditContext(); 68287 const isPreviewMode = context[isPreviewModeKey]; 68288 if (isPreviewMode) { 68289 // Remove all non-content props. 68290 const { 68291 children, 68292 tagName: Tag = 'div', 68293 value, 68294 onChange, 68295 isSelected, 68296 multiline, 68297 inlineToolbar, 68298 wrapperClassName, 68299 autocompleters, 68300 onReplace, 68301 placeholder, 68302 allowedFormats, 68303 withoutInteractiveFormatting, 68304 onRemove, 68305 onMerge, 68306 onSplit, 68307 __unstableOnSplitAtEnd, 68308 __unstableOnSplitAtDoubleLineEnd, 68309 identifier, 68310 preserveWhiteSpace, 68311 __unstablePastePlainText, 68312 __unstableEmbedURLOnPaste, 68313 __unstableDisableFormats, 68314 disableLineBreaks, 68315 __unstableAllowPrefixTransformations, 68316 readOnly, 68317 ...contentProps 68318 } = removeNativeProps(props); 68319 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tag, { 68320 ...contentProps, 68321 dangerouslySetInnerHTML: { 68322 __html: valueToHTMLString(value, multiline) 68323 } 68324 }); 68325 } 68326 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateRichText, { 68327 ref: ref, 68328 ...props, 68329 readOnly: false 68330 }); 68331 }); 68332 PublicForwardedRichTextContainer.Content = Content; 68333 PublicForwardedRichTextContainer.isEmpty = value => { 68334 return !value || value.length === 0; 68335 }; 68336 /* harmony default export */ const rich_text = (PublicForwardedRichTextContainer); 68337 68338 68339 68340 68341 ;// ./node_modules/@wordpress/block-editor/build-module/components/editable-text/index.js 68342 /** 68343 * WordPress dependencies 68344 */ 68345 68346 68347 /** 68348 * Internal dependencies 68349 */ 68350 68351 68352 const EditableText = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => { 68353 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(rich_text, { 68354 ref: ref, 68355 ...props, 68356 __unstableDisableFormats: true 68357 }); 68358 }); 68359 EditableText.Content = ({ 68360 value = '', 68361 tagName: Tag = 'div', 68362 ...props 68363 }) => { 68364 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tag, { 68365 ...props, 68366 children: value 68367 }); 68368 }; 68369 68370 /** 68371 * Renders an editable text input in which text formatting is not allowed. 68372 */ 68373 /* harmony default export */ const editable_text = (EditableText); 68374 68375 ;// ./node_modules/@wordpress/block-editor/build-module/components/plain-text/index.js 68376 /** 68377 * External dependencies 68378 */ 68379 68380 68381 68382 /** 68383 * WordPress dependencies 68384 */ 68385 68386 68387 /** 68388 * Internal dependencies 68389 */ 68390 68391 68392 /** 68393 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/plain-text/README.md 68394 */ 68395 68396 const PlainText = (0,external_wp_element_namespaceObject.forwardRef)(({ 68397 __experimentalVersion, 68398 ...props 68399 }, ref) => { 68400 if (__experimentalVersion === 2) { 68401 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editable_text, { 68402 ref: ref, 68403 ...props 68404 }); 68405 } 68406 const { 68407 className, 68408 onChange, 68409 ...remainingProps 68410 } = props; 68411 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(lib/* default */.A, { 68412 ref: ref, 68413 className: dist_clsx('block-editor-plain-text', className), 68414 onChange: event => onChange(event.target.value), 68415 ...remainingProps 68416 }); 68417 }); 68418 /* harmony default export */ const plain_text = (PlainText); 68419 68420 ;// ./node_modules/@wordpress/block-editor/build-module/components/responsive-block-control/label.js 68421 /** 68422 * WordPress dependencies 68423 */ 68424 68425 68426 68427 68428 68429 68430 function ResponsiveBlockControlLabel({ 68431 property, 68432 viewport, 68433 desc 68434 }) { 68435 const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(ResponsiveBlockControlLabel); 68436 const accessibleLabel = desc || (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: 1: property name. 2: viewport name. */ 68437 (0,external_wp_i18n_namespaceObject._x)('Controls the %1$s property for %2$s viewports.', 'Text labelling a interface as controlling a given layout property (eg: margin) for a given screen size.'), property, viewport.label); 68438 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 68439 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 68440 "aria-describedby": `rbc-desc-$instanceId}`, 68441 children: viewport.label 68442 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, { 68443 as: "span", 68444 id: `rbc-desc-$instanceId}`, 68445 children: accessibleLabel 68446 })] 68447 }); 68448 } 68449 68450 ;// ./node_modules/@wordpress/block-editor/build-module/components/responsive-block-control/index.js 68451 /** 68452 * External dependencies 68453 */ 68454 68455 68456 /** 68457 * WordPress dependencies 68458 */ 68459 68460 68461 68462 68463 /** 68464 * Internal dependencies 68465 */ 68466 68467 68468 68469 function ResponsiveBlockControl(props) { 68470 const { 68471 title, 68472 property, 68473 toggleLabel, 68474 onIsResponsiveChange, 68475 renderDefaultControl, 68476 renderResponsiveControls, 68477 isResponsive = false, 68478 defaultLabel = { 68479 id: 'all', 68480 label: (0,external_wp_i18n_namespaceObject._x)('All', 'screen sizes') 68481 }, 68482 viewports = [{ 68483 id: 'small', 68484 label: (0,external_wp_i18n_namespaceObject.__)('Small screens') 68485 }, { 68486 id: 'medium', 68487 label: (0,external_wp_i18n_namespaceObject.__)('Medium screens') 68488 }, { 68489 id: 'large', 68490 label: (0,external_wp_i18n_namespaceObject.__)('Large screens') 68491 }] 68492 } = props; 68493 if (!title || !property || !renderDefaultControl) { 68494 return null; 68495 } 68496 const toggleControlLabel = toggleLabel || (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %s: Property value for the control (eg: margin, padding, etc.). */ 68497 (0,external_wp_i18n_namespaceObject.__)('Use the same %s on all screen sizes.'), property); 68498 const toggleHelpText = (0,external_wp_i18n_namespaceObject.__)('Toggle between using the same value for all screen sizes or using a unique value per screen size.'); 68499 const defaultControl = renderDefaultControl( /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ResponsiveBlockControlLabel, { 68500 property: property, 68501 viewport: defaultLabel 68502 }), defaultLabel); 68503 const defaultResponsiveControls = () => { 68504 return viewports.map(viewport => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.Fragment, { 68505 children: renderDefaultControl( /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ResponsiveBlockControlLabel, { 68506 property: property, 68507 viewport: viewport 68508 }), viewport) 68509 }, viewport.id)); 68510 }; 68511 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", { 68512 className: "block-editor-responsive-block-control", 68513 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("legend", { 68514 className: "block-editor-responsive-block-control__title", 68515 children: title 68516 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 68517 className: "block-editor-responsive-block-control__inner", 68518 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, { 68519 __nextHasNoMarginBottom: true, 68520 className: "block-editor-responsive-block-control__toggle", 68521 label: toggleControlLabel, 68522 checked: !isResponsive, 68523 onChange: onIsResponsiveChange, 68524 help: toggleHelpText 68525 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 68526 className: dist_clsx('block-editor-responsive-block-control__group', { 68527 'is-responsive': isResponsive 68528 }), 68529 children: [!isResponsive && defaultControl, isResponsive && (renderResponsiveControls ? renderResponsiveControls(viewports) : defaultResponsiveControls())] 68530 })] 68531 })] 68532 }); 68533 } 68534 /* harmony default export */ const responsive_block_control = (ResponsiveBlockControl); 68535 68536 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/shortcut.js 68537 /** 68538 * WordPress dependencies 68539 */ 68540 68541 68542 68543 /** 68544 * Internal dependencies 68545 */ 68546 68547 function RichTextShortcut({ 68548 character, 68549 type, 68550 onUse 68551 }) { 68552 const keyboardShortcuts = (0,external_wp_element_namespaceObject.useContext)(keyboardShortcutContext); 68553 const onUseRef = (0,external_wp_element_namespaceObject.useRef)(); 68554 onUseRef.current = onUse; 68555 (0,external_wp_element_namespaceObject.useEffect)(() => { 68556 function callback(event) { 68557 if (external_wp_keycodes_namespaceObject.isKeyboardEvent[type](event, character)) { 68558 onUseRef.current(); 68559 event.preventDefault(); 68560 } 68561 } 68562 keyboardShortcuts.current.add(callback); 68563 return () => { 68564 keyboardShortcuts.current.delete(callback); 68565 }; 68566 }, [character, type]); 68567 return null; 68568 } 68569 68570 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/toolbar-button.js 68571 /** 68572 * WordPress dependencies 68573 */ 68574 68575 68576 68577 function RichTextToolbarButton({ 68578 name, 68579 shortcutType, 68580 shortcutCharacter, 68581 ...props 68582 }) { 68583 let shortcut; 68584 let fillName = 'RichText.ToolbarControls'; 68585 if (name) { 68586 fillName += `.$name}`; 68587 } 68588 if (shortcutType && shortcutCharacter) { 68589 shortcut = external_wp_keycodes_namespaceObject.displayShortcut[shortcutType](shortcutCharacter); 68590 } 68591 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Fill, { 68592 name: fillName, 68593 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 68594 ...props, 68595 shortcut: shortcut 68596 }) 68597 }); 68598 } 68599 68600 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/input-event.js 68601 /** 68602 * WordPress dependencies 68603 */ 68604 68605 68606 /** 68607 * Internal dependencies 68608 */ 68609 68610 function __unstableRichTextInputEvent({ 68611 inputType, 68612 onInput 68613 }) { 68614 const callbacks = (0,external_wp_element_namespaceObject.useContext)(inputEventContext); 68615 const onInputRef = (0,external_wp_element_namespaceObject.useRef)(); 68616 onInputRef.current = onInput; 68617 (0,external_wp_element_namespaceObject.useEffect)(() => { 68618 function callback(event) { 68619 if (event.inputType === inputType) { 68620 onInputRef.current(); 68621 event.preventDefault(); 68622 } 68623 } 68624 callbacks.current.add(callback); 68625 return () => { 68626 callbacks.current.delete(callback); 68627 }; 68628 }, [inputType]); 68629 return null; 68630 } 68631 68632 ;// ./node_modules/@wordpress/block-editor/build-module/components/tool-selector/index.js 68633 /** 68634 * WordPress dependencies 68635 */ 68636 68637 68638 68639 68640 68641 68642 /** 68643 * Internal dependencies 68644 */ 68645 68646 68647 68648 68649 68650 const selectIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, { 68651 xmlns: "http://www.w3.org/2000/svg", 68652 width: "24", 68653 height: "24", 68654 viewBox: "0 0 24 24", 68655 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, { 68656 d: "M9.4 20.5L5.2 3.8l14.6 9-2 .3c-.2 0-.4.1-.7.1-.9.2-1.6.3-2.2.5-.8.3-1.4.5-1.8.8-.4.3-.8.8-1.3 1.5-.4.5-.8 1.2-1.2 2l-.3.6-.9 1.9zM7.6 7.1l2.4 9.3c.2-.4.5-.8.7-1.1.6-.8 1.1-1.4 1.6-1.8.5-.4 1.3-.8 2.2-1.1l1.2-.3-8.1-5z" 68657 }) 68658 }); 68659 function ToolSelector(props, ref) { 68660 const mode = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).__unstableGetEditorMode(), []); 68661 const { 68662 resetZoomLevel, 68663 __unstableSetEditorMode 68664 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 68665 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { 68666 renderToggle: ({ 68667 isOpen, 68668 onToggle 68669 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 68670 size: "compact", 68671 ...props, 68672 ref: ref, 68673 icon: mode === 'navigation' ? selectIcon : edit, 68674 "aria-expanded": isOpen, 68675 "aria-haspopup": "true", 68676 onClick: onToggle 68677 /* translators: button label text should, if possible, be under 16 characters. */, 68678 label: (0,external_wp_i18n_namespaceObject.__)('Tools') 68679 }), 68680 popoverProps: { 68681 placement: 'bottom-start' 68682 }, 68683 renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 68684 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.NavigableMenu, { 68685 role: "menu", 68686 "aria-label": (0,external_wp_i18n_namespaceObject.__)('Tools'), 68687 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItemsChoice, { 68688 value: mode === 'navigation' ? 'navigation' : 'edit', 68689 onSelect: newMode => { 68690 resetZoomLevel(); 68691 __unstableSetEditorMode(newMode); 68692 }, 68693 choices: [{ 68694 value: 'edit', 68695 label: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 68696 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 68697 icon: edit 68698 }), (0,external_wp_i18n_namespaceObject.__)('Edit')] 68699 }) 68700 }, { 68701 value: 'navigation', 68702 label: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 68703 children: [selectIcon, (0,external_wp_i18n_namespaceObject.__)('Select')] 68704 }) 68705 }] 68706 }) 68707 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 68708 className: "block-editor-tool-selector__help", 68709 children: (0,external_wp_i18n_namespaceObject.__)('Tools provide different interactions for selecting, navigating, and editing blocks. Toggle between select and edit by pressing Escape and Enter.') 68710 })] 68711 }) 68712 }); 68713 } 68714 /* harmony default export */ const tool_selector = ((0,external_wp_element_namespaceObject.forwardRef)(ToolSelector)); 68715 68716 ;// ./node_modules/@wordpress/block-editor/build-module/components/unit-control/index.js 68717 /** 68718 * WordPress dependencies 68719 */ 68720 68721 68722 /** 68723 * Internal dependencies 68724 */ 68725 68726 68727 function UnitControl({ 68728 units: unitsProp, 68729 ...props 68730 }) { 68731 const [availableUnits] = use_settings_useSettings('spacing.units'); 68732 const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({ 68733 availableUnits: availableUnits || ['%', 'px', 'em', 'rem', 'vw'], 68734 units: unitsProp 68735 }); 68736 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 68737 units: units, 68738 ...props 68739 }); 68740 } 68741 68742 ;// ./node_modules/@wordpress/icons/build-module/library/arrow-left.js 68743 /** 68744 * WordPress dependencies 68745 */ 68746 68747 68748 const arrowLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 68749 xmlns: "http://www.w3.org/2000/svg", 68750 viewBox: "0 0 24 24", 68751 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 68752 d: "M20 11.2H6.8l3.7-3.7-1-1L3.9 12l5.6 5.5 1-1-3.7-3.7H20z" 68753 }) 68754 }); 68755 /* harmony default export */ const arrow_left = (arrowLeft); 68756 68757 ;// ./node_modules/@wordpress/block-editor/build-module/components/url-input/button.js 68758 /** 68759 * WordPress dependencies 68760 */ 68761 68762 68763 68764 68765 68766 /** 68767 * Internal dependencies 68768 */ 68769 68770 68771 68772 class URLInputButton extends external_wp_element_namespaceObject.Component { 68773 constructor() { 68774 super(...arguments); 68775 this.toggle = this.toggle.bind(this); 68776 this.submitLink = this.submitLink.bind(this); 68777 this.state = { 68778 expanded: false 68779 }; 68780 } 68781 toggle() { 68782 this.setState({ 68783 expanded: !this.state.expanded 68784 }); 68785 } 68786 submitLink(event) { 68787 event.preventDefault(); 68788 this.toggle(); 68789 } 68790 render() { 68791 const { 68792 url, 68793 onChange 68794 } = this.props; 68795 const { 68796 expanded 68797 } = this.state; 68798 const buttonLabel = url ? (0,external_wp_i18n_namespaceObject.__)('Edit link') : (0,external_wp_i18n_namespaceObject.__)('Insert link'); 68799 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 68800 className: "block-editor-url-input__button", 68801 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 68802 size: "compact", 68803 icon: library_link, 68804 label: buttonLabel, 68805 onClick: this.toggle, 68806 className: "components-toolbar__control", 68807 isPressed: !!url 68808 }), expanded && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("form", { 68809 className: "block-editor-url-input__button-modal", 68810 onSubmit: this.submitLink, 68811 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 68812 className: "block-editor-url-input__button-modal-line", 68813 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 68814 __next40pxDefaultSize: true, 68815 className: "block-editor-url-input__back", 68816 icon: arrow_left, 68817 label: (0,external_wp_i18n_namespaceObject.__)('Close'), 68818 onClick: this.toggle 68819 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_input, { 68820 value: url || '', 68821 onChange: onChange, 68822 suffix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlSuffixWrapper, { 68823 variant: "control", 68824 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 68825 size: "small", 68826 icon: keyboard_return, 68827 label: (0,external_wp_i18n_namespaceObject.__)('Submit'), 68828 type: "submit" 68829 }) 68830 }) 68831 })] 68832 }) 68833 })] 68834 }); 68835 } 68836 } 68837 68838 /** 68839 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/url-input/README.md 68840 */ 68841 /* harmony default export */ const url_input_button = (URLInputButton); 68842 68843 ;// ./node_modules/@wordpress/icons/build-module/library/image.js 68844 /** 68845 * WordPress dependencies 68846 */ 68847 68848 68849 const image_image = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 68850 viewBox: "0 0 24 24", 68851 xmlns: "http://www.w3.org/2000/svg", 68852 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 68853 d: "M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM5 4.5h14c.3 0 .5.2.5.5v8.4l-3-2.9c-.3-.3-.8-.3-1 0L11.9 14 9 12c-.3-.2-.6-.2-.8 0l-3.6 2.6V5c-.1-.3.1-.5.4-.5zm14 15H5c-.3 0-.5-.2-.5-.5v-2.4l4.1-3 3 1.9c.3.2.7.2.9-.1L16 12l3.5 3.4V19c0 .3-.2.5-.5.5z" 68854 }) 68855 }); 68856 /* harmony default export */ const library_image = (image_image); 68857 68858 ;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/image-url-input-ui.js 68859 /** 68860 * WordPress dependencies 68861 */ 68862 68863 68864 68865 68866 68867 68868 /** 68869 * Internal dependencies 68870 */ 68871 68872 68873 68874 68875 const LINK_DESTINATION_NONE = 'none'; 68876 const LINK_DESTINATION_CUSTOM = 'custom'; 68877 const LINK_DESTINATION_MEDIA = 'media'; 68878 const LINK_DESTINATION_ATTACHMENT = 'attachment'; 68879 const NEW_TAB_REL = ['noreferrer', 'noopener']; 68880 const ImageURLInputUI = ({ 68881 linkDestination, 68882 onChangeUrl, 68883 url, 68884 mediaType = 'image', 68885 mediaUrl, 68886 mediaLink, 68887 linkTarget, 68888 linkClass, 68889 rel, 68890 showLightboxSetting, 68891 lightboxEnabled, 68892 onSetLightbox, 68893 resetLightbox 68894 }) => { 68895 const [isOpen, setIsOpen] = (0,external_wp_element_namespaceObject.useState)(false); 68896 // Use internal state instead of a ref to make sure that the component 68897 // re-renders when the popover's anchor updates. 68898 const [popoverAnchor, setPopoverAnchor] = (0,external_wp_element_namespaceObject.useState)(null); 68899 const openLinkUI = () => { 68900 setIsOpen(true); 68901 }; 68902 const [isEditingLink, setIsEditingLink] = (0,external_wp_element_namespaceObject.useState)(false); 68903 const [urlInput, setUrlInput] = (0,external_wp_element_namespaceObject.useState)(null); 68904 const autocompleteRef = (0,external_wp_element_namespaceObject.useRef)(null); 68905 const wrapperRef = (0,external_wp_element_namespaceObject.useRef)(); 68906 (0,external_wp_element_namespaceObject.useEffect)(() => { 68907 if (!wrapperRef.current) { 68908 return; 68909 } 68910 const nextFocusTarget = external_wp_dom_namespaceObject.focus.focusable.find(wrapperRef.current)[0] || wrapperRef.current; 68911 nextFocusTarget.focus(); 68912 }, [isEditingLink, url, lightboxEnabled]); 68913 const startEditLink = () => { 68914 if (linkDestination === LINK_DESTINATION_MEDIA || linkDestination === LINK_DESTINATION_ATTACHMENT) { 68915 setUrlInput(''); 68916 } 68917 setIsEditingLink(true); 68918 }; 68919 const stopEditLink = () => { 68920 setIsEditingLink(false); 68921 }; 68922 const closeLinkUI = () => { 68923 setUrlInput(null); 68924 stopEditLink(); 68925 setIsOpen(false); 68926 }; 68927 const getUpdatedLinkTargetSettings = value => { 68928 const newLinkTarget = value ? '_blank' : undefined; 68929 let updatedRel; 68930 if (newLinkTarget) { 68931 const rels = (rel !== null && rel !== void 0 ? rel : '').split(' '); 68932 NEW_TAB_REL.forEach(relVal => { 68933 if (!rels.includes(relVal)) { 68934 rels.push(relVal); 68935 } 68936 }); 68937 updatedRel = rels.join(' '); 68938 } else { 68939 const rels = (rel !== null && rel !== void 0 ? rel : '').split(' ').filter(relVal => NEW_TAB_REL.includes(relVal) === false); 68940 updatedRel = rels.length ? rels.join(' ') : undefined; 68941 } 68942 return { 68943 linkTarget: newLinkTarget, 68944 rel: updatedRel 68945 }; 68946 }; 68947 const onFocusOutside = () => { 68948 return event => { 68949 // The autocomplete suggestions list renders in a separate popover (in a portal), 68950 // so onFocusOutside fails to detect that a click on a suggestion occurred in the 68951 // LinkContainer. Detect clicks on autocomplete suggestions using a ref here, and 68952 // return to avoid the popover being closed. 68953 const autocompleteElement = autocompleteRef.current; 68954 if (autocompleteElement && autocompleteElement.contains(event.target)) { 68955 return; 68956 } 68957 setIsOpen(false); 68958 setUrlInput(null); 68959 stopEditLink(); 68960 }; 68961 }; 68962 const onSubmitLinkChange = () => { 68963 return event => { 68964 if (urlInput) { 68965 // It is possible the entered URL actually matches a named link destination. 68966 // This check will ensure our link destination is correct. 68967 const selectedDestination = getLinkDestinations().find(destination => destination.url === urlInput)?.linkDestination || LINK_DESTINATION_CUSTOM; 68968 onChangeUrl({ 68969 href: urlInput, 68970 linkDestination: selectedDestination, 68971 lightbox: { 68972 enabled: false 68973 } 68974 }); 68975 } 68976 stopEditLink(); 68977 setUrlInput(null); 68978 event.preventDefault(); 68979 }; 68980 }; 68981 const onLinkRemove = () => { 68982 onChangeUrl({ 68983 linkDestination: LINK_DESTINATION_NONE, 68984 href: '' 68985 }); 68986 }; 68987 const getLinkDestinations = () => { 68988 const linkDestinations = [{ 68989 linkDestination: LINK_DESTINATION_MEDIA, 68990 title: (0,external_wp_i18n_namespaceObject.__)('Link to image file'), 68991 url: mediaType === 'image' ? mediaUrl : undefined, 68992 icon: library_image 68993 }]; 68994 if (mediaType === 'image' && mediaLink) { 68995 linkDestinations.push({ 68996 linkDestination: LINK_DESTINATION_ATTACHMENT, 68997 title: (0,external_wp_i18n_namespaceObject.__)('Link to attachment page'), 68998 url: mediaType === 'image' ? mediaLink : undefined, 68999 icon: library_page 69000 }); 69001 } 69002 return linkDestinations; 69003 }; 69004 const onSetHref = value => { 69005 const linkDestinations = getLinkDestinations(); 69006 let linkDestinationInput; 69007 if (!value) { 69008 linkDestinationInput = LINK_DESTINATION_NONE; 69009 } else { 69010 linkDestinationInput = (linkDestinations.find(destination => { 69011 return destination.url === value; 69012 }) || { 69013 linkDestination: LINK_DESTINATION_CUSTOM 69014 }).linkDestination; 69015 } 69016 onChangeUrl({ 69017 linkDestination: linkDestinationInput, 69018 href: value 69019 }); 69020 }; 69021 const onSetNewTab = value => { 69022 const updatedLinkTarget = getUpdatedLinkTargetSettings(value); 69023 onChangeUrl(updatedLinkTarget); 69024 }; 69025 const onSetLinkRel = value => { 69026 onChangeUrl({ 69027 rel: value 69028 }); 69029 }; 69030 const onSetLinkClass = value => { 69031 onChangeUrl({ 69032 linkClass: value 69033 }); 69034 }; 69035 const advancedOptions = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 69036 spacing: "3", 69037 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, { 69038 __nextHasNoMarginBottom: true, 69039 label: (0,external_wp_i18n_namespaceObject.__)('Open in new tab'), 69040 onChange: onSetNewTab, 69041 checked: linkTarget === '_blank' 69042 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, { 69043 __next40pxDefaultSize: true, 69044 __nextHasNoMarginBottom: true, 69045 label: (0,external_wp_i18n_namespaceObject.__)('Link rel'), 69046 value: rel !== null && rel !== void 0 ? rel : '', 69047 onChange: onSetLinkRel 69048 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, { 69049 __next40pxDefaultSize: true, 69050 __nextHasNoMarginBottom: true, 69051 label: (0,external_wp_i18n_namespaceObject.__)('Link CSS class'), 69052 value: linkClass || '', 69053 onChange: onSetLinkClass 69054 })] 69055 }); 69056 const linkEditorValue = urlInput !== null ? urlInput : url; 69057 const hideLightboxPanel = !lightboxEnabled || lightboxEnabled && !showLightboxSetting; 69058 const showLinkEditor = !linkEditorValue && hideLightboxPanel; 69059 const urlLabel = (getLinkDestinations().find(destination => destination.linkDestination === linkDestination) || {}).title; 69060 const PopoverChildren = () => { 69061 if (lightboxEnabled && showLightboxSetting && !url && !isEditingLink) { 69062 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 69063 className: "block-editor-url-popover__expand-on-click", 69064 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, { 69065 icon: library_fullscreen 69066 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 69067 className: "text", 69068 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 69069 children: (0,external_wp_i18n_namespaceObject.__)('Expand on click') 69070 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 69071 className: "description", 69072 children: (0,external_wp_i18n_namespaceObject.__)('Scales the image with a lightbox effect') 69073 })] 69074 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 69075 icon: link_off, 69076 label: (0,external_wp_i18n_namespaceObject.__)('Disable expand on click'), 69077 onClick: () => { 69078 onSetLightbox?.(false); 69079 }, 69080 size: "compact" 69081 })] 69082 }); 69083 } else if (!url || isEditingLink) { 69084 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_popover.LinkEditor, { 69085 className: "block-editor-format-toolbar__link-container-content", 69086 value: linkEditorValue, 69087 onChangeInputValue: setUrlInput, 69088 onSubmit: onSubmitLinkChange(), 69089 autocompleteRef: autocompleteRef 69090 }); 69091 } else if (url && !isEditingLink) { 69092 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 69093 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_popover.LinkViewer, { 69094 className: "block-editor-format-toolbar__link-container-content", 69095 url: url, 69096 onEditLinkClick: startEditLink, 69097 urlLabel: urlLabel 69098 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 69099 icon: link_off, 69100 label: (0,external_wp_i18n_namespaceObject.__)('Remove link'), 69101 onClick: () => { 69102 onLinkRemove(); 69103 resetLightbox?.(); 69104 }, 69105 size: "compact" 69106 })] 69107 }); 69108 } 69109 }; 69110 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 69111 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, { 69112 icon: library_link, 69113 className: "components-toolbar__control", 69114 label: (0,external_wp_i18n_namespaceObject.__)('Link'), 69115 "aria-expanded": isOpen, 69116 onClick: openLinkUI, 69117 ref: setPopoverAnchor, 69118 isActive: !!url || lightboxEnabled && showLightboxSetting 69119 }), isOpen && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_popover, { 69120 ref: wrapperRef, 69121 anchor: popoverAnchor, 69122 onFocusOutside: onFocusOutside(), 69123 onClose: closeLinkUI, 69124 renderSettings: hideLightboxPanel ? () => advancedOptions : null, 69125 additionalControls: showLinkEditor && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.NavigableMenu, { 69126 children: [getLinkDestinations().map(link => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 69127 icon: link.icon, 69128 iconPosition: "left", 69129 onClick: () => { 69130 setUrlInput(null); 69131 onSetHref(link.url); 69132 stopEditLink(); 69133 }, 69134 children: link.title 69135 }, link.linkDestination)), showLightboxSetting && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, { 69136 className: "block-editor-url-popover__expand-on-click", 69137 icon: library_fullscreen, 69138 info: (0,external_wp_i18n_namespaceObject.__)('Scale the image with a lightbox effect.'), 69139 iconPosition: "left", 69140 onClick: () => { 69141 setUrlInput(null); 69142 onChangeUrl({ 69143 linkDestination: LINK_DESTINATION_NONE, 69144 href: '' 69145 }); 69146 onSetLightbox?.(true); 69147 stopEditLink(); 69148 }, 69149 children: (0,external_wp_i18n_namespaceObject.__)('Expand on click') 69150 }, "expand-on-click")] 69151 }), 69152 offset: 13, 69153 children: PopoverChildren() 69154 })] 69155 }); 69156 }; 69157 69158 69159 ;// ./node_modules/@wordpress/block-editor/build-module/components/preview-options/index.js 69160 /** 69161 * WordPress dependencies 69162 */ 69163 69164 function PreviewOptions() { 69165 external_wp_deprecated_default()('wp.blockEditor.PreviewOptions', { 69166 version: '6.5' 69167 }); 69168 return null; 69169 } 69170 69171 ;// ./node_modules/@wordpress/block-editor/build-module/components/use-resize-canvas/index.js 69172 /** 69173 * WordPress dependencies 69174 */ 69175 69176 69177 /** 69178 * Function to resize the editor window. 69179 * 69180 * @param {string} deviceType Used for determining the size of the container (e.g. Desktop, Tablet, Mobile) 69181 * 69182 * @return {Object} Inline styles to be added to resizable container. 69183 */ 69184 function useResizeCanvas(deviceType) { 69185 const [actualWidth, updateActualWidth] = (0,external_wp_element_namespaceObject.useState)(window.innerWidth); 69186 (0,external_wp_element_namespaceObject.useEffect)(() => { 69187 if (deviceType === 'Desktop') { 69188 return; 69189 } 69190 const resizeListener = () => updateActualWidth(window.innerWidth); 69191 window.addEventListener('resize', resizeListener); 69192 return () => { 69193 window.removeEventListener('resize', resizeListener); 69194 }; 69195 }, [deviceType]); 69196 const getCanvasWidth = device => { 69197 let deviceWidth; 69198 switch (device) { 69199 case 'Tablet': 69200 deviceWidth = 780; 69201 break; 69202 case 'Mobile': 69203 deviceWidth = 360; 69204 break; 69205 default: 69206 return null; 69207 } 69208 return deviceWidth < actualWidth ? deviceWidth : actualWidth; 69209 }; 69210 const contentInlineStyles = device => { 69211 const height = device === 'Mobile' ? '768px' : '1024px'; 69212 const marginVertical = '40px'; 69213 const marginHorizontal = 'auto'; 69214 switch (device) { 69215 case 'Tablet': 69216 case 'Mobile': 69217 return { 69218 width: getCanvasWidth(device), 69219 // Keeping margin styles separate to avoid warnings 69220 // when those props get overridden in the iframe component 69221 marginTop: marginVertical, 69222 marginBottom: marginVertical, 69223 marginLeft: marginHorizontal, 69224 marginRight: marginHorizontal, 69225 height, 69226 overflowY: 'auto' 69227 }; 69228 default: 69229 return { 69230 marginLeft: marginHorizontal, 69231 marginRight: marginHorizontal 69232 }; 69233 } 69234 }; 69235 return contentInlineStyles(deviceType); 69236 } 69237 69238 ;// ./node_modules/@wordpress/block-editor/build-module/components/skip-to-selected-block/index.js 69239 /** 69240 * WordPress dependencies 69241 */ 69242 69243 69244 69245 69246 69247 /** 69248 * Internal dependencies 69249 */ 69250 69251 69252 69253 /** 69254 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/skip-to-selected-block/README.md 69255 */ 69256 69257 function SkipToSelectedBlock() { 69258 const selectedBlockClientId = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getBlockSelectionStart(), []); 69259 const ref = (0,external_wp_element_namespaceObject.useRef)(); 69260 useBlockElementRef(selectedBlockClientId, ref); 69261 const onClick = () => { 69262 ref.current?.focus(); 69263 }; 69264 return selectedBlockClientId ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 69265 __next40pxDefaultSize: true, 69266 variant: "secondary", 69267 className: "block-editor-skip-to-selected-block", 69268 onClick: onClick, 69269 children: (0,external_wp_i18n_namespaceObject.__)('Skip to the selected block') 69270 }) : null; 69271 } 69272 69273 ;// external ["wp","wordcount"] 69274 const external_wp_wordcount_namespaceObject = window["wp"]["wordcount"]; 69275 ;// ./node_modules/@wordpress/block-editor/build-module/components/multi-selection-inspector/index.js 69276 /** 69277 * WordPress dependencies 69278 */ 69279 69280 69281 69282 69283 69284 69285 /** 69286 * Internal dependencies 69287 */ 69288 69289 69290 69291 69292 function MultiSelectionInspector() { 69293 const { 69294 blocks 69295 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 69296 const { 69297 getMultiSelectedBlocks 69298 } = select(store); 69299 return { 69300 blocks: getMultiSelectedBlocks() 69301 }; 69302 }, []); 69303 const words = (0,external_wp_wordcount_namespaceObject.count)((0,external_wp_blocks_namespaceObject.serialize)(blocks), 'words'); 69304 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 69305 className: "block-editor-multi-selection-inspector__card", 69306 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 69307 icon: library_copy, 69308 showColors: true 69309 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 69310 className: "block-editor-multi-selection-inspector__card-content", 69311 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 69312 className: "block-editor-multi-selection-inspector__card-title", 69313 children: (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %d: number of blocks */ 69314 (0,external_wp_i18n_namespaceObject._n)('%d Block', '%d Blocks', blocks.length), blocks.length) 69315 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 69316 className: "block-editor-multi-selection-inspector__card-description", 69317 children: (0,external_wp_i18n_namespaceObject.sprintf)( /* translators: %d: number of words */ 69318 (0,external_wp_i18n_namespaceObject._n)('%d word selected.', '%d words selected.', words), words) 69319 })] 69320 })] 69321 }); 69322 } 69323 69324 ;// ./node_modules/@wordpress/icons/build-module/library/cog.js 69325 /** 69326 * WordPress dependencies 69327 */ 69328 69329 69330 const cog = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 69331 xmlns: "http://www.w3.org/2000/svg", 69332 viewBox: "0 0 24 24", 69333 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 69334 fillRule: "evenodd", 69335 d: "M10.289 4.836A1 1 0 0111.275 4h1.306a1 1 0 01.987.836l.244 1.466c.787.26 1.503.679 2.108 1.218l1.393-.522a1 1 0 011.216.437l.653 1.13a1 1 0 01-.23 1.273l-1.148.944a6.025 6.025 0 010 2.435l1.149.946a1 1 0 01.23 1.272l-.653 1.13a1 1 0 01-1.216.437l-1.394-.522c-.605.54-1.32.958-2.108 1.218l-.244 1.466a1 1 0 01-.987.836h-1.306a1 1 0 01-.986-.836l-.244-1.466a5.995 5.995 0 01-2.108-1.218l-1.394.522a1 1 0 01-1.217-.436l-.653-1.131a1 1 0 01.23-1.272l1.149-.946a6.026 6.026 0 010-2.435l-1.148-.944a1 1 0 01-.23-1.272l.653-1.131a1 1 0 011.217-.437l1.393.522a5.994 5.994 0 012.108-1.218l.244-1.466zM14.929 12a3 3 0 11-6 0 3 3 0 016 0z", 69336 clipRule: "evenodd" 69337 }) 69338 }); 69339 /* harmony default export */ const library_cog = (cog); 69340 69341 ;// ./node_modules/@wordpress/icons/build-module/library/styles.js 69342 /** 69343 * WordPress dependencies 69344 */ 69345 69346 69347 const styles = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { 69348 viewBox: "0 0 24 24", 69349 xmlns: "http://www.w3.org/2000/svg", 69350 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { 69351 fillRule: "evenodd", 69352 clipRule: "evenodd", 69353 d: "M20 12a8 8 0 1 1-16 0 8 8 0 0 1 16 0Zm-1.5 0a6.5 6.5 0 0 1-6.5 6.5v-13a6.5 6.5 0 0 1 6.5 6.5Z" 69354 }) 69355 }); 69356 /* harmony default export */ const library_styles = (styles); 69357 69358 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/utils.js 69359 /** 69360 * WordPress dependencies 69361 */ 69362 69363 69364 const TAB_SETTINGS = { 69365 name: 'settings', 69366 title: (0,external_wp_i18n_namespaceObject.__)('Settings'), 69367 value: 'settings', 69368 icon: library_cog, 69369 className: 'block-editor-block-inspector__tab-item' 69370 }; 69371 const TAB_STYLES = { 69372 name: 'styles', 69373 title: (0,external_wp_i18n_namespaceObject.__)('Styles'), 69374 value: 'styles', 69375 icon: library_styles, 69376 className: 'block-editor-block-inspector__tab-item' 69377 }; 69378 const TAB_LIST_VIEW = { 69379 name: 'list', 69380 title: (0,external_wp_i18n_namespaceObject.__)('List View'), 69381 value: 'list-view', 69382 icon: list_view, 69383 className: 'block-editor-block-inspector__tab-item' 69384 }; 69385 69386 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/advanced-controls-panel.js 69387 /** 69388 * WordPress dependencies 69389 */ 69390 69391 69392 69393 /** 69394 * Internal dependencies 69395 */ 69396 69397 69398 const AdvancedControls = () => { 69399 const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(InspectorAdvancedControls.slotName); 69400 const hasFills = Boolean(fills && fills.length); 69401 if (!hasFills) { 69402 return null; 69403 } 69404 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, { 69405 className: "block-editor-block-inspector__advanced", 69406 title: (0,external_wp_i18n_namespaceObject.__)('Advanced'), 69407 initialOpen: false, 69408 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 69409 group: "advanced" 69410 }) 69411 }); 69412 }; 69413 /* harmony default export */ const advanced_controls_panel = (AdvancedControls); 69414 69415 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/position-controls-panel.js 69416 /** 69417 * WordPress dependencies 69418 */ 69419 69420 69421 69422 69423 69424 /** 69425 * Internal dependencies 69426 */ 69427 69428 69429 69430 69431 const PositionControlsPanel = () => { 69432 const [initialOpen, setInitialOpen] = (0,external_wp_element_namespaceObject.useState)(); 69433 69434 // Determine whether the panel should be expanded. 69435 const { 69436 multiSelectedBlocks 69437 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 69438 const { 69439 getBlocksByClientId, 69440 getSelectedBlockClientIds 69441 } = select(store); 69442 const clientIds = getSelectedBlockClientIds(); 69443 return { 69444 multiSelectedBlocks: getBlocksByClientId(clientIds) 69445 }; 69446 }, []); 69447 (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { 69448 // If any selected block has a position set, open the panel by default. 69449 // The first block's value will still be used within the control though. 69450 if (initialOpen === undefined) { 69451 setInitialOpen(multiSelectedBlocks.some(({ 69452 attributes 69453 }) => !!attributes?.style?.position?.type)); 69454 } 69455 }, [initialOpen, multiSelectedBlocks, setInitialOpen]); 69456 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, { 69457 className: "block-editor-block-inspector__position", 69458 title: (0,external_wp_i18n_namespaceObject.__)('Position'), 69459 initialOpen: initialOpen !== null && initialOpen !== void 0 ? initialOpen : false, 69460 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 69461 group: "position" 69462 }) 69463 }); 69464 }; 69465 const PositionControls = () => { 69466 const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(inspector_controls_groups.position.Slot.__unstableName); 69467 const hasFills = Boolean(fills && fills.length); 69468 if (!hasFills) { 69469 return null; 69470 } 69471 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PositionControlsPanel, {}); 69472 }; 69473 /* harmony default export */ const position_controls_panel = (PositionControls); 69474 69475 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/settings-tab.js 69476 /** 69477 * Internal dependencies 69478 */ 69479 69480 69481 69482 69483 69484 69485 const SettingsTab = ({ 69486 showAdvancedControls = false 69487 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 69488 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(position_controls_panel, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 69489 group: "bindings" 69490 }), showAdvancedControls && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 69491 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(advanced_controls_panel, {}) 69492 })] 69493 }); 69494 /* harmony default export */ const settings_tab = (SettingsTab); 69495 69496 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/styles-tab.js 69497 /** 69498 * WordPress dependencies 69499 */ 69500 69501 69502 69503 /** 69504 * Internal dependencies 69505 */ 69506 69507 69508 69509 69510 69511 69512 const StylesTab = ({ 69513 blockName, 69514 clientId, 69515 hasBlockStyles 69516 }) => { 69517 const borderPanelLabel = useBorderPanelLabel({ 69518 blockName 69519 }); 69520 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 69521 children: [hasBlockStyles && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 69522 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, { 69523 title: (0,external_wp_i18n_namespaceObject.__)('Styles'), 69524 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_styles, { 69525 clientId: clientId 69526 }) 69527 }) 69528 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 69529 group: "color", 69530 label: (0,external_wp_i18n_namespaceObject.__)('Color'), 69531 className: "color-block-support-panel__inner-wrapper" 69532 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 69533 group: "background", 69534 label: (0,external_wp_i18n_namespaceObject.__)('Background image') 69535 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 69536 group: "filter" 69537 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 69538 group: "typography", 69539 label: (0,external_wp_i18n_namespaceObject.__)('Typography') 69540 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 69541 group: "dimensions", 69542 label: (0,external_wp_i18n_namespaceObject.__)('Dimensions') 69543 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 69544 group: "border", 69545 label: borderPanelLabel 69546 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 69547 group: "styles" 69548 })] 69549 }); 69550 }; 69551 /* harmony default export */ const styles_tab = (StylesTab); 69552 69553 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/use-is-list-view-tab-disabled.js 69554 // List view tab restricts the blocks that may render to it via the 69555 // allowlist below. 69556 const allowlist = ['core/navigation']; 69557 const useIsListViewTabDisabled = blockName => { 69558 return !allowlist.includes(blockName); 69559 }; 69560 /* harmony default export */ const use_is_list_view_tab_disabled = (useIsListViewTabDisabled); 69561 69562 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/index.js 69563 /** 69564 * WordPress dependencies 69565 */ 69566 69567 69568 69569 69570 /** 69571 * Internal dependencies 69572 */ 69573 69574 69575 69576 69577 69578 69579 69580 69581 const { 69582 Tabs: inspector_controls_tabs_Tabs 69583 } = unlock(external_wp_components_namespaceObject.privateApis); 69584 function InspectorControlsTabs({ 69585 blockName, 69586 clientId, 69587 hasBlockStyles, 69588 tabs 69589 }) { 69590 const showIconLabels = (0,external_wp_data_namespaceObject.useSelect)(select => { 69591 return select(external_wp_preferences_namespaceObject.store).get('core', 'showIconLabels'); 69592 }, []); 69593 69594 // The tabs panel will mount before fills are rendered to the list view 69595 // slot. This means the list view tab isn't initially included in the 69596 // available tabs so the panel defaults selection to the settings tab 69597 // which at the time is the first tab. This check allows blocks known to 69598 // include the list view tab to set it as the tab selected by default. 69599 const initialTabName = !use_is_list_view_tab_disabled(blockName) ? TAB_LIST_VIEW.name : undefined; 69600 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 69601 className: "block-editor-block-inspector__tabs", 69602 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(inspector_controls_tabs_Tabs, { 69603 defaultTabId: initialTabName, 69604 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.TabList, { 69605 children: tabs.map(tab => showIconLabels ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.Tab, { 69606 tabId: tab.name, 69607 className: tab.className, 69608 children: tab.title 69609 }, tab.name) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, { 69610 text: tab.title, 69611 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.Tab, { 69612 tabId: tab.name, 69613 className: tab.className, 69614 "aria-label": tab.title, 69615 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, { 69616 icon: tab.icon 69617 }) 69618 }) 69619 }, tab.name)) 69620 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.TabPanel, { 69621 tabId: TAB_SETTINGS.name, 69622 focusable: false, 69623 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(settings_tab, { 69624 showAdvancedControls: !!blockName 69625 }) 69626 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.TabPanel, { 69627 tabId: TAB_STYLES.name, 69628 focusable: false, 69629 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(styles_tab, { 69630 blockName: blockName, 69631 clientId: clientId, 69632 hasBlockStyles: hasBlockStyles 69633 }) 69634 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.TabPanel, { 69635 tabId: TAB_LIST_VIEW.name, 69636 focusable: false, 69637 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 69638 group: "list" 69639 }) 69640 })] 69641 }, clientId) 69642 }); 69643 } 69644 69645 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/use-inspector-controls-tabs.js 69646 /** 69647 * WordPress dependencies 69648 */ 69649 69650 69651 69652 /** 69653 * Internal dependencies 69654 */ 69655 69656 69657 69658 69659 69660 const use_inspector_controls_tabs_EMPTY_ARRAY = []; 69661 function getShowTabs(blockName, tabSettings = {}) { 69662 // Block specific setting takes precedence over generic default. 69663 if (tabSettings[blockName] !== undefined) { 69664 return tabSettings[blockName]; 69665 } 69666 69667 // Use generic default if set over the Gutenberg experiment option. 69668 if (tabSettings.default !== undefined) { 69669 return tabSettings.default; 69670 } 69671 return true; 69672 } 69673 function useInspectorControlsTabs(blockName) { 69674 const tabs = []; 69675 const { 69676 bindings: bindingsGroup, 69677 border: borderGroup, 69678 color: colorGroup, 69679 default: defaultGroup, 69680 dimensions: dimensionsGroup, 69681 list: listGroup, 69682 position: positionGroup, 69683 styles: stylesGroup, 69684 typography: typographyGroup, 69685 effects: effectsGroup 69686 } = inspector_controls_groups; 69687 69688 // List View Tab: If there are any fills for the list group add that tab. 69689 const listViewDisabled = use_is_list_view_tab_disabled(blockName); 69690 const listFills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(listGroup.Slot.__unstableName); 69691 const hasListFills = !listViewDisabled && !!listFills && listFills.length; 69692 69693 // Styles Tab: Add this tab if there are any fills for block supports 69694 // e.g. border, color, spacing, typography, etc. 69695 const styleFills = [...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(borderGroup.Slot.__unstableName) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(colorGroup.Slot.__unstableName) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(dimensionsGroup.Slot.__unstableName) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(stylesGroup.Slot.__unstableName) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(typographyGroup.Slot.__unstableName) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(effectsGroup.Slot.__unstableName) || [])]; 69696 const hasStyleFills = styleFills.length; 69697 69698 // Settings Tab: If we don't have multiple tabs to display 69699 // (i.e. both list view and styles), check only the default and position 69700 // InspectorControls slots. If we have multiple tabs, we'll need to check 69701 // the advanced controls slot as well to ensure they are rendered. 69702 const advancedFills = [...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(InspectorAdvancedControls.slotName) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(bindingsGroup.Slot.__unstableName) || [])]; 69703 const settingsFills = [...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(defaultGroup.Slot.__unstableName) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(positionGroup.Slot.__unstableName) || []), ...(hasListFills && hasStyleFills > 1 ? advancedFills : [])]; 69704 69705 // Add the tabs in the order that they will default to if available. 69706 // List View > Settings > Styles. 69707 if (hasListFills) { 69708 tabs.push(TAB_LIST_VIEW); 69709 } 69710 if (settingsFills.length) { 69711 tabs.push(TAB_SETTINGS); 69712 } 69713 if (hasStyleFills) { 69714 tabs.push(TAB_STYLES); 69715 } 69716 const tabSettings = (0,external_wp_data_namespaceObject.useSelect)(select => { 69717 return select(store).getSettings().blockInspectorTabs; 69718 }, []); 69719 const showTabs = getShowTabs(blockName, tabSettings); 69720 return showTabs ? tabs : use_inspector_controls_tabs_EMPTY_ARRAY; 69721 } 69722 69723 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-inspector/useBlockInspectorAnimationSettings.js 69724 /** 69725 * WordPress dependencies 69726 */ 69727 69728 69729 /** 69730 * Internal dependencies 69731 */ 69732 69733 function useBlockInspectorAnimationSettings(blockType) { 69734 return (0,external_wp_data_namespaceObject.useSelect)(select => { 69735 if (blockType) { 69736 const globalBlockInspectorAnimationSettings = select(store).getSettings().blockInspectorAnimation; 69737 69738 // Get the name of the block that will allow it's children to be animated. 69739 const animationParent = globalBlockInspectorAnimationSettings?.animationParent; 69740 69741 // Determine whether the animationParent block is a parent of the selected block. 69742 const { 69743 getSelectedBlockClientId, 69744 getBlockParentsByBlockName 69745 } = select(store); 69746 const _selectedBlockClientId = getSelectedBlockClientId(); 69747 const animationParentBlockClientId = getBlockParentsByBlockName(_selectedBlockClientId, animationParent, true)[0]; 69748 69749 // If the selected block is not a child of the animationParent block, 69750 // and not an animationParent block itself, don't animate. 69751 if (!animationParentBlockClientId && blockType.name !== animationParent) { 69752 return null; 69753 } 69754 return globalBlockInspectorAnimationSettings?.[blockType.name]; 69755 } 69756 return null; 69757 }, [blockType]); 69758 } 69759 69760 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-info-slot-fill/index.js 69761 /** 69762 * WordPress dependencies 69763 */ 69764 69765 69766 /** 69767 * Internal dependencies 69768 */ 69769 69770 69771 69772 const { 69773 createPrivateSlotFill 69774 } = unlock(external_wp_components_namespaceObject.privateApis); 69775 const { 69776 Fill: block_info_slot_fill_Fill, 69777 Slot: block_info_slot_fill_Slot 69778 } = createPrivateSlotFill('BlockInformation'); 69779 const BlockInfo = props => { 69780 const context = useBlockEditContext(); 69781 if (!context[mayDisplayControlsKey]) { 69782 return null; 69783 } 69784 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_info_slot_fill_Fill, { 69785 ...props 69786 }); 69787 }; 69788 BlockInfo.Slot = props => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_info_slot_fill_Slot, { 69789 ...props 69790 }); 69791 /* harmony default export */ const block_info_slot_fill = (BlockInfo); 69792 69793 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-quick-navigation/index.js 69794 /** 69795 * WordPress dependencies 69796 */ 69797 69798 69799 69800 /** 69801 * Internal dependencies 69802 */ 69803 69804 69805 69806 69807 69808 69809 function BlockQuickNavigation({ 69810 clientIds, 69811 onSelect 69812 }) { 69813 if (!clientIds.length) { 69814 return null; 69815 } 69816 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalVStack, { 69817 spacing: 1, 69818 children: clientIds.map(clientId => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockQuickNavigationItem, { 69819 onSelect: onSelect, 69820 clientId: clientId 69821 }, clientId)) 69822 }); 69823 } 69824 function BlockQuickNavigationItem({ 69825 clientId, 69826 onSelect 69827 }) { 69828 const blockInformation = useBlockDisplayInformation(clientId); 69829 const blockTitle = useBlockDisplayTitle({ 69830 clientId, 69831 context: 'list-view' 69832 }); 69833 const { 69834 isSelected 69835 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 69836 const { 69837 isBlockSelected, 69838 hasSelectedInnerBlock 69839 } = select(store); 69840 return { 69841 isSelected: isBlockSelected(clientId) || hasSelectedInnerBlock(clientId, /* deep: */true) 69842 }; 69843 }, [clientId]); 69844 const { 69845 selectBlock 69846 } = (0,external_wp_data_namespaceObject.useDispatch)(store); 69847 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button 69848 // TODO: Switch to `true` (40px size) if possible 69849 , { 69850 __next40pxDefaultSize: false, 69851 isPressed: isSelected, 69852 onClick: async () => { 69853 await selectBlock(clientId); 69854 if (onSelect) { 69855 onSelect(clientId); 69856 } 69857 }, 69858 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, { 69859 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, { 69860 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, { 69861 icon: blockInformation?.icon 69862 }) 69863 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexBlock, { 69864 style: { 69865 textAlign: 'left' 69866 }, 69867 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, { 69868 children: blockTitle 69869 }) 69870 })] 69871 }) 69872 }); 69873 } 69874 69875 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-inspector/index.js 69876 /** 69877 * WordPress dependencies 69878 */ 69879 69880 69881 69882 69883 69884 /** 69885 * Internal dependencies 69886 */ 69887 69888 69889 69890 69891 69892 69893 69894 69895 69896 69897 69898 69899 69900 69901 69902 69903 69904 69905 69906 69907 function BlockStylesPanel({ 69908 clientId 69909 }) { 69910 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, { 69911 title: (0,external_wp_i18n_namespaceObject.__)('Styles'), 69912 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_styles, { 69913 clientId: clientId 69914 }) 69915 }); 69916 } 69917 function BlockInspectorLockedBlocks({ 69918 topLevelLockedBlock 69919 }) { 69920 const contentClientIds = (0,external_wp_data_namespaceObject.useSelect)(select => { 69921 const { 69922 getClientIdsOfDescendants, 69923 getBlockName, 69924 getBlockEditingMode 69925 } = select(store); 69926 return getClientIdsOfDescendants(topLevelLockedBlock).filter(clientId => getBlockName(clientId) !== 'core/list-item' && getBlockEditingMode(clientId) === 'contentOnly'); 69927 }, [topLevelLockedBlock]); 69928 const hasBlockStyles = (0,external_wp_data_namespaceObject.useSelect)(select => { 69929 const { 69930 getBlockName 69931 } = select(store); 69932 const { 69933 getBlockStyles 69934 } = select(external_wp_blocks_namespaceObject.store); 69935 return !!getBlockStyles(getBlockName(topLevelLockedBlock))?.length; 69936 }, [topLevelLockedBlock]); 69937 const blockInformation = useBlockDisplayInformation(topLevelLockedBlock); 69938 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 69939 className: "block-editor-block-inspector", 69940 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_card, { 69941 ...blockInformation, 69942 className: blockInformation.isSynced && 'is-synced' 69943 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_info_slot_fill.Slot, {}), hasBlockStyles && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesPanel, { 69944 clientId: topLevelLockedBlock 69945 }), contentClientIds.length > 0 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, { 69946 title: (0,external_wp_i18n_namespaceObject.__)('Content'), 69947 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockQuickNavigation, { 69948 clientIds: contentClientIds 69949 }) 69950 })] 69951 }); 69952 } 69953 const BlockInspector = ({ 69954 showNoBlockSelectedMessage = true 69955 }) => { 69956 const { 69957 count, 69958 selectedBlockName, 69959 selectedBlockClientId, 69960 blockType, 69961 topLevelLockedBlock 69962 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 69963 const { 69964 getSelectedBlockClientId, 69965 getSelectedBlockCount, 69966 getBlockName, 69967 getContentLockingParent, 69968 getTemplateLock 69969 } = unlock(select(store)); 69970 const _selectedBlockClientId = getSelectedBlockClientId(); 69971 const _selectedBlockName = _selectedBlockClientId && getBlockName(_selectedBlockClientId); 69972 const _blockType = _selectedBlockName && (0,external_wp_blocks_namespaceObject.getBlockType)(_selectedBlockName); 69973 return { 69974 count: getSelectedBlockCount(), 69975 selectedBlockClientId: _selectedBlockClientId, 69976 selectedBlockName: _selectedBlockName, 69977 blockType: _blockType, 69978 topLevelLockedBlock: getContentLockingParent(_selectedBlockClientId) || (getTemplateLock(_selectedBlockClientId) === 'contentOnly' || _selectedBlockName === 'core/block' ? _selectedBlockClientId : undefined) 69979 }; 69980 }, []); 69981 const availableTabs = useInspectorControlsTabs(blockType?.name); 69982 const showTabs = availableTabs?.length > 1; 69983 69984 // The block inspector animation settings will be completely 69985 // removed in the future to create an API which allows the block 69986 // inspector to transition between what it 69987 // displays based on the relationship between the selected block 69988 // and its parent, and only enable it if the parent is controlling 69989 // its children blocks. 69990 const blockInspectorAnimationSettings = useBlockInspectorAnimationSettings(blockType); 69991 const borderPanelLabel = useBorderPanelLabel({ 69992 blockName: selectedBlockName 69993 }); 69994 if (count > 1) { 69995 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 69996 className: "block-editor-block-inspector", 69997 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MultiSelectionInspector, {}), showTabs ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorControlsTabs, { 69998 tabs: availableTabs 69999 }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 70000 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70001 group: "color", 70002 label: (0,external_wp_i18n_namespaceObject.__)('Color'), 70003 className: "color-block-support-panel__inner-wrapper" 70004 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70005 group: "background", 70006 label: (0,external_wp_i18n_namespaceObject.__)('Background image') 70007 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70008 group: "typography", 70009 label: (0,external_wp_i18n_namespaceObject.__)('Typography') 70010 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70011 group: "dimensions", 70012 label: (0,external_wp_i18n_namespaceObject.__)('Dimensions') 70013 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70014 group: "border", 70015 label: borderPanelLabel 70016 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70017 group: "styles" 70018 })] 70019 })] 70020 }); 70021 } 70022 const isSelectedBlockUnregistered = selectedBlockName === (0,external_wp_blocks_namespaceObject.getUnregisteredTypeHandlerName)(); 70023 70024 /* 70025 * If the selected block is of an unregistered type, avoid showing it as an actual selection 70026 * because we want the user to focus on the unregistered block warning, not block settings. 70027 */ 70028 if (!blockType || !selectedBlockClientId || isSelectedBlockUnregistered) { 70029 if (showNoBlockSelectedMessage) { 70030 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", { 70031 className: "block-editor-block-inspector__no-blocks", 70032 children: (0,external_wp_i18n_namespaceObject.__)('No block selected.') 70033 }); 70034 } 70035 return null; 70036 } 70037 if (topLevelLockedBlock) { 70038 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockInspectorLockedBlocks, { 70039 topLevelLockedBlock: topLevelLockedBlock 70040 }); 70041 } 70042 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockInspectorSingleBlockWrapper, { 70043 animate: blockInspectorAnimationSettings, 70044 wrapper: children => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AnimatedContainer, { 70045 blockInspectorAnimationSettings: blockInspectorAnimationSettings, 70046 selectedBlockClientId: selectedBlockClientId, 70047 children: children 70048 }), 70049 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockInspectorSingleBlock, { 70050 clientId: selectedBlockClientId, 70051 blockName: blockType.name 70052 }) 70053 }); 70054 }; 70055 const BlockInspectorSingleBlockWrapper = ({ 70056 animate, 70057 wrapper, 70058 children 70059 }) => { 70060 return animate ? wrapper(children) : children; 70061 }; 70062 const AnimatedContainer = ({ 70063 blockInspectorAnimationSettings, 70064 selectedBlockClientId, 70065 children 70066 }) => { 70067 const animationOrigin = blockInspectorAnimationSettings && blockInspectorAnimationSettings.enterDirection === 'leftToRight' ? -50 : 50; 70068 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, { 70069 animate: { 70070 x: 0, 70071 opacity: 1, 70072 transition: { 70073 ease: 'easeInOut', 70074 duration: 0.14 70075 } 70076 }, 70077 initial: { 70078 x: animationOrigin, 70079 opacity: 0 70080 }, 70081 children: children 70082 }, selectedBlockClientId); 70083 }; 70084 const BlockInspectorSingleBlock = ({ 70085 clientId, 70086 blockName 70087 }) => { 70088 const availableTabs = useInspectorControlsTabs(blockName); 70089 const showTabs = availableTabs?.length > 1; 70090 const hasBlockStyles = (0,external_wp_data_namespaceObject.useSelect)(select => { 70091 const { 70092 getBlockStyles 70093 } = select(external_wp_blocks_namespaceObject.store); 70094 const blockStyles = getBlockStyles(blockName); 70095 return blockStyles && blockStyles.length > 0; 70096 }, [blockName]); 70097 const blockInformation = useBlockDisplayInformation(clientId); 70098 const borderPanelLabel = useBorderPanelLabel({ 70099 blockName 70100 }); 70101 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 70102 className: "block-editor-block-inspector", 70103 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_card, { 70104 ...blockInformation, 70105 className: blockInformation.isSynced && 'is-synced' 70106 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_variation_transforms, { 70107 blockClientId: clientId 70108 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_info_slot_fill.Slot, {}), showTabs && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorControlsTabs, { 70109 hasBlockStyles: hasBlockStyles, 70110 clientId: clientId, 70111 blockName: blockName, 70112 tabs: availableTabs 70113 }), !showTabs && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 70114 children: [hasBlockStyles && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesPanel, { 70115 clientId: clientId 70116 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70117 group: "list" 70118 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70119 group: "color", 70120 label: (0,external_wp_i18n_namespaceObject.__)('Color'), 70121 className: "color-block-support-panel__inner-wrapper" 70122 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70123 group: "background", 70124 label: (0,external_wp_i18n_namespaceObject.__)('Background image') 70125 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70126 group: "typography", 70127 label: (0,external_wp_i18n_namespaceObject.__)('Typography') 70128 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70129 group: "dimensions", 70130 label: (0,external_wp_i18n_namespaceObject.__)('Dimensions') 70131 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70132 group: "border", 70133 label: borderPanelLabel 70134 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70135 group: "styles" 70136 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(position_controls_panel, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, { 70137 group: "bindings" 70138 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 70139 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(advanced_controls_panel, {}) 70140 })] 70141 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SkipToSelectedBlock, {}, "back")] 70142 }); 70143 }; 70144 70145 /** 70146 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-inspector/README.md 70147 */ 70148 /* harmony default export */ const block_inspector = (BlockInspector); 70149 70150 ;// ./node_modules/@wordpress/block-editor/build-module/components/copy-handler/index.js 70151 /** 70152 * WordPress dependencies 70153 */ 70154 70155 70156 /** 70157 * Internal dependencies 70158 */ 70159 70160 70161 /** 70162 * @deprecated 70163 */ 70164 70165 const __unstableUseClipboardHandler = () => { 70166 external_wp_deprecated_default()('__unstableUseClipboardHandler', { 70167 alternative: 'BlockCanvas or WritingFlow', 70168 since: '6.4', 70169 version: '6.7' 70170 }); 70171 return useClipboardHandler(); 70172 }; 70173 70174 /** 70175 * @deprecated 70176 * @param {Object} props 70177 */ 70178 function CopyHandler(props) { 70179 external_wp_deprecated_default()('CopyHandler', { 70180 alternative: 'BlockCanvas or WritingFlow', 70181 since: '6.4', 70182 version: '6.7' 70183 }); 70184 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 70185 ...props, 70186 ref: useClipboardHandler() 70187 }); 70188 } 70189 70190 ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/library.js 70191 /** 70192 * WordPress dependencies 70193 */ 70194 70195 70196 70197 /** 70198 * Internal dependencies 70199 */ 70200 70201 70202 70203 const library_noop = () => {}; 70204 function InserterLibrary({ 70205 rootClientId, 70206 clientId, 70207 isAppender, 70208 showInserterHelpPanel, 70209 showMostUsedBlocks = false, 70210 __experimentalInsertionIndex, 70211 __experimentalInitialTab, 70212 __experimentalInitialCategory, 70213 __experimentalFilterValue, 70214 onPatternCategorySelection, 70215 onSelect = library_noop, 70216 shouldFocusBlock = false, 70217 onClose 70218 }, ref) { 70219 const { 70220 destinationRootClientId 70221 } = (0,external_wp_data_namespaceObject.useSelect)(select => { 70222 const { 70223 getBlockRootClientId 70224 } = select(store); 70225 const _rootClientId = rootClientId || getBlockRootClientId(clientId) || undefined; 70226 return { 70227 destinationRootClientId: _rootClientId 70228 }; 70229 }, [clientId, rootClientId]); 70230 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateInserterMenu, { 70231 onSelect: onSelect, 70232 rootClientId: destinationRootClientId, 70233 clientId: clientId, 70234 isAppender: isAppender, 70235 showInserterHelpPanel: showInserterHelpPanel, 70236 showMostUsedBlocks: showMostUsedBlocks, 70237 __experimentalInsertionIndex: __experimentalInsertionIndex, 70238 __experimentalFilterValue: __experimentalFilterValue, 70239 onPatternCategorySelection: onPatternCategorySelection, 70240 __experimentalInitialTab: __experimentalInitialTab, 70241 __experimentalInitialCategory: __experimentalInitialCategory, 70242 shouldFocusBlock: shouldFocusBlock, 70243 ref: ref, 70244 onClose: onClose 70245 }); 70246 } 70247 const PrivateInserterLibrary = (0,external_wp_element_namespaceObject.forwardRef)(InserterLibrary); 70248 function PublicInserterLibrary(props, ref) { 70249 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateInserterLibrary, { 70250 ...props, 70251 onPatternCategorySelection: undefined, 70252 ref: ref 70253 }); 70254 } 70255 /* harmony default export */ const library = ((0,external_wp_element_namespaceObject.forwardRef)(PublicInserterLibrary)); 70256 70257 ;// ./node_modules/@wordpress/block-editor/build-module/components/selection-scroll-into-view/index.js 70258 /** 70259 * WordPress dependencies 70260 */ 70261 70262 70263 /** 70264 * Scrolls the multi block selection end into view if not in view already. This 70265 * is important to do after selection by keyboard. 70266 * 70267 * @deprecated 70268 */ 70269 function MultiSelectScrollIntoView() { 70270 external_wp_deprecated_default()('wp.blockEditor.MultiSelectScrollIntoView', { 70271 hint: 'This behaviour is now built-in.', 70272 since: '5.8' 70273 }); 70274 return null; 70275 } 70276 70277 ;// ./node_modules/@wordpress/block-editor/build-module/components/typewriter/index.js 70278 /** 70279 * WordPress dependencies 70280 */ 70281 70282 70283 70284 70285 70286 /** 70287 * Internal dependencies 70288 */ 70289 70290 70291 const isIE = window.navigator.userAgent.indexOf('Trident') !== -1; 70292 const arrowKeyCodes = new Set([external_wp_keycodes_namespaceObject.UP, external_wp_keycodes_namespaceObject.DOWN, external_wp_keycodes_namespaceObject.LEFT, external_wp_keycodes_namespaceObject.RIGHT]); 70293 const initialTriggerPercentage = 0.75; 70294 function useTypewriter() { 70295 const hasSelectedBlock = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).hasSelectedBlock(), []); 70296 return (0,external_wp_compose_namespaceObject.useRefEffect)(node => { 70297 if (!hasSelectedBlock) { 70298 return; 70299 } 70300 const { 70301 ownerDocument 70302 } = node; 70303 const { 70304 defaultView 70305 } = ownerDocument; 70306 let scrollResizeRafId; 70307 let onKeyDownRafId; 70308 let caretRect; 70309 function onScrollResize() { 70310 if (scrollResizeRafId) { 70311 return; 70312 } 70313 scrollResizeRafId = defaultView.requestAnimationFrame(() => { 70314 computeCaretRectangle(); 70315 scrollResizeRafId = null; 70316 }); 70317 } 70318 function onKeyDown(event) { 70319 // Ensure the any remaining request is cancelled. 70320 if (onKeyDownRafId) { 70321 defaultView.cancelAnimationFrame(onKeyDownRafId); 70322 } 70323 70324 // Use an animation frame for a smooth result. 70325 onKeyDownRafId = defaultView.requestAnimationFrame(() => { 70326 maintainCaretPosition(event); 70327 onKeyDownRafId = null; 70328 }); 70329 } 70330 70331 /** 70332 * Maintains the scroll position after a selection change caused by a 70333 * keyboard event. 70334 * 70335 * @param {KeyboardEvent} event Keyboard event. 70336 */ 70337 function maintainCaretPosition({ 70338 keyCode 70339 }) { 70340 if (!isSelectionEligibleForScroll()) { 70341 return; 70342 } 70343 const currentCaretRect = (0,external_wp_dom_namespaceObject.computeCaretRect)(defaultView); 70344 if (!currentCaretRect) { 70345 return; 70346 } 70347 70348 // If for some reason there is no position set to be scrolled to, let 70349 // this be the position to be scrolled to in the future. 70350 if (!caretRect) { 70351 caretRect = currentCaretRect; 70352 return; 70353 } 70354 70355 // Even though enabling the typewriter effect for arrow keys results in 70356 // a pleasant experience, it may not be the case for everyone, so, for 70357 // now, let's disable it. 70358 if (arrowKeyCodes.has(keyCode)) { 70359 // Reset the caret position to maintain. 70360 caretRect = currentCaretRect; 70361 return; 70362 } 70363 const diff = currentCaretRect.top - caretRect.top; 70364 if (diff === 0) { 70365 return; 70366 } 70367 const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(node); 70368 70369 // The page must be scrollable. 70370 if (!scrollContainer) { 70371 return; 70372 } 70373 const windowScroll = scrollContainer === ownerDocument.body || scrollContainer === ownerDocument.documentElement; 70374 const scrollY = windowScroll ? defaultView.scrollY : scrollContainer.scrollTop; 70375 const scrollContainerY = windowScroll ? 0 : scrollContainer.getBoundingClientRect().top; 70376 const relativeScrollPosition = windowScroll ? caretRect.top / defaultView.innerHeight : (caretRect.top - scrollContainerY) / (defaultView.innerHeight - scrollContainerY); 70377 70378 // If the scroll position is at the start, the active editable element 70379 // is the last one, and the caret is positioned within the initial 70380 // trigger percentage of the page, do not scroll the page. 70381 // The typewriter effect should not kick in until an empty page has been 70382 // filled with the initial trigger percentage or the user scrolls 70383 // intentionally down. 70384 if (scrollY === 0 && relativeScrollPosition < initialTriggerPercentage && isLastEditableNode()) { 70385 // Reset the caret position to maintain. 70386 caretRect = currentCaretRect; 70387 return; 70388 } 70389 const scrollContainerHeight = windowScroll ? defaultView.innerHeight : scrollContainer.clientHeight; 70390 70391 // Abort if the target scroll position would scroll the caret out of 70392 // view. 70393 if ( 70394 // The caret is under the lower fold. 70395 caretRect.top + caretRect.height > scrollContainerY + scrollContainerHeight || 70396 // The caret is above the upper fold. 70397 caretRect.top < scrollContainerY) { 70398 // Reset the caret position to maintain. 70399 caretRect = currentCaretRect; 70400 return; 70401 } 70402 if (windowScroll) { 70403 defaultView.scrollBy(0, diff); 70404 } else { 70405 scrollContainer.scrollTop += diff; 70406 } 70407 } 70408 70409 /** 70410 * Adds a `selectionchange` listener to reset the scroll position to be 70411 * maintained. 70412 */ 70413 function addSelectionChangeListener() { 70414 ownerDocument.addEventListener('selectionchange', computeCaretRectOnSelectionChange); 70415 } 70416 70417 /** 70418 * Resets the scroll position to be maintained during a `selectionchange` 70419 * event. Also removes the listener, so it acts as a one-time listener. 70420 */ 70421 function computeCaretRectOnSelectionChange() { 70422 ownerDocument.removeEventListener('selectionchange', computeCaretRectOnSelectionChange); 70423 computeCaretRectangle(); 70424 } 70425 70426 /** 70427 * Resets the scroll position to be maintained. 70428 */ 70429 function computeCaretRectangle() { 70430 if (isSelectionEligibleForScroll()) { 70431 caretRect = (0,external_wp_dom_namespaceObject.computeCaretRect)(defaultView); 70432 } 70433 } 70434 70435 /** 70436 * Checks if the current situation is elegible for scroll: 70437 * - There should be one and only one block selected. 70438 * - The component must contain the selection. 70439 * - The active element must be contenteditable. 70440 */ 70441 function isSelectionEligibleForScroll() { 70442 return node.contains(ownerDocument.activeElement) && ownerDocument.activeElement.isContentEditable; 70443 } 70444 function isLastEditableNode() { 70445 const editableNodes = node.querySelectorAll('[contenteditable="true"]'); 70446 const lastEditableNode = editableNodes[editableNodes.length - 1]; 70447 return lastEditableNode === ownerDocument.activeElement; 70448 } 70449 70450 // When the user scrolls or resizes, the scroll position should be 70451 // reset. 70452 defaultView.addEventListener('scroll', onScrollResize, true); 70453 defaultView.addEventListener('resize', onScrollResize, true); 70454 node.addEventListener('keydown', onKeyDown); 70455 node.addEventListener('keyup', maintainCaretPosition); 70456 node.addEventListener('mousedown', addSelectionChangeListener); 70457 node.addEventListener('touchstart', addSelectionChangeListener); 70458 return () => { 70459 defaultView.removeEventListener('scroll', onScrollResize, true); 70460 defaultView.removeEventListener('resize', onScrollResize, true); 70461 node.removeEventListener('keydown', onKeyDown); 70462 node.removeEventListener('keyup', maintainCaretPosition); 70463 node.removeEventListener('mousedown', addSelectionChangeListener); 70464 node.removeEventListener('touchstart', addSelectionChangeListener); 70465 ownerDocument.removeEventListener('selectionchange', computeCaretRectOnSelectionChange); 70466 defaultView.cancelAnimationFrame(scrollResizeRafId); 70467 defaultView.cancelAnimationFrame(onKeyDownRafId); 70468 }; 70469 }, [hasSelectedBlock]); 70470 } 70471 function Typewriter({ 70472 children 70473 }) { 70474 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", { 70475 ref: useTypewriter(), 70476 className: "block-editor__typewriter", 70477 children: children 70478 }); 70479 } 70480 70481 /** 70482 * The exported component. The implementation of Typewriter faced technical 70483 * challenges in Internet Explorer, and is simply skipped, rendering the given 70484 * props children instead. 70485 * 70486 * @type {Component} 70487 */ 70488 const TypewriterOrIEBypass = isIE ? props => props.children : Typewriter; 70489 70490 /** 70491 * Ensures that the text selection keeps the same vertical distance from the 70492 * viewport during keyboard events within this component. The vertical distance 70493 * can vary. It is the last clicked or scrolled to position. 70494 */ 70495 /* harmony default export */ const typewriter = (TypewriterOrIEBypass); 70496 70497 ;// ./node_modules/@wordpress/block-editor/build-module/components/recursion-provider/index.js 70498 /** 70499 * WordPress dependencies 70500 */ 70501 70502 70503 70504 /** 70505 * Internal dependencies 70506 */ 70507 70508 70509 const RenderedRefsContext = (0,external_wp_element_namespaceObject.createContext)({}); 70510 70511 /** 70512 * Immutably adds an unique identifier to a set scoped for a given block type. 70513 * 70514 * @param {Object} renderedBlocks Rendered blocks grouped by block name 70515 * @param {string} blockName Name of the block. 70516 * @param {*} uniqueId Any value that acts as a unique identifier for a block instance. 70517 * 70518 * @return {Object} The list of rendered blocks grouped by block name. 70519 */ 70520 function addToBlockType(renderedBlocks, blockName, uniqueId) { 70521 const result = { 70522 ...renderedBlocks, 70523 [blockName]: renderedBlocks[blockName] ? new Set(renderedBlocks[blockName]) : new Set() 70524 }; 70525 result[blockName].add(uniqueId); 70526 return result; 70527 } 70528 70529 /** 70530 * A React context provider for use with the `useHasRecursion` hook to prevent recursive 70531 * renders. 70532 * 70533 * Wrap block content with this provider and provide the same `uniqueId` prop as used 70534 * with `useHasRecursion`. 70535 * 70536 * @param {Object} props 70537 * @param {*} props.uniqueId Any value that acts as a unique identifier for a block instance. 70538 * @param {string} props.blockName Optional block name. 70539 * @param {JSX.Element} props.children React children. 70540 * 70541 * @return {JSX.Element} A React element. 70542 */ 70543 function RecursionProvider({ 70544 children, 70545 uniqueId, 70546 blockName = '' 70547 }) { 70548 const previouslyRenderedBlocks = (0,external_wp_element_namespaceObject.useContext)(RenderedRefsContext); 70549 const { 70550 name 70551 } = useBlockEditContext(); 70552 blockName = blockName || name; 70553 const newRenderedBlocks = (0,external_wp_element_namespaceObject.useMemo)(() => addToBlockType(previouslyRenderedBlocks, blockName, uniqueId), [previouslyRenderedBlocks, blockName, uniqueId]); 70554 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RenderedRefsContext.Provider, { 70555 value: newRenderedBlocks, 70556 children: children 70557 }); 70558 } 70559 70560 /** 70561 * A React hook for keeping track of blocks previously rendered up in the block 70562 * tree. Blocks susceptible to recursion can use this hook in their `Edit` 70563 * function to prevent said recursion. 70564 * 70565 * Use this with the `RecursionProvider` component, using the same `uniqueId` value 70566 * for both the hook and the provider. 70567 * 70568 * @param {*} uniqueId Any value that acts as a unique identifier for a block instance. 70569 * @param {string} blockName Optional block name. 70570 * 70571 * @return {boolean} A boolean describing whether the provided id has already been rendered. 70572 */ 70573 function useHasRecursion(uniqueId, blockName = '') { 70574 const previouslyRenderedBlocks = (0,external_wp_element_namespaceObject.useContext)(RenderedRefsContext); 70575 const { 70576 name 70577 } = useBlockEditContext(); 70578 blockName = blockName || name; 70579 return Boolean(previouslyRenderedBlocks[blockName]?.has(uniqueId)); 70580 } 70581 const DeprecatedExperimentalRecursionProvider = props => { 70582 external_wp_deprecated_default()('wp.blockEditor.__experimentalRecursionProvider', { 70583 since: '6.5', 70584 alternative: 'wp.blockEditor.RecursionProvider' 70585 }); 70586 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RecursionProvider, { 70587 ...props 70588 }); 70589 }; 70590 const DeprecatedExperimentalUseHasRecursion = (...args) => { 70591 external_wp_deprecated_default()('wp.blockEditor.__experimentalUseHasRecursion', { 70592 since: '6.5', 70593 alternative: 'wp.blockEditor.useHasRecursion' 70594 }); 70595 return useHasRecursion(...args); 70596 }; 70597 70598 ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-popover-header/index.js 70599 /** 70600 * WordPress dependencies 70601 */ 70602 70603 70604 70605 70606 70607 function InspectorPopoverHeader({ 70608 title, 70609 help, 70610 actions = [], 70611 onClose 70612 }) { 70613 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 70614 className: "block-editor-inspector-popover-header", 70615 spacing: 4, 70616 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 70617 alignment: "center", 70618 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, { 70619 className: "block-editor-inspector-popover-header__heading", 70620 level: 2, 70621 size: 13, 70622 children: title 70623 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, {}), actions.map(({ 70624 label, 70625 icon, 70626 onClick 70627 }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 70628 size: "small", 70629 className: "block-editor-inspector-popover-header__action", 70630 label: label, 70631 icon: icon, 70632 variant: !icon && 'tertiary', 70633 onClick: onClick, 70634 children: !icon && label 70635 }, label)), onClose && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 70636 size: "small", 70637 className: "block-editor-inspector-popover-header__action", 70638 label: (0,external_wp_i18n_namespaceObject.__)('Close'), 70639 icon: close_small, 70640 onClick: onClose 70641 })] 70642 }), help && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, { 70643 children: help 70644 })] 70645 }); 70646 } 70647 70648 ;// ./node_modules/@wordpress/block-editor/build-module/components/publish-date-time-picker/index.js 70649 /** 70650 * WordPress dependencies 70651 */ 70652 70653 70654 70655 70656 70657 /** 70658 * Internal dependencies 70659 */ 70660 70661 70662 70663 function PublishDateTimePicker({ 70664 onClose, 70665 onChange, 70666 showPopoverHeaderActions, 70667 isCompact, 70668 currentDate, 70669 ...additionalProps 70670 }, ref) { 70671 const datePickerProps = { 70672 startOfWeek: (0,external_wp_date_namespaceObject.getSettings)().l10n.startOfWeek, 70673 onChange, 70674 currentDate: isCompact ? undefined : currentDate, 70675 currentTime: isCompact ? currentDate : undefined, 70676 ...additionalProps 70677 }; 70678 const DatePickerComponent = isCompact ? external_wp_components_namespaceObject.TimePicker : external_wp_components_namespaceObject.DateTimePicker; 70679 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", { 70680 ref: ref, 70681 className: "block-editor-publish-date-time-picker", 70682 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorPopoverHeader, { 70683 title: (0,external_wp_i18n_namespaceObject.__)('Publish'), 70684 actions: showPopoverHeaderActions ? [{ 70685 label: (0,external_wp_i18n_namespaceObject.__)('Now'), 70686 onClick: () => onChange?.(null) 70687 }] : undefined, 70688 onClose: onClose 70689 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DatePickerComponent, { 70690 ...datePickerProps 70691 })] 70692 }); 70693 } 70694 const PrivatePublishDateTimePicker = (0,external_wp_element_namespaceObject.forwardRef)(PublishDateTimePicker); 70695 function PublicPublishDateTimePicker(props, ref) { 70696 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivatePublishDateTimePicker, { 70697 ...props, 70698 showPopoverHeaderActions: true, 70699 isCompact: false, 70700 ref: ref 70701 }); 70702 } 70703 /* harmony default export */ const publish_date_time_picker = ((0,external_wp_element_namespaceObject.forwardRef)(PublicPublishDateTimePicker)); 70704 70705 ;// ./node_modules/@wordpress/block-editor/build-module/components/index.js 70706 /* 70707 * Block Creation Components 70708 */ 70709 70710 70711 70712 70713 70714 70715 70716 70717 70718 70719 70720 70721 70722 70723 70724 70725 70726 70727 70728 70729 70730 70731 70732 70733 70734 70735 70736 70737 70738 70739 70740 70741 70742 70743 70744 70745 70746 70747 70748 70749 70750 70751 70752 70753 70754 70755 70756 70757 70758 70759 70760 70761 70762 70763 70764 70765 70766 70767 70768 70769 70770 70771 70772 70773 70774 70775 70776 70777 70778 70779 /* 70780 * Content Related Components 70781 */ 70782 70783 70784 70785 70786 70787 70788 70789 70790 70791 70792 70793 70794 70795 70796 70797 70798 70799 70800 70801 70802 70803 70804 70805 70806 70807 70808 70809 70810 70811 70812 70813 70814 70815 70816 70817 70818 70819 70820 70821 70822 /* 70823 * State Related Components 70824 */ 70825 70826 70827 70828 70829 70830 ;// ./node_modules/@wordpress/block-editor/build-module/elements/index.js 70831 const elements_ELEMENT_CLASS_NAMES = { 70832 button: 'wp-element-button', 70833 caption: 'wp-element-caption' 70834 }; 70835 const __experimentalGetElementClassName = element => { 70836 return elements_ELEMENT_CLASS_NAMES[element] ? elements_ELEMENT_CLASS_NAMES[element] : ''; 70837 }; 70838 70839 ;// ./node_modules/@wordpress/block-editor/build-module/utils/get-px-from-css-unit.js 70840 /** 70841 * This function was accidentally exposed for mobile/native usage. 70842 * 70843 * @deprecated 70844 * 70845 * @return {string} Empty string. 70846 */ 70847 /* harmony default export */ const get_px_from_css_unit = (() => ''); 70848 70849 ;// ./node_modules/@wordpress/block-editor/build-module/utils/index.js 70850 70851 70852 70853 70854 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/image-settings-panel.js 70855 /** 70856 * WordPress dependencies 70857 */ 70858 70859 70860 70861 /** 70862 * Internal dependencies 70863 */ 70864 70865 70866 70867 function useHasImageSettingsPanel(name, value, inheritedValue) { 70868 // Note: If lightbox `value` exists, that means it was 70869 // defined via the the Global Styles UI and will NOT 70870 // be a boolean value or contain the `allowEditing` property, 70871 // so we should show the settings panel in those cases. 70872 return name === 'core/image' && inheritedValue?.lightbox?.allowEditing || !!value?.lightbox; 70873 } 70874 function ImageSettingsPanel({ 70875 onChange, 70876 value, 70877 inheritedValue, 70878 panelId 70879 }) { 70880 const dropdownMenuProps = useToolsPanelDropdownMenuProps(); 70881 const resetLightbox = () => { 70882 onChange(undefined); 70883 }; 70884 const onChangeLightbox = newSetting => { 70885 onChange({ 70886 enabled: newSetting 70887 }); 70888 }; 70889 let lightboxChecked = false; 70890 if (inheritedValue?.lightbox?.enabled) { 70891 lightboxChecked = inheritedValue.lightbox.enabled; 70892 } 70893 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { 70894 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, { 70895 label: (0,external_wp_i18n_namespaceObject._x)('Settings', 'Image settings'), 70896 resetAll: resetLightbox, 70897 panelId: panelId, 70898 dropdownMenuProps: dropdownMenuProps, 70899 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem 70900 // We use the `userSettings` prop instead of `settings`, because `settings` 70901 // contains the core/theme values for the lightbox and we want to show the 70902 // "RESET" button ONLY when the user has explicitly set a value in the 70903 // Global Styles. 70904 , { 70905 hasValue: () => !!value?.lightbox, 70906 label: (0,external_wp_i18n_namespaceObject.__)('Expand on click'), 70907 onDeselect: resetLightbox, 70908 isShownByDefault: true, 70909 panelId: panelId, 70910 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, { 70911 __nextHasNoMarginBottom: true, 70912 label: (0,external_wp_i18n_namespaceObject.__)('Expand on click'), 70913 checked: lightboxChecked, 70914 onChange: onChangeLightbox 70915 }) 70916 }) 70917 }) 70918 }); 70919 } 70920 70921 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/advanced-panel.js 70922 /** 70923 * WordPress dependencies 70924 */ 70925 70926 70927 70928 70929 /** 70930 * Internal dependencies 70931 */ 70932 70933 70934 70935 function AdvancedPanel({ 70936 value, 70937 onChange, 70938 inheritedValue = value 70939 }) { 70940 // Custom CSS 70941 const [cssError, setCSSError] = (0,external_wp_element_namespaceObject.useState)(null); 70942 const customCSS = inheritedValue?.css; 70943 function handleOnChange(newValue) { 70944 onChange({ 70945 ...value, 70946 css: newValue 70947 }); 70948 if (cssError) { 70949 // Check if the new value is valid CSS, and pass a wrapping selector 70950 // to ensure that `transformStyles` validates the CSS. Note that the 70951 // wrapping selector here is not used in the actual output of any styles. 70952 const [transformed] = transform_styles([{ 70953 css: newValue 70954 }], '.for-validation-only'); 70955 if (transformed) { 70956 setCSSError(null); 70957 } 70958 } 70959 } 70960 function handleOnBlur(event) { 70961 if (!event?.target?.value) { 70962 setCSSError(null); 70963 return; 70964 } 70965 70966 // Check if the new value is valid CSS, and pass a wrapping selector 70967 // to ensure that `transformStyles` validates the CSS. Note that the 70968 // wrapping selector here is not used in the actual output of any styles. 70969 const [transformed] = transform_styles([{ 70970 css: event.target.value 70971 }], '.for-validation-only'); 70972 setCSSError(transformed === null ? (0,external_wp_i18n_namespaceObject.__)('There is an error with your CSS structure.') : null); 70973 } 70974 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, { 70975 spacing: 3, 70976 children: [cssError && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Notice, { 70977 status: "error", 70978 onRemove: () => setCSSError(null), 70979 children: cssError 70980 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextareaControl, { 70981 label: (0,external_wp_i18n_namespaceObject.__)('Additional CSS'), 70982 __nextHasNoMarginBottom: true, 70983 value: customCSS, 70984 onChange: newValue => handleOnChange(newValue), 70985 onBlur: handleOnBlur, 70986 className: "block-editor-global-styles-advanced-panel__custom-css-input", 70987 spellCheck: false 70988 })] 70989 }); 70990 } 70991 70992 ;// ./node_modules/memize/dist/index.js 70993 /** 70994 * Memize options object. 70995 * 70996 * @typedef MemizeOptions 70997 * 70998 * @property {number} [maxSize] Maximum size of the cache. 70999 */ 71000 71001 /** 71002 * Internal cache entry. 71003 * 71004 * @typedef MemizeCacheNode 71005 * 71006 * @property {?MemizeCacheNode|undefined} [prev] Previous node. 71007 * @property {?MemizeCacheNode|undefined} [next] Next node. 71008 * @property {Array<*>} args Function arguments for cache 71009 * entry. 71010 * @property {*} val Function result. 71011 */ 71012 71013 /** 71014 * Properties of the enhanced function for controlling cache. 71015 * 71016 * @typedef MemizeMemoizedFunction 71017 * 71018 * @property {()=>void} clear Clear the cache. 71019 */ 71020 71021 /** 71022 * Accepts a function to be memoized, and returns a new memoized function, with 71023 * optional options. 71024 * 71025 * @template {(...args: any[]) => any} F 71026 * 71027 * @param {F} fn Function to memoize. 71028 * @param {MemizeOptions} [options] Options object. 71029 * 71030 * @return {((...args: Parameters<F>) => ReturnType<F>) & MemizeMemoizedFunction} Memoized function. 71031 */ 71032 function memize(fn, options) { 71033 var size = 0; 71034 71035 /** @type {?MemizeCacheNode|undefined} */ 71036 var head; 71037 71038 /** @type {?MemizeCacheNode|undefined} */ 71039 var tail; 71040 71041 options = options || {}; 71042 71043 function memoized(/* ...args */) { 71044 var node = head, 71045 len = arguments.length, 71046 args, 71047 i; 71048 71049 searchCache: while (node) { 71050 // Perform a shallow equality test to confirm that whether the node 71051 // under test is a candidate for the arguments passed. Two arrays 71052 // are shallowly equal if their length matches and each entry is 71053 // strictly equal between the two sets. Avoid abstracting to a 71054 // function which could incur an arguments leaking deoptimization. 71055 71056 // Check whether node arguments match arguments length 71057 if (node.args.length !== arguments.length) { 71058 node = node.next; 71059 continue; 71060 } 71061 71062 // Check whether node arguments match arguments values 71063 for (i = 0; i < len; i++) { 71064 if (node.args[i] !== arguments[i]) { 71065 node = node.next; 71066 continue searchCache; 71067 } 71068 } 71069 71070 // At this point we can assume we've found a match 71071 71072 // Surface matched node to head if not already 71073 if (node !== head) { 71074 // As tail, shift to previous. Must only shift if not also 71075 // head, since if both head and tail, there is no previous. 71076 if (node === tail) { 71077 tail = node.prev; 71078 } 71079 71080 // Adjust siblings to point to each other. If node was tail, 71081 // this also handles new tail's empty `next` assignment. 71082 /** @type {MemizeCacheNode} */ (node.prev).next = node.next; 71083 if (node.next) { 71084 node.next.prev = node.prev; 71085 } 71086 71087 node.next = head; 71088 node.prev = null; 71089 /** @type {MemizeCacheNode} */ (head).prev = node; 71090 head = node; 71091 } 71092 71093 // Return immediately 71094 return node.val; 71095 } 71096 71097 // No cached value found. Continue to insertion phase: 71098 71099 // Create a copy of arguments (avoid leaking deoptimization) 71100 args = new Array(len); 71101 for (i = 0; i < len; i++) { 71102 args[i] = arguments[i]; 71103 } 71104 71105 node = { 71106 args: args, 71107 71108 // Generate the result from original function 71109 val: fn.apply(null, args), 71110 }; 71111 71112 // Don't need to check whether node is already head, since it would 71113 // have been returned above already if it was 71114 71115 // Shift existing head down list 71116 if (head) { 71117 head.prev = node; 71118 node.next = head; 71119 } else { 71120 // If no head, follows that there's no tail (at initial or reset) 71121 tail = node; 71122 } 71123 71124 // Trim tail if we're reached max size and are pending cache insertion 71125 if (size === /** @type {MemizeOptions} */ (options).maxSize) { 71126 tail = /** @type {MemizeCacheNode} */ (tail).prev; 71127 /** @type {MemizeCacheNode} */ (tail).next = null; 71128 } else { 71129 size++; 71130 } 71131 71132 head = node; 71133 71134 return node.val; 71135 } 71136 71137 memoized.clear = function () { 71138 head = null; 71139 tail = null; 71140 size = 0; 71141 }; 71142 71143 // Ignore reason: There's not a clear solution to create an intersection of 71144 // the function with additional properties, where the goal is to retain the 71145 // function signature of the incoming argument and add control properties 71146 // on the return value. 71147 71148 // @ts-ignore 71149 return memoized; 71150 } 71151 71152 71153 71154 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/get-global-styles-changes.js 71155 /** 71156 * External dependencies 71157 */ 71158 71159 71160 /** 71161 * WordPress dependencies 71162 */ 71163 71164 71165 const globalStylesChangesCache = new Map(); 71166 const get_global_styles_changes_EMPTY_ARRAY = []; 71167 const translationMap = { 71168 caption: (0,external_wp_i18n_namespaceObject.__)('Caption'), 71169 link: (0,external_wp_i18n_namespaceObject.__)('Link'), 71170 button: (0,external_wp_i18n_namespaceObject.__)('Button'), 71171 heading: (0,external_wp_i18n_namespaceObject.__)('Heading'), 71172 h1: (0,external_wp_i18n_namespaceObject.__)('H1'), 71173 h2: (0,external_wp_i18n_namespaceObject.__)('H2'), 71174 h3: (0,external_wp_i18n_namespaceObject.__)('H3'), 71175 h4: (0,external_wp_i18n_namespaceObject.__)('H4'), 71176 h5: (0,external_wp_i18n_namespaceObject.__)('H5'), 71177 h6: (0,external_wp_i18n_namespaceObject.__)('H6'), 71178 'settings.color': (0,external_wp_i18n_namespaceObject.__)('Color'), 71179 'settings.typography': (0,external_wp_i18n_namespaceObject.__)('Typography'), 71180 'styles.color': (0,external_wp_i18n_namespaceObject.__)('Colors'), 71181 'styles.spacing': (0,external_wp_i18n_namespaceObject.__)('Spacing'), 71182 'styles.background': (0,external_wp_i18n_namespaceObject.__)('Background'), 71183 'styles.typography': (0,external_wp_i18n_namespaceObject.__)('Typography') 71184 }; 71185 const getBlockNames = memize(() => (0,external_wp_blocks_namespaceObject.getBlockTypes)().reduce((accumulator, { 71186 name, 71187 title 71188 }) => { 71189 accumulator[name] = title; 71190 return accumulator; 71191 }, {})); 71192 const isObject = obj => obj !== null && typeof obj === 'object'; 71193 71194 /** 71195 * Get the translation for a given global styles key. 71196 * @param {string} key A key representing a path to a global style property or setting. 71197 * @return {string|undefined} A translated key or undefined if no translation exists. 71198 */ 71199 function getTranslation(key) { 71200 if (translationMap[key]) { 71201 return translationMap[key]; 71202 } 71203 const keyArray = key.split('.'); 71204 if (keyArray?.[0] === 'blocks') { 71205 const blockName = getBlockNames()?.[keyArray[1]]; 71206 return blockName || keyArray[1]; 71207 } 71208 if (keyArray?.[0] === 'elements') { 71209 return translationMap[keyArray[1]] || keyArray[1]; 71210 } 71211 return undefined; 71212 } 71213 71214 /** 71215 * A deep comparison of two objects, optimized for comparing global styles. 71216 * @param {Object} changedObject The changed object to compare. 71217 * @param {Object} originalObject The original object to compare against. 71218 * @param {string} parentPath A key/value pair object of block names and their rendered titles. 71219 * @return {string[]} An array of paths whose values have changed. 71220 */ 71221 function deepCompare(changedObject, originalObject, parentPath = '') { 71222 // We have two non-object values to compare. 71223 if (!isObject(changedObject) && !isObject(originalObject)) { 71224 /* 71225 * Only return a path if the value has changed. 71226 * And then only the path name up to 2 levels deep. 71227 */ 71228 return changedObject !== originalObject ? parentPath.split('.').slice(0, 2).join('.') : undefined; 71229 } 71230 71231 // Enable comparison when an object doesn't have a corresponding property to compare. 71232 changedObject = isObject(changedObject) ? changedObject : {}; 71233 originalObject = isObject(originalObject) ? originalObject : {}; 71234 const allKeys = new Set([...Object.keys(changedObject), ...Object.keys(originalObject)]); 71235 let diffs = []; 71236 for (const key of allKeys) { 71237 const path = parentPath ? parentPath + '.' + key : key; 71238 const changedPath = deepCompare(changedObject[key], originalObject[key], path); 71239 if (changedPath) { 71240 diffs = diffs.concat(changedPath); 71241 } 71242 } 71243 return diffs; 71244 } 71245 71246 /** 71247 * Returns an array of translated summarized global styles changes. 71248 * Results are cached using a Map() key of `JSON.stringify( { next, previous } )`. 71249 * 71250 * @param {Object} next The changed object to compare. 71251 * @param {Object} previous The original object to compare against. 71252 * @return {Array[]} A 2-dimensional array of tuples: [ "group", "translated change" ]. 71253 */ 71254 function getGlobalStylesChangelist(next, previous) { 71255 const cacheKey = JSON.stringify({ 71256 next, 71257 previous 71258 }); 71259 if (globalStylesChangesCache.has(cacheKey)) { 71260 return globalStylesChangesCache.get(cacheKey); 71261 } 71262 71263 /* 71264 * Compare the two changesets with normalized keys. 71265 * The order of these keys determines the order in which 71266 * they'll appear in the results. 71267 */ 71268 const changedValueTree = deepCompare({ 71269 styles: { 71270 background: next?.styles?.background, 71271 color: next?.styles?.color, 71272 typography: next?.styles?.typography, 71273 spacing: next?.styles?.spacing 71274 }, 71275 blocks: next?.styles?.blocks, 71276 elements: next?.styles?.elements, 71277 settings: next?.settings 71278 }, { 71279 styles: { 71280 background: previous?.styles?.background, 71281 color: previous?.styles?.color, 71282 typography: previous?.styles?.typography, 71283 spacing: previous?.styles?.spacing 71284 }, 71285 blocks: previous?.styles?.blocks, 71286 elements: previous?.styles?.elements, 71287 settings: previous?.settings 71288 }); 71289 if (!changedValueTree.length) { 71290 globalStylesChangesCache.set(cacheKey, get_global_styles_changes_EMPTY_ARRAY); 71291 return get_global_styles_changes_EMPTY_ARRAY; 71292 } 71293 71294 // Remove duplicate results. 71295 const result = [...new Set(changedValueTree)] 71296 /* 71297 * Translate the keys. 71298 * Remove empty translations. 71299 */.reduce((acc, curr) => { 71300 const translation = getTranslation(curr); 71301 if (translation) { 71302 acc.push([curr.split('.')[0], translation]); 71303 } 71304 return acc; 71305 }, []); 71306 globalStylesChangesCache.set(cacheKey, result); 71307 return result; 71308 } 71309 71310 /** 71311 * From a getGlobalStylesChangelist() result, returns an array of translated global styles changes, grouped by type. 71312 * The types are 'blocks', 'elements', 'settings', and 'styles'. 71313 * 71314 * @param {Object} next The changed object to compare. 71315 * @param {Object} previous The original object to compare against. 71316 * @param {{maxResults:number}} options Options. maxResults: results to return before truncating. 71317 * @return {string[]} An array of translated changes. 71318 */ 71319 function getGlobalStylesChanges(next, previous, options = {}) { 71320 let changeList = getGlobalStylesChangelist(next, previous); 71321 const changesLength = changeList.length; 71322 const { 71323 maxResults 71324 } = options; 71325 if (changesLength) { 71326 // Truncate to `n` results if necessary. 71327 if (!!maxResults && changesLength > maxResults) { 71328 changeList = changeList.slice(0, maxResults); 71329 } 71330 return Object.entries(changeList.reduce((acc, curr) => { 71331 const group = acc[curr[0]] || []; 71332 if (!group.includes(curr[1])) { 71333 acc[curr[0]] = [...group, curr[1]]; 71334 } 71335 return acc; 71336 }, {})).map(([key, changeValues]) => { 71337 const changeValuesLength = changeValues.length; 71338 const joinedChangesValue = changeValues.join( /* translators: Used between list items, there is a space after the comma. */ 71339 (0,external_wp_i18n_namespaceObject.__)(', ') // eslint-disable-line @wordpress/i18n-no-flanking-whitespace 71340 ); 71341 switch (key) { 71342 case 'blocks': 71343 { 71344 return (0,external_wp_i18n_namespaceObject.sprintf)( 71345 // translators: %s: a list of block names separated by a comma. 71346 (0,external_wp_i18n_namespaceObject._n)('%s block.', '%s blocks.', changeValuesLength), joinedChangesValue); 71347 } 71348 case 'elements': 71349 { 71350 return (0,external_wp_i18n_namespaceObject.sprintf)( 71351 // translators: %s: a list of element names separated by a comma. 71352 (0,external_wp_i18n_namespaceObject._n)('%s element.', '%s elements.', changeValuesLength), joinedChangesValue); 71353 } 71354 case 'settings': 71355 { 71356 return (0,external_wp_i18n_namespaceObject.sprintf)( 71357 // translators: %s: a list of theme.json setting labels separated by a comma. 71358 (0,external_wp_i18n_namespaceObject.__)('%s settings.'), joinedChangesValue); 71359 } 71360 case 'styles': 71361 { 71362 return (0,external_wp_i18n_namespaceObject.sprintf)( 71363 // translators: %s: a list of theme.json top-level styles labels separated by a comma. 71364 (0,external_wp_i18n_namespaceObject.__)('%s styles.'), joinedChangesValue); 71365 } 71366 default: 71367 { 71368 return (0,external_wp_i18n_namespaceObject.sprintf)( 71369 // translators: %s: a list of global styles changes separated by a comma. 71370 (0,external_wp_i18n_namespaceObject.__)('%s.'), joinedChangesValue); 71371 } 71372 } 71373 }); 71374 } 71375 return get_global_styles_changes_EMPTY_ARRAY; 71376 } 71377 71378 ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/index.js 71379 71380 71381 71382 71383 71384 71385 71386 71387 71388 71389 71390 71391 71392 71393 71394 ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/get-rich-text-values.js 71395 /** 71396 * WordPress dependencies 71397 */ 71398 71399 71400 71401 71402 /** 71403 * Internal dependencies 71404 */ 71405 71406 71407 71408 /* 71409 * This function is similar to `@wordpress/element`'s `renderToString` function, 71410 * except that it does not render the elements to a string, but instead collects 71411 * the values of all rich text `Content` elements. 71412 */ 71413 71414 function addValuesForElement(element, values, innerBlocks) { 71415 if (null === element || undefined === element || false === element) { 71416 return; 71417 } 71418 if (Array.isArray(element)) { 71419 return addValuesForElements(element, values, innerBlocks); 71420 } 71421 switch (typeof element) { 71422 case 'string': 71423 case 'number': 71424 return; 71425 } 71426 const { 71427 type, 71428 props 71429 } = element; 71430 switch (type) { 71431 case external_wp_element_namespaceObject.StrictMode: 71432 case external_wp_element_namespaceObject.Fragment: 71433 return addValuesForElements(props.children, values, innerBlocks); 71434 case external_wp_element_namespaceObject.RawHTML: 71435 return; 71436 case inner_blocks.Content: 71437 return addValuesForBlocks(values, innerBlocks); 71438 case Content: 71439 values.push(props.value); 71440 return; 71441 } 71442 switch (typeof type) { 71443 case 'string': 71444 if (typeof props.children !== 'undefined') { 71445 return addValuesForElements(props.children, values, innerBlocks); 71446 } 71447 return; 71448 case 'function': 71449 const el = type.prototype && typeof type.prototype.render === 'function' ? new type(props).render() : type(props); 71450 return addValuesForElement(el, values, innerBlocks); 71451 } 71452 } 71453 function addValuesForElements(children, ...args) { 71454 children = Array.isArray(children) ? children : [children]; 71455 for (let i = 0; i < children.length; i++) { 71456 addValuesForElement(children[i], ...args); 71457 } 71458 } 71459 function addValuesForBlocks(values, blocks) { 71460 for (let i = 0; i < blocks.length; i++) { 71461 const { 71462 name, 71463 attributes, 71464 innerBlocks 71465 } = blocks[i]; 71466 const saveElement = (0,external_wp_blocks_namespaceObject.getSaveElement)(name, attributes, 71467 /*#__PURE__*/ 71468 // Instead of letting save elements use `useInnerBlocksProps.save`, 71469 // force them to use InnerBlocks.Content instead so we can intercept 71470 // a single component. 71471 (0,external_ReactJSXRuntime_namespaceObject.jsx)(inner_blocks.Content, {})); 71472 addValuesForElement(saveElement, values, innerBlocks); 71473 } 71474 } 71475 function getRichTextValues(blocks = []) { 71476 external_wp_blocks_namespaceObject.__unstableGetBlockProps.skipFilters = true; 71477 const values = []; 71478 addValuesForBlocks(values, blocks); 71479 external_wp_blocks_namespaceObject.__unstableGetBlockProps.skipFilters = false; 71480 return values.map(value => value instanceof external_wp_richText_namespaceObject.RichTextData ? value : external_wp_richText_namespaceObject.RichTextData.fromHTMLString(value)); 71481 } 71482 71483 ;// ./node_modules/@wordpress/block-editor/build-module/components/resizable-box-popover/index.js 71484 /** 71485 * WordPress dependencies 71486 */ 71487 71488 71489 /** 71490 * Internal dependencies 71491 */ 71492 71493 71494 function ResizableBoxPopover({ 71495 clientId, 71496 resizableBoxProps, 71497 ...props 71498 }) { 71499 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, { 71500 clientId: clientId, 71501 __unstablePopoverSlot: "block-toolbar", 71502 ...props, 71503 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ResizableBox, { 71504 ...resizableBoxProps 71505 }) 71506 }); 71507 } 71508 71509 ;// ./node_modules/@wordpress/block-editor/build-module/components/block-removal-warning-modal/index.js 71510 /** 71511 * WordPress dependencies 71512 */ 71513 71514 71515 71516 71517 71518 /** 71519 * Internal dependencies 71520 */ 71521 71522 71523 71524 71525 function BlockRemovalWarningModal({ 71526 rules 71527 }) { 71528 const { 71529 clientIds, 71530 selectPrevious, 71531 message 71532 } = (0,external_wp_data_namespaceObject.useSelect)(select => unlock(select(store)).getRemovalPromptData()); 71533 const { 71534 clearBlockRemovalPrompt, 71535 setBlockRemovalRules, 71536 privateRemoveBlocks 71537 } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store)); 71538 71539 // Load block removal rules, simultaneously signalling that the block 71540 // removal prompt is in place. 71541 (0,external_wp_element_namespaceObject.useEffect)(() => { 71542 setBlockRemovalRules(rules); 71543 return () => { 71544 setBlockRemovalRules(); 71545 }; 71546 }, [rules, setBlockRemovalRules]); 71547 if (!message) { 71548 return; 71549 } 71550 const onConfirmRemoval = () => { 71551 privateRemoveBlocks(clientIds, selectPrevious, /* force */true); 71552 clearBlockRemovalPrompt(); 71553 }; 71554 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Modal, { 71555 title: (0,external_wp_i18n_namespaceObject.__)('Be careful!'), 71556 onRequestClose: clearBlockRemovalPrompt, 71557 size: "medium", 71558 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", { 71559 children: message 71560 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, { 71561 justify: "right", 71562 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 71563 variant: "tertiary", 71564 onClick: clearBlockRemovalPrompt, 71565 __next40pxDefaultSize: true, 71566 children: (0,external_wp_i18n_namespaceObject.__)('Cancel') 71567 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { 71568 variant: "primary", 71569 onClick: onConfirmRemoval, 71570 __next40pxDefaultSize: true, 71571 children: (0,external_wp_i18n_namespaceObject.__)('Delete') 71572 })] 71573 })] 71574 }); 71575 } 71576 71577 ;// ./node_modules/@wordpress/block-editor/build-module/components/dimensions-tool/scale-tool.js 71578 /** 71579 * WordPress dependencies 71580 */ 71581 71582 71583 71584 71585 /** 71586 * @typedef {import('@wordpress/components/build-types/select-control/types').SelectControlProps} SelectControlProps 71587 */ 71588 71589 /** 71590 * The descriptions are purposely made generic as object-fit could be used for 71591 * any replaced element. Provide your own set of options if you need different 71592 * help text or labels. 71593 * 71594 * @see https://developer.mozilla.org/en-US/docs/Web/CSS/Replaced_element 71595 * 71596 * @type {SelectControlProps[]} 71597 */ 71598 71599 const DEFAULT_SCALE_OPTIONS = [{ 71600 value: 'fill', 71601 label: (0,external_wp_i18n_namespaceObject._x)('Fill', 'Scale option for dimensions control'), 71602 help: (0,external_wp_i18n_namespaceObject.__)('Fill the space by stretching the content.') 71603 }, { 71604 value: 'contain', 71605 label: (0,external_wp_i18n_namespaceObject._x)('Contain', 'Scale option for dimensions control'), 71606 help: (0,external_wp_i18n_namespaceObject.__)('Fit the content to the space without clipping.') 71607 }, { 71608 value: 'cover', 71609 label: (0,external_wp_i18n_namespaceObject._x)('Cover', 'Scale option for dimensions control'), 71610 help: (0,external_wp_i18n_namespaceObject.__)("Fill the space by clipping what doesn't fit.") 71611 }, { 71612 value: 'none', 71613 label: (0,external_wp_i18n_namespaceObject._x)('None', 'Scale option for dimensions control'), 71614 help: (0,external_wp_i18n_namespaceObject.__)('Do not adjust the sizing of the content. Content that is too large will be clipped, and content that is too small will have additional padding.') 71615 }, { 71616 value: 'scale-down', 71617 label: (0,external_wp_i18n_namespaceObject._x)('Scale down', 'Scale option for dimensions control'), 71618 help: (0,external_wp_i18n_namespaceObject.__)('Scale down the content to fit the space if it is too big. Content that is too small will have additional padding.') 71619 }]; 71620 71621 /** 71622 * @callback ScaleToolPropsOnChange 71623 * @param {string} nextValue New scale value. 71624 * @return {void} 71625 */ 71626 71627 /** 71628 * @typedef {Object} ScaleToolProps 71629 * @property {string} [panelId] ID of the panel that contains the controls. 71630 * @property {string} [value] Current scale value. 71631 * @property {ScaleToolPropsOnChange} [onChange] Callback to update the scale value. 71632 * @property {SelectControlProps[]} [options] Scale options. 71633 * @property {string} [defaultValue] Default scale value. 71634 * @property {boolean} [showControl=true] Whether to show the control. 71635 * @property {boolean} [isShownByDefault=true] Whether the tool panel is shown by default. 71636 */ 71637 71638 /** 71639 * A tool to select the CSS object-fit property for the image. 71640 * 71641 * @param {ScaleToolProps} props 71642 * 71643 * @return {import('react').ReactElement} The scale tool. 71644 */ 71645 function ScaleTool({ 71646 panelId, 71647 value, 71648 onChange, 71649 options = DEFAULT_SCALE_OPTIONS, 71650 defaultValue = DEFAULT_SCALE_OPTIONS[0].value, 71651 isShownByDefault = true 71652 }) { 71653 // Match the CSS default so if the value is used directly in CSS it will look correct in the control. 71654 const displayValue = value !== null && value !== void 0 ? value : 'fill'; 71655 const scaleHelp = (0,external_wp_element_namespaceObject.useMemo)(() => { 71656 return options.reduce((acc, option) => { 71657 acc[option.value] = option.help; 71658 return acc; 71659 }, {}); 71660 }, [options]); 71661 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 71662 label: (0,external_wp_i18n_namespaceObject.__)('Scale'), 71663 isShownByDefault: isShownByDefault, 71664 hasValue: () => displayValue !== defaultValue, 71665 onDeselect: () => onChange(defaultValue), 71666 panelId: panelId, 71667 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, { 71668 __nextHasNoMarginBottom: true, 71669 label: (0,external_wp_i18n_namespaceObject.__)('Scale'), 71670 isBlock: true, 71671 help: scaleHelp[displayValue], 71672 value: displayValue, 71673 onChange: onChange, 71674 size: "__unstable-large", 71675 children: options.map(option => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, { 71676 ...option 71677 }, option.value)) 71678 }) 71679 }); 71680 } 71681 71682 ;// ./node_modules/@babel/runtime/helpers/esm/extends.js 71683 function extends_extends() { 71684 extends_extends = Object.assign ? Object.assign.bind() : function (target) { 71685 for (var i = 1; i < arguments.length; i++) { 71686 var source = arguments[i]; 71687 for (var key in source) { 71688 if (Object.prototype.hasOwnProperty.call(source, key)) { 71689 target[key] = source[key]; 71690 } 71691 } 71692 } 71693 return target; 71694 }; 71695 return extends_extends.apply(this, arguments); 71696 } 71697 ;// ./node_modules/@emotion/memoize/dist/emotion-memoize.esm.js 71698 function memoize(fn) { 71699 var cache = Object.create(null); 71700 return function (arg) { 71701 if (cache[arg] === undefined) cache[arg] = fn(arg); 71702 return cache[arg]; 71703 }; 71704 } 71705 71706 71707 71708 ;// ./node_modules/@emotion/styled/node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js 71709 71710 71711 var reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|download|draggable|encType|enterKeyHint|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23 71712 71713 var isPropValid = /* #__PURE__ */memoize(function (prop) { 71714 return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111 71715 /* o */ 71716 && prop.charCodeAt(1) === 110 71717 /* n */ 71718 && prop.charCodeAt(2) < 91; 71719 } 71720 /* Z+1 */ 71721 ); 71722 71723 71724 71725 ;// ./node_modules/@emotion/sheet/dist/emotion-sheet.browser.esm.js 71726 /* 71727 71728 Based off glamor's StyleSheet, thanks Sunil ❤️ 71729 71730 high performance StyleSheet for css-in-js systems 71731 71732 - uses multiple style tags behind the scenes for millions of rules 71733 - uses `insertRule` for appending in production for *much* faster performance 71734 71735 // usage 71736 71737 import { StyleSheet } from '@emotion/sheet' 71738 71739 let styleSheet = new StyleSheet({ key: '', container: document.head }) 71740 71741 styleSheet.insert('#box { border: 1px solid red; }') 71742 - appends a css rule into the stylesheet 71743 71744 styleSheet.flush() 71745 - empties the stylesheet of all its contents 71746 71747 */ 71748 // $FlowFixMe 71749 function sheetForTag(tag) { 71750 if (tag.sheet) { 71751 // $FlowFixMe 71752 return tag.sheet; 71753 } // this weirdness brought to you by firefox 71754 71755 /* istanbul ignore next */ 71756 71757 71758 for (var i = 0; i < document.styleSheets.length; i++) { 71759 if (document.styleSheets[i].ownerNode === tag) { 71760 // $FlowFixMe 71761 return document.styleSheets[i]; 71762 } 71763 } 71764 } 71765 71766 function createStyleElement(options) { 71767 var tag = document.createElement('style'); 71768 tag.setAttribute('data-emotion', options.key); 71769 71770 if (options.nonce !== undefined) { 71771 tag.setAttribute('nonce', options.nonce); 71772 } 71773 71774 tag.appendChild(document.createTextNode('')); 71775 tag.setAttribute('data-s', ''); 71776 return tag; 71777 } 71778 71779 var StyleSheet = /*#__PURE__*/function () { 71780 // Using Node instead of HTMLElement since container may be a ShadowRoot 71781 function StyleSheet(options) { 71782 var _this = this; 71783 71784 this._insertTag = function (tag) { 71785 var before; 71786 71787 if (_this.tags.length === 0) { 71788 if (_this.insertionPoint) { 71789 before = _this.insertionPoint.nextSibling; 71790 } else if (_this.prepend) { 71791 before = _this.container.firstChild; 71792 } else { 71793 before = _this.before; 71794 } 71795 } else { 71796 before = _this.tags[_this.tags.length - 1].nextSibling; 71797 } 71798 71799 _this.container.insertBefore(tag, before); 71800 71801 _this.tags.push(tag); 71802 }; 71803 71804 this.isSpeedy = options.speedy === undefined ? "production" === 'production' : options.speedy; 71805 this.tags = []; 71806 this.ctr = 0; 71807 this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets 71808 71809 this.key = options.key; 71810 this.container = options.container; 71811 this.prepend = options.prepend; 71812 this.insertionPoint = options.insertionPoint; 71813 this.before = null; 71814 } 71815 71816 var _proto = StyleSheet.prototype; 71817 71818 _proto.hydrate = function hydrate(nodes) { 71819 nodes.forEach(this._insertTag); 71820 }; 71821 71822 _proto.insert = function insert(rule) { 71823 // the max length is how many rules we have per style tag, it's 65000 in speedy mode 71824 // it's 1 in dev because we insert source maps that map a single rule to a location 71825 // and you can only have one source map per style tag 71826 if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) { 71827 this._insertTag(createStyleElement(this)); 71828 } 71829 71830 var tag = this.tags[this.tags.length - 1]; 71831 71832 if (false) { var isImportRule; } 71833 71834 if (this.isSpeedy) { 71835 var sheet = sheetForTag(tag); 71836 71837 try { 71838 // this is the ultrafast version, works across browsers 71839 // the big drawback is that the css won't be editable in devtools 71840 sheet.insertRule(rule, sheet.cssRules.length); 71841 } catch (e) { 71842 if (false) {} 71843 } 71844 } else { 71845 tag.appendChild(document.createTextNode(rule)); 71846 } 71847 71848 this.ctr++; 71849 }; 71850 71851 _proto.flush = function flush() { 71852 // $FlowFixMe 71853 this.tags.forEach(function (tag) { 71854 return tag.parentNode && tag.parentNode.removeChild(tag); 71855 }); 71856 this.tags = []; 71857 this.ctr = 0; 71858 71859 if (false) {} 71860 }; 71861 71862 return StyleSheet; 71863 }(); 71864 71865 71866 71867 ;// ./node_modules/stylis/src/Utility.js 71868 /** 71869 * @param {number} 71870 * @return {number} 71871 */ 71872 var abs = Math.abs 71873 71874 /** 71875 * @param {number} 71876 * @return {string} 71877 */ 71878 var Utility_from = String.fromCharCode 71879 71880 /** 71881 * @param {object} 71882 * @return {object} 71883 */ 71884 var Utility_assign = Object.assign 71885 71886 /** 71887 * @param {string} value 71888 * @param {number} length 71889 * @return {number} 71890 */ 71891 function hash (value, length) { 71892 return Utility_charat(value, 0) ^ 45 ? (((((((length << 2) ^ Utility_charat(value, 0)) << 2) ^ Utility_charat(value, 1)) << 2) ^ Utility_charat(value, 2)) << 2) ^ Utility_charat(value, 3) : 0 71893 } 71894 71895 /** 71896 * @param {string} value 71897 * @return {string} 71898 */ 71899 function trim (value) { 71900 return value.trim() 71901 } 71902 71903 /** 71904 * @param {string} value 71905 * @param {RegExp} pattern 71906 * @return {string?} 71907 */ 71908 function Utility_match (value, pattern) { 71909 return (value = pattern.exec(value)) ? value[0] : value 71910 } 71911 71912 /** 71913 * @param {string} value 71914 * @param {(string|RegExp)} pattern 71915 * @param {string} replacement 71916 * @return {string} 71917 */ 71918 function Utility_replace (value, pattern, replacement) { 71919 return value.replace(pattern, replacement) 71920 } 71921 71922 /** 71923 * @param {string} value 71924 * @param {string} search 71925 * @return {number} 71926 */ 71927 function indexof (value, search) { 71928 return value.indexOf(search) 71929 } 71930 71931 /** 71932 * @param {string} value 71933 * @param {number} index 71934 * @return {number} 71935 */ 71936 function Utility_charat (value, index) { 71937 return value.charCodeAt(index) | 0 71938 } 71939 71940 /** 71941 * @param {string} value 71942 * @param {number} begin 71943 * @param {number} end 71944 * @return {string} 71945 */ 71946 function Utility_substr (value, begin, end) { 71947 return value.slice(begin, end) 71948 } 71949 71950 /** 71951 * @param {string} value 71952 * @return {number} 71953 */ 71954 function Utility_strlen (value) { 71955 return value.length 71956 } 71957 71958 /** 71959 * @param {any[]} value 71960 * @return {number} 71961 */ 71962 function Utility_sizeof (value) { 71963 return value.length 71964 } 71965 71966 /** 71967 * @param {any} value 71968 * @param {any[]} array 71969 * @return {any} 71970 */ 71971 function Utility_append (value, array) { 71972 return array.push(value), value 71973 } 71974 71975 /** 71976 * @param {string[]} array 71977 * @param {function} callback 71978 * @return {string} 71979 */ 71980 function Utility_combine (array, callback) { 71981 return array.map(callback).join('') 71982 } 71983 71984 ;// ./node_modules/stylis/src/Tokenizer.js 71985 71986 71987 var line = 1 71988 var column = 1 71989 var Tokenizer_length = 0 71990 var Tokenizer_position = 0 71991 var Tokenizer_character = 0 71992 var characters = '' 71993 71994 /** 71995 * @param {string} value 71996 * @param {object | null} root 71997 * @param {object | null} parent 71998 * @param {string} type 71999 * @param {string[] | string} props 72000 * @param {object[] | string} children 72001 * @param {number} length 72002 */ 72003 function node (value, root, parent, type, props, children, length) { 72004 return {value: value, root: root, parent: parent, type: type, props: props, children: children, line: line, column: column, length: length, return: ''} 72005 } 72006 72007 /** 72008 * @param {object} root 72009 * @param {object} props 72010 * @return {object} 72011 */ 72012 function Tokenizer_copy (root, props) { 72013 return Utility_assign(node('', null, null, '', null, null, 0), root, {length: -root.length}, props) 72014 } 72015 72016 /** 72017 * @return {number} 72018 */ 72019 function Tokenizer_char () { 72020 return Tokenizer_character 72021 } 72022 72023 /** 72024 * @return {number} 72025 */ 72026 function prev () { 72027 Tokenizer_character = Tokenizer_position > 0 ? Utility_charat(characters, --Tokenizer_position) : 0 72028 72029 if (column--, Tokenizer_character === 10) 72030 column = 1, line-- 72031 72032 return Tokenizer_character 72033 } 72034 72035 /** 72036 * @return {number} 72037 */ 72038 function next () { 72039 Tokenizer_character = Tokenizer_position < Tokenizer_length ? Utility_charat(characters, Tokenizer_position++) : 0 72040 72041 if (column++, Tokenizer_character === 10) 72042 column = 1, line++ 72043 72044 return Tokenizer_character 72045 } 72046 72047 /** 72048 * @return {number} 72049 */ 72050 function peek () { 72051 return Utility_charat(characters, Tokenizer_position) 72052 } 72053 72054 /** 72055 * @return {number} 72056 */ 72057 function caret () { 72058 return Tokenizer_position 72059 } 72060 72061 /** 72062 * @param {number} begin 72063 * @param {number} end 72064 * @return {string} 72065 */ 72066 function slice (begin, end) { 72067 return Utility_substr(characters, begin, end) 72068 } 72069 72070 /** 72071 * @param {number} type 72072 * @return {number} 72073 */ 72074 function token (type) { 72075 switch (type) { 72076 // \0 \t \n \r \s whitespace token 72077 case 0: case 9: case 10: case 13: case 32: 72078 return 5 72079 // ! + , / > @ ~ isolate token 72080 case 33: case 43: case 44: case 47: case 62: case 64: case 126: 72081 // ; { } breakpoint token 72082 case 59: case 123: case 125: 72083 return 4 72084 // : accompanied token 72085 case 58: 72086 return 3 72087 // " ' ( [ opening delimit token 72088 case 34: case 39: case 40: case 91: 72089 return 2 72090 // ) ] closing delimit token 72091 case 41: case 93: 72092 return 1 72093 } 72094 72095 return 0 72096 } 72097 72098 /** 72099 * @param {string} value 72100 * @return {any[]} 72101 */ 72102 function alloc (value) { 72103 return line = column = 1, Tokenizer_length = Utility_strlen(characters = value), Tokenizer_position = 0, [] 72104 } 72105 72106 /** 72107 * @param {any} value 72108 * @return {any} 72109 */ 72110 function dealloc (value) { 72111 return characters = '', value 72112 } 72113 72114 /** 72115 * @param {number} type 72116 * @return {string} 72117 */ 72118 function delimit (type) { 72119 return trim(slice(Tokenizer_position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type))) 72120 } 72121 72122 /** 72123 * @param {string} value 72124 * @return {string[]} 72125 */ 72126 function Tokenizer_tokenize (value) { 72127 return dealloc(tokenizer(alloc(value))) 72128 } 72129 72130 /** 72131 * @param {number} type 72132 * @return {string} 72133 */ 72134 function whitespace (type) { 72135 while (Tokenizer_character = peek()) 72136 if (Tokenizer_character < 33) 72137 next() 72138 else 72139 break 72140 72141 return token(type) > 2 || token(Tokenizer_character) > 3 ? '' : ' ' 72142 } 72143 72144 /** 72145 * @param {string[]} children 72146 * @return {string[]} 72147 */ 72148 function tokenizer (children) { 72149 while (next()) 72150 switch (token(Tokenizer_character)) { 72151 case 0: append(identifier(Tokenizer_position - 1), children) 72152 break 72153 case 2: append(delimit(Tokenizer_character), children) 72154 break 72155 default: append(from(Tokenizer_character), children) 72156 } 72157 72158 return children 72159 } 72160 72161 /** 72162 * @param {number} index 72163 * @param {number} count 72164 * @return {string} 72165 */ 72166 function escaping (index, count) { 72167 while (--count && next()) 72168 // not 0-9 A-F a-f 72169 if (Tokenizer_character < 48 || Tokenizer_character > 102 || (Tokenizer_character > 57 && Tokenizer_character < 65) || (Tokenizer_character > 70 && Tokenizer_character < 97)) 72170 break 72171 72172 return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32)) 72173 } 72174 72175 /** 72176 * @param {number} type 72177 * @return {number} 72178 */ 72179 function delimiter (type) { 72180 while (next()) 72181 switch (Tokenizer_character) { 72182 // ] ) " ' 72183 case type: 72184 return Tokenizer_position 72185 // " ' 72186 case 34: case 39: 72187 if (type !== 34 && type !== 39) 72188 delimiter(Tokenizer_character) 72189 break 72190 // ( 72191 case 40: 72192 if (type === 41) 72193 delimiter(type) 72194 break 72195 // \ 72196 case 92: 72197 next() 72198 break 72199 } 72200 72201 return Tokenizer_position 72202 } 72203 72204 /** 72205 * @param {number} type 72206 * @param {number} index 72207 * @return {number} 72208 */ 72209 function commenter (type, index) { 72210 while (next()) 72211 // // 72212 if (type + Tokenizer_character === 47 + 10) 72213 break 72214 // /* 72215 else if (type + Tokenizer_character === 42 + 42 && peek() === 47) 72216 break 72217 72218 return '/*' + slice(index, Tokenizer_position - 1) + '*' + Utility_from(type === 47 ? type : next()) 72219 } 72220 72221 /** 72222 * @param {number} index 72223 * @return {string} 72224 */ 72225 function identifier (index) { 72226 while (!token(peek())) 72227 next() 72228 72229 return slice(index, Tokenizer_position) 72230 } 72231 72232 ;// ./node_modules/stylis/src/Enum.js 72233 var Enum_MS = '-ms-' 72234 var Enum_MOZ = '-moz-' 72235 var Enum_WEBKIT = '-webkit-' 72236 72237 var COMMENT = 'comm' 72238 var Enum_RULESET = 'rule' 72239 var Enum_DECLARATION = 'decl' 72240 72241 var PAGE = '@page' 72242 var MEDIA = '@media' 72243 var IMPORT = '@import' 72244 var CHARSET = '@charset' 72245 var VIEWPORT = '@viewport' 72246 var SUPPORTS = '@supports' 72247 var DOCUMENT = '@document' 72248 var NAMESPACE = '@namespace' 72249 var Enum_KEYFRAMES = '@keyframes' 72250 var FONT_FACE = '@font-face' 72251 var COUNTER_STYLE = '@counter-style' 72252 var FONT_FEATURE_VALUES = '@font-feature-values' 72253 72254 ;// ./node_modules/stylis/src/Serializer.js 72255 72256 72257 72258 /** 72259 * @param {object[]} children 72260 * @param {function} callback 72261 * @return {string} 72262 */ 72263 function Serializer_serialize (children, callback) { 72264 var output = '' 72265 var length = Utility_sizeof(children) 72266 72267 for (var i = 0; i < length; i++) 72268 output += callback(children[i], i, children, callback) || '' 72269 72270 return output 72271 } 72272 72273 /** 72274 * @param {object} element 72275 * @param {number} index 72276 * @param {object[]} children 72277 * @param {function} callback 72278 * @return {string} 72279 */ 72280 function Serializer_stringify (element, index, children, callback) { 72281 switch (element.type) { 72282 case IMPORT: case Enum_DECLARATION: return element.return = element.return || element.value 72283 case COMMENT: return '' 72284 case Enum_KEYFRAMES: return element.return = element.value + '{' + Serializer_serialize(element.children, callback) + '}' 72285 case Enum_RULESET: element.value = element.props.join(',') 72286 } 72287 72288 return Utility_strlen(children = Serializer_serialize(element.children, callback)) ? element.return = element.value + '{' + children + '}' : '' 72289 } 72290 72291 ;// ./node_modules/stylis/src/Middleware.js 72292 72293 72294 72295 72296 72297 72298 /** 72299 * @param {function[]} collection 72300 * @return {function} 72301 */ 72302 function middleware (collection) { 72303 var length = Utility_sizeof(collection) 72304 72305 return function (element, index, children, callback) { 72306 var output = '' 72307 72308 for (var i = 0; i < length; i++) 72309 output += collection[i](element, index, children, callback) || '' 72310 72311 return output 72312 } 72313 } 72314 72315 /** 72316 * @param {function} callback 72317 * @return {function} 72318 */ 72319 function rulesheet (callback) { 72320 return function (element) { 72321 if (!element.root) 72322 if (element = element.return) 72323 callback(element) 72324 } 72325 } 72326 72327 /** 72328 * @param {object} element 72329 * @param {number} index 72330 * @param {object[]} children 72331 * @param {function} callback 72332 */ 72333 function prefixer (element, index, children, callback) { 72334 if (element.length > -1) 72335 if (!element.return) 72336 switch (element.type) { 72337 case DECLARATION: element.return = prefix(element.value, element.length, children) 72338 return 72339 case KEYFRAMES: 72340 return serialize([copy(element, {value: replace(element.value, '@', '@' + WEBKIT)})], callback) 72341 case RULESET: 72342 if (element.length) 72343 return combine(element.props, function (value) { 72344 switch (match(value, /(::plac\w+|:read-\w+)/)) { 72345 // :read-(only|write) 72346 case ':read-only': case ':read-write': 72347 return serialize([copy(element, {props: [replace(value, /:(read-\w+)/, ':' + MOZ + '$1')]})], callback) 72348 // :placeholder 72349 case '::placeholder': 72350 return serialize([ 72351 copy(element, {props: [replace(value, /:(plac\w+)/, ':' + WEBKIT + 'input-$1')]}), 72352 copy(element, {props: [replace(value, /:(plac\w+)/, ':' + MOZ + '$1')]}), 72353 copy(element, {props: [replace(value, /:(plac\w+)/, MS + 'input-$1')]}) 72354 ], callback) 72355 } 72356 72357 return '' 72358 }) 72359 } 72360 } 72361 72362 /** 72363 * @param {object} element 72364 * @param {number} index 72365 * @param {object[]} children 72366 */ 72367 function namespace (element) { 72368 switch (element.type) { 72369 case RULESET: 72370 element.props = element.props.map(function (value) { 72371 return combine(tokenize(value), function (value, index, children) { 72372 switch (charat(value, 0)) { 72373 // \f 72374 case 12: 72375 return substr(value, 1, strlen(value)) 72376 // \0 ( + > ~ 72377 case 0: case 40: case 43: case 62: case 126: 72378 return value 72379 // : 72380 case 58: 72381 if (children[++index] === 'global') 72382 children[index] = '', children[++index] = '\f' + substr(children[index], index = 1, -1) 72383 // \s 72384 case 32: 72385 return index === 1 ? '' : value 72386 default: 72387 switch (index) { 72388 case 0: element = value 72389 return sizeof(children) > 1 ? '' : value 72390 case index = sizeof(children) - 1: case 2: 72391 return index === 2 ? value + element + element : value + element 72392 default: 72393 return value 72394 } 72395 } 72396 }) 72397 }) 72398 } 72399 } 72400 72401 ;// ./node_modules/stylis/src/Parser.js 72402 72403 72404 72405 72406 /** 72407 * @param {string} value 72408 * @return {object[]} 72409 */ 72410 function compile (value) { 72411 return dealloc(Parser_parse('', null, null, null, [''], value = alloc(value), 0, [0], value)) 72412 } 72413 72414 /** 72415 * @param {string} value 72416 * @param {object} root 72417 * @param {object?} parent 72418 * @param {string[]} rule 72419 * @param {string[]} rules 72420 * @param {string[]} rulesets 72421 * @param {number[]} pseudo 72422 * @param {number[]} points 72423 * @param {string[]} declarations 72424 * @return {object} 72425 */ 72426 function Parser_parse (value, root, parent, rule, rules, rulesets, pseudo, points, declarations) { 72427 var index = 0 72428 var offset = 0 72429 var length = pseudo 72430 var atrule = 0 72431 var property = 0 72432 var previous = 0 72433 var variable = 1 72434 var scanning = 1 72435 var ampersand = 1 72436 var character = 0 72437 var type = '' 72438 var props = rules 72439 var children = rulesets 72440 var reference = rule 72441 var characters = type 72442 72443 while (scanning) 72444 switch (previous = character, character = next()) { 72445 // ( 72446 case 40: 72447 if (previous != 108 && Utility_charat(characters, length - 1) == 58) { 72448 if (indexof(characters += Utility_replace(delimit(character), '&', '&\f'), '&\f') != -1) 72449 ampersand = -1 72450 break 72451 } 72452 // " ' [ 72453 case 34: case 39: case 91: 72454 characters += delimit(character) 72455 break 72456 // \t \n \r \s 72457 case 9: case 10: case 13: case 32: 72458 characters += whitespace(previous) 72459 break 72460 // \ 72461 case 92: 72462 characters += escaping(caret() - 1, 7) 72463 continue 72464 // / 72465 case 47: 72466 switch (peek()) { 72467 case 42: case 47: 72468 Utility_append(Parser_comment(commenter(next(), caret()), root, parent), declarations) 72469 break 72470 default: 72471 characters += '/' 72472 } 72473 break 72474 // { 72475 case 123 * variable: 72476 points[index++] = Utility_strlen(characters) * ampersand 72477 // } ; \0 72478 case 125 * variable: case 59: case 0: 72479 switch (character) { 72480 // \0 } 72481 case 0: case 125: scanning = 0 72482 // ; 72483 case 59 + offset: 72484 if (property > 0 && (Utility_strlen(characters) - length)) 72485 Utility_append(property > 32 ? declaration(characters + ';', rule, parent, length - 1) : declaration(Utility_replace(characters, ' ', '') + ';', rule, parent, length - 2), declarations) 72486 break 72487 // @ ; 72488 case 59: characters += ';' 72489 // { rule/at-rule 72490 default: 72491 Utility_append(reference = ruleset(characters, root, parent, index, offset, rules, points, type, props = [], children = [], length), rulesets) 72492 72493 if (character === 123) 72494 if (offset === 0) 72495 Parser_parse(characters, root, reference, reference, props, rulesets, length, points, children) 72496 else 72497 switch (atrule === 99 && Utility_charat(characters, 3) === 110 ? 100 : atrule) { 72498 // d m s 72499 case 100: case 109: case 115: 72500 Parser_parse(value, reference, reference, rule && Utility_append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length), children), rules, children, length, points, rule ? props : children) 72501 break 72502 default: 72503 Parser_parse(characters, reference, reference, reference, [''], children, 0, points, children) 72504 } 72505 } 72506 72507 index = offset = property = 0, variable = ampersand = 1, type = characters = '', length = pseudo 72508 break 72509 // : 72510 case 58: 72511 length = 1 + Utility_strlen(characters), property = previous 72512 default: 72513 if (variable < 1) 72514 if (character == 123) 72515 --variable 72516 else if (character == 125 && variable++ == 0 && prev() == 125) 72517 continue 72518 72519 switch (characters += Utility_from(character), character * variable) { 72520 // & 72521 case 38: 72522 ampersand = offset > 0 ? 1 : (characters += '\f', -1) 72523 break 72524 // , 72525 case 44: 72526 points[index++] = (Utility_strlen(characters) - 1) * ampersand, ampersand = 1 72527 break 72528 // @ 72529 case 64: 72530 // - 72531 if (peek() === 45) 72532 characters += delimit(next()) 72533 72534 atrule = peek(), offset = length = Utility_strlen(type = characters += identifier(caret())), character++ 72535 break 72536 // - 72537 case 45: 72538 if (previous === 45 && Utility_strlen(characters) == 2) 72539 variable = 0 72540 } 72541 } 72542 72543 return rulesets 72544 } 72545 72546 /** 72547 * @param {string} value 72548 * @param {object} root 72549 * @param {object?} parent 72550 * @param {number} index 72551 * @param {number} offset 72552 * @param {string[]} rules 72553 * @param {number[]} points 72554 * @param {string} type 72555 * @param {string[]} props 72556 * @param {string[]} children 72557 * @param {number} length 72558 * @return {object} 72559 */ 72560 function ruleset (value, root, parent, index, offset, rules, points, type, props, children, length) { 72561 var post = offset - 1 72562 var rule = offset === 0 ? rules : [''] 72563 var size = Utility_sizeof(rule) 72564 72565 for (var i = 0, j = 0, k = 0; i < index; ++i) 72566 for (var x = 0, y = Utility_substr(value, post + 1, post = abs(j = points[i])), z = value; x < size; ++x) 72567 if (z = trim(j > 0 ? rule[x] + ' ' + y : Utility_replace(y, /&\f/g, rule[x]))) 72568 props[k++] = z 72569 72570 return node(value, root, parent, offset === 0 ? Enum_RULESET : type, props, children, length) 72571 } 72572 72573 /** 72574 * @param {number} value 72575 * @param {object} root 72576 * @param {object?} parent 72577 * @return {object} 72578 */ 72579 function Parser_comment (value, root, parent) { 72580 return node(value, root, parent, COMMENT, Utility_from(Tokenizer_char()), Utility_substr(value, 2, -2), 0) 72581 } 72582 72583 /** 72584 * @param {string} value 72585 * @param {object} root 72586 * @param {object?} parent 72587 * @param {number} length 72588 * @return {object} 72589 */ 72590 function declaration (value, root, parent, length) { 72591 return node(value, root, parent, Enum_DECLARATION, Utility_substr(value, 0, length), Utility_substr(value, length + 1, -1), length) 72592 } 72593 72594 ;// ./node_modules/@emotion/cache/dist/emotion-cache.browser.esm.js 72595 72596 72597 72598 72599 72600 var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) { 72601 var previous = 0; 72602 var character = 0; 72603 72604 while (true) { 72605 previous = character; 72606 character = peek(); // &\f 72607 72608 if (previous === 38 && character === 12) { 72609 points[index] = 1; 72610 } 72611 72612 if (token(character)) { 72613 break; 72614 } 72615 72616 next(); 72617 } 72618 72619 return slice(begin, Tokenizer_position); 72620 }; 72621 72622 var toRules = function toRules(parsed, points) { 72623 // pretend we've started with a comma 72624 var index = -1; 72625 var character = 44; 72626 72627 do { 72628 switch (token(character)) { 72629 case 0: 72630 // &\f 72631 if (character === 38 && peek() === 12) { 72632 // this is not 100% correct, we don't account for literal sequences here - like for example quoted strings 72633 // stylis inserts \f after & to know when & where it should replace this sequence with the context selector 72634 // and when it should just concatenate the outer and inner selectors 72635 // it's very unlikely for this sequence to actually appear in a different context, so we just leverage this fact here 72636 points[index] = 1; 72637 } 72638 72639 parsed[index] += identifierWithPointTracking(Tokenizer_position - 1, points, index); 72640 break; 72641 72642 case 2: 72643 parsed[index] += delimit(character); 72644 break; 72645 72646 case 4: 72647 // comma 72648 if (character === 44) { 72649 // colon 72650 parsed[++index] = peek() === 58 ? '&\f' : ''; 72651 points[index] = parsed[index].length; 72652 break; 72653 } 72654 72655 // fallthrough 72656 72657 default: 72658 parsed[index] += Utility_from(character); 72659 } 72660 } while (character = next()); 72661 72662 return parsed; 72663 }; 72664 72665 var getRules = function getRules(value, points) { 72666 return dealloc(toRules(alloc(value), points)); 72667 }; // WeakSet would be more appropriate, but only WeakMap is supported in IE11 72668 72669 72670 var fixedElements = /* #__PURE__ */new WeakMap(); 72671 var compat = function compat(element) { 72672 if (element.type !== 'rule' || !element.parent || // positive .length indicates that this rule contains pseudo 72673 // negative .length indicates that this rule has been already prefixed 72674 element.length < 1) { 72675 return; 72676 } 72677 72678 var value = element.value, 72679 parent = element.parent; 72680 var isImplicitRule = element.column === parent.column && element.line === parent.line; 72681 72682 while (parent.type !== 'rule') { 72683 parent = parent.parent; 72684 if (!parent) return; 72685 } // short-circuit for the simplest case 72686 72687 72688 if (element.props.length === 1 && value.charCodeAt(0) !== 58 72689 /* colon */ 72690 && !fixedElements.get(parent)) { 72691 return; 72692 } // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level) 72693 // then the props has already been manipulated beforehand as they that array is shared between it and its "rule parent" 72694 72695 72696 if (isImplicitRule) { 72697 return; 72698 } 72699 72700 fixedElements.set(element, true); 72701 var points = []; 72702 var rules = getRules(value, points); 72703 var parentRules = parent.props; 72704 72705 for (var i = 0, k = 0; i < rules.length; i++) { 72706 for (var j = 0; j < parentRules.length; j++, k++) { 72707 element.props[k] = points[i] ? rules[i].replace(/&\f/g, parentRules[j]) : parentRules[j] + " " + rules[i]; 72708 } 72709 } 72710 }; 72711 var removeLabel = function removeLabel(element) { 72712 if (element.type === 'decl') { 72713 var value = element.value; 72714 72715 if ( // charcode for l 72716 value.charCodeAt(0) === 108 && // charcode for b 72717 value.charCodeAt(2) === 98) { 72718 // this ignores label 72719 element["return"] = ''; 72720 element.value = ''; 72721 } 72722 } 72723 }; 72724 var ignoreFlag = 'emotion-disable-server-rendering-unsafe-selector-warning-please-do-not-use-this-the-warning-exists-for-a-reason'; 72725 72726 var isIgnoringComment = function isIgnoringComment(element) { 72727 return element.type === 'comm' && element.children.indexOf(ignoreFlag) > -1; 72728 }; 72729 72730 var createUnsafeSelectorsAlarm = function createUnsafeSelectorsAlarm(cache) { 72731 return function (element, index, children) { 72732 if (element.type !== 'rule' || cache.compat) return; 72733 var unsafePseudoClasses = element.value.match(/(:first|:nth|:nth-last)-child/g); 72734 72735 if (unsafePseudoClasses) { 72736 var isNested = element.parent === children[0]; // in nested rules comments become children of the "auto-inserted" rule 72737 // 72738 // considering this input: 72739 // .a { 72740 // .b /* comm */ {} 72741 // color: hotpink; 72742 // } 72743 // we get output corresponding to this: 72744 // .a { 72745 // & { 72746 // /* comm */ 72747 // color: hotpink; 72748 // } 72749 // .b {} 72750 // } 72751 72752 var commentContainer = isNested ? children[0].children : // global rule at the root level 72753 children; 72754 72755 for (var i = commentContainer.length - 1; i >= 0; i--) { 72756 var node = commentContainer[i]; 72757 72758 if (node.line < element.line) { 72759 break; 72760 } // it is quite weird but comments are *usually* put at `column: element.column - 1` 72761 // so we seek *from the end* for the node that is earlier than the rule's `element` and check that 72762 // this will also match inputs like this: 72763 // .a { 72764 // /* comm */ 72765 // .b {} 72766 // } 72767 // 72768 // but that is fine 72769 // 72770 // it would be the easiest to change the placement of the comment to be the first child of the rule: 72771 // .a { 72772 // .b { /* comm */ } 72773 // } 72774 // with such inputs we wouldn't have to search for the comment at all 72775 // TODO: consider changing this comment placement in the next major version 72776 72777 72778 if (node.column < element.column) { 72779 if (isIgnoringComment(node)) { 72780 return; 72781 } 72782 72783 break; 72784 } 72785 } 72786 72787 unsafePseudoClasses.forEach(function (unsafePseudoClass) { 72788 console.error("The pseudo class \"" + unsafePseudoClass + "\" is potentially unsafe when doing server-side rendering. Try changing it to \"" + unsafePseudoClass.split('-child')[0] + "-of-type\"."); 72789 }); 72790 } 72791 }; 72792 }; 72793 72794 var isImportRule = function isImportRule(element) { 72795 return element.type.charCodeAt(1) === 105 && element.type.charCodeAt(0) === 64; 72796 }; 72797 72798 var isPrependedWithRegularRules = function isPrependedWithRegularRules(index, children) { 72799 for (var i = index - 1; i >= 0; i--) { 72800 if (!isImportRule(children[i])) { 72801 return true; 72802 } 72803 } 72804 72805 return false; 72806 }; // use this to remove incorrect elements from further processing 72807 // so they don't get handed to the `sheet` (or anything else) 72808 // as that could potentially lead to additional logs which in turn could be overhelming to the user 72809 72810 72811 var nullifyElement = function nullifyElement(element) { 72812 element.type = ''; 72813 element.value = ''; 72814 element["return"] = ''; 72815 element.children = ''; 72816 element.props = ''; 72817 }; 72818 72819 var incorrectImportAlarm = function incorrectImportAlarm(element, index, children) { 72820 if (!isImportRule(element)) { 72821 return; 72822 } 72823 72824 if (element.parent) { 72825 console.error("`@import` rules can't be nested inside other rules. Please move it to the top level and put it before regular rules. Keep in mind that they can only be used within global styles."); 72826 nullifyElement(element); 72827 } else if (isPrependedWithRegularRules(index, children)) { 72828 console.error("`@import` rules can't be after other rules. Please put your `@import` rules before your other rules."); 72829 nullifyElement(element); 72830 } 72831 }; 72832 72833 /* eslint-disable no-fallthrough */ 72834 72835 function emotion_cache_browser_esm_prefix(value, length) { 72836 switch (hash(value, length)) { 72837 // color-adjust 72838 case 5103: 72839 return Enum_WEBKIT + 'print-' + value + value; 72840 // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function) 72841 72842 case 5737: 72843 case 4201: 72844 case 3177: 72845 case 3433: 72846 case 1641: 72847 case 4457: 72848 case 2921: // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break 72849 72850 case 5572: 72851 case 6356: 72852 case 5844: 72853 case 3191: 72854 case 6645: 72855 case 3005: // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite, 72856 72857 case 6391: 72858 case 5879: 72859 case 5623: 72860 case 6135: 72861 case 4599: 72862 case 4855: // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width) 72863 72864 case 4215: 72865 case 6389: 72866 case 5109: 72867 case 5365: 72868 case 5621: 72869 case 3829: 72870 return Enum_WEBKIT + value + value; 72871 // appearance, user-select, transform, hyphens, text-size-adjust 72872 72873 case 5349: 72874 case 4246: 72875 case 4810: 72876 case 6968: 72877 case 2756: 72878 return Enum_WEBKIT + value + Enum_MOZ + value + Enum_MS + value + value; 72879 // flex, flex-direction 72880 72881 case 6828: 72882 case 4268: 72883 return Enum_WEBKIT + value + Enum_MS + value + value; 72884 // order 72885 72886 case 6165: 72887 return Enum_WEBKIT + value + Enum_MS + 'flex-' + value + value; 72888 // align-items 72889 72890 case 5187: 72891 return Enum_WEBKIT + value + Utility_replace(value, /(\w+).+(:[^]+)/, Enum_WEBKIT + 'box-$1$2' + Enum_MS + 'flex-$1$2') + value; 72892 // align-self 72893 72894 case 5443: 72895 return Enum_WEBKIT + value + Enum_MS + 'flex-item-' + Utility_replace(value, /flex-|-self/, '') + value; 72896 // align-content 72897 72898 case 4675: 72899 return Enum_WEBKIT + value + Enum_MS + 'flex-line-pack' + Utility_replace(value, /align-content|flex-|-self/, '') + value; 72900 // flex-shrink 72901 72902 case 5548: 72903 return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, 'shrink', 'negative') + value; 72904 // flex-basis 72905 72906 case 5292: 72907 return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, 'basis', 'preferred-size') + value; 72908 // flex-grow 72909 72910 case 6060: 72911 return Enum_WEBKIT + 'box-' + Utility_replace(value, '-grow', '') + Enum_WEBKIT + value + Enum_MS + Utility_replace(value, 'grow', 'positive') + value; 72912 // transition 72913 72914 case 4554: 72915 return Enum_WEBKIT + Utility_replace(value, /([^-])(transform)/g, '$1' + Enum_WEBKIT + '$2') + value; 72916 // cursor 72917 72918 case 6187: 72919 return Utility_replace(Utility_replace(Utility_replace(value, /(zoom-|grab)/, Enum_WEBKIT + '$1'), /(image-set)/, Enum_WEBKIT + '$1'), value, '') + value; 72920 // background, background-image 72921 72922 case 5495: 72923 case 3959: 72924 return Utility_replace(value, /(image-set\([^]*)/, Enum_WEBKIT + '$1' + '$`$1'); 72925 // justify-content 72926 72927 case 4968: 72928 return Utility_replace(Utility_replace(value, /(.+:)(flex-)?(.*)/, Enum_WEBKIT + 'box-pack:$3' + Enum_MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + Enum_WEBKIT + value + value; 72929 // (margin|padding)-inline-(start|end) 72930 72931 case 4095: 72932 case 3583: 72933 case 4068: 72934 case 2532: 72935 return Utility_replace(value, /(.+)-inline(.+)/, Enum_WEBKIT + '$1$2') + value; 72936 // (min|max)?(width|height|inline-size|block-size) 72937 72938 case 8116: 72939 case 7059: 72940 case 5753: 72941 case 5535: 72942 case 5445: 72943 case 5701: 72944 case 4933: 72945 case 4677: 72946 case 5533: 72947 case 5789: 72948 case 5021: 72949 case 4765: 72950 // stretch, max-content, min-content, fill-available 72951 if (Utility_strlen(value) - 1 - length > 6) switch (Utility_charat(value, length + 1)) { 72952 // (m)ax-content, (m)in-content 72953 case 109: 72954 // - 72955 if (Utility_charat(value, length + 4) !== 45) break; 72956 // (f)ill-available, (f)it-content 72957 72958 case 102: 72959 return Utility_replace(value, /(.+:)(.+)-([^]+)/, '$1' + Enum_WEBKIT + '$2-$3' + '$1' + Enum_MOZ + (Utility_charat(value, length + 3) == 108 ? '$3' : '$2-$3')) + value; 72960 // (s)tretch 72961 72962 case 115: 72963 return ~indexof(value, 'stretch') ? emotion_cache_browser_esm_prefix(Utility_replace(value, 'stretch', 'fill-available'), length) + value : value; 72964 } 72965 break; 72966 // position: sticky 72967 72968 case 4949: 72969 // (s)ticky? 72970 if (Utility_charat(value, length + 1) !== 115) break; 72971 // display: (flex|inline-flex) 72972 72973 case 6444: 72974 switch (Utility_charat(value, Utility_strlen(value) - 3 - (~indexof(value, '!important') && 10))) { 72975 // stic(k)y 72976 case 107: 72977 return Utility_replace(value, ':', ':' + Enum_WEBKIT) + value; 72978 // (inline-)?fl(e)x 72979 72980 case 101: 72981 return Utility_replace(value, /(.+:)([^;!]+)(;|!.+)?/, '$1' + Enum_WEBKIT + (Utility_charat(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + Enum_WEBKIT + '$2$3' + '$1' + Enum_MS + '$2box$3') + value; 72982 } 72983 72984 break; 72985 // writing-mode 72986 72987 case 5936: 72988 switch (Utility_charat(value, length + 11)) { 72989 // vertical-l(r) 72990 case 114: 72991 return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, /[svh]\w+-[tblr]{2}/, 'tb') + value; 72992 // vertical-r(l) 72993 72994 case 108: 72995 return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') + value; 72996 // horizontal(-)tb 72997 72998 case 45: 72999 return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, /[svh]\w+-[tblr]{2}/, 'lr') + value; 73000 } 73001 73002 return Enum_WEBKIT + value + Enum_MS + value + value; 73003 } 73004 73005 return value; 73006 } 73007 73008 var emotion_cache_browser_esm_prefixer = function prefixer(element, index, children, callback) { 73009 if (element.length > -1) if (!element["return"]) switch (element.type) { 73010 case Enum_DECLARATION: 73011 element["return"] = emotion_cache_browser_esm_prefix(element.value, element.length); 73012 break; 73013 73014 case Enum_KEYFRAMES: 73015 return Serializer_serialize([Tokenizer_copy(element, { 73016 value: Utility_replace(element.value, '@', '@' + Enum_WEBKIT) 73017 })], callback); 73018 73019 case Enum_RULESET: 73020 if (element.length) return Utility_combine(element.props, function (value) { 73021 switch (Utility_match(value, /(::plac\w+|:read-\w+)/)) { 73022 // :read-(only|write) 73023 case ':read-only': 73024 case ':read-write': 73025 return Serializer_serialize([Tokenizer_copy(element, { 73026 props: [Utility_replace(value, /:(read-\w+)/, ':' + Enum_MOZ + '$1')] 73027 })], callback); 73028 // :placeholder 73029 73030 case '::placeholder': 73031 return Serializer_serialize([Tokenizer_copy(element, { 73032 props: [Utility_replace(value, /:(plac\w+)/, ':' + Enum_WEBKIT + 'input-$1')] 73033 }), Tokenizer_copy(element, { 73034 props: [Utility_replace(value, /:(plac\w+)/, ':' + Enum_MOZ + '$1')] 73035 }), Tokenizer_copy(element, { 73036 props: [Utility_replace(value, /:(plac\w+)/, Enum_MS + 'input-$1')] 73037 })], callback); 73038 } 73039 73040 return ''; 73041 }); 73042 } 73043 }; 73044 73045 var defaultStylisPlugins = [emotion_cache_browser_esm_prefixer]; 73046 73047 var createCache = function createCache(options) { 73048 var key = options.key; 73049 73050 if (false) {} 73051 73052 if ( key === 'css') { 73053 var ssrStyles = document.querySelectorAll("style[data-emotion]:not([data-s])"); // get SSRed styles out of the way of React's hydration 73054 // document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be) 73055 // note this very very intentionally targets all style elements regardless of the key to ensure 73056 // that creating a cache works inside of render of a React component 73057 73058 Array.prototype.forEach.call(ssrStyles, function (node) { 73059 // we want to only move elements which have a space in the data-emotion attribute value 73060 // because that indicates that it is an Emotion 11 server-side rendered style elements 73061 // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector 73062 // Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes) 73063 // so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles 73064 // will not result in the Emotion 10 styles being destroyed 73065 var dataEmotionAttribute = node.getAttribute('data-emotion'); 73066 73067 if (dataEmotionAttribute.indexOf(' ') === -1) { 73068 return; 73069 } 73070 document.head.appendChild(node); 73071 node.setAttribute('data-s', ''); 73072 }); 73073 } 73074 73075 var stylisPlugins = options.stylisPlugins || defaultStylisPlugins; 73076 73077 if (false) {} 73078 73079 var inserted = {}; 73080 var container; 73081 var nodesToHydrate = []; 73082 73083 { 73084 container = options.container || document.head; 73085 Array.prototype.forEach.call( // this means we will ignore elements which don't have a space in them which 73086 // means that the style elements we're looking at are only Emotion 11 server-rendered style elements 73087 document.querySelectorAll("style[data-emotion^=\"" + key + " \"]"), function (node) { 73088 var attrib = node.getAttribute("data-emotion").split(' '); // $FlowFixMe 73089 73090 for (var i = 1; i < attrib.length; i++) { 73091 inserted[attrib[i]] = true; 73092 } 73093 73094 nodesToHydrate.push(node); 73095 }); 73096 } 73097 73098 var _insert; 73099 73100 var omnipresentPlugins = [compat, removeLabel]; 73101 73102 if (false) {} 73103 73104 { 73105 var currentSheet; 73106 var finalizingPlugins = [Serializer_stringify, false ? 0 : rulesheet(function (rule) { 73107 currentSheet.insert(rule); 73108 })]; 73109 var serializer = middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins)); 73110 73111 var stylis = function stylis(styles) { 73112 return Serializer_serialize(compile(styles), serializer); 73113 }; 73114 73115 _insert = function insert(selector, serialized, sheet, shouldCache) { 73116 currentSheet = sheet; 73117 73118 if (false) {} 73119 73120 stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles); 73121 73122 if (shouldCache) { 73123 cache.inserted[serialized.name] = true; 73124 } 73125 }; 73126 } 73127 73128 var cache = { 73129 key: key, 73130 sheet: new StyleSheet({ 73131 key: key, 73132 container: container, 73133 nonce: options.nonce, 73134 speedy: options.speedy, 73135 prepend: options.prepend, 73136 insertionPoint: options.insertionPoint 73137 }), 73138 nonce: options.nonce, 73139 inserted: inserted, 73140 registered: {}, 73141 insert: _insert 73142 }; 73143 cache.sheet.hydrate(nodesToHydrate); 73144 return cache; 73145 }; 73146 73147 /* harmony default export */ const emotion_cache_browser_esm = (createCache); 73148 73149 ;// ./node_modules/@emotion/hash/dist/emotion-hash.esm.js 73150 /* eslint-disable */ 73151 // Inspired by https://github.com/garycourt/murmurhash-js 73152 // Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86 73153 function murmur2(str) { 73154 // 'm' and 'r' are mixing constants generated offline. 73155 // They're not really 'magic', they just happen to work well. 73156 // const m = 0x5bd1e995; 73157 // const r = 24; 73158 // Initialize the hash 73159 var h = 0; // Mix 4 bytes at a time into the hash 73160 73161 var k, 73162 i = 0, 73163 len = str.length; 73164 73165 for (; len >= 4; ++i, len -= 4) { 73166 k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24; 73167 k = 73168 /* Math.imul(k, m): */ 73169 (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16); 73170 k ^= 73171 /* k >>> r: */ 73172 k >>> 24; 73173 h = 73174 /* Math.imul(k, m): */ 73175 (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^ 73176 /* Math.imul(h, m): */ 73177 (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16); 73178 } // Handle the last few bytes of the input array 73179 73180 73181 switch (len) { 73182 case 3: 73183 h ^= (str.charCodeAt(i + 2) & 0xff) << 16; 73184 73185 case 2: 73186 h ^= (str.charCodeAt(i + 1) & 0xff) << 8; 73187 73188 case 1: 73189 h ^= str.charCodeAt(i) & 0xff; 73190 h = 73191 /* Math.imul(h, m): */ 73192 (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16); 73193 } // Do a few final mixes of the hash to ensure the last few 73194 // bytes are well-incorporated. 73195 73196 73197 h ^= h >>> 13; 73198 h = 73199 /* Math.imul(h, m): */ 73200 (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16); 73201 return ((h ^ h >>> 15) >>> 0).toString(36); 73202 } 73203 73204 /* harmony default export */ const emotion_hash_esm = (murmur2); 73205 73206 ;// ./node_modules/@emotion/unitless/dist/emotion-unitless.esm.js 73207 var unitlessKeys = { 73208 animationIterationCount: 1, 73209 borderImageOutset: 1, 73210 borderImageSlice: 1, 73211 borderImageWidth: 1, 73212 boxFlex: 1, 73213 boxFlexGroup: 1, 73214 boxOrdinalGroup: 1, 73215 columnCount: 1, 73216 columns: 1, 73217 flex: 1, 73218 flexGrow: 1, 73219 flexPositive: 1, 73220 flexShrink: 1, 73221 flexNegative: 1, 73222 flexOrder: 1, 73223 gridRow: 1, 73224 gridRowEnd: 1, 73225 gridRowSpan: 1, 73226 gridRowStart: 1, 73227 gridColumn: 1, 73228 gridColumnEnd: 1, 73229 gridColumnSpan: 1, 73230 gridColumnStart: 1, 73231 msGridRow: 1, 73232 msGridRowSpan: 1, 73233 msGridColumn: 1, 73234 msGridColumnSpan: 1, 73235 fontWeight: 1, 73236 lineHeight: 1, 73237 opacity: 1, 73238 order: 1, 73239 orphans: 1, 73240 tabSize: 1, 73241 widows: 1, 73242 zIndex: 1, 73243 zoom: 1, 73244 WebkitLineClamp: 1, 73245 // SVG-related properties 73246 fillOpacity: 1, 73247 floodOpacity: 1, 73248 stopOpacity: 1, 73249 strokeDasharray: 1, 73250 strokeDashoffset: 1, 73251 strokeMiterlimit: 1, 73252 strokeOpacity: 1, 73253 strokeWidth: 1 73254 }; 73255 73256 /* harmony default export */ const emotion_unitless_esm = (unitlessKeys); 73257 73258 ;// ./node_modules/@emotion/serialize/dist/emotion-serialize.browser.esm.js 73259 73260 73261 73262 73263 var ILLEGAL_ESCAPE_SEQUENCE_ERROR = "You have illegal escape sequence in your template literal, most likely inside content's property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \"content: '\\00d7';\" should become \"content: '\\\\00d7';\".\nYou can read more about this here:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences"; 73264 var UNDEFINED_AS_OBJECT_KEY_ERROR = "You have passed in falsy value as style object's key (can happen when in example you pass unexported component as computed key)."; 73265 var hyphenateRegex = /[A-Z]|^ms/g; 73266 var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g; 73267 73268 var isCustomProperty = function isCustomProperty(property) { 73269 return property.charCodeAt(1) === 45; 73270 }; 73271 73272 var isProcessableValue = function isProcessableValue(value) { 73273 return value != null && typeof value !== 'boolean'; 73274 }; 73275 73276 var processStyleName = /* #__PURE__ */memoize(function (styleName) { 73277 return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, '-$&').toLowerCase(); 73278 }); 73279 73280 var processStyleValue = function processStyleValue(key, value) { 73281 switch (key) { 73282 case 'animation': 73283 case 'animationName': 73284 { 73285 if (typeof value === 'string') { 73286 return value.replace(animationRegex, function (match, p1, p2) { 73287 cursor = { 73288 name: p1, 73289 styles: p2, 73290 next: cursor 73291 }; 73292 return p1; 73293 }); 73294 } 73295 } 73296 } 73297 73298 if (emotion_unitless_esm[key] !== 1 && !isCustomProperty(key) && typeof value === 'number' && value !== 0) { 73299 return value + 'px'; 73300 } 73301 73302 return value; 73303 }; 73304 73305 if (false) { var hyphenatedCache, hyphenPattern, msPattern, oldProcessStyleValue, contentValues, contentValuePattern; } 73306 73307 var noComponentSelectorMessage = (/* unused pure expression or super */ null && ('Component selectors can only be used in conjunction with ' + '@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware ' + 'compiler transform.')); 73308 73309 function handleInterpolation(mergedProps, registered, interpolation) { 73310 if (interpolation == null) { 73311 return ''; 73312 } 73313 73314 if (interpolation.__emotion_styles !== undefined) { 73315 if (false) {} 73316 73317 return interpolation; 73318 } 73319 73320 switch (typeof interpolation) { 73321 case 'boolean': 73322 { 73323 return ''; 73324 } 73325 73326 case 'object': 73327 { 73328 if (interpolation.anim === 1) { 73329 cursor = { 73330 name: interpolation.name, 73331 styles: interpolation.styles, 73332 next: cursor 73333 }; 73334 return interpolation.name; 73335 } 73336 73337 if (interpolation.styles !== undefined) { 73338 var next = interpolation.next; 73339 73340 if (next !== undefined) { 73341 // not the most efficient thing ever but this is a pretty rare case 73342 // and there will be very few iterations of this generally 73343 while (next !== undefined) { 73344 cursor = { 73345 name: next.name, 73346 styles: next.styles, 73347 next: cursor 73348 }; 73349 next = next.next; 73350 } 73351 } 73352 73353 var styles = interpolation.styles + ";"; 73354 73355 if (false) {} 73356 73357 return styles; 73358 } 73359 73360 return createStringFromObject(mergedProps, registered, interpolation); 73361 } 73362 73363 case 'function': 73364 { 73365 if (mergedProps !== undefined) { 73366 var previousCursor = cursor; 73367 var result = interpolation(mergedProps); 73368 cursor = previousCursor; 73369 return handleInterpolation(mergedProps, registered, result); 73370 } else if (false) {} 73371 73372 break; 73373 } 73374 73375 case 'string': 73376 if (false) { var replaced, matched; } 73377 73378 break; 73379 } // finalize string values (regular strings and functions interpolated into css calls) 73380 73381 73382 if (registered == null) { 73383 return interpolation; 73384 } 73385 73386 var cached = registered[interpolation]; 73387 return cached !== undefined ? cached : interpolation; 73388 } 73389 73390 function createStringFromObject(mergedProps, registered, obj) { 73391 var string = ''; 73392 73393 if (Array.isArray(obj)) { 73394 for (var i = 0; i < obj.length; i++) { 73395 string += handleInterpolation(mergedProps, registered, obj[i]) + ";"; 73396 } 73397 } else { 73398 for (var _key in obj) { 73399 var value = obj[_key]; 73400 73401 if (typeof value !== 'object') { 73402 if (registered != null && registered[value] !== undefined) { 73403 string += _key + "{" + registered[value] + "}"; 73404 } else if (isProcessableValue(value)) { 73405 string += processStyleName(_key) + ":" + processStyleValue(_key, value) + ";"; 73406 } 73407 } else { 73408 if (_key === 'NO_COMPONENT_SELECTOR' && "production" !== 'production') {} 73409 73410 if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) { 73411 for (var _i = 0; _i < value.length; _i++) { 73412 if (isProcessableValue(value[_i])) { 73413 string += processStyleName(_key) + ":" + processStyleValue(_key, value[_i]) + ";"; 73414 } 73415 } 73416 } else { 73417 var interpolated = handleInterpolation(mergedProps, registered, value); 73418 73419 switch (_key) { 73420 case 'animation': 73421 case 'animationName': 73422 { 73423 string += processStyleName(_key) + ":" + interpolated + ";"; 73424 break; 73425 } 73426 73427 default: 73428 { 73429 if (false) {} 73430 73431 string += _key + "{" + interpolated + "}"; 73432 } 73433 } 73434 } 73435 } 73436 } 73437 } 73438 73439 return string; 73440 } 73441 73442 var labelPattern = /label:\s*([^\s;\n{]+)\s*(;|$)/g; 73443 var sourceMapPattern; 73444 73445 if (false) {} // this is the cursor for keyframes 73446 // keyframes are stored on the SerializedStyles object as a linked list 73447 73448 73449 var cursor; 73450 var emotion_serialize_browser_esm_serializeStyles = function serializeStyles(args, registered, mergedProps) { 73451 if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) { 73452 return args[0]; 73453 } 73454 73455 var stringMode = true; 73456 var styles = ''; 73457 cursor = undefined; 73458 var strings = args[0]; 73459 73460 if (strings == null || strings.raw === undefined) { 73461 stringMode = false; 73462 styles += handleInterpolation(mergedProps, registered, strings); 73463 } else { 73464 if (false) {} 73465 73466 styles += strings[0]; 73467 } // we start at 1 since we've already handled the first arg 73468 73469 73470 for (var i = 1; i < args.length; i++) { 73471 styles += handleInterpolation(mergedProps, registered, args[i]); 73472 73473 if (stringMode) { 73474 if (false) {} 73475 73476 styles += strings[i]; 73477 } 73478 } 73479 73480 var sourceMap; 73481 73482 if (false) {} // using a global regex with .exec is stateful so lastIndex has to be reset each time 73483 73484 73485 labelPattern.lastIndex = 0; 73486 var identifierName = ''; 73487 var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5 73488 73489 while ((match = labelPattern.exec(styles)) !== null) { 73490 identifierName += '-' + // $FlowFixMe we know it's not null 73491 match[1]; 73492 } 73493 73494 var name = emotion_hash_esm(styles) + identifierName; 73495 73496 if (false) {} 73497 73498 return { 73499 name: name, 73500 styles: styles, 73501 next: cursor 73502 }; 73503 }; 73504 73505 73506 73507 ;// ./node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js 73508 73509 73510 73511 var syncFallback = function syncFallback(create) { 73512 return create(); 73513 }; 73514 73515 var useInsertionEffect = external_React_['useInsertion' + 'Effect'] ? external_React_['useInsertion' + 'Effect'] : false; 73516 var emotion_use_insertion_effect_with_fallbacks_browser_esm_useInsertionEffectAlwaysWithSyncFallback = useInsertionEffect || syncFallback; 73517 var useInsertionEffectWithLayoutFallback = (/* unused pure expression or super */ null && (useInsertionEffect || useLayoutEffect)); 73518 73519 73520 73521 ;// ./node_modules/@emotion/react/dist/emotion-element-6a883da9.browser.esm.js 73522 73523 73524 73525 73526 73527 73528 73529 73530 73531 var emotion_element_6a883da9_browser_esm_hasOwnProperty = {}.hasOwnProperty; 73532 73533 var EmotionCacheContext = /* #__PURE__ */(0,external_React_.createContext)( // we're doing this to avoid preconstruct's dead code elimination in this one case 73534 // because this module is primarily intended for the browser and node 73535 // but it's also required in react native and similar environments sometimes 73536 // and we could have a special build just for that 73537 // but this is much easier and the native packages 73538 // might use a different theme context in the future anyway 73539 typeof HTMLElement !== 'undefined' ? /* #__PURE__ */emotion_cache_browser_esm({ 73540 key: 'css' 73541 }) : null); 73542 73543 if (false) {} 73544 73545 var CacheProvider = EmotionCacheContext.Provider; 73546 var __unsafe_useEmotionCache = function useEmotionCache() { 73547 return useContext(EmotionCacheContext); 73548 }; 73549 73550 var withEmotionCache = function withEmotionCache(func) { 73551 // $FlowFixMe 73552 return /*#__PURE__*/(0,external_React_.forwardRef)(function (props, ref) { 73553 // the cache will never be null in the browser 73554 var cache = (0,external_React_.useContext)(EmotionCacheContext); 73555 return func(props, cache, ref); 73556 }); 73557 }; 73558 73559 var ThemeContext = /* #__PURE__ */(0,external_React_.createContext)({}); 73560 73561 if (false) {} 73562 73563 var useTheme = function useTheme() { 73564 return useContext(ThemeContext); 73565 }; 73566 73567 var getTheme = function getTheme(outerTheme, theme) { 73568 if (typeof theme === 'function') { 73569 var mergedTheme = theme(outerTheme); 73570 73571 if (false) {} 73572 73573 return mergedTheme; 73574 } 73575 73576 if (false) {} 73577 73578 return _extends({}, outerTheme, theme); 73579 }; 73580 73581 var createCacheWithTheme = /* #__PURE__ */(/* unused pure expression or super */ null && (weakMemoize(function (outerTheme) { 73582 return weakMemoize(function (theme) { 73583 return getTheme(outerTheme, theme); 73584 }); 73585 }))); 73586 var ThemeProvider = function ThemeProvider(props) { 73587 var theme = useContext(ThemeContext); 73588 73589 if (props.theme !== theme) { 73590 theme = createCacheWithTheme(theme)(props.theme); 73591 } 73592 73593 return /*#__PURE__*/createElement(ThemeContext.Provider, { 73594 value: theme 73595 }, props.children); 73596 }; 73597 function withTheme(Component) { 73598 var componentName = Component.displayName || Component.name || 'Component'; 73599 73600 var render = function render(props, ref) { 73601 var theme = useContext(ThemeContext); 73602 return /*#__PURE__*/createElement(Component, _extends({ 73603 theme: theme, 73604 ref: ref 73605 }, props)); 73606 }; // $FlowFixMe 73607 73608 73609 var WithTheme = /*#__PURE__*/forwardRef(render); 73610 WithTheme.displayName = "WithTheme(" + componentName + ")"; 73611 return hoistNonReactStatics(WithTheme, Component); 73612 } 73613 73614 var getLastPart = function getLastPart(functionName) { 73615 // The match may be something like 'Object.createEmotionProps' or 73616 // 'Loader.prototype.render' 73617 var parts = functionName.split('.'); 73618 return parts[parts.length - 1]; 73619 }; 73620 73621 var getFunctionNameFromStackTraceLine = function getFunctionNameFromStackTraceLine(line) { 73622 // V8 73623 var match = /^\s+at\s+([A-Za-z0-9$.]+)\s/.exec(line); 73624 if (match) return getLastPart(match[1]); // Safari / Firefox 73625 73626 match = /^([A-Za-z0-9$.]+)@/.exec(line); 73627 if (match) return getLastPart(match[1]); 73628 return undefined; 73629 }; 73630 73631 var internalReactFunctionNames = /* #__PURE__ */new Set(['renderWithHooks', 'processChild', 'finishClassComponent', 'renderToString']); // These identifiers come from error stacks, so they have to be valid JS 73632 // identifiers, thus we only need to replace what is a valid character for JS, 73633 // but not for CSS. 73634 73635 var sanitizeIdentifier = function sanitizeIdentifier(identifier) { 73636 return identifier.replace(/\$/g, '-'); 73637 }; 73638 73639 var getLabelFromStackTrace = function getLabelFromStackTrace(stackTrace) { 73640 if (!stackTrace) return undefined; 73641 var lines = stackTrace.split('\n'); 73642 73643 for (var i = 0; i < lines.length; i++) { 73644 var functionName = getFunctionNameFromStackTraceLine(lines[i]); // The first line of V8 stack traces is just "Error" 73645 73646 if (!functionName) continue; // If we reach one of these, we have gone too far and should quit 73647 73648 if (internalReactFunctionNames.has(functionName)) break; // The component name is the first function in the stack that starts with an 73649 // uppercase letter 73650 73651 if (/^[A-Z]/.test(functionName)) return sanitizeIdentifier(functionName); 73652 } 73653 73654 return undefined; 73655 }; 73656 73657 var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__'; 73658 var labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__'; 73659 var createEmotionProps = function createEmotionProps(type, props) { 73660 if (false) {} 73661 73662 var newProps = {}; 73663 73664 for (var key in props) { 73665 if (emotion_element_6a883da9_browser_esm_hasOwnProperty.call(props, key)) { 73666 newProps[key] = props[key]; 73667 } 73668 } 73669 73670 newProps[typePropName] = type; // For performance, only call getLabelFromStackTrace in development and when 73671 // the label hasn't already been computed 73672 73673 if (false) { var label; } 73674 73675 return newProps; 73676 }; 73677 73678 var Insertion = function Insertion(_ref) { 73679 var cache = _ref.cache, 73680 serialized = _ref.serialized, 73681 isStringTag = _ref.isStringTag; 73682 registerStyles(cache, serialized, isStringTag); 73683 var rules = useInsertionEffectAlwaysWithSyncFallback(function () { 73684 return insertStyles(cache, serialized, isStringTag); 73685 }); 73686 73687 return null; 73688 }; 73689 73690 var Emotion = /* #__PURE__ */(/* unused pure expression or super */ null && (withEmotionCache(function (props, cache, ref) { 73691 var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works 73692 // not passing the registered cache to serializeStyles because it would 73693 // make certain babel optimisations not possible 73694 73695 if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) { 73696 cssProp = cache.registered[cssProp]; 73697 } 73698 73699 var WrappedComponent = props[typePropName]; 73700 var registeredStyles = [cssProp]; 73701 var className = ''; 73702 73703 if (typeof props.className === 'string') { 73704 className = getRegisteredStyles(cache.registered, registeredStyles, props.className); 73705 } else if (props.className != null) { 73706 className = props.className + " "; 73707 } 73708 73709 var serialized = serializeStyles(registeredStyles, undefined, useContext(ThemeContext)); 73710 73711 if (false) { var labelFromStack; } 73712 73713 className += cache.key + "-" + serialized.name; 73714 var newProps = {}; 73715 73716 for (var key in props) { 73717 if (emotion_element_6a883da9_browser_esm_hasOwnProperty.call(props, key) && key !== 'css' && key !== typePropName && ( true || 0)) { 73718 newProps[key] = props[key]; 73719 } 73720 } 73721 73722 newProps.ref = ref; 73723 newProps.className = className; 73724 return /*#__PURE__*/createElement(Fragment, null, /*#__PURE__*/createElement(Insertion, { 73725 cache: cache, 73726 serialized: serialized, 73727 isStringTag: typeof WrappedComponent === 'string' 73728 }), /*#__PURE__*/createElement(WrappedComponent, newProps)); 73729 }))); 73730 73731 if (false) {} 73732 73733 73734 73735 ;// ./node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js 73736 var isBrowser = "object" !== 'undefined'; 73737 function emotion_utils_browser_esm_getRegisteredStyles(registered, registeredStyles, classNames) { 73738 var rawClassName = ''; 73739 classNames.split(' ').forEach(function (className) { 73740 if (registered[className] !== undefined) { 73741 registeredStyles.push(registered[className] + ";"); 73742 } else { 73743 rawClassName += className + " "; 73744 } 73745 }); 73746 return rawClassName; 73747 } 73748 var emotion_utils_browser_esm_registerStyles = function registerStyles(cache, serialized, isStringTag) { 73749 var className = cache.key + "-" + serialized.name; 73750 73751 if ( // we only need to add the styles to the registered cache if the 73752 // class name could be used further down 73753 // the tree but if it's a string tag, we know it won't 73754 // so we don't have to add it to registered cache. 73755 // this improves memory usage since we can avoid storing the whole style string 73756 (isStringTag === false || // we need to always store it if we're in compat mode and 73757 // in node since emotion-server relies on whether a style is in 73758 // the registered cache to know whether a style is global or not 73759 // also, note that this check will be dead code eliminated in the browser 73760 isBrowser === false ) && cache.registered[className] === undefined) { 73761 cache.registered[className] = serialized.styles; 73762 } 73763 }; 73764 var emotion_utils_browser_esm_insertStyles = function insertStyles(cache, serialized, isStringTag) { 73765 emotion_utils_browser_esm_registerStyles(cache, serialized, isStringTag); 73766 var className = cache.key + "-" + serialized.name; 73767 73768 if (cache.inserted[serialized.name] === undefined) { 73769 var current = serialized; 73770 73771 do { 73772 var maybeStyles = cache.insert(serialized === current ? "." + className : '', current, cache.sheet, true); 73773 73774 current = current.next; 73775 } while (current !== undefined); 73776 } 73777 }; 73778 73779 73780 73781 ;// ./node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.esm.js 73782 73783 73784 73785 73786 73787 73788 73789 73790 var testOmitPropsOnStringTag = isPropValid; 73791 73792 var testOmitPropsOnComponent = function testOmitPropsOnComponent(key) { 73793 return key !== 'theme'; 73794 }; 73795 73796 var getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag) { 73797 return typeof tag === 'string' && // 96 is one less than the char code 73798 // for "a" so this is checking that 73799 // it's a lowercase character 73800 tag.charCodeAt(0) > 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent; 73801 }; 73802 var composeShouldForwardProps = function composeShouldForwardProps(tag, options, isReal) { 73803 var shouldForwardProp; 73804 73805 if (options) { 73806 var optionsShouldForwardProp = options.shouldForwardProp; 73807 shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function (propName) { 73808 return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName); 73809 } : optionsShouldForwardProp; 73810 } 73811 73812 if (typeof shouldForwardProp !== 'function' && isReal) { 73813 shouldForwardProp = tag.__emotion_forwardProp; 73814 } 73815 73816 return shouldForwardProp; 73817 }; 73818 73819 var emotion_styled_base_browser_esm_ILLEGAL_ESCAPE_SEQUENCE_ERROR = "You have illegal escape sequence in your template literal, most likely inside content's property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \"content: '\\00d7';\" should become \"content: '\\\\00d7';\".\nYou can read more about this here:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences"; 73820 73821 var emotion_styled_base_browser_esm_Insertion = function Insertion(_ref) { 73822 var cache = _ref.cache, 73823 serialized = _ref.serialized, 73824 isStringTag = _ref.isStringTag; 73825 emotion_utils_browser_esm_registerStyles(cache, serialized, isStringTag); 73826 var rules = emotion_use_insertion_effect_with_fallbacks_browser_esm_useInsertionEffectAlwaysWithSyncFallback(function () { 73827 return emotion_utils_browser_esm_insertStyles(cache, serialized, isStringTag); 73828 }); 73829 73830 return null; 73831 }; 73832 73833 var createStyled = function createStyled(tag, options) { 73834 if (false) {} 73835 73836 var isReal = tag.__emotion_real === tag; 73837 var baseTag = isReal && tag.__emotion_base || tag; 73838 var identifierName; 73839 var targetClassName; 73840 73841 if (options !== undefined) { 73842 identifierName = options.label; 73843 targetClassName = options.target; 73844 } 73845 73846 var shouldForwardProp = composeShouldForwardProps(tag, options, isReal); 73847 var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag); 73848 var shouldUseAs = !defaultShouldForwardProp('as'); 73849 return function () { 73850 var args = arguments; 73851 var styles = isReal && tag.__emotion_styles !== undefined ? tag.__emotion_styles.slice(0) : []; 73852 73853 if (identifierName !== undefined) { 73854 styles.push("label:" + identifierName + ";"); 73855 } 73856 73857 if (args[0] == null || args[0].raw === undefined) { 73858 styles.push.apply(styles, args); 73859 } else { 73860 if (false) {} 73861 73862 styles.push(args[0][0]); 73863 var len = args.length; 73864 var i = 1; 73865 73866 for (; i < len; i++) { 73867 if (false) {} 73868 73869 styles.push(args[i], args[0][i]); 73870 } 73871 } // $FlowFixMe: we need to cast StatelessFunctionalComponent to our PrivateStyledComponent class 73872 73873 73874 var Styled = withEmotionCache(function (props, cache, ref) { 73875 var FinalTag = shouldUseAs && props.as || baseTag; 73876 var className = ''; 73877 var classInterpolations = []; 73878 var mergedProps = props; 73879 73880 if (props.theme == null) { 73881 mergedProps = {}; 73882 73883 for (var key in props) { 73884 mergedProps[key] = props[key]; 73885 } 73886 73887 mergedProps.theme = (0,external_React_.useContext)(ThemeContext); 73888 } 73889 73890 if (typeof props.className === 'string') { 73891 className = emotion_utils_browser_esm_getRegisteredStyles(cache.registered, classInterpolations, props.className); 73892 } else if (props.className != null) { 73893 className = props.className + " "; 73894 } 73895 73896 var serialized = emotion_serialize_browser_esm_serializeStyles(styles.concat(classInterpolations), cache.registered, mergedProps); 73897 className += cache.key + "-" + serialized.name; 73898 73899 if (targetClassName !== undefined) { 73900 className += " " + targetClassName; 73901 } 73902 73903 var finalShouldForwardProp = shouldUseAs && shouldForwardProp === undefined ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp; 73904 var newProps = {}; 73905 73906 for (var _key in props) { 73907 if (shouldUseAs && _key === 'as') continue; 73908 73909 if ( // $FlowFixMe 73910 finalShouldForwardProp(_key)) { 73911 newProps[_key] = props[_key]; 73912 } 73913 } 73914 73915 newProps.className = className; 73916 newProps.ref = ref; 73917 return /*#__PURE__*/(0,external_React_.createElement)(external_React_.Fragment, null, /*#__PURE__*/(0,external_React_.createElement)(emotion_styled_base_browser_esm_Insertion, { 73918 cache: cache, 73919 serialized: serialized, 73920 isStringTag: typeof FinalTag === 'string' 73921 }), /*#__PURE__*/(0,external_React_.createElement)(FinalTag, newProps)); 73922 }); 73923 Styled.displayName = identifierName !== undefined ? identifierName : "Styled(" + (typeof baseTag === 'string' ? baseTag : baseTag.displayName || baseTag.name || 'Component') + ")"; 73924 Styled.defaultProps = tag.defaultProps; 73925 Styled.__emotion_real = Styled; 73926 Styled.__emotion_base = baseTag; 73927 Styled.__emotion_styles = styles; 73928 Styled.__emotion_forwardProp = shouldForwardProp; 73929 Object.defineProperty(Styled, 'toString', { 73930 value: function value() { 73931 if (targetClassName === undefined && "production" !== 'production') {} // $FlowFixMe: coerce undefined to string 73932 73933 73934 return "." + targetClassName; 73935 } 73936 }); 73937 73938 Styled.withComponent = function (nextTag, nextOptions) { 73939 return createStyled(nextTag, extends_extends({}, options, nextOptions, { 73940 shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true) 73941 })).apply(void 0, styles); 73942 }; 73943 73944 return Styled; 73945 }; 73946 }; 73947 73948 /* harmony default export */ const emotion_styled_base_browser_esm = (createStyled); 73949 73950 ;// ./node_modules/@wordpress/block-editor/build-module/components/dimensions-tool/width-height-tool.js 73951 73952 function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; } 73953 /** 73954 * External dependencies 73955 */ 73956 73957 /** 73958 * WordPress dependencies 73959 */ 73960 73961 73962 73963 73964 73965 const SingleColumnToolsPanelItem = /*#__PURE__*/emotion_styled_base_browser_esm(external_wp_components_namespaceObject.__experimentalToolsPanelItem, true ? { 73966 target: "ef8pe3d0" 73967 } : 0)( true ? { 73968 name: "957xgf", 73969 styles: "grid-column:span 1" 73970 } : 0); 73971 73972 /** 73973 * @typedef {import('@wordpress/components/build-types/unit-control/types').WPUnitControlUnit} WPUnitControlUnit 73974 */ 73975 73976 /** 73977 * @typedef {Object} WidthHeightToolValue 73978 * @property {string} [width] Width CSS value. 73979 * @property {string} [height] Height CSS value. 73980 */ 73981 73982 /** 73983 * @callback WidthHeightToolOnChange 73984 * @param {WidthHeightToolValue} nextValue Next dimensions value. 73985 * @return {void} 73986 */ 73987 73988 /** 73989 * @typedef {Object} WidthHeightToolProps 73990 * @property {string} [panelId] ID of the panel that contains the controls. 73991 * @property {WidthHeightToolValue} [value] Current dimensions values. 73992 * @property {WidthHeightToolOnChange} [onChange] Callback to update the dimensions values. 73993 * @property {WPUnitControlUnit[]} [units] Units options. 73994 * @property {boolean} [isShownByDefault] Whether the panel is shown by default. 73995 */ 73996 73997 /** 73998 * Component that renders controls to edit the dimensions of an image or container. 73999 * 74000 * @param {WidthHeightToolProps} props The component props. 74001 * 74002 * @return {import('react').ReactElement} The width and height tool. 74003 */ 74004 function WidthHeightTool({ 74005 panelId, 74006 value = {}, 74007 onChange = () => {}, 74008 units, 74009 isShownByDefault = true 74010 }) { 74011 var _value$width, _value$height; 74012 // null, undefined, and 'auto' all represent the default value. 74013 const width = value.width === 'auto' ? '' : (_value$width = value.width) !== null && _value$width !== void 0 ? _value$width : ''; 74014 const height = value.height === 'auto' ? '' : (_value$height = value.height) !== null && _value$height !== void 0 ? _value$height : ''; 74015 const onDimensionChange = dimension => nextDimension => { 74016 const nextValue = { 74017 ...value 74018 }; 74019 // Empty strings or undefined may be passed and both represent removing the value. 74020 if (!nextDimension) { 74021 delete nextValue[dimension]; 74022 } else { 74023 nextValue[dimension] = nextDimension; 74024 } 74025 onChange(nextValue); 74026 }; 74027 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 74028 children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SingleColumnToolsPanelItem, { 74029 label: (0,external_wp_i18n_namespaceObject.__)('Width'), 74030 isShownByDefault: isShownByDefault, 74031 hasValue: () => width !== '', 74032 onDeselect: onDimensionChange('width'), 74033 panelId: panelId, 74034 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 74035 label: (0,external_wp_i18n_namespaceObject.__)('Width'), 74036 placeholder: (0,external_wp_i18n_namespaceObject.__)('Auto'), 74037 labelPosition: "top", 74038 units: units, 74039 min: 0, 74040 value: width, 74041 onChange: onDimensionChange('width'), 74042 size: "__unstable-large" 74043 }) 74044 }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SingleColumnToolsPanelItem, { 74045 label: (0,external_wp_i18n_namespaceObject.__)('Height'), 74046 isShownByDefault: isShownByDefault, 74047 hasValue: () => height !== '', 74048 onDeselect: onDimensionChange('height'), 74049 panelId: panelId, 74050 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, { 74051 label: (0,external_wp_i18n_namespaceObject.__)('Height'), 74052 placeholder: (0,external_wp_i18n_namespaceObject.__)('Auto'), 74053 labelPosition: "top", 74054 units: units, 74055 min: 0, 74056 value: height, 74057 onChange: onDimensionChange('height'), 74058 size: "__unstable-large" 74059 }) 74060 })] 74061 }); 74062 } 74063 74064 ;// ./node_modules/@wordpress/block-editor/build-module/components/dimensions-tool/index.js 74065 /** 74066 * WordPress dependencies 74067 */ 74068 74069 74070 /** 74071 * Internal dependencies 74072 */ 74073 74074 74075 74076 74077 /** 74078 * @typedef {import('@wordpress/components/build-types/select-control/types').SelectControlProps} SelectControlProps 74079 */ 74080 74081 /** 74082 * @typedef {import('@wordpress/components/build-types/unit-control/types').WPUnitControlUnit} WPUnitControlUnit 74083 */ 74084 74085 /** 74086 * @typedef {Object} Dimensions 74087 * @property {string} [width] CSS width property. 74088 * @property {string} [height] CSS height property. 74089 * @property {string} [scale] CSS object-fit property. 74090 * @property {string} [aspectRatio] CSS aspect-ratio property. 74091 */ 74092 74093 /** 74094 * @callback DimensionsControlsOnChange 74095 * @param {Dimensions} nextValue 74096 * @return {void} 74097 */ 74098 74099 /** 74100 * @typedef {Object} DimensionsControlsProps 74101 * @property {string} [panelId] ID of the panel that contains the controls. 74102 * @property {Dimensions} [value] Current dimensions values. 74103 * @property {DimensionsControlsOnChange} [onChange] Callback to update the dimensions values. 74104 * @property {SelectControlProps[]} [aspectRatioOptions] Aspect ratio options. 74105 * @property {SelectControlProps[]} [scaleOptions] Scale options. 74106 * @property {WPUnitControlUnit[]} [unitsOptions] Units options. 74107 */ 74108 74109 /** 74110 * Component that renders controls to edit the dimensions of an image or container. 74111 * 74112 * @param {DimensionsControlsProps} props The component props. 74113 * 74114 * @return {Element} The dimensions controls. 74115 */ 74116 74117 74118 74119 function DimensionsTool({ 74120 panelId, 74121 value = {}, 74122 onChange = () => {}, 74123 aspectRatioOptions, 74124 // Default options handled by AspectRatioTool. 74125 defaultAspectRatio = 'auto', 74126 // Match CSS default value for aspect-ratio. 74127 scaleOptions, 74128 // Default options handled by ScaleTool. 74129 defaultScale = 'fill', 74130 // Match CSS default value for object-fit. 74131 unitsOptions, 74132 // Default options handled by UnitControl. 74133 tools = ['aspectRatio', 'widthHeight', 'scale'] 74134 }) { 74135 // Coerce undefined and CSS default values to be null. 74136 const width = value.width === undefined || value.width === 'auto' ? null : value.width; 74137 const height = value.height === undefined || value.height === 'auto' ? null : value.height; 74138 const aspectRatio = value.aspectRatio === undefined || value.aspectRatio === 'auto' ? null : value.aspectRatio; 74139 const scale = value.scale === undefined || value.scale === 'fill' ? null : value.scale; 74140 74141 // Keep track of state internally, so when the value is cleared by means 74142 // other than directly editing that field, it's easier to restore the 74143 // previous value. 74144 const [lastScale, setLastScale] = (0,external_wp_element_namespaceObject.useState)(scale); 74145 const [lastAspectRatio, setLastAspectRatio] = (0,external_wp_element_namespaceObject.useState)(aspectRatio); 74146 74147 // 'custom' is not a valid value for CSS aspect-ratio, but it is used in the 74148 // dropdown to indicate that setting both the width and height is the same 74149 // as a custom aspect ratio. 74150 const aspectRatioValue = width && height ? 'custom' : lastAspectRatio; 74151 const showScaleControl = aspectRatio || width && height; 74152 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { 74153 children: [tools.includes('aspectRatio') && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioTool, { 74154 panelId: panelId, 74155 options: aspectRatioOptions, 74156 defaultValue: defaultAspectRatio, 74157 value: aspectRatioValue, 74158 onChange: nextAspectRatio => { 74159 const nextValue = { 74160 ...value 74161 }; 74162 74163 // 'auto' is CSS default, so it gets treated as null. 74164 nextAspectRatio = nextAspectRatio === 'auto' ? null : nextAspectRatio; 74165 setLastAspectRatio(nextAspectRatio); 74166 74167 // Update aspectRatio. 74168 if (!nextAspectRatio) { 74169 delete nextValue.aspectRatio; 74170 } else { 74171 nextValue.aspectRatio = nextAspectRatio; 74172 } 74173 74174 // Auto-update scale. 74175 if (!nextAspectRatio) { 74176 delete nextValue.scale; 74177 } else if (lastScale) { 74178 nextValue.scale = lastScale; 74179 } else { 74180 nextValue.scale = defaultScale; 74181 setLastScale(defaultScale); 74182 } 74183 74184 // Auto-update width and height. 74185 if ('custom' !== nextAspectRatio && width && height) { 74186 delete nextValue.height; 74187 } 74188 onChange(nextValue); 74189 } 74190 }), tools.includes('widthHeight') && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WidthHeightTool, { 74191 panelId: panelId, 74192 units: unitsOptions, 74193 value: { 74194 width, 74195 height 74196 }, 74197 onChange: ({ 74198 width: nextWidth, 74199 height: nextHeight 74200 }) => { 74201 const nextValue = { 74202 ...value 74203 }; 74204 74205 // 'auto' is CSS default, so it gets treated as null. 74206 nextWidth = nextWidth === 'auto' ? null : nextWidth; 74207 nextHeight = nextHeight === 'auto' ? null : nextHeight; 74208 74209 // Update width. 74210 if (!nextWidth) { 74211 delete nextValue.width; 74212 } else { 74213 nextValue.width = nextWidth; 74214 } 74215 74216 // Update height. 74217 if (!nextHeight) { 74218 delete nextValue.height; 74219 } else { 74220 nextValue.height = nextHeight; 74221 } 74222 74223 // Auto-update aspectRatio. 74224 if (nextWidth && nextHeight) { 74225 delete nextValue.aspectRatio; 74226 } else if (lastAspectRatio) { 74227 nextValue.aspectRatio = lastAspectRatio; 74228 } else { 74229 // No setting defaultAspectRatio here, because 74230 // aspectRatio is optional in this scenario, 74231 // unlike scale. 74232 } 74233 74234 // Auto-update scale. 74235 if (!lastAspectRatio && !!nextWidth !== !!nextHeight) { 74236 delete nextValue.scale; 74237 } else if (lastScale) { 74238 nextValue.scale = lastScale; 74239 } else { 74240 nextValue.scale = defaultScale; 74241 setLastScale(defaultScale); 74242 } 74243 onChange(nextValue); 74244 } 74245 }), tools.includes('scale') && showScaleControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ScaleTool, { 74246 panelId: panelId, 74247 options: scaleOptions, 74248 defaultValue: defaultScale, 74249 value: lastScale, 74250 onChange: nextScale => { 74251 const nextValue = { 74252 ...value 74253 }; 74254 74255 // 'fill' is CSS default, so it gets treated as null. 74256 nextScale = nextScale === 'fill' ? null : nextScale; 74257 setLastScale(nextScale); 74258 74259 // Update scale. 74260 if (!nextScale) { 74261 delete nextValue.scale; 74262 } else { 74263 nextValue.scale = nextScale; 74264 } 74265 onChange(nextValue); 74266 } 74267 })] 74268 }); 74269 } 74270 /* harmony default export */ const dimensions_tool = (DimensionsTool); 74271 74272 ;// ./node_modules/@wordpress/block-editor/build-module/components/resolution-tool/index.js 74273 /** 74274 * WordPress dependencies 74275 */ 74276 74277 74278 74279 const DEFAULT_SIZE_OPTIONS = [{ 74280 label: (0,external_wp_i18n_namespaceObject._x)('Thumbnail', 'Image size option for resolution control'), 74281 value: 'thumbnail' 74282 }, { 74283 label: (0,external_wp_i18n_namespaceObject._x)('Medium', 'Image size option for resolution control'), 74284 value: 'medium' 74285 }, { 74286 label: (0,external_wp_i18n_namespaceObject._x)('Large', 'Image size option for resolution control'), 74287 value: 'large' 74288 }, { 74289 label: (0,external_wp_i18n_namespaceObject._x)('Full Size', 'Image size option for resolution control'), 74290 value: 'full' 74291 }]; 74292 function ResolutionTool({ 74293 panelId, 74294 value, 74295 onChange, 74296 options = DEFAULT_SIZE_OPTIONS, 74297 defaultValue = DEFAULT_SIZE_OPTIONS[0].value, 74298 isShownByDefault = true 74299 }) { 74300 const displayValue = value !== null && value !== void 0 ? value : defaultValue; 74301 return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, { 74302 hasValue: () => displayValue !== defaultValue, 74303 label: (0,external_wp_i18n_namespaceObject.__)('Resolution'), 74304 onDeselect: () => onChange(defaultValue), 74305 isShownByDefault: isShownByDefault, 74306 panelId: panelId, 74307 children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SelectControl, { 74308 __nextHasNoMarginBottom: true, 74309 label: (0,external_wp_i18n_namespaceObject.__)('Resolution'), 74310 value: displayValue, 74311 options: options, 74312 onChange: onChange, 74313 help: (0,external_wp_i18n_namespaceObject.__)('Select the size of the source image.'), 74314 size: "__unstable-large" 74315 }) 74316 }); 74317 } 74318 74319 ;// ./node_modules/@wordpress/block-editor/build-module/private-apis.js 74320 /** 74321 * Internal dependencies 74322 */ 74323 74324 74325 74326 74327 74328 74329 74330 74331 74332 74333 74334 74335 74336 74337 74338 74339 74340 74341 74342 74343 74344 74345 74346 74347 74348 74349 74350 74351 74352 74353 74354 74355 74356 /** 74357 * Private @wordpress/block-editor APIs. 74358 */ 74359 const privateApis = {}; 74360 lock(privateApis, { 74361 ...global_styles_namespaceObject, 74362 ExperimentalBlockCanvas: ExperimentalBlockCanvas, 74363 ExperimentalBlockEditorProvider: ExperimentalBlockEditorProvider, 74364 getDuotoneFilter: getDuotoneFilter, 74365 getRichTextValues: getRichTextValues, 74366 PrivateQuickInserter: QuickInserter, 74367 extractWords: extractWords, 74368 getNormalizedSearchTerms: getNormalizedSearchTerms, 74369 normalizeString: normalizeString, 74370 PrivateListView: PrivateListView, 74371 ResizableBoxPopover: ResizableBoxPopover, 74372 BlockInfo: block_info_slot_fill, 74373 useHasBlockToolbar: useHasBlockToolbar, 74374 cleanEmptyObject: utils_cleanEmptyObject, 74375 BlockQuickNavigation: BlockQuickNavigation, 74376 LayoutStyle: LayoutStyle, 74377 BlockRemovalWarningModal: BlockRemovalWarningModal, 74378 useLayoutClasses: useLayoutClasses, 74379 useLayoutStyles: useLayoutStyles, 74380 DimensionsTool: dimensions_tool, 74381 ResolutionTool: ResolutionTool, 74382 TabbedSidebar: tabbed_sidebar, 74383 TextAlignmentControl: TextAlignmentControl, 74384 usesContextKey: usesContextKey, 74385 useFlashEditableBlocks: useFlashEditableBlocks, 74386 useZoomOutModeExit: useZoomOutModeExit, 74387 useZoomOut: useZoomOut, 74388 globalStylesDataKey: globalStylesDataKey, 74389 globalStylesLinksDataKey: globalStylesLinksDataKey, 74390 selectBlockPatternsKey: selectBlockPatternsKey, 74391 requiresWrapperOnCopy: requiresWrapperOnCopy, 74392 PrivateRichText: PrivateRichText, 74393 PrivateInserterLibrary: PrivateInserterLibrary, 74394 reusableBlocksSelectKey: reusableBlocksSelectKey, 74395 PrivateBlockPopover: PrivateBlockPopover, 74396 PrivatePublishDateTimePicker: PrivatePublishDateTimePicker, 74397 useSpacingSizes: useSpacingSizes, 74398 useBlockDisplayTitle: useBlockDisplayTitle, 74399 __unstableBlockStyleVariationOverridesWithConfig: __unstableBlockStyleVariationOverridesWithConfig, 74400 setBackgroundStyleDefaults: setBackgroundStyleDefaults, 74401 sectionRootClientIdKey: sectionRootClientIdKey 74402 }); 74403 74404 ;// ./node_modules/@wordpress/block-editor/build-module/index.js 74405 /** 74406 * Internal dependencies 74407 */ 74408 74409 74410 74411 74412 74413 74414 74415 74416 74417 })(); 74418 74419 (window.wp = window.wp || {}).blockEditor = __webpack_exports__; 74420 /******/ })() 74421 ;
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated : Sat Dec 21 08:20:01 2024 | Cross-referenced by PHPXref |