{"version":3,"file":"./build/rich-text/index.min.js","mappings":"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","sources":["webpack://wp/webpack/bootstrap","webpack://wp/webpack/runtime/compat get default export","webpack://wp/webpack/runtime/define property getters","webpack://wp/webpack/runtime/hasOwnProperty shorthand","webpack://wp/webpack/runtime/make namespace object","webpack://wp/external window [\"wp\",\"data\"]","../../packages/rich-text/src/store/reducer.js","../../packages/rich-text/src/store/selectors.js","../../packages/rich-text/src/store/actions.js","../../packages/rich-text/src/store/index.js","../../packages/rich-text/src/is-format-equal.js","../../packages/rich-text/src/normalise-formats.js","../../packages/rich-text/src/apply-format.js","../../packages/rich-text/src/create-element.js","../../packages/rich-text/src/special-characters.js","webpack://wp/external window [\"wp\",\"escapeHtml\"]","../../packages/rich-text/src/get-active-formats.js","../../packages/rich-text/src/get-format-type.js","../../packages/rich-text/src/to-tree.js","../../packages/rich-text/src/to-html-string.js","../../packages/rich-text/src/get-text-content.js","../../packages/rich-text/src/create.js","../../packages/rich-text/src/concat.js","../../packages/rich-text/src/get-active-format.js","../../packages/rich-text/src/get-active-object.js","../../packages/rich-text/src/is-collapsed.ts","../../packages/rich-text/src/is-empty.js","../../packages/rich-text/src/join.js","../../packages/rich-text/src/register-format-type.js","../../packages/rich-text/src/remove-format.js","../../packages/rich-text/src/insert.js","../../packages/rich-text/src/remove.js","../../packages/rich-text/src/replace.js","../../packages/rich-text/src/insert-object.js","../../packages/rich-text/src/slice.js","../../packages/rich-text/src/split.js","../../packages/rich-text/src/is-range-equal.js","../../packages/rich-text/src/to-dom.js","webpack://wp/external window [\"wp\",\"a11y\"]","webpack://wp/external window [\"wp\",\"i18n\"]","../../packages/rich-text/src/toggle-format.js","../../packages/rich-text/src/unregister-format-type.js","webpack://wp/external window [\"wp\",\"element\"]","webpack://wp/external window [\"wp\",\"deprecated\"]","../../packages/rich-text/src/component/use-anchor-ref.js","webpack://wp/external window [\"wp\",\"compose\"]","../../packages/rich-text/src/component/use-anchor.js","../../packages/rich-text/src/component/use-default-style.js","../../packages/rich-text/src/component/use-boundary-style.js","../../packages/rich-text/src/component/event-listeners/copy-handler.js","webpack://wp/external window [\"wp\",\"keycodes\"]","../../packages/rich-text/src/component/event-listeners/format-boundaries.js","../../packages/rich-text/src/component/event-listeners/input-and-selection.js","../../packages/rich-text/src/component/event-listeners/index.js","../../packages/rich-text/src/component/event-listeners/select-object.js","../../packages/rich-text/src/component/event-listeners/delete.js","../../packages/rich-text/src/update-formats.js","../../packages/rich-text/src/component/event-listeners/selection-change-compat.js","../../packages/rich-text/src/component/index.js"],"sourcesContent":["// The require scope\nvar __webpack_require__ = {};\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"data\"];","/**\n * WordPress dependencies\n */\nimport { combineReducers } from '@wordpress/data';\n\n/**\n * Reducer managing the format types\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function formatTypes( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'ADD_FORMAT_TYPES':\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t// Key format types by their name.\n\t\t\t\t...action.formatTypes.reduce(\n\t\t\t\t\t( newFormatTypes, type ) => ( {\n\t\t\t\t\t\t...newFormatTypes,\n\t\t\t\t\t\t[ type.name ]: type,\n\t\t\t\t\t} ),\n\t\t\t\t\t{}\n\t\t\t\t),\n\t\t\t};\n\t\tcase 'REMOVE_FORMAT_TYPES':\n\t\t\treturn Object.fromEntries(\n\t\t\t\tObject.entries( state ).filter(\n\t\t\t\t\t( [ key ] ) => ! action.names.includes( key )\n\t\t\t\t)\n\t\t\t);\n\t}\n\n\treturn state;\n}\n\nexport default combineReducers( { formatTypes } );\n","/**\n * WordPress dependencies\n */\nimport { createSelector } from '@wordpress/data';\n\n/**\n * Returns all the available format types.\n *\n * @param {Object} state Data state.\n *\n * @example\n * ```js\n * import { __, sprintf } from '@wordpress/i18n';\n * import { store as richTextStore } from '@wordpress/rich-text';\n * import { useSelect } from '@wordpress/data';\n *\n * const ExampleComponent = () => {\n *    const { getFormatTypes } = useSelect(\n *        ( select ) => select( richTextStore ),\n *        []\n *    );\n *\n *    const availableFormats = getFormatTypes();\n *\n *    return availableFormats ? (\n *        <ul>\n *            { availableFormats?.map( ( format ) => (\n *                <li>{ format.name }</li>\n *           ) ) }\n *        </ul>\n *    ) : (\n *        __( 'No Formats available' )\n *    );\n * };\n * ```\n *\n * @return {Array} Format types.\n */\nexport const getFormatTypes = createSelector(\n\t( state ) => Object.values( state.formatTypes ),\n\t( state ) => [ state.formatTypes ]\n);\n\n/**\n * Returns a format type by name.\n *\n * @param {Object} state Data state.\n * @param {string} name  Format type name.\n *\n * @example\n * ```js\n * import { __, sprintf } from '@wordpress/i18n';\n * import { store as richTextStore } from '@wordpress/rich-text';\n * import { useSelect } from '@wordpress/data';\n *\n * const ExampleComponent = () => {\n *    const { getFormatType } = useSelect(\n *        ( select ) => select( richTextStore ),\n *        []\n *    );\n *\n *    const boldFormat = getFormatType( 'core/bold' );\n *\n *    return boldFormat ? (\n *        <ul>\n *            { Object.entries( boldFormat )?.map( ( [ key, value ] ) => (\n *                <li>\n *                    { key } : { value }\n *                </li>\n *           ) ) }\n *       </ul>\n *    ) : (\n *        __( 'Not Found' )\n *    ;\n * };\n * ```\n *\n * @return {Object?} Format type.\n */\nexport function getFormatType( state, name ) {\n\treturn state.formatTypes[ name ];\n}\n\n/**\n * Gets the format type, if any, that can handle a bare element (without a\n * data-format-type attribute), given the tag name of this element.\n *\n * @param {Object} state              Data state.\n * @param {string} bareElementTagName The tag name of the element to find a\n *                                    format type for.\n *\n * @example\n * ```js\n * import { __, sprintf } from '@wordpress/i18n';\n * import { store as richTextStore } from '@wordpress/rich-text';\n * import { useSelect } from '@wordpress/data';\n *\n * const ExampleComponent = () => {\n *    const { getFormatTypeForBareElement } = useSelect(\n *        ( select ) => select( richTextStore ),\n *        []\n *    );\n *\n *    const format = getFormatTypeForBareElement( 'strong' );\n *\n *    return format && <p>{ sprintf( __( 'Format name: %s' ), format.name ) }</p>;\n * }\n * ```\n *\n * @return {?Object} Format type.\n */\nexport function getFormatTypeForBareElement( state, bareElementTagName ) {\n\tconst formatTypes = getFormatTypes( state );\n\treturn (\n\t\tformatTypes.find( ( { className, tagName } ) => {\n\t\t\treturn className === null && bareElementTagName === tagName;\n\t\t} ) ||\n\t\tformatTypes.find( ( { className, tagName } ) => {\n\t\t\treturn className === null && '*' === tagName;\n\t\t} )\n\t);\n}\n\n/**\n * Gets the format type, if any, that can handle an element, given its classes.\n *\n * @param {Object} state            Data state.\n * @param {string} elementClassName The classes of the element to find a format\n *                                  type for.\n *\n * @example\n * ```js\n * import { __, sprintf } from '@wordpress/i18n';\n * import { store as richTextStore } from '@wordpress/rich-text';\n * import { useSelect } from '@wordpress/data';\n *\n * const ExampleComponent = () => {\n *    const { getFormatTypeForClassName } = useSelect(\n *        ( select ) => select( richTextStore ),\n *        []\n *    );\n *\n *    const format = getFormatTypeForClassName( 'has-inline-color' );\n *\n *    return format && <p>{ sprintf( __( 'Format name: %s' ), format.name ) }</p>;\n * };\n * ```\n *\n * @return {?Object} Format type.\n */\nexport function getFormatTypeForClassName( state, elementClassName ) {\n\treturn getFormatTypes( state ).find( ( { className } ) => {\n\t\tif ( className === null ) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn ` ${ elementClassName } `.indexOf( ` ${ className } ` ) >= 0;\n\t} );\n}\n","/**\n * Returns an action object used in signalling that format types have been\n * added.\n * Ignored from documentation as registerFormatType should be used instead from @wordpress/rich-text\n *\n * @ignore\n *\n * @param {Array|Object} formatTypes Format types received.\n *\n * @return {Object} Action object.\n */\nexport function addFormatTypes( formatTypes ) {\n\treturn {\n\t\ttype: 'ADD_FORMAT_TYPES',\n\t\tformatTypes: Array.isArray( formatTypes )\n\t\t\t? formatTypes\n\t\t\t: [ formatTypes ],\n\t};\n}\n\n/**\n * Returns an action object used to remove a registered format type.\n *\n * Ignored from documentation as unregisterFormatType should be used instead from @wordpress/rich-text\n *\n * @ignore\n *\n * @param {string|Array} names Format name.\n *\n * @return {Object} Action object.\n */\nexport function removeFormatTypes( names ) {\n\treturn {\n\t\ttype: 'REMOVE_FORMAT_TYPES',\n\t\tnames: Array.isArray( names ) ? names : [ names ],\n\t};\n}\n","/**\n * WordPress dependencies\n */\nimport { createReduxStore, register } from '@wordpress/data';\n\n/**\n * Internal dependencies\n */\nimport reducer from './reducer';\nimport * as selectors from './selectors';\nimport * as actions from './actions';\n\nconst STORE_NAME = 'core/rich-text';\n\n/**\n * Store definition for the rich-text namespace.\n *\n * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore\n *\n * @type {Object}\n */\nexport const store = createReduxStore( STORE_NAME, {\n\treducer,\n\tselectors,\n\tactions,\n} );\n\nregister( store );\n","/** @typedef {import('./types').RichTextFormat} RichTextFormat */\n\n/**\n * Optimised equality check for format objects.\n *\n * @param {?RichTextFormat} format1 Format to compare.\n * @param {?RichTextFormat} format2 Format to compare.\n *\n * @return {boolean} True if formats are equal, false if not.\n */\nexport function isFormatEqual( format1, format2 ) {\n\t// Both not defined.\n\tif ( format1 === format2 ) {\n\t\treturn true;\n\t}\n\n\t// Either not defined.\n\tif ( ! format1 || ! format2 ) {\n\t\treturn false;\n\t}\n\n\tif ( format1.type !== format2.type ) {\n\t\treturn false;\n\t}\n\n\tconst attributes1 = format1.attributes;\n\tconst attributes2 = format2.attributes;\n\n\t// Both not defined.\n\tif ( attributes1 === attributes2 ) {\n\t\treturn true;\n\t}\n\n\t// Either not defined.\n\tif ( ! attributes1 || ! attributes2 ) {\n\t\treturn false;\n\t}\n\n\tconst keys1 = Object.keys( attributes1 );\n\tconst keys2 = Object.keys( attributes2 );\n\n\tif ( keys1.length !== keys2.length ) {\n\t\treturn false;\n\t}\n\n\tconst length = keys1.length;\n\n\t// Optimise for speed.\n\tfor ( let i = 0; i < length; i++ ) {\n\t\tconst name = keys1[ i ];\n\n\t\tif ( attributes1[ name ] !== attributes2[ name ] ) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n","/**\n * Internal dependencies\n */\n\nimport { isFormatEqual } from './is-format-equal';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Normalises formats: ensures subsequent adjacent equal formats have the same\n * reference.\n *\n * @param {RichTextValue} value Value to normalise formats of.\n *\n * @return {RichTextValue} New value with normalised formats.\n */\nexport function normaliseFormats( value ) {\n\tconst newFormats = value.formats.slice();\n\n\tnewFormats.forEach( ( formatsAtIndex, index ) => {\n\t\tconst formatsAtPreviousIndex = newFormats[ index - 1 ];\n\n\t\tif ( formatsAtPreviousIndex ) {\n\t\t\tconst newFormatsAtIndex = formatsAtIndex.slice();\n\n\t\t\tnewFormatsAtIndex.forEach( ( format, formatIndex ) => {\n\t\t\t\tconst previousFormat = formatsAtPreviousIndex[ formatIndex ];\n\n\t\t\t\tif ( isFormatEqual( format, previousFormat ) ) {\n\t\t\t\t\tnewFormatsAtIndex[ formatIndex ] = previousFormat;\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\tnewFormats[ index ] = newFormatsAtIndex;\n\t\t}\n\t} );\n\n\treturn {\n\t\t...value,\n\t\tformats: newFormats,\n\t};\n}\n","/**\n * Internal dependencies\n */\n\nimport { normaliseFormats } from './normalise-formats';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n/** @typedef {import('./types').RichTextFormat} RichTextFormat */\n\nfunction replace( array, index, value ) {\n\tarray = array.slice();\n\tarray[ index ] = value;\n\treturn array;\n}\n\n/**\n * Apply a format object to a Rich Text value from the given `startIndex` to the\n * given `endIndex`. Indices are retrieved from the selection if none are\n * provided.\n *\n * @param {RichTextValue}  value        Value to modify.\n * @param {RichTextFormat} format       Format to apply.\n * @param {number}         [startIndex] Start index.\n * @param {number}         [endIndex]   End index.\n *\n * @return {RichTextValue} A new value with the format applied.\n */\nexport function applyFormat(\n\tvalue,\n\tformat,\n\tstartIndex = value.start,\n\tendIndex = value.end\n) {\n\tconst { formats, activeFormats } = value;\n\tconst newFormats = formats.slice();\n\n\t// The selection is collapsed.\n\tif ( startIndex === endIndex ) {\n\t\tconst startFormat = newFormats[ startIndex ]?.find(\n\t\t\t( { type } ) => type === format.type\n\t\t);\n\n\t\t// If the caret is at a format of the same type, expand start and end to\n\t\t// the edges of the format. This is useful to apply new attributes.\n\t\tif ( startFormat ) {\n\t\t\tconst index = newFormats[ startIndex ].indexOf( startFormat );\n\n\t\t\twhile (\n\t\t\t\tnewFormats[ startIndex ] &&\n\t\t\t\tnewFormats[ startIndex ][ index ] === startFormat\n\t\t\t) {\n\t\t\t\tnewFormats[ startIndex ] = replace(\n\t\t\t\t\tnewFormats[ startIndex ],\n\t\t\t\t\tindex,\n\t\t\t\t\tformat\n\t\t\t\t);\n\t\t\t\tstartIndex--;\n\t\t\t}\n\n\t\t\tendIndex++;\n\n\t\t\twhile (\n\t\t\t\tnewFormats[ endIndex ] &&\n\t\t\t\tnewFormats[ endIndex ][ index ] === startFormat\n\t\t\t) {\n\t\t\t\tnewFormats[ endIndex ] = replace(\n\t\t\t\t\tnewFormats[ endIndex ],\n\t\t\t\t\tindex,\n\t\t\t\t\tformat\n\t\t\t\t);\n\t\t\t\tendIndex++;\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// Determine the highest position the new format can be inserted at.\n\t\tlet position = +Infinity;\n\n\t\tfor ( let index = startIndex; index < endIndex; index++ ) {\n\t\t\tif ( newFormats[ index ] ) {\n\t\t\t\tnewFormats[ index ] = newFormats[ index ].filter(\n\t\t\t\t\t( { type } ) => type !== format.type\n\t\t\t\t);\n\n\t\t\t\tconst length = newFormats[ index ].length;\n\n\t\t\t\tif ( length < position ) {\n\t\t\t\t\tposition = length;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tnewFormats[ index ] = [];\n\t\t\t\tposition = 0;\n\t\t\t}\n\t\t}\n\n\t\tfor ( let index = startIndex; index < endIndex; index++ ) {\n\t\t\tnewFormats[ index ].splice( position, 0, format );\n\t\t}\n\t}\n\n\treturn normaliseFormats( {\n\t\t...value,\n\t\tformats: newFormats,\n\t\t// Always revise active formats. This serves as a placeholder for new\n\t\t// inputs with the format so new input appears with the format applied,\n\t\t// and ensures a format of the same type uses the latest values.\n\t\tactiveFormats: [\n\t\t\t...( activeFormats?.filter(\n\t\t\t\t( { type } ) => type !== format.type\n\t\t\t) || [] ),\n\t\t\tformat,\n\t\t],\n\t} );\n}\n","/**\n * Parse the given HTML into a body element.\n *\n * Note: The current implementation will return a shared reference, reset on\n * each call to `createElement`. Therefore, you should not hold a reference to\n * the value to operate upon asynchronously, as it may have unexpected results.\n *\n * @param {HTMLDocument} document The HTML document to use to parse.\n * @param {string}       html     The HTML to parse.\n *\n * @return {HTMLBodyElement} Body element with parsed HTML.\n */\nexport function createElement( { implementation }, html ) {\n\t// Because `createHTMLDocument` is an expensive operation, and with this\n\t// function being internal to `rich-text` (full control in avoiding a risk\n\t// of asynchronous operations on the shared reference), a single document\n\t// is reused and reset for each call to the function.\n\tif ( ! createElement.body ) {\n\t\tcreateElement.body = implementation.createHTMLDocument( '' ).body;\n\t}\n\n\tcreateElement.body.innerHTML = html;\n\n\treturn createElement.body;\n}\n","/**\n * Object replacement character, used as a placeholder for objects.\n */\nexport const OBJECT_REPLACEMENT_CHARACTER = '\\ufffc';\n\n/**\n * Zero width non-breaking space, used as padding in the editable DOM tree when\n * it is empty otherwise.\n */\nexport const ZWNBSP = '\\ufeff';\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"escapeHtml\"];","/** @typedef {import('./types').RichTextValue} RichTextValue */\n/** @typedef {import('./types').RichTextFormatList} RichTextFormatList */\n\n/**\n * Internal dependencies\n */\nimport { isFormatEqual } from './is-format-equal';\n\n/**\n * Gets the all format objects at the start of the selection.\n *\n * @param {RichTextValue} value                Value to inspect.\n * @param {Array}         EMPTY_ACTIVE_FORMATS Array to return if there are no\n *                                             active formats.\n *\n * @return {RichTextFormatList} Active format objects.\n */\nexport function getActiveFormats( value, EMPTY_ACTIVE_FORMATS = [] ) {\n\tconst { formats, start, end, activeFormats } = value;\n\tif ( start === undefined ) {\n\t\treturn EMPTY_ACTIVE_FORMATS;\n\t}\n\n\tif ( start === end ) {\n\t\t// For a collapsed caret, it is possible to override the active formats.\n\t\tif ( activeFormats ) {\n\t\t\treturn activeFormats;\n\t\t}\n\n\t\tconst formatsBefore = formats[ start - 1 ] || EMPTY_ACTIVE_FORMATS;\n\t\tconst formatsAfter = formats[ start ] || EMPTY_ACTIVE_FORMATS;\n\n\t\t// By default, select the lowest amount of formats possible (which means\n\t\t// the caret is positioned outside the format boundary). The user can\n\t\t// then use arrow keys to define `activeFormats`.\n\t\tif ( formatsBefore.length < formatsAfter.length ) {\n\t\t\treturn formatsBefore;\n\t\t}\n\n\t\treturn formatsAfter;\n\t}\n\n\t// If there's no formats at the start index, there are not active formats.\n\tif ( ! formats[ start ] ) {\n\t\treturn EMPTY_ACTIVE_FORMATS;\n\t}\n\n\tconst selectedFormats = formats.slice( start, end );\n\n\t// Clone the formats so we're not mutating the live value.\n\tconst _activeFormats = [ ...selectedFormats[ 0 ] ];\n\tlet i = selectedFormats.length;\n\n\t// For performance reasons, start from the end where it's much quicker to\n\t// realise that there are no active formats.\n\twhile ( i-- ) {\n\t\tconst formatsAtIndex = selectedFormats[ i ];\n\n\t\t// If we run into any index without formats, we're sure that there's no\n\t\t// active formats.\n\t\tif ( ! formatsAtIndex ) {\n\t\t\treturn EMPTY_ACTIVE_FORMATS;\n\t\t}\n\n\t\tlet ii = _activeFormats.length;\n\n\t\t// Loop over the active formats and remove any that are not present at\n\t\t// the current index.\n\t\twhile ( ii-- ) {\n\t\t\tconst format = _activeFormats[ ii ];\n\n\t\t\tif (\n\t\t\t\t! formatsAtIndex.find( ( _format ) =>\n\t\t\t\t\tisFormatEqual( format, _format )\n\t\t\t\t)\n\t\t\t) {\n\t\t\t\t_activeFormats.splice( ii, 1 );\n\t\t\t}\n\t\t}\n\n\t\t// If there are no active formats, we can stop.\n\t\tif ( _activeFormats.length === 0 ) {\n\t\t\treturn EMPTY_ACTIVE_FORMATS;\n\t\t}\n\t}\n\n\treturn _activeFormats || EMPTY_ACTIVE_FORMATS;\n}\n","/**\n * WordPress dependencies\n */\nimport { select } from '@wordpress/data';\n/**\n * Internal dependencies\n */\nimport { store as richTextStore } from './store';\n\n/** @typedef {import('./register-format-type').RichTextFormatType} RichTextFormatType */\n\n/**\n * Returns a registered format type.\n *\n * @param {string} name Format name.\n *\n * @return {RichTextFormatType|undefined} Format type.\n */\nexport function getFormatType( name ) {\n\treturn select( richTextStore ).getFormatType( name );\n}\n","/**\n * Internal dependencies\n */\n\nimport { getActiveFormats } from './get-active-formats';\nimport { getFormatType } from './get-format-type';\nimport { OBJECT_REPLACEMENT_CHARACTER, ZWNBSP } from './special-characters';\n\nfunction restoreOnAttributes( attributes, isEditableTree ) {\n\tif ( isEditableTree ) {\n\t\treturn attributes;\n\t}\n\n\tconst newAttributes = {};\n\n\tfor ( const key in attributes ) {\n\t\tlet newKey = key;\n\t\tif ( key.startsWith( 'data-disable-rich-text-' ) ) {\n\t\t\tnewKey = key.slice( 'data-disable-rich-text-'.length );\n\t\t}\n\n\t\tnewAttributes[ newKey ] = attributes[ key ];\n\t}\n\n\treturn newAttributes;\n}\n\n/**\n * Converts a format object to information that can be used to create an element\n * from (type, attributes and object).\n *\n * @param {Object}  $1                        Named parameters.\n * @param {string}  $1.type                   The format type.\n * @param {string}  $1.tagName                The tag name.\n * @param {Object}  $1.attributes             The format attributes.\n * @param {Object}  $1.unregisteredAttributes The unregistered format\n *                                            attributes.\n * @param {boolean} $1.object                 Whether or not it is an object\n *                                            format.\n * @param {boolean} $1.boundaryClass          Whether or not to apply a boundary\n *                                            class.\n * @param {boolean} $1.isEditableTree\n *\n * @return {Object} Information to be used for element creation.\n */\nfunction fromFormat( {\n\ttype,\n\ttagName,\n\tattributes,\n\tunregisteredAttributes,\n\tobject,\n\tboundaryClass,\n\tisEditableTree,\n} ) {\n\tconst formatType = getFormatType( type );\n\n\tlet elementAttributes = {};\n\n\tif ( boundaryClass && isEditableTree ) {\n\t\telementAttributes[ 'data-rich-text-format-boundary' ] = 'true';\n\t}\n\n\tif ( ! formatType ) {\n\t\tif ( attributes ) {\n\t\t\telementAttributes = { ...attributes, ...elementAttributes };\n\t\t}\n\n\t\treturn {\n\t\t\ttype,\n\t\t\tattributes: restoreOnAttributes(\n\t\t\t\telementAttributes,\n\t\t\t\tisEditableTree\n\t\t\t),\n\t\t\tobject,\n\t\t};\n\t}\n\n\telementAttributes = { ...unregisteredAttributes, ...elementAttributes };\n\n\tfor ( const name in attributes ) {\n\t\tconst key = formatType.attributes\n\t\t\t? formatType.attributes[ name ]\n\t\t\t: false;\n\n\t\tif ( key ) {\n\t\t\telementAttributes[ key ] = attributes[ name ];\n\t\t} else {\n\t\t\telementAttributes[ name ] = attributes[ name ];\n\t\t}\n\t}\n\n\tif ( formatType.className ) {\n\t\tif ( elementAttributes.class ) {\n\t\t\telementAttributes.class = `${ formatType.className } ${ elementAttributes.class }`;\n\t\t} else {\n\t\t\telementAttributes.class = formatType.className;\n\t\t}\n\t}\n\n\t// When a format is declared as non editable, make it non editable in the\n\t// editor.\n\tif ( isEditableTree && formatType.contentEditable === false ) {\n\t\telementAttributes.contenteditable = 'false';\n\t}\n\n\treturn {\n\t\ttype: tagName || formatType.tagName,\n\t\tobject: formatType.object,\n\t\tattributes: restoreOnAttributes( elementAttributes, isEditableTree ),\n\t};\n}\n\n/**\n * Checks if both arrays of formats up until a certain index are equal.\n *\n * @param {Array}  a     Array of formats to compare.\n * @param {Array}  b     Array of formats to compare.\n * @param {number} index Index to check until.\n */\nfunction isEqualUntil( a, b, index ) {\n\tdo {\n\t\tif ( a[ index ] !== b[ index ] ) {\n\t\t\treturn false;\n\t\t}\n\t} while ( index-- );\n\n\treturn true;\n}\n\nexport function toTree( {\n\tvalue,\n\tpreserveWhiteSpace,\n\tcreateEmpty,\n\tappend,\n\tgetLastChild,\n\tgetParent,\n\tisText,\n\tgetText,\n\tremove,\n\tappendText,\n\tonStartIndex,\n\tonEndIndex,\n\tisEditableTree,\n\tplaceholder,\n} ) {\n\tconst { formats, replacements, text, start, end } = value;\n\tconst formatsLength = formats.length + 1;\n\tconst tree = createEmpty();\n\tconst activeFormats = getActiveFormats( value );\n\tconst deepestActiveFormat = activeFormats[ activeFormats.length - 1 ];\n\n\tlet lastCharacterFormats;\n\tlet lastCharacter;\n\n\tappend( tree, '' );\n\n\tfor ( let i = 0; i < formatsLength; i++ ) {\n\t\tconst character = text.charAt( i );\n\t\tconst shouldInsertPadding =\n\t\t\tisEditableTree &&\n\t\t\t// Pad the line if the line is empty.\n\t\t\t( ! lastCharacter ||\n\t\t\t\t// Pad the line if the previous character is a line break, otherwise\n\t\t\t\t// the line break won't be visible.\n\t\t\t\tlastCharacter === '\\n' );\n\n\t\tconst characterFormats = formats[ i ];\n\t\tlet pointer = getLastChild( tree );\n\n\t\tif ( characterFormats ) {\n\t\t\tcharacterFormats.forEach( ( format, formatIndex ) => {\n\t\t\t\tif (\n\t\t\t\t\tpointer &&\n\t\t\t\t\tlastCharacterFormats &&\n\t\t\t\t\t// Reuse the last element if all formats remain the same.\n\t\t\t\t\tisEqualUntil(\n\t\t\t\t\t\tcharacterFormats,\n\t\t\t\t\t\tlastCharacterFormats,\n\t\t\t\t\t\tformatIndex\n\t\t\t\t\t)\n\t\t\t\t) {\n\t\t\t\t\tpointer = getLastChild( pointer );\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tconst { type, tagName, attributes, unregisteredAttributes } =\n\t\t\t\t\tformat;\n\n\t\t\t\tconst boundaryClass =\n\t\t\t\t\tisEditableTree && format === deepestActiveFormat;\n\n\t\t\t\tconst parent = getParent( pointer );\n\t\t\t\tconst newNode = append(\n\t\t\t\t\tparent,\n\t\t\t\t\tfromFormat( {\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\ttagName,\n\t\t\t\t\t\tattributes,\n\t\t\t\t\t\tunregisteredAttributes,\n\t\t\t\t\t\tboundaryClass,\n\t\t\t\t\t\tisEditableTree,\n\t\t\t\t\t} )\n\t\t\t\t);\n\n\t\t\t\tif ( isText( pointer ) && getText( pointer ).length === 0 ) {\n\t\t\t\t\tremove( pointer );\n\t\t\t\t}\n\n\t\t\t\tpointer = append( newNode, '' );\n\t\t\t} );\n\t\t}\n\n\t\t// If there is selection at 0, handle it before characters are inserted.\n\t\tif ( i === 0 ) {\n\t\t\tif ( onStartIndex && start === 0 ) {\n\t\t\t\tonStartIndex( tree, pointer );\n\t\t\t}\n\n\t\t\tif ( onEndIndex && end === 0 ) {\n\t\t\t\tonEndIndex( tree, pointer );\n\t\t\t}\n\t\t}\n\n\t\tif ( character === OBJECT_REPLACEMENT_CHARACTER ) {\n\t\t\tconst replacement = replacements[ i ];\n\t\t\tif ( ! replacement ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst { type, attributes, innerHTML } = replacement;\n\t\t\tconst formatType = getFormatType( type );\n\n\t\t\tif ( ! isEditableTree && type === 'script' ) {\n\t\t\t\tpointer = append(\n\t\t\t\t\tgetParent( pointer ),\n\t\t\t\t\tfromFormat( {\n\t\t\t\t\t\ttype: 'script',\n\t\t\t\t\t\tisEditableTree,\n\t\t\t\t\t} )\n\t\t\t\t);\n\t\t\t\tappend( pointer, {\n\t\t\t\t\thtml: decodeURIComponent(\n\t\t\t\t\t\tattributes[ 'data-rich-text-script' ]\n\t\t\t\t\t),\n\t\t\t\t} );\n\t\t\t} else if ( formatType?.contentEditable === false ) {\n\t\t\t\t// For non editable formats, render the stored inner HTML.\n\t\t\t\tpointer = append(\n\t\t\t\t\tgetParent( pointer ),\n\t\t\t\t\tfromFormat( {\n\t\t\t\t\t\t...replacement,\n\t\t\t\t\t\tisEditableTree,\n\t\t\t\t\t\tboundaryClass: start === i && end === i + 1,\n\t\t\t\t\t} )\n\t\t\t\t);\n\n\t\t\t\tif ( innerHTML ) {\n\t\t\t\t\tappend( pointer, {\n\t\t\t\t\t\thtml: innerHTML,\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tpointer = append(\n\t\t\t\t\tgetParent( pointer ),\n\t\t\t\t\tfromFormat( {\n\t\t\t\t\t\t...replacement,\n\t\t\t\t\t\tobject: true,\n\t\t\t\t\t\tisEditableTree,\n\t\t\t\t\t} )\n\t\t\t\t);\n\t\t\t}\n\t\t\t// Ensure pointer is text node.\n\t\t\tpointer = append( getParent( pointer ), '' );\n\t\t} else if ( ! preserveWhiteSpace && character === '\\n' ) {\n\t\t\tpointer = append( getParent( pointer ), {\n\t\t\t\ttype: 'br',\n\t\t\t\tattributes: isEditableTree\n\t\t\t\t\t? {\n\t\t\t\t\t\t\t'data-rich-text-line-break': 'true',\n\t\t\t\t\t  }\n\t\t\t\t\t: undefined,\n\t\t\t\tobject: true,\n\t\t\t} );\n\t\t\t// Ensure pointer is text node.\n\t\t\tpointer = append( getParent( pointer ), '' );\n\t\t} else if ( ! isText( pointer ) ) {\n\t\t\tpointer = append( getParent( pointer ), character );\n\t\t} else {\n\t\t\tappendText( pointer, character );\n\t\t}\n\n\t\tif ( onStartIndex && start === i + 1 ) {\n\t\t\tonStartIndex( tree, pointer );\n\t\t}\n\n\t\tif ( onEndIndex && end === i + 1 ) {\n\t\t\tonEndIndex( tree, pointer );\n\t\t}\n\n\t\tif ( shouldInsertPadding && i === text.length ) {\n\t\t\tappend( getParent( pointer ), ZWNBSP );\n\n\t\t\t// We CANNOT use CSS to add a placeholder with pseudo elements on\n\t\t\t// the main block wrappers because that could clash with theme CSS.\n\t\t\tif ( placeholder && text.length === 0 ) {\n\t\t\t\tappend( getParent( pointer ), {\n\t\t\t\t\ttype: 'span',\n\t\t\t\t\tattributes: {\n\t\t\t\t\t\t'data-rich-text-placeholder': placeholder,\n\t\t\t\t\t\t// Necessary to prevent the placeholder from catching\n\t\t\t\t\t\t// selection and being editable.\n\t\t\t\t\t\tstyle: 'pointer-events:none;user-select:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;',\n\t\t\t\t\t},\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\n\t\tlastCharacterFormats = characterFormats;\n\t\tlastCharacter = character;\n\t}\n\n\treturn tree;\n}\n","/**\n * WordPress dependencies\n */\n\nimport {\n\tescapeEditableHTML,\n\tescapeAttribute,\n\tisValidAttributeName,\n} from '@wordpress/escape-html';\n\n/**\n * Internal dependencies\n */\n\nimport { toTree } from './to-tree';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Create an HTML string from a Rich Text value.\n *\n * @param {Object}        $1                      Named arguments.\n * @param {RichTextValue} $1.value                Rich text value.\n * @param {boolean}       [$1.preserveWhiteSpace] Preserves newlines if true.\n *\n * @return {string} HTML string.\n */\nexport function toHTMLString( { value, preserveWhiteSpace } ) {\n\tconst tree = toTree( {\n\t\tvalue,\n\t\tpreserveWhiteSpace,\n\t\tcreateEmpty,\n\t\tappend,\n\t\tgetLastChild,\n\t\tgetParent,\n\t\tisText,\n\t\tgetText,\n\t\tremove,\n\t\tappendText,\n\t} );\n\n\treturn createChildrenHTML( tree.children );\n}\n\nfunction createEmpty() {\n\treturn {};\n}\n\nfunction getLastChild( { children } ) {\n\treturn children && children[ children.length - 1 ];\n}\n\nfunction append( parent, object ) {\n\tif ( typeof object === 'string' ) {\n\t\tobject = { text: object };\n\t}\n\n\tobject.parent = parent;\n\tparent.children = parent.children || [];\n\tparent.children.push( object );\n\treturn object;\n}\n\nfunction appendText( object, text ) {\n\tobject.text += text;\n}\n\nfunction getParent( { parent } ) {\n\treturn parent;\n}\n\nfunction isText( { text } ) {\n\treturn typeof text === 'string';\n}\n\nfunction getText( { text } ) {\n\treturn text;\n}\n\nfunction remove( object ) {\n\tconst index = object.parent.children.indexOf( object );\n\n\tif ( index !== -1 ) {\n\t\tobject.parent.children.splice( index, 1 );\n\t}\n\n\treturn object;\n}\n\nfunction createElementHTML( { type, attributes, object, children } ) {\n\tlet attributeString = '';\n\n\tfor ( const key in attributes ) {\n\t\tif ( ! isValidAttributeName( key ) ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tattributeString += ` ${ key }=\"${ escapeAttribute(\n\t\t\tattributes[ key ]\n\t\t) }\"`;\n\t}\n\n\tif ( object ) {\n\t\treturn `<${ type }${ attributeString }>`;\n\t}\n\n\treturn `<${ type }${ attributeString }>${ createChildrenHTML(\n\t\tchildren\n\t) }</${ type }>`;\n}\n\nfunction createChildrenHTML( children = [] ) {\n\treturn children\n\t\t.map( ( child ) => {\n\t\t\tif ( child.html !== undefined ) {\n\t\t\t\treturn child.html;\n\t\t\t}\n\n\t\t\treturn child.text === undefined\n\t\t\t\t? createElementHTML( child )\n\t\t\t\t: escapeEditableHTML( child.text );\n\t\t} )\n\t\t.join( '' );\n}\n","/**\n * Internal dependencies\n */\nimport { OBJECT_REPLACEMENT_CHARACTER } from './special-characters';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Get the textual content of a Rich Text value. This is similar to\n * `Element.textContent`.\n *\n * @param {RichTextValue} value Value to use.\n *\n * @return {string} The text content.\n */\nexport function getTextContent( { text } ) {\n\treturn text.replace( OBJECT_REPLACEMENT_CHARACTER, '' );\n}\n","/**\n * WordPress dependencies\n */\nimport { select } from '@wordpress/data';\n\n/**\n * Internal dependencies\n */\nimport { store as richTextStore } from './store';\nimport { createElement } from './create-element';\nimport { mergePair } from './concat';\nimport { OBJECT_REPLACEMENT_CHARACTER, ZWNBSP } from './special-characters';\nimport { toHTMLString } from './to-html-string';\nimport { getTextContent } from './get-text-content';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\nfunction createEmptyValue() {\n\treturn {\n\t\tformats: [],\n\t\treplacements: [],\n\t\ttext: '',\n\t};\n}\n\nfunction toFormat( { tagName, attributes } ) {\n\tlet formatType;\n\n\tif ( attributes && attributes.class ) {\n\t\tformatType = select( richTextStore ).getFormatTypeForClassName(\n\t\t\tattributes.class\n\t\t);\n\n\t\tif ( formatType ) {\n\t\t\t// Preserve any additional classes.\n\t\t\tattributes.class = ` ${ attributes.class } `\n\t\t\t\t.replace( ` ${ formatType.className } `, ' ' )\n\t\t\t\t.trim();\n\n\t\t\tif ( ! attributes.class ) {\n\t\t\t\tdelete attributes.class;\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( ! formatType ) {\n\t\tformatType =\n\t\t\tselect( richTextStore ).getFormatTypeForBareElement( tagName );\n\t}\n\n\tif ( ! formatType ) {\n\t\treturn attributes ? { type: tagName, attributes } : { type: tagName };\n\t}\n\n\tif (\n\t\tformatType.__experimentalCreatePrepareEditableTree &&\n\t\t! formatType.__experimentalCreateOnChangeEditableValue\n\t) {\n\t\treturn null;\n\t}\n\n\tif ( ! attributes ) {\n\t\treturn { formatType, type: formatType.name, tagName };\n\t}\n\n\tconst registeredAttributes = {};\n\tconst unregisteredAttributes = {};\n\tconst _attributes = { ...attributes };\n\n\tfor ( const key in formatType.attributes ) {\n\t\tconst name = formatType.attributes[ key ];\n\n\t\tregisteredAttributes[ key ] = _attributes[ name ];\n\n\t\t// delete the attribute and what's left is considered\n\t\t// to be unregistered.\n\t\tdelete _attributes[ name ];\n\n\t\tif ( typeof registeredAttributes[ key ] === 'undefined' ) {\n\t\t\tdelete registeredAttributes[ key ];\n\t\t}\n\t}\n\n\tfor ( const name in _attributes ) {\n\t\tunregisteredAttributes[ name ] = attributes[ name ];\n\t}\n\n\tif ( formatType.contentEditable === false ) {\n\t\tdelete unregisteredAttributes.contenteditable;\n\t}\n\n\treturn {\n\t\tformatType,\n\t\ttype: formatType.name,\n\t\ttagName,\n\t\tattributes: registeredAttributes,\n\t\tunregisteredAttributes,\n\t};\n}\n\n/**\n * The RichTextData class is used to instantiate a wrapper around rich text\n * values, with methods that can be used to transform or manipulate the data.\n *\n * - Create an empty instance: `new RichTextData()`.\n * - Create one from an HTML string: `RichTextData.fromHTMLString(\n *   '<em>hello</em>' )`.\n * - Create one from a wrapper HTMLElement: `RichTextData.fromHTMLElement(\n *   document.querySelector( 'p' ) )`.\n * - Create one from plain text: `RichTextData.fromPlainText( '1\\n2' )`.\n * - Create one from a rich text value: `new RichTextData( { text: '...',\n *   formats: [ ... ] } )`.\n *\n * @todo Add methods to manipulate the data, such as applyFormat, slice etc.\n */\nexport class RichTextData {\n\t#value;\n\n\tstatic empty() {\n\t\treturn new RichTextData();\n\t}\n\tstatic fromPlainText( text ) {\n\t\treturn new RichTextData( create( { text } ) );\n\t}\n\tstatic fromHTMLString( html ) {\n\t\treturn new RichTextData( create( { html } ) );\n\t}\n\tstatic fromHTMLElement( htmlElement, options = {} ) {\n\t\tconst { preserveWhiteSpace = false } = options;\n\t\tconst element = preserveWhiteSpace\n\t\t\t? htmlElement\n\t\t\t: collapseWhiteSpace( htmlElement );\n\t\tconst richTextData = new RichTextData( create( { element } ) );\n\t\tObject.defineProperty( richTextData, 'originalHTML', {\n\t\t\tvalue: htmlElement.innerHTML,\n\t\t} );\n\t\treturn richTextData;\n\t}\n\tconstructor( init = createEmptyValue() ) {\n\t\tthis.#value = init;\n\t}\n\ttoPlainText() {\n\t\treturn getTextContent( this.#value );\n\t}\n\t// We could expose `toHTMLElement` at some point as well, but we'd only use\n\t// it internally.\n\ttoHTMLString( { preserveWhiteSpace } = {} ) {\n\t\treturn (\n\t\t\tthis.originalHTML ||\n\t\t\ttoHTMLString( { value: this.#value, preserveWhiteSpace } )\n\t\t);\n\t}\n\tvalueOf() {\n\t\treturn this.toHTMLString();\n\t}\n\ttoString() {\n\t\treturn this.toHTMLString();\n\t}\n\ttoJSON() {\n\t\treturn this.toHTMLString();\n\t}\n\tget length() {\n\t\treturn this.text.length;\n\t}\n\tget formats() {\n\t\treturn this.#value.formats;\n\t}\n\tget replacements() {\n\t\treturn this.#value.replacements;\n\t}\n\tget text() {\n\t\treturn this.#value.text;\n\t}\n}\n\nfor ( const name of Object.getOwnPropertyNames( String.prototype ) ) {\n\tif ( RichTextData.prototype.hasOwnProperty( name ) ) {\n\t\tcontinue;\n\t}\n\n\tObject.defineProperty( RichTextData.prototype, name, {\n\t\tvalue( ...args ) {\n\t\t\t// Should we convert back to RichTextData?\n\t\t\treturn this.toHTMLString()[ name ]( ...args );\n\t\t},\n\t} );\n}\n\n/**\n * Create a RichText value from an `Element` tree (DOM), an HTML string or a\n * plain text string, with optionally a `Range` object to set the selection. If\n * called without any input, an empty value will be created. The optional\n * functions can be used to filter out content.\n *\n * A value will have the following shape, which you are strongly encouraged not\n * to modify without the use of helper functions:\n *\n * ```js\n * {\n *   text: string,\n *   formats: Array,\n *   replacements: Array,\n *   ?start: number,\n *   ?end: number,\n * }\n * ```\n *\n * As you can see, text and formatting are separated. `text` holds the text,\n * including any replacement characters for objects and lines. `formats`,\n * `objects` and `lines` are all sparse arrays of the same length as `text`. It\n * holds information about the formatting at the relevant text indices. Finally\n * `start` and `end` state which text indices are selected. They are only\n * provided if a `Range` was given.\n *\n * @param {Object}  [$1]                          Optional named arguments.\n * @param {Element} [$1.element]                  Element to create value from.\n * @param {string}  [$1.text]                     Text to create value from.\n * @param {string}  [$1.html]                     HTML to create value from.\n * @param {Range}   [$1.range]                    Range to create value from.\n * @param {boolean} [$1.__unstableIsEditableTree]\n * @return {RichTextValue} A rich text value.\n */\nexport function create( {\n\telement,\n\ttext,\n\thtml,\n\trange,\n\t__unstableIsEditableTree: isEditableTree,\n} = {} ) {\n\tif ( html instanceof RichTextData ) {\n\t\treturn {\n\t\t\ttext: html.text,\n\t\t\tformats: html.formats,\n\t\t\treplacements: html.replacements,\n\t\t};\n\t}\n\n\tif ( typeof text === 'string' && text.length > 0 ) {\n\t\treturn {\n\t\t\tformats: Array( text.length ),\n\t\t\treplacements: Array( text.length ),\n\t\t\ttext,\n\t\t};\n\t}\n\n\tif ( typeof html === 'string' && html.length > 0 ) {\n\t\t// It does not matter which document this is, we're just using it to\n\t\t// parse.\n\t\telement = createElement( document, html );\n\t}\n\n\tif ( typeof element !== 'object' ) {\n\t\treturn createEmptyValue();\n\t}\n\n\treturn createFromElement( {\n\t\telement,\n\t\trange,\n\t\tisEditableTree,\n\t} );\n}\n\n/**\n * Helper to accumulate the value's selection start and end from the current\n * node and range.\n *\n * @param {Object} accumulator Object to accumulate into.\n * @param {Node}   node        Node to create value with.\n * @param {Range}  range       Range to create value with.\n * @param {Object} value       Value that is being accumulated.\n */\nfunction accumulateSelection( accumulator, node, range, value ) {\n\tif ( ! range ) {\n\t\treturn;\n\t}\n\n\tconst { parentNode } = node;\n\tconst { startContainer, startOffset, endContainer, endOffset } = range;\n\tconst currentLength = accumulator.text.length;\n\n\t// Selection can be extracted from value.\n\tif ( value.start !== undefined ) {\n\t\taccumulator.start = currentLength + value.start;\n\t\t// Range indicates that the current node has selection.\n\t} else if ( node === startContainer && node.nodeType === node.TEXT_NODE ) {\n\t\taccumulator.start = currentLength + startOffset;\n\t\t// Range indicates that the current node is selected.\n\t} else if (\n\t\tparentNode === startContainer &&\n\t\tnode === startContainer.childNodes[ startOffset ]\n\t) {\n\t\taccumulator.start = currentLength;\n\t\t// Range indicates that the selection is after the current node.\n\t} else if (\n\t\tparentNode === startContainer &&\n\t\tnode === startContainer.childNodes[ startOffset - 1 ]\n\t) {\n\t\taccumulator.start = currentLength + value.text.length;\n\t\t// Fallback if no child inside handled the selection.\n\t} else if ( node === startContainer ) {\n\t\taccumulator.start = currentLength;\n\t}\n\n\t// Selection can be extracted from value.\n\tif ( value.end !== undefined ) {\n\t\taccumulator.end = currentLength + value.end;\n\t\t// Range indicates that the current node has selection.\n\t} else if ( node === endContainer && node.nodeType === node.TEXT_NODE ) {\n\t\taccumulator.end = currentLength + endOffset;\n\t\t// Range indicates that the current node is selected.\n\t} else if (\n\t\tparentNode === endContainer &&\n\t\tnode === endContainer.childNodes[ endOffset - 1 ]\n\t) {\n\t\taccumulator.end = currentLength + value.text.length;\n\t\t// Range indicates that the selection is before the current node.\n\t} else if (\n\t\tparentNode === endContainer &&\n\t\tnode === endContainer.childNodes[ endOffset ]\n\t) {\n\t\taccumulator.end = currentLength;\n\t\t// Fallback if no child inside handled the selection.\n\t} else if ( node === endContainer ) {\n\t\taccumulator.end = currentLength + endOffset;\n\t}\n}\n\n/**\n * Adjusts the start and end offsets from a range based on a text filter.\n *\n * @param {Node}     node   Node of which the text should be filtered.\n * @param {Range}    range  The range to filter.\n * @param {Function} filter Function to use to filter the text.\n *\n * @return {Object|void} Object containing range properties.\n */\nfunction filterRange( node, range, filter ) {\n\tif ( ! range ) {\n\t\treturn;\n\t}\n\n\tconst { startContainer, endContainer } = range;\n\tlet { startOffset, endOffset } = range;\n\n\tif ( node === startContainer ) {\n\t\tstartOffset = filter( node.nodeValue.slice( 0, startOffset ) ).length;\n\t}\n\n\tif ( node === endContainer ) {\n\t\tendOffset = filter( node.nodeValue.slice( 0, endOffset ) ).length;\n\t}\n\n\treturn { startContainer, startOffset, endContainer, endOffset };\n}\n\n/**\n * Collapse any whitespace used for HTML formatting to one space character,\n * because it will also be displayed as such by the browser.\n *\n * We need to strip it from the content because we use white-space: pre-wrap for\n * displaying editable rich text. Without using white-space: pre-wrap, the\n * browser will litter the content with non breaking spaces, among other issues.\n * See packages/rich-text/src/component/use-default-style.js.\n *\n * @see\n * https://developer.mozilla.org/en-US/docs/Web/CSS/white-space-collapse#collapsing_of_white_space\n *\n * @param {HTMLElement} element\n * @param {boolean}     isRoot\n *\n * @return {HTMLElement} New element with collapsed whitespace.\n */\nfunction collapseWhiteSpace( element, isRoot = true ) {\n\tconst clone = element.cloneNode( true );\n\tclone.normalize();\n\tArray.from( clone.childNodes ).forEach( ( node, i, nodes ) => {\n\t\tif ( node.nodeType === node.TEXT_NODE ) {\n\t\t\tlet newNodeValue = node.nodeValue;\n\n\t\t\tif ( /[\\n\\t\\r\\f]/.test( newNodeValue ) ) {\n\t\t\t\tnewNodeValue = newNodeValue.replace( /[\\n\\t\\r\\f]+/g, ' ' );\n\t\t\t}\n\n\t\t\tif ( newNodeValue.indexOf( '  ' ) !== -1 ) {\n\t\t\t\tnewNodeValue = newNodeValue.replace( / {2,}/g, ' ' );\n\t\t\t}\n\n\t\t\tif ( i === 0 && newNodeValue.startsWith( ' ' ) ) {\n\t\t\t\tnewNodeValue = newNodeValue.slice( 1 );\n\t\t\t} else if (\n\t\t\t\tisRoot &&\n\t\t\t\ti === nodes.length - 1 &&\n\t\t\t\tnewNodeValue.endsWith( ' ' )\n\t\t\t) {\n\t\t\t\tnewNodeValue = newNodeValue.slice( 0, -1 );\n\t\t\t}\n\n\t\t\tnode.nodeValue = newNodeValue;\n\t\t} else if ( node.nodeType === node.ELEMENT_NODE ) {\n\t\t\tcollapseWhiteSpace( node, false );\n\t\t}\n\t} );\n\treturn clone;\n}\n\n/**\n * We need to normalise line breaks to `\\n` so they are consistent across\n * platforms and serialised properly. Not removing \\r would cause it to\n * linger and result in double line breaks when whitespace is preserved.\n */\nconst CARRIAGE_RETURN = '\\r';\n\n/**\n * Removes reserved characters used by rich-text (zero width non breaking spaces\n * added by `toTree` and object replacement characters).\n *\n * @param {string} string\n */\nexport function removeReservedCharacters( string ) {\n\t// with the global flag, note that we should create a new regex each time OR\n\t// reset lastIndex state.\n\treturn string.replace(\n\t\tnew RegExp(\n\t\t\t`[${ ZWNBSP }${ OBJECT_REPLACEMENT_CHARACTER }${ CARRIAGE_RETURN }]`,\n\t\t\t'gu'\n\t\t),\n\t\t''\n\t);\n}\n\n/**\n * Creates a Rich Text value from a DOM element and range.\n *\n * @param {Object}  $1                  Named arguments.\n * @param {Element} [$1.element]        Element to create value from.\n * @param {Range}   [$1.range]          Range to create value from.\n * @param {boolean} [$1.isEditableTree]\n *\n * @return {RichTextValue} A rich text value.\n */\nfunction createFromElement( { element, range, isEditableTree } ) {\n\tconst accumulator = createEmptyValue();\n\n\tif ( ! element ) {\n\t\treturn accumulator;\n\t}\n\n\tif ( ! element.hasChildNodes() ) {\n\t\taccumulateSelection( accumulator, element, range, createEmptyValue() );\n\t\treturn accumulator;\n\t}\n\n\tconst length = element.childNodes.length;\n\n\t// Optimise for speed.\n\tfor ( let index = 0; index < length; index++ ) {\n\t\tconst node = element.childNodes[ index ];\n\t\tconst tagName = node.nodeName.toLowerCase();\n\n\t\tif ( node.nodeType === node.TEXT_NODE ) {\n\t\t\tconst text = removeReservedCharacters( node.nodeValue );\n\t\t\trange = filterRange( node, range, removeReservedCharacters );\n\t\t\taccumulateSelection( accumulator, node, range, { text } );\n\t\t\t// Create a sparse array of the same length as `text`, in which\n\t\t\t// formats can be added.\n\t\t\taccumulator.formats.length += text.length;\n\t\t\taccumulator.replacements.length += text.length;\n\t\t\taccumulator.text += text;\n\t\t\tcontinue;\n\t\t}\n\n\t\tif ( node.nodeType !== node.ELEMENT_NODE ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (\n\t\t\tisEditableTree &&\n\t\t\t// Ignore any line breaks that are not inserted by us.\n\t\t\ttagName === 'br' &&\n\t\t\t! node.getAttribute( 'data-rich-text-line-break' )\n\t\t) {\n\t\t\taccumulateSelection( accumulator, node, range, createEmptyValue() );\n\t\t\tcontinue;\n\t\t}\n\n\t\tif ( tagName === 'script' ) {\n\t\t\tconst value = {\n\t\t\t\tformats: [ , ],\n\t\t\t\treplacements: [\n\t\t\t\t\t{\n\t\t\t\t\t\ttype: tagName,\n\t\t\t\t\t\tattributes: {\n\t\t\t\t\t\t\t'data-rich-text-script':\n\t\t\t\t\t\t\t\tnode.getAttribute( 'data-rich-text-script' ) ||\n\t\t\t\t\t\t\t\tencodeURIComponent( node.innerHTML ),\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t\ttext: OBJECT_REPLACEMENT_CHARACTER,\n\t\t\t};\n\t\t\taccumulateSelection( accumulator, node, range, value );\n\t\t\tmergePair( accumulator, value );\n\t\t\tcontinue;\n\t\t}\n\n\t\tif ( tagName === 'br' ) {\n\t\t\taccumulateSelection( accumulator, node, range, createEmptyValue() );\n\t\t\tmergePair( accumulator, create( { text: '\\n' } ) );\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst format = toFormat( {\n\t\t\ttagName,\n\t\t\tattributes: getAttributes( { element: node } ),\n\t\t} );\n\n\t\t// When a format type is declared as not editable, replace it with an\n\t\t// object replacement character and preserve the inner HTML.\n\t\tif ( format?.formatType?.contentEditable === false ) {\n\t\t\tdelete format.formatType;\n\t\t\taccumulateSelection( accumulator, node, range, createEmptyValue() );\n\t\t\tmergePair( accumulator, {\n\t\t\t\tformats: [ , ],\n\t\t\t\treplacements: [\n\t\t\t\t\t{\n\t\t\t\t\t\t...format,\n\t\t\t\t\t\tinnerHTML: node.innerHTML,\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t\ttext: OBJECT_REPLACEMENT_CHARACTER,\n\t\t\t} );\n\t\t\tcontinue;\n\t\t}\n\n\t\tif ( format ) {\n\t\t\tdelete format.formatType;\n\t\t}\n\n\t\tconst value = createFromElement( {\n\t\t\telement: node,\n\t\t\trange,\n\t\t\tisEditableTree,\n\t\t} );\n\n\t\taccumulateSelection( accumulator, node, range, value );\n\n\t\t// Ignore any placeholders, but keep their content since the browser\n\t\t// might insert text inside them when the editable element is flex.\n\t\tif ( ! format || node.getAttribute( 'data-rich-text-placeholder' ) ) {\n\t\t\tmergePair( accumulator, value );\n\t\t} else if ( value.text.length === 0 ) {\n\t\t\tif ( format.attributes ) {\n\t\t\t\tmergePair( accumulator, {\n\t\t\t\t\tformats: [ , ],\n\t\t\t\t\treplacements: [ format ],\n\t\t\t\t\ttext: OBJECT_REPLACEMENT_CHARACTER,\n\t\t\t\t} );\n\t\t\t}\n\t\t} else {\n\t\t\t// Indices should share a reference to the same formats array.\n\t\t\t// Only create a new reference if `formats` changes.\n\t\t\tfunction mergeFormats( formats ) {\n\t\t\t\tif ( mergeFormats.formats === formats ) {\n\t\t\t\t\treturn mergeFormats.newFormats;\n\t\t\t\t}\n\n\t\t\t\tconst newFormats = formats\n\t\t\t\t\t? [ format, ...formats ]\n\t\t\t\t\t: [ format ];\n\n\t\t\t\tmergeFormats.formats = formats;\n\t\t\t\tmergeFormats.newFormats = newFormats;\n\n\t\t\t\treturn newFormats;\n\t\t\t}\n\n\t\t\t// Since the formats parameter can be `undefined`, preset\n\t\t\t// `mergeFormats` with a new reference.\n\t\t\tmergeFormats.newFormats = [ format ];\n\n\t\t\tmergePair( accumulator, {\n\t\t\t\t...value,\n\t\t\t\tformats: Array.from( value.formats, mergeFormats ),\n\t\t\t} );\n\t\t}\n\t}\n\n\treturn accumulator;\n}\n\n/**\n * Gets the attributes of an element in object shape.\n *\n * @param {Object}  $1         Named arguments.\n * @param {Element} $1.element Element to get attributes from.\n *\n * @return {Object|void} Attribute object or `undefined` if the element has no\n *                       attributes.\n */\nfunction getAttributes( { element } ) {\n\tif ( ! element.hasAttributes() ) {\n\t\treturn;\n\t}\n\n\tconst length = element.attributes.length;\n\tlet accumulator;\n\n\t// Optimise for speed.\n\tfor ( let i = 0; i < length; i++ ) {\n\t\tconst { name, value } = element.attributes[ i ];\n\n\t\tif ( name.indexOf( 'data-rich-text-' ) === 0 ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst safeName = /^on/i.test( name )\n\t\t\t? 'data-disable-rich-text-' + name\n\t\t\t: name;\n\n\t\taccumulator = accumulator || {};\n\t\taccumulator[ safeName ] = value;\n\t}\n\n\treturn accumulator;\n}\n","/**\n * Internal dependencies\n */\n\nimport { normaliseFormats } from './normalise-formats';\nimport { create } from './create';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Concats a pair of rich text values. Not that this mutates `a` and does NOT\n * normalise formats!\n *\n * @param {Object} a Value to mutate.\n * @param {Object} b Value to add read from.\n *\n * @return {Object} `a`, mutated.\n */\nexport function mergePair( a, b ) {\n\ta.formats = a.formats.concat( b.formats );\n\ta.replacements = a.replacements.concat( b.replacements );\n\ta.text += b.text;\n\n\treturn a;\n}\n\n/**\n * Combine all Rich Text values into one. This is similar to\n * `String.prototype.concat`.\n *\n * @param {...RichTextValue} values Objects to combine.\n *\n * @return {RichTextValue} A new value combining all given records.\n */\nexport function concat( ...values ) {\n\treturn normaliseFormats( values.reduce( mergePair, create() ) );\n}\n","/**\n * Internal dependencies\n */\nimport { getActiveFormats } from './get-active-formats';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n/** @typedef {import('./types').RichTextFormat} RichTextFormat */\n\n/**\n * Gets the format object by type at the start of the selection. This can be\n * used to get e.g. the URL of a link format at the current selection, but also\n * to check if a format is active at the selection. Returns undefined if there\n * is no format at the selection.\n *\n * @param {RichTextValue} value      Value to inspect.\n * @param {string}        formatType Format type to look for.\n *\n * @return {RichTextFormat|undefined} Active format object of the specified\n *                                    type, or undefined.\n */\nexport function getActiveFormat( value, formatType ) {\n\treturn getActiveFormats( value ).find(\n\t\t( { type } ) => type === formatType\n\t);\n}\n","/**\n * Internal dependencies\n */\n\nimport { OBJECT_REPLACEMENT_CHARACTER } from './special-characters';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n/** @typedef {import('./types').RichTextFormat} RichTextFormat */\n\n/**\n * Gets the active object, if there is any.\n *\n * @param {RichTextValue} value Value to inspect.\n *\n * @return {RichTextFormat|void} Active object, or undefined.\n */\nexport function getActiveObject( { start, end, replacements, text } ) {\n\tif ( start + 1 !== end || text[ start ] !== OBJECT_REPLACEMENT_CHARACTER ) {\n\t\treturn;\n\t}\n\n\treturn replacements[ start ];\n}\n","/**\n * Internal dependencies\n */\nimport type { RichTextValue } from './types';\n\n/**\n * Check if the selection of a Rich Text value is collapsed or not. Collapsed\n * means that no characters are selected, but there is a caret present. If there\n * is no selection, `undefined` will be returned. This is similar to\n * `window.getSelection().isCollapsed()`.\n *\n * @param props       The rich text value to check.\n * @param props.start\n * @param props.end\n * @return True if the selection is collapsed, false if not, undefined if there is no selection.\n */\nexport function isCollapsed( {\n\tstart,\n\tend,\n}: RichTextValue ): boolean | undefined {\n\tif ( start === undefined || end === undefined ) {\n\t\treturn;\n\t}\n\n\treturn start === end;\n}\n","/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Check if a Rich Text value is Empty, meaning it contains no text or any\n * objects (such as images).\n *\n * @param {RichTextValue} value Value to use.\n *\n * @return {boolean} True if the value is empty, false if not.\n */\nexport function isEmpty( { text } ) {\n\treturn text.length === 0;\n}\n","/**\n * Internal dependencies\n */\n\nimport { create } from './create';\nimport { normaliseFormats } from './normalise-formats';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Combine an array of Rich Text values into one, optionally separated by\n * `separator`, which can be a Rich Text value, HTML string, or plain text\n * string. This is similar to `Array.prototype.join`.\n *\n * @param {Array<RichTextValue>} values      An array of values to join.\n * @param {string|RichTextValue} [separator] Separator string or value.\n *\n * @return {RichTextValue} A new combined value.\n */\nexport function join( values, separator = '' ) {\n\tif ( typeof separator === 'string' ) {\n\t\tseparator = create( { text: separator } );\n\t}\n\n\treturn normaliseFormats(\n\t\tvalues.reduce( ( accumlator, { formats, replacements, text } ) => ( {\n\t\t\tformats: accumlator.formats.concat( separator.formats, formats ),\n\t\t\treplacements: accumlator.replacements.concat(\n\t\t\t\tseparator.replacements,\n\t\t\t\treplacements\n\t\t\t),\n\t\t\ttext: accumlator.text + separator.text + text,\n\t\t} ) )\n\t);\n}\n","/**\n * WordPress dependencies\n */\nimport { select, dispatch } from '@wordpress/data';\n/**\n * Internal dependencies\n */\nimport { store as richTextStore } from './store';\n/**\n * @typedef {Object} WPFormat\n *\n * @property {string}        name        A string identifying the format. Must be\n *                                       unique across all registered formats.\n * @property {string}        tagName     The HTML tag this format will wrap the\n *                                       selection with.\n * @property {boolean}       interactive Whether format makes content interactive or not.\n * @property {string | null} [className] A class to match the format.\n * @property {string}        title       Name of the format.\n * @property {Function}      edit        Should return a component for the user to\n *                                       interact with the new registered format.\n */\n\n/**\n * Registers a new format provided a unique name and an object defining its\n * behavior.\n *\n * @param {string}   name     Format name.\n * @param {WPFormat} settings Format settings.\n *\n * @return {WPFormat|undefined} The format, if it has been successfully\n *                              registered; otherwise `undefined`.\n */\nexport function registerFormatType( name, settings ) {\n\tsettings = {\n\t\tname,\n\t\t...settings,\n\t};\n\n\tif ( typeof settings.name !== 'string' ) {\n\t\twindow.console.error( 'Format names must be strings.' );\n\t\treturn;\n\t}\n\n\tif ( ! /^[a-z][a-z0-9-]*\\/[a-z][a-z0-9-]*$/.test( settings.name ) ) {\n\t\twindow.console.error(\n\t\t\t'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'\n\t\t);\n\t\treturn;\n\t}\n\n\tif ( select( richTextStore ).getFormatType( settings.name ) ) {\n\t\twindow.console.error(\n\t\t\t'Format \"' + settings.name + '\" is already registered.'\n\t\t);\n\t\treturn;\n\t}\n\n\tif ( typeof settings.tagName !== 'string' || settings.tagName === '' ) {\n\t\twindow.console.error( 'Format tag names must be a string.' );\n\t\treturn;\n\t}\n\n\tif (\n\t\t( typeof settings.className !== 'string' ||\n\t\t\tsettings.className === '' ) &&\n\t\tsettings.className !== null\n\t) {\n\t\twindow.console.error(\n\t\t\t'Format class names must be a string, or null to handle bare elements.'\n\t\t);\n\t\treturn;\n\t}\n\n\tif ( ! /^[_a-zA-Z]+[a-zA-Z0-9_-]*$/.test( settings.className ) ) {\n\t\twindow.console.error(\n\t\t\t'A class name must begin with a letter, followed by any number of hyphens, underscores, letters, or numbers.'\n\t\t);\n\t\treturn;\n\t}\n\n\tif ( settings.className === null ) {\n\t\tconst formatTypeForBareElement = select(\n\t\t\trichTextStore\n\t\t).getFormatTypeForBareElement( settings.tagName );\n\n\t\tif (\n\t\t\tformatTypeForBareElement &&\n\t\t\tformatTypeForBareElement.name !== 'core/unknown'\n\t\t) {\n\t\t\twindow.console.error(\n\t\t\t\t`Format \"${ formatTypeForBareElement.name }\" is already registered to handle bare tag name \"${ settings.tagName }\".`\n\t\t\t);\n\t\t\treturn;\n\t\t}\n\t} else {\n\t\tconst formatTypeForClassName = select(\n\t\t\trichTextStore\n\t\t).getFormatTypeForClassName( settings.className );\n\n\t\tif ( formatTypeForClassName ) {\n\t\t\twindow.console.error(\n\t\t\t\t`Format \"${ formatTypeForClassName.name }\" is already registered to handle class name \"${ settings.className }\".`\n\t\t\t);\n\t\t\treturn;\n\t\t}\n\t}\n\n\tif ( ! ( 'title' in settings ) || settings.title === '' ) {\n\t\twindow.console.error(\n\t\t\t'The format \"' + settings.name + '\" must have a title.'\n\t\t);\n\t\treturn;\n\t}\n\n\tif ( 'keywords' in settings && settings.keywords.length > 3 ) {\n\t\twindow.console.error(\n\t\t\t'The format \"' +\n\t\t\t\tsettings.name +\n\t\t\t\t'\" can have a maximum of 3 keywords.'\n\t\t);\n\t\treturn;\n\t}\n\n\tif ( typeof settings.title !== 'string' ) {\n\t\twindow.console.error( 'Format titles must be strings.' );\n\t\treturn;\n\t}\n\n\tdispatch( richTextStore ).addFormatTypes( settings );\n\n\treturn settings;\n}\n","/**\n * Internal dependencies\n */\n\nimport { normaliseFormats } from './normalise-formats';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Remove any format object from a Rich Text value by type from the given\n * `startIndex` to the given `endIndex`. Indices are retrieved from the\n * selection if none are provided.\n *\n * @param {RichTextValue} value        Value to modify.\n * @param {string}        formatType   Format type to remove.\n * @param {number}        [startIndex] Start index.\n * @param {number}        [endIndex]   End index.\n *\n * @return {RichTextValue} A new value with the format applied.\n */\nexport function removeFormat(\n\tvalue,\n\tformatType,\n\tstartIndex = value.start,\n\tendIndex = value.end\n) {\n\tconst { formats, activeFormats } = value;\n\tconst newFormats = formats.slice();\n\n\t// If the selection is collapsed, expand start and end to the edges of the\n\t// format.\n\tif ( startIndex === endIndex ) {\n\t\tconst format = newFormats[ startIndex ]?.find(\n\t\t\t( { type } ) => type === formatType\n\t\t);\n\n\t\tif ( format ) {\n\t\t\twhile (\n\t\t\t\tnewFormats[ startIndex ]?.find(\n\t\t\t\t\t( newFormat ) => newFormat === format\n\t\t\t\t)\n\t\t\t) {\n\t\t\t\tfilterFormats( newFormats, startIndex, formatType );\n\t\t\t\tstartIndex--;\n\t\t\t}\n\n\t\t\tendIndex++;\n\n\t\t\twhile (\n\t\t\t\tnewFormats[ endIndex ]?.find(\n\t\t\t\t\t( newFormat ) => newFormat === format\n\t\t\t\t)\n\t\t\t) {\n\t\t\t\tfilterFormats( newFormats, endIndex, formatType );\n\t\t\t\tendIndex++;\n\t\t\t}\n\t\t}\n\t} else {\n\t\tfor ( let i = startIndex; i < endIndex; i++ ) {\n\t\t\tif ( newFormats[ i ] ) {\n\t\t\t\tfilterFormats( newFormats, i, formatType );\n\t\t\t}\n\t\t}\n\t}\n\n\treturn normaliseFormats( {\n\t\t...value,\n\t\tformats: newFormats,\n\t\tactiveFormats:\n\t\t\tactiveFormats?.filter( ( { type } ) => type !== formatType ) || [],\n\t} );\n}\n\nfunction filterFormats( formats, index, formatType ) {\n\tconst newFormats = formats[ index ].filter(\n\t\t( { type } ) => type !== formatType\n\t);\n\n\tif ( newFormats.length ) {\n\t\tformats[ index ] = newFormats;\n\t} else {\n\t\tdelete formats[ index ];\n\t}\n}\n","/**\n * Internal dependencies\n */\n\nimport { create } from './create';\nimport { normaliseFormats } from './normalise-formats';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Insert a Rich Text value, an HTML string, or a plain text string, into a\n * Rich Text value at the given `startIndex`. Any content between `startIndex`\n * and `endIndex` will be removed. Indices are retrieved from the selection if\n * none are provided.\n *\n * @param {RichTextValue}        value         Value to modify.\n * @param {RichTextValue|string} valueToInsert Value to insert.\n * @param {number}               [startIndex]  Start index.\n * @param {number}               [endIndex]    End index.\n *\n * @return {RichTextValue} A new value with the value inserted.\n */\nexport function insert(\n\tvalue,\n\tvalueToInsert,\n\tstartIndex = value.start,\n\tendIndex = value.end\n) {\n\tconst { formats, replacements, text } = value;\n\n\tif ( typeof valueToInsert === 'string' ) {\n\t\tvalueToInsert = create( { text: valueToInsert } );\n\t}\n\n\tconst index = startIndex + valueToInsert.text.length;\n\n\treturn normaliseFormats( {\n\t\tformats: formats\n\t\t\t.slice( 0, startIndex )\n\t\t\t.concat( valueToInsert.formats, formats.slice( endIndex ) ),\n\t\treplacements: replacements\n\t\t\t.slice( 0, startIndex )\n\t\t\t.concat(\n\t\t\t\tvalueToInsert.replacements,\n\t\t\t\treplacements.slice( endIndex )\n\t\t\t),\n\t\ttext:\n\t\t\ttext.slice( 0, startIndex ) +\n\t\t\tvalueToInsert.text +\n\t\t\ttext.slice( endIndex ),\n\t\tstart: index,\n\t\tend: index,\n\t} );\n}\n","/**\n * Internal dependencies\n */\n\nimport { insert } from './insert';\nimport { create } from './create';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Remove content from a Rich Text value between the given `startIndex` and\n * `endIndex`. Indices are retrieved from the selection if none are provided.\n *\n * @param {RichTextValue} value        Value to modify.\n * @param {number}        [startIndex] Start index.\n * @param {number}        [endIndex]   End index.\n *\n * @return {RichTextValue} A new value with the content removed.\n */\nexport function remove( value, startIndex, endIndex ) {\n\treturn insert( value, create(), startIndex, endIndex );\n}\n","/**\n * Internal dependencies\n */\n\nimport { normaliseFormats } from './normalise-formats';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Search a Rich Text value and replace the match(es) with `replacement`. This\n * is similar to `String.prototype.replace`.\n *\n * @param {RichTextValue}   value       The value to modify.\n * @param {RegExp|string}   pattern     A RegExp object or literal. Can also be\n *                                      a string. It is treated as a verbatim\n *                                      string and is not interpreted as a\n *                                      regular expression. Only the first\n *                                      occurrence will be replaced.\n * @param {Function|string} replacement The match or matches are replaced with\n *                                      the specified or the value returned by\n *                                      the specified function.\n *\n * @return {RichTextValue} A new value with replacements applied.\n */\nexport function replace(\n\t{ formats, replacements, text, start, end },\n\tpattern,\n\treplacement\n) {\n\ttext = text.replace( pattern, ( match, ...rest ) => {\n\t\tconst offset = rest[ rest.length - 2 ];\n\t\tlet newText = replacement;\n\t\tlet newFormats;\n\t\tlet newReplacements;\n\n\t\tif ( typeof newText === 'function' ) {\n\t\t\tnewText = replacement( match, ...rest );\n\t\t}\n\n\t\tif ( typeof newText === 'object' ) {\n\t\t\tnewFormats = newText.formats;\n\t\t\tnewReplacements = newText.replacements;\n\t\t\tnewText = newText.text;\n\t\t} else {\n\t\t\tnewFormats = Array( newText.length );\n\t\t\tnewReplacements = Array( newText.length );\n\n\t\t\tif ( formats[ offset ] ) {\n\t\t\t\tnewFormats = newFormats.fill( formats[ offset ] );\n\t\t\t}\n\t\t}\n\n\t\tformats = formats\n\t\t\t.slice( 0, offset )\n\t\t\t.concat( newFormats, formats.slice( offset + match.length ) );\n\t\treplacements = replacements\n\t\t\t.slice( 0, offset )\n\t\t\t.concat(\n\t\t\t\tnewReplacements,\n\t\t\t\treplacements.slice( offset + match.length )\n\t\t\t);\n\n\t\tif ( start ) {\n\t\t\tstart = end = offset + newText.length;\n\t\t}\n\n\t\treturn newText;\n\t} );\n\n\treturn normaliseFormats( { formats, replacements, text, start, end } );\n}\n","/**\n * Internal dependencies\n */\n\nimport { insert } from './insert';\nimport { OBJECT_REPLACEMENT_CHARACTER } from './special-characters';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n/** @typedef {import('./types').RichTextFormat} RichTextFormat */\n\n/**\n * Insert a format as an object into a Rich Text value at the given\n * `startIndex`. Any content between `startIndex` and `endIndex` will be\n * removed. Indices are retrieved from the selection if none are provided.\n *\n * @param {RichTextValue}  value          Value to modify.\n * @param {RichTextFormat} formatToInsert Format to insert as object.\n * @param {number}         [startIndex]   Start index.\n * @param {number}         [endIndex]     End index.\n *\n * @return {RichTextValue} A new value with the object inserted.\n */\nexport function insertObject( value, formatToInsert, startIndex, endIndex ) {\n\tconst valueToInsert = {\n\t\tformats: [ , ],\n\t\treplacements: [ formatToInsert ],\n\t\ttext: OBJECT_REPLACEMENT_CHARACTER,\n\t};\n\n\treturn insert( value, valueToInsert, startIndex, endIndex );\n}\n","/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Slice a Rich Text value from `startIndex` to `endIndex`. Indices are\n * retrieved from the selection if none are provided. This is similar to\n * `String.prototype.slice`.\n *\n * @param {RichTextValue} value        Value to modify.\n * @param {number}        [startIndex] Start index.\n * @param {number}        [endIndex]   End index.\n *\n * @return {RichTextValue} A new extracted value.\n */\nexport function slice( value, startIndex = value.start, endIndex = value.end ) {\n\tconst { formats, replacements, text } = value;\n\n\tif ( startIndex === undefined || endIndex === undefined ) {\n\t\treturn { ...value };\n\t}\n\n\treturn {\n\t\tformats: formats.slice( startIndex, endIndex ),\n\t\treplacements: replacements.slice( startIndex, endIndex ),\n\t\ttext: text.slice( startIndex, endIndex ),\n\t};\n}\n","/**\n * Internal dependencies\n */\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Split a Rich Text value in two at the given `startIndex` and `endIndex`, or\n * split at the given separator. This is similar to `String.prototype.split`.\n * Indices are retrieved from the selection if none are provided.\n *\n * @param {RichTextValue} value\n * @param {number|string} [string] Start index, or string at which to split.\n *\n * @return {Array<RichTextValue>|undefined} An array of new values.\n */\nexport function split( { formats, replacements, text, start, end }, string ) {\n\tif ( typeof string !== 'string' ) {\n\t\treturn splitAtSelection( ...arguments );\n\t}\n\n\tlet nextStart = 0;\n\n\treturn text.split( string ).map( ( substring ) => {\n\t\tconst startIndex = nextStart;\n\t\tconst value = {\n\t\t\tformats: formats.slice( startIndex, startIndex + substring.length ),\n\t\t\treplacements: replacements.slice(\n\t\t\t\tstartIndex,\n\t\t\t\tstartIndex + substring.length\n\t\t\t),\n\t\t\ttext: substring,\n\t\t};\n\n\t\tnextStart += string.length + substring.length;\n\n\t\tif ( start !== undefined && end !== undefined ) {\n\t\t\tif ( start >= startIndex && start < nextStart ) {\n\t\t\t\tvalue.start = start - startIndex;\n\t\t\t} else if ( start < startIndex && end > startIndex ) {\n\t\t\t\tvalue.start = 0;\n\t\t\t}\n\n\t\t\tif ( end >= startIndex && end < nextStart ) {\n\t\t\t\tvalue.end = end - startIndex;\n\t\t\t} else if ( start < nextStart && end > nextStart ) {\n\t\t\t\tvalue.end = substring.length;\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t} );\n}\n\nfunction splitAtSelection(\n\t{ formats, replacements, text, start, end },\n\tstartIndex = start,\n\tendIndex = end\n) {\n\tif ( start === undefined || end === undefined ) {\n\t\treturn;\n\t}\n\n\tconst before = {\n\t\tformats: formats.slice( 0, startIndex ),\n\t\treplacements: replacements.slice( 0, startIndex ),\n\t\ttext: text.slice( 0, startIndex ),\n\t};\n\tconst after = {\n\t\tformats: formats.slice( endIndex ),\n\t\treplacements: replacements.slice( endIndex ),\n\t\ttext: text.slice( endIndex ),\n\t\tstart: 0,\n\t\tend: 0,\n\t};\n\n\treturn [ before, after ];\n}\n","/**\n * Returns true if two ranges are equal, or false otherwise. Ranges are\n * considered equal if their start and end occur in the same container and\n * offset.\n *\n * @param {Range|null} a First range object to test.\n * @param {Range|null} b First range object to test.\n *\n * @return {boolean} Whether the two ranges are equal.\n */\nexport function isRangeEqual( a, b ) {\n\treturn (\n\t\ta === b ||\n\t\t( a &&\n\t\t\tb &&\n\t\t\ta.startContainer === b.startContainer &&\n\t\t\ta.startOffset === b.startOffset &&\n\t\t\ta.endContainer === b.endContainer &&\n\t\t\ta.endOffset === b.endOffset )\n\t);\n}\n","/**\n * Internal dependencies\n */\n\nimport { toTree } from './to-tree';\nimport { createElement } from './create-element';\nimport { isRangeEqual } from './is-range-equal';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Creates a path as an array of indices from the given root node to the given\n * node.\n *\n * @param {Node}        node     Node to find the path of.\n * @param {HTMLElement} rootNode Root node to find the path from.\n * @param {Array}       path     Initial path to build on.\n *\n * @return {Array} The path from the root node to the node.\n */\nfunction createPathToNode( node, rootNode, path ) {\n\tconst parentNode = node.parentNode;\n\tlet i = 0;\n\n\twhile ( ( node = node.previousSibling ) ) {\n\t\ti++;\n\t}\n\n\tpath = [ i, ...path ];\n\n\tif ( parentNode !== rootNode ) {\n\t\tpath = createPathToNode( parentNode, rootNode, path );\n\t}\n\n\treturn path;\n}\n\n/**\n * Gets a node given a path (array of indices) from the given node.\n *\n * @param {HTMLElement} node Root node to find the wanted node in.\n * @param {Array}       path Path (indices) to the wanted node.\n *\n * @return {Object} Object with the found node and the remaining offset (if any).\n */\nfunction getNodeByPath( node, path ) {\n\tpath = [ ...path ];\n\n\twhile ( node && path.length > 1 ) {\n\t\tnode = node.childNodes[ path.shift() ];\n\t}\n\n\treturn {\n\t\tnode,\n\t\toffset: path[ 0 ],\n\t};\n}\n\nfunction append( element, child ) {\n\tif ( child.html !== undefined ) {\n\t\treturn ( element.innerHTML += child.html );\n\t}\n\n\tif ( typeof child === 'string' ) {\n\t\tchild = element.ownerDocument.createTextNode( child );\n\t}\n\n\tconst { type, attributes } = child;\n\n\tif ( type ) {\n\t\tchild = element.ownerDocument.createElement( type );\n\n\t\tfor ( const key in attributes ) {\n\t\t\tchild.setAttribute( key, attributes[ key ] );\n\t\t}\n\t}\n\n\treturn element.appendChild( child );\n}\n\nfunction appendText( node, text ) {\n\tnode.appendData( text );\n}\n\nfunction getLastChild( { lastChild } ) {\n\treturn lastChild;\n}\n\nfunction getParent( { parentNode } ) {\n\treturn parentNode;\n}\n\nfunction isText( node ) {\n\treturn node.nodeType === node.TEXT_NODE;\n}\n\nfunction getText( { nodeValue } ) {\n\treturn nodeValue;\n}\n\nfunction remove( node ) {\n\treturn node.parentNode.removeChild( node );\n}\n\nexport function toDom( {\n\tvalue,\n\tprepareEditableTree,\n\tisEditableTree = true,\n\tplaceholder,\n\tdoc = document,\n} ) {\n\tlet startPath = [];\n\tlet endPath = [];\n\n\tif ( prepareEditableTree ) {\n\t\tvalue = {\n\t\t\t...value,\n\t\t\tformats: prepareEditableTree( value ),\n\t\t};\n\t}\n\n\t/**\n\t * Returns a new instance of a DOM tree upon which RichText operations can be\n\t * applied.\n\t *\n\t * Note: The current implementation will return a shared reference, reset on\n\t * each call to `createEmpty`. Therefore, you should not hold a reference to\n\t * the value to operate upon asynchronously, as it may have unexpected results.\n\t *\n\t * @return {Object} RichText tree.\n\t */\n\tconst createEmpty = () => createElement( doc, '' );\n\n\tconst tree = toTree( {\n\t\tvalue,\n\t\tcreateEmpty,\n\t\tappend,\n\t\tgetLastChild,\n\t\tgetParent,\n\t\tisText,\n\t\tgetText,\n\t\tremove,\n\t\tappendText,\n\t\tonStartIndex( body, pointer ) {\n\t\t\tstartPath = createPathToNode( pointer, body, [\n\t\t\t\tpointer.nodeValue.length,\n\t\t\t] );\n\t\t},\n\t\tonEndIndex( body, pointer ) {\n\t\t\tendPath = createPathToNode( pointer, body, [\n\t\t\t\tpointer.nodeValue.length,\n\t\t\t] );\n\t\t},\n\t\tisEditableTree,\n\t\tplaceholder,\n\t} );\n\n\treturn {\n\t\tbody: tree,\n\t\tselection: { startPath, endPath },\n\t};\n}\n\n/**\n * Create an `Element` tree from a Rich Text value and applies the difference to\n * the `Element` tree contained by `current`.\n *\n * @param {Object}        $1                       Named arguments.\n * @param {RichTextValue} $1.value                 Value to apply.\n * @param {HTMLElement}   $1.current               The live root node to apply the element tree to.\n * @param {Function}      [$1.prepareEditableTree] Function to filter editorable formats.\n * @param {boolean}       [$1.__unstableDomOnly]   Only apply elements, no selection.\n * @param {string}        [$1.placeholder]         Placeholder text.\n */\nexport function apply( {\n\tvalue,\n\tcurrent,\n\tprepareEditableTree,\n\t__unstableDomOnly,\n\tplaceholder,\n} ) {\n\t// Construct a new element tree in memory.\n\tconst { body, selection } = toDom( {\n\t\tvalue,\n\t\tprepareEditableTree,\n\t\tplaceholder,\n\t\tdoc: current.ownerDocument,\n\t} );\n\n\tapplyValue( body, current );\n\n\tif ( value.start !== undefined && ! __unstableDomOnly ) {\n\t\tapplySelection( selection, current );\n\t}\n}\n\nexport function applyValue( future, current ) {\n\tlet i = 0;\n\tlet futureChild;\n\n\twhile ( ( futureChild = future.firstChild ) ) {\n\t\tconst currentChild = current.childNodes[ i ];\n\n\t\tif ( ! currentChild ) {\n\t\t\tcurrent.appendChild( futureChild );\n\t\t} else if ( ! currentChild.isEqualNode( futureChild ) ) {\n\t\t\tif (\n\t\t\t\tcurrentChild.nodeName !== futureChild.nodeName ||\n\t\t\t\t( currentChild.nodeType === currentChild.TEXT_NODE &&\n\t\t\t\t\tcurrentChild.data !== futureChild.data )\n\t\t\t) {\n\t\t\t\tcurrent.replaceChild( futureChild, currentChild );\n\t\t\t} else {\n\t\t\t\tconst currentAttributes = currentChild.attributes;\n\t\t\t\tconst futureAttributes = futureChild.attributes;\n\n\t\t\t\tif ( currentAttributes ) {\n\t\t\t\t\tlet ii = currentAttributes.length;\n\n\t\t\t\t\t// Reverse loop because `removeAttribute` on `currentChild`\n\t\t\t\t\t// changes `currentAttributes`.\n\t\t\t\t\twhile ( ii-- ) {\n\t\t\t\t\t\tconst { name } = currentAttributes[ ii ];\n\n\t\t\t\t\t\tif ( ! futureChild.getAttribute( name ) ) {\n\t\t\t\t\t\t\tcurrentChild.removeAttribute( name );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif ( futureAttributes ) {\n\t\t\t\t\tfor ( let ii = 0; ii < futureAttributes.length; ii++ ) {\n\t\t\t\t\t\tconst { name, value } = futureAttributes[ ii ];\n\n\t\t\t\t\t\tif ( currentChild.getAttribute( name ) !== value ) {\n\t\t\t\t\t\t\tcurrentChild.setAttribute( name, value );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tapplyValue( futureChild, currentChild );\n\t\t\t\tfuture.removeChild( futureChild );\n\t\t\t}\n\t\t} else {\n\t\t\tfuture.removeChild( futureChild );\n\t\t}\n\n\t\ti++;\n\t}\n\n\twhile ( current.childNodes[ i ] ) {\n\t\tcurrent.removeChild( current.childNodes[ i ] );\n\t}\n}\n\nexport function applySelection( { startPath, endPath }, current ) {\n\tconst { node: startContainer, offset: startOffset } = getNodeByPath(\n\t\tcurrent,\n\t\tstartPath\n\t);\n\tconst { node: endContainer, offset: endOffset } = getNodeByPath(\n\t\tcurrent,\n\t\tendPath\n\t);\n\tconst { ownerDocument } = current;\n\tconst { defaultView } = ownerDocument;\n\tconst selection = defaultView.getSelection();\n\tconst range = ownerDocument.createRange();\n\n\trange.setStart( startContainer, startOffset );\n\trange.setEnd( endContainer, endOffset );\n\n\tconst { activeElement } = ownerDocument;\n\n\tif ( selection.rangeCount > 0 ) {\n\t\t// If the to be added range and the live range are the same, there's no\n\t\t// need to remove the live range and add the equivalent range.\n\t\tif ( isRangeEqual( range, selection.getRangeAt( 0 ) ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tselection.removeAllRanges();\n\t}\n\n\tselection.addRange( range );\n\n\t// This function is not intended to cause a shift in focus. Since the above\n\t// selection manipulations may shift focus, ensure that focus is restored to\n\t// its previous state.\n\tif ( activeElement !== ownerDocument.activeElement ) {\n\t\t// The `instanceof` checks protect against edge cases where the focused\n\t\t// element is not of the interface HTMLElement (does not have a `focus`\n\t\t// or `blur` property).\n\t\t//\n\t\t// See: https://github.com/Microsoft/TypeScript/issues/5901#issuecomment-431649653\n\t\tif ( activeElement instanceof defaultView.HTMLElement ) {\n\t\t\tactiveElement.focus();\n\t\t}\n\t}\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"a11y\"];","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"i18n\"];","/**\n * WordPress dependencies\n */\n\nimport { speak } from '@wordpress/a11y';\nimport { __, sprintf } from '@wordpress/i18n';\n\n/**\n * Internal dependencies\n */\n\nimport { getActiveFormat } from './get-active-format';\nimport { removeFormat } from './remove-format';\nimport { applyFormat } from './apply-format';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n/** @typedef {import('./types').RichTextFormat} RichTextFormat */\n\n/**\n * Toggles a format object to a Rich Text value at the current selection.\n *\n * @param {RichTextValue}  value  Value to modify.\n * @param {RichTextFormat} format Format to apply or remove.\n *\n * @return {RichTextValue} A new value with the format applied or removed.\n */\nexport function toggleFormat( value, format ) {\n\tif ( getActiveFormat( value, format.type ) ) {\n\t\t// For screen readers, will announce if formatting control is disabled.\n\t\tif ( format.title ) {\n\t\t\t// translators: %s: title of the formatting control\n\t\t\tspeak( sprintf( __( '%s removed.' ), format.title ), 'assertive' );\n\t\t}\n\t\treturn removeFormat( value, format.type );\n\t}\n\t// For screen readers, will announce if formatting control is enabled.\n\tif ( format.title ) {\n\t\t// translators: %s: title of the formatting control\n\t\tspeak( sprintf( __( '%s applied.' ), format.title ), 'assertive' );\n\t}\n\treturn applyFormat( value, format );\n}\n","/**\n * WordPress dependencies\n */\nimport { select, dispatch } from '@wordpress/data';\n\n/**\n * Internal dependencies\n */\nimport { store as richTextStore } from './store';\n\n/** @typedef {import('./register-format-type').WPFormat} WPFormat */\n\n/**\n * Unregisters a format.\n *\n * @param {string} name Format name.\n *\n * @return {WPFormat|undefined} The previous format value, if it has\n *                                        been successfully unregistered;\n *                                        otherwise `undefined`.\n */\nexport function unregisterFormatType( name ) {\n\tconst oldFormat = select( richTextStore ).getFormatType( name );\n\n\tif ( ! oldFormat ) {\n\t\twindow.console.error( `Format ${ name } is not registered.` );\n\t\treturn;\n\t}\n\n\tdispatch( richTextStore ).removeFormatTypes( name );\n\n\treturn oldFormat;\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"element\"];","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"deprecated\"];","/**\n * WordPress dependencies\n */\nimport { useMemo } from '@wordpress/element';\nimport deprecated from '@wordpress/deprecated';\n\n/**\n * Internal dependencies\n */\nimport { getActiveFormat } from '../get-active-format';\n\n/**\n * @template T\n * @typedef {import('@wordpress/element').RefObject<T>} RefObject<T>\n */\n/** @typedef {import('../register-format-type').WPFormat} WPFormat */\n/** @typedef {import('../types').RichTextValue} RichTextValue */\n\n/**\n * This hook, to be used in a format type's Edit component, returns the active\n * element that is formatted, or the selection range if no format is active.\n * The returned value is meant to be used for positioning UI, e.g. by passing it\n * to the `Popover` component.\n *\n * @param {Object}                 $1          Named parameters.\n * @param {RefObject<HTMLElement>} $1.ref      React ref of the element\n *                                             containing  the editable content.\n * @param {RichTextValue}          $1.value    Value to check for selection.\n * @param {WPFormat}               $1.settings The format type's settings.\n *\n * @return {Element|Range} The active element or selection range.\n */\nexport function useAnchorRef( { ref, value, settings = {} } ) {\n\tdeprecated( '`useAnchorRef` hook', {\n\t\tsince: '6.1',\n\t\talternative: '`useAnchor` hook',\n\t} );\n\n\tconst { tagName, className, name } = settings;\n\tconst activeFormat = name ? getActiveFormat( value, name ) : undefined;\n\n\treturn useMemo( () => {\n\t\tif ( ! ref.current ) {\n\t\t\treturn;\n\t\t}\n\t\tconst {\n\t\t\townerDocument: { defaultView },\n\t\t} = ref.current;\n\t\tconst selection = defaultView.getSelection();\n\n\t\tif ( ! selection.rangeCount ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst range = selection.getRangeAt( 0 );\n\n\t\tif ( ! activeFormat ) {\n\t\t\treturn range;\n\t\t}\n\n\t\tlet element = range.startContainer;\n\n\t\t// If the caret is right before the element, select the next element.\n\t\telement = element.nextElementSibling || element;\n\n\t\twhile ( element.nodeType !== element.ELEMENT_NODE ) {\n\t\t\telement = element.parentNode;\n\t\t}\n\n\t\treturn element.closest(\n\t\t\ttagName + ( className ? '.' + className : '' )\n\t\t);\n\t}, [ activeFormat, value.start, value.end, tagName, className ] );\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"compose\"];","/**\n * WordPress dependencies\n */\nimport { usePrevious } from '@wordpress/compose';\nimport { useState, useLayoutEffect } from '@wordpress/element';\n\n/** @typedef {import('../register-format-type').WPFormat} WPFormat */\n/** @typedef {import('../types').RichTextValue} RichTextValue */\n\n/**\n * Given a range and a format tag name and class name, returns the closest\n * format element.\n *\n * @param {Range}       range                  The Range to check.\n * @param {HTMLElement} editableContentElement The editable wrapper.\n * @param {string}      tagName                The tag name of the format element.\n * @param {string}      className              The class name of the format element.\n *\n * @return {HTMLElement|undefined} The format element, if found.\n */\nfunction getFormatElement( range, editableContentElement, tagName, className ) {\n\tlet element = range.startContainer;\n\n\t// Even if the active format is defined, the actualy DOM range's start\n\t// container may be outside of the format's DOM element:\n\t// `a‸<strong>b</strong>` (DOM) while visually it's `a<strong>‸b</strong>`.\n\t// So at a given selection index, start with the deepest format DOM element.\n\tif (\n\t\telement.nodeType === element.TEXT_NODE &&\n\t\trange.startOffset === element.length &&\n\t\telement.nextSibling\n\t) {\n\t\telement = element.nextSibling;\n\n\t\twhile ( element.firstChild ) {\n\t\t\telement = element.firstChild;\n\t\t}\n\t}\n\n\tif ( element.nodeType !== element.ELEMENT_NODE ) {\n\t\telement = element.parentElement;\n\t}\n\n\tif ( ! element ) {\n\t\treturn;\n\t}\n\tif ( element === editableContentElement ) {\n\t\treturn;\n\t}\n\tif ( ! editableContentElement.contains( element ) ) {\n\t\treturn;\n\t}\n\n\tconst selector = tagName + ( className ? '.' + className : '' );\n\n\t// .closest( selector ), but with a boundary. Check if the element matches\n\t// the selector. If it doesn't match, try the parent element if it's not the\n\t// editable wrapper. We don't want to try to match ancestors of the editable\n\t// wrapper, which is what .closest( selector ) would do. When the element is\n\t// the editable wrapper (which is most likely the case because most text is\n\t// unformatted), this never runs.\n\twhile ( element !== editableContentElement ) {\n\t\tif ( element.matches( selector ) ) {\n\t\t\treturn element;\n\t\t}\n\n\t\telement = element.parentElement;\n\t}\n}\n\n/**\n * @typedef {Object} VirtualAnchorElement\n * @property {() => DOMRect} getBoundingClientRect A function returning a DOMRect\n * @property {HTMLElement}   contextElement        The actual DOM element\n */\n\n/**\n * Creates a virtual anchor element for a range.\n *\n * @param {Range}       range                  The range to create a virtual anchor element for.\n * @param {HTMLElement} editableContentElement The editable wrapper.\n *\n * @return {VirtualAnchorElement} The virtual anchor element.\n */\nfunction createVirtualAnchorElement( range, editableContentElement ) {\n\treturn {\n\t\tcontextElement: editableContentElement,\n\t\tgetBoundingClientRect() {\n\t\t\treturn editableContentElement.contains( range.startContainer )\n\t\t\t\t? range.getBoundingClientRect()\n\t\t\t\t: editableContentElement.getBoundingClientRect();\n\t\t},\n\t};\n}\n\n/**\n * Get the anchor: a format element if there is a matching one based on the\n * tagName and className or a range otherwise.\n *\n * @param {HTMLElement} editableContentElement The editable wrapper.\n * @param {string}      tagName                The tag name of the format\n *                                             element.\n * @param {string}      className              The class name of the format\n *                                             element.\n *\n * @return {HTMLElement|VirtualAnchorElement|undefined} The anchor.\n */\nfunction getAnchor( editableContentElement, tagName, className ) {\n\tif ( ! editableContentElement ) {\n\t\treturn;\n\t}\n\n\tconst { ownerDocument } = editableContentElement;\n\tconst { defaultView } = ownerDocument;\n\tconst selection = defaultView.getSelection();\n\n\tif ( ! selection ) {\n\t\treturn;\n\t}\n\tif ( ! selection.rangeCount ) {\n\t\treturn;\n\t}\n\n\tconst range = selection.getRangeAt( 0 );\n\n\tif ( ! range || ! range.startContainer ) {\n\t\treturn;\n\t}\n\n\tconst formatElement = getFormatElement(\n\t\trange,\n\t\teditableContentElement,\n\t\ttagName,\n\t\tclassName\n\t);\n\n\tif ( formatElement ) {\n\t\treturn formatElement;\n\t}\n\n\treturn createVirtualAnchorElement( range, editableContentElement );\n}\n\n/**\n * This hook, to be used in a format type's Edit component, returns the active\n * element that is formatted, or a virtual element for the selection range if\n * no format is active. The returned value is meant to be used for positioning\n * UI, e.g. by passing it to the `Popover` component via the `anchor` prop.\n *\n * @param {Object}           $1                        Named parameters.\n * @param {HTMLElement|null} $1.editableContentElement The element containing\n *                                                     the editable content.\n * @param {WPFormat=}        $1.settings               The format type's settings.\n * @return {Element|VirtualAnchorElement|undefined|null} The active element or selection range.\n */\nexport function useAnchor( { editableContentElement, settings = {} } ) {\n\tconst { tagName, className, isActive } = settings;\n\tconst [ anchor, setAnchor ] = useState( () =>\n\t\tgetAnchor( editableContentElement, tagName, className )\n\t);\n\tconst wasActive = usePrevious( isActive );\n\n\tuseLayoutEffect( () => {\n\t\tif ( ! editableContentElement ) {\n\t\t\treturn;\n\t\t}\n\n\t\tfunction callback() {\n\t\t\tsetAnchor(\n\t\t\t\tgetAnchor( editableContentElement, tagName, className )\n\t\t\t);\n\t\t}\n\n\t\tfunction attach() {\n\t\t\townerDocument.addEventListener( 'selectionchange', callback );\n\t\t}\n\n\t\tfunction detach() {\n\t\t\townerDocument.removeEventListener( 'selectionchange', callback );\n\t\t}\n\n\t\tconst { ownerDocument } = editableContentElement;\n\n\t\tif (\n\t\t\teditableContentElement === ownerDocument.activeElement ||\n\t\t\t// When a link is created, we need to attach the popover to the newly created anchor.\n\t\t\t( ! wasActive && isActive ) ||\n\t\t\t// Sometimes we're _removing_ an active anchor, such as the inline color popover.\n\t\t\t// When we add the color, it switches from a virtual anchor to a `<mark>` element.\n\t\t\t// When we _remove_ the color, it switches from a `<mark>` element to a virtual anchor.\n\t\t\t( wasActive && ! isActive )\n\t\t) {\n\t\t\tsetAnchor(\n\t\t\t\tgetAnchor( editableContentElement, tagName, className )\n\t\t\t);\n\t\t\tattach();\n\t\t}\n\n\t\teditableContentElement.addEventListener( 'focusin', attach );\n\t\teditableContentElement.addEventListener( 'focusout', detach );\n\n\t\treturn () => {\n\t\t\tdetach();\n\n\t\t\teditableContentElement.removeEventListener( 'focusin', attach );\n\t\t\teditableContentElement.removeEventListener( 'focusout', detach );\n\t\t};\n\t}, [ editableContentElement, tagName, className, isActive, wasActive ] );\n\n\treturn anchor;\n}\n","/**\n * WordPress dependencies\n */\nimport { useCallback } from '@wordpress/element';\n\n/**\n * In HTML, leading and trailing spaces are not visible, and multiple spaces\n * elsewhere are visually reduced to one space. This rule prevents spaces from\n * collapsing so all space is visible in the editor and can be removed. It also\n * prevents some browsers from inserting non-breaking spaces at the end of a\n * line to prevent the space from visually disappearing. Sometimes these non\n * breaking spaces can linger in the editor causing unwanted non breaking spaces\n * in between words. If also prevent Firefox from inserting a trailing `br` node\n * to visualise any trailing space, causing the element to be saved.\n *\n * > Authors are encouraged to set the 'white-space' property on editing hosts\n * > and on markup that was originally created through these editing mechanisms\n * > to the value 'pre-wrap'. Default HTML whitespace handling is not well\n * > suited to WYSIWYG editing, and line wrapping will not work correctly in\n * > some corner cases if 'white-space' is left at its default value.\n *\n * https://html.spec.whatwg.org/multipage/interaction.html#best-practices-for-in-page-editors\n *\n * @type {string}\n */\nconst whiteSpace = 'pre-wrap';\n\n/**\n * A minimum width of 1px will prevent the rich text container from collapsing\n * to 0 width and hiding the caret. This is useful for inline containers.\n */\nconst minWidth = '1px';\n\nexport function useDefaultStyle() {\n\treturn useCallback( ( element ) => {\n\t\tif ( ! element ) {\n\t\t\treturn;\n\t\t}\n\t\telement.style.whiteSpace = whiteSpace;\n\t\telement.style.minWidth = minWidth;\n\t}, [] );\n}\n","/**\n * WordPress dependencies\n */\nimport { useEffect, useRef } from '@wordpress/element';\n\n/*\n * Calculates and renders the format boundary style when the active formats\n * change.\n */\nexport function useBoundaryStyle( { record } ) {\n\tconst ref = useRef();\n\tconst { activeFormats = [], replacements, start } = record.current;\n\tconst activeReplacement = replacements[ start ];\n\tuseEffect( () => {\n\t\t// There's no need to recalculate the boundary styles if no formats are\n\t\t// active, because no boundary styles will be visible.\n\t\tif (\n\t\t\t( ! activeFormats || ! activeFormats.length ) &&\n\t\t\t! activeReplacement\n\t\t) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst boundarySelector = '*[data-rich-text-format-boundary]';\n\t\tconst element = ref.current.querySelector( boundarySelector );\n\n\t\tif ( ! element ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { ownerDocument } = element;\n\t\tconst { defaultView } = ownerDocument;\n\t\tconst computedStyle = defaultView.getComputedStyle( element );\n\t\tconst newColor = computedStyle.color\n\t\t\t.replace( ')', ', 0.2)' )\n\t\t\t.replace( 'rgb', 'rgba' );\n\t\tconst selector = `.rich-text:focus ${ boundarySelector }`;\n\t\tconst rule = `background-color: ${ newColor }`;\n\t\tconst style = `${ selector } {${ rule }}`;\n\t\tconst globalStyleId = 'rich-text-boundary-style';\n\n\t\tlet globalStyle = ownerDocument.getElementById( globalStyleId );\n\n\t\tif ( ! globalStyle ) {\n\t\t\tglobalStyle = ownerDocument.createElement( 'style' );\n\t\t\tglobalStyle.id = globalStyleId;\n\t\t\townerDocument.head.appendChild( globalStyle );\n\t\t}\n\n\t\tif ( globalStyle.innerHTML !== style ) {\n\t\t\tglobalStyle.innerHTML = style;\n\t\t}\n\t}, [ activeFormats, activeReplacement ] );\n\treturn ref;\n}\n","/**\n * Internal dependencies\n */\nimport { toHTMLString } from '../../to-html-string';\nimport { isCollapsed } from '../../is-collapsed';\nimport { slice } from '../../slice';\nimport { getTextContent } from '../../get-text-content';\n\nexport default ( props ) => ( element ) => {\n\tfunction onCopy( event ) {\n\t\tconst { record } = props.current;\n\t\tconst { ownerDocument } = element;\n\t\tif (\n\t\t\tisCollapsed( record.current ) ||\n\t\t\t! element.contains( ownerDocument.activeElement )\n\t\t) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst selectedRecord = slice( record.current );\n\t\tconst plainText = getTextContent( selectedRecord );\n\t\tconst html = toHTMLString( { value: selectedRecord } );\n\t\tevent.clipboardData.setData( 'text/plain', plainText );\n\t\tevent.clipboardData.setData( 'text/html', html );\n\t\tevent.clipboardData.setData( 'rich-text', 'true' );\n\t\tevent.preventDefault();\n\n\t\tif ( event.type === 'cut' ) {\n\t\t\townerDocument.execCommand( 'delete' );\n\t\t}\n\t}\n\n\tconst { defaultView } = element.ownerDocument;\n\n\tdefaultView.addEventListener( 'copy', onCopy );\n\tdefaultView.addEventListener( 'cut', onCopy );\n\treturn () => {\n\t\tdefaultView.removeEventListener( 'copy', onCopy );\n\t\tdefaultView.removeEventListener( 'cut', onCopy );\n\t};\n};\n","const __WEBPACK_NAMESPACE_OBJECT__ = window[\"wp\"][\"keycodes\"];","/**\n * WordPress dependencies\n */\nimport { LEFT, RIGHT } from '@wordpress/keycodes';\n\n/**\n * Internal dependencies\n */\nimport { isCollapsed } from '../../is-collapsed';\n\nconst EMPTY_ACTIVE_FORMATS = [];\n\nexport default ( props ) => ( element ) => {\n\tfunction onKeyDown( event ) {\n\t\tconst { keyCode, shiftKey, altKey, metaKey, ctrlKey } = event;\n\n\t\tif (\n\t\t\t// Only override left and right keys without modifiers pressed.\n\t\t\tshiftKey ||\n\t\t\taltKey ||\n\t\t\tmetaKey ||\n\t\t\tctrlKey ||\n\t\t\t( keyCode !== LEFT && keyCode !== RIGHT )\n\t\t) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { record, applyRecord, forceRender } = props.current;\n\t\tconst {\n\t\t\ttext,\n\t\t\tformats,\n\t\t\tstart,\n\t\t\tend,\n\t\t\tactiveFormats: currentActiveFormats = [],\n\t\t} = record.current;\n\t\tconst collapsed = isCollapsed( record.current );\n\t\tconst { ownerDocument } = element;\n\t\tconst { defaultView } = ownerDocument;\n\t\t// To do: ideally, we should look at visual position instead.\n\t\tconst { direction } = defaultView.getComputedStyle( element );\n\t\tconst reverseKey = direction === 'rtl' ? RIGHT : LEFT;\n\t\tconst isReverse = event.keyCode === reverseKey;\n\n\t\t// If the selection is collapsed and at the very start, do nothing if\n\t\t// navigating backward.\n\t\t// If the selection is collapsed and at the very end, do nothing if\n\t\t// navigating forward.\n\t\tif ( collapsed && currentActiveFormats.length === 0 ) {\n\t\t\tif ( start === 0 && isReverse ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( end === text.length && ! isReverse ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\n\t\t// If the selection is not collapsed, let the browser handle collapsing\n\t\t// the selection for now. Later we could expand this logic to set\n\t\t// boundary positions if needed.\n\t\tif ( ! collapsed ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst formatsBefore = formats[ start - 1 ] || EMPTY_ACTIVE_FORMATS;\n\t\tconst formatsAfter = formats[ start ] || EMPTY_ACTIVE_FORMATS;\n\t\tconst destination = isReverse ? formatsBefore : formatsAfter;\n\t\tconst isIncreasing = currentActiveFormats.every(\n\t\t\t( format, index ) => format === destination[ index ]\n\t\t);\n\n\t\tlet newActiveFormatsLength = currentActiveFormats.length;\n\n\t\tif ( ! isIncreasing ) {\n\t\t\tnewActiveFormatsLength--;\n\t\t} else if ( newActiveFormatsLength < destination.length ) {\n\t\t\tnewActiveFormatsLength++;\n\t\t}\n\n\t\tif ( newActiveFormatsLength === currentActiveFormats.length ) {\n\t\t\trecord.current._newActiveFormats = destination;\n\t\t\treturn;\n\t\t}\n\n\t\tevent.preventDefault();\n\n\t\tconst origin = isReverse ? formatsAfter : formatsBefore;\n\t\tconst source = isIncreasing ? destination : origin;\n\t\tconst newActiveFormats = source.slice( 0, newActiveFormatsLength );\n\t\tconst newValue = {\n\t\t\t...record.current,\n\t\t\tactiveFormats: newActiveFormats,\n\t\t};\n\t\trecord.current = newValue;\n\t\tapplyRecord( newValue );\n\t\tforceRender();\n\t}\n\n\telement.addEventListener( 'keydown', onKeyDown );\n\treturn () => {\n\t\telement.removeEventListener( 'keydown', onKeyDown );\n\t};\n};\n","/**\n * Internal dependencies\n */\nimport { getActiveFormats } from '../../get-active-formats';\nimport { updateFormats } from '../../update-formats';\n\n/**\n * All inserting input types that would insert HTML into the DOM.\n *\n * @see https://www.w3.org/TR/input-events-2/#interface-InputEvent-Attributes\n *\n * @type {Set}\n */\nconst INSERTION_INPUT_TYPES_TO_IGNORE = new Set( [\n\t'insertParagraph',\n\t'insertOrderedList',\n\t'insertUnorderedList',\n\t'insertHorizontalRule',\n\t'insertLink',\n] );\n\nconst EMPTY_ACTIVE_FORMATS = [];\n\nconst PLACEHOLDER_ATTR_NAME = 'data-rich-text-placeholder';\n\n/**\n * If the selection is set on the placeholder element, collapse the selection to\n * the start (before the placeholder).\n *\n * @param {Window} defaultView\n */\nfunction fixPlaceholderSelection( defaultView ) {\n\tconst selection = defaultView.getSelection();\n\tconst { anchorNode, anchorOffset } = selection;\n\n\tif ( anchorNode.nodeType !== anchorNode.ELEMENT_NODE ) {\n\t\treturn;\n\t}\n\n\tconst targetNode = anchorNode.childNodes[ anchorOffset ];\n\n\tif (\n\t\t! targetNode ||\n\t\ttargetNode.nodeType !== targetNode.ELEMENT_NODE ||\n\t\t! targetNode.hasAttribute( PLACEHOLDER_ATTR_NAME )\n\t) {\n\t\treturn;\n\t}\n\n\tselection.collapseToStart();\n}\n\nexport default ( props ) => ( element ) => {\n\tconst { ownerDocument } = element;\n\tconst { defaultView } = ownerDocument;\n\n\tlet isComposing = false;\n\n\tfunction onInput( event ) {\n\t\t// Do not trigger a change if characters are being composed. Browsers\n\t\t// will usually emit a final `input` event when the characters are\n\t\t// composed. As of December 2019, Safari doesn't support\n\t\t// nativeEvent.isComposing.\n\t\tif ( isComposing ) {\n\t\t\treturn;\n\t\t}\n\n\t\tlet inputType;\n\n\t\tif ( event ) {\n\t\t\tinputType = event.inputType;\n\t\t}\n\n\t\tconst { record, applyRecord, createRecord, handleChange } =\n\t\t\tprops.current;\n\n\t\t// The browser formatted something or tried to insert HTML. Overwrite\n\t\t// it. It will be handled later by the format library if needed.\n\t\tif (\n\t\t\tinputType &&\n\t\t\t( inputType.indexOf( 'format' ) === 0 ||\n\t\t\t\tINSERTION_INPUT_TYPES_TO_IGNORE.has( inputType ) )\n\t\t) {\n\t\t\tapplyRecord( record.current );\n\t\t\treturn;\n\t\t}\n\n\t\tconst currentValue = createRecord();\n\t\tconst { start, activeFormats: oldActiveFormats = [] } = record.current;\n\n\t\t// Update the formats between the last and new caret position.\n\t\tconst change = updateFormats( {\n\t\t\tvalue: currentValue,\n\t\t\tstart,\n\t\t\tend: currentValue.start,\n\t\t\tformats: oldActiveFormats,\n\t\t} );\n\n\t\thandleChange( change );\n\t}\n\n\t/**\n\t * Syncs the selection to local state. A callback for the `selectionchange`\n\t * event.\n\t */\n\tfunction handleSelectionChange() {\n\t\tconst { record, applyRecord, createRecord, onSelectionChange } =\n\t\t\tprops.current;\n\n\t\t// Check if the implementor disabled editing. `contentEditable` does\n\t\t// disable input, but not text selection, so we must ignore selection\n\t\t// changes.\n\t\tif ( element.contentEditable !== 'true' ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Ensure the active element is the rich text element.\n\t\tif ( ownerDocument.activeElement !== element ) {\n\t\t\t// If it is not, we can stop listening for selection changes. We\n\t\t\t// resume listening when the element is focused.\n\t\t\townerDocument.removeEventListener(\n\t\t\t\t'selectionchange',\n\t\t\t\thandleSelectionChange\n\t\t\t);\n\t\t\treturn;\n\t\t}\n\n\t\t// In case of a keyboard event, ignore selection changes during\n\t\t// composition.\n\t\tif ( isComposing ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { start, end, text } = createRecord();\n\t\tconst oldRecord = record.current;\n\n\t\t// Fallback mechanism for IE11, which doesn't support the input event.\n\t\t// Any input results in a selection change.\n\t\tif ( text !== oldRecord.text ) {\n\t\t\tonInput();\n\t\t\treturn;\n\t\t}\n\n\t\tif ( start === oldRecord.start && end === oldRecord.end ) {\n\t\t\t// Sometimes the browser may set the selection on the placeholder\n\t\t\t// element, in which case the caret is not visible. We need to set\n\t\t\t// the caret before the placeholder if that's the case.\n\t\t\tif ( oldRecord.text.length === 0 && start === 0 ) {\n\t\t\t\tfixPlaceholderSelection( defaultView );\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tconst newValue = {\n\t\t\t...oldRecord,\n\t\t\tstart,\n\t\t\tend,\n\t\t\t// _newActiveFormats may be set on arrow key navigation to control\n\t\t\t// the right boundary position. If undefined, getActiveFormats will\n\t\t\t// give the active formats according to the browser.\n\t\t\tactiveFormats: oldRecord._newActiveFormats,\n\t\t\t_newActiveFormats: undefined,\n\t\t};\n\n\t\tconst newActiveFormats = getActiveFormats(\n\t\t\tnewValue,\n\t\t\tEMPTY_ACTIVE_FORMATS\n\t\t);\n\n\t\t// Update the value with the new active formats.\n\t\tnewValue.activeFormats = newActiveFormats;\n\n\t\t// It is important that the internal value is updated first,\n\t\t// otherwise the value will be wrong on render!\n\t\trecord.current = newValue;\n\t\tapplyRecord( newValue, { domOnly: true } );\n\t\tonSelectionChange( start, end );\n\t}\n\n\tfunction onCompositionStart() {\n\t\tisComposing = true;\n\t\t// Do not update the selection when characters are being composed as\n\t\t// this rerenders the component and might destroy internal browser\n\t\t// editing state.\n\t\townerDocument.removeEventListener(\n\t\t\t'selectionchange',\n\t\t\thandleSelectionChange\n\t\t);\n\t\t// Remove the placeholder. Since the rich text value doesn't update\n\t\t// during composition, the placeholder doesn't get removed. There's no\n\t\t// need to re-add it, when the value is updated on compositionend it\n\t\t// will be re-added when the value is empty.\n\t\telement.querySelector( `[${ PLACEHOLDER_ATTR_NAME }]` )?.remove();\n\t}\n\n\tfunction onCompositionEnd() {\n\t\tisComposing = false;\n\t\t// Ensure the value is up-to-date for browsers that don't emit a final\n\t\t// input event after composition.\n\t\tonInput( { inputType: 'insertText' } );\n\t\t// Tracking selection changes can be resumed.\n\t\townerDocument.addEventListener(\n\t\t\t'selectionchange',\n\t\t\thandleSelectionChange\n\t\t);\n\t}\n\n\tfunction onFocus() {\n\t\tconst { record, isSelected, onSelectionChange, applyRecord } =\n\t\t\tprops.current;\n\n\t\t// When the whole editor is editable, let writing flow handle\n\t\t// selection.\n\t\tif ( element.parentElement.closest( '[contenteditable=\"true\"]' ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( ! isSelected ) {\n\t\t\t// We know for certain that on focus, the old selection is invalid.\n\t\t\t// It will be recalculated on the next mouseup, keyup, or touchend\n\t\t\t// event.\n\t\t\tconst index = undefined;\n\n\t\t\trecord.current = {\n\t\t\t\t...record.current,\n\t\t\t\tstart: index,\n\t\t\t\tend: index,\n\t\t\t\tactiveFormats: EMPTY_ACTIVE_FORMATS,\n\t\t\t};\n\t\t} else {\n\t\t\tapplyRecord( record.current, { domOnly: true } );\n\t\t}\n\n\t\tonSelectionChange( record.current.start, record.current.end );\n\n\t\t// There is no selection change event when the element is focused, so\n\t\t// we need to manually trigger it. The selection is also not available\n\t\t// yet in this call stack.\n\t\twindow.queueMicrotask( handleSelectionChange );\n\n\t\townerDocument.addEventListener(\n\t\t\t'selectionchange',\n\t\t\thandleSelectionChange\n\t\t);\n\t}\n\n\telement.addEventListener( 'input', onInput );\n\telement.addEventListener( 'compositionstart', onCompositionStart );\n\telement.addEventListener( 'compositionend', onCompositionEnd );\n\telement.addEventListener( 'focus', onFocus );\n\n\treturn () => {\n\t\telement.removeEventListener( 'input', onInput );\n\t\telement.removeEventListener( 'compositionstart', onCompositionStart );\n\t\telement.removeEventListener( 'compositionend', onCompositionEnd );\n\t\telement.removeEventListener( 'focus', onFocus );\n\t};\n};\n","/**\n * WordPress dependencies\n */\nimport { useMemo, useRef } from '@wordpress/element';\nimport { useRefEffect } from '@wordpress/compose';\n\n/**\n * Internal dependencies\n */\nimport copyHandler from './copy-handler';\nimport selectObject from './select-object';\nimport formatBoundaries from './format-boundaries';\nimport deleteHandler from './delete';\nimport inputAndSelection from './input-and-selection';\nimport selectionChangeCompat from './selection-change-compat';\n\nconst allEventListeners = [\n\tcopyHandler,\n\tselectObject,\n\tformatBoundaries,\n\tdeleteHandler,\n\tinputAndSelection,\n\tselectionChangeCompat,\n];\n\nexport function useEventListeners( props ) {\n\tconst propsRef = useRef( props );\n\tpropsRef.current = props;\n\tconst refEffects = useMemo(\n\t\t() => allEventListeners.map( ( refEffect ) => refEffect( propsRef ) ),\n\t\t[ propsRef ]\n\t);\n\n\treturn useRefEffect(\n\t\t( element ) => {\n\t\t\tconst cleanups = refEffects.map( ( effect ) => effect( element ) );\n\t\t\treturn () => {\n\t\t\t\tcleanups.forEach( ( cleanup ) => cleanup() );\n\t\t\t};\n\t\t},\n\t\t[ refEffects ]\n\t);\n}\n","export default () => ( element ) => {\n\tfunction onClick( event ) {\n\t\tconst { target } = event;\n\n\t\t// If the child element has no text content, it must be an object.\n\t\tif (\n\t\t\ttarget === element ||\n\t\t\t( target.textContent && target.isContentEditable )\n\t\t) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { ownerDocument } = target;\n\t\tconst { defaultView } = ownerDocument;\n\t\tconst selection = defaultView.getSelection();\n\n\t\t// If it's already selected, do nothing and let default behavior happen.\n\t\t// This means it's \"click-through\".\n\t\tif ( selection.containsNode( target ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst range = ownerDocument.createRange();\n\t\t// If the target is within a non editable element, select the non\n\t\t// editable element.\n\t\tconst nodeToSelect = target.isContentEditable\n\t\t\t? target\n\t\t\t: target.closest( '[contenteditable]' );\n\n\t\trange.selectNode( nodeToSelect );\n\t\tselection.removeAllRanges();\n\t\tselection.addRange( range );\n\n\t\tevent.preventDefault();\n\t}\n\n\tfunction onFocusIn( event ) {\n\t\t// When there is incoming focus from a link, select the object.\n\t\tif (\n\t\t\tevent.relatedTarget &&\n\t\t\t! element.contains( event.relatedTarget ) &&\n\t\t\tevent.relatedTarget.tagName === 'A'\n\t\t) {\n\t\t\tonClick( event );\n\t\t}\n\t}\n\n\telement.addEventListener( 'click', onClick );\n\telement.addEventListener( 'focusin', onFocusIn );\n\treturn () => {\n\t\telement.removeEventListener( 'click', onClick );\n\t\telement.removeEventListener( 'focusin', onFocusIn );\n\t};\n};\n","/**\n * WordPress dependencies\n */\nimport { BACKSPACE, DELETE } from '@wordpress/keycodes';\n\n/**\n * Internal dependencies\n */\nimport { remove } from '../../remove';\n\nexport default ( props ) => ( element ) => {\n\tfunction onKeyDown( event ) {\n\t\tconst { keyCode } = event;\n\t\tconst { createRecord, handleChange } = props.current;\n\n\t\tif ( event.defaultPrevented ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( keyCode !== DELETE && keyCode !== BACKSPACE ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst currentValue = createRecord();\n\t\tconst { start, end, text } = currentValue;\n\n\t\t// Always handle full content deletion ourselves.\n\t\tif ( start === 0 && end !== 0 && end === text.length ) {\n\t\t\thandleChange( remove( currentValue ) );\n\t\t\tevent.preventDefault();\n\t\t}\n\t}\n\n\telement.addEventListener( 'keydown', onKeyDown );\n\treturn () => {\n\t\telement.removeEventListener( 'keydown', onKeyDown );\n\t};\n};\n","/**\n * Internal dependencies\n */\n\nimport { isFormatEqual } from './is-format-equal';\n\n/** @typedef {import('./types').RichTextValue} RichTextValue */\n\n/**\n * Efficiently updates all the formats from `start` (including) until `end`\n * (excluding) with the active formats. Mutates `value`.\n *\n * @param {Object}        $1         Named paramentes.\n * @param {RichTextValue} $1.value   Value te update.\n * @param {number}        $1.start   Index to update from.\n * @param {number}        $1.end     Index to update until.\n * @param {Array}         $1.formats Replacement formats.\n *\n * @return {RichTextValue} Mutated value.\n */\nexport function updateFormats( { value, start, end, formats } ) {\n\t// Start and end may be switched in case of delete.\n\tconst min = Math.min( start, end );\n\tconst max = Math.max( start, end );\n\tconst formatsBefore = value.formats[ min - 1 ] || [];\n\tconst formatsAfter = value.formats[ max ] || [];\n\n\t// First, fix the references. If any format right before or after are\n\t// equal, the replacement format should use the same reference.\n\tvalue.activeFormats = formats.map( ( format, index ) => {\n\t\tif ( formatsBefore[ index ] ) {\n\t\t\tif ( isFormatEqual( format, formatsBefore[ index ] ) ) {\n\t\t\t\treturn formatsBefore[ index ];\n\t\t\t}\n\t\t} else if ( formatsAfter[ index ] ) {\n\t\t\tif ( isFormatEqual( format, formatsAfter[ index ] ) ) {\n\t\t\t\treturn formatsAfter[ index ];\n\t\t\t}\n\t\t}\n\n\t\treturn format;\n\t} );\n\n\twhile ( --end >= start ) {\n\t\tif ( value.activeFormats.length > 0 ) {\n\t\t\tvalue.formats[ end ] = value.activeFormats;\n\t\t} else {\n\t\t\tdelete value.formats[ end ];\n\t\t}\n\t}\n\n\treturn value;\n}\n","/**\n * Internal dependencies\n */\nimport { isRangeEqual } from '../../is-range-equal';\n\n/**\n * Sometimes some browsers are not firing a `selectionchange` event when\n * changing the selection by mouse or keyboard. This hook makes sure that, if we\n * detect no `selectionchange` or `input` event between the up and down events,\n * we fire a `selectionchange` event.\n */\nexport default () => ( element ) => {\n\tconst { ownerDocument } = element;\n\tconst { defaultView } = ownerDocument;\n\tconst selection = defaultView?.getSelection();\n\n\tlet range;\n\n\tfunction getRange() {\n\t\treturn selection.rangeCount ? selection.getRangeAt( 0 ) : null;\n\t}\n\n\tfunction onDown( event ) {\n\t\tconst type = event.type === 'keydown' ? 'keyup' : 'pointerup';\n\n\t\tfunction onCancel() {\n\t\t\townerDocument.removeEventListener( type, onUp );\n\t\t\townerDocument.removeEventListener( 'selectionchange', onCancel );\n\t\t\townerDocument.removeEventListener( 'input', onCancel );\n\t\t}\n\n\t\tfunction onUp() {\n\t\t\tonCancel();\n\t\t\tif ( isRangeEqual( range, getRange() ) ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\townerDocument.dispatchEvent( new Event( 'selectionchange' ) );\n\t\t}\n\n\t\townerDocument.addEventListener( type, onUp );\n\t\townerDocument.addEventListener( 'selectionchange', onCancel );\n\t\townerDocument.addEventListener( 'input', onCancel );\n\n\t\trange = getRange();\n\t}\n\n\telement.addEventListener( 'pointerdown', onDown );\n\telement.addEventListener( 'keydown', onDown );\n\treturn () => {\n\t\telement.removeEventListener( 'pointerdown', onDown );\n\t\telement.removeEventListener( 'keydown', onDown );\n\t};\n};\n","/**\n * WordPress dependencies\n */\nimport { useRef, useLayoutEffect, useReducer } from '@wordpress/element';\nimport { useMergeRefs, useRefEffect } from '@wordpress/compose';\nimport { useRegistry } from '@wordpress/data';\n\n/**\n * Internal dependencies\n */\nimport { create, RichTextData } from '../create';\nimport { apply } from '../to-dom';\nimport { toHTMLString } from '../to-html-string';\nimport { useDefaultStyle } from './use-default-style';\nimport { useBoundaryStyle } from './use-boundary-style';\nimport { useEventListeners } from './event-listeners';\n\nexport function useRichText( {\n\tvalue = '',\n\tselectionStart,\n\tselectionEnd,\n\tplaceholder,\n\tonSelectionChange,\n\tpreserveWhiteSpace,\n\tonChange,\n\t__unstableDisableFormats: disableFormats,\n\t__unstableIsSelected: isSelected,\n\t__unstableDependencies = [],\n\t__unstableAfterParse,\n\t__unstableBeforeSerialize,\n\t__unstableAddInvisibleFormats,\n} ) {\n\tconst registry = useRegistry();\n\tconst [ , forceRender ] = useReducer( () => ( {} ) );\n\tconst ref = useRef();\n\n\tfunction createRecord() {\n\t\tconst {\n\t\t\townerDocument: { defaultView },\n\t\t} = ref.current;\n\t\tconst selection = defaultView.getSelection();\n\t\tconst range =\n\t\t\tselection.rangeCount > 0 ? selection.getRangeAt( 0 ) : null;\n\n\t\treturn create( {\n\t\t\telement: ref.current,\n\t\t\trange,\n\t\t\t__unstableIsEditableTree: true,\n\t\t} );\n\t}\n\n\tfunction applyRecord( newRecord, { domOnly } = {} ) {\n\t\tapply( {\n\t\t\tvalue: newRecord,\n\t\t\tcurrent: ref.current,\n\t\t\tprepareEditableTree: __unstableAddInvisibleFormats,\n\t\t\t__unstableDomOnly: domOnly,\n\t\t\tplaceholder,\n\t\t} );\n\t}\n\n\t// Internal values are updated synchronously, unlike props and state.\n\tconst _valueRef = useRef( value );\n\tconst recordRef = useRef();\n\n\tfunction setRecordFromProps() {\n\t\t_valueRef.current = value;\n\t\trecordRef.current = value;\n\t\tif ( ! ( value instanceof RichTextData ) ) {\n\t\t\trecordRef.current = value\n\t\t\t\t? RichTextData.fromHTMLString( value, { preserveWhiteSpace } )\n\t\t\t\t: RichTextData.empty();\n\t\t}\n\t\t// To do: make rich text internally work with RichTextData.\n\t\trecordRef.current = {\n\t\t\ttext: recordRef.current.text,\n\t\t\tformats: recordRef.current.formats,\n\t\t\treplacements: recordRef.current.replacements,\n\t\t};\n\t\tif ( disableFormats ) {\n\t\t\trecordRef.current.formats = Array( value.length );\n\t\t\trecordRef.current.replacements = Array( value.length );\n\t\t}\n\t\tif ( __unstableAfterParse ) {\n\t\t\trecordRef.current.formats = __unstableAfterParse(\n\t\t\t\trecordRef.current\n\t\t\t);\n\t\t}\n\t\trecordRef.current.start = selectionStart;\n\t\trecordRef.current.end = selectionEnd;\n\t}\n\n\tconst hadSelectionUpdateRef = useRef( false );\n\n\tif ( ! recordRef.current ) {\n\t\thadSelectionUpdateRef.current = isSelected;\n\t\tsetRecordFromProps();\n\t} else if (\n\t\tselectionStart !== recordRef.current.start ||\n\t\tselectionEnd !== recordRef.current.end\n\t) {\n\t\thadSelectionUpdateRef.current = isSelected;\n\t\trecordRef.current = {\n\t\t\t...recordRef.current,\n\t\t\tstart: selectionStart,\n\t\t\tend: selectionEnd,\n\t\t\tactiveFormats: undefined,\n\t\t};\n\t}\n\n\t/**\n\t * Sync the value to global state. The node tree and selection will also be\n\t * updated if differences are found.\n\t *\n\t * @param {Object} newRecord The record to sync and apply.\n\t */\n\tfunction handleChange( newRecord ) {\n\t\trecordRef.current = newRecord;\n\t\tapplyRecord( newRecord );\n\n\t\tif ( disableFormats ) {\n\t\t\t_valueRef.current = newRecord.text;\n\t\t} else {\n\t\t\tconst newFormats = __unstableBeforeSerialize\n\t\t\t\t? __unstableBeforeSerialize( newRecord )\n\t\t\t\t: newRecord.formats;\n\t\t\tnewRecord = { ...newRecord, formats: newFormats };\n\t\t\tif ( typeof value === 'string' ) {\n\t\t\t\t_valueRef.current = toHTMLString( {\n\t\t\t\t\tvalue: newRecord,\n\t\t\t\t\tpreserveWhiteSpace,\n\t\t\t\t} );\n\t\t\t} else {\n\t\t\t\t_valueRef.current = new RichTextData( newRecord );\n\t\t\t}\n\t\t}\n\n\t\tconst { start, end, formats, text } = recordRef.current;\n\n\t\t// Selection must be updated first, so it is recorded in history when\n\t\t// the content change happens.\n\t\t// We batch both calls to only attempt to rerender once.\n\t\tregistry.batch( () => {\n\t\t\tonSelectionChange( start, end );\n\t\t\tonChange( _valueRef.current, {\n\t\t\t\t__unstableFormats: formats,\n\t\t\t\t__unstableText: text,\n\t\t\t} );\n\t\t} );\n\t\tforceRender();\n\t}\n\n\tfunction applyFromProps() {\n\t\tsetRecordFromProps();\n\t\tapplyRecord( recordRef.current );\n\t}\n\n\tconst didMountRef = useRef( false );\n\n\t// Value updates must happen synchonously to avoid overwriting newer values.\n\tuseLayoutEffect( () => {\n\t\tif ( didMountRef.current && value !== _valueRef.current ) {\n\t\t\tapplyFromProps();\n\t\t\tforceRender();\n\t\t}\n\t}, [ value ] );\n\n\t// Value updates must happen synchonously to avoid overwriting newer values.\n\tuseLayoutEffect( () => {\n\t\tif ( ! hadSelectionUpdateRef.current ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( ref.current.ownerDocument.activeElement !== ref.current ) {\n\t\t\tref.current.focus();\n\t\t}\n\n\t\tapplyRecord( recordRef.current );\n\t\thadSelectionUpdateRef.current = false;\n\t}, [ hadSelectionUpdateRef.current ] );\n\n\tconst mergedRefs = useMergeRefs( [\n\t\tref,\n\t\tuseDefaultStyle(),\n\t\tuseBoundaryStyle( { record: recordRef } ),\n\t\tuseEventListeners( {\n\t\t\trecord: recordRef,\n\t\t\thandleChange,\n\t\t\tapplyRecord,\n\t\t\tcreateRecord,\n\t\t\tisSelected,\n\t\t\tonSelectionChange,\n\t\t\tforceRender,\n\t\t} ),\n\t\tuseRefEffect( () => {\n\t\t\tapplyFromProps();\n\t\t\tdidMountRef.current = true;\n\t\t}, [ placeholder, ...__unstableDependencies ] ),\n\t] );\n\n\treturn {\n\t\tvalue: recordRef.current,\n\t\t// A function to get the most recent value so event handlers in\n\t\t// useRichText implementations have access to it. For example when\n\t\t// listening to input events, we internally update the state, but this\n\t\t// state is not yet available to the input event handler because React\n\t\t// may re-render asynchronously.\n\t\tgetValue: () => recordRef.current,\n\t\tonChange: handleChange,\n\t\tref: mergedRefs,\n\t};\n}\n\nexport default function __experimentalRichText() {}\n"],"names":["__webpack_require__","module","getter","__esModule","d","a","exports","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Symbol","toStringTag","value","window","combineReducers","formatTypes","state","action","type","reduce","newFormatTypes","name","fromEntries","entries","filter","names","includes","getFormatTypes","createSelector","values","getFormatType","getFormatTypeForBareElement","bareElementTagName","find","className","tagName","getFormatTypeForClassName","elementClassName","indexOf","addFormatTypes","Array","isArray","removeFormatTypes","store","createReduxStore","reducer","selectors","actions","isFormatEqual","format1","format2","attributes1","attributes","attributes2","keys1","keys","keys2","length","i","normaliseFormats","newFormats","formats","slice","forEach","formatsAtIndex","index","formatsAtPreviousIndex","newFormatsAtIndex","format","formatIndex","previousFormat","replace","array","applyFormat","startIndex","start","endIndex","end","activeFormats","startFormat","position","splice","createElement","implementation","html","body","createHTMLDocument","innerHTML","register","OBJECT_REPLACEMENT_CHARACTER","ZWNBSP","getActiveFormats","EMPTY_ACTIVE_FORMATS","undefined","formatsBefore","formatsAfter","selectedFormats","_activeFormats","ii","_format","select","richTextStore","restoreOnAttributes","isEditableTree","newAttributes","newKey","startsWith","fromFormat","unregisteredAttributes","object","boundaryClass","formatType","elementAttributes","class","contentEditable","contenteditable","isEqualUntil","b","toTree","preserveWhiteSpace","createEmpty","append","getLastChild","getParent","isText","getText","remove","appendText","onStartIndex","onEndIndex","placeholder","replacements","text","formatsLength","tree","deepestActiveFormat","lastCharacterFormats","lastCharacter","character","charAt","shouldInsertPadding","characterFormats","pointer","parent","newNode","replacement","decodeURIComponent","style","toHTMLString","createChildrenHTML","children","push","map","child","attributeString","isValidAttributeName","escapeAttribute","createElementHTML","escapeEditableHTML","join","getTextContent","toFormat","trim","__experimentalCreatePrepareEditableTree","__experimentalCreateOnChangeEditableValue","registeredAttributes","_attributes","RichTextData","empty","fromPlainText","create","fromHTMLString","fromHTMLElement","htmlElement","options","element","collapseWhiteSpace","richTextData","constructor","init","this","toPlainText","originalHTML","valueOf","toString","toJSON","getOwnPropertyNames","String","args","range","__unstableIsEditableTree","document","createFromElement","accumulateSelection","accumulator","node","parentNode","startContainer","startOffset","endContainer","endOffset","currentLength","nodeType","TEXT_NODE","childNodes","filterRange","nodeValue","isRoot","clone","cloneNode","normalize","from","nodes","newNodeValue","test","endsWith","ELEMENT_NODE","CARRIAGE_RETURN","removeReservedCharacters","string","RegExp","hasChildNodes","nodeName","toLowerCase","getAttribute","encodeURIComponent","mergePair","getAttributes","mergeFormats","hasAttributes","concat","getActiveFormat","getActiveObject","isCollapsed","isEmpty","separator","accumlator","registerFormatType","settings","console","error","formatTypeForBareElement","formatTypeForClassName","title","keywords","dispatch","removeFormat","newFormat","filterFormats","insert","valueToInsert","pattern","match","rest","offset","newReplacements","newText","fill","insertObject","formatToInsert","split","splitAtSelection","arguments","nextStart","substring","isRangeEqual","createPathToNode","rootNode","path","previousSibling","getNodeByPath","shift","ownerDocument","createTextNode","setAttribute","appendChild","appendData","lastChild","removeChild","toDom","prepareEditableTree","doc","startPath","endPath","selection","apply","current","__unstableDomOnly","applyValue","defaultView","getSelection","createRange","setStart","setEnd","activeElement","rangeCount","getRangeAt","removeAllRanges","addRange","HTMLElement","focus","applySelection","future","futureChild","firstChild","currentChild","isEqualNode","data","replaceChild","currentAttributes","futureAttributes","removeAttribute","toggleFormat","speak","sprintf","__","unregisterFormatType","oldFormat","useAnchorRef","ref","deprecated","since","alternative","activeFormat","useMemo","nextElementSibling","closest","getAnchor","editableContentElement","formatElement","nextSibling","parentElement","contains","selector","matches","getFormatElement","contextElement","getBoundingClientRect","createVirtualAnchorElement","useAnchor","isActive","anchor","setAnchor","useState","wasActive","usePrevious","useLayoutEffect","callback","attach","addEventListener","detach","removeEventListener","whiteSpace","minWidth","useBoundaryStyle","record","useRef","activeReplacement","useEffect","boundarySelector","querySelector","getComputedStyle","color","globalStyleId","globalStyle","getElementById","id","head","INSERTION_INPUT_TYPES_TO_IGNORE","Set","PLACEHOLDER_ATTR_NAME","allEventListeners","props","onCopy","event","selectedRecord","plainText","clipboardData","setData","preventDefault","execCommand","onClick","target","textContent","isContentEditable","containsNode","nodeToSelect","selectNode","onFocusIn","relatedTarget","onKeyDown","keyCode","shiftKey","altKey","metaKey","ctrlKey","LEFT","RIGHT","applyRecord","forceRender","currentActiveFormats","collapsed","direction","reverseKey","isReverse","destination","isIncreasing","every","newActiveFormatsLength","_newActiveFormats","newActiveFormats","newValue","createRecord","handleChange","defaultPrevented","DELETE","BACKSPACE","currentValue","isComposing","onInput","inputType","has","oldActiveFormats","change","min","Math","max","updateFormats","handleSelectionChange","onSelectionChange","oldRecord","anchorNode","anchorOffset","targetNode","hasAttribute","collapseToStart","fixPlaceholderSelection","domOnly","onCompositionStart","onCompositionEnd","onFocus","isSelected","queueMicrotask","getRange","onDown","onCancel","onUp","dispatchEvent","Event","useEventListeners","propsRef","refEffects","refEffect","useRefEffect","cleanups","effect","cleanup","useRichText","selectionStart","selectionEnd","onChange","__unstableDisableFormats","disableFormats","__unstableIsSelected","__unstableDependencies","__unstableAfterParse","__unstableBeforeSerialize","__unstableAddInvisibleFormats","registry","useRegistry","useReducer","newRecord","_valueRef","recordRef","setRecordFromProps","hadSelectionUpdateRef","batch","__unstableFormats","__unstableText","applyFromProps","didMountRef","mergedRefs","useMergeRefs","useCallback","getValue","__experimentalRichText"],"sourceRoot":""}