Editing: rich-text.js
/******/ (() => { // webpackBootstrap /******/ "use strict"; /******/ // The require scope /******/ var __webpack_require__ = {}; /******/ /************************************************************************/ /******/ /* webpack/runtime/compat get default export */ /******/ (() => { /******/ // getDefaultExport function for compatibility with non-harmony modules /******/ __webpack_require__.n = (module) => { /******/ var getter = module && module.__esModule ? /******/ () => (module['default']) : /******/ () => (module); /******/ __webpack_require__.d(getter, { a: getter }); /******/ return getter; /******/ }; /******/ })(); /******/ /******/ /* webpack/runtime/define property getters */ /******/ (() => { /******/ // define getter functions for harmony exports /******/ __webpack_require__.d = (exports, definition) => { /******/ for(var key in definition) { /******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { /******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); /******/ } /******/ } /******/ }; /******/ })(); /******/ /******/ /* webpack/runtime/hasOwnProperty shorthand */ /******/ (() => { /******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) /******/ })(); /******/ /******/ /* webpack/runtime/make namespace object */ /******/ (() => { /******/ // define __esModule on exports /******/ __webpack_require__.r = (exports) => { /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); /******/ } /******/ Object.defineProperty(exports, '__esModule', { value: true }); /******/ }; /******/ })(); /******/ /************************************************************************/ var __webpack_exports__ = {}; // ESM COMPAT FLAG __webpack_require__.r(__webpack_exports__); // EXPORTS __webpack_require__.d(__webpack_exports__, { RichTextData: () => (/* reexport */ RichTextData), __experimentalRichText: () => (/* reexport */ __experimentalRichText), __unstableCreateElement: () => (/* reexport */ createElement), __unstableToDom: () => (/* reexport */ toDom), __unstableUseRichText: () => (/* reexport */ useRichText), applyFormat: () => (/* reexport */ applyFormat), concat: () => (/* reexport */ concat), create: () => (/* reexport */ create), getActiveFormat: () => (/* reexport */ getActiveFormat), getActiveFormats: () => (/* reexport */ getActiveFormats), getActiveObject: () => (/* reexport */ getActiveObject), getTextContent: () => (/* reexport */ getTextContent), insert: () => (/* reexport */ insert), insertObject: () => (/* reexport */ insertObject), isCollapsed: () => (/* reexport */ isCollapsed), isEmpty: () => (/* reexport */ isEmpty), join: () => (/* reexport */ join), registerFormatType: () => (/* reexport */ registerFormatType), remove: () => (/* reexport */ remove_remove), removeFormat: () => (/* reexport */ removeFormat), replace: () => (/* reexport */ replace_replace), slice: () => (/* reexport */ slice), split: () => (/* reexport */ split), store: () => (/* reexport */ store), toHTMLString: () => (/* reexport */ toHTMLString), toggleFormat: () => (/* reexport */ toggleFormat), unregisterFormatType: () => (/* reexport */ unregisterFormatType), useAnchor: () => (/* reexport */ useAnchor), useAnchorRef: () => (/* reexport */ useAnchorRef) }); // NAMESPACE OBJECT: ./node_modules/@wordpress/rich-text/build-module/store/selectors.js var selectors_namespaceObject = {}; __webpack_require__.r(selectors_namespaceObject); __webpack_require__.d(selectors_namespaceObject, { getFormatType: () => (getFormatType), getFormatTypeForBareElement: () => (getFormatTypeForBareElement), getFormatTypeForClassName: () => (getFormatTypeForClassName), getFormatTypes: () => (getFormatTypes) }); // NAMESPACE OBJECT: ./node_modules/@wordpress/rich-text/build-module/store/actions.js var actions_namespaceObject = {}; __webpack_require__.r(actions_namespaceObject); __webpack_require__.d(actions_namespaceObject, { addFormatTypes: () => (addFormatTypes), removeFormatTypes: () => (removeFormatTypes) }); ;// external ["wp","data"] const external_wp_data_namespaceObject = window["wp"]["data"]; ;// ./node_modules/@wordpress/rich-text/build-module/store/reducer.js function formatTypes(state = {}, action) { switch (action.type) { case "ADD_FORMAT_TYPES": return { ...state, // Key format types by their name. ...action.formatTypes.reduce( (newFormatTypes, type) => ({ ...newFormatTypes, [type.name]: type }), {} ) }; case "REMOVE_FORMAT_TYPES": return Object.fromEntries( Object.entries(state).filter( ([key]) => !action.names.includes(key) ) ); } return state; } var reducer_default = (0,external_wp_data_namespaceObject.combineReducers)({ formatTypes }); ;// ./node_modules/@wordpress/rich-text/build-module/store/selectors.js const getFormatTypes = (0,external_wp_data_namespaceObject.createSelector)( (state) => Object.values(state.formatTypes), (state) => [state.formatTypes] ); function getFormatType(state, name) { return state.formatTypes[name]; } function getFormatTypeForBareElement(state, bareElementTagName) { const formatTypes = getFormatTypes(state); return formatTypes.find(({ className, tagName }) => { return className === null && bareElementTagName === tagName; }) || formatTypes.find(({ className, tagName }) => { return className === null && "*" === tagName; }); } function getFormatTypeForClassName(state, elementClassName) { return getFormatTypes(state).find(({ className }) => { if (className === null) { return false; } return ` ${elementClassName} `.indexOf(` ${className} `) >= 0; }); } ;// ./node_modules/@wordpress/rich-text/build-module/store/actions.js function addFormatTypes(formatTypes) { return { type: "ADD_FORMAT_TYPES", formatTypes: Array.isArray(formatTypes) ? formatTypes : [formatTypes] }; } function removeFormatTypes(names) { return { type: "REMOVE_FORMAT_TYPES", names: Array.isArray(names) ? names : [names] }; } ;// ./node_modules/@wordpress/rich-text/build-module/store/index.js const STORE_NAME = "core/rich-text"; const store = (0,external_wp_data_namespaceObject.createReduxStore)(STORE_NAME, { reducer: reducer_default, selectors: selectors_namespaceObject, actions: actions_namespaceObject }); (0,external_wp_data_namespaceObject.register)(store); ;// ./node_modules/@wordpress/rich-text/build-module/is-format-equal.js function isFormatEqual(format1, format2) { if (format1 === format2) { return true; } if (!format1 || !format2) { return false; } if (format1.type !== format2.type) { return false; } const attributes1 = format1.attributes; const attributes2 = format2.attributes; if (attributes1 === attributes2) { return true; } if (!attributes1 || !attributes2) { return false; } const keys1 = Object.keys(attributes1); const keys2 = Object.keys(attributes2); if (keys1.length !== keys2.length) { return false; } const length = keys1.length; for (let i = 0; i < length; i++) { const name = keys1[i]; if (attributes1[name] !== attributes2[name]) { return false; } } return true; } ;// ./node_modules/@wordpress/rich-text/build-module/normalise-formats.js function normaliseFormats(value) { const newFormats = value.formats.slice(); newFormats.forEach((formatsAtIndex, index) => { const formatsAtPreviousIndex = newFormats[index - 1]; if (formatsAtPreviousIndex) { const newFormatsAtIndex = formatsAtIndex.slice(); newFormatsAtIndex.forEach((format, formatIndex) => { const previousFormat = formatsAtPreviousIndex[formatIndex]; if (isFormatEqual(format, previousFormat)) { newFormatsAtIndex[formatIndex] = previousFormat; } }); newFormats[index] = newFormatsAtIndex; } }); return { ...value, formats: newFormats }; } ;// ./node_modules/@wordpress/rich-text/build-module/apply-format.js function replace(array, index, value) { array = array.slice(); array[index] = value; return array; } function applyFormat(value, format, startIndex = value.start, endIndex = value.end) { const { formats, activeFormats } = value; const newFormats = formats.slice(); if (startIndex === endIndex) { const startFormat = newFormats[startIndex]?.find( ({ type }) => type === format.type ); if (startFormat) { const index = newFormats[startIndex].indexOf(startFormat); while (newFormats[startIndex] && newFormats[startIndex][index] === startFormat) { newFormats[startIndex] = replace( newFormats[startIndex], index, format ); startIndex--; } endIndex++; while (newFormats[endIndex] && newFormats[endIndex][index] === startFormat) { newFormats[endIndex] = replace( newFormats[endIndex], index, format ); endIndex++; } } } else { let position = Infinity; for (let index = startIndex; index < endIndex; index++) { if (newFormats[index]) { newFormats[index] = newFormats[index].filter( ({ type }) => type !== format.type ); const length = newFormats[index].length; if (length < position) { position = length; } } else { newFormats[index] = []; position = 0; } } for (let index = startIndex; index < endIndex; index++) { newFormats[index].splice(position, 0, format); } } return normaliseFormats({ ...value, formats: newFormats, // Always revise active formats. This serves as a placeholder for new // inputs with the format so new input appears with the format applied, // and ensures a format of the same type uses the latest values. activeFormats: [ ...activeFormats?.filter( ({ type }) => type !== format.type ) || [], format ] }); } ;// ./node_modules/@wordpress/rich-text/build-module/create-element.js function createElement({ implementation }, html) { if (!createElement.body) { createElement.body = implementation.createHTMLDocument("").body; } createElement.body.innerHTML = html; return createElement.body; } ;// ./node_modules/@wordpress/rich-text/build-module/special-characters.js const OBJECT_REPLACEMENT_CHARACTER = "\uFFFC"; const ZWNBSP = "\uFEFF"; ;// external ["wp","escapeHtml"] const external_wp_escapeHtml_namespaceObject = window["wp"]["escapeHtml"]; ;// ./node_modules/@wordpress/rich-text/build-module/get-active-formats.js function getActiveFormats(value, EMPTY_ACTIVE_FORMATS = []) { const { formats, start, end, activeFormats } = value; if (start === void 0) { return EMPTY_ACTIVE_FORMATS; } if (start === end) { if (activeFormats) { return activeFormats; } const formatsBefore = formats[start - 1] || EMPTY_ACTIVE_FORMATS; const formatsAfter = formats[start] || EMPTY_ACTIVE_FORMATS; if (formatsBefore.length < formatsAfter.length) { return formatsBefore; } return formatsAfter; } if (!formats[start]) { return EMPTY_ACTIVE_FORMATS; } const selectedFormats = formats.slice(start, end); const _activeFormats = [...selectedFormats[0]]; let i = selectedFormats.length; while (i--) { const formatsAtIndex = selectedFormats[i]; if (!formatsAtIndex) { return EMPTY_ACTIVE_FORMATS; } let ii = _activeFormats.length; while (ii--) { const format = _activeFormats[ii]; if (!formatsAtIndex.find( (_format) => isFormatEqual(format, _format) )) { _activeFormats.splice(ii, 1); } } if (_activeFormats.length === 0) { return EMPTY_ACTIVE_FORMATS; } } return _activeFormats || EMPTY_ACTIVE_FORMATS; } ;// ./node_modules/@wordpress/rich-text/build-module/get-format-type.js function get_format_type_getFormatType(name) { return (0,external_wp_data_namespaceObject.select)(store).getFormatType(name); } ;// ./node_modules/@wordpress/rich-text/build-module/to-tree.js function restoreOnAttributes(attributes, isEditableTree) { if (isEditableTree) { return attributes; } const newAttributes = {}; for (const key in attributes) { let newKey = key; if (key.startsWith("data-disable-rich-text-")) { newKey = key.slice("data-disable-rich-text-".length); } newAttributes[newKey] = attributes[key]; } return newAttributes; } function fromFormat({ type, tagName, attributes, unregisteredAttributes, object, boundaryClass, isEditableTree }) { const formatType = get_format_type_getFormatType(type); let elementAttributes = {}; if (boundaryClass && isEditableTree) { elementAttributes["data-rich-text-format-boundary"] = "true"; } if (!formatType) { if (attributes) { elementAttributes = { ...attributes, ...elementAttributes }; } return { type, attributes: restoreOnAttributes( elementAttributes, isEditableTree ), object }; } elementAttributes = { ...unregisteredAttributes, ...elementAttributes }; for (const name in attributes) { const key = formatType.attributes ? formatType.attributes[name] : false; if (key) { elementAttributes[key] = attributes[name]; } else { elementAttributes[name] = attributes[name]; } } if (formatType.className) { if (elementAttributes.class) { elementAttributes.class = `${formatType.className} ${elementAttributes.class}`; } else { elementAttributes.class = formatType.className; } } return { type: tagName || formatType.tagName, object: formatType.object, attributes: restoreOnAttributes(elementAttributes, isEditableTree) }; } function isEqualUntil(a, b, index) { do { if (a[index] !== b[index]) { return false; } } while (index--); return true; } function toTree({ value, preserveWhiteSpace, createEmpty, append, getLastChild, getParent, isText, getText, remove, appendText, onStartIndex, onEndIndex, isEditableTree, placeholder }) { const { formats, replacements, text, start, end } = value; const formatsLength = formats.length + 1; const tree = createEmpty(); const activeFormats = getActiveFormats(value); const deepestActiveFormat = activeFormats[activeFormats.length - 1]; let lastCharacterFormats; let lastCharacter; append(tree, ""); for (let i = 0; i < formatsLength; i++) { const character = text.charAt(i); const shouldInsertPadding = isEditableTree && // Pad the line if the line is empty. (!lastCharacter || // Pad the line if the previous character is a line break, otherwise // the line break won't be visible. lastCharacter === "\n"); const characterFormats = formats[i]; let pointer = getLastChild(tree); if (characterFormats) { characterFormats.forEach((format, formatIndex) => { if (pointer && lastCharacterFormats && // Reuse the last element if all formats remain the same. isEqualUntil( characterFormats, lastCharacterFormats, formatIndex )) { pointer = getLastChild(pointer); return; } const { type, tagName, attributes, unregisteredAttributes } = format; const boundaryClass = isEditableTree && format === deepestActiveFormat; const parent = getParent(pointer); const newNode = append( parent, fromFormat({ type, tagName, attributes, unregisteredAttributes, boundaryClass, isEditableTree }) ); if (isText(pointer) && getText(pointer).length === 0) { remove(pointer); } pointer = append(newNode, ""); }); } if (i === 0) { if (onStartIndex && start === 0) { onStartIndex(tree, pointer); } if (onEndIndex && end === 0) { onEndIndex(tree, pointer); } } if (character === OBJECT_REPLACEMENT_CHARACTER) { const replacement = replacements[i]; if (!replacement) { continue; } const { type, attributes, innerHTML } = replacement; const formatType = get_format_type_getFormatType(type); if (isEditableTree && type === "#comment") { pointer = append(getParent(pointer), { type: "span", attributes: { contenteditable: "false", "data-rich-text-comment": attributes["data-rich-text-comment"] } }); append( append(pointer, { type: "span" }), attributes["data-rich-text-comment"].trim() ); } else if (!isEditableTree && type === "script") { pointer = append( getParent(pointer), fromFormat({ type: "script", isEditableTree }) ); append(pointer, { html: decodeURIComponent( attributes["data-rich-text-script"] ) }); } else if (formatType?.contentEditable === false) { if (innerHTML || isEditableTree) { pointer = getParent(pointer); if (isEditableTree) { const attrs = { contenteditable: "false", "data-rich-text-bogus": true }; if (start === i && end === i + 1) { attrs["data-rich-text-format-boundary"] = true; } pointer = append(pointer, { type: "span", attributes: attrs }); if (isEditableTree && i + 1 === text.length) { append(getParent(pointer), ZWNBSP); } } pointer = append( pointer, fromFormat({ ...replacement, isEditableTree }) ); if (innerHTML) { append(pointer, { html: innerHTML }); } } } else { pointer = append( getParent(pointer), fromFormat({ ...replacement, object: true, isEditableTree }) ); } pointer = append(getParent(pointer), ""); } else if (!preserveWhiteSpace && character === "\n") { pointer = append(getParent(pointer), { type: "br", attributes: isEditableTree ? { "data-rich-text-line-break": "true" } : void 0, object: true }); pointer = append(getParent(pointer), ""); } else if (!isText(pointer)) { pointer = append(getParent(pointer), character); } else { appendText(pointer, character); } if (onStartIndex && start === i + 1) { onStartIndex(tree, pointer); } if (onEndIndex && end === i + 1) { onEndIndex(tree, pointer); } if (shouldInsertPadding && i === text.length) { append(getParent(pointer), ZWNBSP); if (placeholder && text.length === 0) { append(getParent(pointer), { type: "span", attributes: { "data-rich-text-placeholder": placeholder, // Necessary to prevent the placeholder from catching // selection and being editable. style: "pointer-events:none;user-select:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;" } }); } } lastCharacterFormats = characterFormats; lastCharacter = character; } return tree; } ;// ./node_modules/@wordpress/rich-text/build-module/to-html-string.js function toHTMLString({ value, preserveWhiteSpace }) { const tree = toTree({ value, preserveWhiteSpace, createEmpty, append, getLastChild, getParent, isText, getText, remove, appendText }); return createChildrenHTML(tree.children); } function createEmpty() { return {}; } function getLastChild({ children }) { return children && children[children.length - 1]; } function append(parent, object) { if (typeof object === "string") { object = { text: object }; } object.parent = parent; parent.children = parent.children || []; parent.children.push(object); return object; } function appendText(object, text) { object.text += text; } function getParent({ parent }) { return parent; } function isText({ text }) { return typeof text === "string"; } function getText({ text }) { return text; } function remove(object) { const index = object.parent.children.indexOf(object); if (index !== -1) { object.parent.children.splice(index, 1); } return object; } function createElementHTML({ type, attributes, object, children }) { if (type === "#comment") { return `<!--${attributes["data-rich-text-comment"]}-->`; } let attributeString = ""; for (const key in attributes) { if (!(0,external_wp_escapeHtml_namespaceObject.isValidAttributeName)(key)) { continue; } attributeString += ` ${key}="${(0,external_wp_escapeHtml_namespaceObject.escapeAttribute)( attributes[key] )}"`; } if (object) { return `<${type}${attributeString}>`; } return `<${type}${attributeString}>${createChildrenHTML( children )}</${type}>`; } function createChildrenHTML(children = []) { return children.map((child) => { if (child.html !== void 0) { return child.html; } return child.text === void 0 ? createElementHTML(child) : (0,external_wp_escapeHtml_namespaceObject.escapeEditableHTML)(child.text); }).join(""); } ;// ./node_modules/@wordpress/rich-text/build-module/get-text-content.js function getTextContent({ text }) { return text.replace(OBJECT_REPLACEMENT_CHARACTER, ""); } ;// ./node_modules/@wordpress/rich-text/build-module/create.js function createEmptyValue() { return { formats: [], replacements: [], text: "" }; } function toFormat({ tagName, attributes }) { let formatType; if (attributes && attributes.class) { formatType = (0,external_wp_data_namespaceObject.select)(store).getFormatTypeForClassName( attributes.class ); if (formatType) { attributes.class = ` ${attributes.class} `.replace(` ${formatType.className} `, " ").trim(); if (!attributes.class) { delete attributes.class; } } } if (!formatType) { formatType = (0,external_wp_data_namespaceObject.select)(store).getFormatTypeForBareElement(tagName); } if (!formatType) { return attributes ? { type: tagName, attributes } : { type: tagName }; } if (formatType.__experimentalCreatePrepareEditableTree && !formatType.__experimentalCreateOnChangeEditableValue) { return null; } if (!attributes) { return { formatType, type: formatType.name, tagName }; } const registeredAttributes = {}; const unregisteredAttributes = {}; const _attributes = { ...attributes }; for (const key in formatType.attributes) { const name = formatType.attributes[key]; registeredAttributes[key] = _attributes[name]; delete _attributes[name]; if (typeof registeredAttributes[key] === "undefined") { delete registeredAttributes[key]; } } for (const name in _attributes) { unregisteredAttributes[name] = attributes[name]; } if (formatType.contentEditable === false) { delete unregisteredAttributes.contenteditable; } return { formatType, type: formatType.name, tagName, attributes: registeredAttributes, unregisteredAttributes }; } class RichTextData { #value; static empty() { return new RichTextData(); } static fromPlainText(text) { return new RichTextData(create({ text })); } static fromHTMLString(html) { return new RichTextData(create({ html })); } /** * Create a RichTextData instance from an HTML element. * * @param {HTMLElement} htmlElement The HTML element to create the instance from. * @param {{preserveWhiteSpace?: boolean}} options Options. * @return {RichTextData} The RichTextData instance. */ static fromHTMLElement(htmlElement, options = {}) { const { preserveWhiteSpace = false } = options; const element = preserveWhiteSpace ? htmlElement : collapseWhiteSpace(htmlElement); const richTextData = new RichTextData(create({ element })); Object.defineProperty(richTextData, "originalHTML", { value: htmlElement.innerHTML }); return richTextData; } constructor(init = createEmptyValue()) { this.#value = init; } toPlainText() { return getTextContent(this.#value); } // We could expose `toHTMLElement` at some point as well, but we'd only use // it internally. /** * Convert the rich text value to an HTML string. * * @param {{preserveWhiteSpace?: boolean}} options Options. * @return {string} The HTML string. */ toHTMLString({ preserveWhiteSpace } = {}) { return this.originalHTML || toHTMLString({ value: this.#value, preserveWhiteSpace }); } valueOf() { return this.toHTMLString(); } toString() { return this.toHTMLString(); } toJSON() { return this.toHTMLString(); } get length() { return this.text.length; } get formats() { return this.#value.formats; } get replacements() { return this.#value.replacements; } get text() { return this.#value.text; } } for (const name of Object.getOwnPropertyNames(String.prototype)) { if (RichTextData.prototype.hasOwnProperty(name)) { continue; } Object.defineProperty(RichTextData.prototype, name, { value(...args) { return this.toHTMLString()[name](...args); } }); } function create({ element, text, html, range, __unstableIsEditableTree: isEditableTree } = {}) { if (html instanceof RichTextData) { return { text: html.text, formats: html.formats, replacements: html.replacements }; } if (typeof text === "string" && text.length > 0) { return { formats: Array(text.length), replacements: Array(text.length), text }; } if (typeof html === "string" && html.length > 0) { element = createElement(document, html); } if (typeof element !== "object") { return createEmptyValue(); } return createFromElement({ element, range, isEditableTree }); } function accumulateSelection(accumulator, node, range, value) { if (!range) { return; } const { parentNode } = node; const { startContainer, startOffset, endContainer, endOffset } = range; const currentLength = accumulator.text.length; if (value.start !== void 0) { accumulator.start = currentLength + value.start; } else if (node === startContainer && node.nodeType === node.TEXT_NODE) { accumulator.start = currentLength + startOffset; } else if (parentNode === startContainer && node === startContainer.childNodes[startOffset]) { accumulator.start = currentLength; } else if (parentNode === startContainer && node === startContainer.childNodes[startOffset - 1]) { accumulator.start = currentLength + value.text.length; } else if (node === startContainer) { accumulator.start = currentLength; } if (value.end !== void 0) { accumulator.end = currentLength + value.end; } else if (node === endContainer && node.nodeType === node.TEXT_NODE) { accumulator.end = currentLength + endOffset; } else if (parentNode === endContainer && node === endContainer.childNodes[endOffset - 1]) { accumulator.end = currentLength + value.text.length; } else if (parentNode === endContainer && node === endContainer.childNodes[endOffset]) { accumulator.end = currentLength; } else if (node === endContainer) { accumulator.end = currentLength + endOffset; } } function filterRange(node, range, filter) { if (!range) { return; } const { startContainer, endContainer } = range; let { startOffset, endOffset } = range; if (node === startContainer) { startOffset = filter(node.nodeValue.slice(0, startOffset)).length; } if (node === endContainer) { endOffset = filter(node.nodeValue.slice(0, endOffset)).length; } return { startContainer, startOffset, endContainer, endOffset }; } function collapseWhiteSpace(element, isRoot = true) { const clone = element.cloneNode(true); clone.normalize(); Array.from(clone.childNodes).forEach((node, i, nodes) => { if (node.nodeType === node.TEXT_NODE) { let newNodeValue = node.nodeValue; if (/[\n\t\r\f]/.test(newNodeValue)) { newNodeValue = newNodeValue.replace(/[\n\t\r\f]+/g, " "); } if (newNodeValue.indexOf(" ") !== -1) { newNodeValue = newNodeValue.replace(/ {2,}/g, " "); } if (i === 0 && newNodeValue.startsWith(" ")) { newNodeValue = newNodeValue.slice(1); } else if (isRoot && i === nodes.length - 1 && newNodeValue.endsWith(" ")) { newNodeValue = newNodeValue.slice(0, -1); } node.nodeValue = newNodeValue; } else if (node.nodeType === node.ELEMENT_NODE) { node.replaceWith(collapseWhiteSpace(node, false)); } }); return clone; } const CARRIAGE_RETURN = "\r"; function removeReservedCharacters(string) { return string.replace( new RegExp( `[${ZWNBSP}${OBJECT_REPLACEMENT_CHARACTER}${CARRIAGE_RETURN}]`, "gu" ), "" ); } function createFromElement({ element, range, isEditableTree }) { const accumulator = createEmptyValue(); if (!element) { return accumulator; } if (!element.hasChildNodes()) { accumulateSelection(accumulator, element, range, createEmptyValue()); return accumulator; } const length = element.childNodes.length; for (let index = 0; index < length; index++) { const node = element.childNodes[index]; const tagName = node.nodeName.toLowerCase(); if (node.nodeType === node.TEXT_NODE) { const text = removeReservedCharacters(node.nodeValue); range = filterRange(node, range, removeReservedCharacters); accumulateSelection(accumulator, node, range, { text }); accumulator.formats.length += text.length; accumulator.replacements.length += text.length; accumulator.text += text; continue; } if (node.nodeType === node.COMMENT_NODE || node.nodeType === node.ELEMENT_NODE && node.tagName === "SPAN" && node.hasAttribute("data-rich-text-comment")) { const value2 = { formats: [,], replacements: [ { type: "#comment", attributes: { "data-rich-text-comment": node.nodeType === node.COMMENT_NODE ? node.nodeValue : node.getAttribute( "data-rich-text-comment" ) } } ], text: OBJECT_REPLACEMENT_CHARACTER }; accumulateSelection(accumulator, node, range, value2); mergePair(accumulator, value2); continue; } if (node.nodeType !== node.ELEMENT_NODE) { continue; } if (isEditableTree && // Ignore any line breaks that are not inserted by us. tagName === "br" && !node.getAttribute("data-rich-text-line-break")) { accumulateSelection(accumulator, node, range, createEmptyValue()); continue; } if (tagName === "script") { const value2 = { formats: [,], replacements: [ { type: tagName, attributes: { "data-rich-text-script": node.getAttribute("data-rich-text-script") || encodeURIComponent(node.innerHTML) } } ], text: OBJECT_REPLACEMENT_CHARACTER }; accumulateSelection(accumulator, node, range, value2); mergePair(accumulator, value2); continue; } if (tagName === "br") { accumulateSelection(accumulator, node, range, createEmptyValue()); mergePair(accumulator, create({ text: "\n" })); continue; } const format = toFormat({ tagName, attributes: getAttributes({ element: node }) }); if (format?.formatType?.contentEditable === false) { delete format.formatType; accumulateSelection(accumulator, node, range, createEmptyValue()); mergePair(accumulator, { formats: [,], replacements: [ { ...format, innerHTML: node.innerHTML } ], text: OBJECT_REPLACEMENT_CHARACTER }); continue; } if (format) { delete format.formatType; } const value = createFromElement({ element: node, range, isEditableTree }); accumulateSelection(accumulator, node, range, value); if (!format || node.getAttribute("data-rich-text-placeholder") || node.getAttribute("data-rich-text-bogus")) { mergePair(accumulator, value); } else if (value.text.length === 0) { if (format.attributes) { mergePair(accumulator, { formats: [,], replacements: [format], text: OBJECT_REPLACEMENT_CHARACTER }); } } else { let mergeFormats2 = function(formats) { if (mergeFormats2.formats === formats) { return mergeFormats2.newFormats; } const newFormats = formats ? [format, ...formats] : [format]; mergeFormats2.formats = formats; mergeFormats2.newFormats = newFormats; return newFormats; }; var mergeFormats = mergeFormats2; mergeFormats2.newFormats = [format]; mergePair(accumulator, { ...value, formats: Array.from(value.formats, mergeFormats2) }); } } return accumulator; } function getAttributes({ element }) { if (!element.hasAttributes()) { return; } const length = element.attributes.length; let accumulator; for (let i = 0; i < length; i++) { const { name, value } = element.attributes[i]; if (name.indexOf("data-rich-text-") === 0) { continue; } const safeName = /^on/i.test(name) ? "data-disable-rich-text-" + name : name; accumulator = accumulator || {}; accumulator[safeName] = value; } return accumulator; } ;// ./node_modules/@wordpress/rich-text/build-module/concat.js function mergePair(a, b) { a.formats = a.formats.concat(b.formats); a.replacements = a.replacements.concat(b.replacements); a.text += b.text; return a; } function concat(...values) { return normaliseFormats(values.reduce(mergePair, create())); } ;// ./node_modules/@wordpress/rich-text/build-module/get-active-format.js function getActiveFormat(value, formatType) { return getActiveFormats(value).find( ({ type }) => type === formatType ); } ;// ./node_modules/@wordpress/rich-text/build-module/get-active-object.js function getActiveObject({ start, end, replacements, text }) { if (start + 1 !== end || text[start] !== OBJECT_REPLACEMENT_CHARACTER) { return; } return replacements[start]; } ;// ./node_modules/@wordpress/rich-text/build-module/is-collapsed.js function isCollapsed({ start, end }) { if (start === void 0 || end === void 0) { return; } return start === end; } ;// ./node_modules/@wordpress/rich-text/build-module/is-empty.js function isEmpty({ text }) { return text.length === 0; } ;// ./node_modules/@wordpress/rich-text/build-module/join.js function join(values, separator = "") { if (typeof separator === "string") { separator = create({ text: separator }); } return normaliseFormats( values.reduce((accumulator, { formats, replacements, text }) => ({ formats: accumulator.formats.concat(separator.formats, formats), replacements: accumulator.replacements.concat( separator.replacements, replacements ), text: accumulator.text + separator.text + text })) ); } ;// ./node_modules/@wordpress/rich-text/build-module/register-format-type.js function registerFormatType(name, settings) { settings = { name, ...settings }; if (typeof settings.name !== "string") { window.console.error("Format names must be strings."); return; } if (!/^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/.test(settings.name)) { window.console.error( "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" ); return; } if ((0,external_wp_data_namespaceObject.select)(store).getFormatType(settings.name)) { window.console.error( 'Format "' + settings.name + '" is already registered.' ); return; } if (typeof settings.tagName !== "string" || settings.tagName === "") { window.console.error("Format tag names must be a string."); return; } if ((typeof settings.className !== "string" || settings.className === "") && settings.className !== null) { window.console.error( "Format class names must be a string, or null to handle bare elements." ); return; } if (!/^[_a-zA-Z]+[a-zA-Z0-9_-]*$/.test(settings.className)) { window.console.error( "A class name must begin with a letter, followed by any number of hyphens, underscores, letters, or numbers." ); return; } if (settings.className === null) { const formatTypeForBareElement = (0,external_wp_data_namespaceObject.select)( store ).getFormatTypeForBareElement(settings.tagName); if (formatTypeForBareElement && formatTypeForBareElement.name !== "core/unknown") { window.console.error( `Format "${formatTypeForBareElement.name}" is already registered to handle bare tag name "${settings.tagName}".` ); return; } } else { const formatTypeForClassName = (0,external_wp_data_namespaceObject.select)( store ).getFormatTypeForClassName(settings.className); if (formatTypeForClassName) { window.console.error( `Format "${formatTypeForClassName.name}" is already registered to handle class name "${settings.className}".` ); return; } } if (!("title" in settings) || settings.title === "") { window.console.error( 'The format "' + settings.name + '" must have a title.' ); return; } if ("keywords" in settings && settings.keywords.length > 3) { window.console.error( 'The format "' + settings.name + '" can have a maximum of 3 keywords.' ); return; } if (typeof settings.title !== "string") { window.console.error("Format titles must be strings."); return; } (0,external_wp_data_namespaceObject.dispatch)(store).addFormatTypes(settings); return settings; } ;// ./node_modules/@wordpress/rich-text/build-module/remove-format.js function removeFormat(value, formatType, startIndex = value.start, endIndex = value.end) { const { formats, activeFormats } = value; const newFormats = formats.slice(); if (startIndex === endIndex) { const format = newFormats[startIndex]?.find( ({ type }) => type === formatType ); if (format) { while (newFormats[startIndex]?.find( (newFormat) => newFormat === format )) { filterFormats(newFormats, startIndex, formatType); startIndex--; } endIndex++; while (newFormats[endIndex]?.find( (newFormat) => newFormat === format )) { filterFormats(newFormats, endIndex, formatType); endIndex++; } } } else { for (let i = startIndex; i < endIndex; i++) { if (newFormats[i]) { filterFormats(newFormats, i, formatType); } } } return normaliseFormats({ ...value, formats: newFormats, activeFormats: activeFormats?.filter(({ type }) => type !== formatType) || [] }); } function filterFormats(formats, index, formatType) { const newFormats = formats[index].filter( ({ type }) => type !== formatType ); if (newFormats.length) { formats[index] = newFormats; } else { delete formats[index]; } } ;// ./node_modules/@wordpress/rich-text/build-module/insert.js function insert(value, valueToInsert, startIndex = value.start, endIndex = value.end) { const { formats, replacements, text } = value; if (typeof valueToInsert === "string") { valueToInsert = create({ text: valueToInsert }); } const index = startIndex + valueToInsert.text.length; return normaliseFormats({ formats: formats.slice(0, startIndex).concat(valueToInsert.formats, formats.slice(endIndex)), replacements: replacements.slice(0, startIndex).concat( valueToInsert.replacements, replacements.slice(endIndex) ), text: text.slice(0, startIndex) + valueToInsert.text + text.slice(endIndex), start: index, end: index }); } ;// ./node_modules/@wordpress/rich-text/build-module/remove.js function remove_remove(value, startIndex, endIndex) { return insert(value, create(), startIndex, endIndex); } ;// ./node_modules/@wordpress/rich-text/build-module/replace.js function replace_replace({ formats, replacements, text, start, end }, pattern, replacement) { text = text.replace(pattern, (match, ...rest) => { const offset = rest[rest.length - 2]; let newText = replacement; let newFormats; let newReplacements; if (typeof newText === "function") { newText = replacement(match, ...rest); } if (typeof newText === "object") { newFormats = newText.formats; newReplacements = newText.replacements; newText = newText.text; } else { newFormats = Array(newText.length); newReplacements = Array(newText.length); if (formats[offset]) { newFormats = newFormats.fill(formats[offset]); } } formats = formats.slice(0, offset).concat(newFormats, formats.slice(offset + match.length)); replacements = replacements.slice(0, offset).concat( newReplacements, replacements.slice(offset + match.length) ); if (start) { start = end = offset + newText.length; } return newText; }); return normaliseFormats({ formats, replacements, text, start, end }); } ;// ./node_modules/@wordpress/rich-text/build-module/insert-object.js function insertObject(value, formatToInsert, startIndex, endIndex) { const valueToInsert = { formats: [,], replacements: [formatToInsert], text: OBJECT_REPLACEMENT_CHARACTER }; return insert(value, valueToInsert, startIndex, endIndex); } ;// ./node_modules/@wordpress/rich-text/build-module/slice.js function slice(value, startIndex = value.start, endIndex = value.end) { const { formats, replacements, text } = value; if (startIndex === void 0 || endIndex === void 0) { return { ...value }; } return { formats: formats.slice(startIndex, endIndex), replacements: replacements.slice(startIndex, endIndex), text: text.slice(startIndex, endIndex) }; } ;// ./node_modules/@wordpress/rich-text/build-module/split.js function split({ formats, replacements, text, start, end }, string) { if (typeof string !== "string") { return splitAtSelection(...arguments); } let nextStart = 0; return text.split(string).map((substring) => { const startIndex = nextStart; const value = { formats: formats.slice(startIndex, startIndex + substring.length), replacements: replacements.slice( startIndex, startIndex + substring.length ), text: substring }; nextStart += string.length + substring.length; if (start !== void 0 && end !== void 0) { if (start >= startIndex && start < nextStart) { value.start = start - startIndex; } else if (start < startIndex && end > startIndex) { value.start = 0; } if (end >= startIndex && end < nextStart) { value.end = end - startIndex; } else if (start < nextStart && end > nextStart) { value.end = substring.length; } } return value; }); } function splitAtSelection({ formats, replacements, text, start, end }, startIndex = start, endIndex = end) { if (start === void 0 || end === void 0) { return; } const before = { formats: formats.slice(0, startIndex), replacements: replacements.slice(0, startIndex), text: text.slice(0, startIndex) }; const after = { formats: formats.slice(endIndex), replacements: replacements.slice(endIndex), text: text.slice(endIndex), start: 0, end: 0 }; return [before, after]; } ;// ./node_modules/@wordpress/rich-text/build-module/is-range-equal.js function isRangeEqual(a, b) { return a === b || a && b && a.startContainer === b.startContainer && a.startOffset === b.startOffset && a.endContainer === b.endContainer && a.endOffset === b.endOffset; } ;// ./node_modules/@wordpress/rich-text/build-module/to-dom.js const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML"; function createPathToNode(node, rootNode, path) { const parentNode = node.parentNode; let i = 0; while (node = node.previousSibling) { i++; } path = [i, ...path]; if (parentNode !== rootNode) { path = createPathToNode(parentNode, rootNode, path); } return path; } function getNodeByPath(node, path) { path = [...path]; while (node && path.length > 1) { node = node.childNodes[path.shift()]; } return { node, offset: path[0] }; } function to_dom_append(element, child) { if (child.html !== void 0) { return element.innerHTML += child.html; } if (typeof child === "string") { child = element.ownerDocument.createTextNode(child); } const { type, attributes } = child; if (type) { if (type === "#comment") { child = element.ownerDocument.createComment( attributes["data-rich-text-comment"] ); } else { const parentNamespace = element.namespaceURI; if (type === "math") { child = element.ownerDocument.createElementNS( MATHML_NAMESPACE, type ); } else if (parentNamespace === MATHML_NAMESPACE) { if (element.tagName === "MTEXT") { child = element.ownerDocument.createElement(type); } else { child = element.ownerDocument.createElementNS( MATHML_NAMESPACE, type ); } } else { child = element.ownerDocument.createElement(type); } for (const key in attributes) { child.setAttribute(key, attributes[key]); } } } return element.appendChild(child); } function to_dom_appendText(node, text) { node.appendData(text); } function to_dom_getLastChild({ lastChild }) { return lastChild; } function to_dom_getParent({ parentNode }) { return parentNode; } function to_dom_isText(node) { return node.nodeType === node.TEXT_NODE; } function to_dom_getText({ nodeValue }) { return nodeValue; } function to_dom_remove(node) { return node.parentNode.removeChild(node); } function toDom({ value, prepareEditableTree, isEditableTree = true, placeholder, doc = document }) { let startPath = []; let endPath = []; if (prepareEditableTree) { value = { ...value, formats: prepareEditableTree(value) }; } const createEmpty = () => createElement(doc, ""); const tree = toTree({ value, createEmpty, append: to_dom_append, getLastChild: to_dom_getLastChild, getParent: to_dom_getParent, isText: to_dom_isText, getText: to_dom_getText, remove: to_dom_remove, appendText: to_dom_appendText, onStartIndex(body, pointer) { startPath = createPathToNode(pointer, body, [ pointer.nodeValue.length ]); }, onEndIndex(body, pointer) { endPath = createPathToNode(pointer, body, [ pointer.nodeValue.length ]); }, isEditableTree, placeholder }); return { body: tree, selection: { startPath, endPath } }; } function apply({ value, current, prepareEditableTree, __unstableDomOnly, placeholder }) { const { body, selection } = toDom({ value, prepareEditableTree, placeholder, doc: current.ownerDocument }); applyValue(body, current); if (value.start !== void 0 && !__unstableDomOnly) { applySelection(selection, current); } } function applyValue(future, current) { let i = 0; let futureChild; while (futureChild = future.firstChild) { const currentChild = current.childNodes[i]; if (!currentChild) { current.appendChild(futureChild); } else if (!currentChild.isEqualNode(futureChild)) { if (currentChild.nodeName !== futureChild.nodeName || currentChild.nodeType === currentChild.TEXT_NODE && currentChild.data !== futureChild.data) { current.replaceChild(futureChild, currentChild); } else { const currentAttributes = currentChild.attributes; const futureAttributes = futureChild.attributes; if (currentAttributes) { let ii = currentAttributes.length; while (ii--) { const { name } = currentAttributes[ii]; if (!futureChild.getAttribute(name)) { currentChild.removeAttribute(name); } } } if (futureAttributes) { for (let ii = 0; ii < futureAttributes.length; ii++) { const { name, value } = futureAttributes[ii]; if (currentChild.getAttribute(name) !== value) { currentChild.setAttribute(name, value); } } } applyValue(futureChild, currentChild); future.removeChild(futureChild); } } else { future.removeChild(futureChild); } i++; } while (current.childNodes[i]) { current.removeChild(current.childNodes[i]); } } function applySelection({ startPath, endPath }, current) { const { node: startContainer, offset: startOffset } = getNodeByPath( current, startPath ); const { node: endContainer, offset: endOffset } = getNodeByPath( current, endPath ); const { ownerDocument } = current; const { defaultView } = ownerDocument; const selection = defaultView.getSelection(); const range = ownerDocument.createRange(); range.setStart(startContainer, startOffset); range.setEnd(endContainer, endOffset); const { activeElement } = ownerDocument; if (selection.rangeCount > 0) { if (isRangeEqual(range, selection.getRangeAt(0))) { return; } selection.removeAllRanges(); } selection.addRange(range); if (activeElement !== ownerDocument.activeElement) { if (activeElement instanceof defaultView.HTMLElement) { activeElement.focus(); } } } ;// external ["wp","a11y"] const external_wp_a11y_namespaceObject = window["wp"]["a11y"]; ;// external ["wp","i18n"] const external_wp_i18n_namespaceObject = window["wp"]["i18n"]; ;// ./node_modules/@wordpress/rich-text/build-module/toggle-format.js function toggleFormat(value, format) { if (getActiveFormat(value, format.type)) { if (format.title) { (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)("%s removed."), format.title), "assertive"); } return removeFormat(value, format.type); } if (format.title) { (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)("%s applied."), format.title), "assertive"); } return applyFormat(value, format); } ;// ./node_modules/@wordpress/rich-text/build-module/unregister-format-type.js function unregisterFormatType(name) { const oldFormat = (0,external_wp_data_namespaceObject.select)(store).getFormatType(name); if (!oldFormat) { window.console.error(`Format ${name} is not registered.`); return; } (0,external_wp_data_namespaceObject.dispatch)(store).removeFormatTypes(name); return oldFormat; } ;// external ["wp","element"] const external_wp_element_namespaceObject = window["wp"]["element"]; ;// external ["wp","deprecated"] const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"]; var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject); ;// ./node_modules/@wordpress/rich-text/build-module/component/use-anchor-ref.js function useAnchorRef({ ref, value, settings = {} }) { external_wp_deprecated_default()("`useAnchorRef` hook", { since: "6.1", alternative: "`useAnchor` hook" }); const { tagName, className, name } = settings; const activeFormat = name ? getActiveFormat(value, name) : void 0; return (0,external_wp_element_namespaceObject.useMemo)(() => { if (!ref.current) { return; } const { ownerDocument: { defaultView } } = ref.current; const selection = defaultView.getSelection(); if (!selection.rangeCount) { return; } const range = selection.getRangeAt(0); if (!activeFormat) { return range; } let element = range.startContainer; element = element.nextElementSibling || element; while (element.nodeType !== element.ELEMENT_NODE) { element = element.parentNode; } return element.closest( tagName + (className ? "." + className : "") ); }, [activeFormat, value.start, value.end, tagName, className]); } ;// external ["wp","compose"] const external_wp_compose_namespaceObject = window["wp"]["compose"]; ;// ./node_modules/@wordpress/rich-text/build-module/component/use-anchor.js function getFormatElement(range, editableContentElement, tagName, className) { let element = range.startContainer; if (element.nodeType === element.TEXT_NODE && range.startOffset === element.length && element.nextSibling) { element = element.nextSibling; while (element.firstChild) { element = element.firstChild; } } if (element.nodeType !== element.ELEMENT_NODE) { element = element.parentElement; } if (!element) { return; } if (element === editableContentElement) { return; } if (!editableContentElement.contains(element)) { return; } const selector = tagName + (className ? "." + className : ""); while (element !== editableContentElement) { if (element.matches(selector)) { return element; } element = element.parentElement; } } function createVirtualAnchorElement(range, editableContentElement) { return { contextElement: editableContentElement, getBoundingClientRect() { return editableContentElement.contains(range.startContainer) ? range.getBoundingClientRect() : editableContentElement.getBoundingClientRect(); } }; } function getAnchor(editableContentElement, tagName, className) { if (!editableContentElement) { return; } const { ownerDocument } = editableContentElement; const { defaultView } = ownerDocument; const selection = defaultView.getSelection(); if (!selection) { return; } if (!selection.rangeCount) { return; } const range = selection.getRangeAt(0); if (!range || !range.startContainer) { return; } const formatElement = getFormatElement( range, editableContentElement, tagName, className ); if (formatElement) { return formatElement; } return createVirtualAnchorElement(range, editableContentElement); } function useAnchor({ editableContentElement, settings = {} }) { const { tagName, className, isActive } = settings; const [anchor, setAnchor] = (0,external_wp_element_namespaceObject.useState)( () => getAnchor(editableContentElement, tagName, className) ); const wasActive = (0,external_wp_compose_namespaceObject.usePrevious)(isActive); (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { if (!editableContentElement) { return; } function callback() { setAnchor( getAnchor(editableContentElement, tagName, className) ); } function attach() { ownerDocument.addEventListener("selectionchange", callback); } function detach() { ownerDocument.removeEventListener("selectionchange", callback); } const { ownerDocument } = editableContentElement; if (editableContentElement === ownerDocument.activeElement || // When a link is created, we need to attach the popover to the newly created anchor. !wasActive && isActive || // Sometimes we're _removing_ an active anchor, such as the inline color popover. // When we add the color, it switches from a virtual anchor to a `<mark>` element. // When we _remove_ the color, it switches from a `<mark>` element to a virtual anchor. wasActive && !isActive) { setAnchor( getAnchor(editableContentElement, tagName, className) ); attach(); } editableContentElement.addEventListener("focusin", attach); editableContentElement.addEventListener("focusout", detach); return () => { detach(); editableContentElement.removeEventListener("focusin", attach); editableContentElement.removeEventListener("focusout", detach); }; }, [editableContentElement, tagName, className, isActive, wasActive]); return anchor; } ;// ./node_modules/@wordpress/rich-text/build-module/component/use-default-style.js const whiteSpace = "pre-wrap"; const minWidth = "1px"; function useDefaultStyle() { return (0,external_wp_element_namespaceObject.useCallback)((element) => { if (!element) { return; } element.style.whiteSpace = whiteSpace; element.style.minWidth = minWidth; }, []); } ;// ./node_modules/colord/index.mjs var r={grad:.9,turn:360,rad:360/(2*Math.PI)},t=function(r){return"string"==typeof r?r.length>0:"number"==typeof r},n=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=Math.pow(10,t)),Math.round(n*r)/n+0},e=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=1),r>n?n:r>t?r:t},u=function(r){return(r=isFinite(r)?r%360:0)>0?r:r+360},a=function(r){return{r:e(r.r,0,255),g:e(r.g,0,255),b:e(r.b,0,255),a:e(r.a)}},o=function(r){return{r:n(r.r),g:n(r.g),b:n(r.b),a:n(r.a,3)}},i=/^#([0-9a-f]{3,8})$/i,s=function(r){var t=r.toString(16);return t.length<2?"0"+t:t},h=function(r){var t=r.r,n=r.g,e=r.b,u=r.a,a=Math.max(t,n,e),o=a-Math.min(t,n,e),i=o?a===t?(n-e)/o:a===n?2+(e-t)/o:4+(t-n)/o:0;return{h:60*(i<0?i+6:i),s:a?o/a*100:0,v:a/255*100,a:u}},b=function(r){var t=r.h,n=r.s,e=r.v,u=r.a;t=t/360*6,n/=100,e/=100;var a=Math.floor(t),o=e*(1-n),i=e*(1-(t-a)*n),s=e*(1-(1-t+a)*n),h=a%6;return{r:255*[e,i,o,o,s,e][h],g:255*[s,e,e,i,o,o][h],b:255*[o,o,s,e,e,i][h],a:u}},g=function(r){return{h:u(r.h),s:e(r.s,0,100),l:e(r.l,0,100),a:e(r.a)}},d=function(r){return{h:n(r.h),s:n(r.s),l:n(r.l),a:n(r.a,3)}},f=function(r){return b((n=(t=r).s,{h:t.h,s:(n*=((e=t.l)<50?e:100-e)/100)>0?2*n/(e+n)*100:0,v:e+n,a:t.a}));var t,n,e},c=function(r){return{h:(t=h(r)).h,s:(u=(200-(n=t.s))*(e=t.v)/100)>0&&u<200?n*e/100/(u<=100?u:200-u)*100:0,l:u/2,a:t.a};var t,n,e,u},l=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,p=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,v=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,m=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,y={string:[[function(r){var t=i.exec(r);return t?(r=t[1]).length<=4?{r:parseInt(r[0]+r[0],16),g:parseInt(r[1]+r[1],16),b:parseInt(r[2]+r[2],16),a:4===r.length?n(parseInt(r[3]+r[3],16)/255,2):1}:6===r.length||8===r.length?{r:parseInt(r.substr(0,2),16),g:parseInt(r.substr(2,2),16),b:parseInt(r.substr(4,2),16),a:8===r.length?n(parseInt(r.substr(6,2),16)/255,2):1}:null:null},"hex"],[function(r){var t=v.exec(r)||m.exec(r);return t?t[2]!==t[4]||t[4]!==t[6]?null:a({r:Number(t[1])/(t[2]?100/255:1),g:Number(t[3])/(t[4]?100/255:1),b:Number(t[5])/(t[6]?100/255:1),a:void 0===t[7]?1:Number(t[7])/(t[8]?100:1)}):null},"rgb"],[function(t){var n=l.exec(t)||p.exec(t);if(!n)return null;var e,u,a=g({h:(e=n[1],u=n[2],void 0===u&&(u="deg"),Number(e)*(r[u]||1)),s:Number(n[3]),l:Number(n[4]),a:void 0===n[5]?1:Number(n[5])/(n[6]?100:1)});return f(a)},"hsl"]],object:[[function(r){var n=r.r,e=r.g,u=r.b,o=r.a,i=void 0===o?1:o;return t(n)&&t(e)&&t(u)?a({r:Number(n),g:Number(e),b:Number(u),a:Number(i)}):null},"rgb"],[function(r){var n=r.h,e=r.s,u=r.l,a=r.a,o=void 0===a?1:a;if(!t(n)||!t(e)||!t(u))return null;var i=g({h:Number(n),s:Number(e),l:Number(u),a:Number(o)});return f(i)},"hsl"],[function(r){var n=r.h,a=r.s,o=r.v,i=r.a,s=void 0===i?1:i;if(!t(n)||!t(a)||!t(o))return null;var h=function(r){return{h:u(r.h),s:e(r.s,0,100),v:e(r.v,0,100),a:e(r.a)}}({h:Number(n),s:Number(a),v:Number(o),a:Number(s)});return b(h)},"hsv"]]},N=function(r,t){for(var n=0;n<t.length;n++){var e=t[n][0](r);if(e)return[e,t[n][1]]}return[null,void 0]},x=function(r){return"string"==typeof r?N(r.trim(),y.string):"object"==typeof r&&null!==r?N(r,y.object):[null,void 0]},I=function(r){return x(r)[1]},M=function(r,t){var n=c(r);return{h:n.h,s:e(n.s+100*t,0,100),l:n.l,a:n.a}},H=function(r){return(299*r.r+587*r.g+114*r.b)/1e3/255},$=function(r,t){var n=c(r);return{h:n.h,s:n.s,l:e(n.l+100*t,0,100),a:n.a}},j=function(){function r(r){this.parsed=x(r)[0],this.rgba=this.parsed||{r:0,g:0,b:0,a:1}}return r.prototype.isValid=function(){return null!==this.parsed},r.prototype.brightness=function(){return n(H(this.rgba),2)},r.prototype.isDark=function(){return H(this.rgba)<.5},r.prototype.isLight=function(){return H(this.rgba)>=.5},r.prototype.toHex=function(){return r=o(this.rgba),t=r.r,e=r.g,u=r.b,i=(a=r.a)<1?s(n(255*a)):"","#"+s(t)+s(e)+s(u)+i;var r,t,e,u,a,i},r.prototype.toRgb=function(){return o(this.rgba)},r.prototype.toRgbString=function(){return r=o(this.rgba),t=r.r,n=r.g,e=r.b,(u=r.a)<1?"rgba("+t+", "+n+", "+e+", "+u+")":"rgb("+t+", "+n+", "+e+")";var r,t,n,e,u},r.prototype.toHsl=function(){return d(c(this.rgba))},r.prototype.toHslString=function(){return r=d(c(this.rgba)),t=r.h,n=r.s,e=r.l,(u=r.a)<1?"hsla("+t+", "+n+"%, "+e+"%, "+u+")":"hsl("+t+", "+n+"%, "+e+"%)";var r,t,n,e,u},r.prototype.toHsv=function(){return r=h(this.rgba),{h:n(r.h),s:n(r.s),v:n(r.v),a:n(r.a,3)};var r},r.prototype.invert=function(){return w({r:255-(r=this.rgba).r,g:255-r.g,b:255-r.b,a:r.a});var r},r.prototype.saturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,r))},r.prototype.desaturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,-r))},r.prototype.grayscale=function(){return w(M(this.rgba,-1))},r.prototype.lighten=function(r){return void 0===r&&(r=.1),w($(this.rgba,r))},r.prototype.darken=function(r){return void 0===r&&(r=.1),w($(this.rgba,-r))},r.prototype.rotate=function(r){return void 0===r&&(r=15),this.hue(this.hue()+r)},r.prototype.alpha=function(r){return"number"==typeof r?w({r:(t=this.rgba).r,g:t.g,b:t.b,a:r}):n(this.rgba.a,3);var t},r.prototype.hue=function(r){var t=c(this.rgba);return"number"==typeof r?w({h:r,s:t.s,l:t.l,a:t.a}):n(t.h)},r.prototype.isEqual=function(r){return this.toHex()===w(r).toHex()},r}(),w=function(r){return r instanceof j?r:new j(r)},S=(/* unused pure expression or super */ null && ([])),k=function(r){r.forEach(function(r){S.indexOf(r)<0&&(r(j,y),S.push(r))})},E=function(){return new j({r:255*Math.random(),g:255*Math.random(),b:255*Math.random()})}; ;// ./node_modules/@wordpress/rich-text/build-module/component/use-boundary-style.js function useBoundaryStyle({ record }) { const ref = (0,external_wp_element_namespaceObject.useRef)(); const { activeFormats = [], replacements, start } = record.current; const activeReplacement = replacements[start]; (0,external_wp_element_namespaceObject.useEffect)(() => { if ((!activeFormats || !activeFormats.length) && !activeReplacement) { return; } const boundarySelector = "*[data-rich-text-format-boundary]"; const element = ref.current.querySelector(boundarySelector); if (!element) { return; } const { ownerDocument } = element; const { defaultView } = ownerDocument; const computedStyle = defaultView.getComputedStyle(element); const newColor = w(computedStyle.color).alpha(0.2).toRgbString(); const selector = `.rich-text:focus ${boundarySelector}`; const rule = `background-color: ${newColor}`; const style = `${selector} {${rule}}`; const globalStyleId = "rich-text-boundary-style"; let globalStyle = ownerDocument.getElementById(globalStyleId); if (!globalStyle) { globalStyle = ownerDocument.createElement("style"); globalStyle.id = globalStyleId; ownerDocument.head.appendChild(globalStyle); } if (globalStyle.innerHTML !== style) { globalStyle.innerHTML = style; } }, [activeFormats, activeReplacement]); return ref; } ;// ./node_modules/@wordpress/rich-text/build-module/component/event-listeners/copy-handler.js var copy_handler_default = (props) => (element) => { function onCopy(event) { const { record } = props.current; const { ownerDocument } = element; if (isCollapsed(record.current) || !element.contains(ownerDocument.activeElement)) { return; } const selectedRecord = slice(record.current); const plainText = getTextContent(selectedRecord); const html = toHTMLString({ value: selectedRecord }); event.clipboardData.setData("text/plain", plainText); event.clipboardData.setData("text/html", html); event.clipboardData.setData("rich-text", "true"); event.preventDefault(); if (event.type === "cut") { ownerDocument.execCommand("delete"); } } const { defaultView } = element.ownerDocument; defaultView.addEventListener("copy", onCopy); defaultView.addEventListener("cut", onCopy); return () => { defaultView.removeEventListener("copy", onCopy); defaultView.removeEventListener("cut", onCopy); }; }; ;// ./node_modules/@wordpress/rich-text/build-module/component/event-listeners/select-object.js var select_object_default = () => (element) => { function onClick(event) { const { target } = event; if (target === element || target.textContent && target.isContentEditable) { return; } const { ownerDocument } = target; const { defaultView } = ownerDocument; const selection = defaultView.getSelection(); if (selection.containsNode(target)) { return; } const range = ownerDocument.createRange(); const nodeToSelect = target.isContentEditable ? target : target.closest("[contenteditable]"); range.selectNode(nodeToSelect); selection.removeAllRanges(); selection.addRange(range); event.preventDefault(); } function onFocusIn(event) { if (event.relatedTarget && !element.contains(event.relatedTarget) && event.relatedTarget.tagName === "A") { onClick(event); } } element.addEventListener("click", onClick); element.addEventListener("focusin", onFocusIn); return () => { element.removeEventListener("click", onClick); element.removeEventListener("focusin", onFocusIn); }; }; ;// external ["wp","keycodes"] const external_wp_keycodes_namespaceObject = window["wp"]["keycodes"]; ;// ./node_modules/@wordpress/rich-text/build-module/component/event-listeners/format-boundaries.js const EMPTY_ACTIVE_FORMATS = []; var format_boundaries_default = (props) => (element) => { function onKeyDown(event) { const { keyCode, shiftKey, altKey, metaKey, ctrlKey } = event; if ( // Only override left and right keys without modifiers pressed. shiftKey || altKey || metaKey || ctrlKey || keyCode !== external_wp_keycodes_namespaceObject.LEFT && keyCode !== external_wp_keycodes_namespaceObject.RIGHT ) { return; } const { record, applyRecord, forceRender } = props.current; const { text, formats, start, end, activeFormats: currentActiveFormats = [] } = record.current; const collapsed = isCollapsed(record.current); const { ownerDocument } = element; const { defaultView } = ownerDocument; const { direction } = defaultView.getComputedStyle(element); const reverseKey = direction === "rtl" ? external_wp_keycodes_namespaceObject.RIGHT : external_wp_keycodes_namespaceObject.LEFT; const isReverse = event.keyCode === reverseKey; if (collapsed && currentActiveFormats.length === 0) { if (start === 0 && isReverse) { return; } if (end === text.length && !isReverse) { return; } } if (!collapsed) { return; } const formatsBefore = formats[start - 1] || EMPTY_ACTIVE_FORMATS; const formatsAfter = formats[start] || EMPTY_ACTIVE_FORMATS; const destination = isReverse ? formatsBefore : formatsAfter; const isIncreasing = currentActiveFormats.every( (format, index) => format === destination[index] ); let newActiveFormatsLength = currentActiveFormats.length; if (!isIncreasing) { newActiveFormatsLength--; } else if (newActiveFormatsLength < destination.length) { newActiveFormatsLength++; } if (newActiveFormatsLength === currentActiveFormats.length) { record.current._newActiveFormats = destination; return; } event.preventDefault(); const origin = isReverse ? formatsAfter : formatsBefore; const source = isIncreasing ? destination : origin; const newActiveFormats = source.slice(0, newActiveFormatsLength); const newValue = { ...record.current, activeFormats: newActiveFormats }; record.current = newValue; applyRecord(newValue); forceRender(); } element.addEventListener("keydown", onKeyDown); return () => { element.removeEventListener("keydown", onKeyDown); }; }; ;// ./node_modules/@wordpress/rich-text/build-module/component/event-listeners/delete.js var delete_default = (props) => (element) => { function onKeyDown(event) { const { keyCode } = event; const { createRecord, handleChange } = props.current; if (event.defaultPrevented) { return; } if (keyCode !== external_wp_keycodes_namespaceObject.DELETE && keyCode !== external_wp_keycodes_namespaceObject.BACKSPACE) { return; } const currentValue = createRecord(); const { start, end, text } = currentValue; if (start === 0 && end !== 0 && end === text.length) { handleChange(remove_remove(currentValue)); event.preventDefault(); } } element.addEventListener("keydown", onKeyDown); return () => { element.removeEventListener("keydown", onKeyDown); }; }; ;// ./node_modules/@wordpress/rich-text/build-module/update-formats.js function updateFormats({ value, start, end, formats }) { const min = Math.min(start, end); const max = Math.max(start, end); const formatsBefore = value.formats[min - 1] || []; const formatsAfter = value.formats[max] || []; value.activeFormats = formats.map((format, index) => { if (formatsBefore[index]) { if (isFormatEqual(format, formatsBefore[index])) { return formatsBefore[index]; } } else if (formatsAfter[index]) { if (isFormatEqual(format, formatsAfter[index])) { return formatsAfter[index]; } } return format; }); while (--end >= start) { if (value.activeFormats.length > 0) { value.formats[end] = value.activeFormats; } else { delete value.formats[end]; } } return value; } ;// ./node_modules/@wordpress/rich-text/build-module/component/event-listeners/input-and-selection.js const INSERTION_INPUT_TYPES_TO_IGNORE = /* @__PURE__ */ new Set([ "insertParagraph", "insertOrderedList", "insertUnorderedList", "insertHorizontalRule", "insertLink" ]); const input_and_selection_EMPTY_ACTIVE_FORMATS = []; const PLACEHOLDER_ATTR_NAME = "data-rich-text-placeholder"; function fixPlaceholderSelection(defaultView) { const selection = defaultView.getSelection(); const { anchorNode, anchorOffset } = selection; if (anchorNode.nodeType !== anchorNode.ELEMENT_NODE) { return; } const targetNode = anchorNode.childNodes[anchorOffset]; if (!targetNode || targetNode.nodeType !== targetNode.ELEMENT_NODE || !targetNode.hasAttribute(PLACEHOLDER_ATTR_NAME)) { return; } selection.collapseToStart(); } var input_and_selection_default = (props) => (element) => { const { ownerDocument } = element; const { defaultView } = ownerDocument; let isComposing = false; function onInput(event) { if (isComposing) { return; } let inputType; if (event) { inputType = event.inputType; } const { record, applyRecord, createRecord, handleChange } = props.current; if (inputType && (inputType.indexOf("format") === 0 || INSERTION_INPUT_TYPES_TO_IGNORE.has(inputType))) { applyRecord(record.current); return; } const currentValue = createRecord(); const { start, activeFormats: oldActiveFormats = [] } = record.current; const change = updateFormats({ value: currentValue, start, end: currentValue.start, formats: oldActiveFormats }); handleChange(change); } function handleSelectionChange() { const { record, applyRecord, createRecord, onSelectionChange } = props.current; if (element.contentEditable !== "true") { return; } if (ownerDocument.activeElement !== element) { ownerDocument.removeEventListener( "selectionchange", handleSelectionChange ); return; } if (isComposing) { return; } const { start, end, text } = createRecord(); const oldRecord = record.current; if (text !== oldRecord.text) { onInput(); return; } if (start === oldRecord.start && end === oldRecord.end) { if (oldRecord.text.length === 0 && start === 0) { fixPlaceholderSelection(defaultView); } return; } const newValue = { ...oldRecord, start, end, // _newActiveFormats may be set on arrow key navigation to control // the right boundary position. If undefined, getActiveFormats will // give the active formats according to the browser. activeFormats: oldRecord._newActiveFormats, _newActiveFormats: void 0 }; const newActiveFormats = getActiveFormats( newValue, input_and_selection_EMPTY_ACTIVE_FORMATS ); newValue.activeFormats = newActiveFormats; record.current = newValue; applyRecord(newValue, { domOnly: true }); onSelectionChange(start, end); } function onCompositionStart() { isComposing = true; ownerDocument.removeEventListener( "selectionchange", handleSelectionChange ); element.querySelector(`[${PLACEHOLDER_ATTR_NAME}]`)?.remove(); } function onCompositionEnd() { isComposing = false; onInput({ inputType: "insertText" }); ownerDocument.addEventListener( "selectionchange", handleSelectionChange ); } function onFocus() { const { record, isSelected, onSelectionChange, applyRecord } = props.current; if (element.parentElement.closest('[contenteditable="true"]')) { return; } if (!isSelected) { const index = void 0; record.current = { ...record.current, start: index, end: index, activeFormats: input_and_selection_EMPTY_ACTIVE_FORMATS }; } else { applyRecord(record.current, { domOnly: true }); } onSelectionChange(record.current.start, record.current.end); window.queueMicrotask(handleSelectionChange); ownerDocument.addEventListener( "selectionchange", handleSelectionChange ); } element.addEventListener("input", onInput); element.addEventListener("compositionstart", onCompositionStart); element.addEventListener("compositionend", onCompositionEnd); element.addEventListener("focus", onFocus); return () => { element.removeEventListener("input", onInput); element.removeEventListener("compositionstart", onCompositionStart); element.removeEventListener("compositionend", onCompositionEnd); element.removeEventListener("focus", onFocus); }; }; ;// ./node_modules/@wordpress/rich-text/build-module/component/event-listeners/selection-change-compat.js var selection_change_compat_default = () => (element) => { const { ownerDocument } = element; const { defaultView } = ownerDocument; const selection = defaultView?.getSelection(); let range; function getRange() { return selection.rangeCount ? selection.getRangeAt(0) : null; } function onDown(event) { const type = event.type === "keydown" ? "keyup" : "pointerup"; function onCancel() { ownerDocument.removeEventListener(type, onUp); ownerDocument.removeEventListener("selectionchange", onCancel); ownerDocument.removeEventListener("input", onCancel); } function onUp() { onCancel(); if (isRangeEqual(range, getRange())) { return; } ownerDocument.dispatchEvent(new Event("selectionchange")); } ownerDocument.addEventListener(type, onUp); ownerDocument.addEventListener("selectionchange", onCancel); ownerDocument.addEventListener("input", onCancel); range = getRange(); } element.addEventListener("pointerdown", onDown); element.addEventListener("keydown", onDown); return () => { element.removeEventListener("pointerdown", onDown); element.removeEventListener("keydown", onDown); }; }; ;// ./node_modules/@wordpress/rich-text/build-module/component/event-listeners/prevent-focus-capture.js function preventFocusCapture() { return (element) => { const { ownerDocument } = element; const { defaultView } = ownerDocument; let value = null; function onPointerDown(event) { if (event.defaultPrevented) { return; } if (event.target === element) { return; } if (!event.target.contains(element)) { return; } value = element.getAttribute("contenteditable"); element.setAttribute("contenteditable", "false"); defaultView.getSelection().removeAllRanges(); } function onPointerUp() { if (value !== null) { element.setAttribute("contenteditable", value); value = null; } } defaultView.addEventListener("pointerdown", onPointerDown); defaultView.addEventListener("pointerup", onPointerUp); return () => { defaultView.removeEventListener("pointerdown", onPointerDown); defaultView.removeEventListener("pointerup", onPointerUp); }; }; } ;// ./node_modules/@wordpress/rich-text/build-module/component/event-listeners/index.js const allEventListeners = [ copy_handler_default, select_object_default, format_boundaries_default, delete_default, input_and_selection_default, selection_change_compat_default, preventFocusCapture ]; function useEventListeners(props) { const propsRef = (0,external_wp_element_namespaceObject.useRef)(props); (0,external_wp_element_namespaceObject.useInsertionEffect)(() => { propsRef.current = props; }); const refEffects = (0,external_wp_element_namespaceObject.useMemo)( () => allEventListeners.map((refEffect) => refEffect(propsRef)), [propsRef] ); return (0,external_wp_compose_namespaceObject.useRefEffect)( (element) => { const cleanups = refEffects.map((effect) => effect(element)); return () => { cleanups.forEach((cleanup) => cleanup()); }; }, [refEffects] ); } ;// ./node_modules/@wordpress/rich-text/build-module/component/index.js function useRichText({ value = "", selectionStart, selectionEnd, placeholder, onSelectionChange, preserveWhiteSpace, onChange, __unstableDisableFormats: disableFormats, __unstableIsSelected: isSelected, __unstableDependencies = [], __unstableAfterParse, __unstableBeforeSerialize, __unstableAddInvisibleFormats }) { const registry = (0,external_wp_data_namespaceObject.useRegistry)(); const [, forceRender] = (0,external_wp_element_namespaceObject.useReducer)(() => ({})); const ref = (0,external_wp_element_namespaceObject.useRef)(); function createRecord() { const { ownerDocument: { defaultView } } = ref.current; const selection = defaultView.getSelection(); const range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null; return create({ element: ref.current, range, __unstableIsEditableTree: true }); } function applyRecord(newRecord, { domOnly } = {}) { apply({ value: newRecord, current: ref.current, prepareEditableTree: __unstableAddInvisibleFormats, __unstableDomOnly: domOnly, placeholder }); } const _valueRef = (0,external_wp_element_namespaceObject.useRef)(value); const recordRef = (0,external_wp_element_namespaceObject.useRef)(); function setRecordFromProps() { _valueRef.current = value; recordRef.current = value; if (!(value instanceof RichTextData)) { recordRef.current = value ? RichTextData.fromHTMLString(value, { preserveWhiteSpace }) : RichTextData.empty(); } recordRef.current = { text: recordRef.current.text, formats: recordRef.current.formats, replacements: recordRef.current.replacements }; if (disableFormats) { recordRef.current.formats = Array(value.length); recordRef.current.replacements = Array(value.length); } if (__unstableAfterParse) { recordRef.current.formats = __unstableAfterParse( recordRef.current ); } recordRef.current.start = selectionStart; recordRef.current.end = selectionEnd; } const hadSelectionUpdateRef = (0,external_wp_element_namespaceObject.useRef)(false); if (!recordRef.current) { hadSelectionUpdateRef.current = isSelected; setRecordFromProps(); } else if (selectionStart !== recordRef.current.start || selectionEnd !== recordRef.current.end) { hadSelectionUpdateRef.current = isSelected; recordRef.current = { ...recordRef.current, start: selectionStart, end: selectionEnd, activeFormats: void 0 }; } function handleChange(newRecord) { recordRef.current = newRecord; applyRecord(newRecord); if (disableFormats) { _valueRef.current = newRecord.text; } else { const newFormats = __unstableBeforeSerialize ? __unstableBeforeSerialize(newRecord) : newRecord.formats; newRecord = { ...newRecord, formats: newFormats }; if (typeof value === "string") { _valueRef.current = toHTMLString({ value: newRecord, preserveWhiteSpace }); } else { _valueRef.current = new RichTextData(newRecord); } } const { start, end, formats, text } = recordRef.current; registry.batch(() => { onSelectionChange(start, end); onChange(_valueRef.current, { __unstableFormats: formats, __unstableText: text }); }); forceRender(); } function applyFromProps() { const previousValue = _valueRef.current; setRecordFromProps(); const contentLengthChanged = previousValue && typeof previousValue === "string" && typeof value === "string" && previousValue.length !== value.length; const hasFocus = ref.current?.contains( ref.current.ownerDocument.activeElement ); const skipSelection = contentLengthChanged && !hasFocus; applyRecord(recordRef.current, { domOnly: skipSelection }); } const didMountRef = (0,external_wp_element_namespaceObject.useRef)(false); (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { if (didMountRef.current && value !== _valueRef.current) { applyFromProps(); forceRender(); } }, [value]); (0,external_wp_element_namespaceObject.useLayoutEffect)(() => { if (!hadSelectionUpdateRef.current) { return; } if (ref.current.ownerDocument.activeElement !== ref.current) { ref.current.focus(); } applyRecord(recordRef.current); hadSelectionUpdateRef.current = false; }, [hadSelectionUpdateRef.current]); const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([ ref, useDefaultStyle(), useBoundaryStyle({ record: recordRef }), useEventListeners({ record: recordRef, handleChange, applyRecord, createRecord, isSelected, onSelectionChange, forceRender }), (0,external_wp_compose_namespaceObject.useRefEffect)(() => { applyFromProps(); didMountRef.current = true; }, [placeholder, ...__unstableDependencies]) ]); return { value: recordRef.current, // A function to get the most recent value so event handlers in // useRichText implementations have access to it. For example when // listening to input events, we internally update the state, but this // state is not yet available to the input event handler because React // may re-render asynchronously. getValue: () => recordRef.current, onChange: handleChange, ref: mergedRefs }; } function __experimentalRichText() { } ;// ./node_modules/@wordpress/rich-text/build-module/index.js (window.wp = window.wp || {}).richText = __webpack_exports__; /******/ })() ;
Save
Back