8314 lines
293 KiB
JavaScript
8314 lines
293 KiB
JavaScript
(function() {
|
|
"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 editableRootKey = /* @__PURE__ */ Symbol("editableRoot");
|
|
var privateApis = {};
|
|
lock(privateApis, {
|
|
isContentBlock,
|
|
fieldsKey,
|
|
formKey,
|
|
editableRootKey,
|
|
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.
|
|
*)
|
|
*/
|
|
(window.wp ||= {}).blocks = wp.blocks;
|
|
})();
|