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