1"use strict"; 2var wp; 3(wp ||= {}).richText = (() => { 4 var __create = Object.create; 5 var __defProp = Object.defineProperty; 6 var __getOwnPropDesc = Object.getOwnPropertyDescriptor; 7 var __getOwnPropNames = Object.getOwnPropertyNames; 8 var __getProtoOf = Object.getPrototypeOf; 9 var __hasOwnProp = Object.prototype.hasOwnProperty; 10 var __commonJS = (cb, mod) => function __require() { 11 return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; 12 }; 13 var __export = (target, all) => { 14 for (var name in all) 15 __defProp(target, name, { get: all[name], enumerable: true }); 16 }; 17 var __copyProps = (to, from, except, desc) => { 18 if (from && typeof from === "object" || typeof from === "function") { 19 for (let key of __getOwnPropNames(from)) 20 if (!__hasOwnProp.call(to, key) && key !== except) 21 __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); 22 } 23 return to; 24 }; 25 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( 26 // If the importer is in node compatibility mode or this is not an ESM 27 // file that has been converted to a CommonJS file using a Babel- 28 // compatible transform (i.e. "__esModule" has not been set), then set 29 // "default" to the CommonJS "module.exports" for node compatibility. 30 isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, 31 mod 32 )); 33 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); 34 35 // package-external:@wordpress/data 36 var require_data = __commonJS({ 37 "package-external:@wordpress/data"(exports, module) { 38 module.exports = window.wp.data; 39 } 40 }); 41 42 // package-external:@wordpress/escape-html 43 var require_escape_html = __commonJS({ 44 "package-external:@wordpress/escape-html"(exports, module) { 45 module.exports = window.wp.escapeHtml; 46 } 47 }); 48 49 // package-external:@wordpress/a11y 50 var require_a11y = __commonJS({ 51 "package-external:@wordpress/a11y"(exports, module) { 52 module.exports = window.wp.a11y; 53 } 54 }); 55 56 // package-external:@wordpress/i18n 57 var require_i18n = __commonJS({ 58 "package-external:@wordpress/i18n"(exports, module) { 59 module.exports = window.wp.i18n; 60 } 61 }); 62 63 // package-external:@wordpress/private-apis 64 var require_private_apis = __commonJS({ 65 "package-external:@wordpress/private-apis"(exports, module) { 66 module.exports = window.wp.privateApis; 67 } 68 }); 69 70 // package-external:@wordpress/element 71 var require_element = __commonJS({ 72 "package-external:@wordpress/element"(exports, module) { 73 module.exports = window.wp.element; 74 } 75 }); 76 77 // package-external:@wordpress/compose 78 var require_compose = __commonJS({ 79 "package-external:@wordpress/compose"(exports, module) { 80 module.exports = window.wp.compose; 81 } 82 }); 83 84 // package-external:@wordpress/deprecated 85 var require_deprecated = __commonJS({ 86 "package-external:@wordpress/deprecated"(exports, module) { 87 module.exports = window.wp.deprecated; 88 } 89 }); 90 91 // package-external:@wordpress/keycodes 92 var require_keycodes = __commonJS({ 93 "package-external:@wordpress/keycodes"(exports, module) { 94 module.exports = window.wp.keycodes; 95 } 96 }); 97 98 // package-external:@wordpress/dom 99 var require_dom = __commonJS({ 100 "package-external:@wordpress/dom"(exports, module) { 101 module.exports = window.wp.dom; 102 } 103 }); 104 105
105// packages/rich-text/build-module/index.mjs 106 var index_exports = {}; 107 __export(index_exports, { 108 RichTextData: () => RichTextData, 109 __experimentalRichText: () => __experimentalRichText, 110 __unstableCreateElement: () => createElement, 111 __unstableToDom: () => toDom, 112 __unstableUseRichText: () => __unstableUseRichText, 113 applyFormat: () => applyFormat, 114 concat: () => concat, 115 create: () => create, 116 getActiveFormat: () => getActiveFormat, 117 getActiveFormats: () => getActiveFormats, 118 getActiveObject: () => getActiveObject, 119 getTextContent: () => getTextContent, 120 insert: () => insert, 121 insertObject: () => insertObject, 122 isCollapsed: () => isCollapsed, 123 isEmpty: () => isEmpty, 124 join: () => join, 125 privateApis: () => privateApis, 126 registerFormatType: () => registerFormatType, 127 remove: () => remove2, 128 removeFormat: () => removeFormat, 129 replace: () => replace2, 130 slice: () => slice, 131 split: () => split, 132 store: () => store, 133 toHTMLString: () => toHTMLString, 134 toggleFormat: () => toggleFormat, 135 unregisterFormatType: () => unregisterFormatType, 136 useAnchor: () => useAnchor, 137 useAnchorRef: () => useAnchorRef 138 }); 139 140
140// packages/rich-text/build-module/store/index.mjs 141 var import_data3 = __toESM(require_data(), 1); 142 143
143// packages/rich-text/build-module/store/reducer.mjs 144 var import_data = __toESM(require_data(), 1); 145 function formatTypes(state = {}, action) { 146 switch (action.type) { 147 case "ADD_FORMAT_TYPES": 148 return { 149 ...state, 150 // Key format types by their name. 151 ...action.formatTypes.reduce( 152 (newFormatTypes, type) => ({ 153 ...newFormatTypes, 154 [type.name]: type 155 }), 156 {} 157 ) 158 }; 159 case "REMOVE_FORMAT_TYPES": 160 return Object.fromEntries( 161 Object.entries(state).filter( 162 ([key]) => !action.names.includes(key) 163 ) 164 ); 165 } 166 return state; 167 } 168 var reducer_default = (0, import_data.combineReducers)({ formatTypes }); 169 170
170// packages/rich-text/build-module/store/selectors.mjs 171 var selectors_exports = {}; 172 __export(selectors_exports, { 173 getFormatType: () => getFormatType, 174 getFormatTypeForBareElement: () => getFormatTypeForBareElement, 175 getFormatTypeForClassName: () => getFormatTypeForClassName, 176 getFormatTypes: () => getFormatTypes 177 }); 178 var import_data2 = __toESM(require_data(), 1); 179 var getFormatTypes = (0, import_data2.createSelector)( 180 (state) => Object.values(state.formatTypes), 181 (state) => [state.formatTypes] 182 ); 183 function getFormatType(state, name) { 184 return state.formatTypes[name]; 185 } 186 function getFormatTypeForBareElement(state, bareElementTagName) { 187 const formatTypes2 = getFormatTypes(state); 188 return formatTypes2.find(({ className, tagName }) => { 189 return className === null && bareElementTagName === tagName; 190 }) || formatTypes2.find(({ className, tagName }) => { 191 return className === null && "*" === tagName; 192 }); 193 } 194 function getFormatTypeForClassName(state, elementClassName) { 195 return getFormatTypes(state).find(({ className }) => { 196 if (className === null) { 197 return false; 198 } 199 return ` ${elementClassName} `.indexOf(` ${className} `) >= 0; 200 }); 201 } 202 203
203// packages/rich-text/build-module/store/actions.mjs 204 var actions_exports = {}; 205 __export(actions_exports, { 206 addFormatTypes: () => addFormatTypes, 207 removeFormatTypes: () => removeFormatTypes 208 }); 209 function addFormatTypes(formatTypes2) { 210 return { 211 type: "ADD_FORMAT_TYPES", 212 formatTypes: Array.isArray(formatTypes2) ? formatTypes2 : [formatTypes2] 213 }; 214 } 215 function removeFormatTypes(names) { 216 return { 217 type: "REMOVE_FORMAT_TYPES", 218 names: Array.isArray(names) ? names : [names] 219 }; 220 } 221 222
222// packages/rich-text/build-module/store/index.mjs 223 var STORE_NAME = "core/rich-text"; 224 var store = (0, import_data3.createReduxStore)(STORE_NAME, { 225 reducer: reducer_default, 226 selectors: selectors_exports, 227 actions: actions_exports 228 }); 229 (0, import_data3.register)(store); 230 231
231// packages/rich-text/build-module/is-format-equal.mjs 232 function isFormatEqual(format1, format2) { 233 if (format1 === format2) { 234 return true; 235 } 236 if (!format1 || !format2) { 237 return false; 238 } 239 if (format1.type !== format2.type) { 240 return false; 241 } 242 const attributes1 = format1.attributes; 243 const attributes2 = format2.attributes; 244 if (attributes1 === attributes2) { 245 return true; 246 } 247 if (!attributes1 || !attributes2) { 248 return false; 249 } 250 const keys1 = Object.keys(attributes1); 251 const keys2 = Object.keys(attributes2); 252 if (keys1.length !== keys2.length) { 253 return false; 254 } 255 const length = keys1.length; 256 for (let i2 = 0; i2 < length; i2++) { 257 const name = keys1[i2]; 258 if (attributes1[name] !== attributes2[name]) { 259 return false; 260 } 261 } 262 return true; 263 } 264 265
265// packages/rich-text/build-module/normalise-formats.mjs 266 function normaliseFormats(value) { 267 const newFormats = value.formats.slice(); 268 newFormats.forEach((formatsAtIndex, index) => { 269 const formatsAtPreviousIndex = newFormats[index - 1]; 270 if (formatsAtPreviousIndex) { 271 const newFormatsAtIndex = formatsAtIndex.slice(); 272 newFormatsAtIndex.forEach((format, formatIndex) => { 273 const previousFormat = formatsAtPreviousIndex[formatIndex]; 274 if (isFormatEqual(format, previousFormat)) { 275 newFormatsAtIndex[formatIndex] = previousFormat; 276 } 277 }); 278 newFormats[index] = newFormatsAtIndex; 279 } 280 }); 281 return { 282 ...value, 283 formats: newFormats 284 }; 285 } 286 287
287// packages/rich-text/build-module/apply-format.mjs 288 function replace(array, index, value) { 289 array = array.slice(); 290 array[index] = value; 291 return array; 292 } 293 function applyFormat(value, format, startIndex = value.start, endIndex = value.end) { 294 const { formats, activeFormats } = value; 295 const newFormats = formats.slice(); 296 if (startIndex === endIndex) { 297 const startFormat = newFormats[startIndex]?.find( 298 ({ type }) => type === format.type 299 ); 300 if (startFormat) { 301 const index = newFormats[startIndex].indexOf(startFormat); 302 while (newFormats[startIndex] && newFormats[startIndex][index] === startFormat) { 303 newFormats[startIndex] = replace( 304 newFormats[startIndex], 305 index, 306 format 307 ); 308 startIndex--; 309 } 310 endIndex++; 311 while (newFormats[endIndex] && newFormats[endIndex][index] === startFormat) { 312 newFormats[endIndex] = replace( 313 newFormats[endIndex], 314 index, 315 format 316 ); 317 endIndex++; 318 } 319 } 320 } else { 321 let position = Infinity; 322 for (let index = startIndex; index < endIndex; index++) { 323 if (newFormats[index]) { 324 newFormats[index] = newFormats[index].filter( 325 ({ type }) => type !== format.type 326 ); 327 const length = newFormats[index].length; 328 if (length < position) { 329 position = length; 330 } 331 } else { 332 newFormats[index] = []; 333 position = 0; 334 } 335 } 336 for (let index = startIndex; index < endIndex; index++) { 337 newFormats[index].splice(position, 0, format); 338 } 339 } 340 return normaliseFormats({ 341 ...value, 342 formats: newFormats, 343 // Always revise active formats. This serves as a placeholder for new 344 // inputs with the format so new input appears with the format applied, 345 // and ensures a format of the same type uses the latest values. 346 activeFormats: [ 347 ...activeFormats?.filter( 348 ({ type }) => type !== format.type 349 ) || [], 350 format 351 ] 352 }); 353 } 354 355
355// packages/rich-text/build-module/create.mjs 356 var import_data5 = __toESM(require_data(), 1); 357 358
358// packages/rich-text/build-module/create-element.mjs 359 function createElement({ implementation }, html) { 360 if (!createElement.body) { 361 createElement.body = implementation.createHTMLDocument("").body; 362 } 363 createElement.body.innerHTML = html; 364 return createElement.body; 365 } 366 367
367// packages/rich-text/build-module/special-characters.mjs 368 var OBJECT_REPLACEMENT_CHARACTER = "\uFFFC"; 369 var ZWNBSP = "\uFEFF"; 370 371
371// packages/rich-text/build-module/to-html-string.mjs 372 var import_escape_html = __toESM(require_escape_html(), 1); 373 374
374// packages/rich-text/build-module/get-active-formats.mjs 375 function getActiveFormats(value, EMPTY_ACTIVE_FORMATS3 = []) { 376 const { formats, start, end, activeFormats } = value; 377 if (start === void 0) { 378 return EMPTY_ACTIVE_FORMATS3; 379 } 380 if (start === end) { 381 if (activeFormats) { 382 return activeFormats; 383 } 384 const formatsBefore = formats[start - 1] || EMPTY_ACTIVE_FORMATS3; 385 const formatsAfter = formats[start] || EMPTY_ACTIVE_FORMATS3; 386 if (formatsBefore.length < formatsAfter.length) { 387 return formatsBefore; 388 } 389 return formatsAfter; 390 } 391 if (!formats[start]) { 392 return EMPTY_ACTIVE_FORMATS3; 393 } 394 const selectedFormats = formats.slice(start, end); 395 const _activeFormats = [...selectedFormats[0]]; 396 let i2 = selectedFormats.length; 397 while (i2--) { 398 const formatsAtIndex = selectedFormats[i2]; 399 if (!formatsAtIndex) { 400 return EMPTY_ACTIVE_FORMATS3; 401 } 402 let ii = _activeFormats.length; 403 while (ii--) { 404 const format = _activeFormats[ii]; 405 if (!formatsAtIndex.find( 406 (_format) => isFormatEqual(format, _format) 407 )) { 408 _activeFormats.splice(ii, 1); 409 } 410 } 411 if (_activeFormats.length === 0) { 412 return EMPTY_ACTIVE_FORMATS3; 413 } 414 } 415 return _activeFormats || EMPTY_ACTIVE_FORMATS3; 416 } 417 418
418// packages/rich-text/build-module/get-format-type.mjs 419 var import_data4 = __toESM(require_data(), 1); 420 function getFormatType2(name) { 421 return (0, import_data4.select)(store).getFormatType(name); 422 } 423 424
424// packages/rich-text/build-module/to-tree.mjs 425 function restoreOnAttributes(attributes, isEditableTree) { 426 if (isEditableTree) { 427 return attributes; 428 } 429 const newAttributes = {}; 430 for (const key in attributes) { 431 let newKey = key; 432 if (key.startsWith("data-disable-rich-text-")) { 433 newKey = key.slice("data-disable-rich-text-".length); 434 } 435 newAttributes[newKey] = attributes[key]; 436 } 437 return newAttributes; 438 } 439 function fromFormat({ 440 type, 441 tagName, 442 attributes, 443 unregisteredAttributes, 444 object, 445 boundaryClass, 446 isEditableTree 447 }) { 448 const formatType = getFormatType2(type); 449 let elementAttributes = {}; 450 if (boundaryClass && isEditableTree) { 451 elementAttributes["data-rich-text-format-boundary"] = "true"; 452 } 453 if (!formatType) { 454 if (attributes) { 455 elementAttributes = { ...attributes, ...elementAttributes }; 456 } 457 return { 458 type, 459 attributes: restoreOnAttributes( 460 elementAttributes, 461 isEditableTree 462 ), 463 object 464 }; 465 } 466 elementAttributes = { ...unregisteredAttributes, ...elementAttributes }; 467 for (const name in attributes) { 468 const key = formatType.attributes ? formatType.attributes[name] : false; 469 if (key) { 470 elementAttributes[key] = attributes[name]; 471 } else { 472 elementAttributes[name] = attributes[name]; 473 } 474 } 475 if (formatType.className) { 476 if (elementAttributes.class) { 477 elementAttributes.class = `${formatType.className} ${elementAttributes.class}`; 478 } else { 479 elementAttributes.class = formatType.className; 480 } 481 } 482 return { 483 type: tagName || formatType.tagName, 484 object: formatType.object, 485 attributes: restoreOnAttributes(elementAttributes, isEditableTree) 486 }; 487 } 488 function isEqualUntil(a2, b2, index) { 489 do { 490 if (a2[index] !== b2[index]) { 491 return false; 492 } 493 } while (index--); 494 return true; 495 } 496 function toTree({ 497 value, 498 preserveWhiteSpace, 499 createEmpty: createEmpty2, 500 append: append3, 501 getLastChild: getLastChild3, 502 getParent: getParent3, 503 isText: isText3, 504 getText: getText3, 505 remove: remove4, 506 appendText: appendText3, 507 onStartIndex, 508 onEndIndex, 509 isEditableTree, 510 placeholder 511 }) { 512 const { formats, replacements, text, start, end } = value; 513 const formatsLength = formats.length + 1; 514 const tree = createEmpty2(); 515 const activeFormats = getActiveFormats(value); 516 const deepestActiveFormat = activeFormats[activeFormats.length - 1]; 517 let lastCharacterFormats; 518 let lastCharacter; 519 append3(tree, ""); 520 for (let i2 = 0; i2 < formatsLength; i2++) { 521 const character = text.charAt(i2); 522 const shouldInsertPadding = isEditableTree && // Pad the line if the line is empty. 523 (!lastCharacter || // Pad the line if the previous character is a line break, otherwise 524 // the line break won't be visible. 525 lastCharacter === "\n"); 526 const characterFormats = formats[i2]; 527 let pointer = getLastChild3(tree); 528 if (characterFormats) { 529 characterFormats.forEach((format, formatIndex) => { 530 if (pointer && lastCharacterFormats && // Reuse the last element if all formats remain the same. 531 isEqualUntil( 532 characterFormats, 533 lastCharacterFormats, 534 formatIndex 535 )) { 536 pointer = getLastChild3(pointer); 537 return; 538 } 539 const { type, tagName, attributes, unregisteredAttributes } = format; 540 const boundaryClass = isEditableTree && format === deepestActiveFormat; 541 const parent = getParent3(pointer); 542 const newNode = append3( 543 parent, 544 fromFormat({ 545 type, 546 tagName, 547 attributes, 548 unregisteredAttributes, 549 boundaryClass, 550 isEditableTree 551 }) 552 ); 553 if (isText3(pointer) && getText3(pointer).length === 0) { 554 remove4(pointer); 555 } 556 pointer = append3(newNode, ""); 557 }); 558 } 559 if (i2 === 0) { 560 if (onStartIndex && start === 0) { 561 onStartIndex(tree, pointer); 562 } 563 if (onEndIndex && end === 0) { 564 onEndIndex(tree, pointer); 565 } 566 } 567 if (character === OBJECT_REPLACEMENT_CHARACTER) { 568 const replacement = replacements[i2]; 569 if (!replacement) { 570 continue; 571 } 572 const { type, attributes, innerHTML } = replacement; 573 const formatType = getFormatType2(type); 574 if (isEditableTree && type === "#comment") { 575 pointer = append3(getParent3(pointer), { 576 type: "span", 577 attributes: { 578 contenteditable: "false", 579 "data-rich-text-comment": attributes["data-rich-text-comment"] 580 } 581 }); 582 append3( 583 append3(pointer, { type: "span" }), 584 attributes["data-rich-text-comment"].trim() 585 ); 586 } else if (!isEditableTree && type === "script") { 587 pointer = append3( 588 getParent3(pointer), 589 fromFormat({ 590 type: "script", 591 isEditableTree 592 }) 593 ); 594 append3(pointer, { 595 html: decodeURIComponent( 596 attributes["data-rich-text-script"] 597 ) 598 }); 599 } else if (formatType?.contentEditable === false) { 600 if (innerHTML || isEditableTree) { 601 pointer = getParent3(pointer); 602 if (isEditableTree) { 603 const attrs = { 604 contenteditable: "false", 605 "data-rich-text-bogus": true 606 }; 607 if (start === i2 && end === i2 + 1) { 608 attrs["data-rich-text-format-boundary"] = true; 609 } 610 pointer = append3(pointer, { 611 type: "span", 612 attributes: attrs 613 }); 614 if (isEditableTree && i2 + 1 === text.length) { 615 append3(getParent3(pointer), ZWNBSP); 616 } 617 } 618 pointer = append3( 619 pointer, 620 fromFormat({ 621 ...replacement, 622 isEditableTree 623 }) 624 ); 625 if (innerHTML) { 626 append3(pointer, { 627 html: innerHTML 628 }); 629 } 630 } 631 } else { 632 pointer = append3( 633 getParent3(pointer), 634 fromFormat({ 635 ...replacement, 636 object: true, 637 isEditableTree 638 }) 639 ); 640 } 641 pointer = append3(getParent3(pointer), ""); 642 } else if (!preserveWhiteSpace && character === "\n") { 643 pointer = append3(getParent3(pointer), { 644 type: "br", 645 attributes: isEditableTree ? { 646 "data-rich-text-line-break": "true" 647 } : void 0, 648 object: true 649 }); 650 pointer = append3(getParent3(pointer), ""); 651 } else if (!isText3(pointer)) { 652 pointer = append3(getParent3(pointer), character); 653 } else { 654 appendText3(pointer, character); 655 } 656 if (onStartIndex && start === i2 + 1) { 657 onStartIndex(tree, pointer); 658 } 659 if (onEndIndex && end === i2 + 1) { 660 onEndIndex(tree, pointer); 661 } 662 if (shouldInsertPadding && i2 === text.length) { 663 append3(getParent3(pointer), ZWNBSP); 664 if (placeholder && text.length === 0) { 665 append3(getParent3(pointer), { 666 type: "span", 667 attributes: { 668 "data-rich-text-placeholder": placeholder, 669 // Necessary to prevent the placeholder from catching 670 // selection and being editable. 671 style: "pointer-events:none;user-select:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;" 672 } 673 }); 674 } 675 } 676 lastCharacterFormats = characterFormats; 677 lastCharacter = character; 678 } 679 return tree; 680 } 681 682
682// packages/rich-text/build-module/to-html-string.mjs 683 function toHTMLString({ value, preserveWhiteSpace }) { 684 const tree = toTree({ 685 value, 686 preserveWhiteSpace, 687 createEmpty, 688 append, 689 getLastChild, 690 getParent, 691 isText, 692 getText, 693 remove, 694 appendText 695 }); 696 return createChildrenHTML(tree.children); 697 } 698 function createEmpty() { 699 return {}; 700 } 701 function getLastChild({ children }) { 702 return children && children[children.length - 1]; 703 } 704 function append(parent, object) { 705 if (typeof object === "string") { 706 object = { text: object }; 707 } 708 object.parent = parent; 709 parent.children = parent.children || []; 710 parent.children.push(object); 711 return object; 712 } 713 function appendText(object, text) { 714 object.text += text; 715 } 716 function getParent({ parent }) { 717 return parent; 718 } 719 function isText({ text }) { 720 return typeof text === "string"; 721 } 722 function getText({ text }) { 723 return text; 724 } 725 function remove(object) { 726 const index = object.parent.children.indexOf(object); 727 if (index !== -1) { 728 object.parent.children.splice(index, 1); 729 } 730 return object; 731 } 732 function createElementHTML({ type, attributes, object, children }) { 733 if (type === "#comment") { 734 return `<!--${attributes["data-rich-text-comment"]}-->`; 735 } 736 let attributeString = ""; 737 for (const key in attributes) { 738 if (!(0, import_escape_html.isValidAttributeName)(key)) { 739 continue; 740 } 741 attributeString += ` ${key}="${(0, import_escape_html.escapeAttribute)( 742 attributes[key] 743 )}"`; 744 } 745 if (object) { 746 return `<${type}${attributeString}>`; 747 } 748 return `<${type}${attributeString}>${createChildrenHTML( 749 children 750 )}</${type}>`; 751 } 752 function createChildrenHTML(children = []) { 753 return children.map((child) => { 754 if (child.html !== void 0) { 755 return child.html; 756 } 757 return child.text === void 0 ? createElementHTML(child) : (0, import_escape_html.escapeEditableHTML)(child.text); 758 }).join(""); 759 } 760 761
761// packages/rich-text/build-module/get-text-content.mjs 762 function getTextContent({ text }) { 763 return text.replace(OBJECT_REPLACEMENT_CHARACTER, ""); 764 } 765 766
766// packages/rich-text/build-module/create.mjs 767 function createEmptyValue() { 768 return { 769 formats: [], 770 replacements: [], 771 text: "" 772 }; 773 } 774 function toFormat({ tagName, attributes }) { 775 let formatType; 776 if (attributes && attributes.class) { 777 formatType = (0, import_data5.select)(store).getFormatTypeForClassName( 778 attributes.class 779 ); 780 if (formatType) { 781 attributes.class = ` ${attributes.class} `.replace(` ${formatType.className} `, " ").trim(); 782 if (!attributes.class) { 783 delete attributes.class; 784 } 785 } 786 } 787 if (!formatType) { 788 formatType = (0, import_data5.select)(store).getFormatTypeForBareElement(tagName); 789 } 790 if (!formatType) { 791 return attributes ? { type: tagName, attributes } : { type: tagName }; 792 } 793 if (formatType.__experimentalCreatePrepareEditableTree && !formatType.__experimentalCreateOnChangeEditableValue) { 794 return null; 795 } 796 if (!attributes) { 797 return { formatType, type: formatType.name, tagName }; 798 } 799 const registeredAttributes = {}; 800 const unregisteredAttributes = {}; 801 const _attributes = { ...attributes }; 802 for (const key in formatType.attributes) { 803 const name = formatType.attributes[key]; 804 registeredAttributes[key] = _attributes[name]; 805 delete _attributes[name]; 806 if (typeof registeredAttributes[key] === "undefined") { 807 delete registeredAttributes[key]; 808 } 809 } 810 for (const name in _attributes) { 811 unregisteredAttributes[name] = attributes[name]; 812 } 813 if (formatType.contentEditable === false) { 814 delete unregisteredAttributes.contenteditable; 815 } 816 return { 817 formatType, 818 type: formatType.name, 819 tagName, 820 attributes: registeredAttributes, 821 unregisteredAttributes 822 }; 823 } 824 var RichTextData = class _RichTextData { 825 #value; 826 static empty() { 827 return new _RichTextData(); 828 } 829 static fromPlainText(text) { 830 return new _RichTextData(create({ text })); 831 } 832 static fromHTMLString(html) { 833 return new _RichTextData(create({ html })); 834 } 835 /** 836 * Create a RichTextData instance from an HTML element. 837 * 838 * @param {HTMLElement} htmlElement The HTML element to create the instance from. 839 * @param {{preserveWhiteSpace?: boolean}} options Options. 840 * @return {RichTextData} The RichTextData instance. 841 */ 842 static fromHTMLElement(htmlElement, options = {}) { 843 const { preserveWhiteSpace = false } = options; 844 const element = preserveWhiteSpace ? htmlElement : collapseWhiteSpace(htmlElement); 845 const richTextData = new _RichTextData(create({ element })); 846 Object.defineProperty(richTextData, "originalHTML", { 847 value: htmlElement.innerHTML 848 }); 849 return richTextData; 850 } 851 constructor(init = createEmptyValue()) { 852 this.#value = init; 853 } 854 toPlainText() { 855 return getTextContent(this.#value); 856 } 857 // We could expose `toHTMLElement` at some point as well, but we'd only use 858 // it internally. 859 /** 860 * Convert the rich text value to an HTML string. 861 * 862 * @param {{preserveWhiteSpace?: boolean}} options Options. 863 * @return {string} The HTML string. 864 */ 865 toHTMLString({ preserveWhiteSpace } = {}) { 866 return this.originalHTML || toHTMLString({ value: this.#value, preserveWhiteSpace }); 867 } 868 valueOf() { 869 return this.toHTMLString(); 870 } 871 toString() { 872 return this.toHTMLString(); 873 } 874 toJSON() { 875 return this.toHTMLString(); 876 } 877 get length() { 878 return this.text.length; 879 } 880 get formats() { 881 return this.#value.formats; 882 } 883 get replacements() { 884 return this.#value.replacements; 885 } 886 get text() { 887 return this.#value.text; 888 } 889 }; 890 for (const name of Object.getOwnPropertyNames(String.prototype)) { 891 if (RichTextData.prototype.hasOwnProperty(name)) { 892 continue; 893 } 894 Object.defineProperty(RichTextData.prototype, name, { 895 value(...args) { 896 return this.toHTMLString()[name](...args); 897 } 898 }); 899 } 900 function create({ 901 element, 902 text, 903 html, 904 range, 905 __unstableIsEditableTree: isEditableTree 906 } = {}) { 907 if (html instanceof RichTextData) { 908 return { 909 text: html.text, 910 formats: html.formats, 911 replacements: html.replacements 912 }; 913 } 914 if (typeof text === "string" && text.length > 0) { 915 return { 916 formats: Array(text.length), 917 replacements: Array(text.length), 918 text 919 }; 920 } 921 if (typeof html === "string" && html.length > 0) { 922 element = createElement(document, html); 923 } 924 if (typeof element !== "object") { 925 return createEmptyValue(); 926 } 927 return createFromElement({ 928 element, 929 range, 930 isEditableTree 931 }); 932 } 933 function accumulateSelection(accumulator, node, range, value) { 934 if (!range) { 935 return; 936 } 937 const { parentNode } = node; 938 const { startContainer, startOffset, endContainer, endOffset } = range; 939 const currentLength = accumulator.text.length; 940 if (value.start !== void 0) { 941 accumulator.start = currentLength + value.start; 942 } else if (node === startContainer && node.nodeType === node.TEXT_NODE) { 943 accumulator.start = currentLength + startOffset; 944 } else if (parentNode === startContainer && node === startContainer.childNodes[startOffset]) { 945 accumulator.start = currentLength; 946 } else if (parentNode === startContainer && node === startContainer.childNodes[startOffset - 1]) { 947 accumulator.start = currentLength + value.text.length; 948 } else if (node === startContainer) { 949 accumulator.start = currentLength; 950 } 951 if (value.end !== void 0) { 952 accumulator.end = currentLength + value.end; 953 } else if (node === endContainer && node.nodeType === node.TEXT_NODE) { 954 accumulator.end = currentLength + endOffset; 955 } else if (parentNode === endContainer && node === endContainer.childNodes[endOffset - 1]) { 956 accumulator.end = currentLength + value.text.length; 957 } else if (parentNode === endContainer && node === endContainer.childNodes[endOffset]) { 958 accumulator.end = currentLength; 959 } else if (node === endContainer) { 960 accumulator.end = currentLength + endOffset; 961 } 962 } 963 function filterRange(node, range, filter) { 964 if (!range) { 965 return; 966 } 967 const { startContainer, endContainer } = range; 968 let { startOffset, endOffset } = range; 969 if (node === startContainer) { 970 startOffset = filter(node.nodeValue.slice(0, startOffset)).length; 971 } 972 if (node === endContainer) { 973 endOffset = filter(node.nodeValue.slice(0, endOffset)).length; 974 } 975 return { startContainer, startOffset, endContainer, endOffset }; 976 } 977 function collapseWhiteSpace(element, isRoot = true, hasPrecedingSpace = false, hasTrailingSpace = false) { 978 const clone = element.cloneNode(true); 979 clone.normalize();
980 Array.from(clone.childNodes).forEach((node, i2, nodes) => { 981 if (node.nodeType === node.TEXT_NODE) { 982 let newNodeValue = node.nodeValue; 983 if (/[\n\t\r\f]/.test(newNodeValue)) { 984 newNodeValue = newNodeValue.replace(/[\n\t\r\f]+/g, " "); 985 } 986 if (newNodeValue.indexOf(" ") !== -1) { 987 newNodeValue = newNodeValue.replace(/ {2,}/g, " "); 988 } 989 if (i2 === 0 && newNodeValue.startsWith(" ") && (isRoot || hasPrecedingSpace)) { 990 newNodeValue = newNodeValue.slice(1); 991 } 992 if (i2 === nodes.length - 1 && newNodeValue.endsWith(" ") && (isRoot || hasTrailingSpace)) { 993 newNodeValue = newNodeValue.slice(0, -1); 994 } 995 node.nodeValue = newNodeValue; 996 } else if (node.nodeType === node.ELEMENT_NODE) { 997 const { previousSibling, nextSibling } = node; 998 const prevHasSpace = previousSibling?.textContent.endsWith(" "); 999 const nextHasSpace = nextSibling?.textContent.startsWith(" "); 1000 node.replaceWith( 1001 collapseWhiteSpace( 1002 node, 1003 false, 1004 previousSibling ? prevHasSpace : isRoot || hasPrecedingSpace, 1005 nextSibling ? nextHasSpace : isRoot || hasTrailingSpace 1006 ) 1007 ); 1008 } 1009 }); 1010 return clone; 1011 } 1012 var CARRIAGE_RETURN = "\r"; 1013 function removeReservedCharacters(string) { 1014 return string.replace( 1015 new RegExp( 1016 `[${ZWNBSP}${OBJECT_REPLACEMENT_CHARACTER}${CARRIAGE_RETURN}]`, 1017 "gu" 1018 ), 1019 "" 1020 ); 1021 } 1022 function createFromElement({ element, range, isEditableTree }) { 1023 const accumulator = createEmptyValue(); 1024 if (!element) { 1025 return accumulator; 1026 } 1027 if (!element.hasChildNodes()) { 1028 accumulateSelection(accumulator, element, range, createEmptyValue()); 1029 return accumulator; 1030 } 1031 const length = element.childNodes.length; 1032 for (let index = 0; index < length; index++) { 1033 const node = element.childNodes[index]; 1034 const tagName = node.nodeName.toLowerCase(); 1035 if (node.nodeType === node.TEXT_NODE) { 1036 const text = removeReservedCharacters(node.nodeValue); 1037 range = filterRange(node, range, removeReservedCharacters); 1038 accumulateSelection(accumulator, node, range, { text }); 1039 accumulator.formats.length += text.length; 1040 accumulator.replacements.length += text.length; 1041 accumulator.text += text; 1042 continue; 1043 } 1044 if (node.nodeType === node.COMMENT_NODE || node.nodeType === node.ELEMENT_NODE && node.tagName === "SPAN" && node.hasAttribute("data-rich-text-comment")) { 1045 const value2 = { 1046 formats: [,], 1047 replacements: [ 1048 { 1049 type: "#comment", 1050 attributes: { 1051 "data-rich-text-comment": node.nodeType === node.COMMENT_NODE ? node.nodeValue : node.getAttribute( 1052 "data-rich-text-comment" 1053 ) 1054 } 1055 } 1056 ], 1057 text: OBJECT_REPLACEMENT_CHARACTER 1058 }; 1059 accumulateSelection(accumulator, node, range, value2); 1060 mergePair(accumulator, value2); 1061 continue; 1062 } 1063 if (node.nodeType !== node.ELEMENT_NODE) { 1064 continue; 1065 } 1066 if (isEditableTree && // Ignore any line breaks that are not inserted by us. 1067 tagName === "br" && !node.getAttribute("data-rich-text-line-break")) { 1068 accumulateSelection(accumulator, node, range, createEmptyValue()); 1069 continue; 1070 } 1071 if (tagName === "script") { 1072 const value2 = { 1073 formats: [,], 1074 replacements: [ 1075 { 1076 type: tagName, 1077 attributes: { 1078 "data-rich-text-script": node.getAttribute("data-rich-text-script") || encodeURIComponent(node.innerHTML) 1079 } 1080 } 1081 ], 1082 text: OBJECT_REPLACEMENT_CHARACTER 1083 }; 1084 accumulateSelection(accumulator, node, range, value2); 1085 mergePair(accumulator, value2); 1086 continue; 1087 } 1088 if (tagName === "br") { 1089 accumulateSelection(accumulator, node, range, createEmptyValue()); 1090 mergePair(accumulator, create({ text: "\n" })); 1091 continue; 1092 } 1093 const format = toFormat({ 1094 tagName, 1095 attributes: getAttributes({ element: node }) 1096 }); 1097 if (format?.formatType?.contentEditable === false) { 1098 delete format.formatType; 1099 accumulateSelection(accumulator, node, range, createEmptyValue()); 1100 mergePair(accumulator, { 1101 formats: [,], 1102 replacements: [ 1103 { 1104 ...format,
1105 innerHTML: node.innerHTML 1106 } 1107 ], 1108 text: OBJECT_REPLACEMENT_CHARACTER 1109 }); 1110 continue; 1111 } 1112 if (format) { 1113 delete format.formatType; 1114 } 1115 const value = createFromElement({ 1116 element: node, 1117 range, 1118 isEditableTree 1119 }); 1120 accumulateSelection(accumulator, node, range, value); 1121 if (!format || node.getAttribute("data-rich-text-placeholder") || node.getAttribute("data-rich-text-bogus")) { 1122 mergePair(accumulator, value); 1123 } else if (value.text.length === 0) { 1124 if (format.attributes) { 1125 mergePair(accumulator, { 1126 formats: [,], 1127 replacements: [format], 1128 text: OBJECT_REPLACEMENT_CHARACTER 1129 }); 1130 } 1131 } else { 1132 let mergeFormats2 = function(formats) { 1133 if (mergeFormats2.formats === formats) { 1134 return mergeFormats2.newFormats; 1135 } 1136 const newFormats = formats ? [format, ...formats] : [format]; 1137 mergeFormats2.formats = formats; 1138 mergeFormats2.newFormats = newFormats; 1139 return newFormats; 1140 }; 1141 var mergeFormats = mergeFormats2; 1142 mergeFormats2.newFormats = [format]; 1143 mergePair(accumulator, { 1144 ...value, 1145 formats: Array.from(value.formats, mergeFormats2) 1146 }); 1147 } 1148 } 1149 return accumulator; 1150 } 1151 function getAttributes({ element }) { 1152 if (!element.hasAttributes()) { 1153 return; 1154 } 1155 const length = element.attributes.length; 1156 let accumulator; 1157 for (let i2 = 0; i2 < length; i2++) { 1158 const { name, value } = element.attributes[i2]; 1159 if (name.indexOf("data-rich-text-") === 0) { 1160 continue; 1161 } 1162 const safeName = /^on/i.test(name) ? "data-disable-rich-text-" + name : name; 1163 accumulator = accumulator || {}; 1164 accumulator[safeName] = value; 1165 } 1166 return accumulator; 1167 } 1168 1169
1169// packages/rich-text/build-module/concat.mjs 1170 function mergePair(a2, b2) { 1171 a2.formats = a2.formats.concat(b2.formats); 1172 a2.replacements = a2.replacements.concat(b2.replacements); 1173 a2.text += b2.text; 1174 return a2; 1175 } 1176 function concat(...values) { 1177 return normaliseFormats(values.reduce(mergePair, create())); 1178 } 1179 1180
1180// packages/rich-text/build-module/get-active-format.mjs 1181 function getActiveFormat(value, formatType) { 1182 return getActiveFormats(value).find( 1183 ({ type }) => type === formatType 1184 ); 1185 } 1186 1187
1187// packages/rich-text/build-module/get-active-object.mjs 1188 function getActiveObject({ start, end, replacements, text }) { 1189 if (start + 1 !== end || text[start] !== OBJECT_REPLACEMENT_CHARACTER) { 1190 return; 1191 } 1192 return replacements[start]; 1193 } 1194 1195
1195// packages/rich-text/build-module/is-collapsed.mjs 1196 function isCollapsed({ 1197 start, 1198 end 1199 }) { 1200 if (start === void 0 || end === void 0) { 1201 return; 1202 } 1203 return start === end; 1204 } 1205 1206
1206// packages/rich-text/build-module/is-empty.mjs 1207 function isEmpty({ text }) { 1208 return text.length === 0; 1209 } 1210 1211
1211// packages/rich-text/build-module/join.mjs 1212 function join(values, separator = "") { 1213 if (typeof separator === "string") { 1214 separator = create({ text: separator }); 1215 } 1216 return normaliseFormats( 1217 values.reduce((accumulator, { formats, replacements, text }) => ({ 1218 formats: accumulator.formats.concat(separator.formats, formats), 1219 replacements: accumulator.replacements.concat( 1220 separator.replacements, 1221 replacements 1222 ), 1223 text: accumulator.text + separator.text + text 1224 })) 1225 ); 1226 } 1227 1228
1228// packages/rich-text/build-module/register-format-type.mjs 1229 var import_data6 = __toESM(require_data(), 1); 1230 function registerFormatType(name, settings) { 1231 settings = { 1232 name, 1233 ...settings 1234 }; 1235 if (typeof settings.name !== "string") { 1236 window.console.error("Format names must be strings."); 1237 return; 1238 } 1239 if (!/^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/.test(settings.name)) { 1240 window.console.error( 1241 "Format names must contain a namespace prefix, include only lowercase alphanumeric characters or dashes, and start with a letter. Example: my-plugin/my-custom-format" 1242 ); 1243 return; 1244 } 1245 if ((0, import_data6.select)(store).getFormatType(settings.name)) { 1246 window.console.error( 1247 'Format "' + settings.name + '" is already registered.' 1248 ); 1249 return; 1250 } 1251 if (typeof settings.tagName !== "string" || settings.tagName === "") { 1252 window.console.error("Format tag names must be a string."); 1253 return; 1254 } 1255 if ((typeof settings.className !== "string" || settings.className === "") && settings.className !== null) { 1256 window.console.error( 1257 "Format class names must be a string, or null to handle bare elements." 1258 ); 1259 return; 1260 } 1261 if (!/^[_a-zA-Z]+[a-zA-Z0-9_-]*$/.test(settings.className)) { 1262 window.console.error( 1263 "A class name must begin with a letter, followed by any number of hyphens, underscores, letters, or numbers." 1264 ); 1265 return; 1266 } 1267 if (settings.className === null) { 1268 const formatTypeForBareElement = (0, import_data6.select)( 1269 store 1270 ).getFormatTypeForBareElement(settings.tagName); 1271 if (formatTypeForBareElement && formatTypeForBareElement.name !== "core/unknown") { 1272 window.console.error( 1273 `Format "${formatTypeForBareElement.name}" is already registered to handle bare tag name "${settings.tagName}".` 1274 ); 1275 return; 1276 } 1277 } else { 1278 const formatTypeForClassName = (0, import_data6.select)( 1279 store 1280 ).getFormatTypeForClassName(settings.className); 1281 if (formatTypeForClassName) { 1282 window.console.error( 1283 `Format "${formatTypeForClassName.name}" is already registered to handle class name "${settings.className}".` 1284 ); 1285 return; 1286 } 1287 } 1288 if (!("title" in settings) || settings.title === "") { 1289 window.console.error( 1290 'The format "' + settings.name + '" must have a title.' 1291 ); 1292 return; 1293 } 1294 if ("keywords" in settings && settings.keywords.length > 3) { 1295 window.console.error( 1296 'The format "' + settings.name + '" can have a maximum of 3 keywords.' 1297 ); 1298 return; 1299 } 1300 if (typeof settings.title !== "string") { 1301 window.console.error("Format titles must be strings."); 1302 return; 1303 } 1304 (0, import_data6.dispatch)(store).addFormatTypes(settings); 1305 return settings; 1306 } 1307 1308
1308// packages/rich-text/build-module/remove-format.mjs 1309 function removeFormat(value, formatType, startIndex = value.start, endIndex = value.end) { 1310 const { formats, activeFormats } = value; 1311 const newFormats = formats.slice(); 1312 if (startIndex === endIndex) { 1313 const format = newFormats[startIndex]?.find( 1314 ({ type }) => type === formatType 1315 ); 1316 if (format) { 1317 while (newFormats[startIndex]?.find( 1318 (newFormat) => newFormat === format 1319 )) { 1320 filterFormats(newFormats, startIndex, formatType); 1321 startIndex--; 1322 } 1323 endIndex++; 1324 while (newFormats[endIndex]?.find( 1325 (newFormat) => newFormat === format 1326 )) { 1327 filterFormats(newFormats, endIndex, formatType); 1328 endIndex++; 1329 } 1330 } 1331 } else { 1332 for (let i2 = startIndex; i2 < endIndex; i2++) { 1333 if (newFormats[i2]) { 1334 filterFormats(newFormats, i2, formatType); 1335 } 1336 } 1337 } 1338 return normaliseFormats({ 1339 ...value, 1340 formats: newFormats, 1341 activeFormats: activeFormats?.filter(({ type }) => type !== formatType) || [] 1342 }); 1343 } 1344 function filterFormats(formats, index, formatType) { 1345 const newFormats = formats[index].filter( 1346 ({ type }) => type !== formatType 1347 ); 1348 if (newFormats.length) { 1349 formats[index] = newFormats; 1350 } else { 1351 delete formats[index]; 1352 } 1353 } 1354 1355
1355// packages/rich-text/build-module/insert.mjs 1356 function insert(value, valueToInsert, startIndex = value.start, endIndex = value.end) { 1357 const { formats, replacements, text } = value; 1358 if (typeof valueToInsert === "string") { 1359 valueToInsert = create({ text: valueToInsert }); 1360 } 1361 const index = startIndex + valueToInsert.text.length; 1362 return normaliseFormats({ 1363 formats: formats.slice(0, startIndex).concat(valueToInsert.formats, formats.slice(endIndex)), 1364 replacements: replacements.slice(0, startIndex).concat( 1365 valueToInsert.replacements, 1366 replacements.slice(endIndex) 1367 ), 1368 text: text.slice(0, startIndex) + valueToInsert.text + text.slice(endIndex), 1369 start: index, 1370 end: index 1371 }); 1372 } 1373 1374
1374// packages/rich-text/build-module/remove.mjs 1375 function remove2(value, startIndex, endIndex) { 1376 return insert(value, create(), startIndex, endIndex); 1377 } 1378 1379
1379// packages/rich-text/build-module/replace.mjs 1380 function replace2({ formats, replacements, text, start, end }, pattern, replacement) { 1381 text = text.replace(pattern, (match, ...rest) => { 1382 const offset = rest[rest.length - 2]; 1383 let newText = replacement; 1384 let newFormats; 1385 let newReplacements; 1386 if (typeof newText === "function") { 1387 newText = replacement(match, ...rest); 1388 } 1389 if (typeof newText === "object") { 1390 newFormats = newText.formats; 1391 newReplacements = newText.replacements; 1392 newText = newText.text; 1393 } else { 1394 newFormats = Array(newText.length); 1395 newReplacements = Array(newText.length); 1396 if (formats[offset]) { 1397 newFormats = newFormats.fill(formats[offset]); 1398 } 1399 } 1400 formats = formats.slice(0, offset).concat(newFormats, formats.slice(offset + match.length)); 1401 replacements = replacements.slice(0, offset).concat( 1402 newReplacements, 1403 replacements.slice(offset + match.length) 1404 ); 1405 if (start) { 1406 start = end = offset + newText.length; 1407 } 1408 return newText; 1409 }); 1410 return normaliseFormats({ formats, replacements, text, start, end }); 1411 } 1412 1413
1413// packages/rich-text/build-module/insert-object.mjs 1414 function insertObject(value, formatToInsert, startIndex, endIndex) { 1415 const valueToInsert = { 1416 formats: [,], 1417 replacements: [formatToInsert], 1418 text: OBJECT_REPLACEMENT_CHARACTER 1419 }; 1420 return insert(value, valueToInsert, startIndex, endIndex); 1421 } 1422 1423
1423// packages/rich-text/build-module/slice.mjs 1424 function slice(value, startIndex = value.start, endIndex = value.end) { 1425 const { formats, replacements, text } = value; 1426 if (startIndex === void 0 || endIndex === void 0) { 1427 return { ...value }; 1428 } 1429 return { 1430 formats: formats.slice(startIndex, endIndex), 1431 replacements: replacements.slice(startIndex, endIndex), 1432 text: text.slice(startIndex, endIndex) 1433 }; 1434 } 1435 1436
1436// packages/rich-text/build-module/split.mjs 1437 function split({ formats, replacements, text, start, end }, string) { 1438 if (typeof string !== "string") { 1439 return splitAtSelection(...arguments); 1440 } 1441 let nextStart = 0; 1442 return text.split(string).map((substring) => { 1443 const startIndex = nextStart; 1444 const value = { 1445 formats: formats.slice(startIndex, startIndex + substring.length), 1446 replacements: replacements.slice( 1447 startIndex, 1448 startIndex + substring.length 1449 ), 1450 text: substring 1451 }; 1452 nextStart += string.length + substring.length; 1453 if (start !== void 0 && end !== void 0) { 1454 if (start >= startIndex && start < nextStart) { 1455 value.start = start - startIndex; 1456 } else if (start < startIndex && end > startIndex) { 1457 value.start = 0; 1458 } 1459 if (end >= startIndex && end < nextStart) { 1460 value.end = end - startIndex; 1461 } else if (start < nextStart && end > nextStart) { 1462 value.end = substring.length; 1463 } 1464 } 1465 return value; 1466 }); 1467 } 1468 function splitAtSelection({ formats, replacements, text, start, end }, startIndex = start, endIndex = end) { 1469 if (start === void 0 || end === void 0) { 1470 return; 1471 } 1472 const before = { 1473 formats: formats.slice(0, startIndex), 1474 replacements: replacements.slice(0, startIndex), 1475 text: text.slice(0, startIndex) 1476 }; 1477 const after = { 1478 formats: formats.slice(endIndex), 1479 replacements: replacements.slice(endIndex), 1480 text: text.slice(endIndex), 1481 start: 0, 1482 end: 0 1483 }; 1484 return [before, after]; 1485 } 1486 1487
1487// packages/rich-text/build-module/is-range-equal.mjs 1488 function isRangeEqual(a2, b2) { 1489 return a2 === b2 || a2 && b2 && a2.startContainer === b2.startContainer && a2.startOffset === b2.startOffset && a2.endContainer === b2.endContainer && a2.endOffset === b2.endOffset; 1490 } 1491 1492
1492// packages/rich-text/build-module/to-dom.mjs 1493 var MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML"; 1494 function createPathToNode(node, rootNode, path) { 1495 const parentNode = node.parentNode; 1496 let i2 = 0; 1497 while (node = node.previousSibling) { 1498 i2++; 1499 } 1500 path = [i2, ...path]; 1501 if (parentNode !== rootNode) { 1502 path = createPathToNode(parentNode, rootNode, path); 1503 } 1504 return path; 1505 } 1506 function getNodeByPath(node, path) { 1507 path = [...path]; 1508 while (node && path.length > 1) { 1509 node = node.childNodes[path.shift()]; 1510 } 1511 return { 1512 node, 1513 offset: path[0] 1514 }; 1515 } 1516 function append2(element, child) { 1517 if (child.html !== void 0) { 1518 return element.innerHTML += child.html; 1519 } 1520 if (typeof child === "string") { 1521 child = element.ownerDocument.createTextNode(child); 1522 } 1523 const { type, attributes } = child; 1524 if (type) { 1525 if (type === "#comment") { 1526 child = element.ownerDocument.createComment( 1527 attributes["data-rich-text-comment"] 1528 ); 1529 } else { 1530 const parentNamespace = element.namespaceURI; 1531 if (type === "math") { 1532 child = element.ownerDocument.createElementNS( 1533 MATHML_NAMESPACE, 1534 type 1535 ); 1536 } else if (parentNamespace === MATHML_NAMESPACE) { 1537 if (element.tagName === "MTEXT") { 1538 child = element.ownerDocument.createElement(type); 1539 } else { 1540 child = element.ownerDocument.createElementNS( 1541 MATHML_NAMESPACE, 1542 type 1543 ); 1544 } 1545 } else { 1546 child = element.ownerDocument.createElement(type); 1547 } 1548 for (const key in attributes) { 1549 child.setAttribute(key, attributes[key]); 1550 } 1551 } 1552 } 1553 return element.appendChild(child); 1554 } 1555 function appendText2(node, text) { 1556 node.appendData(text); 1557 } 1558 function getLastChild2({ lastChild }) { 1559 return lastChild; 1560 } 1561 function getParent2({ parentNode }) { 1562 return parentNode; 1563 } 1564 function isText2(node) { 1565 return node.nodeType === node.TEXT_NODE; 1566 } 1567 function getText2({ nodeValue }) { 1568 return nodeValue; 1569 } 1570 function remove3(node) { 1571 return node.parentNode.removeChild(node); 1572 } 1573 function toDom({ 1574 value, 1575 prepareEditableTree, 1576 isEditableTree = true, 1577 placeholder, 1578 doc = document 1579 }) { 1580 let startPath = []; 1581 let endPath = []; 1582 if (prepareEditableTree) { 1583 value = { 1584 ...value, 1585 formats: prepareEditableTree(value) 1586 }; 1587 } 1588 const createEmpty2 = () => createElement(doc, ""); 1589 const tree = toTree({ 1590 value, 1591 createEmpty: createEmpty2, 1592 append: append2, 1593 getLastChild: getLastChild2, 1594 getParent: getParent2, 1595 isText: isText2, 1596 getText: getText2, 1597 remove: remove3, 1598 appendText: appendText2, 1599 onStartIndex(body, pointer) { 1600 startPath = createPathToNode(pointer, body, [ 1601 pointer.nodeValue.length 1602 ]); 1603 }, 1604 onEndIndex(body, pointer) { 1605 endPath = createPathToNode(pointer, body, [ 1606 pointer.nodeValue.length 1607 ]); 1608 }, 1609 isEditableTree, 1610 placeholder 1611 }); 1612 return { 1613 body: tree, 1614 selection: { startPath, endPath } 1615 }; 1616 } 1617 function apply({ 1618 value, 1619 current, 1620 prepareEditableTree, 1621 __unstableDomOnly, 1622 placeholder 1623 }) { 1624 const { body, selection } = toDom({ 1625 value, 1626 prepareEditableTree, 1627 placeholder, 1628 doc: current.ownerDocument 1629 }); 1630 applyValue(body, current); 1631 if (value.start !== void 0 && !__unstableDomOnly) { 1632 applySelection(selection, current); 1633 } 1634 } 1635 function applyValue(future, current) { 1636 let i2 = 0; 1637 let futureChild; 1638 while (futureChild = future.firstChild) { 1639 const currentChild = current.childNodes[i2]; 1640 if (!currentChild) { 1641 current.appendChild(futureChild); 1642 } else if (!currentChild.isEqualNode(futureChild)) { 1643 if (currentChild.nodeName !== futureChild.nodeName || currentChild.nodeType === currentChild.TEXT_NODE && currentChild.data !== futureChild.data) { 1644 current.replaceChild(futureChild, currentChild); 1645 } else { 1646 const currentAttributes = currentChild.attributes; 1647 const futureAttributes = futureChild.attributes; 1648 if (currentAttributes) { 1649 let ii = currentAttributes.length; 1650 while (ii--) { 1651 const { name } = currentAttributes[ii]; 1652 if (!futureChild.getAttribute(name)) { 1653 currentChild.removeAttribute(name); 1654 } 1655 } 1656 } 1657 if (futureAttributes) { 1658 for (let ii = 0; ii < futureAttributes.length; ii++) { 1659 const { name, value } = futureAttributes[ii]; 1660 if (currentChild.getAttribute(name) !== value) { 1661 currentChild.setAttribute(name, value); 1662 } 1663 } 1664 } 1665 applyValue(futureChild, currentChild); 1666 future.removeChild(futureChild); 1667 } 1668 } else { 1669 future.removeChild(futureChild); 1670 } 1671 i2++; 1672 } 1673 while (current.childNodes[i2]) { 1674 current.removeChild(current.childNodes[i2]); 1675 } 1676 } 1677 function applySelection({ startPath, endPath }, current) { 1678 const { node: startContainer, offset: startOffset } = getNodeByPath( 1679 current, 1680 startPath 1681 ); 1682 const { node: endContainer, offset: endOffset } = getNodeByPath( 1683 current, 1684 endPath 1685 ); 1686 const { ownerDocument } = current; 1687 const { defaultView } = ownerDocument; 1688 const selection = defaultView.getSelection(); 1689 const range = ownerDocument.createRange(); 1690 range.setStart(startContainer, startOffset); 1691 range.setEnd(endContainer, endOffset); 1692 const { activeElement } = ownerDocument; 1693 if (selection.rangeCount > 0) { 1694 if (isRangeEqual(range, selection.getRangeAt(0))) { 1695 return; 1696 } 1697 selection.removeAllRanges(); 1698 } 1699 selection.addRange(range); 1700 if (activeElement !== ownerDocument.activeElement) { 1701 if (activeElement instanceof defaultView.HTMLElement) { 1702 activeElement.focus(); 1703 } 1704 } 1705 } 1706 1707
1707// packages/rich-text/build-module/toggle-format.mjs 1708 var import_a11y = __toESM(require_a11y(), 1); 1709 var import_i18n = __toESM(require_i18n(), 1); 1710 function toggleFormat(value, format) { 1711 if (getActiveFormat(value, format.type)) { 1712 if (format.title) { 1713 (0, import_a11y.speak)((0, import_i18n.sprintf)((0, import_i18n.__)("%s removed."), format.title), "assertive"); 1714 } 1715 return removeFormat(value, format.type); 1716 } 1717 if (format.title) { 1718 (0, import_a11y.speak)((0, import_i18n.sprintf)((0, import_i18n.__)("%s applied."), format.title), "assertive"); 1719 } 1720 return applyFormat(value, format); 1721 } 1722 1723
1723// packages/rich-text/build-module/unregister-format-type.mjs 1724 var import_data7 = __toESM(require_data(), 1); 1725 function unregisterFormatType(name) { 1726 const oldFormat = (0, import_data7.select)(store).getFormatType(name); 1727 if (!oldFormat) { 1728 window.console.error(`Format ${name} is not registered.`); 1729 return; 1730 } 1731 (0, import_data7.dispatch)(store).removeFormatTypes(name); 1732 return oldFormat; 1733 } 1734 1735
1735// packages/rich-text/build-module/lock-unlock.mjs 1736 var import_private_apis = __toESM(require_private_apis(), 1); 1737 var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)( 1738 "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.", 1739 "@wordpress/rich-text" 1740 ); 1741 1742
1742// packages/rich-text/build-module/hook/index.mjs 1743 var import_element5 = __toESM(require_element(), 1); 1744 var import_compose2 = __toESM(require_compose(), 1); 1745 var import_data9 = __toESM(require_data(), 1); 1746 var import_deprecated = __toESM(require_deprecated(), 1); 1747 1748
1748// packages/rich-text/build-module/hook/use-default-style.mjs 1749 var import_element = __toESM(require_element(), 1); 1750 var whiteSpace = "pre-wrap"; 1751 function useDefaultStyle() { 1752 return (0, import_element.useCallback)((element) => { 1753 if (!element) { 1754 return; 1755 } 1756 element.style.whiteSpace = whiteSpace; 1757 }, []); 1758 } 1759 1760
vendor: 8,333 bytes, lines 1760-1918
1760// node_modules/colord/index.mjs 1761 var r = { grad: 0.9, turn: 360, rad: 360 / (2 * Math.PI) }; 1762 var t = function(r2) { 1763 return "string" == typeof r2 ? r2.length > 0 : "number" == typeof r2; 1764 }; 1765 var n = function(r2, t2, n2) { 1766 return void 0 === t2 && (t2 = 0), void 0 === n2 && (n2 = Math.pow(10, t2)), Math.round(n2 * r2) / n2 + 0; 1767 }; 1768 var e = function(r2, t2, n2) { 1769 return void 0 === t2 && (t2 = 0), void 0 === n2 && (n2 = 1), r2 > n2 ? n2 : r2 > t2 ? r2 : t2; 1770 }; 1771 var u = function(r2) { 1772 return (r2 = isFinite(r2) ? r2 % 360 : 0) > 0 ? r2 : r2 + 360; 1773 }; 1774 var a = function(r2) { 1775 return { r: e(r2.r, 0, 255), g: e(r2.g, 0, 255), b: e(r2.b, 0, 255), a: e(r2.a) }; 1776 }; 1777 var o = function(r2) { 1778 return { r: n(r2.r), g: n(r2.g), b: n(r2.b), a: n(r2.a, 3) }; 1779 }; 1780 var i = /^#([0-9a-f]{3,8})$/i; 1781 var s = function(r2) { 1782 var t2 = r2.toString(16); 1783 return t2.length < 2 ? "0" + t2 : t2; 1784 }; 1785 var h = function(r2) { 1786 var t2 = r2.r, n2 = r2.g, e2 = r2.b, u2 = r2.a, a2 = Math.max(t2, n2, e2), o2 = a2 - Math.min(t2, n2, e2), i2 = o2 ? a2 === t2 ? (n2 - e2) / o2 : a2 === n2 ? 2 + (e2 - t2) / o2 : 4 + (t2 - n2) / o2 : 0; 1787 return { h: 60 * (i2 < 0 ? i2 + 6 : i2), s: a2 ? o2 / a2 * 100 : 0, v: a2 / 255 * 100, a: u2 }; 1788 }; 1789 var b = function(r2) { 1790 var t2 = r2.h, n2 = r2.s, e2 = r2.v, u2 = r2.a; 1791 t2 = t2 / 360 * 6, n2 /= 100, e2 /= 100; 1792 var a2 = Math.floor(t2), o2 = e2 * (1 - n2), i2 = e2 * (1 - (t2 - a2) * n2), s2 = e2 * (1 - (1 - t2 + a2) * n2), h2 = a2 % 6; 1793 return { r: 255 * [e2, i2, o2, o2, s2, e2][h2], g: 255 * [s2, e2, e2, i2, o2, o2][h2], b: 255 * [o2, o2, s2, e2, e2, i2][h2], a: u2 }; 1794 }; 1795 var g = function(r2) { 1796 return { h: u(r2.h), s: e(r2.s, 0, 100), l: e(r2.l, 0, 100), a: e(r2.a) }; 1797 }; 1798 var d = function(r2) { 1799 return { h: n(r2.h), s: n(r2.s), l: n(r2.l), a: n(r2.a, 3) }; 1800 }; 1801 var f = function(r2) { 1802 return b((n2 = (t2 = r2).s, { h: t2.h, s: (n2 *= ((e2 = t2.l) < 50 ? e2 : 100 - e2) / 100) > 0 ? 2 * n2 / (e2 + n2) * 100 : 0, v: e2 + n2, a: t2.a })); 1803 var t2, n2, e2; 1804 }; 1805 var c = function(r2) { 1806 return { h: (t2 = h(r2)).h, s: (u2 = (200 - (n2 = t2.s)) * (e2 = t2.v) / 100) > 0 && u2 < 200 ? n2 * e2 / 100 / (u2 <= 100 ? u2 : 200 - u2) * 100 : 0, l: u2 / 2, a: t2.a }; 1807 var t2, n2, e2, u2; 1808 }; 1809 var l = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i; 1810 var p = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i; 1811 var v = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i; 1812 var m = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i; 1813 var y = { string: [[function(r2) { 1814 var t2 = i.exec(r2); 1815 return t2 ? (r2 = t2[1]).length <= 4 ? { r: parseInt(r2[0] + r2[0], 16), g: parseInt(r2[1] + r2[1], 16), b: parseInt(r2[2] + r2[2], 16), a: 4 === r2.length ? n(parseInt(r2[3] + r2[3], 16) / 255, 2) : 1 } : 6 === r2.length || 8 === r2.length ? { r: parseInt(r2.substr(0, 2), 16), g: parseInt(r2.substr(2, 2), 16), b: parseInt(r2.substr(4, 2), 16), a: 8 === r2.length ? n(parseInt(r2.substr(6, 2), 16) / 255, 2) : 1 } : null : null; 1816 }, "hex"], [function(r2) { 1817 var t2 = v.exec(r2) || m.exec(r2); 1818 return t2 ? t2[2] !== t2[4] || t2[4] !== t2[6] ? null : a({ r: Number(t2[1]) / (t2[2] ? 100 / 255 : 1), g: Number(t2[3]) / (t2[4] ? 100 / 255 : 1), b: Number(t2[5]) / (t2[6] ? 100 / 255 : 1), a: void 0 === t2[7] ? 1 : Number(t2[7]) / (t2[8] ? 100 : 1) }) : null; 1819 }, "rgb"], [function(t2) { 1820 var n2 = l.exec(t2) || p.exec(t2); 1821 if (!n2) return null; 1822 var e2, u2, a2 = g({ h: (e2 = n2[1], u2 = n2[2], void 0 === u2 && (u2 = "deg"), Number(e2) * (r[u2] || 1)), s: Number(n2[3]), l: Number(n2[4]), a: void 0 === n2[5] ? 1 : Number(n2[5]) / (n2[6] ? 100 : 1) }); 1823 return f(a2); 1824 }, "hsl"]], object: [[function(r2) { 1825 var n2 = r2.r, e2 = r2.g, u2 = r2.b, o2 = r2.a, i2 = void 0 === o2 ? 1 : o2; 1826 return t(n2) && t(e2) && t(u2) ? a({ r: Number(n2), g: Number(e2), b: Number(u2), a: Number(i2) }) : null; 1827 }, "rgb"], [function(r2) { 1828 var n2 = r2.h, e2 = r2.s, u2 = r2.l, a2 = r2.a, o2 = void 0 === a2 ? 1 : a2; 1829 if (!t(n2) || !t(e2) || !t(u2)) return null; 1830 var i2 = g({ h: Number(n2), s: Number(e2), l: Number(u2), a: Number(o2) }); 1831 return f(i2); 1832 }, "hsl"], [function(r2) { 1833 var n2 = r2.h, a2 = r2.s, o2 = r2.v, i2 = r2.a, s2 = void 0 === i2 ? 1 : i2; 1834 if (!t(n2) || !t(a2) || !t(o2)) return null; 1835 var h2 = (function(r3) { 1836 return { h: u(r3.h), s: e(r3.s, 0, 100), v: e(r3.v, 0, 100), a: e(r3.a) }; 1837 })({ h: Number(n2), s: Number(a2), v: Number(o2), a: Number(s2) }); 1838 return b(h2); 1839 }, "hsv"]] }; 1840 var N = function(r2, t2) { 1841 for (var n2 = 0; n2 < t2.length; n2++) { 1842 var e2 = t2[n2][0](r2); 1843 if (e2) return [e2, t2[n2][1]]; 1844 } 1845 return [null, void 0]; 1846 }; 1847 var x = function(r2) { 1848 return "string" == typeof r2 ? N(r2.trim(), y.string) : "object" == typeof r2 && null !== r2 ? N(r2, y.object) : [null, void 0]; 1849 }; 1850 var M = function(r2, t2) { 1851 var n2 = c(r2); 1852 return { h: n2.h, s: e(n2.s + 100 * t2, 0, 100), l: n2.l, a: n2.a }; 1853 }; 1854 var H = function(r2) { 1855 return (299 * r2.r + 587 * r2.g + 114 * r2.b) / 1e3 / 255; 1856 }; 1857 var $ = function(r2, t2) { 1858 var n2 = c(r2); 1859 return { h: n2.h, s: n2.s, l: e(n2.l + 100 * t2, 0, 100), a: n2.a }; 1860 }; 1861 var j = (function() { 1862 function r2(r3) { 1863 this.parsed = x(r3)[0], this.rgba = this.parsed || { r: 0, g: 0, b: 0, a: 1 }; 1864 } 1865 return r2.prototype.isValid = function() { 1866 return null !== this.parsed; 1867 }, r2.prototype.brightness = function() { 1868 return n(H(this.rgba), 2); 1869 }, r2.prototype.isDark = function() { 1870 return H(this.rgba) < 0.5; 1871 }, r2.prototype.isLight = function() { 1872 return H(this.rgba) >= 0.5; 1873 }, r2.prototype.toHex = function() { 1874 return r3 = o(this.rgba), t2 = r3.r, e2 = r3.g, u2 = r3.b, i2 = (a2 = r3.a) < 1 ? s(n(255 * a2)) : "", "#" + s(t2) + s(e2) + s(u2) + i2; 1875 var r3, t2, e2, u2, a2, i2; 1876 }, r2.prototype.toRgb = function() { 1877 return o(this.rgba); 1878 }, r2.prototype.toRgbString = function() { 1879 return r3 = o(this.rgba), t2 = r3.r, n2 = r3.g, e2 = r3.b, (u2 = r3.a) < 1 ? "rgba(" + t2 + ", " + n2 + ", " + e2 + ", " + u2 + ")" : "rgb(" + t2 + ", " + n2 + ", " + e2 + ")"; 1880 var r3, t2, n2, e2, u2; 1881 }, r2.prototype.toHsl = function() { 1882 return d(c(this.rgba)); 1883 }, r2.prototype.toHslString = function() { 1884 return r3 = d(c(this.rgba)), t2 = r3.h, n2 = r3.s, e2 = r3.l, (u2 = r3.a) < 1 ? "hsla(" + t2 + ", " + n2 + "%, " + e2 + "%, " + u2 + ")" : "hsl(" + t2 + ", " + n2 + "%, " + e2 + "%)"; 1885 var r3, t2, n2, e2, u2; 1886 }, r2.prototype.toHsv = function() { 1887 return r3 = h(this.rgba), { h: n(r3.h), s: n(r3.s), v: n(r3.v), a: n(r3.a, 3) }; 1888 var r3; 1889 }, r2.prototype.invert = function() { 1890 return w({ r: 255 - (r3 = this.rgba).r, g: 255 - r3.g, b: 255 - r3.b, a: r3.a }); 1891 var r3; 1892 }, r2.prototype.saturate = function(r3) { 1893 return void 0 === r3 && (r3 = 0.1), w(M(this.rgba, r3)); 1894 }, r2.prototype.desaturate = function(r3) { 1895 return void 0 === r3 && (r3 = 0.1), w(M(this.rgba, -r3)); 1896 }, r2.prototype.grayscale = function() { 1897 return w(M(this.rgba, -1)); 1898 }, r2.prototype.lighten = function(r3) { 1899 return void 0 === r3 && (r3 = 0.1), w($(this.rgba, r3)); 1900 }, r2.prototype.darken = function(r3) { 1901 return void 0 === r3 && (r3 = 0.1), w($(this.rgba, -r3)); 1902 }, r2.prototype.rotate = function(r3) { 1903 return void 0 === r3 && (r3 = 15), this.hue(this.hue() + r3); 1904 }, r2.prototype.alpha = function(r3) { 1905 return "number" == typeof r3 ? w({ r: (t2 = this.rgba).r, g: t2.g, b: t2.b, a: r3 }) : n(this.rgba.a, 3); 1906 var t2; 1907 }, r2.prototype.hue = function(r3) { 1908 var t2 = c(this.rgba); 1909 return "number" == typeof r3 ? w({ h: r3, s: t2.s, l: t2.l, a: t2.a }) : n(t2.h); 1910 }, r2.prototype.isEqual = function(r3) { 1911 return this.toHex() === w(r3).toHex(); 1912 }, r2; 1913 })(); 1914 var w = function(r2) { 1915 return r2 instanceof j ? r2 : new j(r2); 1916 }; 1917 1918
1918// packages/rich-text/build-module/hook/use-boundary-style.mjs 1919 var import_element2 = __toESM(require_element(), 1); 1920 function useBoundaryStyle({ record }) { 1921 const ref = (0, import_element2.useRef)(); 1922 const { activeFormats = [], replacements, start } = record.current; 1923 const activeReplacement = replacements[start]; 1924 (0, import_element2.useEffect)(() => { 1925 if ((!activeFormats || !activeFormats.length) && !activeReplacement) { 1926 return; 1927 } 1928 const boundarySelector = "*[data-rich-text-format-boundary]"; 1929 const element = ref.current.querySelector(boundarySelector); 1930 if (!element) { 1931 return; 1932 } 1933 const { ownerDocument } = element; 1934 const { defaultView } = ownerDocument; 1935 const computedStyle = defaultView.getComputedStyle(element); 1936 const newColor = w(computedStyle.color).alpha(0.2).toRgbString(); 1937 const selector = `.rich-text:focus ${boundarySelector}`; 1938 const rule = `background-color: ${newColor}`; 1939 const style = `${selector} {${rule}}`; 1940 const globalStyleId = "rich-text-boundary-style"; 1941 let globalStyle = ownerDocument.getElementById(globalStyleId); 1942 if (!globalStyle) { 1943 globalStyle = ownerDocument.createElement("style"); 1944 globalStyle.id = globalStyleId; 1945 ownerDocument.head.appendChild(globalStyle); 1946 } 1947 if (globalStyle.innerHTML !== style) { 1948 globalStyle.innerHTML = style; 1949 } 1950 }, [activeFormats, activeReplacement]); 1951 return ref; 1952 } 1953 1954
1954// packages/rich-text/build-module/hook/event-listeners/index.mjs 1955 var import_element3 = __toESM(require_element(), 1); 1956 var import_compose = __toESM(require_compose(), 1); 1957 1958
1958// packages/rich-text/build-module/hook/event-listeners/copy-handler.mjs 1959 var copy_handler_default = (props) => (element) => { 1960 function onCopy(event) { 1961 const { record } = props.current; 1962 const { ownerDocument } = element; 1963 if (isCollapsed(record.current) || !element.contains(ownerDocument.activeElement)) { 1964 return; 1965 } 1966 const selectedRecord = slice(record.current); 1967 const plainText = getTextContent(selectedRecord); 1968 const html = toHTMLString({ value: selectedRecord }); 1969 event.clipboardData.setData("text/plain", plainText); 1970 event.clipboardData.setData("text/html", html); 1971 event.clipboardData.setData("rich-text", "true"); 1972 event.preventDefault(); 1973 if (event.type === "cut") { 1974 ownerDocument.execCommand("delete"); 1975 } 1976 } 1977 const { defaultView } = element.ownerDocument; 1978 defaultView.addEventListener("copy", onCopy); 1979 defaultView.addEventListener("cut", onCopy); 1980 return () => { 1981 defaultView.removeEventListener("copy", onCopy); 1982 defaultView.removeEventListener("cut", onCopy); 1983 }; 1984 }; 1985 1986
1986// packages/rich-text/build-module/hook/event-listeners/select-object.mjs 1987 var select_object_default = () => (element) => { 1988 function onClick(event) { 1989 const { target } = event; 1990 if (target === element || target.textContent && target.isContentEditable) { 1991 return; 1992 } 1993 const { ownerDocument } = target; 1994 const { defaultView } = ownerDocument; 1995 const selection = defaultView.getSelection(); 1996 if (selection.containsNode(target)) { 1997 return; 1998 } 1999 const range = ownerDocument.createRange(); 2000 const nodeToSelect = target.isContentEditable ? target : target.closest("[contenteditable]"); 2001 range.selectNode(nodeToSelect); 2002 selection.removeAllRanges(); 2003 selection.addRange(range); 2004 event.preventDefault(); 2005 } 2006 function onFocusIn(event) { 2007 if (event.relatedTarget && !element.contains(event.relatedTarget) && event.relatedTarget.tagName === "A") { 2008 onClick(event); 2009 } 2010 } 2011 element.addEventListener("click", onClick); 2012 element.addEventListener("focusin", onFocusIn); 2013 return () => { 2014 element.removeEventListener("click", onClick); 2015 element.removeEventListener("focusin", onFocusIn); 2016 }; 2017 }; 2018 2019
2019// packages/rich-text/build-module/hook/event-listeners/format-boundaries.mjs 2020 var import_keycodes = __toESM(require_keycodes(), 1); 2021 var EMPTY_ACTIVE_FORMATS = []; 2022 var format_boundaries_default = (props) => (element) => { 2023 function onKeyDown(event) { 2024 const { keyCode, shiftKey, altKey, metaKey, ctrlKey } = event; 2025 if ( 2026 // Only override left and right keys without modifiers pressed. 2027 shiftKey || altKey || metaKey || ctrlKey || keyCode !== import_keycodes.LEFT && keyCode !== import_keycodes.RIGHT 2028 ) { 2029 return; 2030 } 2031 const { record, applyRecord, forceRender } = props.current; 2032 const { 2033 text, 2034 formats, 2035 start, 2036 end, 2037 activeFormats: currentActiveFormats = [] 2038 } = record.current; 2039 const collapsed = isCollapsed(record.current); 2040 const { ownerDocument } = element; 2041 const { defaultView } = ownerDocument; 2042 const { direction } = defaultView.getComputedStyle(element); 2043 const reverseKey = direction === "rtl" ? import_keycodes.RIGHT : import_keycodes.LEFT; 2044 const isReverse = event.keyCode === reverseKey; 2045 if (collapsed && currentActiveFormats.length === 0) { 2046 if (start === 0 && isReverse) { 2047 return; 2048 } 2049 if (end === text.length && !isReverse) { 2050 return; 2051 } 2052 } 2053 if (!collapsed) { 2054 return; 2055 } 2056 const formatsBefore = formats[start - 1] || EMPTY_ACTIVE_FORMATS; 2057 const formatsAfter = formats[start] || EMPTY_ACTIVE_FORMATS; 2058 const destination = isReverse ? formatsBefore : formatsAfter; 2059 const isIncreasing = currentActiveFormats.every( 2060 (format, index) => format === destination[index] 2061 ); 2062 let newActiveFormatsLength = currentActiveFormats.length; 2063 if (!isIncreasing) { 2064 newActiveFormatsLength--; 2065 } else if (newActiveFormatsLength < destination.length) { 2066 newActiveFormatsLength++; 2067 } 2068 if (newActiveFormatsLength === currentActiveFormats.length) { 2069 record.current._newActiveFormats = destination; 2070 return; 2071 } 2072 event.preventDefault(); 2073 const origin = isReverse ? formatsAfter : formatsBefore; 2074 const source = isIncreasing ? destination : origin; 2075 const newActiveFormats = source.slice(0, newActiveFormatsLength); 2076 const newValue = { 2077 ...record.current, 2078 activeFormats: newActiveFormats 2079 }; 2080 record.current = newValue; 2081 applyRecord(newValue); 2082 forceRender(); 2083 } 2084 element.addEventListener("keydown", onKeyDown); 2085 return () => { 2086 element.removeEventListener("keydown", onKeyDown); 2087 }; 2088 }; 2089 2090
2090// packages/rich-text/build-module/hook/event-listeners/delete.mjs 2091 var import_keycodes2 = __toESM(require_keycodes(), 1); 2092 var delete_default = (props) => (element) => { 2093 function onKeyDown(event) { 2094 const { keyCode } = event; 2095 const { createRecord, handleChange } = props.current; 2096 if (event.defaultPrevented) { 2097 return; 2098 } 2099 if (keyCode !== import_keycodes2.DELETE && keyCode !== import_keycodes2.BACKSPACE) { 2100 return; 2101 } 2102 const currentValue = createRecord(); 2103 const { start, end, text } = currentValue; 2104 if (start === 0 && end !== 0 && end === text.length) { 2105 handleChange(remove2(currentValue)); 2106 event.preventDefault(); 2107 } 2108 } 2109 element.addEventListener("keydown", onKeyDown); 2110 return () => { 2111 element.removeEventListener("keydown", onKeyDown); 2112 }; 2113 }; 2114 2115
2115// packages/rich-text/build-module/update-formats.mjs 2116 function updateFormats({ value, start, end, formats }) { 2117 const min = Math.min(start, end); 2118 const max = Math.max(start, end); 2119 const formatsBefore = value.formats[min - 1] || []; 2120 const formatsAfter = value.formats[max] || []; 2121 value.activeFormats = formats.map((format, index) => { 2122 if (formatsBefore[index]) { 2123 if (isFormatEqual(format, formatsBefore[index])) { 2124 return formatsBefore[index]; 2125 } 2126 } else if (formatsAfter[index]) { 2127 if (isFormatEqual(format, formatsAfter[index])) { 2128 return formatsAfter[index]; 2129 } 2130 } 2131 return format; 2132 }); 2133 while (--end >= start) { 2134 if (value.activeFormats.length > 0) { 2135 value.formats[end] = value.activeFormats; 2136 } else { 2137 delete value.formats[end]; 2138 } 2139 } 2140 return value; 2141 } 2142 2143
2143// packages/rich-text/build-module/hook/event-listeners/input-and-selection.mjs 2144 var INSERTION_INPUT_TYPES_TO_IGNORE = /* @__PURE__ */ new Set([ 2145 "insertParagraph", 2146 "insertOrderedList", 2147 "insertUnorderedList", 2148 "insertHorizontalRule", 2149 "insertLink" 2150 ]); 2151 var EMPTY_ACTIVE_FORMATS2 = []; 2152 var PLACEHOLDER_ATTR_NAME = "data-rich-text-placeholder"; 2153 function fixPlaceholderSelection(defaultView) { 2154 const selection = defaultView.getSelection(); 2155 const { anchorNode, anchorOffset } = selection; 2156 if (anchorNode.nodeType !== anchorNode.ELEMENT_NODE) { 2157 return; 2158 } 2159 const targetNode = anchorNode.childNodes[anchorOffset]; 2160 if (!targetNode || targetNode.nodeType !== targetNode.ELEMENT_NODE || !targetNode.hasAttribute(PLACEHOLDER_ATTR_NAME)) { 2161 return; 2162 } 2163 selection.collapseToStart(); 2164 } 2165 var input_and_selection_default = (props) => (element) => { 2166 const { ownerDocument } = element; 2167 const { defaultView } = ownerDocument; 2168 let isComposing = false; 2169 function onInput(event) { 2170 if (isComposing) { 2171 return; 2172 } 2173 let inputType; 2174 if (event) { 2175 inputType = event.inputType; 2176 } 2177 const { record, applyRecord, createRecord, handleChange } = props.current; 2178 if (inputType && (inputType.indexOf("format") === 0 || INSERTION_INPUT_TYPES_TO_IGNORE.has(inputType))) { 2179 applyRecord(record.current); 2180 return; 2181 } 2182 const currentValue = createRecord(); 2183 const { start, activeFormats: oldActiveFormats = [] } = record.current; 2184 const clearFormats = !isCollapsed(record.current) && currentValue.start <= start; 2185 const change = updateFormats({ 2186 value: currentValue, 2187 start, 2188 end: currentValue.start, 2189 formats: clearFormats ? [] : oldActiveFormats 2190 }); 2191 handleChange(change); 2192 } 2193 function handleSelectionChange() { 2194 const { record, applyRecord, createRecord, onSelectionChange } = props.current; 2195 if (element.contentEditable !== "true") { 2196 return; 2197 } 2198 if (ownerDocument.activeElement !== element) { 2199 ownerDocument.removeEventListener( 2200 "selectionchange", 2201 handleSelectionChange 2202 ); 2203 return; 2204 } 2205 if (isComposing) { 2206 return; 2207 } 2208 const { start, end, text } = createRecord(); 2209 const oldRecord = record.current; 2210 if (text !== oldRecord.text) { 2211 onInput(); 2212 return; 2213 } 2214 if (start === oldRecord.start && end === oldRecord.end) { 2215 if (oldRecord.text.length === 0 && start === 0) { 2216 fixPlaceholderSelection(defaultView); 2217 } 2218 return; 2219 } 2220 const newValue = { 2221 ...oldRecord, 2222 start, 2223 end, 2224 // _newActiveFormats may be set on arrow key navigation to control 2225 // the right boundary position. If undefined, getActiveFormats will 2226 // give the active formats according to the browser. 2227 activeFormats: oldRecord._newActiveFormats, 2228 _newActiveFormats: void 0 2229 }; 2230 const newActiveFormats = getActiveFormats( 2231 newValue, 2232 EMPTY_ACTIVE_FORMATS2 2233 ); 2234 newValue.activeFormats = newActiveFormats; 2235 record.current = newValue; 2236 applyRecord(newValue, { domOnly: true }); 2237 onSelectionChange(start, end); 2238 } 2239 function onCompositionStart() { 2240 isComposing = true; 2241 ownerDocument.removeEventListener( 2242 "selectionchange", 2243 handleSelectionChange 2244 ); 2245 element.querySelector(`[${PLACEHOLDER_ATTR_NAME}]`)?.remove(); 2246 } 2247 function onCompositionEnd() { 2248 isComposing = false; 2249 onInput({ inputType: "insertText" }); 2250 ownerDocument.addEventListener( 2251 "selectionchange", 2252 handleSelectionChange 2253 ); 2254 } 2255 function onFocus() { 2256 const { record, isSelected, onSelectionChange, applyRecord } = props.current; 2257 if (element.parentElement.closest('[contenteditable="true"]')) { 2258 return; 2259 } 2260 if (!isSelected) { 2261 const index = void 0; 2262 record.current = { 2263 ...record.current, 2264 start: index, 2265 end: index, 2266 activeFormats: EMPTY_ACTIVE_FORMATS2 2267 }; 2268 } else { 2269 applyRecord(record.current, { domOnly: true }); 2270 } 2271 onSelectionChange(record.current.start, record.current.end); 2272 window.queueMicrotask(handleSelectionChange); 2273 ownerDocument.addEventListener( 2274 "selectionchange", 2275 handleSelectionChange 2276 ); 2277 } 2278 element.addEventListener("input", onInput); 2279 element.addEventListener("compositionstart", onCompositionStart); 2280 element.addEventListener("compositionend", onCompositionEnd); 2281 element.addEventListener("focus", onFocus); 2282 return () => { 2283 element.removeEventListener("input", onInput); 2284 element.removeEventListener("compositionstart", onCompositionStart); 2285 element.removeEventListener("compositionend", onCompositionEnd); 2286 element.removeEventListener("focus", onFocus); 2287 }; 2288 }; 2289 2290
2290// packages/rich-text/build-module/hook/event-listeners/selection-change-compat.mjs 2291 var selection_change_compat_default = () => (element) => { 2292 const { ownerDocument } = element; 2293 const { defaultView } = ownerDocument; 2294 const selection = defaultView?.getSelection(); 2295 let range; 2296 function getRange() { 2297 return selection.rangeCount ? selection.getRangeAt(0) : null; 2298 } 2299 function onDown(event) { 2300 const type = event.type === "keydown" ? "keyup" : "pointerup"; 2301 function onCancel() { 2302 ownerDocument.removeEventListener(type, onUp); 2303 ownerDocument.removeEventListener("selectionchange", onCancel); 2304 ownerDocument.removeEventListener("input", onCancel); 2305 } 2306 function onUp() { 2307 onCancel(); 2308 if (isRangeEqual(range, getRange())) { 2309 return; 2310 } 2311 ownerDocument.dispatchEvent(new Event("selectionchange")); 2312 } 2313 ownerDocument.addEventListener(type, onUp); 2314 ownerDocument.addEventListener("selectionchange", onCancel); 2315 ownerDocument.addEventListener("input", onCancel); 2316 range = getRange(); 2317 } 2318 element.addEventListener("pointerdown", onDown); 2319 element.addEventListener("keydown", onDown); 2320 return () => { 2321 element.removeEventListener("pointerdown", onDown); 2322 element.removeEventListener("keydown", onDown); 2323 }; 2324 }; 2325 2326
2326// packages/rich-text/build-module/hook/event-listeners/prevent-focus-capture.mjs 2327 function preventFocusCapture() { 2328 return (element) => { 2329 const { ownerDocument } = element; 2330 const { defaultView } = ownerDocument; 2331 let value = null; 2332 function onPointerDown(event) { 2333 if (event.defaultPrevented) { 2334 return; 2335 } 2336 if (event.target === element) { 2337 return; 2338 } 2339 if (!event.target.contains(element)) { 2340 return; 2341 } 2342 value = element.getAttribute("contenteditable"); 2343 element.setAttribute("contenteditable", "false"); 2344 defaultView.getSelection().removeAllRanges(); 2345 } 2346 function onPointerUp() { 2347 if (value !== null) { 2348 element.setAttribute("contenteditable", value); 2349 value = null; 2350 } 2351 } 2352 defaultView.addEventListener("pointerdown", onPointerDown); 2353 defaultView.addEventListener("pointerup", onPointerUp); 2354 return () => { 2355 defaultView.removeEventListener("pointerdown", onPointerDown); 2356 defaultView.removeEventListener("pointerup", onPointerUp); 2357 }; 2358 }; 2359 } 2360 2361
2361// packages/rich-text/build-module/hook/event-listeners/index.mjs 2362 var allEventListeners = [ 2363 copy_handler_default, 2364 select_object_default, 2365 format_boundaries_default, 2366 delete_default, 2367 input_and_selection_default, 2368 selection_change_compat_default, 2369 preventFocusCapture 2370 ]; 2371 function useEventListeners(props) { 2372 const propsRef = (0, import_element3.useRef)(props); 2373 (0, import_element3.useInsertionEffect)(() => { 2374 propsRef.current = props; 2375 }); 2376 const refEffects = (0, import_element3.useMemo)( 2377 () => allEventListeners.map((refEffect) => refEffect(propsRef)), 2378 [propsRef] 2379 ); 2380 return (0, import_compose.useRefEffect)( 2381 (element) => { 2382 const cleanups = refEffects.map((effect) => effect(element)); 2383 return () => { 2384 cleanups.forEach((cleanup) => cleanup()); 2385 }; 2386 }, 2387 [refEffects] 2388 ); 2389 } 2390 2391
2391// packages/rich-text/build-module/hook/use-format-types.mjs 2392 var import_element4 = __toESM(require_element(), 1); 2393 var import_data8 = __toESM(require_data(), 1); 2394 function formatTypesSelector(select5) { 2395 return select5(store).getFormatTypes(); 2396 } 2397 var interactiveContentTags = /* @__PURE__ */ new Set([ 2398 "a", 2399 "audio", 2400 "button", 2401 "details", 2402 "embed", 2403 "iframe", 2404 "input", 2405 "label", 2406 "select", 2407 "textarea", 2408 "video" 2409 ]); 2410 function prefixSelectKeys(selected, prefix) { 2411 if (typeof selected !== "object") { 2412 return { [prefix]: selected }; 2413 } 2414 return Object.fromEntries( 2415 Object.entries(selected).map(([key, value]) => [ 2416 `${prefix}.${key}`, 2417 value 2418 ]) 2419 ); 2420 } 2421 function getPrefixedSelectKeys(selected, prefix) { 2422 if (selected[prefix]) { 2423 return selected[prefix]; 2424 } 2425 return Object.keys(selected).filter((key) => key.startsWith(prefix + ".")).reduce((accumulator, key) => { 2426 accumulator[key.slice(prefix.length + 1)] = selected[key]; 2427 return accumulator; 2428 }, {}); 2429 } 2430 function useFormatTypes({ 2431 allowedFormats, 2432 withoutInteractiveFormatting, 2433 __unstableFormatTypeHandlerContext 2434 }) { 2435 const allFormatTypes = (0, import_data8.useSelect)(formatTypesSelector, []); 2436 const formatTypes2 = (0, import_element4.useMemo)(() => { 2437 return allFormatTypes.filter(({ name, interactive, tagName }) => { 2438 if (allowedFormats && !allowedFormats.includes(name)) { 2439 return false; 2440 } 2441 if (withoutInteractiveFormatting && (interactive || interactiveContentTags.has(tagName))) { 2442 return false; 2443 } 2444 return true; 2445 }); 2446 }, [allFormatTypes, allowedFormats, withoutInteractiveFormatting]); 2447 const keyedSelected = (0, import_data8.useSelect)( 2448 (select5) => formatTypes2.reduce((accumulator, type) => { 2449 if (!type.__experimentalGetPropsForEditableTreePreparation || !__unstableFormatTypeHandlerContext) { 2450 return accumulator; 2451 } 2452 return { 2453 ...accumulator, 2454 ...prefixSelectKeys( 2455 type.__experimentalGetPropsForEditableTreePreparation( 2456 select5, 2457 __unstableFormatTypeHandlerContext 2458 ), 2459 type.name 2460 ) 2461 }; 2462 }, {}), 2463 [formatTypes2, __unstableFormatTypeHandlerContext] 2464 ); 2465 const dispatch3 = (0, import_data8.useDispatch)(); 2466 const prepareHandlers = []; 2467 const valueHandlers = []; 2468 const changeHandlers = []; 2469 const dependencies = []; 2470 for (const key in keyedSelected) { 2471 dependencies.push(keyedSelected[key]); 2472 } 2473 formatTypes2.forEach((type) => { 2474 if (type.__experimentalCreatePrepareEditableTree && __unstableFormatTypeHandlerContext) { 2475 const handler = type.__experimentalCreatePrepareEditableTree( 2476 getPrefixedSelectKeys(keyedSelected, type.name), 2477 __unstableFormatTypeHandlerContext 2478 ); 2479 if (type.__experimentalCreateOnChangeEditableValue) { 2480 valueHandlers.push(handler); 2481 } else { 2482 prepareHandlers.push(handler); 2483 } 2484 } 2485 if (type.__experimentalCreateOnChangeEditableValue && __unstableFormatTypeHandlerContext) { 2486 let dispatchers = {}; 2487 if (type.__experimentalGetPropsForEditableTreeChangeHandler) { 2488 dispatchers = type.__experimentalGetPropsForEditableTreeChangeHandler( 2489 dispatch3, 2490 __unstableFormatTypeHandlerContext 2491 ); 2492 } 2493 const selected = getPrefixedSelectKeys(keyedSelected, type.name); 2494 changeHandlers.push( 2495 type.__experimentalCreateOnChangeEditableValue( 2496 { 2497 ...typeof selected === "object" ? selected : {}, 2498 ...dispatchers 2499 }, 2500 __unstableFormatTypeHandlerContext 2501 ) 2502 ); 2503 } 2504 }); 2505 return { 2506 formatTypes: formatTypes2, 2507 prepareHandlers, 2508 valueHandlers, 2509 changeHandlers, 2510 dependencies 2511 }; 2512 } 2513 2514
2514// packages/rich-text/build-module/hook/index.mjs 2515 function useRichTextBase({ 2516 value = "", 2517 selectionStart, 2518 selectionEnd, 2519 placeholder, 2520 onSelectionChange, 2521 preserveWhiteSpace, 2522 onChange, 2523 __unstableDisableFormats: disableFormats, 2524 __unstableIsSelected: isSelected, 2525 __unstableDependencies = [], 2526 __unstableAfterParse, 2527 __unstableBeforeSerialize, 2528 __unstableAddInvisibleFormats 2529 }) { 2530 const registry = (0, import_data9.useRegistry)(); 2531 const [, forceRender] = (0, import_element5.useReducer)(() => ({})); 2532 const ref = (0, import_element5.useRef)(); 2533 function createRecord() { 2534 const { 2535 ownerDocument: { defaultView } 2536 } = ref.current; 2537 const selection = defaultView.getSelection(); 2538 const range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null; 2539 return create({ 2540 element: ref.current, 2541 range, 2542 __unstableIsEditableTree: true 2543 }); 2544 } 2545 function applyRecord(newRecord, { domOnly } = {}) { 2546 apply({ 2547 value: newRecord, 2548 current: ref.current, 2549 prepareEditableTree: __unstableAddInvisibleFormats, 2550 __unstableDomOnly: domOnly, 2551 placeholder 2552 }); 2553 } 2554 const _valueRef = (0, import_element5.useRef)(value); 2555 const recordRef = (0, import_element5.useRef)(); 2556 function setRecordFromProps() { 2557 const activeFormats = recordRef.current?.activeFormats; 2558 _valueRef.current = value; 2559 recordRef.current = value; 2560 if (!(value instanceof RichTextData)) { 2561 recordRef.current = value ? RichTextData.fromHTMLString(value, { preserveWhiteSpace }) : RichTextData.empty(); 2562 } 2563 recordRef.current = { 2564 text: recordRef.current.text, 2565 formats: recordRef.current.formats, 2566 replacements: recordRef.current.replacements, 2567 activeFormats 2568 }; 2569 if (disableFormats) { 2570 recordRef.current.formats = Array(value.length); 2571 recordRef.current.replacements = Array(value.length); 2572 } 2573 if (__unstableAfterParse) { 2574 recordRef.current.formats = __unstableAfterParse( 2575 recordRef.current 2576 ); 2577 } 2578 recordRef.current.start = selectionStart; 2579 recordRef.current.end = selectionEnd; 2580 } 2581 const hadSelectionUpdateRef = (0, import_element5.useRef)(false); 2582 if (!recordRef.current) { 2583 hadSelectionUpdateRef.current = isSelected; 2584 setRecordFromProps(); 2585 } else if (selectionStart !== recordRef.current.start || selectionEnd !== recordRef.current.end) { 2586 hadSelectionUpdateRef.current = isSelected; 2587 recordRef.current = { 2588 ...recordRef.current, 2589 start: selectionStart, 2590 end: selectionEnd, 2591 activeFormats: void 0 2592 }; 2593 } 2594 function handleChange(newRecord) { 2595 recordRef.current = newRecord; 2596 applyRecord(newRecord); 2597 if (disableFormats) { 2598 _valueRef.current = newRecord.text; 2599 } else { 2600 const newFormats = __unstableBeforeSerialize ? __unstableBeforeSerialize(newRecord) : newRecord.formats; 2601 newRecord = { ...newRecord, formats: newFormats }; 2602 if (typeof value === "string") { 2603 _valueRef.current = toHTMLString({ 2604 value: newRecord, 2605 preserveWhiteSpace 2606 }); 2607 } else { 2608 _valueRef.current = new RichTextData(newRecord); 2609 } 2610 } 2611 const { start, end, formats, text } = recordRef.current; 2612 registry.batch(() => { 2613 onSelectionChange(start, end); 2614 onChange(_valueRef.current, { 2615 __unstableFormats: formats, 2616 __unstableText: text 2617 }); 2618 }); 2619 forceRender(); 2620 } 2621 function applyFromProps() { 2622 const previousValue = _valueRef.current; 2623 setRecordFromProps(); 2624 const contentLengthChanged = previousValue && typeof previousValue === "string" && typeof value === "string" && previousValue.length !== value.length; 2625 const hasFocus = ref.current?.contains( 2626 ref.current.ownerDocument.activeElement 2627 ); 2628 const skipSelection = contentLengthChanged && !hasFocus; 2629 applyRecord(recordRef.current, { domOnly: skipSelection }); 2630 } 2631 const didMountRef = (0, import_element5.useRef)(false); 2632 (0, import_element5.useLayoutEffect)(() => { 2633 if (didMountRef.current && value !== _valueRef.current) { 2634 applyFromProps(); 2635 forceRender(); 2636 } 2637 }, [value]); 2638 (0, import_element5.useLayoutEffect)(() => { 2639 if (!hadSelectionUpdateRef.current) { 2640 return; 2641 } 2642 if (ref.current.ownerDocument.activeElement !== ref.current) { 2643 ref.current.focus(); 2644 } 2645 applyRecord(recordRef.current); 2646 hadSelectionUpdateRef.current = false;
2647 }, [hadSelectionUpdateRef.current]); 2648 const mergedRefs = (0, import_compose2.useMergeRefs)([ 2649 ref, 2650 useDefaultStyle(), 2651 useBoundaryStyle({ record: recordRef }), 2652 useEventListeners({ 2653 record: recordRef, 2654 handleChange, 2655 applyRecord, 2656 createRecord, 2657 isSelected, 2658 onSelectionChange, 2659 forceRender 2660 }), 2661 (0, import_compose2.useRefEffect)(() => { 2662 applyFromProps(); 2663 didMountRef.current = true; 2664 }, [placeholder, ...__unstableDependencies]) 2665 ]); 2666 return { 2667 value: recordRef.current, 2668 // A function to get the most recent value so event handlers in 2669 // useRichText implementations have access to it. For example when 2670 // listening to input events, we internally update the state, but this 2671 // state is not yet available to the input event handler because React 2672 // may re-render asynchronously. 2673 getValue: () => recordRef.current, 2674 onChange: handleChange, 2675 ref: mergedRefs 2676 }; 2677 } 2678 function useRichText({ 2679 allowedFormats, 2680 withoutInteractiveFormatting, 2681 onChange, 2682 __unstableDependencies = [], 2683 __unstableFormatTypeHandlerContext, 2684 ...props 2685 }) { 2686 const { 2687 formatTypes: formatTypes2, 2688 prepareHandlers, 2689 valueHandlers, 2690 changeHandlers, 2691 dependencies 2692 } = useFormatTypes({ 2693 allowedFormats, 2694 withoutInteractiveFormatting, 2695 __unstableFormatTypeHandlerContext 2696 }); 2697 function addEditorOnlyFormats(record) { 2698 return valueHandlers.reduce( 2699 (accumulator, fn) => fn(accumulator, record.text), 2700 record.formats 2701 ); 2702 } 2703 function removeEditorOnlyFormats(record) { 2704 formatTypes2.forEach((formatType) => { 2705 if (formatType.__experimentalCreatePrepareEditableTree) { 2706 record = removeFormat( 2707 record, 2708 formatType.name, 2709 0, 2710 record.text.length 2711 ); 2712 } 2713 }); 2714 return record.formats; 2715 } 2716 function addInvisibleFormats(record) { 2717 return prepareHandlers.reduce( 2718 (accumulator, fn) => fn(accumulator, record.text), 2719 record.formats 2720 ); 2721 } 2722 const result = useRichTextBase({ 2723 ...props, 2724 onChange(value, { __unstableFormats, __unstableText }) { 2725 onChange(value, { __unstableFormats, __unstableText }); 2726 Object.values(changeHandlers).forEach((changeHandler) => { 2727 changeHandler(__unstableFormats, __unstableText); 2728 }); 2729 }, 2730 __unstableDependencies: [...dependencies, ...__unstableDependencies], 2731 __unstableAfterParse: addEditorOnlyFormats, 2732 __unstableBeforeSerialize: removeEditorOnlyFormats, 2733 __unstableAddInvisibleFormats: addInvisibleFormats 2734 }); 2735 return { ...result, formatTypes: formatTypes2 }; 2736 } 2737 function __unstableUseRichText(props) { 2738 (0, import_deprecated.default)("`__unstableUseRichText` hook", { 2739 since: "7.0" 2740 }); 2741 return useRichTextBase(props); 2742 } 2743 2744
2744// packages/rich-text/build-module/private-apis.mjs 2745 var privateApis = {}; 2746 lock(privateApis, { 2747 useRichText 2748 }); 2749 2750
2750// packages/rich-text/build-module/hook/use-anchor-ref.mjs 2751 var import_element6 = __toESM(require_element(), 1); 2752 var import_deprecated2 = __toESM(require_deprecated(), 1); 2753 function useAnchorRef({ ref, value, settings = {} }) { 2754 (0, import_deprecated2.default)("`useAnchorRef` hook", { 2755 since: "6.1", 2756 alternative: "`useAnchor` hook" 2757 }); 2758 const { tagName, className, name } = settings; 2759 const activeFormat = name ? getActiveFormat(value, name) : void 0; 2760 return (0, import_element6.useMemo)(() => { 2761 if (!ref.current) { 2762 return; 2763 } 2764 const { 2765 ownerDocument: { defaultView } 2766 } = ref.current; 2767 const selection = defaultView.getSelection(); 2768 if (!selection.rangeCount) { 2769 return; 2770 } 2771 const range = selection.getRangeAt(0); 2772 if (!activeFormat) { 2773 return range; 2774 } 2775 let element = range.startContainer; 2776 element = element.nextElementSibling || element; 2777 while (element.nodeType !== element.ELEMENT_NODE) { 2778 element = element.parentNode; 2779 } 2780 return element.closest( 2781 tagName + (className ? "." + className : "") 2782 ); 2783 }, [activeFormat, value.start, value.end, tagName, className]); 2784 } 2785 2786
2786// packages/rich-text/build-module/hook/use-anchor.mjs 2787 var import_compose3 = __toESM(require_compose(), 1); 2788 var import_element7 = __toESM(require_element(), 1); 2789 var import_dom = __toESM(require_dom(), 1); 2790 function getFormatElement(range, editableContentElement, tagName, className) { 2791 let element = range.startContainer; 2792 if (element.nodeType === element.TEXT_NODE && range.startOffset === element.length && element.nextSibling) { 2793 element = element.nextSibling; 2794 while (element.firstChild) { 2795 element = element.firstChild; 2796 } 2797 } 2798 if (element.nodeType !== element.ELEMENT_NODE) { 2799 element = element.parentElement; 2800 } 2801 if (!element) { 2802 return; 2803 } 2804 if (element === editableContentElement) { 2805 return; 2806 } 2807 if (!editableContentElement.contains(element)) { 2808 return; 2809 } 2810 const selector = tagName + (className ? "." + className : ""); 2811 while (element !== editableContentElement) { 2812 if (element.matches(selector)) { 2813 return element; 2814 } 2815 element = element.parentElement; 2816 } 2817 } 2818 function createVirtualAnchorElement(range, editableContentElement) { 2819 return { 2820 contextElement: editableContentElement, 2821 getBoundingClientRect() { 2822 if (editableContentElement.contains(range.startContainer)) { 2823 return (0, import_dom.getRectangleFromRange)(range) ?? range.getBoundingClientRect(); 2824 } 2825 return editableContentElement.getBoundingClientRect(); 2826 } 2827 }; 2828 } 2829 function getAnchor(editableContentElement, tagName, className) { 2830 if (!editableContentElement) { 2831 return; 2832 } 2833 const { ownerDocument } = editableContentElement; 2834 const { defaultView } = ownerDocument; 2835 const selection = defaultView.getSelection(); 2836 if (!selection) { 2837 return; 2838 } 2839 if (!selection.rangeCount) { 2840 return; 2841 } 2842 const range = selection.getRangeAt(0); 2843 if (!range || !range.startContainer) { 2844 return; 2845 } 2846 const formatElement = getFormatElement( 2847 range, 2848 editableContentElement, 2849 tagName, 2850 className 2851 ); 2852 if (formatElement) { 2853 return formatElement; 2854 } 2855 return createVirtualAnchorElement(range, editableContentElement); 2856 } 2857 function useAnchor({ editableContentElement, settings = {} }) { 2858 const { tagName, className, isActive } = settings; 2859 const [anchor, setAnchor] = (0, import_element7.useState)( 2860 () => getAnchor(editableContentElement, tagName, className) 2861 ); 2862 const wasActive = (0, import_compose3.usePrevious)(isActive); 2863 (0, import_element7.useLayoutEffect)(() => { 2864 if (!editableContentElement) { 2865 return; 2866 } 2867 function callback() { 2868 setAnchor( 2869 getAnchor(editableContentElement, tagName, className) 2870 ); 2871 } 2872 function attach() { 2873 ownerDocument.addEventListener("selectionchange", callback); 2874 } 2875 function detach() { 2876 ownerDocument.removeEventListener("selectionchange", callback); 2877 } 2878 const { ownerDocument } = editableContentElement; 2879 if (editableContentElement === ownerDocument.activeElement || // When a link is created, we need to attach the popover to the newly created anchor. 2880 !wasActive && isActive || // Sometimes we're _removing_ an active anchor, such as the inline color popover. 2881 // When we add the color, it switches from a virtual anchor to a `<mark>` element. 2882 // When we _remove_ the color, it switches from a `<mark>` element to a virtual anchor. 2883 wasActive && !isActive) { 2884 setAnchor( 2885 getAnchor(editableContentElement, tagName, className) 2886 ); 2887 attach(); 2888 } 2889 editableContentElement.addEventListener("focusin", attach); 2890 editableContentElement.addEventListener("focusout", detach); 2891 return () => { 2892 detach(); 2893 editableContentElement.removeEventListener("focusin", attach); 2894 editableContentElement.removeEventListener("focusout", detach); 2895 }; 2896 }, [editableContentElement, tagName, className, isActive, wasActive]); 2897 return anchor; 2898 } 2899 2900
2900// packages/rich-text/build-module/index.mjs 2901 function __experimentalRichText() { 2902 } 2903 return __toCommonJS(index_exports); 2904})();
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.