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