File: //srv/wordpress/core/beta/wp-includes/js/dist/blocks.js
"use strict";
var wp;
(wp ||= {}).blocks = (() => {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// package-external:@wordpress/data
var require_data = __commonJS({
"package-external:@wordpress/data"(exports, module) {
module.exports = window.wp.data;
}
});
// package-external:@wordpress/i18n
var require_i18n = __commonJS({
"package-external:@wordpress/i18n"(exports, module) {
module.exports = window.wp.i18n;
}
});
// package-external:@wordpress/element
var require_element = __commonJS({
"package-external:@wordpress/element"(exports, module) {
module.exports = window.wp.element;
}
});
// package-external:@wordpress/dom
var require_dom = __commonJS({
"package-external:@wordpress/dom"(exports, module) {
module.exports = window.wp.dom;
}
});
// package-external:@wordpress/rich-text
var require_rich_text = __commonJS({
"package-external:@wordpress/rich-text"(exports, module) {
module.exports = window.wp.richText;
}
});
// package-external:@wordpress/deprecated
var require_deprecated = __commonJS({
"package-external:@wordpress/deprecated"(exports, module) {
module.exports = window.wp.deprecated;
}
});
// package-external:@wordpress/warning
var require_warning = __commonJS({
"package-external:@wordpress/warning"(exports, module) {
module.exports = window.wp.warning;
}
});
// package-external:@wordpress/private-apis
var require_private_apis = __commonJS({
"package-external:@wordpress/private-apis"(exports, module) {
module.exports = window.wp.privateApis;
}
});
// node_modules/remove-accents/index.js
var require_remove_accents = __commonJS({
"node_modules/remove-accents/index.js"(exports, module) {
var characterMap = {
"\xC0": "A",
"\xC1": "A",
"\xC2": "A",
"\xC3": "A",
"\xC4": "A",
"\xC5": "A",
"\u1EA4": "A",
"\u1EAE": "A",
"\u1EB2": "A",
"\u1EB4": "A",
"\u1EB6": "A",
"\xC6": "AE",
"\u1EA6": "A",
"\u1EB0": "A",
"\u0202": "A",
"\u1EA2": "A",
"\u1EA0": "A",
"\u1EA8": "A",
"\u1EAA": "A",
"\u1EAC": "A",
"\xC7": "C",
"\u1E08": "C",
"\xC8": "E",
"\xC9": "E",
"\xCA": "E",
"\xCB": "E",
"\u1EBE": "E",
"\u1E16": "E",
"\u1EC0": "E",
"\u1E14": "E",
"\u1E1C": "E",
"\u0206": "E",
"\u1EBA": "E",
"\u1EBC": "E",
"\u1EB8": "E",
"\u1EC2": "E",
"\u1EC4": "E",
"\u1EC6": "E",
"\xCC": "I",
"\xCD": "I",
"\xCE": "I",
"\xCF": "I",
"\u1E2E": "I",
"\u020A": "I",
"\u1EC8": "I",
"\u1ECA": "I",
"\xD0": "D",
"\xD1": "N",
"\xD2": "O",
"\xD3": "O",
"\xD4": "O",
"\xD5": "O",
"\xD6": "O",
"\xD8": "O",
"\u1ED0": "O",
"\u1E4C": "O",
"\u1E52": "O",
"\u020E": "O",
"\u1ECE": "O",
"\u1ECC": "O",
"\u1ED4": "O",
"\u1ED6": "O",
"\u1ED8": "O",
"\u1EDC": "O",
"\u1EDE": "O",
"\u1EE0": "O",
"\u1EDA": "O",
"\u1EE2": "O",
"\xD9": "U",
"\xDA": "U",
"\xDB": "U",
"\xDC": "U",
"\u1EE6": "U",
"\u1EE4": "U",
"\u1EEC": "U",
"\u1EEE": "U",
"\u1EF0": "U",
"\xDD": "Y",
"\xE0": "a",
"\xE1": "a",
"\xE2": "a",
"\xE3": "a",
"\xE4": "a",
"\xE5": "a",
"\u1EA5": "a",
"\u1EAF": "a",
"\u1EB3": "a",
"\u1EB5": "a",
"\u1EB7": "a",
"\xE6": "ae",
"\u1EA7": "a",
"\u1EB1": "a",
"\u0203": "a",
"\u1EA3": "a",
"\u1EA1": "a",
"\u1EA9": "a",
"\u1EAB": "a",
"\u1EAD": "a",
"\xE7": "c",
"\u1E09": "c",
"\xE8": "e",
"\xE9": "e",
"\xEA": "e",
"\xEB": "e",
"\u1EBF": "e",
"\u1E17": "e",
"\u1EC1": "e",
"\u1E15": "e",
"\u1E1D": "e",
"\u0207": "e",
"\u1EBB": "e",
"\u1EBD": "e",
"\u1EB9": "e",
"\u1EC3": "e",
"\u1EC5": "e",
"\u1EC7": "e",
"\xEC": "i",
"\xED": "i",
"\xEE": "i",
"\xEF": "i",
"\u1E2F": "i",
"\u020B": "i",
"\u1EC9": "i",
"\u1ECB": "i",
"\xF0": "d",
"\xF1": "n",
"\xF2": "o",
"\xF3": "o",
"\xF4": "o",
"\xF5": "o",
"\xF6": "o",
"\xF8": "o",
"\u1ED1": "o",
"\u1E4D": "o",
"\u1E53": "o",
"\u020F": "o",
"\u1ECF": "o",
"\u1ECD": "o",
"\u1ED5": "o",
"\u1ED7": "o",
"\u1ED9": "o",
"\u1EDD": "o",
"\u1EDF": "o",
"\u1EE1": "o",
"\u1EDB": "o",
"\u1EE3": "o",
"\xF9": "u",
"\xFA": "u",
"\xFB": "u",
"\xFC": "u",
"\u1EE7": "u",
"\u1EE5": "u",
"\u1EED": "u",
"\u1EEF": "u",
"\u1EF1": "u",
"\xFD": "y",
"\xFF": "y",
"\u0100": "A",
"\u0101": "a",
"\u0102": "A",
"\u0103": "a",
"\u0104": "A",
"\u0105": "a",
"\u0106": "C",
"\u0107": "c",
"\u0108": "C",
"\u0109": "c",
"\u010A": "C",
"\u010B": "c",
"\u010C": "C",
"\u010D": "c",
"C\u0306": "C",
"c\u0306": "c",
"\u010E": "D",
"\u010F": "d",
"\u0110": "D",
"\u0111": "d",
"\u0112": "E",
"\u0113": "e",
"\u0114": "E",
"\u0115": "e",
"\u0116": "E",
"\u0117": "e",
"\u0118": "E",
"\u0119": "e",
"\u011A": "E",
"\u011B": "e",
"\u011C": "G",
"\u01F4": "G",
"\u011D": "g",
"\u01F5": "g",
"\u011E": "G",
"\u011F": "g",
"\u0120": "G",
"\u0121": "g",
"\u0122": "G",
"\u0123": "g",
"\u0124": "H",
"\u0125": "h",
"\u0126": "H",
"\u0127": "h",
"\u1E2A": "H",
"\u1E2B": "h",
"\u0128": "I",
"\u0129": "i",
"\u012A": "I",
"\u012B": "i",
"\u012C": "I",
"\u012D": "i",
"\u012E": "I",
"\u012F": "i",
"\u0130": "I",
"\u0131": "i",
"\u0132": "IJ",
"\u0133": "ij",
"\u0134": "J",
"\u0135": "j",
"\u0136": "K",
"\u0137": "k",
"\u1E30": "K",
"\u1E31": "k",
"K\u0306": "K",
"k\u0306": "k",
"\u0139": "L",
"\u013A": "l",
"\u013B": "L",
"\u013C": "l",
"\u013D": "L",
"\u013E": "l",
"\u013F": "L",
"\u0140": "l",
"\u0141": "l",
"\u0142": "l",
"\u1E3E": "M",
"\u1E3F": "m",
"M\u0306": "M",
"m\u0306": "m",
"\u0143": "N",
"\u0144": "n",
"\u0145": "N",
"\u0146": "n",
"\u0147": "N",
"\u0148": "n",
"\u0149": "n",
"N\u0306": "N",
"n\u0306": "n",
"\u014C": "O",
"\u014D": "o",
"\u014E": "O",
"\u014F": "o",
"\u0150": "O",
"\u0151": "o",
"\u0152": "OE",
"\u0153": "oe",
"P\u0306": "P",
"p\u0306": "p",
"\u0154": "R",
"\u0155": "r",
"\u0156": "R",
"\u0157": "r",
"\u0158": "R",
"\u0159": "r",
"R\u0306": "R",
"r\u0306": "r",
"\u0212": "R",
"\u0213": "r",
"\u015A": "S",
"\u015B": "s",
"\u015C": "S",
"\u015D": "s",
"\u015E": "S",
"\u0218": "S",
"\u0219": "s",
"\u015F": "s",
"\u0160": "S",
"\u0161": "s",
"\u0162": "T",
"\u0163": "t",
"\u021B": "t",
"\u021A": "T",
"\u0164": "T",
"\u0165": "t",
"\u0166": "T",
"\u0167": "t",
"T\u0306": "T",
"t\u0306": "t",
"\u0168": "U",
"\u0169": "u",
"\u016A": "U",
"\u016B": "u",
"\u016C": "U",
"\u016D": "u",
"\u016E": "U",
"\u016F": "u",
"\u0170": "U",
"\u0171": "u",
"\u0172": "U",
"\u0173": "u",
"\u0216": "U",
"\u0217": "u",
"V\u0306": "V",
"v\u0306": "v",
"\u0174": "W",
"\u0175": "w",
"\u1E82": "W",
"\u1E83": "w",
"X\u0306": "X",
"x\u0306": "x",
"\u0176": "Y",
"\u0177": "y",
"\u0178": "Y",
"Y\u0306": "Y",
"y\u0306": "y",
"\u0179": "Z",
"\u017A": "z",
"\u017B": "Z",
"\u017C": "z",
"\u017D": "Z",
"\u017E": "z",
"\u017F": "s",
"\u0192": "f",
"\u01A0": "O",
"\u01A1": "o",
"\u01AF": "U",
"\u01B0": "u",
"\u01CD": "A",
"\u01CE": "a",
"\u01CF": "I",
"\u01D0": "i",
"\u01D1": "O",
"\u01D2": "o",
"\u01D3": "U",
"\u01D4": "u",
"\u01D5": "U",
"\u01D6": "u",
"\u01D7": "U",
"\u01D8": "u",
"\u01D9": "U",
"\u01DA": "u",
"\u01DB": "U",
"\u01DC": "u",
"\u1EE8": "U",
"\u1EE9": "u",
"\u1E78": "U",
"\u1E79": "u",
"\u01FA": "A",
"\u01FB": "a",
"\u01FC": "AE",
"\u01FD": "ae",
"\u01FE": "O",
"\u01FF": "o",
"\xDE": "TH",
"\xFE": "th",
"\u1E54": "P",
"\u1E55": "p",
"\u1E64": "S",
"\u1E65": "s",
"X\u0301": "X",
"x\u0301": "x",
"\u0403": "\u0413",
"\u0453": "\u0433",
"\u040C": "\u041A",
"\u045C": "\u043A",
"A\u030B": "A",
"a\u030B": "a",
"E\u030B": "E",
"e\u030B": "e",
"I\u030B": "I",
"i\u030B": "i",
"\u01F8": "N",
"\u01F9": "n",
"\u1ED2": "O",
"\u1ED3": "o",
"\u1E50": "O",
"\u1E51": "o",
"\u1EEA": "U",
"\u1EEB": "u",
"\u1E80": "W",
"\u1E81": "w",
"\u1EF2": "Y",
"\u1EF3": "y",
"\u0200": "A",
"\u0201": "a",
"\u0204": "E",
"\u0205": "e",
"\u0208": "I",
"\u0209": "i",
"\u020C": "O",
"\u020D": "o",
"\u0210": "R",
"\u0211": "r",
"\u0214": "U",
"\u0215": "u",
"B\u030C": "B",
"b\u030C": "b",
"\u010C\u0323": "C",
"\u010D\u0323": "c",
"\xCA\u030C": "E",
"\xEA\u030C": "e",
"F\u030C": "F",
"f\u030C": "f",
"\u01E6": "G",
"\u01E7": "g",
"\u021E": "H",
"\u021F": "h",
"J\u030C": "J",
"\u01F0": "j",
"\u01E8": "K",
"\u01E9": "k",
"M\u030C": "M",
"m\u030C": "m",
"P\u030C": "P",
"p\u030C": "p",
"Q\u030C": "Q",
"q\u030C": "q",
"\u0158\u0329": "R",
"\u0159\u0329": "r",
"\u1E66": "S",
"\u1E67": "s",
"V\u030C": "V",
"v\u030C": "v",
"W\u030C": "W",
"w\u030C": "w",
"X\u030C": "X",
"x\u030C": "x",
"Y\u030C": "Y",
"y\u030C": "y",
"A\u0327": "A",
"a\u0327": "a",
"B\u0327": "B",
"b\u0327": "b",
"\u1E10": "D",
"\u1E11": "d",
"\u0228": "E",
"\u0229": "e",
"\u0190\u0327": "E",
"\u025B\u0327": "e",
"\u1E28": "H",
"\u1E29": "h",
"I\u0327": "I",
"i\u0327": "i",
"\u0197\u0327": "I",
"\u0268\u0327": "i",
"M\u0327": "M",
"m\u0327": "m",
"O\u0327": "O",
"o\u0327": "o",
"Q\u0327": "Q",
"q\u0327": "q",
"U\u0327": "U",
"u\u0327": "u",
"X\u0327": "X",
"x\u0327": "x",
"Z\u0327": "Z",
"z\u0327": "z",
"\u0439": "\u0438",
"\u0419": "\u0418",
"\u0451": "\u0435",
"\u0401": "\u0415"
};
var chars = Object.keys(characterMap).join("|");
var allAccents = new RegExp(chars, "g");
var firstAccent = new RegExp(chars, "");
function matcher3(match) {
return characterMap[match];
}
var removeAccents2 = function(string) {
return string.replace(allAccents, matcher3);
};
var hasAccents = function(string) {
return !!string.match(firstAccent);
};
module.exports = removeAccents2;
module.exports.has = hasAccents;
module.exports.remove = removeAccents2;
}
});
// node_modules/fast-deep-equal/es6/index.js
var require_es6 = __commonJS({
"node_modules/fast-deep-equal/es6/index.js"(exports, module) {
"use strict";
module.exports = function equal(a2, b3) {
if (a2 === b3) return true;
if (a2 && b3 && typeof a2 == "object" && typeof b3 == "object") {
if (a2.constructor !== b3.constructor) return false;
var length, i2, keys;
if (Array.isArray(a2)) {
length = a2.length;
if (length != b3.length) return false;
for (i2 = length; i2-- !== 0; )
if (!equal(a2[i2], b3[i2])) return false;
return true;
}
if (a2 instanceof Map && b3 instanceof Map) {
if (a2.size !== b3.size) return false;
for (i2 of a2.entries())
if (!b3.has(i2[0])) return false;
for (i2 of a2.entries())
if (!equal(i2[1], b3.get(i2[0]))) return false;
return true;
}
if (a2 instanceof Set && b3 instanceof Set) {
if (a2.size !== b3.size) return false;
for (i2 of a2.entries())
if (!b3.has(i2[0])) return false;
return true;
}
if (ArrayBuffer.isView(a2) && ArrayBuffer.isView(b3)) {
length = a2.length;
if (length != b3.length) return false;
for (i2 = length; i2-- !== 0; )
if (a2[i2] !== b3[i2]) return false;
return true;
}
if (a2.constructor === RegExp) return a2.source === b3.source && a2.flags === b3.flags;
if (a2.valueOf !== Object.prototype.valueOf) return a2.valueOf() === b3.valueOf();
if (a2.toString !== Object.prototype.toString) return a2.toString() === b3.toString();
keys = Object.keys(a2);
length = keys.length;
if (length !== Object.keys(b3).length) return false;
for (i2 = length; i2-- !== 0; )
if (!Object.prototype.hasOwnProperty.call(b3, keys[i2])) return false;
for (i2 = length; i2-- !== 0; ) {
var key = keys[i2];
if (!equal(a2[key], b3[key])) return false;
}
return true;
}
return a2 !== a2 && b3 !== b3;
};
}
});
// packages/blocks/node_modules/react-is/cjs/react-is.development.js
var require_react_is_development = __commonJS({
"packages/blocks/node_modules/react-is/cjs/react-is.development.js"(exports) {
"use strict";
if (true) {
(function() {
"use strict";
var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.element");
var REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal");
var REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment");
var REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode");
var REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler");
var REACT_PROVIDER_TYPE = /* @__PURE__ */ Symbol.for("react.provider");
var REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context");
var REACT_SERVER_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.server_context");
var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
var REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense");
var REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list");
var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
var REACT_OFFSCREEN_TYPE = /* @__PURE__ */ Symbol.for("react.offscreen");
var enableScopeAPI = false;
var enableCacheElement = false;
var enableTransitionTracing = false;
var enableLegacyHidden = false;
var enableDebugTracing = false;
var REACT_MODULE_REFERENCE;
{
REACT_MODULE_REFERENCE = /* @__PURE__ */ Symbol.for("react.module.reference");
}
function isValidElementType2(type) {
if (typeof type === "string" || typeof type === "function") {
return true;
}
if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) {
return true;
}
if (typeof type === "object" && type !== null) {
if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
// types supported by any Flight configuration anywhere since
// we don't know which Flight build this will end up being used
// with.
type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== void 0) {
return true;
}
}
return false;
}
function typeOf(object) {
if (typeof object === "object" && object !== null) {
var $$typeof = object.$$typeof;
switch ($$typeof) {
case REACT_ELEMENT_TYPE:
var type = object.type;
switch (type) {
case REACT_FRAGMENT_TYPE:
case REACT_PROFILER_TYPE:
case REACT_STRICT_MODE_TYPE:
case REACT_SUSPENSE_TYPE:
case REACT_SUSPENSE_LIST_TYPE:
return type;
default:
var $$typeofType = type && type.$$typeof;
switch ($$typeofType) {
case REACT_SERVER_CONTEXT_TYPE:
case REACT_CONTEXT_TYPE:
case REACT_FORWARD_REF_TYPE:
case REACT_LAZY_TYPE:
case REACT_MEMO_TYPE:
case REACT_PROVIDER_TYPE:
return $$typeofType;
default:
return $$typeof;
}
}
case REACT_PORTAL_TYPE:
return $$typeof;
}
}
return void 0;
}
var ContextConsumer = REACT_CONTEXT_TYPE;
var ContextProvider = REACT_PROVIDER_TYPE;
var Element = REACT_ELEMENT_TYPE;
var ForwardRef = REACT_FORWARD_REF_TYPE;
var Fragment = REACT_FRAGMENT_TYPE;
var Lazy = REACT_LAZY_TYPE;
var Memo = REACT_MEMO_TYPE;
var Portal = REACT_PORTAL_TYPE;
var Profiler = REACT_PROFILER_TYPE;
var StrictMode = REACT_STRICT_MODE_TYPE;
var Suspense = REACT_SUSPENSE_TYPE;
var SuspenseList = REACT_SUSPENSE_LIST_TYPE;
var hasWarnedAboutDeprecatedIsAsyncMode = false;
var hasWarnedAboutDeprecatedIsConcurrentMode = false;
function isAsyncMode(object) {
{
if (!hasWarnedAboutDeprecatedIsAsyncMode) {
hasWarnedAboutDeprecatedIsAsyncMode = true;
console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.");
}
}
return false;
}
function isConcurrentMode(object) {
{
if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
hasWarnedAboutDeprecatedIsConcurrentMode = true;
console["warn"]("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.");
}
}
return false;
}
function isContextConsumer(object) {
return typeOf(object) === REACT_CONTEXT_TYPE;
}
function isContextProvider(object) {
return typeOf(object) === REACT_PROVIDER_TYPE;
}
function isElement(object) {
return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
}
function isForwardRef(object) {
return typeOf(object) === REACT_FORWARD_REF_TYPE;
}
function isFragment(object) {
return typeOf(object) === REACT_FRAGMENT_TYPE;
}
function isLazy(object) {
return typeOf(object) === REACT_LAZY_TYPE;
}
function isMemo(object) {
return typeOf(object) === REACT_MEMO_TYPE;
}
function isPortal(object) {
return typeOf(object) === REACT_PORTAL_TYPE;
}
function isProfiler(object) {
return typeOf(object) === REACT_PROFILER_TYPE;
}
function isStrictMode(object) {
return typeOf(object) === REACT_STRICT_MODE_TYPE;
}
function isSuspense(object) {
return typeOf(object) === REACT_SUSPENSE_TYPE;
}
function isSuspenseList(object) {
return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
}
exports.ContextConsumer = ContextConsumer;
exports.ContextProvider = ContextProvider;
exports.Element = Element;
exports.ForwardRef = ForwardRef;
exports.Fragment = Fragment;
exports.Lazy = Lazy;
exports.Memo = Memo;
exports.Portal = Portal;
exports.Profiler = Profiler;
exports.StrictMode = StrictMode;
exports.Suspense = Suspense;
exports.SuspenseList = SuspenseList;
exports.isAsyncMode = isAsyncMode;
exports.isConcurrentMode = isConcurrentMode;
exports.isContextConsumer = isContextConsumer;
exports.isContextProvider = isContextProvider;
exports.isElement = isElement;
exports.isForwardRef = isForwardRef;
exports.isFragment = isFragment;
exports.isLazy = isLazy;
exports.isMemo = isMemo;
exports.isPortal = isPortal;
exports.isProfiler = isProfiler;
exports.isStrictMode = isStrictMode;
exports.isSuspense = isSuspense;
exports.isSuspenseList = isSuspenseList;
exports.isValidElementType = isValidElementType2;
exports.typeOf = typeOf;
})();
}
}
});
// packages/blocks/node_modules/react-is/index.js
var require_react_is = __commonJS({
"packages/blocks/node_modules/react-is/index.js"(exports, module) {
"use strict";
if (false) {
module.exports = null;
} else {
module.exports = require_react_is_development();
}
}
});
// package-external:@wordpress/hooks
var require_hooks = __commonJS({
"package-external:@wordpress/hooks"(exports, module) {
module.exports = window.wp.hooks;
}
});
// package-external:@wordpress/block-serialization-default-parser
var require_block_serialization_default_parser = __commonJS({
"package-external:@wordpress/block-serialization-default-parser"(exports, module) {
module.exports = window.wp.blockSerializationDefaultParser;
}
});
// package-external:@wordpress/autop
var require_autop = __commonJS({
"package-external:@wordpress/autop"(exports, module) {
module.exports = window.wp.autop;
}
});
// package-external:@wordpress/is-shallow-equal
var require_is_shallow_equal = __commonJS({
"package-external:@wordpress/is-shallow-equal"(exports, module) {
module.exports = window.wp.isShallowEqual;
}
});
// vendor-external:react/jsx-runtime
var require_jsx_runtime = __commonJS({
"vendor-external:react/jsx-runtime"(exports, module) {
module.exports = window.ReactJSXRuntime;
}
});
// package-external:@wordpress/html-entities
var require_html_entities = __commonJS({
"package-external:@wordpress/html-entities"(exports, module) {
module.exports = window.wp.htmlEntities;
}
});
// package-external:@wordpress/shortcode
var require_shortcode = __commonJS({
"package-external:@wordpress/shortcode"(exports, module) {
module.exports = window.wp.shortcode;
}
});
// package-external:@wordpress/blob
var require_blob = __commonJS({
"package-external:@wordpress/blob"(exports, module) {
module.exports = window.wp.blob;
}
});
// packages/blocks/build-module/index.mjs
var index_exports = {};
__export(index_exports, {
__EXPERIMENTAL_ELEMENTS: () => __EXPERIMENTAL_ELEMENTS,
__EXPERIMENTAL_PATHS_WITH_OVERRIDE: () => __EXPERIMENTAL_PATHS_WITH_OVERRIDE,
__EXPERIMENTAL_STYLE_PROPERTY: () => __EXPERIMENTAL_STYLE_PROPERTY,
__experimentalCloneSanitizedBlock: () => __experimentalCloneSanitizedBlock,
__experimentalGetAccessibleBlockLabel: () => getAccessibleBlockLabel,
__experimentalGetBlockAttributesNamesByRole: () => __experimentalGetBlockAttributesNamesByRole,
__experimentalGetBlockLabel: () => getBlockLabel,
__experimentalSanitizeBlockAttributes: () => __experimentalSanitizeBlockAttributes,
__unstableGetBlockProps: () => getBlockProps,
__unstableGetInnerBlocksProps: () => getInnerBlocksProps,
__unstableSerializeAndClean: () => __unstableSerializeAndClean,
children: () => children_default,
cloneBlock: () => cloneBlock,
cloneSanitizedBlock: () => cloneSanitizedBlock,
createBlock: () => createBlock,
createBlocksFromInnerBlocksTemplate: () => createBlocksFromInnerBlocksTemplate,
doBlocksMatchTemplate: () => doBlocksMatchTemplate,
findTransform: () => findTransform,
getBlockAttributes: () => getBlockAttributes,
getBlockAttributesNamesByRole: () => getBlockAttributesNamesByRole,
getBlockBindingsSource: () => getBlockBindingsSource,
getBlockBindingsSources: () => getBlockBindingsSources,
getBlockContent: () => getBlockInnerHTML,
getBlockDefaultClassName: () => getBlockDefaultClassName,
getBlockFromExample: () => getBlockFromExample,
getBlockMenuDefaultClassName: () => getBlockMenuDefaultClassName,
getBlockSupport: () => getBlockSupport,
getBlockTransforms: () => getBlockTransforms,
getBlockType: () => getBlockType,
getBlockTypes: () => getBlockTypes,
getBlockVariations: () => getBlockVariations,
getCategories: () => getCategories2,
getChildBlockNames: () => getChildBlockNames,
getDefaultBlockName: () => getDefaultBlockName,
getFreeformContentHandlerName: () => getFreeformContentHandlerName,
getGroupingBlockName: () => getGroupingBlockName,
getPhrasingContentSchema: () => deprecatedGetPhrasingContentSchema,
getPossibleBlockTransformations: () => getPossibleBlockTransformations,
getSaveContent: () => getSaveContent,
getSaveElement: () => getSaveElement,
getUnregisteredTypeHandlerName: () => getUnregisteredTypeHandlerName,
hasBlockSupport: () => hasBlockSupport,
hasChildBlocks: () => hasChildBlocks,
hasChildBlocksWithInserterSupport: () => hasChildBlocksWithInserterSupport,
isReusableBlock: () => isReusableBlock,
isTemplatePart: () => isTemplatePart,
isUnmodifiedBlock: () => isUnmodifiedBlock,
isUnmodifiedDefaultBlock: () => isUnmodifiedDefaultBlock,
isValidBlockContent: () => isValidBlockContent,
isValidIcon: () => isValidIcon,
node: () => node_default,
normalizeIconObject: () => normalizeIconObject,
parse: () => parse2,
parseWithAttributeSchema: () => parseWithAttributeSchema,
pasteHandler: () => pasteHandler,
privateApis: () => privateApis,
rawHandler: () => rawHandler,
registerBlockBindingsSource: () => registerBlockBindingsSource,
registerBlockCollection: () => registerBlockCollection,
registerBlockStyle: () => registerBlockStyle,
registerBlockType: () => registerBlockType,
registerBlockVariation: () => registerBlockVariation,
sanitizeBlockAttributes: () => sanitizeBlockAttributes,
serialize: () => serialize,
serializeRawBlock: () => serializeRawBlock,
setCategories: () => setCategories2,
setDefaultBlockName: () => setDefaultBlockName,
setFreeformContentHandlerName: () => setFreeformContentHandlerName,
setGroupingBlockName: () => setGroupingBlockName,
setUnregisteredTypeHandlerName: () => setUnregisteredTypeHandlerName,
store: () => store,
switchToBlockType: () => switchToBlockType,
synchronizeBlocksWithTemplate: () => synchronizeBlocksWithTemplate,
unregisterBlockBindingsSource: () => unregisterBlockBindingsSource,
unregisterBlockStyle: () => unregisterBlockStyle,
unregisterBlockType: () => unregisterBlockType,
unregisterBlockVariation: () => unregisterBlockVariation,
unstable__bootstrapServerSideBlockDefinitions: () => unstable__bootstrapServerSideBlockDefinitions,
updateCategory: () => updateCategory2,
validateBlock: () => validateBlock,
withBlockContentContext: () => withBlockContentContext
});
// packages/blocks/build-module/store/index.mjs
var import_data5 = __toESM(require_data(), 1);
// node_modules/tslib/tslib.es6.mjs
var __assign = function() {
__assign = Object.assign || function __assign2(t3) {
for (var s2, i2 = 1, n2 = arguments.length; i2 < n2; i2++) {
s2 = arguments[i2];
for (var p2 in s2) if (Object.prototype.hasOwnProperty.call(s2, p2)) t3[p2] = s2[p2];
}
return t3;
};
return __assign.apply(this, arguments);
};
// node_modules/lower-case/dist.es2015/index.js
function lowerCase(str) {
return str.toLowerCase();
}
// node_modules/no-case/dist.es2015/index.js
var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
function noCase(input, options) {
if (options === void 0) {
options = {};
}
var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
var start = 0;
var end = result.length;
while (result.charAt(start) === "\0")
start++;
while (result.charAt(end - 1) === "\0")
end--;
return result.slice(start, end).split("\0").map(transform).join(delimiter);
}
function replace(input, re2, value) {
if (re2 instanceof RegExp)
return input.replace(re2, value);
return re2.reduce(function(input2, re3) {
return input2.replace(re3, value);
}, input);
}
// node_modules/pascal-case/dist.es2015/index.js
function pascalCaseTransform(input, index) {
var firstChar = input.charAt(0);
var lowerChars = input.substr(1).toLowerCase();
if (index > 0 && firstChar >= "0" && firstChar <= "9") {
return "_" + firstChar + lowerChars;
}
return "" + firstChar.toUpperCase() + lowerChars;
}
function pascalCase(input, options) {
if (options === void 0) {
options = {};
}
return noCase(input, __assign({ delimiter: "", transform: pascalCaseTransform }, options));
}
// node_modules/camel-case/dist.es2015/index.js
function camelCaseTransform(input, index) {
if (index === 0)
return input.toLowerCase();
return pascalCaseTransform(input, index);
}
function camelCase(input, options) {
if (options === void 0) {
options = {};
}
return pascalCase(input, __assign({ transform: camelCaseTransform }, options));
}
// packages/blocks/build-module/store/reducer.mjs
var import_data2 = __toESM(require_data(), 1);
var import_i18n3 = __toESM(require_i18n(), 1);
// node_modules/colord/index.mjs
var r = { grad: 0.9, turn: 360, rad: 360 / (2 * Math.PI) };
var t = function(r2) {
return "string" == typeof r2 ? r2.length > 0 : "number" == typeof r2;
};
var n = function(r2, t3, n2) {
return void 0 === t3 && (t3 = 0), void 0 === n2 && (n2 = Math.pow(10, t3)), Math.round(n2 * r2) / n2 + 0;
};
var e = function(r2, t3, n2) {
return void 0 === t3 && (t3 = 0), void 0 === n2 && (n2 = 1), r2 > n2 ? n2 : r2 > t3 ? r2 : t3;
};
var u = function(r2) {
return (r2 = isFinite(r2) ? r2 % 360 : 0) > 0 ? r2 : r2 + 360;
};
var a = function(r2) {
return { r: e(r2.r, 0, 255), g: e(r2.g, 0, 255), b: e(r2.b, 0, 255), a: e(r2.a) };
};
var o = function(r2) {
return { r: n(r2.r), g: n(r2.g), b: n(r2.b), a: n(r2.a, 3) };
};
var i = /^#([0-9a-f]{3,8})$/i;
var s = function(r2) {
var t3 = r2.toString(16);
return t3.length < 2 ? "0" + t3 : t3;
};
var h = function(r2) {
var t3 = r2.r, n2 = r2.g, e2 = r2.b, u2 = r2.a, a2 = Math.max(t3, n2, e2), o3 = a2 - Math.min(t3, n2, e2), i2 = o3 ? a2 === t3 ? (n2 - e2) / o3 : a2 === n2 ? 2 + (e2 - t3) / o3 : 4 + (t3 - n2) / o3 : 0;
return { h: 60 * (i2 < 0 ? i2 + 6 : i2), s: a2 ? o3 / a2 * 100 : 0, v: a2 / 255 * 100, a: u2 };
};
var b = function(r2) {
var t3 = r2.h, n2 = r2.s, e2 = r2.v, u2 = r2.a;
t3 = t3 / 360 * 6, n2 /= 100, e2 /= 100;
var a2 = Math.floor(t3), o3 = e2 * (1 - n2), i2 = e2 * (1 - (t3 - a2) * n2), s2 = e2 * (1 - (1 - t3 + a2) * n2), h2 = a2 % 6;
return { r: 255 * [e2, i2, o3, o3, s2, e2][h2], g: 255 * [s2, e2, e2, i2, o3, o3][h2], b: 255 * [o3, o3, s2, e2, e2, i2][h2], a: u2 };
};
var g = function(r2) {
return { h: u(r2.h), s: e(r2.s, 0, 100), l: e(r2.l, 0, 100), a: e(r2.a) };
};
var d = function(r2) {
return { h: n(r2.h), s: n(r2.s), l: n(r2.l), a: n(r2.a, 3) };
};
var f = function(r2) {
return b((n2 = (t3 = r2).s, { h: t3.h, s: (n2 *= ((e2 = t3.l) < 50 ? e2 : 100 - e2) / 100) > 0 ? 2 * n2 / (e2 + n2) * 100 : 0, v: e2 + n2, a: t3.a }));
var t3, n2, e2;
};
var c = function(r2) {
return { h: (t3 = h(r2)).h, s: (u2 = (200 - (n2 = t3.s)) * (e2 = t3.v) / 100) > 0 && u2 < 200 ? n2 * e2 / 100 / (u2 <= 100 ? u2 : 200 - u2) * 100 : 0, l: u2 / 2, a: t3.a };
var t3, n2, e2, u2;
};
var l = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
var p = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
var v = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
var m = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
var y = { string: [[function(r2) {
var t3 = i.exec(r2);
return t3 ? (r2 = t3[1]).length <= 4 ? { r: parseInt(r2[0] + r2[0], 16), g: parseInt(r2[1] + r2[1], 16), b: parseInt(r2[2] + r2[2], 16), a: 4 === r2.length ? n(parseInt(r2[3] + r2[3], 16) / 255, 2) : 1 } : 6 === r2.length || 8 === r2.length ? { r: parseInt(r2.substr(0, 2), 16), g: parseInt(r2.substr(2, 2), 16), b: parseInt(r2.substr(4, 2), 16), a: 8 === r2.length ? n(parseInt(r2.substr(6, 2), 16) / 255, 2) : 1 } : null : null;
}, "hex"], [function(r2) {
var t3 = v.exec(r2) || m.exec(r2);
return t3 ? t3[2] !== t3[4] || t3[4] !== t3[6] ? null : a({ r: Number(t3[1]) / (t3[2] ? 100 / 255 : 1), g: Number(t3[3]) / (t3[4] ? 100 / 255 : 1), b: Number(t3[5]) / (t3[6] ? 100 / 255 : 1), a: void 0 === t3[7] ? 1 : Number(t3[7]) / (t3[8] ? 100 : 1) }) : null;
}, "rgb"], [function(t3) {
var n2 = l.exec(t3) || p.exec(t3);
if (!n2) return null;
var e2, u2, a2 = g({ h: (e2 = n2[1], u2 = n2[2], void 0 === u2 && (u2 = "deg"), Number(e2) * (r[u2] || 1)), s: Number(n2[3]), l: Number(n2[4]), a: void 0 === n2[5] ? 1 : Number(n2[5]) / (n2[6] ? 100 : 1) });
return f(a2);
}, "hsl"]], object: [[function(r2) {
var n2 = r2.r, e2 = r2.g, u2 = r2.b, o3 = r2.a, i2 = void 0 === o3 ? 1 : o3;
return t(n2) && t(e2) && t(u2) ? a({ r: Number(n2), g: Number(e2), b: Number(u2), a: Number(i2) }) : null;
}, "rgb"], [function(r2) {
var n2 = r2.h, e2 = r2.s, u2 = r2.l, a2 = r2.a, o3 = void 0 === a2 ? 1 : a2;
if (!t(n2) || !t(e2) || !t(u2)) return null;
var i2 = g({ h: Number(n2), s: Number(e2), l: Number(u2), a: Number(o3) });
return f(i2);
}, "hsl"], [function(r2) {
var n2 = r2.h, a2 = r2.s, o3 = r2.v, i2 = r2.a, s2 = void 0 === i2 ? 1 : i2;
if (!t(n2) || !t(a2) || !t(o3)) return null;
var h2 = (function(r3) {
return { h: u(r3.h), s: e(r3.s, 0, 100), v: e(r3.v, 0, 100), a: e(r3.a) };
})({ h: Number(n2), s: Number(a2), v: Number(o3), a: Number(s2) });
return b(h2);
}, "hsv"]] };
var N = function(r2, t3) {
for (var n2 = 0; n2 < t3.length; n2++) {
var e2 = t3[n2][0](r2);
if (e2) return [e2, t3[n2][1]];
}
return [null, void 0];
};
var x = function(r2) {
return "string" == typeof r2 ? N(r2.trim(), y.string) : "object" == typeof r2 && null !== r2 ? N(r2, y.object) : [null, void 0];
};
var M = function(r2, t3) {
var n2 = c(r2);
return { h: n2.h, s: e(n2.s + 100 * t3, 0, 100), l: n2.l, a: n2.a };
};
var H = function(r2) {
return (299 * r2.r + 587 * r2.g + 114 * r2.b) / 1e3 / 255;
};
var $ = function(r2, t3) {
var n2 = c(r2);
return { h: n2.h, s: n2.s, l: e(n2.l + 100 * t3, 0, 100), a: n2.a };
};
var j = (function() {
function r2(r3) {
this.parsed = x(r3)[0], this.rgba = this.parsed || { r: 0, g: 0, b: 0, a: 1 };
}
return r2.prototype.isValid = function() {
return null !== this.parsed;
}, r2.prototype.brightness = function() {
return n(H(this.rgba), 2);
}, r2.prototype.isDark = function() {
return H(this.rgba) < 0.5;
}, r2.prototype.isLight = function() {
return H(this.rgba) >= 0.5;
}, r2.prototype.toHex = function() {
return r3 = o(this.rgba), t3 = r3.r, e2 = r3.g, u2 = r3.b, i2 = (a2 = r3.a) < 1 ? s(n(255 * a2)) : "", "#" + s(t3) + s(e2) + s(u2) + i2;
var r3, t3, e2, u2, a2, i2;
}, r2.prototype.toRgb = function() {
return o(this.rgba);
}, r2.prototype.toRgbString = function() {
return r3 = o(this.rgba), t3 = r3.r, n2 = r3.g, e2 = r3.b, (u2 = r3.a) < 1 ? "rgba(" + t3 + ", " + n2 + ", " + e2 + ", " + u2 + ")" : "rgb(" + t3 + ", " + n2 + ", " + e2 + ")";
var r3, t3, n2, e2, u2;
}, r2.prototype.toHsl = function() {
return d(c(this.rgba));
}, r2.prototype.toHslString = function() {
return r3 = d(c(this.rgba)), t3 = r3.h, n2 = r3.s, e2 = r3.l, (u2 = r3.a) < 1 ? "hsla(" + t3 + ", " + n2 + "%, " + e2 + "%, " + u2 + ")" : "hsl(" + t3 + ", " + n2 + "%, " + e2 + "%)";
var r3, t3, n2, e2, u2;
}, r2.prototype.toHsv = function() {
return r3 = h(this.rgba), { h: n(r3.h), s: n(r3.s), v: n(r3.v), a: n(r3.a, 3) };
var r3;
}, r2.prototype.invert = function() {
return w({ r: 255 - (r3 = this.rgba).r, g: 255 - r3.g, b: 255 - r3.b, a: r3.a });
var r3;
}, r2.prototype.saturate = function(r3) {
return void 0 === r3 && (r3 = 0.1), w(M(this.rgba, r3));
}, r2.prototype.desaturate = function(r3) {
return void 0 === r3 && (r3 = 0.1), w(M(this.rgba, -r3));
}, r2.prototype.grayscale = function() {
return w(M(this.rgba, -1));
}, r2.prototype.lighten = function(r3) {
return void 0 === r3 && (r3 = 0.1), w($(this.rgba, r3));
}, r2.prototype.darken = function(r3) {
return void 0 === r3 && (r3 = 0.1), w($(this.rgba, -r3));
}, r2.prototype.rotate = function(r3) {
return void 0 === r3 && (r3 = 15), this.hue(this.hue() + r3);
}, r2.prototype.alpha = function(r3) {
return "number" == typeof r3 ? w({ r: (t3 = this.rgba).r, g: t3.g, b: t3.b, a: r3 }) : n(this.rgba.a, 3);
var t3;
}, r2.prototype.hue = function(r3) {
var t3 = c(this.rgba);
return "number" == typeof r3 ? w({ h: r3, s: t3.s, l: t3.l, a: t3.a }) : n(t3.h);
}, r2.prototype.isEqual = function(r3) {
return this.toHex() === w(r3).toHex();
}, r2;
})();
var w = function(r2) {
return r2 instanceof j ? r2 : new j(r2);
};
var S = [];
var k = function(r2) {
r2.forEach(function(r3) {
S.indexOf(r3) < 0 && (r3(j, y), S.push(r3));
});
};
// node_modules/colord/plugins/names.mjs
function names_default(e2, f2) {
var a2 = { white: "#ffffff", bisque: "#ffe4c4", blue: "#0000ff", cadetblue: "#5f9ea0", chartreuse: "#7fff00", chocolate: "#d2691e", coral: "#ff7f50", antiquewhite: "#faebd7", aqua: "#00ffff", azure: "#f0ffff", whitesmoke: "#f5f5f5", papayawhip: "#ffefd5", plum: "#dda0dd", blanchedalmond: "#ffebcd", black: "#000000", gold: "#ffd700", goldenrod: "#daa520", gainsboro: "#dcdcdc", cornsilk: "#fff8dc", cornflowerblue: "#6495ed", burlywood: "#deb887", aquamarine: "#7fffd4", beige: "#f5f5dc", crimson: "#dc143c", cyan: "#00ffff", darkblue: "#00008b", darkcyan: "#008b8b", darkgoldenrod: "#b8860b", darkkhaki: "#bdb76b", darkgray: "#a9a9a9", darkgreen: "#006400", darkgrey: "#a9a9a9", peachpuff: "#ffdab9", darkmagenta: "#8b008b", darkred: "#8b0000", darkorchid: "#9932cc", darkorange: "#ff8c00", darkslateblue: "#483d8b", gray: "#808080", darkslategray: "#2f4f4f", darkslategrey: "#2f4f4f", deeppink: "#ff1493", deepskyblue: "#00bfff", wheat: "#f5deb3", firebrick: "#b22222", floralwhite: "#fffaf0", ghostwhite: "#f8f8ff", darkviolet: "#9400d3", magenta: "#ff00ff", green: "#008000", dodgerblue: "#1e90ff", grey: "#808080", honeydew: "#f0fff0", hotpink: "#ff69b4", blueviolet: "#8a2be2", forestgreen: "#228b22", lawngreen: "#7cfc00", indianred: "#cd5c5c", indigo: "#4b0082", fuchsia: "#ff00ff", brown: "#a52a2a", maroon: "#800000", mediumblue: "#0000cd", lightcoral: "#f08080", darkturquoise: "#00ced1", lightcyan: "#e0ffff", ivory: "#fffff0", lightyellow: "#ffffe0", lightsalmon: "#ffa07a", lightseagreen: "#20b2aa", linen: "#faf0e6", mediumaquamarine: "#66cdaa", lemonchiffon: "#fffacd", lime: "#00ff00", khaki: "#f0e68c", mediumseagreen: "#3cb371", limegreen: "#32cd32", mediumspringgreen: "#00fa9a", lightskyblue: "#87cefa", lightblue: "#add8e6", midnightblue: "#191970", lightpink: "#ffb6c1", mistyrose: "#ffe4e1", moccasin: "#ffe4b5", mintcream: "#f5fffa", lightslategray: "#778899", lightslategrey: "#778899", navajowhite: "#ffdead", navy: "#000080", mediumvioletred: "#c71585", powderblue: "#b0e0e6", palegoldenrod: "#eee8aa", oldlace: "#fdf5e6", paleturquoise: "#afeeee", mediumturquoise: "#48d1cc", mediumorchid: "#ba55d3", rebeccapurple: "#663399", lightsteelblue: "#b0c4de", mediumslateblue: "#7b68ee", thistle: "#d8bfd8", tan: "#d2b48c", orchid: "#da70d6", mediumpurple: "#9370db", purple: "#800080", pink: "#ffc0cb", skyblue: "#87ceeb", springgreen: "#00ff7f", palegreen: "#98fb98", red: "#ff0000", yellow: "#ffff00", slateblue: "#6a5acd", lavenderblush: "#fff0f5", peru: "#cd853f", palevioletred: "#db7093", violet: "#ee82ee", teal: "#008080", slategray: "#708090", slategrey: "#708090", aliceblue: "#f0f8ff", darkseagreen: "#8fbc8f", darkolivegreen: "#556b2f", greenyellow: "#adff2f", seagreen: "#2e8b57", seashell: "#fff5ee", tomato: "#ff6347", silver: "#c0c0c0", sienna: "#a0522d", lavender: "#e6e6fa", lightgreen: "#90ee90", orange: "#ffa500", orangered: "#ff4500", steelblue: "#4682b4", royalblue: "#4169e1", turquoise: "#40e0d0", yellowgreen: "#9acd32", salmon: "#fa8072", saddlebrown: "#8b4513", sandybrown: "#f4a460", rosybrown: "#bc8f8f", darksalmon: "#e9967a", lightgoldenrodyellow: "#fafad2", snow: "#fffafa", lightgrey: "#d3d3d3", lightgray: "#d3d3d3", dimgray: "#696969", dimgrey: "#696969", olivedrab: "#6b8e23", olive: "#808000" }, r2 = {};
for (var d3 in a2) r2[a2[d3]] = d3;
var l4 = {};
e2.prototype.toName = function(f3) {
if (!(this.rgba.a || this.rgba.r || this.rgba.g || this.rgba.b)) return "transparent";
var d4, i2, n2 = r2[this.toHex()];
if (n2) return n2;
if (null == f3 ? void 0 : f3.closest) {
var o3 = this.toRgb(), t3 = 1 / 0, b3 = "black";
if (!l4.length) for (var c2 in a2) l4[c2] = new e2(a2[c2]).toRgb();
for (var g3 in a2) {
var u2 = (d4 = o3, i2 = l4[g3], Math.pow(d4.r - i2.r, 2) + Math.pow(d4.g - i2.g, 2) + Math.pow(d4.b - i2.b, 2));
u2 < t3 && (t3 = u2, b3 = g3);
}
return b3;
}
};
f2.string.push([function(f3) {
var r3 = f3.toLowerCase(), d4 = "transparent" === r3 ? "#0000" : a2[r3];
return d4 ? new e2(d4).toRgb() : null;
}, "name"]);
}
// node_modules/colord/plugins/a11y.mjs
var o2 = function(o3) {
var t3 = o3 / 255;
return t3 < 0.04045 ? t3 / 12.92 : Math.pow((t3 + 0.055) / 1.055, 2.4);
};
var t2 = function(t3) {
return 0.2126 * o2(t3.r) + 0.7152 * o2(t3.g) + 0.0722 * o2(t3.b);
};
function a11y_default(o3) {
o3.prototype.luminance = function() {
return o4 = t2(this.rgba), void 0 === (r2 = 2) && (r2 = 0), void 0 === n2 && (n2 = Math.pow(10, r2)), Math.round(n2 * o4) / n2 + 0;
var o4, r2, n2;
}, o3.prototype.contrast = function(r2) {
void 0 === r2 && (r2 = "#FFF");
var n2, a2, i2, e2, v3, u2, d3, c2 = r2 instanceof o3 ? r2 : new o3(r2);
return e2 = this.rgba, v3 = c2.toRgb(), u2 = t2(e2), d3 = t2(v3), n2 = u2 > d3 ? (u2 + 0.05) / (d3 + 0.05) : (d3 + 0.05) / (u2 + 0.05), void 0 === (a2 = 2) && (a2 = 0), void 0 === i2 && (i2 = Math.pow(10, a2)), Math.floor(i2 * n2) / i2 + 0;
}, o3.prototype.isReadable = function(o4, t3) {
return void 0 === o4 && (o4 = "#FFF"), void 0 === t3 && (t3 = {}), this.contrast(o4) >= (e2 = void 0 === (i2 = (r2 = t3).size) ? "normal" : i2, "AAA" === (a2 = void 0 === (n2 = r2.level) ? "AA" : n2) && "normal" === e2 ? 7 : "AA" === a2 && "large" === e2 ? 3 : 4.5);
var r2, n2, a2, i2, e2;
};
}
// packages/blocks/build-module/api/utils.mjs
var import_element = __toESM(require_element(), 1);
var import_i18n2 = __toESM(require_i18n(), 1);
var import_dom = __toESM(require_dom(), 1);
var import_rich_text = __toESM(require_rich_text(), 1);
var import_deprecated = __toESM(require_deprecated(), 1);
// packages/blocks/build-module/api/constants.mjs
var BLOCK_ICON_DEFAULT = "block-default";
var DEPRECATED_ENTRY_KEYS = [
"attributes",
"supports",
"save",
"migrate",
"isEligible",
"apiVersion"
];
var __EXPERIMENTAL_STYLE_PROPERTY = {
// Kept for back-compatibility purposes.
"--wp--style--color--link": {
value: ["color", "link"],
support: ["color", "link"]
},
aspectRatio: {
value: ["dimensions", "aspectRatio"],
support: ["dimensions", "aspectRatio"],
useEngine: true
},
background: {
value: ["color", "gradient"],
support: ["color", "gradients"],
useEngine: true
},
backgroundColor: {
value: ["color", "background"],
support: ["color", "background"],
requiresOptOut: true,
useEngine: true
},
backgroundImage: {
value: ["background", "backgroundImage"],
support: ["background", "backgroundImage"],
useEngine: true
},
backgroundRepeat: {
value: ["background", "backgroundRepeat"],
support: ["background", "backgroundRepeat"],
useEngine: true
},
backgroundSize: {
value: ["background", "backgroundSize"],
support: ["background", "backgroundSize"],
useEngine: true
},
backgroundPosition: {
value: ["background", "backgroundPosition"],
support: ["background", "backgroundPosition"],
useEngine: true
},
backgroundGradient: {
value: ["background", "gradient"],
support: ["background", "gradient"],
useEngine: true
},
borderColor: {
value: ["border", "color"],
support: ["__experimentalBorder", "color"],
useEngine: true
},
borderRadius: {
value: ["border", "radius"],
support: ["__experimentalBorder", "radius"],
properties: {
borderTopLeftRadius: "topLeft",
borderTopRightRadius: "topRight",
borderBottomLeftRadius: "bottomLeft",
borderBottomRightRadius: "bottomRight"
},
useEngine: true
},
borderStyle: {
value: ["border", "style"],
support: ["__experimentalBorder", "style"],
useEngine: true
},
borderWidth: {
value: ["border", "width"],
support: ["__experimentalBorder", "width"],
useEngine: true
},
borderTopColor: {
value: ["border", "top", "color"],
support: ["__experimentalBorder", "color"],
useEngine: true
},
borderTopStyle: {
value: ["border", "top", "style"],
support: ["__experimentalBorder", "style"],
useEngine: true
},
borderTopWidth: {
value: ["border", "top", "width"],
support: ["__experimentalBorder", "width"],
useEngine: true
},
borderRightColor: {
value: ["border", "right", "color"],
support: ["__experimentalBorder", "color"],
useEngine: true
},
borderRightStyle: {
value: ["border", "right", "style"],
support: ["__experimentalBorder", "style"],
useEngine: true
},
borderRightWidth: {
value: ["border", "right", "width"],
support: ["__experimentalBorder", "width"],
useEngine: true
},
borderBottomColor: {
value: ["border", "bottom", "color"],
support: ["__experimentalBorder", "color"],
useEngine: true
},
borderBottomStyle: {
value: ["border", "bottom", "style"],
support: ["__experimentalBorder", "style"],
useEngine: true
},
borderBottomWidth: {
value: ["border", "bottom", "width"],
support: ["__experimentalBorder", "width"],
useEngine: true
},
borderLeftColor: {
value: ["border", "left", "color"],
support: ["__experimentalBorder", "color"],
useEngine: true
},
borderLeftStyle: {
value: ["border", "left", "style"],
support: ["__experimentalBorder", "style"],
useEngine: true
},
borderLeftWidth: {
value: ["border", "left", "width"],
support: ["__experimentalBorder", "width"],
useEngine: true
},
color: {
value: ["color", "text"],
support: ["color", "text"],
requiresOptOut: true,
useEngine: true
},
columnCount: {
value: ["typography", "textColumns"],
support: ["typography", "textColumns"],
useEngine: true
},
filter: {
value: ["filter", "duotone"],
support: ["filter", "duotone"]
},
linkColor: {
value: ["elements", "link", "color", "text"],
support: ["color", "link"]
},
captionColor: {
value: ["elements", "caption", "color", "text"],
support: ["color", "caption"]
},
buttonColor: {
value: ["elements", "button", "color", "text"],
support: ["color", "button"]
},
buttonBackgroundColor: {
value: ["elements", "button", "color", "background"],
support: ["color", "button"]
},
headingColor: {
value: ["elements", "heading", "color", "text"],
support: ["color", "heading"]
},
headingBackgroundColor: {
value: ["elements", "heading", "color", "background"],
support: ["color", "heading"]
},
fontFamily: {
value: ["typography", "fontFamily"],
support: ["typography", "__experimentalFontFamily"],
useEngine: true
},
fontSize: {
value: ["typography", "fontSize"],
support: ["typography", "fontSize"],
useEngine: true
},
fontStyle: {
value: ["typography", "fontStyle"],
support: ["typography", "__experimentalFontStyle"],
useEngine: true
},
fontWeight: {
value: ["typography", "fontWeight"],
support: ["typography", "__experimentalFontWeight"],
useEngine: true
},
lineHeight: {
value: ["typography", "lineHeight"],
support: ["typography", "lineHeight"],
useEngine: true
},
margin: {
value: ["spacing", "margin"],
support: ["spacing", "margin"],
properties: {
marginTop: "top",
marginRight: "right",
marginBottom: "bottom",
marginLeft: "left"
},
useEngine: true
},
minHeight: {
value: ["dimensions", "minHeight"],
support: ["dimensions", "minHeight"],
useEngine: true
},
minWidth: {
value: ["dimensions", "minWidth"],
support: ["dimensions", "minWidth"],
useEngine: true
},
height: {
value: ["dimensions", "height"],
support: ["dimensions", "height"],
useEngine: true
},
width: {
value: ["dimensions", "width"],
support: ["dimensions", "width"],
useEngine: true
},
padding: {
value: ["spacing", "padding"],
support: ["spacing", "padding"],
properties: {
paddingTop: "top",
paddingRight: "right",
paddingBottom: "bottom",
paddingLeft: "left"
},
useEngine: true
},
textAlign: {
value: ["typography", "textAlign"],
support: ["typography", "textAlign"],
useEngine: false
},
textDecoration: {
value: ["typography", "textDecoration"],
support: ["typography", "__experimentalTextDecoration"],
useEngine: true
},
textTransform: {
value: ["typography", "textTransform"],
support: ["typography", "__experimentalTextTransform"],
useEngine: true
},
letterSpacing: {
value: ["typography", "letterSpacing"],
support: ["typography", "__experimentalLetterSpacing"],
useEngine: true
},
textIndent: {
value: ["typography", "textIndent"],
support: ["typography", "textIndent"],
useEngine: true
},
writingMode: {
value: ["typography", "writingMode"],
support: ["typography", "__experimentalWritingMode"],
useEngine: true
},
"--wp--style--root--padding": {
value: ["spacing", "padding"],
support: ["spacing", "padding"],
properties: {
"--wp--style--root--padding-top": "top",
"--wp--style--root--padding-right": "right",
"--wp--style--root--padding-bottom": "bottom",
"--wp--style--root--padding-left": "left"
},
rootOnly: true
}
};
var __EXPERIMENTAL_ELEMENTS = {
link: "a:where(:not(.wp-element-button))",
heading: "h1, h2, h3, h4, h5, h6",
h1: "h1",
h2: "h2",
h3: "h3",
h4: "h4",
h5: "h5",
h6: "h6",
button: ".wp-element-button, .wp-block-button__link",
caption: ".wp-element-caption, .wp-block-audio figcaption, .wp-block-embed figcaption, .wp-block-gallery figcaption, .wp-block-image figcaption, .wp-block-table figcaption, .wp-block-video figcaption",
cite: "cite",
select: "select",
textInput: "textarea, input:where([type=email],[type=number],[type=password],[type=search],[type=tel],[type=text],[type=url])"
};
var __EXPERIMENTAL_PATHS_WITH_OVERRIDE = {
"color.duotone": true,
"color.gradients": true,
"color.palette": true,
"dimensions.aspectRatios": true,
"typography.fontSizes": true,
"spacing.spacingSizes": true
};
// packages/blocks/build-module/api/registration.mjs
var import_data = __toESM(require_data(), 1);
var import_i18n = __toESM(require_i18n(), 1);
var import_warning = __toESM(require_warning(), 1);
// packages/blocks/build-module/api/i18n-block.json
var i18n_block_default = {
title: "block title",
description: "block description",
keywords: ["block keyword"],
styles: [
{
label: "block style label"
}
],
variations: [
{
title: "block variation title",
description: "block variation description",
keywords: ["block variation keyword"]
}
]
};
// packages/blocks/build-module/lock-unlock.mjs
var import_private_apis = __toESM(require_private_apis(), 1);
var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
"I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
"@wordpress/blocks"
);
// packages/blocks/build-module/api/registration.mjs
function isObject(object) {
return object !== null && typeof object === "object";
}
function unstable__bootstrapServerSideBlockDefinitions(definitions) {
const { addBootstrappedBlockType: addBootstrappedBlockType2 } = unlock((0, import_data.dispatch)(store));
for (const [name, blockType] of Object.entries(definitions)) {
addBootstrappedBlockType2(name, blockType);
}
}
function getBlockSettingsFromMetadata({
textdomain,
...metadata
}) {
const allowedFields = [
"apiVersion",
"title",
"category",
"parent",
"ancestor",
"icon",
"description",
"keywords",
"attributes",
"providesContext",
"usesContext",
"selectors",
"supports",
"styles",
"example",
"variations",
"blockHooks",
"allowedBlocks"
];
const settings = Object.fromEntries(
Object.entries(metadata).filter(
([key]) => allowedFields.includes(key)
)
);
if (textdomain) {
Object.keys(i18n_block_default).forEach((key) => {
if (!settings[key]) {
return;
}
settings[key] = translateBlockSettingUsingI18nSchema(
i18n_block_default[key],
settings[key],
textdomain
);
});
}
return settings;
}
function registerBlockType(blockNameOrMetadata, settings) {
const name = isObject(blockNameOrMetadata) ? blockNameOrMetadata.name : blockNameOrMetadata;
if (typeof name !== "string") {
(0, import_warning.default)("Block names must be strings.");
return;
}
if (!/^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/.test(name)) {
(0, import_warning.default)(
"Block names must contain a namespace prefix, include only lowercase alphanumeric characters or dashes, and start with a letter. Example: my-plugin/my-custom-block"
);
return;
}
if ((0, import_data.select)(store).getBlockType(name)) {
(0, import_warning.default)('Block "' + name + '" is already registered.');
return;
}
const { addBootstrappedBlockType: addBootstrappedBlockType2, addUnprocessedBlockType: addUnprocessedBlockType2 } = unlock(
(0, import_data.dispatch)(store)
);
if (isObject(blockNameOrMetadata)) {
const metadata = getBlockSettingsFromMetadata(blockNameOrMetadata);
addBootstrappedBlockType2(name, metadata);
}
addUnprocessedBlockType2(name, settings);
return (0, import_data.select)(store).getBlockType(name);
}
function translateBlockSettingUsingI18nSchema(i18nSchema, settingValue, textdomain) {
if (typeof i18nSchema === "string" && typeof settingValue === "string") {
return (0, import_i18n._x)(settingValue, i18nSchema, textdomain);
}
if (Array.isArray(i18nSchema) && i18nSchema.length && Array.isArray(settingValue)) {
return settingValue.map(
(value) => translateBlockSettingUsingI18nSchema(
i18nSchema[0],
value,
textdomain
)
);
}
if (isObject(i18nSchema) && Object.entries(i18nSchema).length && isObject(settingValue)) {
return Object.keys(settingValue).reduce(
(accumulator, key) => {
if (!i18nSchema[key]) {
accumulator[key] = settingValue[key];
return accumulator;
}
accumulator[key] = translateBlockSettingUsingI18nSchema(
i18nSchema[key],
settingValue[key],
textdomain
);
return accumulator;
},
{}
);
}
return settingValue;
}
function registerBlockCollection(namespace, { title, icon }) {
(0, import_data.dispatch)(store).addBlockCollection(namespace, title, icon);
}
function unregisterBlockType(name) {
const oldBlock = (0, import_data.select)(store).getBlockType(name);
if (!oldBlock) {
(0, import_warning.default)('Block "' + name + '" is not registered.');
return;
}
(0, import_data.dispatch)(store).removeBlockTypes(name);
return oldBlock;
}
function setFreeformContentHandlerName(blockName) {
(0, import_data.dispatch)(store).setFreeformFallbackBlockName(blockName);
}
function getFreeformContentHandlerName() {
return (0, import_data.select)(store).getFreeformFallbackBlockName();
}
function getGroupingBlockName() {
return (0, import_data.select)(store).getGroupingBlockName();
}
function setUnregisteredTypeHandlerName(blockName) {
(0, import_data.dispatch)(store).setUnregisteredFallbackBlockName(blockName);
}
function getUnregisteredTypeHandlerName() {
return (0, import_data.select)(store).getUnregisteredFallbackBlockName();
}
function setDefaultBlockName(name) {
(0, import_data.dispatch)(store).setDefaultBlockName(name);
}
function setGroupingBlockName(name) {
(0, import_data.dispatch)(store).setGroupingBlockName(name);
}
function getDefaultBlockName() {
return (0, import_data.select)(store).getDefaultBlockName();
}
function getBlockType(name) {
return (0, import_data.select)(store)?.getBlockType(name);
}
function getBlockTypes() {
return (0, import_data.select)(store).getBlockTypes();
}
function getBlockSupport(nameOrType, feature, defaultSupports) {
return (0, import_data.select)(store).getBlockSupport(
nameOrType,
feature,
defaultSupports
);
}
function hasBlockSupport(nameOrType, feature, defaultSupports) {
return (0, import_data.select)(store).hasBlockSupport(
nameOrType,
feature,
defaultSupports
);
}
function isReusableBlock(blockOrType) {
return blockOrType?.name === "core/block";
}
function isTemplatePart(blockOrType) {
return blockOrType?.name === "core/template-part";
}
var getChildBlockNames = (blockName) => {
return (0, import_data.select)(store).getChildBlockNames(blockName);
};
var hasChildBlocks = (blockName) => {
return (0, import_data.select)(store).hasChildBlocks(blockName);
};
var hasChildBlocksWithInserterSupport = (blockName) => {
return (0, import_data.select)(store).hasChildBlocksWithInserterSupport(blockName);
};
var registerBlockStyle = (blockNames, styleVariation) => {
(0, import_data.dispatch)(store).addBlockStyles(blockNames, styleVariation);
};
var unregisterBlockStyle = (blockName, styleVariationName) => {
(0, import_data.dispatch)(store).removeBlockStyles(blockName, styleVariationName);
};
var getBlockVariations = (blockName, scope) => {
return (0, import_data.select)(store).getBlockVariations(blockName, scope);
};
var registerBlockVariation = (blockName, variation) => {
if (Array.isArray(variation)) {
for (const v3 of variation) {
if (typeof v3.name !== "string") {
(0, import_warning.default)("Variation names must be unique strings.");
}
}
} else if (typeof variation.name !== "string") {
(0, import_warning.default)("Variation names must be unique strings.");
}
(0, import_data.dispatch)(store).addBlockVariations(blockName, variation);
};
var unregisterBlockVariation = (blockName, variationName) => {
(0, import_data.dispatch)(store).removeBlockVariations(blockName, variationName);
};
var registerBlockBindingsSource = (source) => {
const {
name,
label,
usesContext,
getValues,
setValues,
canUserEditValue,
getFieldsList
} = source;
const existingSource = unlock(
(0, import_data.select)(store)
).getBlockBindingsSource(name);
const serverProps = ["label", "usesContext"];
for (const prop2 in existingSource) {
if (!serverProps.includes(prop2) && existingSource[prop2]) {
(0, import_warning.default)(
'Block bindings source "' + name + '" is already registered.'
);
return;
}
}
if (!name) {
(0, import_warning.default)("Block bindings source must contain a name.");
return;
}
if (typeof name !== "string") {
(0, import_warning.default)("Block bindings source name must be a string.");
return;
}
if (/[A-Z]+/.test(name)) {
(0, import_warning.default)(
"Block bindings source name must not contain uppercase characters."
);
return;
}
if (!/^[a-z0-9/-]+$/.test(name)) {
(0, import_warning.default)(
"Block bindings source name must contain only valid characters: lowercase characters, hyphens, or digits. Example: my-plugin/my-custom-source."
);
return;
}
if (!/^[a-z0-9-]+\/[a-z0-9-]+$/.test(name)) {
(0, import_warning.default)(
"Block bindings source name must contain a namespace and valid characters. Example: my-plugin/my-custom-source."
);
return;
}
if (!label && !existingSource?.label) {
(0, import_warning.default)("Block bindings source must contain a label.");
return;
}
if (label && typeof label !== "string") {
(0, import_warning.default)("Block bindings source label must be a string.");
return;
}
if (label && existingSource?.label && label !== existingSource?.label) {
(0, import_warning.default)('Block bindings "' + name + '" source label was overridden.');
}
if (usesContext && !Array.isArray(usesContext)) {
(0, import_warning.default)("Block bindings source usesContext must be an array.");
return;
}
if (getValues && typeof getValues !== "function") {
(0, import_warning.default)("Block bindings source getValues must be a function.");
return;
}
if (setValues && typeof setValues !== "function") {
(0, import_warning.default)("Block bindings source setValues must be a function.");
return;
}
if (canUserEditValue && typeof canUserEditValue !== "function") {
(0, import_warning.default)("Block bindings source canUserEditValue must be a function.");
return;
}
if (getFieldsList && typeof getFieldsList !== "function") {
(0, import_warning.default)("Block bindings source getFieldsList must be a function.");
return;
}
return unlock((0, import_data.dispatch)(store)).addBlockBindingsSource(source);
};
function unregisterBlockBindingsSource(name) {
const oldSource = getBlockBindingsSource(name);
if (!oldSource) {
(0, import_warning.default)('Block bindings source "' + name + '" is not registered.');
return;
}
unlock((0, import_data.dispatch)(store)).removeBlockBindingsSource(name);
}
function getBlockBindingsSource(name) {
return unlock((0, import_data.select)(store)).getBlockBindingsSource(name);
}
function getBlockBindingsSources() {
return unlock((0, import_data.select)(store)).getAllBlockBindingsSources();
}
// packages/blocks/build-module/api/utils.mjs
k([names_default, a11y_default]);
var ICON_COLORS = ["#191e23", "#f8f9f9"];
function isUnmodifiedBlock(block, role) {
const blockAttributes = getBlockType(block.name)?.attributes ?? {};
const attributesByRole = role ? Object.entries(blockAttributes).filter(([key, definition]) => {
if (role === "content" && key === "metadata") {
return Object.keys(
block.attributes[key]?.bindings ?? {}
).length > 0;
}
return definition.role === role || definition.__experimentalRole === role;
}) : [];
const attributesToCheck = !!attributesByRole.length ? attributesByRole : Object.entries(blockAttributes);
return attributesToCheck.every(([key, definition]) => {
const value = block.attributes[key];
if (definition.hasOwnProperty("default")) {
return value === definition.default;
}
if (definition.type === "rich-text") {
return !value?.length;
}
return value === void 0;
});
}
function isUnmodifiedDefaultBlock(block, role) {
return block.name === getDefaultBlockName() && isUnmodifiedBlock(block, role);
}
function isValidIcon(icon) {
return !!icon && (typeof icon === "string" || (0, import_element.isValidElement)(icon) || typeof icon === "function" || icon instanceof import_element.Component);
}
function normalizeIconObject(icon) {
const resolvedIcon = icon || BLOCK_ICON_DEFAULT;
if (isValidIcon(resolvedIcon)) {
return { src: resolvedIcon };
}
const iconDescriptor = resolvedIcon;
if ("background" in iconDescriptor) {
const colordBgColor = w(iconDescriptor.background);
const getColorContrast = (iconColor) => colordBgColor.contrast(iconColor);
const maxContrast = Math.max(...ICON_COLORS.map(getColorContrast));
return {
...iconDescriptor,
foreground: iconDescriptor.foreground ? iconDescriptor.foreground : ICON_COLORS.find(
(iconColor) => getColorContrast(iconColor) === maxContrast
),
shadowColor: colordBgColor.alpha(0.3).toRgbString()
};
}
return iconDescriptor;
}
function normalizeBlockType(blockTypeOrName) {
if (typeof blockTypeOrName === "string") {
return getBlockType(blockTypeOrName);
}
return blockTypeOrName;
}
function getBlockLabel(blockType, attributes, context = "visual") {
const { __experimentalLabel: getLabel, title } = blockType;
const label = getLabel && getLabel(attributes, { context });
if (!label) {
return title;
}
if (label.toPlainText) {
return label.toPlainText();
}
return (0, import_dom.__unstableStripHTML)(label);
}
function getAccessibleBlockLabel(blockType, attributes, position, direction = "vertical") {
const title = blockType?.title ?? "";
const label = blockType ? getBlockLabel(blockType, attributes, "accessibility") : "";
const hasPosition = position !== void 0;
const hasLabel = label && label !== title;
if (hasPosition && direction === "vertical") {
if (hasLabel) {
return (0, import_i18n2.sprintf)(
/* translators: accessibility text. 1: The block title. 2: The block row number. 3: The block label.. */
(0, import_i18n2.__)("%1$s Block. Row %2$d. %3$s"),
title,
position,
label
);
}
return (0, import_i18n2.sprintf)(
/* translators: accessibility text. 1: The block title. 2: The block row number. */
(0, import_i18n2.__)("%1$s Block. Row %2$d"),
title,
position
);
} else if (hasPosition && direction === "horizontal") {
if (hasLabel) {
return (0, import_i18n2.sprintf)(
/* translators: accessibility text. 1: The block title. 2: The block column number. 3: The block label.. */
(0, import_i18n2.__)("%1$s Block. Column %2$d. %3$s"),
title,
position,
label
);
}
return (0, import_i18n2.sprintf)(
/* translators: accessibility text. 1: The block title. 2: The block column number. */
(0, import_i18n2.__)("%1$s Block. Column %2$d"),
title,
position
);
}
if (hasLabel) {
return (0, import_i18n2.sprintf)(
/* translators: accessibility text. 1: The block title. 2: The block label. */
(0, import_i18n2.__)("%1$s Block. %2$s"),
title,
label
);
}
return (0, import_i18n2.sprintf)(
/* translators: accessibility text. %s: The block title. */
(0, import_i18n2.__)("%s Block"),
title
);
}
function getDefault(attributeSchema) {
if (attributeSchema.default !== void 0) {
return attributeSchema.default;
}
if (attributeSchema.type === "rich-text") {
return new import_rich_text.RichTextData();
}
return void 0;
}
function isBlockRegistered(name) {
return getBlockType(name) !== void 0;
}
function sanitizeBlockAttributes(name, attributes) {
const blockType = getBlockType(name);
if (void 0 === blockType) {
throw new Error(`Block type '${name}' is not registered.`);
}
return Object.entries(blockType.attributes).reduce(
(accumulator, [key, schema]) => {
const value = attributes[key];
if (void 0 !== value) {
if (schema.type === "rich-text") {
if (value instanceof import_rich_text.RichTextData) {
accumulator[key] = value;
} else if (typeof value === "string") {
accumulator[key] = import_rich_text.RichTextData.fromHTMLString(value);
}
} else if (schema.type === "string" && value instanceof import_rich_text.RichTextData) {
accumulator[key] = value.toHTMLString();
} else {
accumulator[key] = value;
}
} else {
const _default = getDefault(schema);
if (void 0 !== _default) {
accumulator[key] = _default;
}
}
if (["node", "children"].indexOf(schema.source ?? "") !== -1) {
if (typeof accumulator[key] === "string") {
accumulator[key] = [accumulator[key]];
} else if (!Array.isArray(accumulator[key])) {
accumulator[key] = [];
}
}
return accumulator;
},
{}
);
}
function __experimentalSanitizeBlockAttributes(name, attributes) {
(0, import_deprecated.default)("__experimentalSanitizeBlockAttributes", {
since: "7.1",
alternative: "sanitizeBlockAttributes"
});
return sanitizeBlockAttributes(name, attributes);
}
function getBlockAttributesNamesByRole(name, role) {
const attributes = getBlockType(name)?.attributes;
if (!attributes) {
return [];
}
const attributesNames = Object.keys(attributes);
if (!role) {
return attributesNames;
}
return attributesNames.filter((attributeName) => {
const attribute = attributes[attributeName];
if (attribute?.role === role) {
return true;
}
if (attribute?.__experimentalRole === role) {
(0, import_deprecated.default)("__experimentalRole attribute", {
since: "6.7",
version: "6.8",
alternative: "role attribute",
hint: `Check the block.json of the ${name} block.`
});
return true;
}
return false;
});
}
var __experimentalGetBlockAttributesNamesByRole = (...args) => {
(0, import_deprecated.default)("__experimentalGetBlockAttributesNamesByRole", {
since: "6.7",
version: "6.8",
alternative: "getBlockAttributesNamesByRole"
});
return getBlockAttributesNamesByRole(...args);
};
function isContentBlock(name) {
const blockType = getBlockType(name);
const attributes = blockType?.attributes;
const supportsContentRole = blockType?.supports?.contentRole;
if (supportsContentRole) {
return true;
}
if (!attributes) {
return false;
}
return !!Object.keys(attributes)?.some((attributeKey) => {
const attribute = attributes[attributeKey];
return attribute?.role === "content" || attribute?.__experimentalRole === "content";
});
}
function omit(object, keys) {
const keysArray = Array.isArray(keys) ? keys : [keys];
return Object.fromEntries(
Object.entries(object).filter(
([key]) => !keysArray.includes(key)
)
);
}
// packages/blocks/build-module/store/reducer.mjs
var DEFAULT_CATEGORIES = [
{ slug: "text", title: (0, import_i18n3.__)("Text") },
{ slug: "media", title: (0, import_i18n3.__)("Media") },
{ slug: "design", title: (0, import_i18n3.__)("Design") },
{ slug: "widgets", title: (0, import_i18n3.__)("Widgets") },
{ slug: "theme", title: (0, import_i18n3.__)("Theme") },
{ slug: "embed", title: (0, import_i18n3.__)("Embeds") },
{ slug: "reusable", title: (0, import_i18n3.__)("Reusable blocks") }
];
function keyBlockTypesByName(types) {
return types.reduce(
(newBlockTypes, block) => ({
...newBlockTypes,
[block.name]: block
}),
{}
);
}
function getUniqueItemsByName(items) {
return items.reduce((acc, currentItem) => {
if (!acc.some((item) => item.name === currentItem.name)) {
acc.push(currentItem);
}
return acc;
}, []);
}
function bootstrappedBlockTypes(state = {}, action) {
switch (action.type) {
case "ADD_BOOTSTRAPPED_BLOCK_TYPE":
const { name, blockType } = action;
const serverDefinition = state[name];
if (serverDefinition) {
return state;
}
const newDefinition = Object.fromEntries(
Object.entries(blockType).filter(
([, value]) => value !== null && value !== void 0
).map(([key, value]) => [camelCase(key), value])
);
newDefinition.name = name;
return {
...state,
[name]: newDefinition
};
case "REMOVE_BLOCK_TYPES":
return omit(state, action.names);
}
return state;
}
function unprocessedBlockTypes(state = {}, action) {
switch (action.type) {
case "ADD_UNPROCESSED_BLOCK_TYPE":
return {
...state,
[action.name]: action.blockType
};
case "REMOVE_BLOCK_TYPES":
return omit(state, action.names);
}
return state;
}
function blockTypes(state = {}, action) {
switch (action.type) {
case "ADD_BLOCK_TYPES":
return {
...state,
...keyBlockTypesByName(action.blockTypes)
};
case "REMOVE_BLOCK_TYPES":
return omit(state, action.names);
}
return state;
}
function blockStyles(state = {}, action) {
switch (action.type) {
case "ADD_BLOCK_TYPES":
return {
...state,
...Object.fromEntries(
Object.entries(
keyBlockTypesByName(action.blockTypes)
).map(([name, blockType]) => [
name,
getUniqueItemsByName([
...(blockType.styles ?? []).map((style) => ({
...style,
source: "block"
})),
...(state[blockType.name] ?? []).filter(
({ source }) => "block" !== source
)
])
])
)
};
case "ADD_BLOCK_STYLES":
const updatedStyles = {};
action.blockNames.forEach((blockName) => {
updatedStyles[blockName] = getUniqueItemsByName([
...state[blockName] ?? [],
...action.styles
]);
});
return { ...state, ...updatedStyles };
case "REMOVE_BLOCK_STYLES":
return {
...state,
[action.blockName]: (state[action.blockName] ?? []).filter(
(style) => action.styleNames.indexOf(style.name) === -1
)
};
}
return state;
}
function blockVariations(state = {}, action) {
switch (action.type) {
case "ADD_BLOCK_TYPES":
return {
...state,
...Object.fromEntries(
Object.entries(
keyBlockTypesByName(action.blockTypes)
).map(([name, blockType]) => {
return [
name,
getUniqueItemsByName([
...(blockType.variations ?? []).map(
(variation) => ({
...variation,
source: "block"
})
),
...(state[blockType.name] ?? []).filter(
({ source }) => "block" !== source
)
])
];
})
)
};
case "ADD_BLOCK_VARIATIONS":
return {
...state,
[action.blockName]: getUniqueItemsByName([
...state[action.blockName] ?? [],
...action.variations
])
};
case "REMOVE_BLOCK_VARIATIONS":
return {
...state,
[action.blockName]: (state[action.blockName] ?? []).filter(
(variation) => action.variationNames.indexOf(variation.name) === -1
)
};
}
return state;
}
function createBlockNameSetterReducer(setActionType) {
return (state = null, action) => {
switch (action.type) {
case "REMOVE_BLOCK_TYPES":
if (action.names.indexOf(state) !== -1) {
return null;
}
return state;
case setActionType:
return action.name || null;
}
return state;
};
}
var defaultBlockName = createBlockNameSetterReducer(
"SET_DEFAULT_BLOCK_NAME"
);
var freeformFallbackBlockName = createBlockNameSetterReducer(
"SET_FREEFORM_FALLBACK_BLOCK_NAME"
);
var unregisteredFallbackBlockName = createBlockNameSetterReducer(
"SET_UNREGISTERED_FALLBACK_BLOCK_NAME"
);
var groupingBlockName = createBlockNameSetterReducer(
"SET_GROUPING_BLOCK_NAME"
);
function categories(state = DEFAULT_CATEGORIES, action) {
switch (action.type) {
case "SET_CATEGORIES":
const uniqueCategories = /* @__PURE__ */ new Map();
(action.categories || []).forEach((category) => {
uniqueCategories.set(category.slug, category);
});
return [...uniqueCategories.values()];
case "UPDATE_CATEGORY": {
if (!action.category || !Object.keys(action.category).length) {
return state;
}
const categoryToChange = state.find(
({ slug }) => slug === action.slug
);
if (categoryToChange) {
return state.map((category) => {
if (category.slug === action.slug) {
return {
...category,
...action.category
};
}
return category;
});
}
}
}
return state;
}
function collections(state = {}, action) {
switch (action.type) {
case "ADD_BLOCK_COLLECTION":
return {
...state,
[action.namespace]: {
title: action.title,
icon: action.icon
}
};
case "REMOVE_BLOCK_COLLECTION":
return omit(state, action.namespace);
}
return state;
}
function getMergedUsesContext(existingUsesContext = [], newUsesContext = []) {
const mergedArrays = Array.from(
new Set(existingUsesContext.concat(newUsesContext))
);
return mergedArrays.length > 0 ? mergedArrays : void 0;
}
function blockBindingsSources(state = {}, action) {
switch (action.type) {
case "ADD_BLOCK_BINDINGS_SOURCE":
return {
...state,
[action.name]: {
label: action.label || state[action.name]?.label,
usesContext: getMergedUsesContext(
state[action.name]?.usesContext,
action.usesContext
),
getValues: action.getValues,
setValues: action.setValues,
// Only set `canUserEditValue` if `setValues` is also defined.
canUserEditValue: action.setValues && action.canUserEditValue,
getFieldsList: action.getFieldsList
}
};
case "REMOVE_BLOCK_BINDINGS_SOURCE":
return omit(state, action.name);
}
return state;
}
var reducer_default = (0, import_data2.combineReducers)({
bootstrappedBlockTypes,
unprocessedBlockTypes,
blockTypes,
blockStyles,
blockVariations,
defaultBlockName,
freeformFallbackBlockName,
unregisteredFallbackBlockName,
groupingBlockName,
categories,
collections,
blockBindingsSources
});
// packages/blocks/build-module/store/selectors.mjs
var selectors_exports = {};
__export(selectors_exports, {
__experimentalHasContentRoleAttribute: () => __experimentalHasContentRoleAttribute,
getActiveBlockVariation: () => getActiveBlockVariation,
getBlockStyles: () => getBlockStyles,
getBlockSupport: () => getBlockSupport2,
getBlockType: () => getBlockType2,
getBlockTypes: () => getBlockTypes2,
getBlockVariations: () => getBlockVariations2,
getCategories: () => getCategories,
getChildBlockNames: () => getChildBlockNames2,
getCollections: () => getCollections,
getDefaultBlockName: () => getDefaultBlockName2,
getDefaultBlockVariation: () => getDefaultBlockVariation,
getFreeformFallbackBlockName: () => getFreeformFallbackBlockName,
getGroupingBlockName: () => getGroupingBlockName2,
getUnregisteredFallbackBlockName: () => getUnregisteredFallbackBlockName,
hasBlockSupport: () => hasBlockSupport2,
hasChildBlocks: () => hasChildBlocks2,
hasChildBlocksWithInserterSupport: () => hasChildBlocksWithInserterSupport2,
isMatchingSearchTerm: () => isMatchingSearchTerm
});
var import_remove_accents = __toESM(require_remove_accents(), 1);
var import_es6 = __toESM(require_es6(), 1);
var import_data4 = __toESM(require_data(), 1);
var import_rich_text2 = __toESM(require_rich_text(), 1);
var import_deprecated3 = __toESM(require_deprecated(), 1);
// packages/blocks/build-module/store/utils.mjs
var getValueFromObjectPath = (object, path, defaultValue) => {
const normalizedPath = Array.isArray(path) ? path : path.split(".");
let value = object;
normalizedPath.forEach((fieldName) => {
value = value?.[fieldName];
});
return value ?? defaultValue;
};
function isObject2(candidate) {
return typeof candidate === "object" && candidate !== null && candidate.constructor === Object;
}
function matchesAttributes(blockAttributes, variationAttributes) {
if (isObject2(blockAttributes) && isObject2(variationAttributes)) {
return Object.entries(variationAttributes).every(
([key, value]) => matchesAttributes(blockAttributes?.[key], value)
);
}
return blockAttributes === variationAttributes;
}
// packages/blocks/build-module/store/private-selectors.mjs
var private_selectors_exports = {};
__export(private_selectors_exports, {
getAllBlockBindingsSources: () => getAllBlockBindingsSources,
getBlockBindingsSource: () => getBlockBindingsSource2,
getBlockBindingsSourceFieldsList: () => getBlockBindingsSourceFieldsList,
getBootstrappedBlockType: () => getBootstrappedBlockType,
getSupportedStyles: () => getSupportedStyles,
getUnprocessedBlockTypes: () => getUnprocessedBlockTypes,
hasContentRoleAttribute: () => hasContentRoleAttribute
});
var import_data3 = __toESM(require_data(), 1);
var import_deprecated2 = __toESM(require_deprecated(), 1);
var ROOT_BLOCK_SUPPORTS = [
"background",
"backgroundColor",
"color",
"linkColor",
"captionColor",
"buttonColor",
"headingColor",
"fontFamily",
"fontSize",
"fontStyle",
"fontWeight",
"lineHeight",
"padding",
"contentSize",
"wideSize",
"blockGap",
"textAlign",
"textDecoration",
"textIndent",
"textTransform",
"letterSpacing"
];
function filterElementBlockSupports(blockSupports, name, element) {
return blockSupports.filter((support) => {
if (support === "fontSize" && element === "heading") {
return false;
}
if (support === "textDecoration" && !name && element !== "link") {
return false;
}
if (support === "textTransform" && !name && !(["heading", "h1", "h2", "h3", "h4", "h5", "h6"].includes(
element
) || element === "button" || element === "caption" || element === "text")) {
return false;
}
if (support === "letterSpacing" && !name && !(["heading", "h1", "h2", "h3", "h4", "h5", "h6"].includes(
element
) || element === "button" || element === "caption" || element === "text")) {
return false;
}
if (support === "textIndent" && !name) {
return false;
}
if (support === "textColumns" && !name) {
return false;
}
return true;
});
}
var getSupportedStyles = (0, import_data3.createSelector)(
(state, name, element) => {
if (!name) {
return filterElementBlockSupports(
ROOT_BLOCK_SUPPORTS,
name,
element
);
}
const blockType = getBlockType2(state, name);
if (!blockType) {
return [];
}
const supportKeys = [];
const supports = blockType?.supports;
if (supports?.spacing?.blockGap) {
supportKeys.push("blockGap");
}
if (supports?.shadow) {
supportKeys.push("shadow");
}
const stylePropertyMap = __EXPERIMENTAL_STYLE_PROPERTY;
Object.keys(stylePropertyMap).forEach((styleName) => {
if (!stylePropertyMap[styleName].support) {
return;
}
if (stylePropertyMap[styleName].requiresOptOut) {
if (supports && stylePropertyMap[styleName].support[0] in supports && getValueFromObjectPath(
supports,
stylePropertyMap[styleName].support
) !== false) {
supportKeys.push(styleName);
return;
}
}
if (supports && getValueFromObjectPath(
supports,
stylePropertyMap[styleName].support,
false
)) {
supportKeys.push(styleName);
}
});
return filterElementBlockSupports(supportKeys, name, element);
},
(state, name) => [
state.blockTypes[name]
]
);
function getBootstrappedBlockType(state, name) {
return state.bootstrappedBlockTypes[name];
}
function getUnprocessedBlockTypes(state) {
return state.unprocessedBlockTypes;
}
function getAllBlockBindingsSources(state) {
return state.blockBindingsSources;
}
function getBlockBindingsSource2(state, sourceName) {
return state.blockBindingsSources[sourceName];
}
var getBlockBindingsSourceFieldsList = (0, import_data3.createRegistrySelector)(
(select3) => (0, import_data3.createSelector)(
(state, source, blockContext) => {
if (!source.getFieldsList) {
return [];
}
const context = {};
if (source?.usesContext?.length) {
for (const key of source.usesContext) {
context[key] = blockContext[key];
}
}
return source.getFieldsList({ select: select3, context });
},
(state, source, blockContext) => [source.getFieldsList, source.usesContext, blockContext]
)
);
var hasContentRoleAttribute = (state, blockTypeName) => {
const blockType = getBlockType2(state, blockTypeName);
if (!blockType) {
return false;
}
return Object.values(blockType.attributes).some(
({ role, __experimentalRole }) => {
if (role === "content") {
return true;
}
if (__experimentalRole === "content") {
(0, import_deprecated2.default)("__experimentalRole attribute", {
since: "6.7",
version: "6.8",
alternative: "role attribute",
hint: `Check the block.json of the ${blockTypeName} block.`
});
return true;
}
return false;
}
);
};
// packages/blocks/build-module/store/selectors.mjs
var getNormalizedBlockType = (state, nameOrType) => "string" === typeof nameOrType ? getBlockType2(state, nameOrType) : nameOrType;
var getBlockTypes2 = (0, import_data4.createSelector)(
(state) => Object.values(state.blockTypes),
(state) => [state.blockTypes]
);
function getBlockType2(state, name) {
return state.blockTypes[name];
}
function getBlockStyles(state, name) {
return state.blockStyles[name];
}
var getBlockVariations2 = (0, import_data4.createSelector)(
(state, blockName, scope) => {
const variations = state.blockVariations[blockName];
if (!variations || !scope) {
return variations;
}
return variations.filter((variation) => {
return (variation.scope || ["block", "inserter"]).includes(
scope
);
});
},
(state, blockName) => [
state.blockVariations[blockName]
]
);
function getActiveBlockVariation(state, blockName, attributes, scope, innerContent) {
const variations = getBlockVariations2(state, blockName, scope);
if (!variations) {
return variations;
}
if (innerContent) {
const innerContentMatch = variations.find(
(variation) => variation.innerContent && (0, import_es6.default)(variation.innerContent, innerContent)
);
if (innerContentMatch) {
return innerContentMatch;
}
}
const blockType = getBlockType2(state, blockName);
const attributeKeys = Object.keys(blockType?.attributes || {});
let match;
let maxMatchedAttributes = 0;
for (const variation of variations) {
if (variation.innerContent) {
continue;
}
if (Array.isArray(variation.isActive)) {
const definedAttributes = variation.isActive.filter(
(attribute) => {
const topLevelAttribute = attribute.split(".")[0];
return attributeKeys.includes(topLevelAttribute);
}
);
const definedAttributesLength = definedAttributes.length;
if (definedAttributesLength === 0) {
continue;
}
const isMatch = definedAttributes.every((attribute) => {
const variationAttributeValue = getValueFromObjectPath(
variation.attributes,
attribute
);
if (variationAttributeValue === void 0) {
return false;
}
let blockAttributeValue = getValueFromObjectPath(
attributes,
attribute
);
if (blockAttributeValue instanceof import_rich_text2.RichTextData) {
blockAttributeValue = blockAttributeValue.toHTMLString();
}
return matchesAttributes(
blockAttributeValue,
variationAttributeValue
);
});
if (isMatch && definedAttributesLength > maxMatchedAttributes) {
match = variation;
maxMatchedAttributes = definedAttributesLength;
}
} else if (variation.isActive?.(
attributes,
variation.attributes
)) {
return match || variation;
}
}
if (!match && ["block", "transform"].includes(scope)) {
match = variations.find(
(variation) => variation?.isDefault && !Object.hasOwn(variation, "isActive")
);
}
return match;
}
function getDefaultBlockVariation(state, blockName, scope) {
const variations = getBlockVariations2(state, blockName, scope);
const defaultVariation = [...variations || []].reverse().find(({ isDefault }) => !!isDefault);
return defaultVariation || variations?.[0];
}
function getCategories(state) {
return state.categories;
}
function getCollections(state) {
return state.collections;
}
function getDefaultBlockName2(state) {
return state.defaultBlockName;
}
function getFreeformFallbackBlockName(state) {
return state.freeformFallbackBlockName;
}
function getUnregisteredFallbackBlockName(state) {
return state.unregisteredFallbackBlockName;
}
function getGroupingBlockName2(state) {
return state.groupingBlockName;
}
var getChildBlockNames2 = (0, import_data4.createSelector)(
(state, blockName) => {
return getBlockTypes2(state).filter((blockType) => {
return blockType.parent?.includes(blockName);
}).map(({ name }) => name);
},
(state) => [state.blockTypes]
);
var getBlockSupport2 = (state, nameOrType, feature, defaultSupports) => {
const blockType = getNormalizedBlockType(state, nameOrType);
if (!blockType?.supports) {
return defaultSupports;
}
return getValueFromObjectPath(
blockType.supports,
feature,
defaultSupports
);
};
function hasBlockSupport2(state, nameOrType, feature, defaultSupports) {
return !!getBlockSupport2(state, nameOrType, feature, defaultSupports);
}
function getNormalizedSearchTerm(term) {
return (0, import_remove_accents.default)(term ?? "").toLowerCase().trim();
}
function isMatchingSearchTerm(state, nameOrType, searchTerm = "") {
const blockType = getNormalizedBlockType(state, nameOrType);
const normalizedSearchTerm = getNormalizedSearchTerm(searchTerm);
const isSearchMatch = (candidate) => getNormalizedSearchTerm(candidate).includes(normalizedSearchTerm);
return isSearchMatch(blockType?.title) || blockType?.keywords?.some(isSearchMatch) || isSearchMatch(blockType?.category) || typeof blockType?.description === "string" && isSearchMatch(blockType.description);
}
var hasChildBlocks2 = (state, blockName) => {
return getChildBlockNames2(state, blockName).length > 0;
};
var hasChildBlocksWithInserterSupport2 = (state, blockName) => {
return getChildBlockNames2(state, blockName).some((childBlockName) => {
return hasBlockSupport2(state, childBlockName, "inserter", true);
});
};
var __experimentalHasContentRoleAttribute = (...args) => {
(0, import_deprecated3.default)("__experimentalHasContentRoleAttribute", {
since: "6.7",
version: "6.8",
hint: "This is a private selector."
});
return hasContentRoleAttribute(...args);
};
// packages/blocks/build-module/store/actions.mjs
var actions_exports = {};
__export(actions_exports, {
__experimentalReapplyBlockFilters: () => __experimentalReapplyBlockFilters,
addBlockCollection: () => addBlockCollection,
addBlockStyles: () => addBlockStyles,
addBlockTypes: () => addBlockTypes,
addBlockVariations: () => addBlockVariations,
reapplyBlockTypeFilters: () => reapplyBlockTypeFilters,
removeBlockCollection: () => removeBlockCollection,
removeBlockStyles: () => removeBlockStyles,
removeBlockTypes: () => removeBlockTypes,
removeBlockVariations: () => removeBlockVariations,
setCategories: () => setCategories,
setDefaultBlockName: () => setDefaultBlockName2,
setFreeformFallbackBlockName: () => setFreeformFallbackBlockName,
setGroupingBlockName: () => setGroupingBlockName2,
setUnregisteredFallbackBlockName: () => setUnregisteredFallbackBlockName,
updateCategory: () => updateCategory
});
var import_deprecated5 = __toESM(require_deprecated(), 1);
// node_modules/is-plain-object/dist/is-plain-object.mjs
function isObject3(o3) {
return Object.prototype.toString.call(o3) === "[object Object]";
}
function isPlainObject(o3) {
var ctor, prot;
if (isObject3(o3) === false) return false;
ctor = o3.constructor;
if (ctor === void 0) return true;
prot = ctor.prototype;
if (isObject3(prot) === false) return false;
if (prot.hasOwnProperty("isPrototypeOf") === false) {
return false;
}
return true;
}
// packages/blocks/build-module/store/process-block-type.mjs
var import_react_is = __toESM(require_react_is(), 1);
var import_deprecated4 = __toESM(require_deprecated(), 1);
var import_hooks = __toESM(require_hooks(), 1);
var import_warning2 = __toESM(require_warning(), 1);
var LEGACY_CATEGORY_MAPPING = {
common: "text",
formatting: "text",
layout: "design"
};
function mergeBlockVariations(bootstrappedVariations = [], clientVariations = []) {
const result = [...bootstrappedVariations];
clientVariations.forEach((clientVariation) => {
const index = result.findIndex(
(bootstrappedVariation) => bootstrappedVariation.name === clientVariation.name
);
if (index !== -1) {
result[index] = { ...result[index], ...clientVariation };
} else {
result.push(clientVariation);
}
});
return result;
}
var processBlockType = (name, blockSettings) => ({
select: select3
}) => {
const bootstrappedBlockType = select3.getBootstrappedBlockType(name);
const blockType = {
apiVersion: 1,
name,
icon: BLOCK_ICON_DEFAULT,
keywords: [],
attributes: {},
providesContext: {},
usesContext: [],
selectors: {},
supports: {},
styles: [],
blockHooks: {},
save: () => null,
...bootstrappedBlockType,
...blockSettings,
// blockType.variations can be defined as a filePath.
variations: mergeBlockVariations(
Array.isArray(bootstrappedBlockType?.variations) ? bootstrappedBlockType.variations : [],
Array.isArray(blockSettings?.variations) ? blockSettings.variations : []
)
};
if (!blockType.attributes || typeof blockType.attributes !== "object") {
(0, import_warning2.default)(
'The block "' + name + '" is registering attributes as `null` or `undefined`. Use an empty object (`attributes: {}`) or exclude the `attributes` key.'
);
blockType.attributes = {};
}
const settings = (0, import_hooks.applyFilters)(
"blocks.registerBlockType",
blockType,
name,
null
);
if (settings.apiVersion <= 2) {
(0, import_deprecated4.default)("Block with API version 2 or lower", {
since: "6.9",
hint: `The block "${name}" is registered with API version ${settings.apiVersion}. This means that the post editor may work as a non-iframe editor. Since all editors are planned to work as iframes in the future, set the \`apiVersion\` field to 3 and test the block inside the iframe editor.`,
link: "https://developer.wordpress.org/block-editor/reference-guides/block-api/block-api-versions/block-migration-for-iframe-editor-compatibility/"
});
}
if (settings.description && typeof settings.description !== "string") {
(0, import_deprecated4.default)("Declaring non-string block descriptions", {
since: "6.2"
});
}
if (settings.deprecated) {
settings.deprecated = settings.deprecated.map(
(deprecation) => Object.fromEntries(
Object.entries(
// Only keep valid deprecation keys.
(0, import_hooks.applyFilters)(
"blocks.registerBlockType",
// Merge deprecation keys with pre-filter settings
// so that filters that depend on specific keys being
// present don't fail.
{
// Omit deprecation keys here so that deprecations
// can opt out of specific keys like "supports".
...omit(blockType, DEPRECATED_ENTRY_KEYS),
...deprecation
},
blockType.name,
deprecation
)
).filter(
([key]) => DEPRECATED_ENTRY_KEYS.includes(key)
)
)
);
}
if (!isPlainObject(settings)) {
(0, import_warning2.default)("Block settings must be a valid object.");
return;
}
if (typeof settings.save !== "function") {
(0, import_warning2.default)('The "save" property must be a valid function.');
return;
}
if ("edit" in settings && !(0, import_react_is.isValidElementType)(settings.edit)) {
(0, import_warning2.default)('The "edit" property must be a valid component.');
return;
}
if (LEGACY_CATEGORY_MAPPING.hasOwnProperty(settings.category)) {
settings.category = LEGACY_CATEGORY_MAPPING[settings.category];
}
if ("category" in settings && !select3.getCategories().some(
({ slug }) => slug === settings.category
)) {
(0, import_warning2.default)(
'The block "' + name + '" is registered with an invalid category "' + settings.category + '".'
);
delete settings.category;
}
if (!("title" in settings) || settings.title === "") {
(0, import_warning2.default)('The block "' + name + '" must have a title.');
return;
}
if (typeof settings.title !== "string") {
(0, import_warning2.default)("Block titles must be strings.");
return;
}
settings.icon = normalizeIconObject(settings.icon);
if (!isValidIcon(settings.icon.src)) {
(0, import_warning2.default)(
"The icon passed is invalid. The icon should be a string, an element, a function, or an object following the specifications documented in https://developer.wordpress.org/block-editor/developers/block-api/block-registration/#icon-optional"
);
return;
}
if (typeof settings?.parent === "string" || settings?.parent instanceof String) {
settings.parent = [settings.parent];
(0, import_warning2.default)(
"Parent must be undefined or an array of strings (block types), but it is a string."
);
}
if (!Array.isArray(settings?.parent) && settings?.parent !== void 0) {
(0, import_warning2.default)(
"Parent must be undefined or an array of block types, but it is " + settings.parent
);
return;
}
if (1 === settings?.parent?.length && name === settings.parent[0]) {
(0, import_warning2.default)(
'Block "' + name + '" cannot be a parent of itself. Please remove the block name from the parent list.'
);
return;
}
return settings;
};
// packages/blocks/build-module/store/actions.mjs
function addBlockTypes(blockTypes2) {
return {
type: "ADD_BLOCK_TYPES",
blockTypes: Array.isArray(blockTypes2) ? blockTypes2 : [blockTypes2]
};
}
function reapplyBlockTypeFilters() {
return ({ dispatch: dispatch3, select: select3 }) => {
const processedBlockTypes = [];
for (const [name, settings] of Object.entries(
select3.getUnprocessedBlockTypes()
)) {
const result = dispatch3(processBlockType(name, settings));
if (result) {
processedBlockTypes.push(result);
}
}
if (!processedBlockTypes.length) {
return;
}
dispatch3.addBlockTypes(processedBlockTypes);
};
}
function __experimentalReapplyBlockFilters() {
(0, import_deprecated5.default)(
'wp.data.dispatch( "core/blocks" ).__experimentalReapplyBlockFilters',
{
since: "6.4",
alternative: "reapplyBlockFilters"
}
);
return reapplyBlockTypeFilters();
}
function removeBlockTypes(names) {
return {
type: "REMOVE_BLOCK_TYPES",
names: Array.isArray(names) ? names : [names]
};
}
function addBlockStyles(blockNames, styles) {
return {
type: "ADD_BLOCK_STYLES",
styles: Array.isArray(styles) ? styles : [styles],
blockNames: Array.isArray(blockNames) ? blockNames : [blockNames]
};
}
function removeBlockStyles(blockName, styleNames) {
return {
type: "REMOVE_BLOCK_STYLES",
styleNames: Array.isArray(styleNames) ? styleNames : [styleNames],
blockName
};
}
function addBlockVariations(blockName, variations) {
return {
type: "ADD_BLOCK_VARIATIONS",
variations: Array.isArray(variations) ? variations : [variations],
blockName
};
}
function removeBlockVariations(blockName, variationNames) {
return {
type: "REMOVE_BLOCK_VARIATIONS",
variationNames: Array.isArray(variationNames) ? variationNames : [variationNames],
blockName
};
}
function setDefaultBlockName2(name) {
return {
type: "SET_DEFAULT_BLOCK_NAME",
name
};
}
function setFreeformFallbackBlockName(name) {
return {
type: "SET_FREEFORM_FALLBACK_BLOCK_NAME",
name
};
}
function setUnregisteredFallbackBlockName(name) {
return {
type: "SET_UNREGISTERED_FALLBACK_BLOCK_NAME",
name
};
}
function setGroupingBlockName2(name) {
return {
type: "SET_GROUPING_BLOCK_NAME",
name
};
}
function setCategories(categories2) {
return {
type: "SET_CATEGORIES",
categories: categories2
};
}
function updateCategory(slug, category) {
return {
type: "UPDATE_CATEGORY",
slug,
category
};
}
function addBlockCollection(namespace, title, icon) {
return {
type: "ADD_BLOCK_COLLECTION",
namespace,
title,
icon
};
}
function removeBlockCollection(namespace) {
return {
type: "REMOVE_BLOCK_COLLECTION",
namespace
};
}
// packages/blocks/build-module/store/private-actions.mjs
var private_actions_exports = {};
__export(private_actions_exports, {
addBlockBindingsSource: () => addBlockBindingsSource,
addBootstrappedBlockType: () => addBootstrappedBlockType,
addUnprocessedBlockType: () => addUnprocessedBlockType,
removeBlockBindingsSource: () => removeBlockBindingsSource
});
function addBootstrappedBlockType(name, blockType) {
return {
type: "ADD_BOOTSTRAPPED_BLOCK_TYPE",
name,
blockType
};
}
function addUnprocessedBlockType(name, blockType) {
return ({ dispatch: dispatch3 }) => {
dispatch3({ type: "ADD_UNPROCESSED_BLOCK_TYPE", name, blockType });
const processedBlockType = dispatch3(
processBlockType(name, blockType)
);
if (!processedBlockType) {
return;
}
dispatch3.addBlockTypes(processedBlockType);
};
}
function addBlockBindingsSource(source) {
return {
type: "ADD_BLOCK_BINDINGS_SOURCE",
name: source.name,
label: source.label,
usesContext: source.usesContext,
getValues: source.getValues,
setValues: source.setValues,
canUserEditValue: source.canUserEditValue,
getFieldsList: source.getFieldsList
};
}
function removeBlockBindingsSource(name) {
return {
type: "REMOVE_BLOCK_BINDINGS_SOURCE",
name
};
}
// packages/blocks/build-module/store/constants.mjs
var STORE_NAME = "core/blocks";
// packages/blocks/build-module/store/index.mjs
var store = (0, import_data5.createReduxStore)(STORE_NAME, {
reducer: reducer_default,
selectors: selectors_exports,
actions: actions_exports
});
(0, import_data5.register)(store);
unlock(store).registerPrivateSelectors(private_selectors_exports);
unlock(store).registerPrivateActions(private_actions_exports);
// node_modules/uuid/dist/stringify.js
var byteToHex = [];
for (let i2 = 0; i2 < 256; ++i2) {
byteToHex.push((i2 + 256).toString(16).slice(1));
}
function unsafeStringify(arr, offset = 0) {
return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
}
// node_modules/uuid/dist/rng.js
var rnds8 = new Uint8Array(16);
function rng() {
return crypto.getRandomValues(rnds8);
}
// node_modules/uuid/dist/v4.js
function v4(options, buf, offset) {
if (!buf && !options && crypto.randomUUID) {
return crypto.randomUUID();
}
return _v4(options, buf, offset);
}
function _v4(options, buf, offset) {
options = options || {};
const rnds = options.random ?? options.rng?.() ?? rng();
if (rnds.length < 16) {
throw new Error("Random bytes length must be >= 16");
}
rnds[6] = rnds[6] & 15 | 64;
rnds[8] = rnds[8] & 63 | 128;
if (buf) {
offset = offset || 0;
if (offset < 0 || offset + 16 > buf.length) {
throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
}
for (let i2 = 0; i2 < 16; ++i2) {
buf[offset + i2] = rnds[i2];
}
return buf;
}
return unsafeStringify(rnds);
}
var v4_default = v4;
// packages/blocks/build-module/api/factory.mjs
var import_hooks2 = __toESM(require_hooks(), 1);
var import_deprecated6 = __toESM(require_deprecated(), 1);
var import_warning3 = __toESM(require_warning(), 1);
var getBlockTypeWithTransformMetadata = (blockType, transform) => transform.variationName ? { ...blockType, variationName: transform.variationName } : blockType;
function createBlock(name, attributes = {}, innerBlocks = [], innerContent) {
if (!isBlockRegistered(name)) {
return createBlock("core/missing", {
originalName: name,
originalContent: "",
originalUndelimitedContent: ""
});
}
const sanitizedAttributes = sanitizeBlockAttributes(name, attributes);
const clientId = v4_default();
const block = {
clientId,
name,
isValid: true,
attributes: sanitizedAttributes,
innerBlocks
};
if (innerContent) {
if (name === "core/html") {
block.innerContent = innerContent;
} else {
(0, import_warning3.default)(
`The innerContent argument passed to createBlock for the "${name}" block was ignored. Only the Custom HTML block stores static inner content.`
);
}
}
return block;
}
function createBlocksFromInnerBlocksTemplate(innerBlocksOrTemplate = []) {
return innerBlocksOrTemplate.map((innerBlock) => {
const innerBlockTemplate = Array.isArray(innerBlock) ? innerBlock : [
innerBlock.name,
innerBlock.attributes,
innerBlock.innerBlocks,
innerBlock.innerContent
];
const [name, attributes, innerBlocks = [], innerContent] = innerBlockTemplate;
return createBlock(
name,
attributes,
createBlocksFromInnerBlocksTemplate(
innerBlocks
),
innerContent
);
});
}
function cloneSanitizedBlock(block, mergeAttributes = {}, newInnerBlocks) {
const { name } = block;
if (!isBlockRegistered(name)) {
return createBlock("core/missing", {
originalName: name,
originalContent: "",
originalUndelimitedContent: ""
});
}
const clientId = v4_default();
const sanitizedAttributes = sanitizeBlockAttributes(name, {
...block.attributes,
...mergeAttributes
});
return {
...block,
clientId,
attributes: sanitizedAttributes,
innerBlocks: newInnerBlocks || block.innerBlocks.map(
(innerBlock) => cloneSanitizedBlock(innerBlock)
)
};
}
function __experimentalCloneSanitizedBlock(block, mergeAttributes = {}, newInnerBlocks) {
(0, import_deprecated6.default)("__experimentalCloneSanitizedBlock", {
since: "7.1",
alternative: "cloneSanitizedBlock"
});
return cloneSanitizedBlock(block, mergeAttributes, newInnerBlocks);
}
function cloneBlock(block, mergeAttributes = {}, newInnerBlocks) {
const clientId = v4_default();
return {
...block,
clientId,
attributes: {
...block.attributes,
...mergeAttributes
},
innerBlocks: newInnerBlocks || block.innerBlocks.map((innerBlock) => cloneBlock(innerBlock))
};
}
var isPossibleTransformForSource = (transform, direction, blocks) => {
if (!blocks.length) {
return false;
}
const isMultiBlock = blocks.length > 1;
const firstBlockName = blocks[0].name;
const isValidForMultiBlocks = isWildcardBlockTransform(transform) || !isMultiBlock || transform.isMultiBlock;
if (!isValidForMultiBlocks) {
return false;
}
if (!isWildcardBlockTransform(transform) && !blocks.every((block) => block.name === firstBlockName)) {
return false;
}
const isBlockType = transform.type === "block";
if (!isBlockType) {
return false;
}
const sourceBlock = blocks[0];
const hasMatchingName = direction !== "from" || transform.blocks.indexOf(sourceBlock.name) !== -1 || isWildcardBlockTransform(transform);
if (!hasMatchingName) {
return false;
}
if (!isMultiBlock && direction === "from" && isContainerGroupBlock(sourceBlock.name) && isContainerGroupBlock(transform.blockName)) {
return false;
}
if (!maybeCheckTransformIsMatch(transform, blocks)) {
return false;
}
return true;
};
var getBlockTypesForPossibleFromTransforms = (blocks) => {
if (!blocks.length) {
return [];
}
const allBlockTypes = getBlockTypes();
const blockTypesWithPossibleFromTransforms = allBlockTypes.flatMap(
(blockType) => {
const fromTransforms = getBlockTransforms("from", blockType.name);
return fromTransforms.filter(
(transform) => isPossibleTransformForSource(transform, "from", blocks)
).map(
(transform) => getBlockTypeWithTransformMetadata(blockType, transform)
);
}
);
return blockTypesWithPossibleFromTransforms;
};
var getBlockTypesForPossibleToTransforms = (blocks) => {
if (!blocks.length) {
return [];
}
const sourceBlock = blocks[0];
const blockType = getBlockType(sourceBlock.name);
const transformsTo = blockType ? getBlockTransforms("to", blockType.name) : [];
const possibleTransforms = transformsTo.filter((transform) => {
return transform && isPossibleTransformForSource(transform, "to", blocks);
});
return possibleTransforms.flatMap((transformation) => {
return (transformation.blocks || []).map((name) => {
const transformedBlockType = getBlockType(name);
return transformedBlockType ? getBlockTypeWithTransformMetadata(
transformedBlockType,
transformation
) : void 0;
});
}).filter((bt) => !!bt);
};
var isWildcardBlockTransform = (t3) => !!t3 && t3.type === "block" && Array.isArray(t3.blocks) && t3.blocks.includes("*");
var isContainerGroupBlock = (name) => name === getGroupingBlockName();
function getPossibleBlockTransformations(blocks) {
if (!blocks.length) {
return [];
}
const blockTypesForFromTransforms = getBlockTypesForPossibleFromTransforms(blocks);
const blockTypesForToTransforms = getBlockTypesForPossibleToTransforms(blocks);
const blockTypesByNameAndVariation = /* @__PURE__ */ new Map();
for (const blockType of [
...blockTypesForFromTransforms,
...blockTypesForToTransforms
]) {
const key = blockType.variationName ? `${blockType.name}/${blockType.variationName}` : blockType.name;
if (!blockTypesByNameAndVariation.has(key)) {
blockTypesByNameAndVariation.set(key, blockType);
}
}
return [...blockTypesByNameAndVariation.values()];
}
function findTransform(transforms, predicate) {
const hooks = (0, import_hooks2.createHooks)();
for (let i2 = 0; i2 < transforms.length; i2++) {
const candidate = transforms[i2];
if (predicate(candidate)) {
hooks.addFilter(
"transform",
"transform/" + i2.toString(),
(result) => result ? result : candidate,
candidate.priority
);
}
}
return hooks.applyFilters("transform", null);
}
function getBlockTransforms(direction, blockTypeOrName) {
if (blockTypeOrName === void 0) {
return getBlockTypes().map(({ name }) => getBlockTransforms(direction, name)).flat();
}
const blockType = normalizeBlockType(blockTypeOrName);
const { name: blockName, transforms } = blockType || {};
const directionTransforms = transforms?.[direction];
if (!transforms || !Array.isArray(directionTransforms)) {
return [];
}
const usingMobileTransformations = transforms.supportedMobileTransforms && Array.isArray(transforms.supportedMobileTransforms);
const filteredTransforms = usingMobileTransformations ? directionTransforms.filter((t3) => {
if (t3.type === "raw") {
return true;
}
if (t3.type === "prefix") {
return true;
}
if (!t3.blocks || !t3.blocks.length) {
return false;
}
if (isWildcardBlockTransform(t3)) {
return true;
}
return t3.blocks.every(
(transformBlockName) => transforms.supportedMobileTransforms.includes(
transformBlockName
)
);
}) : directionTransforms;
return filteredTransforms.map((transform) => ({
...transform,
blockName,
usingMobileTransformations
}));
}
function maybeCheckTransformIsMatch(transform, blocks) {
if (typeof transform.isMatch !== "function") {
return true;
}
const sourceBlock = blocks[0];
const attributes = transform.isMultiBlock ? blocks.map((block2) => block2.attributes) : sourceBlock.attributes;
const block = transform.isMultiBlock ? blocks : sourceBlock;
return transform.isMatch(attributes, block);
}
function switchToBlockType(blocks, name, variationName) {
const blocksArray = Array.isArray(blocks) ? blocks : [blocks];
const isMultiBlock = blocksArray.length > 1;
const firstBlock = blocksArray[0];
const sourceName = firstBlock.name;
const transformationsFrom = getBlockTransforms("from", name);
const transformationsTo = getBlockTransforms("to", sourceName);
const isMatchingVariation = (t3) => variationName ? t3.variationName === variationName : !t3.variationName;
const transformation = findTransform(
transformationsTo,
(t3) => t3.type === "block" && isMatchingVariation(t3) && (isWildcardBlockTransform(t3) || t3.blocks.indexOf(name) !== -1) && (!isMultiBlock || !!t3.isMultiBlock) && maybeCheckTransformIsMatch(t3, blocksArray)
) || findTransform(
transformationsFrom,
(t3) => t3.type === "block" && isMatchingVariation(t3) && (isWildcardBlockTransform(t3) || t3.blocks.indexOf(sourceName) !== -1) && (!isMultiBlock || !!t3.isMultiBlock) && maybeCheckTransformIsMatch(t3, blocksArray)
);
if (!transformation) {
return null;
}
let transformationResults;
if (transformation.isMultiBlock) {
if ("__experimentalConvert" in transformation) {
transformationResults = transformation.__experimentalConvert(blocksArray);
} else {
transformationResults = transformation.transform(
blocksArray.map((currentBlock) => currentBlock.attributes),
blocksArray.map((currentBlock) => currentBlock.innerBlocks)
);
}
} else if ("__experimentalConvert" in transformation) {
transformationResults = transformation.__experimentalConvert(firstBlock);
} else {
transformationResults = transformation.transform(
firstBlock.attributes,
firstBlock.innerBlocks
);
}
if (transformationResults === null || typeof transformationResults !== "object") {
return null;
}
transformationResults = Array.isArray(transformationResults) ? transformationResults : [transformationResults];
if (transformationResults.some(
(result) => !getBlockType(result.name)
)) {
return null;
}
const hasSwitchedBlock = transformationResults.some(
(result) => result.name === name
);
if (!hasSwitchedBlock) {
return null;
}
const ret = transformationResults.map((result, index, results) => {
return (0, import_hooks2.applyFilters)(
"blocks.switchToBlockType.transformedBlock",
result,
blocks,
index,
results
);
});
return ret;
}
var getBlockFromExample = (name, example) => createBlock(
name,
example.attributes,
(example.innerBlocks ?? []).map(
(innerBlock) => getBlockFromExample(innerBlock.name, innerBlock)
),
example.innerContent
);
// packages/blocks/build-module/api/parser/index.mjs
var import_block_serialization_default_parser = __toESM(require_block_serialization_default_parser(), 1);
var import_autop2 = __toESM(require_autop(), 1);
// packages/blocks/build-module/api/serializer.mjs
var import_element2 = __toESM(require_element(), 1);
var import_hooks3 = __toESM(require_hooks(), 1);
var import_is_shallow_equal = __toESM(require_is_shallow_equal(), 1);
var import_autop = __toESM(require_autop(), 1);
var import_deprecated7 = __toESM(require_deprecated(), 1);
// packages/blocks/build-module/api/parser/serialize-raw-block.mjs
function serializeRawBlock(rawBlock, options = {}) {
const { isCommentDelimited = true } = options;
const {
blockName,
attrs = {},
innerBlocks = [],
innerContent = []
} = rawBlock;
let childIndex = 0;
const content = innerContent.map(
(item) => (
// `null` denotes a nested block, otherwise we have an HTML fragment.
item !== null ? item : serializeRawBlock(innerBlocks[childIndex++], options)
)
).join("\n").replace(/\n+/g, "\n").trim();
return isCommentDelimited ? getCommentDelimitedContent(blockName ?? void 0, attrs, content) : content;
}
// packages/blocks/build-module/api/serializer.mjs
var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
function getBlockDefaultClassName(blockName) {
const className = "wp-block-" + blockName.replace(/\//, "-").replace(/^core-/, "");
return (0, import_hooks3.applyFilters)(
"blocks.getBlockDefaultClassName",
className,
blockName
);
}
function getBlockMenuDefaultClassName(blockName) {
const className = "editor-block-list-item-" + blockName.replace(/\//, "-").replace(/^core-/, "");
return (0, import_hooks3.applyFilters)(
"blocks.getBlockMenuDefaultClassName",
className,
blockName
);
}
var blockPropsProvider = {};
var innerBlocksPropsProvider = {};
function getBlockProps(props = {}) {
const { blockType, attributes } = blockPropsProvider;
return getBlockProps.skipFilters ? props : (0, import_hooks3.applyFilters)(
"blocks.getSaveContent.extraProps",
{ ...props },
blockType,
attributes
);
}
function getInnerBlocksProps(props = {}) {
const { innerBlocks } = innerBlocksPropsProvider;
if (!Array.isArray(innerBlocks)) {
return { ...props, children: innerBlocks };
}
const html2 = serialize(innerBlocks, { isInnerBlocks: true });
const children = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_element2.RawHTML, { children: html2 });
return { ...props, children };
}
function getSaveElement(blockTypeOrName, attributes, innerBlocks = []) {
const blockType = normalizeBlockType(blockTypeOrName);
if (!blockType?.save) {
return null;
}
let save = blockType.save;
if (save.prototype instanceof import_element2.Component) {
const SaveClass = save;
const instance = new SaveClass({ attributes });
save = instance.render.bind(instance);
}
blockPropsProvider.blockType = blockType;
blockPropsProvider.attributes = attributes;
innerBlocksPropsProvider.innerBlocks = innerBlocks;
let element = save({
attributes,
innerBlocks
});
if (element !== null && typeof element === "object" && (0, import_hooks3.hasFilter)("blocks.getSaveContent.extraProps") && !((blockType.apiVersion ?? 0) > 1)) {
const props = (0, import_hooks3.applyFilters)(
"blocks.getSaveContent.extraProps",
{ ...element.props },
blockType,
attributes
);
if (!(0, import_is_shallow_equal.isShallowEqual)(props, element.props)) {
element = (0, import_element2.cloneElement)(
element,
props
);
}
}
return (0, import_hooks3.applyFilters)(
"blocks.getSaveElement",
element,
blockType,
attributes
);
}
function getSaveContent(blockTypeOrName, attributes, innerBlocks) {
const blockType = normalizeBlockType(
blockTypeOrName
);
if (!blockType) {
return "";
}
return (0, import_element2.renderToString)(
getSaveElement(blockType, attributes, innerBlocks)
);
}
function getCommentAttributes(blockType, attributes) {
return Object.entries(blockType.attributes ?? {}).reduce(
(accumulator, [key, attributeSchema]) => {
const value = attributes[key];
if (void 0 === value) {
return accumulator;
}
if (attributeSchema.source !== void 0) {
return accumulator;
}
if (attributeSchema.role === "local") {
return accumulator;
}
if (attributeSchema.__experimentalRole === "local") {
(0, import_deprecated7.default)("__experimentalRole attribute", {
since: "6.7",
version: "6.8",
alternative: "role attribute",
hint: `Check the block.json of the ${blockType?.name} block.`
});
return accumulator;
}
if ("default" in attributeSchema && JSON.stringify(attributeSchema.default) === JSON.stringify(value)) {
return accumulator;
}
accumulator[key] = value;
return accumulator;
},
{}
);
}
function serializeAttributes(attributes) {
return JSON.stringify(attributes).replaceAll("\\\\", "\\u005c").replaceAll("--", "\\u002d\\u002d").replaceAll("<", "\\u003c").replaceAll(">", "\\u003e").replaceAll("&", "\\u0026").replaceAll('\\"', "\\u0022");
}
function serializeInnerContent(innerContent, innerBlocks) {
let childIndex = 0;
const parts = innerContent.map((item) => {
if (item !== null) {
return item;
}
const innerBlock = innerBlocks[childIndex++];
return innerBlock ? serializeBlock(innerBlock, { isInnerBlocks: true }) : "";
});
for (; childIndex < innerBlocks.length; childIndex++) {
parts.push(
serializeBlock(innerBlocks[childIndex], { isInnerBlocks: true })
);
}
return parts.join("").trim();
}
function getBlockInnerHTML(block) {
if (block.innerContent && block.name === "core/html") {
return serializeInnerContent(block.innerContent, block.innerBlocks);
}
let saveContent = block.originalContent ?? "";
if (block.isValid || block.innerBlocks.length) {
try {
saveContent = getSaveContent(
block.name,
block.attributes,
block.innerBlocks
);
} catch {
}
}
return saveContent;
}
function getCommentDelimitedContent(rawBlockName, attributes, content) {
const serializedAttributes = attributes && Object.entries(attributes).length ? serializeAttributes(attributes) + " " : "";
const blockName = rawBlockName?.startsWith("core/") ? rawBlockName.slice(5) : rawBlockName;
if (!content) {
return `<!-- wp:${blockName} ${serializedAttributes}/-->`;
}
return `<!-- wp:${blockName} ${serializedAttributes}-->
` + content + `
<!-- /wp:${blockName} -->`;
}
function serializeBlock(block, { isInnerBlocks = false } = {}) {
if (!block.isValid && block.__unstableBlockSource) {
return serializeRawBlock(block.__unstableBlockSource);
}
const blockName = block.name;
const saveContent = getBlockInnerHTML(block);
if (blockName === getUnregisteredTypeHandlerName() || !isInnerBlocks && blockName === getFreeformContentHandlerName()) {
return saveContent;
}
const blockType = getBlockType(blockName);
if (!blockType) {
return saveContent;
}
const saveAttributes = getCommentAttributes(blockType, block.attributes);
return getCommentDelimitedContent(blockName, saveAttributes, saveContent);
}
var __unstableSerializeAndClean = /* @__PURE__ */ (() => {
const cache = /* @__PURE__ */ new WeakMap();
return (blocks) => {
const cached = cache.get(blocks);
if (cached !== void 0) {
return cached;
}
let effectiveBlocks = blocks;
if (effectiveBlocks.length === 1 && isUnmodifiedDefaultBlock(effectiveBlocks[0])) {
effectiveBlocks = [];
}
let content = serialize(effectiveBlocks);
if (effectiveBlocks.length === 1 && effectiveBlocks[0].name === getFreeformContentHandlerName() && effectiveBlocks[0].name === "core/freeform") {
content = (0, import_autop.removep)(content);
}
cache.set(blocks, content);
return content;
};
})();
function serialize(blocks, options) {
const blocksArray = Array.isArray(blocks) ? blocks : [blocks];
return blocksArray.map((block) => serializeBlock(block, options)).join("\n\n");
}
// node_modules/simple-html-tokenizer/dist/es6/index.js
var HEXCHARCODE = /^#[xX]([A-Fa-f0-9]+)$/;
var CHARCODE = /^#([0-9]+)$/;
var NAMED = /^([A-Za-z0-9]+)$/;
var EntityParser = (
/** @class */
(function() {
function EntityParser2(named) {
this.named = named;
}
EntityParser2.prototype.parse = function(entity) {
if (!entity) {
return;
}
var matches = entity.match(HEXCHARCODE);
if (matches) {
return String.fromCharCode(parseInt(matches[1], 16));
}
matches = entity.match(CHARCODE);
if (matches) {
return String.fromCharCode(parseInt(matches[1], 10));
}
matches = entity.match(NAMED);
if (matches) {
return this.named[matches[1]];
}
};
return EntityParser2;
})()
);
var WSP = /[\t\n\f ]/;
var ALPHA = /[A-Za-z]/;
var CRLF = /\r\n?/g;
function isSpace(char) {
return WSP.test(char);
}
function isAlpha(char) {
return ALPHA.test(char);
}
function preprocessInput(input) {
return input.replace(CRLF, "\n");
}
var EventedTokenizer = (
/** @class */
(function() {
function EventedTokenizer2(delegate, entityParser) {
this.delegate = delegate;
this.entityParser = entityParser;
this.state = "beforeData";
this.line = -1;
this.column = -1;
this.input = "";
this.index = -1;
this.tagNameBuffer = "";
this.states = {
beforeData: function() {
var char = this.peek();
if (char === "<") {
this.transitionTo(
"tagOpen"
/* tagOpen */
);
this.markTagStart();
this.consume();
} else {
if (char === "\n") {
var tag = this.tagNameBuffer.toLowerCase();
if (tag === "pre" || tag === "textarea") {
this.consume();
}
}
this.transitionTo(
"data"
/* data */
);
this.delegate.beginData();
}
},
data: function() {
var char = this.peek();
if (char === "<") {
this.delegate.finishData();
this.transitionTo(
"tagOpen"
/* tagOpen */
);
this.markTagStart();
this.consume();
} else if (char === "&") {
this.consume();
this.delegate.appendToData(this.consumeCharRef() || "&");
} else {
this.consume();
this.delegate.appendToData(char);
}
},
tagOpen: function() {
var char = this.consume();
if (char === "!") {
this.transitionTo(
"markupDeclarationOpen"
/* markupDeclarationOpen */
);
} else if (char === "/") {
this.transitionTo(
"endTagOpen"
/* endTagOpen */
);
} else if (char === "@" || char === ":" || isAlpha(char)) {
this.transitionTo(
"tagName"
/* tagName */
);
this.tagNameBuffer = "";
this.delegate.beginStartTag();
this.appendToTagName(char);
}
},
markupDeclarationOpen: function() {
var char = this.consume();
if (char === "-" && this.input.charAt(this.index) === "-") {
this.consume();
this.transitionTo(
"commentStart"
/* commentStart */
);
this.delegate.beginComment();
}
},
commentStart: function() {
var char = this.consume();
if (char === "-") {
this.transitionTo(
"commentStartDash"
/* commentStartDash */
);
} else if (char === ">") {
this.delegate.finishComment();
this.transitionTo(
"beforeData"
/* beforeData */
);
} else {
this.delegate.appendToCommentData(char);
this.transitionTo(
"comment"
/* comment */
);
}
},
commentStartDash: function() {
var char = this.consume();
if (char === "-") {
this.transitionTo(
"commentEnd"
/* commentEnd */
);
} else if (char === ">") {
this.delegate.finishComment();
this.transitionTo(
"beforeData"
/* beforeData */
);
} else {
this.delegate.appendToCommentData("-");
this.transitionTo(
"comment"
/* comment */
);
}
},
comment: function() {
var char = this.consume();
if (char === "-") {
this.transitionTo(
"commentEndDash"
/* commentEndDash */
);
} else {
this.delegate.appendToCommentData(char);
}
},
commentEndDash: function() {
var char = this.consume();
if (char === "-") {
this.transitionTo(
"commentEnd"
/* commentEnd */
);
} else {
this.delegate.appendToCommentData("-" + char);
this.transitionTo(
"comment"
/* comment */
);
}
},
commentEnd: function() {
var char = this.consume();
if (char === ">") {
this.delegate.finishComment();
this.transitionTo(
"beforeData"
/* beforeData */
);
} else {
this.delegate.appendToCommentData("--" + char);
this.transitionTo(
"comment"
/* comment */
);
}
},
tagName: function() {
var char = this.consume();
if (isSpace(char)) {
this.transitionTo(
"beforeAttributeName"
/* beforeAttributeName */
);
} else if (char === "/") {
this.transitionTo(
"selfClosingStartTag"
/* selfClosingStartTag */
);
} else if (char === ">") {
this.delegate.finishTag();
this.transitionTo(
"beforeData"
/* beforeData */
);
} else {
this.appendToTagName(char);
}
},
beforeAttributeName: function() {
var char = this.peek();
if (isSpace(char)) {
this.consume();
return;
} else if (char === "/") {
this.transitionTo(
"selfClosingStartTag"
/* selfClosingStartTag */
);
this.consume();
} else if (char === ">") {
this.consume();
this.delegate.finishTag();
this.transitionTo(
"beforeData"
/* beforeData */
);
} else if (char === "=") {
this.delegate.reportSyntaxError("attribute name cannot start with equals sign");
this.transitionTo(
"attributeName"
/* attributeName */
);
this.delegate.beginAttribute();
this.consume();
this.delegate.appendToAttributeName(char);
} else {
this.transitionTo(
"attributeName"
/* attributeName */
);
this.delegate.beginAttribute();
}
},
attributeName: function() {
var char = this.peek();
if (isSpace(char)) {
this.transitionTo(
"afterAttributeName"
/* afterAttributeName */
);
this.consume();
} else if (char === "/") {
this.delegate.beginAttributeValue(false);
this.delegate.finishAttributeValue();
this.consume();
this.transitionTo(
"selfClosingStartTag"
/* selfClosingStartTag */
);
} else if (char === "=") {
this.transitionTo(
"beforeAttributeValue"
/* beforeAttributeValue */
);
this.consume();
} else if (char === ">") {
this.delegate.beginAttributeValue(false);
this.delegate.finishAttributeValue();
this.consume();
this.delegate.finishTag();
this.transitionTo(
"beforeData"
/* beforeData */
);
} else if (char === '"' || char === "'" || char === "<") {
this.delegate.reportSyntaxError(char + " is not a valid character within attribute names");
this.consume();
this.delegate.appendToAttributeName(char);
} else {
this.consume();
this.delegate.appendToAttributeName(char);
}
},
afterAttributeName: function() {
var char = this.peek();
if (isSpace(char)) {
this.consume();
return;
} else if (char === "/") {
this.delegate.beginAttributeValue(false);
this.delegate.finishAttributeValue();
this.consume();
this.transitionTo(
"selfClosingStartTag"
/* selfClosingStartTag */
);
} else if (char === "=") {
this.consume();
this.transitionTo(
"beforeAttributeValue"
/* beforeAttributeValue */
);
} else if (char === ">") {
this.delegate.beginAttributeValue(false);
this.delegate.finishAttributeValue();
this.consume();
this.delegate.finishTag();
this.transitionTo(
"beforeData"
/* beforeData */
);
} else {
this.delegate.beginAttributeValue(false);
this.delegate.finishAttributeValue();
this.transitionTo(
"attributeName"
/* attributeName */
);
this.delegate.beginAttribute();
this.consume();
this.delegate.appendToAttributeName(char);
}
},
beforeAttributeValue: function() {
var char = this.peek();
if (isSpace(char)) {
this.consume();
} else if (char === '"') {
this.transitionTo(
"attributeValueDoubleQuoted"
/* attributeValueDoubleQuoted */
);
this.delegate.beginAttributeValue(true);
this.consume();
} else if (char === "'") {
this.transitionTo(
"attributeValueSingleQuoted"
/* attributeValueSingleQuoted */
);
this.delegate.beginAttributeValue(true);
this.consume();
} else if (char === ">") {
this.delegate.beginAttributeValue(false);
this.delegate.finishAttributeValue();
this.consume();
this.delegate.finishTag();
this.transitionTo(
"beforeData"
/* beforeData */
);
} else {
this.transitionTo(
"attributeValueUnquoted"
/* attributeValueUnquoted */
);
this.delegate.beginAttributeValue(false);
this.consume();
this.delegate.appendToAttributeValue(char);
}
},
attributeValueDoubleQuoted: function() {
var char = this.consume();
if (char === '"') {
this.delegate.finishAttributeValue();
this.transitionTo(
"afterAttributeValueQuoted"
/* afterAttributeValueQuoted */
);
} else if (char === "&") {
this.delegate.appendToAttributeValue(this.consumeCharRef() || "&");
} else {
this.delegate.appendToAttributeValue(char);
}
},
attributeValueSingleQuoted: function() {
var char = this.consume();
if (char === "'") {
this.delegate.finishAttributeValue();
this.transitionTo(
"afterAttributeValueQuoted"
/* afterAttributeValueQuoted */
);
} else if (char === "&") {
this.delegate.appendToAttributeValue(this.consumeCharRef() || "&");
} else {
this.delegate.appendToAttributeValue(char);
}
},
attributeValueUnquoted: function() {
var char = this.peek();
if (isSpace(char)) {
this.delegate.finishAttributeValue();
this.consume();
this.transitionTo(
"beforeAttributeName"
/* beforeAttributeName */
);
} else if (char === "/") {
this.delegate.finishAttributeValue();
this.consume();
this.transitionTo(
"selfClosingStartTag"
/* selfClosingStartTag */
);
} else if (char === "&") {
this.consume();
this.delegate.appendToAttributeValue(this.consumeCharRef() || "&");
} else if (char === ">") {
this.delegate.finishAttributeValue();
this.consume();
this.delegate.finishTag();
this.transitionTo(
"beforeData"
/* beforeData */
);
} else {
this.consume();
this.delegate.appendToAttributeValue(char);
}
},
afterAttributeValueQuoted: function() {
var char = this.peek();
if (isSpace(char)) {
this.consume();
this.transitionTo(
"beforeAttributeName"
/* beforeAttributeName */
);
} else if (char === "/") {
this.consume();
this.transitionTo(
"selfClosingStartTag"
/* selfClosingStartTag */
);
} else if (char === ">") {
this.consume();
this.delegate.finishTag();
this.transitionTo(
"beforeData"
/* beforeData */
);
} else {
this.transitionTo(
"beforeAttributeName"
/* beforeAttributeName */
);
}
},
selfClosingStartTag: function() {
var char = this.peek();
if (char === ">") {
this.consume();
this.delegate.markTagAsSelfClosing();
this.delegate.finishTag();
this.transitionTo(
"beforeData"
/* beforeData */
);
} else {
this.transitionTo(
"beforeAttributeName"
/* beforeAttributeName */
);
}
},
endTagOpen: function() {
var char = this.consume();
if (char === "@" || char === ":" || isAlpha(char)) {
this.transitionTo(
"tagName"
/* tagName */
);
this.tagNameBuffer = "";
this.delegate.beginEndTag();
this.appendToTagName(char);
}
}
};
this.reset();
}
EventedTokenizer2.prototype.reset = function() {
this.transitionTo(
"beforeData"
/* beforeData */
);
this.input = "";
this.index = 0;
this.line = 1;
this.column = 0;
this.delegate.reset();
};
EventedTokenizer2.prototype.transitionTo = function(state) {
this.state = state;
};
EventedTokenizer2.prototype.tokenize = function(input) {
this.reset();
this.tokenizePart(input);
this.tokenizeEOF();
};
EventedTokenizer2.prototype.tokenizePart = function(input) {
this.input += preprocessInput(input);
while (this.index < this.input.length) {
var handler = this.states[this.state];
if (handler !== void 0) {
handler.call(this);
} else {
throw new Error("unhandled state " + this.state);
}
}
};
EventedTokenizer2.prototype.tokenizeEOF = function() {
this.flushData();
};
EventedTokenizer2.prototype.flushData = function() {
if (this.state === "data") {
this.delegate.finishData();
this.transitionTo(
"beforeData"
/* beforeData */
);
}
};
EventedTokenizer2.prototype.peek = function() {
return this.input.charAt(this.index);
};
EventedTokenizer2.prototype.consume = function() {
var char = this.peek();
this.index++;
if (char === "\n") {
this.line++;
this.column = 0;
} else {
this.column++;
}
return char;
};
EventedTokenizer2.prototype.consumeCharRef = function() {
var endIndex = this.input.indexOf(";", this.index);
if (endIndex === -1) {
return;
}
var entity = this.input.slice(this.index, endIndex);
var chars = this.entityParser.parse(entity);
if (chars) {
var count = entity.length;
while (count) {
this.consume();
count--;
}
this.consume();
return chars;
}
};
EventedTokenizer2.prototype.markTagStart = function() {
this.delegate.tagOpen();
};
EventedTokenizer2.prototype.appendToTagName = function(char) {
this.tagNameBuffer += char;
this.delegate.appendToTagName(char);
};
return EventedTokenizer2;
})()
);
var Tokenizer = (
/** @class */
(function() {
function Tokenizer2(entityParser, options) {
if (options === void 0) {
options = {};
}
this.options = options;
this.token = null;
this.startLine = 1;
this.startColumn = 0;
this.tokens = [];
this.tokenizer = new EventedTokenizer(this, entityParser);
this._currentAttribute = void 0;
}
Tokenizer2.prototype.tokenize = function(input) {
this.tokens = [];
this.tokenizer.tokenize(input);
return this.tokens;
};
Tokenizer2.prototype.tokenizePart = function(input) {
this.tokens = [];
this.tokenizer.tokenizePart(input);
return this.tokens;
};
Tokenizer2.prototype.tokenizeEOF = function() {
this.tokens = [];
this.tokenizer.tokenizeEOF();
return this.tokens[0];
};
Tokenizer2.prototype.reset = function() {
this.token = null;
this.startLine = 1;
this.startColumn = 0;
};
Tokenizer2.prototype.current = function() {
var token = this.token;
if (token === null) {
throw new Error("token was unexpectedly null");
}
if (arguments.length === 0) {
return token;
}
for (var i2 = 0; i2 < arguments.length; i2++) {
if (token.type === arguments[i2]) {
return token;
}
}
throw new Error("token type was unexpectedly " + token.type);
};
Tokenizer2.prototype.push = function(token) {
this.token = token;
this.tokens.push(token);
};
Tokenizer2.prototype.currentAttribute = function() {
return this._currentAttribute;
};
Tokenizer2.prototype.addLocInfo = function() {
if (this.options.loc) {
this.current().loc = {
start: {
line: this.startLine,
column: this.startColumn
},
end: {
line: this.tokenizer.line,
column: this.tokenizer.column
}
};
}
this.startLine = this.tokenizer.line;
this.startColumn = this.tokenizer.column;
};
Tokenizer2.prototype.beginData = function() {
this.push({
type: "Chars",
chars: ""
});
};
Tokenizer2.prototype.appendToData = function(char) {
this.current(
"Chars"
/* Chars */
).chars += char;
};
Tokenizer2.prototype.finishData = function() {
this.addLocInfo();
};
Tokenizer2.prototype.beginComment = function() {
this.push({
type: "Comment",
chars: ""
});
};
Tokenizer2.prototype.appendToCommentData = function(char) {
this.current(
"Comment"
/* Comment */
).chars += char;
};
Tokenizer2.prototype.finishComment = function() {
this.addLocInfo();
};
Tokenizer2.prototype.tagOpen = function() {
};
Tokenizer2.prototype.beginStartTag = function() {
this.push({
type: "StartTag",
tagName: "",
attributes: [],
selfClosing: false
});
};
Tokenizer2.prototype.beginEndTag = function() {
this.push({
type: "EndTag",
tagName: ""
});
};
Tokenizer2.prototype.finishTag = function() {
this.addLocInfo();
};
Tokenizer2.prototype.markTagAsSelfClosing = function() {
this.current(
"StartTag"
/* StartTag */
).selfClosing = true;
};
Tokenizer2.prototype.appendToTagName = function(char) {
this.current(
"StartTag",
"EndTag"
/* EndTag */
).tagName += char;
};
Tokenizer2.prototype.beginAttribute = function() {
this._currentAttribute = ["", "", false];
};
Tokenizer2.prototype.appendToAttributeName = function(char) {
this.currentAttribute()[0] += char;
};
Tokenizer2.prototype.beginAttributeValue = function(isQuoted) {
this.currentAttribute()[2] = isQuoted;
};
Tokenizer2.prototype.appendToAttributeValue = function(char) {
this.currentAttribute()[1] += char;
};
Tokenizer2.prototype.finishAttributeValue = function() {
this.current(
"StartTag"
/* StartTag */
).attributes.push(this._currentAttribute);
};
Tokenizer2.prototype.reportSyntaxError = function(message) {
this.current().syntaxError = message;
};
return Tokenizer2;
})()
);
// packages/blocks/build-module/api/validation/index.mjs
var import_es62 = __toESM(require_es6(), 1);
var import_deprecated8 = __toESM(require_deprecated(), 1);
var import_html_entities = __toESM(require_html_entities(), 1);
// packages/blocks/build-module/api/validation/logger.mjs
function createLogger() {
function createLogHandler(logger) {
return (message, ...args) => logger("Block validation: " + message, ...args);
}
return {
// eslint-disable-next-line no-console
error: createLogHandler(console.error),
// eslint-disable-next-line no-console
warning: createLogHandler(console.warn),
getItems() {
return [];
}
};
}
function createQueuedLogger() {
const queue = [];
const logger = createLogger();
return {
error(...args) {
queue.push({ log: logger.error, args });
},
warning(...args) {
queue.push({ log: logger.warning, args });
},
getItems() {
return queue;
}
};
}
// packages/blocks/build-module/api/validation/index.mjs
var identity = (x3) => x3;
var REGEXP_WHITESPACE = /[\t\n\r\v\f ]+/g;
var REGEXP_ONLY_WHITESPACE = /^[\t\n\r\v\f ]*$/;
var REGEXP_STYLE_URL_TYPE = /^url\s*\(['"\s]*(.*?)['"\s]*\)$/;
var BOOLEAN_ATTRIBUTES = [
"allowfullscreen",
"allowpaymentrequest",
"allowusermedia",
"async",
"autofocus",
"autoplay",
"checked",
"controls",
"default",
"defer",
"disabled",
"download",
"formnovalidate",
"hidden",
"ismap",
"itemscope",
"loop",
"multiple",
"muted",
"nomodule",
"novalidate",
"open",
"playsinline",
"readonly",
"required",
"reversed",
"selected",
"typemustmatch"
];
var ENUMERATED_ATTRIBUTES = [
"autocapitalize",
"autocomplete",
"charset",
"contenteditable",
"crossorigin",
"decoding",
"dir",
"draggable",
"enctype",
"formenctype",
"formmethod",
"http-equiv",
"inputmode",
"kind",
"method",
"preload",
"scope",
"shape",
"spellcheck",
"translate",
"type",
"wrap"
];
var MEANINGFUL_ATTRIBUTES = [
...BOOLEAN_ATTRIBUTES,
...ENUMERATED_ATTRIBUTES
];
var TEXT_NORMALIZATIONS = [
identity,
getTextWithCollapsedWhitespace
];
var REGEXP_NAMED_CHARACTER_REFERENCE = /^[\da-z]+$/i;
var REGEXP_DECIMAL_CHARACTER_REFERENCE = /^#\d+$/;
var REGEXP_HEXADECIMAL_CHARACTER_REFERENCE = /^#x[\da-f]+$/i;
function isValidCharacterReference(text2) {
return REGEXP_NAMED_CHARACTER_REFERENCE.test(text2) || REGEXP_DECIMAL_CHARACTER_REFERENCE.test(text2) || REGEXP_HEXADECIMAL_CHARACTER_REFERENCE.test(text2);
}
var DecodeEntityParser = class {
/**
* Returns a substitute string for an entity string sequence between `&`
* and `;`, or undefined if no substitution should occur.
*
* @param entity Entity fragment discovered in HTML.
*
* @return Entity substitute value.
*/
parse(entity) {
if (isValidCharacterReference(entity)) {
return (0, import_html_entities.decodeEntities)("&" + entity + ";");
}
return void 0;
}
};
function getTextPiecesSplitOnWhitespace(text2) {
return text2.trim().split(REGEXP_WHITESPACE);
}
function getTextWithCollapsedWhitespace(text2) {
return getTextPiecesSplitOnWhitespace(text2).join(" ");
}
function getMeaningfulAttributePairs(token) {
return (token.attributes ?? []).filter((pair) => {
const [key, value] = pair;
return value || key.indexOf("data-") === 0 || MEANINGFUL_ATTRIBUTES.includes(key);
});
}
function isEquivalentTextTokens(actual, expected, logger = createLogger()) {
let actualChars = actual.chars;
let expectedChars = expected.chars;
for (let i2 = 0; i2 < TEXT_NORMALIZATIONS.length; i2++) {
const normalize = TEXT_NORMALIZATIONS[i2];
actualChars = normalize(actualChars);
expectedChars = normalize(expectedChars);
if (actualChars === expectedChars) {
return true;
}
}
logger.warning(
"Expected text `%s`, saw `%s`.",
expected.chars,
actual.chars
);
return false;
}
function getNormalizedLength(value) {
if (0 === parseFloat(value)) {
return "0";
}
if (value.indexOf(".") === 0) {
return "0" + value;
}
return value;
}
function getNormalizedStyleValue(value) {
const textPieces = getTextPiecesSplitOnWhitespace(value);
const normalizedPieces = textPieces.map(getNormalizedLength);
const result = normalizedPieces.join(" ");
return result.replace(REGEXP_STYLE_URL_TYPE, "url($1)");
}
function getStyleProperties(text2) {
const pairs = text2.replace(/;?\s*$/, "").split(";").map((style) => {
const [key, ...valueParts] = style.split(":");
const value = valueParts.join(":");
return [key.trim(), getNormalizedStyleValue(value.trim())];
});
return Object.fromEntries(pairs);
}
var isEqualAttributesOfName = {
class: (actual, expected) => {
const [actualPieces, expectedPieces] = [actual, expected].map(
getTextPiecesSplitOnWhitespace
);
const actualDiff = actualPieces.filter(
(c2) => !expectedPieces.includes(c2)
);
const expectedDiff = expectedPieces.filter(
(c2) => !actualPieces.includes(c2)
);
return actualDiff.length === 0 && expectedDiff.length === 0;
},
style: (actual, expected) => {
return (0, import_es62.default)(
...[actual, expected].map(getStyleProperties)
);
},
// For each boolean attribute, mere presence of attribute in both is enough
// to assume equivalence.
...Object.fromEntries(
BOOLEAN_ATTRIBUTES.map((attribute) => [attribute, () => true])
)
};
function isEqualTagAttributePairs(actual, expected, logger = createLogger()) {
if (actual.length !== expected.length) {
logger.warning(
"Expected attributes %o, instead saw %o.",
expected,
actual
);
return false;
}
const expectedAttributes = {};
for (let i2 = 0; i2 < expected.length; i2++) {
expectedAttributes[expected[i2][0].toLowerCase()] = expected[i2][1];
}
for (let i2 = 0; i2 < actual.length; i2++) {
const [name, actualValue] = actual[i2];
const nameLower = name.toLowerCase();
if (!expectedAttributes.hasOwnProperty(nameLower)) {
logger.warning("Encountered unexpected attribute `%s`.", name);
return false;
}
const expectedValue = expectedAttributes[nameLower];
const isEqualAttributes = isEqualAttributesOfName[nameLower];
if (isEqualAttributes) {
if (!isEqualAttributes(actualValue, expectedValue)) {
logger.warning(
"Expected attribute `%s` of value `%s`, saw `%s`.",
name,
expectedValue,
actualValue
);
return false;
}
} else if (actualValue !== expectedValue) {
logger.warning(
"Expected attribute `%s` of value `%s`, saw `%s`.",
name,
expectedValue,
actualValue
);
return false;
}
}
return true;
}
var isEqualTokensOfType = {
StartTag: (actual, expected, logger = createLogger()) => {
if (actual.tagName !== expected.tagName && // Optimization: Use short-circuit evaluation to defer case-
// insensitive check on the assumption that the majority case will
// have exactly equal tag names.
actual.tagName.toLowerCase() !== expected.tagName.toLowerCase()) {
logger.warning(
"Expected tag name `%s`, instead saw `%s`.",
expected.tagName,
actual.tagName
);
return false;
}
return isEqualTagAttributePairs(
...[actual, expected].map(getMeaningfulAttributePairs),
logger
);
},
Chars: isEquivalentTextTokens,
Comment: isEquivalentTextTokens
};
function getNextNonWhitespaceToken(tokens) {
let token;
while (token = tokens.shift()) {
if (token.type !== "Chars") {
return token;
}
if (!REGEXP_ONLY_WHITESPACE.test(token.chars)) {
return token;
}
}
return void 0;
}
function getHTMLTokens(html2, logger = createLogger()) {
try {
return new Tokenizer(new DecodeEntityParser()).tokenize(
html2
);
} catch {
logger.warning("Malformed HTML detected: %s", html2);
}
return null;
}
function isClosedByToken(currentToken, nextToken) {
if (!currentToken.selfClosing) {
return false;
}
if (nextToken && nextToken.tagName === currentToken.tagName && nextToken.type === "EndTag") {
return true;
}
return false;
}
function isEquivalentHTML(actual, expected, logger = createLogger()) {
if (actual === expected) {
return true;
}
const [actualTokens, expectedTokens] = [actual, expected].map(
(html2) => getHTMLTokens(html2, logger)
);
if (!actualTokens || !expectedTokens) {
return false;
}
let actualToken, expectedToken;
while (actualToken = getNextNonWhitespaceToken(actualTokens)) {
expectedToken = getNextNonWhitespaceToken(expectedTokens);
if (!expectedToken) {
logger.warning(
"Expected end of content, instead saw %o.",
actualToken
);
return false;
}
if (actualToken.type !== expectedToken.type) {
logger.warning(
"Expected token of type `%s` (%o), instead saw `%s` (%o).",
expectedToken.type,
expectedToken,
actualToken.type,
actualToken
);
return false;
}
const isEqualTokens = isEqualTokensOfType[actualToken.type];
if (isEqualTokens && !isEqualTokens(actualToken, expectedToken, logger)) {
return false;
}
if (isClosedByToken(actualToken, expectedTokens[0])) {
getNextNonWhitespaceToken(expectedTokens);
} else if (isClosedByToken(expectedToken, actualTokens[0])) {
getNextNonWhitespaceToken(actualTokens);
}
}
if (expectedToken = getNextNonWhitespaceToken(expectedTokens)) {
logger.warning(
"Expected %o, instead saw end of content.",
expectedToken
);
return false;
}
return true;
}
function validateBlock(block, blockTypeOrName = block.name) {
const isFallbackBlock = block.name === getFreeformContentHandlerName() || block.name === getUnregisteredTypeHandlerName();
if (isFallbackBlock) {
return [true, []];
}
const logger = createQueuedLogger();
const blockType = normalizeBlockType(blockTypeOrName);
let generatedBlockContent;
try {
generatedBlockContent = getSaveContent(blockType, block.attributes);
} catch (error) {
logger.error(
"Block validation failed because an error occurred while generating block content:\n\n%s",
error.toString()
);
return [false, logger.getItems()];
}
const isValid = isEquivalentHTML(
block.originalContent,
generatedBlockContent,
logger
);
if (!isValid) {
logger.error(
"Block validation failed for `%s` (%o).\n\nContent generated by `save` function:\n\n%s\n\nContent retrieved from post body:\n\n%s",
blockType.name,
blockType,
generatedBlockContent,
block.originalContent
);
}
return [isValid, logger.getItems()];
}
function isValidBlockContent(blockTypeOrName, attributes, originalBlockContent) {
(0, import_deprecated8.default)("isValidBlockContent introduces opportunity for data loss", {
since: "12.6",
plugin: "Gutenberg",
alternative: "validateBlock"
});
const blockType = normalizeBlockType(blockTypeOrName);
const block = {
clientId: "",
name: blockType.name,
isValid: true,
attributes,
innerBlocks: [],
originalContent: originalBlockContent
};
const [isValid] = validateBlock(block, blockType);
return isValid;
}
// packages/blocks/build-module/api/parser/convert-legacy-block.mjs
function normalizeStyleStateAliases(style) {
if (true) {
return style;
}
if (!style || typeof style !== "object" || Array.isArray(style)) {
return style;
}
let normalizedStyle = style;
const viewportAliases = {
"@mobile": "mobile",
"@tablet": "tablet"
};
Object.entries(viewportAliases).forEach(([state, legacyState]) => {
if (!Object.hasOwn(normalizedStyle, legacyState)) {
return;
}
if (normalizedStyle === style) {
normalizedStyle = { ...normalizedStyle };
}
if (!Object.hasOwn(normalizedStyle, state)) {
normalizedStyle[state] = normalizedStyle[legacyState];
}
delete normalizedStyle[legacyState];
});
return normalizedStyle;
}
function convertLegacyBlockNameAndAttributes(name, attributes) {
const newAttributes = { ...attributes };
if ("core/cover-image" === name) {
name = "core/cover";
}
if ("core/text" === name || "core/cover-text" === name) {
name = "core/paragraph";
}
if (name && name.indexOf("core/social-link-") === 0) {
newAttributes.service = name.substring(17);
name = "core/social-link";
}
if (name && name.indexOf("core-embed/") === 0) {
const providerSlug = name.substring(11);
const deprecated13 = {
speaker: "speaker-deck",
polldaddy: "crowdsignal"
};
newAttributes.providerNameSlug = providerSlug in deprecated13 ? deprecated13[providerSlug] : providerSlug;
if (!["amazon-kindle", "wordpress"].includes(providerSlug)) {
newAttributes.responsive = true;
}
name = "core/embed";
}
if (name === "core/post-comment-author") {
name = "core/comment-author-name";
}
if (name === "core/post-comment-content") {
name = "core/comment-content";
}
if (name === "core/post-comment-date") {
name = "core/comment-date";
}
if (name === "core/comments-query-loop") {
name = "core/comments";
const className = newAttributes.className ?? "";
if (!className.includes("wp-block-comments-query-loop")) {
newAttributes.className = [
"wp-block-comments-query-loop",
className
].join(" ");
}
}
if (name === "core/post-comments") {
name = "core/comments";
newAttributes.legacy = true;
}
const layout = attributes.layout;
if (layout?.type === "grid" && typeof layout?.columnCount === "string") {
newAttributes.layout = {
...newAttributes.layout,
columnCount: parseInt(layout.columnCount, 10)
};
}
const style = attributes.style;
const styleLayout = style?.layout;
if (typeof styleLayout?.columnSpan === "string") {
const columnSpanNumber = parseInt(styleLayout.columnSpan, 10);
newAttributes.style = {
...newAttributes.style,
layout: {
...newAttributes.style?.layout,
columnSpan: isNaN(columnSpanNumber) ? void 0 : columnSpanNumber
}
};
}
if (typeof styleLayout?.rowSpan === "string") {
const rowSpanNumber = parseInt(styleLayout.rowSpan, 10);
newAttributes.style = {
...newAttributes.style,
layout: {
...newAttributes.style?.layout,
rowSpan: isNaN(rowSpanNumber) ? void 0 : rowSpanNumber
}
};
}
const normalizedStyle = normalizeStyleStateAliases(newAttributes.style);
if (normalizedStyle !== newAttributes.style) {
newAttributes.style = normalizedStyle;
}
return [name, newAttributes];
}
// node_modules/hpq/es/get-path.js
function getPath(object, path) {
var segments = path.split(".");
var segment;
while (segment = segments.shift()) {
if (!(segment in object)) {
return;
}
object = object[segment];
}
return object;
}
// node_modules/hpq/es/index.js
var getDocument = /* @__PURE__ */ (function() {
var doc;
return function() {
if (!doc) {
doc = document.implementation.createHTMLDocument("");
}
return doc;
};
})();
function parse(source, matchers) {
if (!matchers) {
return;
}
if ("string" === typeof source) {
var doc = getDocument();
doc.body.innerHTML = source;
source = doc.body;
}
if ("function" === typeof matchers) {
return matchers(source);
}
if (Object !== matchers.constructor) {
return;
}
return Object.keys(matchers).reduce(function(memo, key) {
memo[key] = parse(source, matchers[key]);
return memo;
}, {});
}
function prop(selector, name) {
if (1 === arguments.length) {
name = selector;
selector = void 0;
}
return function(node) {
var match = node;
if (selector) {
match = node.querySelector(selector);
}
if (match) {
return getPath(match, name);
}
};
}
function attr(selector, name) {
if (1 === arguments.length) {
name = selector;
selector = void 0;
}
return function(node) {
var attributes = prop(selector, "attributes")(node);
if (attributes && attributes.hasOwnProperty(name)) {
return attributes[name].value;
}
};
}
function text(selector) {
return prop(selector, "textContent");
}
function query(selector, matchers) {
return function(node) {
var matches = node.querySelectorAll(selector);
return [].map.call(matches, function(match) {
return parse(match, matchers);
});
};
}
// node_modules/memize/dist/index.js
function memize(fn, options) {
var size = 0;
var head;
var tail;
options = options || {};
function memoized() {
var node = head, len = arguments.length, args, i2;
searchCache: while (node) {
if (node.args.length !== arguments.length) {
node = node.next;
continue;
}
for (i2 = 0; i2 < len; i2++) {
if (node.args[i2] !== arguments[i2]) {
node = node.next;
continue searchCache;
}
}
if (node !== head) {
if (node === tail) {
tail = node.prev;
}
node.prev.next = node.next;
if (node.next) {
node.next.prev = node.prev;
}
node.next = head;
node.prev = null;
head.prev = node;
head = node;
}
return node.val;
}
args = new Array(len);
for (i2 = 0; i2 < len; i2++) {
args[i2] = arguments[i2];
}
node = {
args,
// Generate the result from original function
val: fn.apply(null, args)
};
if (head) {
head.prev = node;
node.next = head;
} else {
tail = node;
}
if (size === /** @type {MemizeOptions} */
options.maxSize) {
tail = /** @type {MemizeCacheNode} */
tail.prev;
tail.next = null;
} else {
size++;
}
head = node;
return node.val;
}
memoized.clear = function() {
head = null;
tail = null;
size = 0;
};
return memoized;
}
// packages/blocks/build-module/api/parser/get-block-attributes.mjs
var import_hooks4 = __toESM(require_hooks(), 1);
var import_rich_text4 = __toESM(require_rich_text(), 1);
// packages/blocks/build-module/api/matchers.mjs
var import_rich_text3 = __toESM(require_rich_text(), 1);
// packages/blocks/build-module/api/node.mjs
var import_deprecated10 = __toESM(require_deprecated(), 1);
// packages/blocks/build-module/api/children.mjs
var import_element3 = __toESM(require_element(), 1);
var import_deprecated9 = __toESM(require_deprecated(), 1);
function getSerializeCapableElement(children) {
return children;
}
function getChildrenArray(children) {
(0, import_deprecated9.default)("wp.blocks.children.getChildrenArray", {
since: "6.1",
version: "6.3",
link: "https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/"
});
return children;
}
function concat(...blockNodes) {
(0, import_deprecated9.default)("wp.blocks.children.concat", {
since: "6.1",
version: "6.3",
alternative: "wp.richText.concat",
link: "https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/"
});
const result = [];
for (let i2 = 0; i2 < blockNodes.length; i2++) {
const blockNode = Array.isArray(blockNodes[i2]) ? blockNodes[i2] : [blockNodes[i2]];
for (let j3 = 0; j3 < blockNode.length; j3++) {
const child = blockNode[j3];
const canConcatToPreviousString = typeof child === "string" && typeof result[result.length - 1] === "string";
if (canConcatToPreviousString) {
result[result.length - 1] += child;
} else {
result.push(child);
}
}
}
return result;
}
function fromDOM22(domNodes) {
(0, import_deprecated9.default)("wp.blocks.children.fromDOM", {
since: "6.1",
version: "6.3",
alternative: "wp.richText.create",
link: "https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/"
});
const result = [];
for (let i2 = 0; i2 < domNodes.length; i2++) {
try {
result.push(fromDOM2(domNodes[i2]));
} catch {
}
}
return result;
}
function toHTML(children) {
(0, import_deprecated9.default)("wp.blocks.children.toHTML", {
since: "6.1",
version: "6.3",
alternative: "wp.richText.toHTMLString",
link: "https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/"
});
const element = getSerializeCapableElement(children);
return (0, import_element3.renderToString)(element);
}
function matcher(selector) {
(0, import_deprecated9.default)("wp.blocks.children.matcher", {
since: "6.1",
version: "6.3",
alternative: "html source",
link: "https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/"
});
return (domNode) => {
let match = domNode;
if (selector) {
match = domNode.querySelector(selector);
}
if (match) {
return fromDOM22(match.childNodes);
}
return [];
};
}
var children_default = {
concat,
getChildrenArray,
fromDOM: fromDOM22,
toHTML,
matcher
};
// packages/blocks/build-module/api/node.mjs
function isNodeOfType(node, type) {
(0, import_deprecated10.default)("wp.blocks.node.isNodeOfType", {
since: "6.1",
version: "6.3",
link: "https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/"
});
return typeof node !== "string" && node?.type === type;
}
function getNamedNodeMapAsObject(nodeMap) {
const result = {};
for (let i2 = 0; i2 < nodeMap.length; i2++) {
const { name, value } = nodeMap[i2];
result[name] = value;
}
return result;
}
function fromDOM2(domNode) {
(0, import_deprecated10.default)("wp.blocks.node.fromDOM", {
since: "6.1",
version: "6.3",
alternative: "wp.richText.create",
link: "https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/"
});
if (domNode.nodeType === domNode.TEXT_NODE) {
return domNode.nodeValue;
}
if (domNode.nodeType !== domNode.ELEMENT_NODE) {
throw new TypeError(
"A block node can only be created from a node of type text or element."
);
}
return {
type: domNode.nodeName.toLowerCase(),
props: {
...getNamedNodeMapAsObject(domNode.attributes),
children: fromDOM22(domNode.childNodes)
}
};
}
function toHTML2(node) {
(0, import_deprecated10.default)("wp.blocks.node.toHTML", {
since: "6.1",
version: "6.3",
alternative: "wp.richText.toHTMLString",
link: "https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/"
});
return toHTML([node]);
}
function matcher2(selector) {
(0, import_deprecated10.default)("wp.blocks.node.matcher", {
since: "6.1",
version: "6.3",
alternative: "html source",
link: "https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/"
});
return (domNode) => {
let match = domNode;
if (selector) {
match = domNode.querySelector(selector);
}
try {
return fromDOM2(match);
} catch {
return null;
}
};
}
var node_default = {
isNodeOfType,
fromDOM: fromDOM2,
toHTML: toHTML2,
matcher: matcher2
};
// packages/blocks/build-module/api/matchers.mjs
function html(selector, multilineTag) {
return (domNode) => {
let match = domNode;
if (selector) {
match = domNode.querySelector(selector);
}
if (!match) {
return "";
}
if (multilineTag) {
let value = "";
const length = match.children.length;
for (let index = 0; index < length; index++) {
const child = match.children[index];
if (child.nodeName.toLowerCase() !== multilineTag) {
continue;
}
value += child.outerHTML;
}
return value;
}
return match.innerHTML;
};
}
var richText = (selector, preserveWhiteSpace) => (el) => {
const target = selector ? el.querySelector(selector) : el;
return target ? import_rich_text3.RichTextData.fromHTMLElement(target, {
preserveWhiteSpace
}) : import_rich_text3.RichTextData.empty();
};
// packages/blocks/build-module/api/parser/get-block-attributes.mjs
var toBooleanAttributeMatcher = (matcher3) => (value) => matcher3(value) !== void 0;
function isOfType(value, type) {
switch (type) {
case "rich-text":
return value instanceof import_rich_text4.RichTextData;
case "string":
return typeof value === "string";
case "boolean":
return typeof value === "boolean";
case "object":
return !!value && value.constructor === Object;
case "null":
return value === null;
case "array":
return Array.isArray(value);
case "integer":
case "number":
return typeof value === "number";
}
return true;
}
function isOfTypes(value, types) {
return types.some((type) => isOfType(value, type));
}
function getBlockAttribute(attributeKey, attributeSchema, innerDOM, commentAttributes, innerHTML) {
let value;
switch (attributeSchema.source) {
// An undefined source means that it's an attribute serialized to the
// block's "comment".
case void 0:
value = commentAttributes ? commentAttributes[attributeKey] : void 0;
break;
// raw source means that it's the original raw block content.
case "raw":
value = innerHTML;
break;
case "attribute":
case "property":
case "html":
case "text":
case "rich-text":
case "children":
case "node":
case "query":
case "tag":
value = parseWithAttributeSchema(innerDOM, attributeSchema);
break;
}
if (!isValidByType(value, attributeSchema.type) || !isValidByEnum(value, attributeSchema.enum)) {
value = void 0;
}
if (value === void 0) {
value = getDefault(attributeSchema);
}
return value;
}
function isValidByType(value, type) {
return type === void 0 || isOfTypes(value, Array.isArray(type) ? type : [type]);
}
function isValidByEnum(value, enumSet) {
return !Array.isArray(enumSet) || enumSet.includes(value);
}
var matcherFromSource = memize(
(sourceConfig) => {
switch (sourceConfig.source) {
case "attribute": {
let matcher3 = attr(
sourceConfig.selector,
sourceConfig.attribute
);
if (sourceConfig.type === "boolean") {
matcher3 = toBooleanAttributeMatcher(matcher3);
}
return matcher3;
}
case "html":
return html(sourceConfig.selector, sourceConfig.multiline);
case "text":
return text(sourceConfig.selector);
case "rich-text":
return richText(
sourceConfig.selector,
sourceConfig.__unstablePreserveWhiteSpace
);
case "children":
return matcher(sourceConfig.selector);
case "node":
return matcher2(sourceConfig.selector);
case "query":
const subMatchers = Object.fromEntries(
Object.entries(sourceConfig.query).map(
([key, subSourceConfig]) => [
key,
matcherFromSource(subSourceConfig)
]
)
);
return query(sourceConfig.selector, subMatchers);
case "tag": {
const matcher3 = prop(sourceConfig.selector, "nodeName");
return (domNode) => matcher3(domNode)?.toLowerCase();
}
default:
console.error(
`Unknown source type "${sourceConfig.source}"`
);
return void 0;
}
}
);
function parseHtml(innerHTML) {
return parse(innerHTML, (h2) => h2);
}
function parseWithAttributeSchema(innerHTML, attributeSchema) {
return matcherFromSource(attributeSchema)(
parseHtml(innerHTML)
);
}
function getBlockAttributes(blockTypeOrName, innerHTML, attributes = {}) {
const doc = parseHtml(innerHTML);
const blockType = normalizeBlockType(blockTypeOrName);
const blockAttributes = Object.fromEntries(
Object.entries(blockType?.attributes ?? {}).map(
([key, schema]) => [
key,
getBlockAttribute(key, schema, doc, attributes, innerHTML)
]
)
);
return (0, import_hooks4.applyFilters)(
"blocks.getBlockAttributes",
blockAttributes,
blockType,
innerHTML,
attributes
);
}
// packages/blocks/build-module/api/parser/fix-custom-classname.mjs
var CLASS_ATTR_SCHEMA = {
type: "string",
source: "attribute",
selector: "[data-custom-class-name] > *",
attribute: "class"
};
function getHTMLRootElementClasses(innerHTML) {
const parsed = parseWithAttributeSchema(
`<div data-custom-class-name>${innerHTML}</div>`,
CLASS_ATTR_SCHEMA
);
return parsed ? parsed.trim().split(/\s+/) : [];
}
function fixCustomClassname(blockAttributes, blockType, innerHTML) {
if (!hasBlockSupport(blockType, "customClassName", true)) {
return blockAttributes;
}
const modifiedBlockAttributes = { ...blockAttributes };
const { className: omittedClassName, ...attributesSansClassName } = modifiedBlockAttributes;
const serialized = getSaveContent(blockType, attributesSansClassName);
const defaultClasses = getHTMLRootElementClasses(serialized);
const actualClasses = getHTMLRootElementClasses(innerHTML);
const customClasses = actualClasses.filter(
(className) => !defaultClasses.includes(className)
);
if (customClasses.length) {
modifiedBlockAttributes.className = customClasses.join(" ");
} else if (serialized) {
delete modifiedBlockAttributes.className;
}
return modifiedBlockAttributes;
}
// packages/blocks/build-module/api/parser/fix-global-attribute.mjs
function getHTMLRootElement(innerHTML, dataAttribute, attributeSchema) {
const parsed = parseWithAttributeSchema(
`<div ${dataAttribute}>${innerHTML}</div>`,
attributeSchema
);
return parsed;
}
function fixGlobalAttribute(blockAttributes, blockType, innerHTML, supportKey, dataAttribute, attributeSchema) {
if (!hasBlockSupport(blockType, supportKey, false)) {
return blockAttributes;
}
const modifiedBlockAttributes = { ...blockAttributes };
const attributeValue = getHTMLRootElement(
innerHTML,
dataAttribute,
attributeSchema
);
if (attributeValue) {
modifiedBlockAttributes[supportKey] = attributeValue;
}
return modifiedBlockAttributes;
}
// packages/blocks/build-module/api/parser/apply-built-in-validation-fixes.mjs
var ARIA_LABEL_ATTR_SCHEMA = {
type: "string",
source: "attribute",
selector: "[data-aria-label] > *",
attribute: "aria-label"
};
var ANCHOR_ATTR_SCHEMA = {
type: "string",
source: "attribute",
selector: "[data-anchor] > *",
attribute: "id"
};
function applyBuiltInValidationFixes(block, blockType) {
const { attributes, originalContent } = block;
let updatedBlockAttributes = attributes;
updatedBlockAttributes = fixCustomClassname(
attributes,
blockType,
originalContent ?? ""
);
updatedBlockAttributes = fixGlobalAttribute(
updatedBlockAttributes,
blockType,
originalContent ?? "",
"ariaLabel",
"data-aria-label",
ARIA_LABEL_ATTR_SCHEMA
);
updatedBlockAttributes = fixGlobalAttribute(
updatedBlockAttributes,
blockType,
originalContent ?? "",
"anchor",
"data-anchor",
ANCHOR_ATTR_SCHEMA
);
return {
...block,
attributes: updatedBlockAttributes
};
}
// packages/blocks/build-module/api/parser/apply-block-deprecated-versions.mjs
function stubFalse() {
return false;
}
function applyBlockDeprecatedVersions(block, rawBlock, blockType) {
const parsedAttributes = rawBlock.attrs ?? {};
const { deprecated: deprecatedDefinitions } = blockType;
if (!deprecatedDefinitions || !deprecatedDefinitions.length) {
return block;
}
for (let i2 = 0; i2 < deprecatedDefinitions.length; i2++) {
const { isEligible = stubFalse } = deprecatedDefinitions[i2];
if (block.isValid && !isEligible(parsedAttributes, block.innerBlocks, {
blockNode: rawBlock,
block
})) {
continue;
}
const deprecatedBlockType = Object.assign(
omit(
blockType,
DEPRECATED_ENTRY_KEYS
),
deprecatedDefinitions[i2]
);
let migratedBlock = {
...block,
attributes: getBlockAttributes(
deprecatedBlockType,
block.originalContent ?? "",
parsedAttributes
)
};
let [isValid] = validateBlock(migratedBlock, deprecatedBlockType);
if (!isValid) {
migratedBlock = applyBuiltInValidationFixes(
migratedBlock,
deprecatedBlockType
);
[isValid] = validateBlock(migratedBlock, deprecatedBlockType);
}
if (!isValid) {
continue;
}
let migratedInnerBlocks = migratedBlock.innerBlocks;
let migratedAttributes = migratedBlock.attributes;
const { migrate } = deprecatedBlockType;
if (migrate) {
let migrated = migrate(migratedAttributes, block.innerBlocks);
if (!Array.isArray(migrated)) {
migrated = [migrated];
}
[
migratedAttributes = parsedAttributes,
migratedInnerBlocks = block.innerBlocks
] = migrated;
}
block = {
...block,
attributes: migratedAttributes,
innerBlocks: migratedInnerBlocks,
isValid: true,
validationIssues: []
};
}
return block;
}
// packages/blocks/build-module/api/parser/index.mjs
function convertLegacyBlocks(rawBlock) {
const [correctName, correctedAttributes] = convertLegacyBlockNameAndAttributes(
rawBlock.blockName,
rawBlock.attrs ?? {}
);
return {
...rawBlock,
blockName: correctName,
attrs: correctedAttributes
};
}
function normalizeRawBlock(rawBlock, options) {
const fallbackBlockName = getFreeformContentHandlerName();
const rawBlockName = rawBlock.blockName || getFreeformContentHandlerName();
const rawAttributes = rawBlock.attrs || {};
const rawInnerBlocks = rawBlock.innerBlocks || [];
let rawInnerHTML = rawBlock.innerHTML.trim();
if (rawBlockName === fallbackBlockName && rawBlockName === "core/freeform" && !options?.__unstableSkipAutop) {
rawInnerHTML = (0, import_autop2.autop)(rawInnerHTML).trim();
}
return {
...rawBlock,
blockName: rawBlockName,
attrs: rawAttributes,
innerHTML: rawInnerHTML,
innerBlocks: rawInnerBlocks
};
}
function createMissingBlockType(rawBlock) {
const unregisteredFallbackBlock = getUnregisteredTypeHandlerName() || getFreeformContentHandlerName();
const originalUndelimitedContent = serializeRawBlock(rawBlock, {
isCommentDelimited: false
});
const originalContent = serializeRawBlock(rawBlock, {
isCommentDelimited: true
});
return {
blockName: unregisteredFallbackBlock,
attrs: {
originalName: rawBlock.blockName,
originalContent,
originalUndelimitedContent
},
innerHTML: rawBlock.blockName ? originalContent : rawBlock.innerHTML,
innerBlocks: rawBlock.innerBlocks,
innerContent: rawBlock.innerContent
};
}
function applyBlockValidation(unvalidatedBlock, blockType) {
const [isValid] = validateBlock(unvalidatedBlock, blockType);
if (isValid) {
return { ...unvalidatedBlock, isValid, validationIssues: [] };
}
const fixedBlock = applyBuiltInValidationFixes(
unvalidatedBlock,
blockType
);
const [isFixedValid, validationIssues] = validateBlock(
fixedBlock,
blockType
);
return { ...fixedBlock, isValid: isFixedValid, validationIssues };
}
function parseRawBlock(rawBlock, options) {
let normalizedBlock = normalizeRawBlock(rawBlock, options);
normalizedBlock = convertLegacyBlocks(normalizedBlock);
let blockType = getBlockType(normalizedBlock.blockName);
if (!blockType) {
normalizedBlock = createMissingBlockType(normalizedBlock);
blockType = getBlockType(normalizedBlock.blockName);
}
const isFallbackBlock = normalizedBlock.blockName === getFreeformContentHandlerName() || normalizedBlock.blockName === getUnregisteredTypeHandlerName();
if (!blockType || !normalizedBlock.innerHTML && isFallbackBlock) {
return;
}
const parsedInnerBlocks = normalizedBlock.innerBlocks.map((innerBlock) => parseRawBlock(innerBlock, options)).filter((innerBlock) => !!innerBlock);
const parsedBlock = createBlock(
normalizedBlock.blockName,
getBlockAttributes(
blockType,
normalizedBlock.innerHTML,
normalizedBlock.attrs
),
parsedInnerBlocks
);
parsedBlock.originalContent = normalizedBlock.innerHTML;
if (blockType.name === "core/html") {
parsedBlock.innerContent = normalizedBlock.innerContent ?? [
normalizedBlock.innerHTML
];
parsedBlock.isValid = true;
parsedBlock.validationIssues = [];
return parsedBlock;
}
const validatedBlock = applyBlockValidation(parsedBlock, blockType);
const { validationIssues } = validatedBlock;
const updatedBlock = applyBlockDeprecatedVersions(
validatedBlock,
normalizedBlock,
blockType
);
if (!updatedBlock.isValid) {
updatedBlock.__unstableBlockSource = rawBlock;
}
if (!validatedBlock.isValid && updatedBlock.isValid && !options?.__unstableSkipMigrationLogs) {
console.groupCollapsed("Updated Block: %s", blockType.name);
console.info(
"Block successfully updated for `%s` (%o).\n\nNew content generated by `save` function:\n\n%s\n\nContent retrieved from post body:\n\n%s",
blockType.name,
blockType,
getSaveContent(blockType, updatedBlock.attributes),
updatedBlock.originalContent
);
console.groupEnd();
} else if (!validatedBlock.isValid && !updatedBlock.isValid) {
validationIssues.forEach(({ log: log2, args }) => log2(...args));
}
return updatedBlock;
}
function parse2(content, options) {
return (0, import_block_serialization_default_parser.parse)(content).reduce(
(accumulator, rawBlock) => {
const block = parseRawBlock(
rawBlock,
options
);
if (block) {
accumulator.push(block);
}
return accumulator;
},
[]
);
}
// packages/blocks/build-module/api/raw-handling/index.mjs
var import_deprecated11 = __toESM(require_deprecated(), 1);
var import_dom13 = __toESM(require_dom(), 1);
// packages/blocks/build-module/api/raw-handling/get-raw-transforms.mjs
function getRawTransforms() {
return getBlockTransforms("from").filter(({ type }) => type === "raw").map((transform) => {
return transform.isMatch ? transform : {
...transform,
isMatch: (node) => transform.selector && node.matches(transform.selector)
};
});
}
// packages/blocks/build-module/api/raw-handling/html-to-blocks.mjs
function htmlToBlocks(html2, handler) {
const doc = document.implementation.createHTMLDocument("");
doc.body.innerHTML = html2;
return Array.from(doc.body.children).flatMap((node) => {
const transforms = getRawTransforms();
const rawTransform = findTransform(
transforms,
((t3) => {
const transform2 = t3;
return transform2.isMatch(node);
})
);
if (!rawTransform) {
return createBlock(
// Should not be hardcoded.
"core/html",
{},
[],
[node.outerHTML]
);
}
const { transform, blockName } = rawTransform;
if (transform) {
const block = transform(node, handler);
if (node.hasAttribute("class")) {
block.attributes.className = node.getAttribute("class");
}
return block;
}
return createBlock(
blockName,
getBlockAttributes(blockName, node.outerHTML)
);
});
}
// packages/blocks/build-module/api/raw-handling/normalise-blocks.mjs
var import_dom2 = __toESM(require_dom(), 1);
function normaliseBlocks(HTML, options = {}) {
const decuDoc = document.implementation.createHTMLDocument("");
const accuDoc = document.implementation.createHTMLDocument("");
const decu = decuDoc.body;
const accu = accuDoc.body;
decu.innerHTML = HTML;
while (decu.firstChild) {
const node = decu.firstChild;
if (node.nodeType === node.TEXT_NODE) {
if ((0, import_dom2.isEmpty)(node)) {
decu.removeChild(node);
} else {
if (!accu.lastChild || accu.lastChild.nodeName !== "P") {
accu.appendChild(accuDoc.createElement("P"));
}
accu.lastChild.appendChild(node);
}
} else if (node.nodeType === node.ELEMENT_NODE) {
if (node.nodeName === "BR") {
if (node.nextSibling && node.nextSibling.nodeName === "BR") {
accu.appendChild(accuDoc.createElement("P"));
decu.removeChild(node.nextSibling);
}
if (accu.lastChild && accu.lastChild.nodeName === "P" && accu.lastChild.hasChildNodes()) {
accu.lastChild.appendChild(node);
} else {
decu.removeChild(node);
}
} else if (node.nodeName === "P") {
if ((0, import_dom2.isEmpty)(node) && !options.raw) {
decu.removeChild(node);
} else {
accu.appendChild(node);
}
} else if ((0, import_dom2.isPhrasingContent)(node)) {
if (!accu.lastChild || accu.lastChild.nodeName !== "P") {
accu.appendChild(accuDoc.createElement("P"));
}
accu.lastChild.appendChild(node);
} else {
accu.appendChild(node);
}
} else {
decu.removeChild(node);
}
}
return accu.innerHTML;
}
// packages/blocks/build-module/api/raw-handling/special-comment-converter.mjs
var import_dom3 = __toESM(require_dom(), 1);
function specialCommentConverter(node, doc) {
if (node.nodeType !== node.COMMENT_NODE) {
return;
}
if (node.nodeValue !== "nextpage" && node.nodeValue.indexOf("more") !== 0) {
return;
}
const block = createBlock2(node, doc);
if (!node.parentNode || node.parentNode.nodeName !== "P") {
(0, import_dom3.replace)(node, block);
} else {
const childNodes = Array.from(node.parentNode.childNodes);
const nodeIndex = childNodes.indexOf(node);
const wrapperNode = node.parentNode.parentNode || doc.body;
const paragraphBuilder = (acc, child) => {
if (!acc) {
acc = doc.createElement("p");
}
acc.appendChild(child);
return acc;
};
[
childNodes.slice(0, nodeIndex).reduce(paragraphBuilder, null),
block,
childNodes.slice(nodeIndex + 1).reduce(paragraphBuilder, null)
].forEach(
(element) => element && wrapperNode.insertBefore(element, node.parentNode)
);
(0, import_dom3.remove)(node.parentNode);
}
}
function createBlock2(commentNode, doc) {
if (commentNode.nodeValue === "nextpage") {
return createNextpage(doc);
}
const customText = commentNode.nodeValue.slice(4).trim();
let sibling = commentNode;
let noTeaser = false;
while (sibling = sibling.nextSibling) {
if (sibling.nodeType === sibling.COMMENT_NODE && sibling.nodeValue === "noteaser") {
noTeaser = true;
(0, import_dom3.remove)(sibling);
break;
}
}
return createMore(customText, noTeaser, doc);
}
function createMore(customText, noTeaser, doc) {
const node = doc.createElement("wp-block");
node.dataset.block = "core/more";
if (customText) {
node.dataset.customText = customText;
}
if (noTeaser) {
node.dataset.noTeaser = "";
}
return node;
}
function createNextpage(doc) {
const node = doc.createElement("wp-block");
node.dataset.block = "core/nextpage";
return node;
}
// packages/blocks/build-module/api/raw-handling/list-reducer.mjs
var import_dom4 = __toESM(require_dom(), 1);
function isList(node) {
return node.nodeName === "OL" || node.nodeName === "UL";
}
function shallowTextContent(element) {
return Array.from(element.childNodes).map(({ nodeValue = "" }) => nodeValue).join("");
}
function listReducer(node) {
if (!isList(node)) {
return;
}
const list = node;
const prevElement = list.previousElementSibling;
if (prevElement && prevElement.nodeName === node.nodeName && list.children.length === 1) {
while (list.firstChild) {
prevElement.appendChild(list.firstChild);
}
list.parentNode.removeChild(list);
}
const parentElement = node.parentNode;
if (parentElement && parentElement.nodeName === "LI" && parentElement.children.length === 1 && !/\S/.test(shallowTextContent(parentElement))) {
const parentListItem = parentElement;
const prevListItem = parentListItem.previousElementSibling;
const parentList = parentListItem.parentNode;
if (prevListItem) {
prevListItem.appendChild(list);
parentList.removeChild(parentListItem);
}
}
if (parentElement && isList(parentElement)) {
const prevListItem = list.previousElementSibling;
if (prevListItem) {
prevListItem.appendChild(node);
} else {
(0, import_dom4.unwrap)(node);
}
}
}
// packages/blocks/build-module/api/raw-handling/blockquote-normaliser.mjs
function blockquoteNormaliser(options = {}) {
return (bq) => {
if (bq.nodeName !== "BLOCKQUOTE") {
return;
}
const node = bq;
node.innerHTML = normaliseBlocks(node.innerHTML, options);
};
}
// packages/blocks/build-module/api/raw-handling/figure-content-reducer.mjs
var import_dom5 = __toESM(require_dom(), 1);
function isFigureContent(node, schema) {
const tag = node.nodeName.toLowerCase();
if (tag === "figcaption" || (0, import_dom5.isTextContent)(node)) {
return false;
}
return tag in (schema?.figure?.children ?? {});
}
function canHaveAnchor(node, schema) {
const tag = node.nodeName.toLowerCase();
return tag in (schema?.figure?.children?.a?.children ?? {});
}
function wrapFigureContent(element, beforeElement = element) {
const figure = element.ownerDocument.createElement("figure");
beforeElement.parentNode.insertBefore(figure, beforeElement);
figure.appendChild(element);
}
function figureContentReducer(node, doc, schema) {
if (!schema || !isFigureContent(node, schema)) {
return;
}
let nodeToInsert = node;
const parentNode = node.parentNode;
if (canHaveAnchor(node, schema) && parentNode.nodeName === "A" && parentNode.childNodes.length === 1) {
nodeToInsert = node.parentNode;
}
const wrapper = nodeToInsert.closest("p,div");
if (wrapper) {
const element = node;
if (!element.classList) {
wrapFigureContent(nodeToInsert, wrapper);
} else if (element.classList.contains("alignright") || element.classList.contains("alignleft") || element.classList.contains("aligncenter") || !wrapper.textContent.trim()) {
wrapFigureContent(nodeToInsert, wrapper);
}
} else {
wrapFigureContent(nodeToInsert);
}
}
// packages/blocks/build-module/api/raw-handling/shortcode-converter.mjs
var import_shortcode = __toESM(require_shortcode(), 1);
var castArray = (maybeArray) => Array.isArray(maybeArray) ? maybeArray : [maybeArray];
var beforeLineRegexp = /(\n|<p>|<br\s*\/?>)\s*$/;
var afterLineRegexp = /^\s*(\n|<\/p>|<br\s*\/?>)/;
function segmentHTMLToShortcodeBlock(HTML, lastIndex = 0, excludedBlockNames = []) {
const transformsFrom = getBlockTransforms(
"from"
);
const transformation = findTransform(
transformsFrom,
((transform) => {
const t3 = transform;
return excludedBlockNames.indexOf(t3.blockName) === -1 && t3.type === "shortcode" && castArray(t3.tag).some(
(tag) => (0, import_shortcode.regexp)(tag).test(HTML)
);
})
);
if (!transformation) {
return [HTML];
}
const transformTags = castArray(transformation.tag);
const transformTag = transformTags.find(
(tag) => (0, import_shortcode.regexp)(tag).test(HTML)
);
let match;
const previousIndex = lastIndex;
if (match = (0, import_shortcode.next)(transformTag, HTML, lastIndex)) {
lastIndex = match.index + match.content.length;
const beforeHTML = HTML.substr(0, match.index);
const afterHTML = HTML.substr(lastIndex);
if (!match.shortcode.content?.includes("<") && !(beforeLineRegexp.test(beforeHTML) && afterLineRegexp.test(afterHTML))) {
return segmentHTMLToShortcodeBlock(HTML, lastIndex);
}
if (transformation.isMatch && !transformation.isMatch(match.shortcode.attrs)) {
return segmentHTMLToShortcodeBlock(HTML, previousIndex, [
...excludedBlockNames,
transformation.blockName
]);
}
let blocks = [];
if (typeof transformation.transform === "function") {
blocks = [].concat(
transformation.transform(match.shortcode.attrs, match)
);
blocks = blocks.map((block) => {
block.originalContent = match.shortcode.content;
return applyBuiltInValidationFixes(
block,
getBlockType(block.name)
);
});
} else {
const attributes = Object.fromEntries(
Object.entries(transformation.attributes).filter(([, schema]) => schema.shortcode).map(([key, schema]) => [
key,
schema.shortcode(match.shortcode.attrs, match)
])
);
const blockType = getBlockType(transformation.blockName);
if (!blockType) {
return [HTML];
}
const transformationBlockType = {
...blockType,
attributes: transformation.attributes
};
let block = createBlock(
transformation.blockName,
getBlockAttributes(
transformationBlockType,
match.shortcode.content,
attributes
)
);
block.originalContent = match.shortcode.content;
block = applyBuiltInValidationFixes(
block,
transformationBlockType
);
blocks = [block];
}
return [
...segmentHTMLToShortcodeBlock(
beforeHTML.replace(beforeLineRegexp, "")
),
...blocks,
...segmentHTMLToShortcodeBlock(
afterHTML.replace(afterLineRegexp, "")
)
];
}
return [HTML];
}
var shortcode_converter_default = segmentHTMLToShortcodeBlock;
// packages/blocks/build-module/api/raw-handling/utils.mjs
var import_dom6 = __toESM(require_dom(), 1);
function getBlockContentSchemaFromTransforms(transforms, context) {
const phrasingContentSchema = (0, import_dom6.getPhrasingContentSchema)(context);
const schemaArgs = { phrasingContentSchema, isPaste: context === "paste" };
const schemas = transforms.map(({ isMatch, blockName, schema }) => {
const hasAnchorSupport = hasBlockSupport(blockName, "anchor");
schema = typeof schema === "function" ? schema(schemaArgs) : schema;
if (!hasAnchorSupport && !isMatch) {
return schema;
}
if (!schema) {
return {};
}
return Object.fromEntries(
Object.entries(schema).map(([key, value]) => {
let attributes = value.attributes || [];
if (hasAnchorSupport) {
attributes = [...attributes, "id"];
}
return [
key,
{
...value,
attributes,
isMatch: isMatch ? isMatch : void 0
}
];
})
);
});
function mergeTagNameSchemaProperties(objValue, srcValue, key) {
switch (key) {
case "children": {
if (objValue === "*" || srcValue === "*") {
return "*";
}
return mergeSchemas(
{ ...objValue || {} },
srcValue || {}
);
}
case "attributes":
case "require": {
return Array.from(
/* @__PURE__ */ new Set([...objValue || [], ...srcValue || []])
);
}
case "isMatch": {
if (!objValue || !srcValue) {
return void 0;
}
return (...args) => {
return objValue(...args) || srcValue(...args);
};
}
case "classes": {
if ((objValue || []).includes("*") || (srcValue || []).includes("*")) {
return ["*"];
}
return [...objValue || [], ...srcValue || []];
}
}
}
function mergeTagNameSchemas(a2, b3) {
if (a2 === b3) {
return a2;
}
for (const key in b3) {
if (a2[key]) {
a2[key] = mergeTagNameSchemaProperties(
a2[key],
b3[key],
key
);
} else if (Array.isArray(b3[key])) {
a2[key] = b3[key].slice();
} else {
a2[key] = { ...b3[key] };
}
}
return a2;
}
function mergeSchemas(a2, b3) {
if (a2 === b3) {
return a2;
}
for (const key in b3) {
if (a2[key]) {
a2[key] = mergeTagNameSchemas(a2[key], b3[key]);
} else if (Array.isArray(b3[key])) {
a2[key] = b3[key].slice();
} else {
a2[key] = { ...b3[key] };
}
}
return a2;
}
return schemas.reduce(mergeSchemas, {});
}
function getBlockContentSchema(context) {
return getBlockContentSchemaFromTransforms(getRawTransforms(), context);
}
function isPlain(HTML) {
if (!/<(?!br[ />])/i.test(HTML)) {
return true;
}
const doc = document.implementation.createHTMLDocument("");
doc.body.innerHTML = HTML;
if (doc.body.children.length !== 1) {
return false;
}
const wrapper = doc.body.children.item(0);
const descendants = wrapper.getElementsByTagName("*");
for (let i2 = 0; i2 < descendants.length; i2++) {
if (descendants.item(i2).tagName !== "BR") {
return false;
}
}
if (wrapper.tagName !== "SPAN") {
return false;
}
return true;
}
function deepFilterNodeList(nodeList, filters, doc, schema) {
Array.from(nodeList).forEach((node) => {
deepFilterNodeList(node.childNodes, filters, doc, schema);
filters.forEach((item) => {
if (!doc.contains(node)) {
return;
}
item(node, doc, schema);
});
});
}
function deepFilterHTML(HTML, filters = [], schema) {
const doc = document.implementation.createHTMLDocument("");
doc.body.innerHTML = HTML;
deepFilterNodeList(doc.body.childNodes, filters, doc, schema);
return doc.body.innerHTML;
}
function getSibling(node, which) {
const sibling = node[`${which}Sibling`];
if (sibling && (0, import_dom6.isPhrasingContent)(sibling)) {
return sibling;
}
const { parentNode } = node;
if (!parentNode || !(0, import_dom6.isPhrasingContent)(parentNode)) {
return;
}
return getSibling(parentNode, which);
}
// packages/blocks/build-module/api/raw-handling/paste-handler.mjs
var import_dom12 = __toESM(require_dom(), 1);
// packages/blocks/build-module/api/raw-handling/comment-remover.mjs
var import_dom7 = __toESM(require_dom(), 1);
function commentRemover(node) {
if (node.nodeType === node.COMMENT_NODE) {
(0, import_dom7.remove)(node);
}
}
// packages/blocks/build-module/api/raw-handling/is-inline-content.mjs
var import_dom8 = __toESM(require_dom(), 1);
function isInline(node, contextTag) {
if ((0, import_dom8.isTextContent)(node)) {
return true;
}
if (!contextTag) {
return false;
}
const tag = node.nodeName.toLowerCase();
const inlineAllowedTagGroups = [
["ul", "li", "ol"],
["h1", "h2", "h3", "h4", "h5", "h6"]
];
return inlineAllowedTagGroups.some(
(tagGroup) => [tag, contextTag].filter((t3) => !tagGroup.includes(t3)).length === 0
);
}
function deepCheck(nodes, contextTag) {
return nodes.every(
(node) => isInline(node, contextTag) && deepCheck(Array.from(node.children), contextTag)
);
}
function isDoubleBR(node) {
return node.nodeName === "BR" && !!node.previousSibling && node.previousSibling.nodeName === "BR";
}
function isInlineContent(HTML, contextTag) {
const doc = document.implementation.createHTMLDocument("");
doc.body.innerHTML = HTML;
const nodes = Array.from(doc.body.children);
return !nodes.some(isDoubleBR) && deepCheck(nodes, contextTag);
}
// packages/blocks/build-module/api/raw-handling/phrasing-content-reducer.mjs
var import_dom9 = __toESM(require_dom(), 1);
function phrasingContentReducer(node, doc) {
if (node.nodeName === "SPAN" && node.style) {
const {
fontWeight,
fontStyle,
textDecorationLine,
textDecoration,
verticalAlign
} = node.style;
const element = node;
if (fontWeight === "bold" || fontWeight === "700") {
(0, import_dom9.wrap)(doc.createElement("strong"), element);
}
if (fontStyle === "italic") {
(0, import_dom9.wrap)(doc.createElement("em"), element);
}
if (textDecorationLine === "line-through" || textDecoration.includes("line-through")) {
(0, import_dom9.wrap)(doc.createElement("s"), element);
}
if (verticalAlign === "super") {
(0, import_dom9.wrap)(doc.createElement("sup"), element);
} else if (verticalAlign === "sub") {
(0, import_dom9.wrap)(doc.createElement("sub"), element);
}
} else if (node.nodeName === "B") {
(0, import_dom9.replaceTag)(node, "strong");
} else if (node.nodeName === "I") {
(0, import_dom9.replaceTag)(node, "em");
} else if (node.nodeName === "A") {
const anchor = node;
if (anchor.target && anchor.target.toLowerCase() === "_blank") {
anchor.rel = "noopener";
} else {
anchor.removeAttribute("target");
anchor.removeAttribute("rel");
}
if (anchor.name && !anchor.id) {
anchor.id = anchor.name;
}
if (anchor.id && !anchor.ownerDocument.querySelector(`[href="#${anchor.id}"]`)) {
anchor.removeAttribute("id");
}
}
}
// packages/blocks/build-module/api/raw-handling/head-remover.mjs
function headRemover(node) {
if (node.nodeName !== "SCRIPT" && node.nodeName !== "NOSCRIPT" && node.nodeName !== "TEMPLATE" && node.nodeName !== "STYLE") {
return;
}
node.parentNode.removeChild(node);
}
// packages/blocks/build-module/api/raw-handling/ms-list-ignore.mjs
function msListIgnore(node) {
if (node.nodeType !== node.ELEMENT_NODE) {
return;
}
const el = node;
const style = el.getAttribute("style");
if (!style || !style.includes("mso-list")) {
return;
}
const rules = style.split(";").reduce(
(acc, rule) => {
const [key, value] = rule.split(":");
if (key && value) {
acc[key.trim().toLowerCase()] = value.trim().toLowerCase();
}
return acc;
},
{}
);
if (rules["mso-list"] === "ignore") {
el.remove();
}
}
// packages/blocks/build-module/api/raw-handling/ms-list-converter.mjs
function isList2(node) {
return node.nodeName === "OL" || node.nodeName === "UL";
}
function msListConverter(node, doc) {
if (node.nodeName !== "P") {
return;
}
const element = node;
const style = element.getAttribute("style");
if (!style || !style.includes("mso-list")) {
return;
}
const prevNode = element.previousElementSibling;
if (!prevNode || !isList2(prevNode)) {
const type = element.textContent.trim().slice(0, 1);
const isNumeric = /[1iIaA]/.test(type);
const newListNode = doc.createElement(isNumeric ? "ol" : "ul");
if (isNumeric) {
newListNode.setAttribute("type", type);
}
element.parentNode.insertBefore(newListNode, element);
}
const listNode = element.previousElementSibling;
const listType = listNode.nodeName;
const listItem = doc.createElement("li");
let receivingNode = listNode;
listItem.innerHTML = deepFilterHTML(element.innerHTML, [msListIgnore]);
const matches = /mso-list\s*:[^;]+level([0-9]+)/i.exec(style);
let level = matches ? parseInt(matches[1], 10) - 1 || 0 : 0;
while (level--) {
receivingNode = receivingNode.lastChild || receivingNode;
if (isList2(receivingNode)) {
receivingNode = receivingNode.lastChild || receivingNode;
}
}
if (!isList2(receivingNode)) {
receivingNode = receivingNode.appendChild(
doc.createElement(listType)
);
}
receivingNode.appendChild(listItem);
element.parentNode.removeChild(element);
}
// packages/blocks/build-module/api/raw-handling/image-corrector.mjs
var import_blob = __toESM(require_blob(), 1);
function imageCorrector(img) {
if (img.nodeName !== "IMG") {
return;
}
const node = img;
if (node.src.indexOf("file:") === 0) {
node.src = "";
}
if (node.src.indexOf("data:") === 0) {
const [properties, data] = node.src.split(",");
const [type] = properties.slice(5).split(";");
if (!data || !type) {
node.src = "";
return;
}
let decoded;
try {
decoded = atob(data);
} catch {
node.src = "";
return;
}
const uint8Array = new Uint8Array(decoded.length);
for (let i2 = 0; i2 < uint8Array.length; i2++) {
uint8Array[i2] = decoded.charCodeAt(i2);
}
const name = type.replace("/", ".");
const file = new window.File([uint8Array], name, { type });
node.src = (0, import_blob.createBlobURL)(file);
}
if (node.height === 1 || node.width === 1) {
node.parentNode.removeChild(node);
}
}
// packages/blocks/build-module/api/raw-handling/div-normaliser.mjs
function divNormaliser(div) {
if (div.nodeName !== "DIV") {
return;
}
const node = div;
node.innerHTML = normaliseBlocks(node.innerHTML);
}
// node_modules/marked/lib/marked.esm.js
function z() {
return { async: false, breaks: false, extensions: null, gfm: true, hooks: null, pedantic: false, renderer: null, silent: false, tokenizer: null, walkTokens: null };
}
var T = z();
function G(l4) {
T = l4;
}
var _ = { exec: () => null };
function d2(l4, e2 = "") {
let t3 = typeof l4 == "string" ? l4 : l4.source, n2 = { replace: (s2, r2) => {
let i2 = typeof r2 == "string" ? r2 : r2.source;
return i2 = i2.replace(m2.caret, "$1"), t3 = t3.replace(s2, i2), n2;
}, getRegex: () => new RegExp(t3, e2) };
return n2;
}
var Re = ((l4 = "") => {
try {
return !!new RegExp("(?<=1)(?<!1)" + l4);
} catch {
return false;
}
})();
var m2 = { codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm, outputLinkReplace: /\\([\[\]])/g, indentCodeCompensation: /^(\s+)(?:```)/, beginningSpace: /^\s+/, endingHash: /#$/, startingSpaceChar: /^ /, endingSpaceChar: / $/, nonSpaceChar: /[^ ]/, newLineCharGlobal: /\n/g, tabCharGlobal: /\t/g, multipleSpaceGlobal: /\s+/g, blankLine: /^[ \t]*$/, doubleBlankLine: /\n[ \t]*\n[ \t]*$/, blockquoteStart: /^ {0,3}>/, blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g, blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm, listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g, listIsTask: /^\[[ xX]\] +\S/, listReplaceTask: /^\[[ xX]\] +/, listTaskCheckbox: /\[[ xX]\]/, anyLine: /\n.*\n/, hrefBrackets: /^<(.*)>$/, tableDelimiter: /[:|]/, tableAlignChars: /^\||\| *$/g, tableRowBlankLine: /\n[ \t]*$/, tableAlignRight: /^ *-+: *$/, tableAlignCenter: /^ *:-+: *$/, tableAlignLeft: /^ *:-+ *$/, startATag: /^<a /i, endATag: /^<\/a>/i, startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i, endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i, startAngleBracket: /^</, endAngleBracket: />$/, pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/, unicodeAlphaNumeric: /[\p{L}\p{N}]/u, escapeTest: /[&<>"']/, escapeReplace: /[&<>"']/g, escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g, caret: /(^|[^\[])\^/g, percentDecode: /%25/g, findPipe: /\|/g, splitPipe: / \|/, slashPipe: /\\\|/g, carriageReturn: /\r\n|\r/g, spaceLine: /^ +$/gm, notSpaceStart: /^\S*/, endingNewline: /\n$/, listItemRegex: (l4) => new RegExp(`^( {0,3}${l4})((?:[ ][^\\n]*)?(?:\\n|$))`), nextBulletRegex: (l4) => new RegExp(`^ {0,${Math.min(3, l4 - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`), hrRegex: (l4) => new RegExp(`^ {0,${Math.min(3, l4 - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`), fencesBeginRegex: (l4) => new RegExp(`^ {0,${Math.min(3, l4 - 1)}}(?:\`\`\`|~~~)`), headingBeginRegex: (l4) => new RegExp(`^ {0,${Math.min(3, l4 - 1)}}#`), htmlBeginRegex: (l4) => new RegExp(`^ {0,${Math.min(3, l4 - 1)}}<(?:[a-z].*>|!--)`, "i"), blockquoteBeginRegex: (l4) => new RegExp(`^ {0,${Math.min(3, l4 - 1)}}>`) };
var Te = /^(?:[ \t]*(?:\n|$))+/;
var Oe = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
var we = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
var I = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
var ye = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
var Q = / {0,3}(?:[*+-]|\d{1,9}[.)])/;
var ie = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/;
var oe = d2(ie).replace(/bull/g, Q).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex();
var Pe = d2(ie).replace(/bull/g, Q).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex();
var j2 = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
var Se = /^[^\n]+/;
var F = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/;
var $e = d2(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", F).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
var Le = d2(/^(bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, Q).getRegex();
var v2 = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
var U = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
var _e = d2("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$))", "i").replace("comment", U).replace("tag", v2).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
var ae = d2(j2).replace("hr", I).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", v2).getRegex();
var Me = d2(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", ae).getRegex();
var K = { blockquote: Me, code: Oe, def: $e, fences: we, heading: ye, hr: I, html: _e, lheading: oe, list: Le, newline: Te, paragraph: ae, table: _, text: Se };
var re = d2("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", I).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3} )[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", v2).getRegex();
var ze = { ...K, lheading: Pe, table: re, paragraph: d2(j2).replace("hr", I).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", re).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", v2).getRegex() };
var Ee = { ...K, html: d2(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", U).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, heading: /^(#{1,6})(.*)(?:\n+|$)/, fences: _, lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, paragraph: d2(j2).replace("hr", I).replace("heading", ` *#{1,6} *[^
]`).replace("lheading", oe).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() };
var Ae = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
var Ce = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
var le = /^( {2,}|\\)\n(?!\s*$)/;
var Ie = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
var E = /[\p{P}\p{S}]/u;
var H2 = /[\s\p{P}\p{S}]/u;
var W = /[^\s\p{P}\p{S}]/u;
var Be = d2(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, H2).getRegex();
var ue = /(?!~)[\p{P}\p{S}]/u;
var De = /(?!~)[\s\p{P}\p{S}]/u;
var qe = /(?:[^\s\p{P}\p{S}]|~)/u;
var ve = d2(/link|precode-code|html/, "g").replace("link", /\[(?:[^\[\]`]|(?<a>`+)[^`]+\k<a>(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace("precode-", Re ? "(?<!`)()" : "(^^|[^`])").replace("code", /(?<b>`+)[^`]+\k<b>(?!`)/).replace("html", /<(?! )[^<>]*?>/).getRegex();
var pe = /^(?:\*+(?:((?!\*)punct)|([^\s*]))?)|^_+(?:((?!_)punct)|([^\s_]))?/;
var He = d2(pe, "u").replace(/punct/g, E).getRegex();
var Ze = d2(pe, "u").replace(/punct/g, ue).getRegex();
var ce = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)";
var Ge = d2(ce, "gu").replace(/notPunctSpace/g, W).replace(/punctSpace/g, H2).replace(/punct/g, E).getRegex();
var Ne = d2(ce, "gu").replace(/notPunctSpace/g, qe).replace(/punctSpace/g, De).replace(/punct/g, ue).getRegex();
var Qe = d2("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, W).replace(/punctSpace/g, H2).replace(/punct/g, E).getRegex();
var je = d2(/^~~?(?:((?!~)punct)|[^\s~])/, "u").replace(/punct/g, E).getRegex();
var Fe = "^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)";
var Ue = d2(Fe, "gu").replace(/notPunctSpace/g, W).replace(/punctSpace/g, H2).replace(/punct/g, E).getRegex();
var Ke = d2(/\\(punct)/, "gu").replace(/punct/g, E).getRegex();
var We = d2(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
var Xe = d2(U).replace("(?:-->|$)", "-->").getRegex();
var Je = d2("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", Xe).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
var q = /(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\])|[^\[\]\\`])*?/;
var Ve = d2(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]+(?:\n[ \t]*)?|\n[ \t]*)(title))?\s*\)/).replace("label", q).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
var he = d2(/^!?\[(label)\]\[(ref)\]/).replace("label", q).replace("ref", F).getRegex();
var ke = d2(/^!?\[(ref)\](?:\[\])?/).replace("ref", F).getRegex();
var Ye = d2("reflink|nolink(?!\\()", "g").replace("reflink", he).replace("nolink", ke).getRegex();
var se = /[hH][tT][tT][pP][sS]?|[fF][tT][pP]/;
var X = { _backpedal: _, anyPunctuation: Ke, autolink: We, blockSkip: ve, br: le, code: Ce, del: _, delLDelim: _, delRDelim: _, emStrongLDelim: He, emStrongRDelimAst: Ge, emStrongRDelimUnd: Qe, escape: Ae, link: Ve, nolink: ke, punctuation: Be, reflink: he, reflinkSearch: Ye, tag: Je, text: Ie, url: _ };
var et = { ...X, link: d2(/^!?\[(label)\]\((.*?)\)/).replace("label", q).getRegex(), reflink: d2(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", q).getRegex() };
var N2 = { ...X, emStrongRDelimAst: Ne, emStrongLDelim: Ze, delLDelim: je, delRDelim: Ue, url: d2(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("protocol", se).replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(), _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, del: /^(~~?)(?=[^\s~])((?:\\[\s\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/, text: d2(/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|protocol:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/).replace("protocol", se).getRegex() };
var tt = { ...N2, br: d2(le).replace("{2,}", "*").getRegex(), text: d2(N2.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex() };
var B = { normal: K, gfm: ze, pedantic: Ee };
var A = { normal: X, gfm: N2, breaks: tt, pedantic: et };
var nt = { "&": "&", "<": "<", ">": ">", '"': """, "'": "'" };
var de = (l4) => nt[l4];
function O(l4, e2) {
if (e2) {
if (m2.escapeTest.test(l4)) return l4.replace(m2.escapeReplace, de);
} else if (m2.escapeTestNoEncode.test(l4)) return l4.replace(m2.escapeReplaceNoEncode, de);
return l4;
}
function J(l4) {
try {
l4 = encodeURI(l4).replace(m2.percentDecode, "%");
} catch {
return null;
}
return l4;
}
function V(l4, e2) {
let t3 = l4.replace(m2.findPipe, (r2, i2, o3) => {
let u2 = false, a2 = i2;
for (; --a2 >= 0 && o3[a2] === "\\"; ) u2 = !u2;
return u2 ? "|" : " |";
}), n2 = t3.split(m2.splitPipe), s2 = 0;
if (n2[0].trim() || n2.shift(), n2.length > 0 && !n2.at(-1)?.trim() && n2.pop(), e2) if (n2.length > e2) n2.splice(e2);
else for (; n2.length < e2; ) n2.push("");
for (; s2 < n2.length; s2++) n2[s2] = n2[s2].trim().replace(m2.slashPipe, "|");
return n2;
}
function $2(l4, e2, t3) {
let n2 = l4.length;
if (n2 === 0) return "";
let s2 = 0;
for (; s2 < n2; ) {
let r2 = l4.charAt(n2 - s2 - 1);
if (r2 === e2 && !t3) s2++;
else if (r2 !== e2 && t3) s2++;
else break;
}
return l4.slice(0, n2 - s2);
}
function Y(l4) {
let e2 = l4.split(`
`), t3 = e2.length - 1;
for (; t3 >= 0 && m2.blankLine.test(e2[t3]); ) t3--;
return e2.length - t3 <= 2 ? l4 : e2.slice(0, t3 + 1).join(`
`);
}
function ge(l4, e2) {
if (l4.indexOf(e2[1]) === -1) return -1;
let t3 = 0;
for (let n2 = 0; n2 < l4.length; n2++) if (l4[n2] === "\\") n2++;
else if (l4[n2] === e2[0]) t3++;
else if (l4[n2] === e2[1] && (t3--, t3 < 0)) return n2;
return t3 > 0 ? -2 : -1;
}
function fe(l4, e2 = 0) {
let t3 = e2, n2 = "";
for (let s2 of l4) if (s2 === " ") {
let r2 = 4 - t3 % 4;
n2 += " ".repeat(r2), t3 += r2;
} else n2 += s2, t3++;
return n2;
}
function me(l4, e2, t3, n2, s2) {
let r2 = e2.href, i2 = e2.title || null, o3 = l4[1].replace(s2.other.outputLinkReplace, "$1");
n2.state.inLink = true;
let u2 = { type: l4[0].charAt(0) === "!" ? "image" : "link", raw: t3, href: r2, title: i2, text: o3, tokens: n2.inlineTokens(o3) };
return n2.state.inLink = false, u2;
}
function rt(l4, e2, t3) {
let n2 = l4.match(t3.other.indentCodeCompensation);
if (n2 === null) return e2;
let s2 = n2[1];
return e2.split(`
`).map((r2) => {
let i2 = r2.match(t3.other.beginningSpace);
if (i2 === null) return r2;
let [o3] = i2;
return o3.length >= s2.length ? r2.slice(s2.length) : r2;
}).join(`
`);
}
var w2 = class {
options;
rules;
lexer;
constructor(e2) {
this.options = e2 || T;
}
space(e2) {
let t3 = this.rules.block.newline.exec(e2);
if (t3 && t3[0].length > 0) return { type: "space", raw: t3[0] };
}
code(e2) {
let t3 = this.rules.block.code.exec(e2);
if (t3) {
let n2 = this.options.pedantic ? t3[0] : Y(t3[0]), s2 = n2.replace(this.rules.other.codeRemoveIndent, "");
return { type: "code", raw: n2, codeBlockStyle: "indented", text: s2 };
}
}
fences(e2) {
let t3 = this.rules.block.fences.exec(e2);
if (t3) {
let n2 = t3[0], s2 = rt(n2, t3[3] || "", this.rules);
return { type: "code", raw: n2, lang: t3[2] ? t3[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : t3[2], text: s2 };
}
}
heading(e2) {
let t3 = this.rules.block.heading.exec(e2);
if (t3) {
let n2 = t3[2].trim();
if (this.rules.other.endingHash.test(n2)) {
let s2 = $2(n2, "#");
(this.options.pedantic || !s2 || this.rules.other.endingSpaceChar.test(s2)) && (n2 = s2.trim());
}
return { type: "heading", raw: $2(t3[0], `
`), depth: t3[1].length, text: n2, tokens: this.lexer.inline(n2) };
}
}
hr(e2) {
let t3 = this.rules.block.hr.exec(e2);
if (t3) return { type: "hr", raw: $2(t3[0], `
`) };
}
blockquote(e2) {
let t3 = this.rules.block.blockquote.exec(e2);
if (t3) {
let n2 = $2(t3[0], `
`).split(`
`), s2 = "", r2 = "", i2 = [];
for (; n2.length > 0; ) {
let o3 = false, u2 = [], a2;
for (a2 = 0; a2 < n2.length; a2++) if (this.rules.other.blockquoteStart.test(n2[a2])) u2.push(n2[a2]), o3 = true;
else if (!o3) u2.push(n2[a2]);
else break;
n2 = n2.slice(a2);
let c2 = u2.join(`
`), p2 = c2.replace(this.rules.other.blockquoteSetextReplace, `
$1`).replace(this.rules.other.blockquoteSetextReplace2, "");
s2 = s2 ? `${s2}
${c2}` : c2, r2 = r2 ? `${r2}
${p2}` : p2;
let k2 = this.lexer.state.top;
if (this.lexer.state.top = true, this.lexer.blockTokens(p2, i2, true), this.lexer.state.top = k2, n2.length === 0) break;
let h2 = i2.at(-1);
if (h2?.type === "code") break;
if (h2?.type === "blockquote") {
let R = h2, f2 = R.raw + `
` + n2.join(`
`), S2 = this.blockquote(f2);
i2[i2.length - 1] = S2, s2 = s2.substring(0, s2.length - R.raw.length) + S2.raw, r2 = r2.substring(0, r2.length - R.text.length) + S2.text;
break;
} else if (h2?.type === "list") {
let R = h2, f2 = R.raw + `
` + n2.join(`
`), S2 = this.list(f2);
i2[i2.length - 1] = S2, s2 = s2.substring(0, s2.length - h2.raw.length) + S2.raw, r2 = r2.substring(0, r2.length - R.raw.length) + S2.raw, n2 = f2.substring(i2.at(-1).raw.length).split(`
`);
continue;
}
}
return { type: "blockquote", raw: s2, tokens: i2, text: r2 };
}
}
list(e2) {
let t3 = this.rules.block.list.exec(e2);
if (t3) {
let n2 = t3[1].trim(), s2 = n2.length > 1, r2 = { type: "list", raw: "", ordered: s2, start: s2 ? +n2.slice(0, -1) : "", loose: false, items: [] };
n2 = s2 ? `\\d{1,9}\\${n2.slice(-1)}` : `\\${n2}`, this.options.pedantic && (n2 = s2 ? n2 : "[*+-]");
let i2 = this.rules.other.listItemRegex(n2), o3 = false;
for (; e2; ) {
let a2 = false, c2 = "", p2 = "";
if (!(t3 = i2.exec(e2)) || this.rules.block.hr.test(e2)) break;
c2 = t3[0], e2 = e2.substring(c2.length);
let k2 = fe(t3[2].split(`
`, 1)[0], t3[1].length), h2 = e2.split(`
`, 1)[0], R = !k2.trim(), f2 = 0;
if (this.options.pedantic ? (f2 = 2, p2 = k2.trimStart()) : R ? f2 = t3[1].length + 1 : (f2 = k2.search(this.rules.other.nonSpaceChar), f2 = f2 > 4 ? 1 : f2, p2 = k2.slice(f2), f2 += t3[1].length), R && this.rules.other.blankLine.test(h2) && (c2 += h2 + `
`, e2 = e2.substring(h2.length + 1), a2 = true), !a2) {
let S2 = this.rules.other.nextBulletRegex(f2), ee = this.rules.other.hrRegex(f2), te = this.rules.other.fencesBeginRegex(f2), ne = this.rules.other.headingBeginRegex(f2), xe = this.rules.other.htmlBeginRegex(f2), be = this.rules.other.blockquoteBeginRegex(f2);
for (; e2; ) {
let Z = e2.split(`
`, 1)[0], C;
if (h2 = Z, this.options.pedantic ? (h2 = h2.replace(this.rules.other.listReplaceNesting, " "), C = h2) : C = h2.replace(this.rules.other.tabCharGlobal, " "), te.test(h2) || ne.test(h2) || xe.test(h2) || be.test(h2) || S2.test(h2) || ee.test(h2)) break;
if (C.search(this.rules.other.nonSpaceChar) >= f2 || !h2.trim()) p2 += `
` + C.slice(f2);
else {
if (R || k2.replace(this.rules.other.tabCharGlobal, " ").search(this.rules.other.nonSpaceChar) >= 4 || te.test(k2) || ne.test(k2) || ee.test(k2)) break;
p2 += `
` + h2;
}
R = !h2.trim(), c2 += Z + `
`, e2 = e2.substring(Z.length + 1), k2 = C.slice(f2);
}
}
r2.loose || (o3 ? r2.loose = true : this.rules.other.doubleBlankLine.test(c2) && (o3 = true)), r2.items.push({ type: "list_item", raw: c2, task: !!this.options.gfm && this.rules.other.listIsTask.test(p2), loose: false, text: p2, tokens: [] }), r2.raw += c2;
}
let u2 = r2.items.at(-1);
if (u2) u2.raw = u2.raw.trimEnd(), u2.text = u2.text.trimEnd();
else return;
r2.raw = r2.raw.trimEnd();
for (let a2 of r2.items) {
this.lexer.state.top = false, a2.tokens = this.lexer.blockTokens(a2.text, []);
let c2 = a2.tokens[0];
if (a2.task && (c2?.type === "text" || c2?.type === "paragraph")) {
a2.text = a2.text.replace(this.rules.other.listReplaceTask, ""), c2.raw = c2.raw.replace(this.rules.other.listReplaceTask, ""), c2.text = c2.text.replace(this.rules.other.listReplaceTask, "");
for (let k2 = this.lexer.inlineQueue.length - 1; k2 >= 0; k2--) if (this.rules.other.listIsTask.test(this.lexer.inlineQueue[k2].src)) {
this.lexer.inlineQueue[k2].src = this.lexer.inlineQueue[k2].src.replace(this.rules.other.listReplaceTask, "");
break;
}
let p2 = this.rules.other.listTaskCheckbox.exec(a2.raw);
if (p2) {
let k2 = { type: "checkbox", raw: p2[0] + " ", checked: p2[0] !== "[ ]" };
a2.checked = k2.checked, r2.loose ? a2.tokens[0] && ["paragraph", "text"].includes(a2.tokens[0].type) && "tokens" in a2.tokens[0] && a2.tokens[0].tokens ? (a2.tokens[0].raw = k2.raw + a2.tokens[0].raw, a2.tokens[0].text = k2.raw + a2.tokens[0].text, a2.tokens[0].tokens.unshift(k2)) : a2.tokens.unshift({ type: "paragraph", raw: k2.raw, text: k2.raw, tokens: [k2] }) : a2.tokens.unshift(k2);
}
} else a2.task && (a2.task = false);
if (!r2.loose) {
let p2 = a2.tokens.filter((h2) => h2.type === "space"), k2 = p2.length > 0 && p2.some((h2) => this.rules.other.anyLine.test(h2.raw));
r2.loose = k2;
}
}
if (r2.loose) for (let a2 of r2.items) {
a2.loose = true;
for (let c2 of a2.tokens) c2.type === "text" && (c2.type = "paragraph");
}
return r2;
}
}
html(e2) {
let t3 = this.rules.block.html.exec(e2);
if (t3) {
let n2 = Y(t3[0]);
return { type: "html", block: true, raw: n2, pre: t3[1] === "pre" || t3[1] === "script" || t3[1] === "style", text: n2 };
}
}
def(e2) {
let t3 = this.rules.block.def.exec(e2);
if (t3) {
let n2 = t3[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " "), s2 = t3[2] ? t3[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", r2 = t3[3] ? t3[3].substring(1, t3[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : t3[3];
return { type: "def", tag: n2, raw: $2(t3[0], `
`), href: s2, title: r2 };
}
}
table(e2) {
let t3 = this.rules.block.table.exec(e2);
if (!t3 || !this.rules.other.tableDelimiter.test(t3[2])) return;
let n2 = V(t3[1]), s2 = t3[2].replace(this.rules.other.tableAlignChars, "").split("|"), r2 = t3[3]?.trim() ? t3[3].replace(this.rules.other.tableRowBlankLine, "").split(`
`) : [], i2 = { type: "table", raw: $2(t3[0], `
`), header: [], align: [], rows: [] };
if (n2.length === s2.length) {
for (let o3 of s2) this.rules.other.tableAlignRight.test(o3) ? i2.align.push("right") : this.rules.other.tableAlignCenter.test(o3) ? i2.align.push("center") : this.rules.other.tableAlignLeft.test(o3) ? i2.align.push("left") : i2.align.push(null);
for (let o3 = 0; o3 < n2.length; o3++) i2.header.push({ text: n2[o3], tokens: this.lexer.inline(n2[o3]), header: true, align: i2.align[o3] });
for (let o3 of r2) i2.rows.push(V(o3, i2.header.length).map((u2, a2) => ({ text: u2, tokens: this.lexer.inline(u2), header: false, align: i2.align[a2] })));
return i2;
}
}
lheading(e2) {
let t3 = this.rules.block.lheading.exec(e2);
if (t3) {
let n2 = t3[1].trim();
return { type: "heading", raw: $2(t3[0], `
`), depth: t3[2].charAt(0) === "=" ? 1 : 2, text: n2, tokens: this.lexer.inline(n2) };
}
}
paragraph(e2) {
let t3 = this.rules.block.paragraph.exec(e2);
if (t3) {
let n2 = t3[1].charAt(t3[1].length - 1) === `
` ? t3[1].slice(0, -1) : t3[1];
return { type: "paragraph", raw: t3[0], text: n2, tokens: this.lexer.inline(n2) };
}
}
text(e2) {
let t3 = this.rules.block.text.exec(e2);
if (t3) return { type: "text", raw: t3[0], text: t3[0], tokens: this.lexer.inline(t3[0]) };
}
escape(e2) {
let t3 = this.rules.inline.escape.exec(e2);
if (t3) return { type: "escape", raw: t3[0], text: t3[1] };
}
tag(e2) {
let t3 = this.rules.inline.tag.exec(e2);
if (t3) return !this.lexer.state.inLink && this.rules.other.startATag.test(t3[0]) ? this.lexer.state.inLink = true : this.lexer.state.inLink && this.rules.other.endATag.test(t3[0]) && (this.lexer.state.inLink = false), !this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(t3[0]) ? this.lexer.state.inRawBlock = true : this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(t3[0]) && (this.lexer.state.inRawBlock = false), { type: "html", raw: t3[0], inLink: this.lexer.state.inLink, inRawBlock: this.lexer.state.inRawBlock, block: false, text: t3[0] };
}
link(e2) {
let t3 = this.rules.inline.link.exec(e2);
if (t3) {
let n2 = t3[2].trim();
if (!this.options.pedantic && this.rules.other.startAngleBracket.test(n2)) {
if (!this.rules.other.endAngleBracket.test(n2)) return;
let i2 = $2(n2.slice(0, -1), "\\");
if ((n2.length - i2.length) % 2 === 0) return;
} else {
let i2 = ge(t3[2], "()");
if (i2 === -2) return;
if (i2 > -1) {
let u2 = (t3[0].indexOf("!") === 0 ? 5 : 4) + t3[1].length + i2;
t3[2] = t3[2].substring(0, i2), t3[0] = t3[0].substring(0, u2).trim(), t3[3] = "";
}
}
let s2 = t3[2], r2 = "";
if (this.options.pedantic) {
let i2 = this.rules.other.pedanticHrefTitle.exec(s2);
i2 && (s2 = i2[1], r2 = i2[3]);
} else r2 = t3[3] ? t3[3].slice(1, -1) : "";
return s2 = s2.trim(), this.rules.other.startAngleBracket.test(s2) && (this.options.pedantic && !this.rules.other.endAngleBracket.test(n2) ? s2 = s2.slice(1) : s2 = s2.slice(1, -1)), me(t3, { href: s2 && s2.replace(this.rules.inline.anyPunctuation, "$1"), title: r2 && r2.replace(this.rules.inline.anyPunctuation, "$1") }, t3[0], this.lexer, this.rules);
}
}
reflink(e2, t3) {
let n2;
if ((n2 = this.rules.inline.reflink.exec(e2)) || (n2 = this.rules.inline.nolink.exec(e2))) {
let s2 = (n2[2] || n2[1]).replace(this.rules.other.multipleSpaceGlobal, " "), r2 = t3[s2.toLowerCase()];
if (!r2) {
let i2 = n2[0].charAt(0);
return { type: "text", raw: i2, text: i2 };
}
return me(n2, r2, n2[0], this.lexer, this.rules);
}
}
emStrong(e2, t3, n2 = "") {
let s2 = this.rules.inline.emStrongLDelim.exec(e2);
if (!s2 || !s2[1] && !s2[2] && !s2[3] && !s2[4] || s2[4] && n2.match(this.rules.other.unicodeAlphaNumeric)) return;
if (!(s2[1] || s2[3] || "") || !n2 || this.rules.inline.punctuation.exec(n2)) {
let i2 = [...s2[0]].length - 1, o3, u2, a2 = i2, c2 = 0, p2 = s2[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
for (p2.lastIndex = 0, t3 = t3.slice(-1 * e2.length + i2); (s2 = p2.exec(t3)) !== null; ) {
if (o3 = s2[1] || s2[2] || s2[3] || s2[4] || s2[5] || s2[6], !o3) continue;
if (u2 = [...o3].length, s2[3] || s2[4]) {
a2 += u2;
continue;
} else if ((s2[5] || s2[6]) && i2 % 3 && !((i2 + u2) % 3)) {
c2 += u2;
continue;
}
if (a2 -= u2, a2 > 0) continue;
u2 = Math.min(u2, u2 + a2 + c2);
let k2 = [...s2[0]][0].length, h2 = e2.slice(0, i2 + s2.index + k2 + u2);
if (Math.min(i2, u2) % 2) {
let f2 = h2.slice(1, -1);
return { type: "em", raw: h2, text: f2, tokens: this.lexer.inlineTokens(f2) };
}
let R = h2.slice(2, -2);
return { type: "strong", raw: h2, text: R, tokens: this.lexer.inlineTokens(R) };
}
}
}
codespan(e2) {
let t3 = this.rules.inline.code.exec(e2);
if (t3) {
let n2 = t3[2].replace(this.rules.other.newLineCharGlobal, " "), s2 = this.rules.other.nonSpaceChar.test(n2), r2 = this.rules.other.startingSpaceChar.test(n2) && this.rules.other.endingSpaceChar.test(n2);
return s2 && r2 && (n2 = n2.substring(1, n2.length - 1)), { type: "codespan", raw: t3[0], text: n2 };
}
}
br(e2) {
let t3 = this.rules.inline.br.exec(e2);
if (t3) return { type: "br", raw: t3[0] };
}
del(e2, t3, n2 = "") {
let s2 = this.rules.inline.delLDelim.exec(e2);
if (!s2) return;
if (!(s2[1] || "") || !n2 || this.rules.inline.punctuation.exec(n2)) {
let i2 = [...s2[0]].length - 1, o3, u2, a2 = i2, c2 = this.rules.inline.delRDelim;
for (c2.lastIndex = 0, t3 = t3.slice(-1 * e2.length + i2); (s2 = c2.exec(t3)) !== null; ) {
if (o3 = s2[1] || s2[2] || s2[3] || s2[4] || s2[5] || s2[6], !o3 || (u2 = [...o3].length, u2 !== i2)) continue;
if (s2[3] || s2[4]) {
a2 += u2;
continue;
}
if (a2 -= u2, a2 > 0) continue;
u2 = Math.min(u2, u2 + a2);
let p2 = [...s2[0]][0].length, k2 = e2.slice(0, i2 + s2.index + p2 + u2), h2 = k2.slice(i2, -i2);
return { type: "del", raw: k2, text: h2, tokens: this.lexer.inlineTokens(h2) };
}
}
}
autolink(e2) {
let t3 = this.rules.inline.autolink.exec(e2);
if (t3) {
let n2, s2;
return t3[2] === "@" ? (n2 = t3[1], s2 = "mailto:" + n2) : (n2 = t3[1], s2 = n2), { type: "link", raw: t3[0], text: n2, href: s2, tokens: [{ type: "text", raw: n2, text: n2 }] };
}
}
url(e2) {
let t3;
if (t3 = this.rules.inline.url.exec(e2)) {
let n2, s2;
if (t3[2] === "@") n2 = t3[0], s2 = "mailto:" + n2;
else {
let r2;
do
r2 = t3[0], t3[0] = this.rules.inline._backpedal.exec(t3[0])?.[0] ?? "";
while (r2 !== t3[0]);
n2 = t3[0], t3[1] === "www." ? s2 = "http://" + t3[0] : s2 = t3[0];
}
return { type: "link", raw: t3[0], text: n2, href: s2, tokens: [{ type: "text", raw: n2, text: n2 }] };
}
}
inlineText(e2) {
let t3 = this.rules.inline.text.exec(e2);
if (t3) {
let n2 = this.lexer.state.inRawBlock;
return { type: "text", raw: t3[0], text: t3[0], escaped: n2 };
}
}
};
var x2 = class l2 {
tokens;
options;
state;
inlineQueue;
tokenizer;
constructor(e2) {
this.tokens = [], this.tokens.links = /* @__PURE__ */ Object.create(null), this.options = e2 || T, this.options.tokenizer = this.options.tokenizer || new w2(), this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = { inLink: false, inRawBlock: false, top: true };
let t3 = { other: m2, block: B.normal, inline: A.normal };
this.options.pedantic ? (t3.block = B.pedantic, t3.inline = A.pedantic) : this.options.gfm && (t3.block = B.gfm, this.options.breaks ? t3.inline = A.breaks : t3.inline = A.gfm), this.tokenizer.rules = t3;
}
static get rules() {
return { block: B, inline: A };
}
static lex(e2, t3) {
return new l2(t3).lex(e2);
}
static lexInline(e2, t3) {
return new l2(t3).inlineTokens(e2);
}
lex(e2) {
e2 = e2.replace(m2.carriageReturn, `
`), this.blockTokens(e2, this.tokens);
for (let t3 = 0; t3 < this.inlineQueue.length; t3++) {
let n2 = this.inlineQueue[t3];
this.inlineTokens(n2.src, n2.tokens);
}
return this.inlineQueue = [], this.tokens;
}
blockTokens(e2, t3 = [], n2 = false) {
this.tokenizer.lexer = this, this.options.pedantic && (e2 = e2.replace(m2.tabCharGlobal, " ").replace(m2.spaceLine, ""));
let s2 = 1 / 0;
for (; e2; ) {
if (e2.length < s2) s2 = e2.length;
else {
this.infiniteLoopError(e2.charCodeAt(0));
break;
}
let r2;
if (this.options.extensions?.block?.some((o3) => (r2 = o3.call({ lexer: this }, e2, t3)) ? (e2 = e2.substring(r2.raw.length), t3.push(r2), true) : false)) continue;
if (r2 = this.tokenizer.space(e2)) {
e2 = e2.substring(r2.raw.length);
let o3 = t3.at(-1);
r2.raw.length === 1 && o3 !== void 0 ? o3.raw += `
` : t3.push(r2);
continue;
}
if (r2 = this.tokenizer.code(e2)) {
e2 = e2.substring(r2.raw.length);
let o3 = t3.at(-1);
o3?.type === "paragraph" || o3?.type === "text" ? (o3.raw += (o3.raw.endsWith(`
`) ? "" : `
`) + r2.raw, o3.text += `
` + r2.text, this.inlineQueue.at(-1).src = o3.text) : t3.push(r2);
continue;
}
if (r2 = this.tokenizer.fences(e2)) {
e2 = e2.substring(r2.raw.length), t3.push(r2);
continue;
}
if (r2 = this.tokenizer.heading(e2)) {
e2 = e2.substring(r2.raw.length), t3.push(r2);
continue;
}
if (r2 = this.tokenizer.hr(e2)) {
e2 = e2.substring(r2.raw.length), t3.push(r2);
continue;
}
if (r2 = this.tokenizer.blockquote(e2)) {
e2 = e2.substring(r2.raw.length), t3.push(r2);
continue;
}
if (r2 = this.tokenizer.list(e2)) {
e2 = e2.substring(r2.raw.length), t3.push(r2);
continue;
}
if (r2 = this.tokenizer.html(e2)) {
e2 = e2.substring(r2.raw.length), t3.push(r2);
continue;
}
if (r2 = this.tokenizer.def(e2)) {
e2 = e2.substring(r2.raw.length);
let o3 = t3.at(-1);
o3?.type === "paragraph" || o3?.type === "text" ? (o3.raw += (o3.raw.endsWith(`
`) ? "" : `
`) + r2.raw, o3.text += `
` + r2.raw, this.inlineQueue.at(-1).src = o3.text) : this.tokens.links[r2.tag] || (this.tokens.links[r2.tag] = { href: r2.href, title: r2.title }, t3.push(r2));
continue;
}
if (r2 = this.tokenizer.table(e2)) {
e2 = e2.substring(r2.raw.length), t3.push(r2);
continue;
}
if (r2 = this.tokenizer.lheading(e2)) {
e2 = e2.substring(r2.raw.length), t3.push(r2);
continue;
}
let i2 = e2;
if (this.options.extensions?.startBlock) {
let o3 = 1 / 0, u2 = e2.slice(1), a2;
this.options.extensions.startBlock.forEach((c2) => {
a2 = c2.call({ lexer: this }, u2), typeof a2 == "number" && a2 >= 0 && (o3 = Math.min(o3, a2));
}), o3 < 1 / 0 && o3 >= 0 && (i2 = e2.substring(0, o3 + 1));
}
if (this.state.top && (r2 = this.tokenizer.paragraph(i2))) {
let o3 = t3.at(-1);
n2 && o3?.type === "paragraph" ? (o3.raw += (o3.raw.endsWith(`
`) ? "" : `
`) + r2.raw, o3.text += `
` + r2.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = o3.text) : t3.push(r2), n2 = i2.length !== e2.length, e2 = e2.substring(r2.raw.length);
continue;
}
if (r2 = this.tokenizer.text(e2)) {
e2 = e2.substring(r2.raw.length);
let o3 = t3.at(-1);
o3?.type === "text" ? (o3.raw += (o3.raw.endsWith(`
`) ? "" : `
`) + r2.raw, o3.text += `
` + r2.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = o3.text) : t3.push(r2);
continue;
}
if (e2) {
this.infiniteLoopError(e2.charCodeAt(0));
break;
}
}
return this.state.top = true, t3;
}
inline(e2, t3 = []) {
return this.inlineQueue.push({ src: e2, tokens: t3 }), t3;
}
inlineTokens(e2, t3 = []) {
this.tokenizer.lexer = this;
let n2 = e2, s2 = null;
if (this.tokens.links) {
let a2 = Object.keys(this.tokens.links);
if (a2.length > 0) for (; (s2 = this.tokenizer.rules.inline.reflinkSearch.exec(n2)) !== null; ) a2.includes(s2[0].slice(s2[0].lastIndexOf("[") + 1, -1)) && (n2 = n2.slice(0, s2.index) + "[" + "a".repeat(s2[0].length - 2) + "]" + n2.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex));
}
for (; (s2 = this.tokenizer.rules.inline.anyPunctuation.exec(n2)) !== null; ) n2 = n2.slice(0, s2.index) + "++" + n2.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
let r2;
for (; (s2 = this.tokenizer.rules.inline.blockSkip.exec(n2)) !== null; ) r2 = s2[2] ? s2[2].length : 0, n2 = n2.slice(0, s2.index + r2) + "[" + "a".repeat(s2[0].length - r2 - 2) + "]" + n2.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
n2 = this.options.hooks?.emStrongMask?.call({ lexer: this }, n2) ?? n2;
let i2 = false, o3 = "", u2 = 1 / 0;
for (; e2; ) {
if (e2.length < u2) u2 = e2.length;
else {
this.infiniteLoopError(e2.charCodeAt(0));
break;
}
i2 || (o3 = ""), i2 = false;
let a2;
if (this.options.extensions?.inline?.some((p2) => (a2 = p2.call({ lexer: this }, e2, t3)) ? (e2 = e2.substring(a2.raw.length), t3.push(a2), true) : false)) continue;
if (a2 = this.tokenizer.escape(e2)) {
e2 = e2.substring(a2.raw.length), t3.push(a2);
continue;
}
if (a2 = this.tokenizer.tag(e2)) {
e2 = e2.substring(a2.raw.length), t3.push(a2);
continue;
}
if (a2 = this.tokenizer.link(e2)) {
e2 = e2.substring(a2.raw.length), t3.push(a2);
continue;
}
if (a2 = this.tokenizer.reflink(e2, this.tokens.links)) {
e2 = e2.substring(a2.raw.length);
let p2 = t3.at(-1);
a2.type === "text" && p2?.type === "text" ? (p2.raw += a2.raw, p2.text += a2.text) : t3.push(a2);
continue;
}
if (a2 = this.tokenizer.emStrong(e2, n2, o3)) {
e2 = e2.substring(a2.raw.length), t3.push(a2);
continue;
}
if (a2 = this.tokenizer.codespan(e2)) {
e2 = e2.substring(a2.raw.length), t3.push(a2);
continue;
}
if (a2 = this.tokenizer.br(e2)) {
e2 = e2.substring(a2.raw.length), t3.push(a2);
continue;
}
if (a2 = this.tokenizer.del(e2, n2, o3)) {
e2 = e2.substring(a2.raw.length), t3.push(a2);
continue;
}
if (a2 = this.tokenizer.autolink(e2)) {
e2 = e2.substring(a2.raw.length), t3.push(a2);
continue;
}
if (!this.state.inLink && (a2 = this.tokenizer.url(e2))) {
e2 = e2.substring(a2.raw.length), t3.push(a2);
continue;
}
let c2 = e2;
if (this.options.extensions?.startInline) {
let p2 = 1 / 0, k2 = e2.slice(1), h2;
this.options.extensions.startInline.forEach((R) => {
h2 = R.call({ lexer: this }, k2), typeof h2 == "number" && h2 >= 0 && (p2 = Math.min(p2, h2));
}), p2 < 1 / 0 && p2 >= 0 && (c2 = e2.substring(0, p2 + 1));
}
if (a2 = this.tokenizer.inlineText(c2)) {
e2 = e2.substring(a2.raw.length), a2.raw.slice(-1) !== "_" && (o3 = a2.raw.slice(-1)), i2 = true;
let p2 = t3.at(-1);
p2?.type === "text" ? (p2.raw += a2.raw, p2.text += a2.text) : t3.push(a2);
continue;
}
if (e2) {
this.infiniteLoopError(e2.charCodeAt(0));
break;
}
}
return t3;
}
infiniteLoopError(e2) {
let t3 = "Infinite loop on byte: " + e2;
if (this.options.silent) console.error(t3);
else throw new Error(t3);
}
};
var y2 = class {
options;
parser;
constructor(e2) {
this.options = e2 || T;
}
space(e2) {
return "";
}
code({ text: e2, lang: t3, escaped: n2 }) {
let s2 = (t3 || "").match(m2.notSpaceStart)?.[0], r2 = e2.replace(m2.endingNewline, "") + `
`;
return s2 ? '<pre><code class="language-' + O(s2) + '">' + (n2 ? r2 : O(r2, true)) + `</code></pre>
` : "<pre><code>" + (n2 ? r2 : O(r2, true)) + `</code></pre>
`;
}
blockquote({ tokens: e2 }) {
return `<blockquote>
${this.parser.parse(e2)}</blockquote>
`;
}
html({ text: e2 }) {
return e2;
}
def(e2) {
return "";
}
heading({ tokens: e2, depth: t3 }) {
return `<h${t3}>${this.parser.parseInline(e2)}</h${t3}>
`;
}
hr(e2) {
return `<hr>
`;
}
list(e2) {
let t3 = e2.ordered, n2 = e2.start, s2 = "";
for (let o3 = 0; o3 < e2.items.length; o3++) {
let u2 = e2.items[o3];
s2 += this.listitem(u2);
}
let r2 = t3 ? "ol" : "ul", i2 = t3 && n2 !== 1 ? ' start="' + n2 + '"' : "";
return "<" + r2 + i2 + `>
` + s2 + "</" + r2 + `>
`;
}
listitem(e2) {
return `<li>${this.parser.parse(e2.tokens)}</li>
`;
}
checkbox({ checked: e2 }) {
return "<input " + (e2 ? 'checked="" ' : "") + 'disabled="" type="checkbox"> ';
}
paragraph({ tokens: e2 }) {
return `<p>${this.parser.parseInline(e2)}</p>
`;
}
table(e2) {
let t3 = "", n2 = "";
for (let r2 = 0; r2 < e2.header.length; r2++) n2 += this.tablecell(e2.header[r2]);
t3 += this.tablerow({ text: n2 });
let s2 = "";
for (let r2 = 0; r2 < e2.rows.length; r2++) {
let i2 = e2.rows[r2];
n2 = "";
for (let o3 = 0; o3 < i2.length; o3++) n2 += this.tablecell(i2[o3]);
s2 += this.tablerow({ text: n2 });
}
return s2 && (s2 = `<tbody>${s2}</tbody>`), `<table>
<thead>
` + t3 + `</thead>
` + s2 + `</table>
`;
}
tablerow({ text: e2 }) {
return `<tr>
${e2}</tr>
`;
}
tablecell(e2) {
let t3 = this.parser.parseInline(e2.tokens), n2 = e2.header ? "th" : "td";
return (e2.align ? `<${n2} align="${e2.align}">` : `<${n2}>`) + t3 + `</${n2}>
`;
}
strong({ tokens: e2 }) {
return `<strong>${this.parser.parseInline(e2)}</strong>`;
}
em({ tokens: e2 }) {
return `<em>${this.parser.parseInline(e2)}</em>`;
}
codespan({ text: e2 }) {
return `<code>${O(e2, true)}</code>`;
}
br(e2) {
return "<br>";
}
del({ tokens: e2 }) {
return `<del>${this.parser.parseInline(e2)}</del>`;
}
link({ href: e2, title: t3, tokens: n2 }) {
let s2 = this.parser.parseInline(n2), r2 = J(e2);
if (r2 === null) return s2;
e2 = r2;
let i2 = '<a href="' + e2 + '"';
return t3 && (i2 += ' title="' + O(t3) + '"'), i2 += ">" + s2 + "</a>", i2;
}
image({ href: e2, title: t3, text: n2, tokens: s2 }) {
s2 && (n2 = this.parser.parseInline(s2, this.parser.textRenderer));
let r2 = J(e2);
if (r2 === null) return O(n2);
e2 = r2;
let i2 = `<img src="${e2}" alt="${O(n2)}"`;
return t3 && (i2 += ` title="${O(t3)}"`), i2 += ">", i2;
}
text(e2) {
return "tokens" in e2 && e2.tokens ? this.parser.parseInline(e2.tokens) : "escaped" in e2 && e2.escaped ? e2.text : O(e2.text);
}
};
var L = class {
strong({ text: e2 }) {
return e2;
}
em({ text: e2 }) {
return e2;
}
codespan({ text: e2 }) {
return e2;
}
del({ text: e2 }) {
return e2;
}
html({ text: e2 }) {
return e2;
}
text({ text: e2 }) {
return e2;
}
link({ text: e2 }) {
return "" + e2;
}
image({ text: e2 }) {
return "" + e2;
}
br() {
return "";
}
checkbox({ raw: e2 }) {
return e2;
}
};
var b2 = class l3 {
options;
renderer;
textRenderer;
constructor(e2) {
this.options = e2 || T, this.options.renderer = this.options.renderer || new y2(), this.renderer = this.options.renderer, this.renderer.options = this.options, this.renderer.parser = this, this.textRenderer = new L();
}
static parse(e2, t3) {
return new l3(t3).parse(e2);
}
static parseInline(e2, t3) {
return new l3(t3).parseInline(e2);
}
parse(e2) {
this.renderer.parser = this;
let t3 = "";
for (let n2 = 0; n2 < e2.length; n2++) {
let s2 = e2[n2];
if (this.options.extensions?.renderers?.[s2.type]) {
let i2 = s2, o3 = this.options.extensions.renderers[i2.type].call({ parser: this }, i2);
if (o3 !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "def", "paragraph", "text"].includes(i2.type)) {
t3 += o3 || "";
continue;
}
}
let r2 = s2;
switch (r2.type) {
case "space": {
t3 += this.renderer.space(r2);
break;
}
case "hr": {
t3 += this.renderer.hr(r2);
break;
}
case "heading": {
t3 += this.renderer.heading(r2);
break;
}
case "code": {
t3 += this.renderer.code(r2);
break;
}
case "table": {
t3 += this.renderer.table(r2);
break;
}
case "blockquote": {
t3 += this.renderer.blockquote(r2);
break;
}
case "list": {
t3 += this.renderer.list(r2);
break;
}
case "checkbox": {
t3 += this.renderer.checkbox(r2);
break;
}
case "html": {
t3 += this.renderer.html(r2);
break;
}
case "def": {
t3 += this.renderer.def(r2);
break;
}
case "paragraph": {
t3 += this.renderer.paragraph(r2);
break;
}
case "text": {
t3 += this.renderer.text(r2);
break;
}
default: {
let i2 = 'Token with "' + r2.type + '" type was not found.';
if (this.options.silent) return console.error(i2), "";
throw new Error(i2);
}
}
}
return t3;
}
parseInline(e2, t3 = this.renderer) {
this.renderer.parser = this;
let n2 = "";
for (let s2 = 0; s2 < e2.length; s2++) {
let r2 = e2[s2];
if (this.options.extensions?.renderers?.[r2.type]) {
let o3 = this.options.extensions.renderers[r2.type].call({ parser: this }, r2);
if (o3 !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(r2.type)) {
n2 += o3 || "";
continue;
}
}
let i2 = r2;
switch (i2.type) {
case "escape": {
n2 += t3.text(i2);
break;
}
case "html": {
n2 += t3.html(i2);
break;
}
case "link": {
n2 += t3.link(i2);
break;
}
case "image": {
n2 += t3.image(i2);
break;
}
case "checkbox": {
n2 += t3.checkbox(i2);
break;
}
case "strong": {
n2 += t3.strong(i2);
break;
}
case "em": {
n2 += t3.em(i2);
break;
}
case "codespan": {
n2 += t3.codespan(i2);
break;
}
case "br": {
n2 += t3.br(i2);
break;
}
case "del": {
n2 += t3.del(i2);
break;
}
case "text": {
n2 += t3.text(i2);
break;
}
default: {
let o3 = 'Token with "' + i2.type + '" type was not found.';
if (this.options.silent) return console.error(o3), "";
throw new Error(o3);
}
}
}
return n2;
}
};
var P = class {
options;
block;
constructor(e2) {
this.options = e2 || T;
}
static passThroughHooks = /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens", "emStrongMask"]);
static passThroughHooksRespectAsync = /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens"]);
preprocess(e2) {
return e2;
}
postprocess(e2) {
return e2;
}
processAllTokens(e2) {
return e2;
}
emStrongMask(e2) {
return e2;
}
provideLexer(e2 = this.block) {
return e2 ? x2.lex : x2.lexInline;
}
provideParser(e2 = this.block) {
return e2 ? b2.parse : b2.parseInline;
}
};
var D = class {
defaults = z();
options = this.setOptions;
parse = this.parseMarkdown(true);
parseInline = this.parseMarkdown(false);
Parser = b2;
Renderer = y2;
TextRenderer = L;
Lexer = x2;
Tokenizer = w2;
Hooks = P;
constructor(...e2) {
this.use(...e2);
}
walkTokens(e2, t3) {
let n2 = [];
for (let s2 of e2) switch (n2 = n2.concat(t3.call(this, s2)), s2.type) {
case "table": {
let r2 = s2;
for (let i2 of r2.header) n2 = n2.concat(this.walkTokens(i2.tokens, t3));
for (let i2 of r2.rows) for (let o3 of i2) n2 = n2.concat(this.walkTokens(o3.tokens, t3));
break;
}
case "list": {
let r2 = s2;
n2 = n2.concat(this.walkTokens(r2.items, t3));
break;
}
default: {
let r2 = s2;
this.defaults.extensions?.childTokens?.[r2.type] ? this.defaults.extensions.childTokens[r2.type].forEach((i2) => {
let o3 = r2[i2].flat(1 / 0);
n2 = n2.concat(this.walkTokens(o3, t3));
}) : r2.tokens && (n2 = n2.concat(this.walkTokens(r2.tokens, t3)));
}
}
return n2;
}
use(...e2) {
let t3 = this.defaults.extensions || { renderers: {}, childTokens: {} };
return e2.forEach((n2) => {
let s2 = { ...n2 };
if (s2.async = this.defaults.async || s2.async || false, n2.extensions && (n2.extensions.forEach((r2) => {
if (!r2.name) throw new Error("extension name required");
if ("renderer" in r2) {
let i2 = t3.renderers[r2.name];
i2 ? t3.renderers[r2.name] = function(...o3) {
let u2 = r2.renderer.apply(this, o3);
return u2 === false && (u2 = i2.apply(this, o3)), u2;
} : t3.renderers[r2.name] = r2.renderer;
}
if ("tokenizer" in r2) {
if (!r2.level || r2.level !== "block" && r2.level !== "inline") throw new Error("extension level must be 'block' or 'inline'");
let i2 = t3[r2.level];
i2 ? i2.unshift(r2.tokenizer) : t3[r2.level] = [r2.tokenizer], r2.start && (r2.level === "block" ? t3.startBlock ? t3.startBlock.push(r2.start) : t3.startBlock = [r2.start] : r2.level === "inline" && (t3.startInline ? t3.startInline.push(r2.start) : t3.startInline = [r2.start]));
}
"childTokens" in r2 && r2.childTokens && (t3.childTokens[r2.name] = r2.childTokens);
}), s2.extensions = t3), n2.renderer) {
let r2 = this.defaults.renderer || new y2(this.defaults);
for (let i2 in n2.renderer) {
if (!(i2 in r2)) throw new Error(`renderer '${i2}' does not exist`);
if (["options", "parser"].includes(i2)) continue;
let o3 = i2, u2 = n2.renderer[o3], a2 = r2[o3];
r2[o3] = (...c2) => {
let p2 = u2.apply(r2, c2);
return p2 === false && (p2 = a2.apply(r2, c2)), p2 || "";
};
}
s2.renderer = r2;
}
if (n2.tokenizer) {
let r2 = this.defaults.tokenizer || new w2(this.defaults);
for (let i2 in n2.tokenizer) {
if (!(i2 in r2)) throw new Error(`tokenizer '${i2}' does not exist`);
if (["options", "rules", "lexer"].includes(i2)) continue;
let o3 = i2, u2 = n2.tokenizer[o3], a2 = r2[o3];
r2[o3] = (...c2) => {
let p2 = u2.apply(r2, c2);
return p2 === false && (p2 = a2.apply(r2, c2)), p2;
};
}
s2.tokenizer = r2;
}
if (n2.hooks) {
let r2 = this.defaults.hooks || new P();
for (let i2 in n2.hooks) {
if (!(i2 in r2)) throw new Error(`hook '${i2}' does not exist`);
if (["options", "block"].includes(i2)) continue;
let o3 = i2, u2 = n2.hooks[o3], a2 = r2[o3];
P.passThroughHooks.has(i2) ? r2[o3] = (c2) => {
if (this.defaults.async && P.passThroughHooksRespectAsync.has(i2)) return (async () => {
let k2 = await u2.call(r2, c2);
return a2.call(r2, k2);
})();
let p2 = u2.call(r2, c2);
return a2.call(r2, p2);
} : r2[o3] = (...c2) => {
if (this.defaults.async) return (async () => {
let k2 = await u2.apply(r2, c2);
return k2 === false && (k2 = await a2.apply(r2, c2)), k2;
})();
let p2 = u2.apply(r2, c2);
return p2 === false && (p2 = a2.apply(r2, c2)), p2;
};
}
s2.hooks = r2;
}
if (n2.walkTokens) {
let r2 = this.defaults.walkTokens, i2 = n2.walkTokens;
s2.walkTokens = function(o3) {
let u2 = [];
return u2.push(i2.call(this, o3)), r2 && (u2 = u2.concat(r2.call(this, o3))), u2;
};
}
this.defaults = { ...this.defaults, ...s2 };
}), this;
}
setOptions(e2) {
return this.defaults = { ...this.defaults, ...e2 }, this;
}
lexer(e2, t3) {
return x2.lex(e2, t3 ?? this.defaults);
}
parser(e2, t3) {
return b2.parse(e2, t3 ?? this.defaults);
}
parseMarkdown(e2) {
return (n2, s2) => {
let r2 = { ...s2 }, i2 = { ...this.defaults, ...r2 }, o3 = this.onError(!!i2.silent, !!i2.async);
if (this.defaults.async === true && r2.async === false) return o3(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));
if (typeof n2 > "u" || n2 === null) return o3(new Error("marked(): input parameter is undefined or null"));
if (typeof n2 != "string") return o3(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(n2) + ", string expected"));
if (i2.hooks && (i2.hooks.options = i2, i2.hooks.block = e2), i2.async) return (async () => {
let u2 = i2.hooks ? await i2.hooks.preprocess(n2) : n2, c2 = await (i2.hooks ? await i2.hooks.provideLexer(e2) : e2 ? x2.lex : x2.lexInline)(u2, i2), p2 = i2.hooks ? await i2.hooks.processAllTokens(c2) : c2;
i2.walkTokens && await Promise.all(this.walkTokens(p2, i2.walkTokens));
let h2 = await (i2.hooks ? await i2.hooks.provideParser(e2) : e2 ? b2.parse : b2.parseInline)(p2, i2);
return i2.hooks ? await i2.hooks.postprocess(h2) : h2;
})().catch(o3);
try {
i2.hooks && (n2 = i2.hooks.preprocess(n2));
let a2 = (i2.hooks ? i2.hooks.provideLexer(e2) : e2 ? x2.lex : x2.lexInline)(n2, i2);
i2.hooks && (a2 = i2.hooks.processAllTokens(a2)), i2.walkTokens && this.walkTokens(a2, i2.walkTokens);
let p2 = (i2.hooks ? i2.hooks.provideParser(e2) : e2 ? b2.parse : b2.parseInline)(a2, i2);
return i2.hooks && (p2 = i2.hooks.postprocess(p2)), p2;
} catch (u2) {
return o3(u2);
}
};
}
onError(e2, t3) {
return (n2) => {
if (n2.message += `
Please report this to https://github.com/markedjs/marked.`, e2) {
let s2 = "<p>An error occurred:</p><pre>" + O(n2.message + "", true) + "</pre>";
return t3 ? Promise.resolve(s2) : s2;
}
if (t3) return Promise.reject(n2);
throw n2;
};
}
};
var M2 = new D();
function g2(l4, e2) {
return M2.parse(l4, e2);
}
g2.options = g2.setOptions = function(l4) {
return M2.setOptions(l4), g2.defaults = M2.defaults, G(g2.defaults), g2;
};
g2.getDefaults = z;
g2.defaults = T;
g2.use = function(...l4) {
return M2.use(...l4), g2.defaults = M2.defaults, G(g2.defaults), g2;
};
g2.walkTokens = function(l4, e2) {
return M2.walkTokens(l4, e2);
};
g2.parseInline = M2.parseInline;
g2.Parser = b2;
g2.parser = b2.parse;
g2.Renderer = y2;
g2.TextRenderer = L;
g2.Lexer = x2;
g2.lexer = x2.lex;
g2.Tokenizer = w2;
g2.Hooks = P;
g2.parse = g2;
var jt = g2.options;
var Ft = g2.setOptions;
var Ut = g2.use;
var Kt = g2.walkTokens;
var Wt = g2.parseInline;
var Jt = b2.parse;
var Vt = x2.lex;
// packages/blocks/build-module/api/raw-handling/markdown-converter.mjs
function escapeBodyText(value) {
return value.replace(/&(?!#?\w+;)/g, "&").replace(/</g, "<").replace(/>/g, ">");
}
var converter = new D({
gfm: true,
breaks: true,
renderer: {
// Match showdown's `omitExtraWLInCodeBlocks`: marked appends `\n`
// before `</code>`, which leaks into the Code block's content as a
// trailing blank line.
code({ text: text2, lang }) {
const language = (lang || "").match(/^\S*/)?.[0];
const cls = language ? ` class="${language} language-${language}"` : "";
return `<pre><code${cls}>${escapeBodyText(
text2
)}</code></pre>`;
},
text(token) {
if ("tokens" in token && token.tokens || "escaped" in token && token.escaped) {
return false;
}
return escapeBodyText(token.text);
}
}
});
function slackMarkdownVariantCorrector(text2) {
return text2.replace(
/((?:^|\n)```)([^\n`]+)(```(?:$|\n))/,
(match, p1, p2, p3) => `${p1}
${p2}
${p3}`
);
}
function bulletsToAsterisks(text2) {
return text2.replace(/(^|\n)•( +)/g, "$1*$2");
}
function escapeSingleLineOrderedListMarker(text2) {
if (text2.includes("\n")) {
return text2;
}
return text2.replace(/^(\d+)\.(\s)/, "$1\\.$2");
}
var correctors = [
escapeSingleLineOrderedListMarker,
bulletsToAsterisks,
slackMarkdownVariantCorrector
];
function markdownConverter(text2) {
return converter.parse(
correctors.reduce(
(current, corrector) => corrector(current),
text2
),
{ async: false }
);
}
// packages/blocks/build-module/api/raw-handling/iframe-remover.mjs
function iframeRemover(iframe) {
if (iframe.nodeName === "IFRAME") {
const node = iframe;
const text2 = node.ownerDocument.createTextNode(node.src);
node.parentNode.replaceChild(text2, node);
}
}
// packages/blocks/build-module/api/raw-handling/google-docs-uid-remover.mjs
var import_dom10 = __toESM(require_dom(), 1);
function googleDocsUIdRemover(node) {
const el = node;
if (!el.id || el.id.indexOf("docs-internal-guid-") !== 0) {
return;
}
if (el.tagName === "B") {
(0, import_dom10.unwrap)(node);
} else {
el.removeAttribute("id");
}
}
// packages/blocks/build-module/api/raw-handling/html-formatting-remover.mjs
function isFormattingSpace(character) {
return character === " " || character === "\r" || character === "\n" || character === " ";
}
function htmlFormattingRemover(node) {
if (node.nodeType !== node.TEXT_NODE) {
return;
}
let parent = node;
while (parent = parent.parentNode) {
if (parent.nodeType === parent.ELEMENT_NODE && parent.nodeName === "PRE") {
return;
}
}
const textNode = node;
let newData = textNode.data.replace(/[ \r\n\t]+/g, " ");
if (newData[0] === " ") {
const previousSibling = getSibling(node, "previous");
if (!previousSibling || previousSibling.nodeName === "BR" || previousSibling.textContent.slice(-1) === " ") {
newData = newData.slice(1);
}
}
if (newData[newData.length - 1] === " ") {
const nextSibling = getSibling(node, "next");
if (!nextSibling || nextSibling.nodeName === "BR" || nextSibling.nodeType === nextSibling.TEXT_NODE && isFormattingSpace(nextSibling.textContent[0])) {
newData = newData.slice(0, -1);
}
}
if (!newData) {
node.parentNode.removeChild(node);
} else {
textNode.data = newData;
}
}
// packages/blocks/build-module/api/raw-handling/format-space-corrector.mjs
var import_dom11 = __toESM(require_dom(), 1);
function moveEdgeSpace(node, doc, isLeading) {
const child = isLeading ? node.firstChild : node.lastChild;
if (!child || child.nodeType !== node.TEXT_NODE) {
return;
}
const text2 = child;
const edgeIndex = isLeading ? 0 : text2.data.length - 1;
if (text2.data[edgeIndex] !== " ") {
return;
}
text2.data = isLeading ? text2.data.slice(1) : text2.data.slice(0, -1);
if (!text2.data) {
node.removeChild(text2);
}
node.parentNode.insertBefore(
doc.createTextNode(" "),
isLeading ? node : node.nextSibling
);
}
function formatSpaceCorrector(node, doc) {
if (node.nodeType !== node.ELEMENT_NODE || !(0, import_dom11.isPhrasingContent)(node)) {
return;
}
moveEdgeSpace(node, doc, true);
moveEdgeSpace(node, doc, false);
}
// packages/blocks/build-module/api/raw-handling/br-remover.mjs
function brRemover(node) {
if (node.nodeName !== "BR") {
return;
}
if (getSibling(node, "next")) {
return;
}
node.parentNode.removeChild(node);
}
// packages/blocks/build-module/api/raw-handling/empty-paragraph-remover.mjs
function emptyParagraphRemover(node) {
if (node.nodeName !== "P") {
return;
}
if (node.hasChildNodes()) {
return;
}
node.parentNode.removeChild(node);
}
// packages/blocks/build-module/api/raw-handling/slack-paragraph-corrector.mjs
function slackParagraphCorrector(node) {
if (node.nodeName !== "SPAN") {
return;
}
if (node.getAttribute("data-stringify-type") !== "paragraph-break") {
return;
}
const parentNode = node.parentNode;
parentNode.insertBefore(node.ownerDocument.createElement("br"), node);
parentNode.insertBefore(node.ownerDocument.createElement("br"), node);
parentNode.removeChild(node);
}
// packages/blocks/build-module/api/raw-handling/latex-to-math.mjs
function isLatexMathMode(text2) {
const lettersRegex = /[\p{L}\s]+/gu;
let match;
while (match = lettersRegex.exec(text2)) {
if (text2[match.index - 1] === "{") {
continue;
}
let sequence = match[0];
if (text2[match.index - 1] === "\\") {
sequence = sequence.replace(/^[a-zA-Z]+/, "");
}
if (sequence.length < 6) {
continue;
}
return false;
}
if (/\\[a-zA-Z]+\s*\{/g.test(text2)) {
return true;
}
const softClues = [
(t3) => t3.includes("^") && !t3.startsWith("^"),
(t3) => ["=", "+", "-", "/", "*"].some(
(operator) => t3.includes(operator)
),
(t3) => /\\[a-zA-Z]+/g.test(t3)
];
if (softClues.filter((clue) => clue(text2)).length >= 2) {
return true;
}
return false;
}
// packages/blocks/build-module/api/raw-handling/heading-transformer.mjs
function headingTransformer(node) {
if (node.nodeType !== node.ELEMENT_NODE) {
return;
}
const element = node;
if (element.tagName === "P" && element.getAttribute("role") === "heading" && element.hasAttribute("aria-level")) {
const level = parseInt(element.getAttribute("aria-level"), 10);
if (level >= 1 && level <= 6) {
const headingTag = `H${level}`;
const newHeading = element.ownerDocument.createElement(headingTag);
Array.from(element.attributes).forEach((attr2) => {
if (attr2.name !== "role" && attr2.name !== "aria-level") {
newHeading.setAttribute(attr2.name, attr2.value);
}
});
while (element.firstChild) {
newHeading.appendChild(element.firstChild);
}
element.parentNode.replaceChild(newHeading, element);
}
}
}
// packages/blocks/build-module/api/raw-handling/paste-handler.mjs
var log = (...args) => window?.console?.log?.(...args);
function filterInlineHTML(HTML) {
HTML = deepFilterHTML(HTML, [
headRemover,
googleDocsUIdRemover,
msListIgnore,
phrasingContentReducer,
commentRemover
]);
HTML = (0, import_dom12.removeInvalidHTML)(
HTML,
(0, import_dom12.getPhrasingContentSchema)("paste"),
true
);
HTML = deepFilterHTML(HTML, [
htmlFormattingRemover,
formatSpaceCorrector,
brRemover
]);
log("Processed inline HTML:\n\n", HTML);
return HTML;
}
function pasteHandler({
HTML = "",
plainText = "",
mode = "AUTO",
tagName
}) {
log("Received HTML (pasteHandler):\n\n", HTML);
log("Received plain text (pasteHandler):\n\n", plainText);
HTML = HTML.replace(/<meta[^>]+>/g, "");
HTML = HTML.replace(
/^\s*<html[^>]*>\s*<body[^>]*>(?:\s*<!--\s*StartFragment\s*-->)?/i,
""
);
HTML = HTML.replace(
/(?:<!--\s*EndFragment\s*-->\s*)?<\/body>\s*<\/html>\s*$/i,
""
);
if (mode !== "INLINE") {
const content = HTML ? HTML : plainText;
if (content.indexOf("<!-- wp:") !== -1) {
const parseResult = parse2(content);
const isSingleFreeFormBlock = parseResult.length === 1 && parseResult[0].name === "core/freeform";
if (!isSingleFreeFormBlock) {
return parseResult;
}
}
}
HTML = HTML.normalize();
HTML = deepFilterHTML(HTML, [slackParagraphCorrector]);
const isPlainText = plainText && (!HTML || isPlain(HTML));
if (isPlainText && isLatexMathMode(plainText)) {
return [createBlock("core/math", { latex: plainText })];
}
if (isPlainText) {
HTML = plainText;
if (!/^\s+$/.test(plainText)) {
HTML = markdownConverter(HTML);
}
}
const pieces = shortcode_converter_default(HTML);
const hasShortcodes = pieces.length > 1;
if (isPlainText && !hasShortcodes) {
if (mode === "AUTO" && plainText.indexOf("\n") === -1 && plainText.indexOf("<p>") !== 0 && HTML.indexOf("<p>") === 0) {
mode = "INLINE";
}
}
if (mode === "INLINE") {
return filterInlineHTML(HTML);
}
if (mode === "AUTO" && !hasShortcodes && isInlineContent(HTML, tagName)) {
return filterInlineHTML(HTML);
}
const phrasingContentSchema = (0, import_dom12.getPhrasingContentSchema)("paste");
const blockContentSchema = getBlockContentSchema("paste");
const blocks = pieces.map((piece) => {
if (typeof piece !== "string") {
return piece;
}
const filters = [
googleDocsUIdRemover,
msListConverter,
headRemover,
listReducer,
imageCorrector,
phrasingContentReducer,
specialCommentConverter,
commentRemover,
iframeRemover,
figureContentReducer,
blockquoteNormaliser(),
divNormaliser,
headingTransformer
];
const schema = {
...blockContentSchema,
// Keep top-level phrasing content, normalised by `normaliseBlocks`.
...phrasingContentSchema
};
piece = deepFilterHTML(piece, filters, blockContentSchema);
piece = (0, import_dom12.removeInvalidHTML)(piece, schema, false);
piece = normaliseBlocks(piece);
piece = deepFilterHTML(
piece,
[
htmlFormattingRemover,
formatSpaceCorrector,
brRemover,
emptyParagraphRemover
],
blockContentSchema
);
log("Processed HTML piece:\n\n", piece);
return htmlToBlocks(piece, pasteHandler);
}).flat().filter(Boolean);
if (mode === "AUTO" && blocks.length === 1 && hasBlockSupport(blocks[0].name, "__unstablePasteTextInline", false)) {
const trimRegex = /^[\n]+|[\n]+$/g;
const trimmedPlainText = plainText.replace(trimRegex, "");
if (trimmedPlainText !== "" && trimmedPlainText.indexOf("\n") === -1) {
return (0, import_dom12.removeInvalidHTML)(
getBlockInnerHTML(blocks[0]),
phrasingContentSchema,
false
).replace(trimRegex, "");
}
}
return blocks;
}
// packages/blocks/build-module/api/raw-handling/index.mjs
function deprecatedGetPhrasingContentSchema(context) {
(0, import_deprecated11.default)("wp.blocks.getPhrasingContentSchema", {
since: "5.6",
alternative: "wp.dom.getPhrasingContentSchema"
});
return (0, import_dom13.getPhrasingContentSchema)(context);
}
function rawHandler({ HTML = "" }) {
if (HTML.indexOf("<!-- wp:") !== -1) {
const parseResult = parse2(HTML);
const isSingleFreeFormBlock = parseResult.length === 1 && parseResult[0].name === "core/freeform";
if (!isSingleFreeFormBlock) {
return parseResult;
}
}
const pieces = shortcode_converter_default(HTML);
const blockContentSchema = getBlockContentSchema();
return pieces.map((piece) => {
if (typeof piece !== "string") {
return piece;
}
const filters = [
// Needed to adjust invalid lists.
listReducer,
// Needed to create more and nextpage blocks.
specialCommentConverter,
// Needed to create media blocks.
figureContentReducer,
// Needed to create the quote block, which cannot handle text
// without wrapper paragraphs.
blockquoteNormaliser({ raw: true })
];
piece = deepFilterHTML(piece, filters, blockContentSchema);
piece = normaliseBlocks(piece, { raw: true });
return htmlToBlocks(piece, rawHandler);
}).flat().filter(Boolean);
}
// packages/blocks/build-module/api/categories.mjs
var import_data6 = __toESM(require_data(), 1);
function getCategories2() {
return (0, import_data6.select)(store).getCategories();
}
function setCategories2(categories2) {
(0, import_data6.dispatch)(store).setCategories(categories2);
}
function updateCategory2(slug, category) {
(0, import_data6.dispatch)(store).updateCategory(slug, category);
}
// packages/blocks/build-module/api/templates.mjs
var import_element4 = __toESM(require_element(), 1);
function doBlocksMatchTemplate(blocks = [], template = []) {
return blocks.length === template.length && template.every(([name, , innerBlocksTemplate], index) => {
const block = blocks[index];
return name === block.name && doBlocksMatchTemplate(block.innerBlocks, innerBlocksTemplate);
});
}
var isHTMLAttribute = (attributeDefinition) => attributeDefinition?.source === "html";
var isQueryAttribute = (attributeDefinition) => attributeDefinition?.source === "query";
function normalizeAttributes(schema, values) {
if (!values) {
return {};
}
return Object.fromEntries(
Object.entries(values).map(([key, value]) => [
key,
normalizeAttribute(schema[key], value)
])
);
}
function normalizeAttribute(definition, value) {
if (isHTMLAttribute(definition) && Array.isArray(value)) {
return (0, import_element4.renderToString)(value);
}
if (isQueryAttribute(definition) && value) {
return value.map(
(subValues) => {
return normalizeAttributes(definition.query, subValues);
}
);
}
return value;
}
function synchronizeBlocksWithTemplate(blocks = [], template) {
if (!template) {
return blocks;
}
return template.map(
([name, attributes, innerBlocksTemplate], index) => {
const block = blocks[index];
if (block && block.name === name) {
const innerBlocks = synchronizeBlocksWithTemplate(
block.innerBlocks,
innerBlocksTemplate
);
return { ...block, innerBlocks };
}
const blockType = getBlockType(name);
const normalizedAttributes = normalizeAttributes(
blockType?.attributes ?? {},
attributes
);
const [blockName, blockAttributes] = convertLegacyBlockNameAndAttributes(
name,
normalizedAttributes
);
return createBlock(
blockName,
blockAttributes,
synchronizeBlocksWithTemplate([], innerBlocksTemplate)
);
}
);
}
// packages/blocks/build-module/api/index.mjs
var fieldsKey = /* @__PURE__ */ Symbol("fields");
var formKey = /* @__PURE__ */ Symbol("form");
var privateApis = {};
lock(privateApis, {
isContentBlock,
fieldsKey,
formKey,
parseRawBlock
});
// packages/blocks/build-module/deprecated.mjs
var import_deprecated12 = __toESM(require_deprecated(), 1);
function withBlockContentContext(OriginalComponent) {
(0, import_deprecated12.default)("wp.blocks.withBlockContentContext", {
since: "6.1"
});
return OriginalComponent;
}
return __toCommonJS(index_exports);
})();
/*! Bundled license information:
react-is/cjs/react-is.development.js:
(**
* @license React
* react-is.development.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*)
is-plain-object/dist/is-plain-object.mjs:
(*!
* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
*
* Copyright (c) 2014-2017, Jon Schlinkert.
* Released under the MIT License.
*)
*/