| [ Index ] |
PHP Cross Reference of WordPress |
[Summary view] [Print] [Text view]
1 this["wp"] = this["wp"] || {}; this["wp"]["blocks"] = 2 /******/ (function(modules) { // webpackBootstrap 3 /******/ // The module cache 4 /******/ var installedModules = {}; 5 /******/ 6 /******/ // The require function 7 /******/ function __webpack_require__(moduleId) { 8 /******/ 9 /******/ // Check if module is in cache 10 /******/ if(installedModules[moduleId]) { 11 /******/ return installedModules[moduleId].exports; 12 /******/ } 13 /******/ // Create a new module (and put it into the cache) 14 /******/ var module = installedModules[moduleId] = { 15 /******/ i: moduleId, 16 /******/ l: false, 17 /******/ exports: {} 18 /******/ }; 19 /******/ 20 /******/ // Execute the module function 21 /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 22 /******/ 23 /******/ // Flag the module as loaded 24 /******/ module.l = true; 25 /******/ 26 /******/ // Return the exports of the module 27 /******/ return module.exports; 28 /******/ } 29 /******/ 30 /******/ 31 /******/ // expose the modules object (__webpack_modules__) 32 /******/ __webpack_require__.m = modules; 33 /******/ 34 /******/ // expose the module cache 35 /******/ __webpack_require__.c = installedModules; 36 /******/ 37 /******/ // define getter function for harmony exports 38 /******/ __webpack_require__.d = function(exports, name, getter) { 39 /******/ if(!__webpack_require__.o(exports, name)) { 40 /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); 41 /******/ } 42 /******/ }; 43 /******/ 44 /******/ // define __esModule on exports 45 /******/ __webpack_require__.r = function(exports) { 46 /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 47 /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 48 /******/ } 49 /******/ Object.defineProperty(exports, '__esModule', { value: true }); 50 /******/ }; 51 /******/ 52 /******/ // create a fake namespace object 53 /******/ // mode & 1: value is a module id, require it 54 /******/ // mode & 2: merge all properties of value into the ns 55 /******/ // mode & 4: return value when already ns object 56 /******/ // mode & 8|1: behave like require 57 /******/ __webpack_require__.t = function(value, mode) { 58 /******/ if(mode & 1) value = __webpack_require__(value); 59 /******/ if(mode & 8) return value; 60 /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; 61 /******/ var ns = Object.create(null); 62 /******/ __webpack_require__.r(ns); 63 /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); 64 /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); 65 /******/ return ns; 66 /******/ }; 67 /******/ 68 /******/ // getDefaultExport function for compatibility with non-harmony modules 69 /******/ __webpack_require__.n = function(module) { 70 /******/ var getter = module && module.__esModule ? 71 /******/ function getDefault() { return module['default']; } : 72 /******/ function getModuleExports() { return module; }; 73 /******/ __webpack_require__.d(getter, 'a', getter); 74 /******/ return getter; 75 /******/ }; 76 /******/ 77 /******/ // Object.prototype.hasOwnProperty.call 78 /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 79 /******/ 80 /******/ // __webpack_public_path__ 81 /******/ __webpack_require__.p = ""; 82 /******/ 83 /******/ 84 /******/ // Load entry module and return exports 85 /******/ return __webpack_require__(__webpack_require__.s = "0ATp"); 86 /******/ }) 87 /************************************************************************/ 88 /******/ ({ 89 90 /***/ "//Lo": 91 /***/ (function(module, __webpack_exports__, __webpack_require__) { 92 93 "use strict"; 94 /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("GRId"); 95 /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__); 96 /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("Tqx9"); 97 /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__); 98 99 100 /** 101 * WordPress dependencies 102 */ 103 104 const blockDefault = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], { 105 xmlns: "http://www.w3.org/2000/svg", 106 viewBox: "0 0 24 24" 107 }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], { 108 d: "M19 8h-1V6h-5v2h-2V6H6v2H5c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-8c0-1.1-.9-2-2-2zm.5 10c0 .3-.2.5-.5.5H5c-.3 0-.5-.2-.5-.5v-8c0-.3.2-.5.5-.5h14c.3 0 .5.2.5.5v8z" 109 })); 110 /* harmony default export */ __webpack_exports__["a"] = (blockDefault); 111 112 113 /***/ }), 114 115 /***/ "0ATp": 116 /***/ (function(module, __webpack_exports__, __webpack_require__) { 117 118 "use strict"; 119 // ESM COMPAT FLAG 120 __webpack_require__.r(__webpack_exports__); 121 122 // EXPORTS 123 __webpack_require__.d(__webpack_exports__, "store", function() { return /* reexport */ store; }); 124 __webpack_require__.d(__webpack_exports__, "createBlock", function() { return /* reexport */ createBlock; }); 125 __webpack_require__.d(__webpack_exports__, "createBlocksFromInnerBlocksTemplate", function() { return /* reexport */ createBlocksFromInnerBlocksTemplate; }); 126 __webpack_require__.d(__webpack_exports__, "cloneBlock", function() { return /* reexport */ cloneBlock; }); 127 __webpack_require__.d(__webpack_exports__, "__experimentalCloneSanitizedBlock", function() { return /* reexport */ __experimentalCloneSanitizedBlock; }); 128 __webpack_require__.d(__webpack_exports__, "getPossibleBlockTransformations", function() { return /* reexport */ getPossibleBlockTransformations; }); 129 __webpack_require__.d(__webpack_exports__, "switchToBlockType", function() { return /* reexport */ switchToBlockType; }); 130 __webpack_require__.d(__webpack_exports__, "getBlockTransforms", function() { return /* reexport */ getBlockTransforms; }); 131 __webpack_require__.d(__webpack_exports__, "findTransform", function() { return /* reexport */ findTransform; }); 132 __webpack_require__.d(__webpack_exports__, "getBlockFromExample", function() { return /* reexport */ getBlockFromExample; }); 133 __webpack_require__.d(__webpack_exports__, "parse", function() { return /* reexport */ parser; }); 134 __webpack_require__.d(__webpack_exports__, "getBlockAttributes", function() { return /* reexport */ getBlockAttributes; }); 135 __webpack_require__.d(__webpack_exports__, "parseWithAttributeSchema", function() { return /* reexport */ parseWithAttributeSchema; }); 136 __webpack_require__.d(__webpack_exports__, "pasteHandler", function() { return /* reexport */ pasteHandler; }); 137 __webpack_require__.d(__webpack_exports__, "rawHandler", function() { return /* reexport */ rawHandler; }); 138 __webpack_require__.d(__webpack_exports__, "getPhrasingContentSchema", function() { return /* reexport */ deprecatedGetPhrasingContentSchema; }); 139 __webpack_require__.d(__webpack_exports__, "serialize", function() { return /* reexport */ serialize; }); 140 __webpack_require__.d(__webpack_exports__, "getBlockContent", function() { return /* reexport */ getBlockInnerHTML; }); 141 __webpack_require__.d(__webpack_exports__, "getBlockDefaultClassName", function() { return /* reexport */ getBlockDefaultClassName; }); 142 __webpack_require__.d(__webpack_exports__, "getBlockMenuDefaultClassName", function() { return /* reexport */ getBlockMenuDefaultClassName; }); 143 __webpack_require__.d(__webpack_exports__, "getSaveElement", function() { return /* reexport */ getSaveElement; }); 144 __webpack_require__.d(__webpack_exports__, "getSaveContent", function() { return /* reexport */ getSaveContent; }); 145 __webpack_require__.d(__webpack_exports__, "__unstableGetBlockProps", function() { return /* reexport */ getBlockProps; }); 146 __webpack_require__.d(__webpack_exports__, "__unstableSerializeAndClean", function() { return /* reexport */ __unstableSerializeAndClean; }); 147 __webpack_require__.d(__webpack_exports__, "isValidBlockContent", function() { return /* reexport */ isValidBlockContent; }); 148 __webpack_require__.d(__webpack_exports__, "getCategories", function() { return /* reexport */ categories_getCategories; }); 149 __webpack_require__.d(__webpack_exports__, "setCategories", function() { return /* reexport */ categories_setCategories; }); 150 __webpack_require__.d(__webpack_exports__, "updateCategory", function() { return /* reexport */ categories_updateCategory; }); 151 __webpack_require__.d(__webpack_exports__, "registerBlockType", function() { return /* reexport */ registerBlockType; }); 152 __webpack_require__.d(__webpack_exports__, "registerBlockTypeFromMetadata", function() { return /* reexport */ registerBlockTypeFromMetadata; }); 153 __webpack_require__.d(__webpack_exports__, "registerBlockCollection", function() { return /* reexport */ registerBlockCollection; }); 154 __webpack_require__.d(__webpack_exports__, "unregisterBlockType", function() { return /* reexport */ unregisterBlockType; }); 155 __webpack_require__.d(__webpack_exports__, "setFreeformContentHandlerName", function() { return /* reexport */ setFreeformContentHandlerName; }); 156 __webpack_require__.d(__webpack_exports__, "getFreeformContentHandlerName", function() { return /* reexport */ getFreeformContentHandlerName; }); 157 __webpack_require__.d(__webpack_exports__, "setUnregisteredTypeHandlerName", function() { return /* reexport */ setUnregisteredTypeHandlerName; }); 158 __webpack_require__.d(__webpack_exports__, "getUnregisteredTypeHandlerName", function() { return /* reexport */ getUnregisteredTypeHandlerName; }); 159 __webpack_require__.d(__webpack_exports__, "setDefaultBlockName", function() { return /* reexport */ registration_setDefaultBlockName; }); 160 __webpack_require__.d(__webpack_exports__, "getDefaultBlockName", function() { return /* reexport */ registration_getDefaultBlockName; }); 161 __webpack_require__.d(__webpack_exports__, "setGroupingBlockName", function() { return /* reexport */ registration_setGroupingBlockName; }); 162 __webpack_require__.d(__webpack_exports__, "getGroupingBlockName", function() { return /* reexport */ registration_getGroupingBlockName; }); 163 __webpack_require__.d(__webpack_exports__, "getBlockType", function() { return /* reexport */ registration_getBlockType; }); 164 __webpack_require__.d(__webpack_exports__, "getBlockTypes", function() { return /* reexport */ registration_getBlockTypes; }); 165 __webpack_require__.d(__webpack_exports__, "getBlockSupport", function() { return /* reexport */ registration_getBlockSupport; }); 166 __webpack_require__.d(__webpack_exports__, "hasBlockSupport", function() { return /* reexport */ registration_hasBlockSupport; }); 167 __webpack_require__.d(__webpack_exports__, "getBlockVariations", function() { return /* reexport */ registration_getBlockVariations; }); 168 __webpack_require__.d(__webpack_exports__, "isReusableBlock", function() { return /* reexport */ isReusableBlock; }); 169 __webpack_require__.d(__webpack_exports__, "isTemplatePart", function() { return /* reexport */ isTemplatePart; }); 170 __webpack_require__.d(__webpack_exports__, "getChildBlockNames", function() { return /* reexport */ registration_getChildBlockNames; }); 171 __webpack_require__.d(__webpack_exports__, "hasChildBlocks", function() { return /* reexport */ registration_hasChildBlocks; }); 172 __webpack_require__.d(__webpack_exports__, "hasChildBlocksWithInserterSupport", function() { return /* reexport */ registration_hasChildBlocksWithInserterSupport; }); 173 __webpack_require__.d(__webpack_exports__, "unstable__bootstrapServerSideBlockDefinitions", function() { return /* reexport */ unstable__bootstrapServerSideBlockDefinitions; }); 174 __webpack_require__.d(__webpack_exports__, "registerBlockStyle", function() { return /* reexport */ registerBlockStyle; }); 175 __webpack_require__.d(__webpack_exports__, "unregisterBlockStyle", function() { return /* reexport */ unregisterBlockStyle; }); 176 __webpack_require__.d(__webpack_exports__, "registerBlockVariation", function() { return /* reexport */ registerBlockVariation; }); 177 __webpack_require__.d(__webpack_exports__, "unregisterBlockVariation", function() { return /* reexport */ unregisterBlockVariation; }); 178 __webpack_require__.d(__webpack_exports__, "isUnmodifiedDefaultBlock", function() { return /* reexport */ isUnmodifiedDefaultBlock; }); 179 __webpack_require__.d(__webpack_exports__, "normalizeIconObject", function() { return /* reexport */ normalizeIconObject; }); 180 __webpack_require__.d(__webpack_exports__, "isValidIcon", function() { return /* reexport */ isValidIcon; }); 181 __webpack_require__.d(__webpack_exports__, "__experimentalGetBlockLabel", function() { return /* reexport */ getBlockLabel; }); 182 __webpack_require__.d(__webpack_exports__, "__experimentalGetAccessibleBlockLabel", function() { return /* reexport */ getAccessibleBlockLabel; }); 183 __webpack_require__.d(__webpack_exports__, "__experimentalSanitizeBlockAttributes", function() { return /* reexport */ __experimentalSanitizeBlockAttributes; }); 184 __webpack_require__.d(__webpack_exports__, "__experimentalGetBlockAttributesNamesByRole", function() { return /* reexport */ __experimentalGetBlockAttributesNamesByRole; }); 185 __webpack_require__.d(__webpack_exports__, "doBlocksMatchTemplate", function() { return /* reexport */ doBlocksMatchTemplate; }); 186 __webpack_require__.d(__webpack_exports__, "synchronizeBlocksWithTemplate", function() { return /* reexport */ synchronizeBlocksWithTemplate; }); 187 __webpack_require__.d(__webpack_exports__, "children", function() { return /* reexport */ api_children; }); 188 __webpack_require__.d(__webpack_exports__, "node", function() { return /* reexport */ api_node; }); 189 __webpack_require__.d(__webpack_exports__, "__EXPERIMENTAL_STYLE_PROPERTY", function() { return /* reexport */ __EXPERIMENTAL_STYLE_PROPERTY; }); 190 __webpack_require__.d(__webpack_exports__, "__EXPERIMENTAL_ELEMENTS", function() { return /* reexport */ __EXPERIMENTAL_ELEMENTS; }); 191 __webpack_require__.d(__webpack_exports__, "withBlockContentContext", function() { return /* reexport */ withBlockContentContext; }); 192 193 // NAMESPACE OBJECT: ./node_modules/@wordpress/blocks/build-module/store/selectors.js 194 var selectors_namespaceObject = {}; 195 __webpack_require__.r(selectors_namespaceObject); 196 __webpack_require__.d(selectors_namespaceObject, "getBlockTypes", function() { return getBlockTypes; }); 197 __webpack_require__.d(selectors_namespaceObject, "getBlockType", function() { return getBlockType; }); 198 __webpack_require__.d(selectors_namespaceObject, "getBlockStyles", function() { return getBlockStyles; }); 199 __webpack_require__.d(selectors_namespaceObject, "getBlockVariations", function() { return getBlockVariations; }); 200 __webpack_require__.d(selectors_namespaceObject, "getActiveBlockVariation", function() { return getActiveBlockVariation; }); 201 __webpack_require__.d(selectors_namespaceObject, "getDefaultBlockVariation", function() { return getDefaultBlockVariation; }); 202 __webpack_require__.d(selectors_namespaceObject, "getCategories", function() { return getCategories; }); 203 __webpack_require__.d(selectors_namespaceObject, "getCollections", function() { return getCollections; }); 204 __webpack_require__.d(selectors_namespaceObject, "getDefaultBlockName", function() { return getDefaultBlockName; }); 205 __webpack_require__.d(selectors_namespaceObject, "getFreeformFallbackBlockName", function() { return getFreeformFallbackBlockName; }); 206 __webpack_require__.d(selectors_namespaceObject, "getUnregisteredFallbackBlockName", function() { return getUnregisteredFallbackBlockName; }); 207 __webpack_require__.d(selectors_namespaceObject, "getGroupingBlockName", function() { return getGroupingBlockName; }); 208 __webpack_require__.d(selectors_namespaceObject, "getChildBlockNames", function() { return getChildBlockNames; }); 209 __webpack_require__.d(selectors_namespaceObject, "getBlockSupport", function() { return getBlockSupport; }); 210 __webpack_require__.d(selectors_namespaceObject, "hasBlockSupport", function() { return hasBlockSupport; }); 211 __webpack_require__.d(selectors_namespaceObject, "isMatchingSearchTerm", function() { return isMatchingSearchTerm; }); 212 __webpack_require__.d(selectors_namespaceObject, "hasChildBlocks", function() { return hasChildBlocks; }); 213 __webpack_require__.d(selectors_namespaceObject, "hasChildBlocksWithInserterSupport", function() { return hasChildBlocksWithInserterSupport; }); 214 215 // NAMESPACE OBJECT: ./node_modules/@wordpress/blocks/build-module/store/actions.js 216 var actions_namespaceObject = {}; 217 __webpack_require__.r(actions_namespaceObject); 218 __webpack_require__.d(actions_namespaceObject, "addBlockTypes", function() { return addBlockTypes; }); 219 __webpack_require__.d(actions_namespaceObject, "removeBlockTypes", function() { return removeBlockTypes; }); 220 __webpack_require__.d(actions_namespaceObject, "addBlockStyles", function() { return addBlockStyles; }); 221 __webpack_require__.d(actions_namespaceObject, "removeBlockStyles", function() { return removeBlockStyles; }); 222 __webpack_require__.d(actions_namespaceObject, "addBlockVariations", function() { return addBlockVariations; }); 223 __webpack_require__.d(actions_namespaceObject, "removeBlockVariations", function() { return removeBlockVariations; }); 224 __webpack_require__.d(actions_namespaceObject, "setDefaultBlockName", function() { return setDefaultBlockName; }); 225 __webpack_require__.d(actions_namespaceObject, "setFreeformFallbackBlockName", function() { return setFreeformFallbackBlockName; }); 226 __webpack_require__.d(actions_namespaceObject, "setUnregisteredFallbackBlockName", function() { return setUnregisteredFallbackBlockName; }); 227 __webpack_require__.d(actions_namespaceObject, "setGroupingBlockName", function() { return setGroupingBlockName; }); 228 __webpack_require__.d(actions_namespaceObject, "setCategories", function() { return setCategories; }); 229 __webpack_require__.d(actions_namespaceObject, "updateCategory", function() { return updateCategory; }); 230 __webpack_require__.d(actions_namespaceObject, "addBlockCollection", function() { return addBlockCollection; }); 231 __webpack_require__.d(actions_namespaceObject, "removeBlockCollection", function() { return removeBlockCollection; }); 232 233 // EXTERNAL MODULE: external ["wp","data"] 234 var external_wp_data_ = __webpack_require__("1ZqX"); 235 236 // EXTERNAL MODULE: external "lodash" 237 var external_lodash_ = __webpack_require__("YLtl"); 238 239 // EXTERNAL MODULE: external ["wp","i18n"] 240 var external_wp_i18n_ = __webpack_require__("l3Sj"); 241 242 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/reducer.js 243 /** 244 * External dependencies 245 */ 246 247 /** 248 * WordPress dependencies 249 */ 250 251 252 253 /** 254 * @typedef {Object} WPBlockCategory 255 * 256 * @property {string} slug Unique category slug. 257 * @property {string} title Category label, for display in user interface. 258 */ 259 260 /** 261 * Default set of categories. 262 * 263 * @type {WPBlockCategory[]} 264 */ 265 266 const DEFAULT_CATEGORIES = [{ 267 slug: 'text', 268 title: Object(external_wp_i18n_["__"])('Text') 269 }, { 270 slug: 'media', 271 title: Object(external_wp_i18n_["__"])('Media') 272 }, { 273 slug: 'design', 274 title: Object(external_wp_i18n_["__"])('Design') 275 }, { 276 slug: 'widgets', 277 title: Object(external_wp_i18n_["__"])('Widgets') 278 }, { 279 slug: 'theme', 280 title: Object(external_wp_i18n_["__"])('Theme') 281 }, { 282 slug: 'embed', 283 title: Object(external_wp_i18n_["__"])('Embeds') 284 }, { 285 slug: 'reusable', 286 title: Object(external_wp_i18n_["__"])('Reusable blocks') 287 }]; 288 /** 289 * Reducer managing the block types 290 * 291 * @param {Object} state Current state. 292 * @param {Object} action Dispatched action. 293 * 294 * @return {Object} Updated state. 295 */ 296 297 function reducer_blockTypes(state = {}, action) { 298 switch (action.type) { 299 case 'ADD_BLOCK_TYPES': 300 return { ...state, 301 ...Object(external_lodash_["keyBy"])(Object(external_lodash_["map"])(action.blockTypes, blockType => Object(external_lodash_["omit"])(blockType, 'styles ')), 'name') 302 }; 303 304 case 'REMOVE_BLOCK_TYPES': 305 return Object(external_lodash_["omit"])(state, action.names); 306 } 307 308 return state; 309 } 310 /** 311 * Reducer managing the block style variations. 312 * 313 * @param {Object} state Current state. 314 * @param {Object} action Dispatched action. 315 * 316 * @return {Object} Updated state. 317 */ 318 319 function blockStyles(state = {}, action) { 320 switch (action.type) { 321 case 'ADD_BLOCK_TYPES': 322 return { ...state, 323 ...Object(external_lodash_["mapValues"])(Object(external_lodash_["keyBy"])(action.blockTypes, 'name'), blockType => { 324 return Object(external_lodash_["uniqBy"])([...Object(external_lodash_["get"])(blockType, ['styles'], []), ...Object(external_lodash_["get"])(state, [blockType.name], [])], style => style.name); 325 }) 326 }; 327 328 case 'ADD_BLOCK_STYLES': 329 return { ...state, 330 [action.blockName]: Object(external_lodash_["uniqBy"])([...Object(external_lodash_["get"])(state, [action.blockName], []), ...action.styles], style => style.name) 331 }; 332 333 case 'REMOVE_BLOCK_STYLES': 334 return { ...state, 335 [action.blockName]: Object(external_lodash_["filter"])(Object(external_lodash_["get"])(state, [action.blockName], []), style => action.styleNames.indexOf(style.name) === -1) 336 }; 337 } 338 339 return state; 340 } 341 /** 342 * Reducer managing the block variations. 343 * 344 * @param {Object} state Current state. 345 * @param {Object} action Dispatched action. 346 * 347 * @return {Object} Updated state. 348 */ 349 350 function blockVariations(state = {}, action) { 351 switch (action.type) { 352 case 'ADD_BLOCK_TYPES': 353 return { ...state, 354 ...Object(external_lodash_["mapValues"])(Object(external_lodash_["keyBy"])(action.blockTypes, 'name'), blockType => { 355 return Object(external_lodash_["uniqBy"])([...Object(external_lodash_["get"])(blockType, ['variations'], []), ...Object(external_lodash_["get"])(state, [blockType.name], [])], variation => variation.name); 356 }) 357 }; 358 359 case 'ADD_BLOCK_VARIATIONS': 360 return { ...state, 361 [action.blockName]: Object(external_lodash_["uniqBy"])([...Object(external_lodash_["get"])(state, [action.blockName], []), ...action.variations], variation => variation.name) 362 }; 363 364 case 'REMOVE_BLOCK_VARIATIONS': 365 return { ...state, 366 [action.blockName]: Object(external_lodash_["filter"])(Object(external_lodash_["get"])(state, [action.blockName], []), variation => action.variationNames.indexOf(variation.name) === -1) 367 }; 368 } 369 370 return state; 371 } 372 /** 373 * Higher-order Reducer creating a reducer keeping track of given block name. 374 * 375 * @param {string} setActionType Action type. 376 * 377 * @return {Function} Reducer. 378 */ 379 380 function createBlockNameSetterReducer(setActionType) { 381 return (state = null, action) => { 382 switch (action.type) { 383 case 'REMOVE_BLOCK_TYPES': 384 if (action.names.indexOf(state) !== -1) { 385 return null; 386 } 387 388 return state; 389 390 case setActionType: 391 return action.name || null; 392 } 393 394 return state; 395 }; 396 } 397 const reducer_defaultBlockName = createBlockNameSetterReducer('SET_DEFAULT_BLOCK_NAME'); 398 const freeformFallbackBlockName = createBlockNameSetterReducer('SET_FREEFORM_FALLBACK_BLOCK_NAME'); 399 const unregisteredFallbackBlockName = createBlockNameSetterReducer('SET_UNREGISTERED_FALLBACK_BLOCK_NAME'); 400 const groupingBlockName = createBlockNameSetterReducer('SET_GROUPING_BLOCK_NAME'); 401 /** 402 * Reducer managing the categories 403 * 404 * @param {WPBlockCategory[]} state Current state. 405 * @param {Object} action Dispatched action. 406 * 407 * @return {WPBlockCategory[]} Updated state. 408 */ 409 410 function reducer_categories(state = DEFAULT_CATEGORIES, action) { 411 switch (action.type) { 412 case 'SET_CATEGORIES': 413 return action.categories || []; 414 415 case 'UPDATE_CATEGORY': 416 { 417 if (!action.category || Object(external_lodash_["isEmpty"])(action.category)) { 418 return state; 419 } 420 421 const categoryToChange = Object(external_lodash_["find"])(state, ['slug', action.slug]); 422 423 if (categoryToChange) { 424 return Object(external_lodash_["map"])(state, category => { 425 if (category.slug === action.slug) { 426 return { ...category, 427 ...action.category 428 }; 429 } 430 431 return category; 432 }); 433 } 434 } 435 } 436 437 return state; 438 } 439 function collections(state = {}, action) { 440 switch (action.type) { 441 case 'ADD_BLOCK_COLLECTION': 442 return { ...state, 443 [action.namespace]: { 444 title: action.title, 445 icon: action.icon 446 } 447 }; 448 449 case 'REMOVE_BLOCK_COLLECTION': 450 return Object(external_lodash_["omit"])(state, action.namespace); 451 } 452 453 return state; 454 } 455 /* harmony default export */ var reducer = (Object(external_wp_data_["combineReducers"])({ 456 blockTypes: reducer_blockTypes, 457 blockStyles, 458 blockVariations, 459 defaultBlockName: reducer_defaultBlockName, 460 freeformFallbackBlockName, 461 unregisteredFallbackBlockName, 462 groupingBlockName, 463 categories: reducer_categories, 464 collections 465 })); 466 467 // EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js 468 var rememo = __webpack_require__("pPDe"); 469 470 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/selectors.js 471 /** 472 * External dependencies 473 */ 474 475 476 /** @typedef {import('../api/registration').WPBlockVariation} WPBlockVariation */ 477 478 /** @typedef {import('../api/registration').WPBlockVariationScope} WPBlockVariationScope */ 479 480 /** @typedef {import('./reducer').WPBlockCategory} WPBlockCategory */ 481 482 /** 483 * Given a block name or block type object, returns the corresponding 484 * normalized block type object. 485 * 486 * @param {Object} state Blocks state. 487 * @param {(string|Object)} nameOrType Block name or type object 488 * 489 * @return {Object} Block type object. 490 */ 491 492 const getNormalizedBlockType = (state, nameOrType) => 'string' === typeof nameOrType ? getBlockType(state, nameOrType) : nameOrType; 493 /** 494 * Returns all the available block types. 495 * 496 * @param {Object} state Data state. 497 * 498 * @return {Array} Block Types. 499 */ 500 501 502 const getBlockTypes = Object(rememo["a" /* default */])(state => { 503 return Object.values(state.blockTypes).map(blockType => { 504 return { ...blockType, 505 variations: getBlockVariations(state, blockType.name) 506 }; 507 }); 508 }, state => [state.blockTypes, state.blockVariations]); 509 /** 510 * Returns a block type by name. 511 * 512 * @param {Object} state Data state. 513 * @param {string} name Block type name. 514 * 515 * @return {Object?} Block Type. 516 */ 517 518 function getBlockType(state, name) { 519 return state.blockTypes[name]; 520 } 521 /** 522 * Returns block styles by block name. 523 * 524 * @param {Object} state Data state. 525 * @param {string} name Block type name. 526 * 527 * @return {Array?} Block Styles. 528 */ 529 530 function getBlockStyles(state, name) { 531 return state.blockStyles[name]; 532 } 533 /** 534 * Returns block variations by block name. 535 * 536 * @param {Object} state Data state. 537 * @param {string} blockName Block type name. 538 * @param {WPBlockVariationScope} [scope] Block variation scope name. 539 * 540 * @return {(WPBlockVariation[]|void)} Block variations. 541 */ 542 543 const getBlockVariations = Object(rememo["a" /* default */])((state, blockName, scope) => { 544 const variations = state.blockVariations[blockName]; 545 546 if (!variations || !scope) { 547 return variations; 548 } 549 550 return variations.filter(variation => { 551 // For backward compatibility reasons, variation's scope defaults to 552 // `block` and `inserter` when not set. 553 return (variation.scope || ['block', 'inserter']).includes(scope); 554 }); 555 }, (state, blockName) => [state.blockVariations[blockName]]); 556 /** 557 * Returns the active block variation for a given block based on its attributes. 558 * Variations are determined by their `isActive` property. 559 * Which is either an array of block attribute keys or a function. 560 * 561 * In case of an array of block attribute keys, the `attributes` are compared 562 * to the variation's attributes using strict equality check. 563 * 564 * In case of function type, the function should accept a block's attributes 565 * and the variation's attributes and determines if a variation is active. 566 * A function that accepts a block's attributes and the variation's attributes and determines if a variation is active. 567 * 568 * @param {Object} state Data state. 569 * @param {string} blockName Name of block (example: “core/columns”). 570 * @param {Object} attributes Block attributes used to determine active variation. 571 * @param {WPBlockVariationScope} [scope] Block variation scope name. 572 * 573 * @return {(WPBlockVariation|undefined)} Active block variation. 574 */ 575 576 function getActiveBlockVariation(state, blockName, attributes, scope) { 577 const variations = getBlockVariations(state, blockName, scope); 578 const match = variations === null || variations === void 0 ? void 0 : variations.find(variation => { 579 var _variation$isActive; 580 581 if (Array.isArray(variation.isActive)) { 582 const blockType = getBlockType(state, blockName); 583 const attributeKeys = Object.keys(blockType.attributes || {}); 584 const definedAttributes = variation.isActive.filter(attribute => attributeKeys.includes(attribute)); 585 586 if (definedAttributes.length === 0) { 587 return false; 588 } 589 590 return definedAttributes.every(attribute => attributes[attribute] === variation.attributes[attribute]); 591 } 592 593 return (_variation$isActive = variation.isActive) === null || _variation$isActive === void 0 ? void 0 : _variation$isActive.call(variation, attributes, variation.attributes); 594 }); 595 return match; 596 } 597 /** 598 * Returns the default block variation for the given block type. 599 * When there are multiple variations annotated as the default one, 600 * the last added item is picked. This simplifies registering overrides. 601 * When there is no default variation set, it returns the first item. 602 * 603 * @param {Object} state Data state. 604 * @param {string} blockName Block type name. 605 * @param {WPBlockVariationScope} [scope] Block variation scope name. 606 * 607 * @return {?WPBlockVariation} The default block variation. 608 */ 609 610 function getDefaultBlockVariation(state, blockName, scope) { 611 const variations = getBlockVariations(state, blockName, scope); 612 return Object(external_lodash_["findLast"])(variations, 'isDefault') || Object(external_lodash_["first"])(variations); 613 } 614 /** 615 * Returns all the available categories. 616 * 617 * @param {Object} state Data state. 618 * 619 * @return {WPBlockCategory[]} Categories list. 620 */ 621 622 function getCategories(state) { 623 return state.categories; 624 } 625 /** 626 * Returns all the available collections. 627 * 628 * @param {Object} state Data state. 629 * 630 * @return {Object} Collections list. 631 */ 632 633 function getCollections(state) { 634 return state.collections; 635 } 636 /** 637 * Returns the name of the default block name. 638 * 639 * @param {Object} state Data state. 640 * 641 * @return {string?} Default block name. 642 */ 643 644 function getDefaultBlockName(state) { 645 return state.defaultBlockName; 646 } 647 /** 648 * Returns the name of the block for handling non-block content. 649 * 650 * @param {Object} state Data state. 651 * 652 * @return {string?} Name of the block for handling non-block content. 653 */ 654 655 function getFreeformFallbackBlockName(state) { 656 return state.freeformFallbackBlockName; 657 } 658 /** 659 * Returns the name of the block for handling unregistered blocks. 660 * 661 * @param {Object} state Data state. 662 * 663 * @return {string?} Name of the block for handling unregistered blocks. 664 */ 665 666 function getUnregisteredFallbackBlockName(state) { 667 return state.unregisteredFallbackBlockName; 668 } 669 /** 670 * Returns the name of the block for handling unregistered blocks. 671 * 672 * @param {Object} state Data state. 673 * 674 * @return {string?} Name of the block for handling unregistered blocks. 675 */ 676 677 function getGroupingBlockName(state) { 678 return state.groupingBlockName; 679 } 680 /** 681 * Returns an array with the child blocks of a given block. 682 * 683 * @param {Object} state Data state. 684 * @param {string} blockName Block type name. 685 * 686 * @return {Array} Array of child block names. 687 */ 688 689 const getChildBlockNames = Object(rememo["a" /* default */])((state, blockName) => { 690 return Object(external_lodash_["map"])(Object(external_lodash_["filter"])(state.blockTypes, blockType => { 691 return Object(external_lodash_["includes"])(blockType.parent, blockName); 692 }), ({ 693 name 694 }) => name); 695 }, state => [state.blockTypes]); 696 /** 697 * Returns the block support value for a feature, if defined. 698 * 699 * @param {Object} state Data state. 700 * @param {(string|Object)} nameOrType Block name or type object 701 * @param {string} feature Feature to retrieve 702 * @param {*} defaultSupports Default value to return if not 703 * explicitly defined 704 * 705 * @return {?*} Block support value 706 */ 707 708 const getBlockSupport = (state, nameOrType, feature, defaultSupports) => { 709 const blockType = getNormalizedBlockType(state, nameOrType); 710 return Object(external_lodash_["get"])(blockType, ['supports', ...feature.split('.')], defaultSupports); 711 }; 712 /** 713 * Returns true if the block defines support for a feature, or false otherwise. 714 * 715 * @param {Object} state Data state. 716 * @param {(string|Object)} nameOrType Block name or type object. 717 * @param {string} feature Feature to test. 718 * @param {boolean} defaultSupports Whether feature is supported by 719 * default if not explicitly defined. 720 * 721 * @return {boolean} Whether block supports feature. 722 */ 723 724 function hasBlockSupport(state, nameOrType, feature, defaultSupports) { 725 return !!getBlockSupport(state, nameOrType, feature, defaultSupports); 726 } 727 /** 728 * Returns true if the block type by the given name or object value matches a 729 * search term, or false otherwise. 730 * 731 * @param {Object} state Blocks state. 732 * @param {(string|Object)} nameOrType Block name or type object. 733 * @param {string} searchTerm Search term by which to filter. 734 * 735 * @return {Object[]} Whether block type matches search term. 736 */ 737 738 function isMatchingSearchTerm(state, nameOrType, searchTerm) { 739 const blockType = getNormalizedBlockType(state, nameOrType); 740 const getNormalizedSearchTerm = Object(external_lodash_["flow"])([// Disregard diacritics. 741 // Input: "média" 742 external_lodash_["deburr"], // Lowercase. 743 // Input: "MEDIA" 744 term => term.toLowerCase(), // Strip leading and trailing whitespace. 745 // Input: " media " 746 term => term.trim()]); 747 const normalizedSearchTerm = getNormalizedSearchTerm(searchTerm); 748 const isSearchMatch = Object(external_lodash_["flow"])([getNormalizedSearchTerm, normalizedCandidate => Object(external_lodash_["includes"])(normalizedCandidate, normalizedSearchTerm)]); 749 return isSearchMatch(blockType.title) || Object(external_lodash_["some"])(blockType.keywords, isSearchMatch) || isSearchMatch(blockType.category); 750 } 751 /** 752 * Returns a boolean indicating if a block has child blocks or not. 753 * 754 * @param {Object} state Data state. 755 * @param {string} blockName Block type name. 756 * 757 * @return {boolean} True if a block contains child blocks and false otherwise. 758 */ 759 760 const hasChildBlocks = (state, blockName) => { 761 return getChildBlockNames(state, blockName).length > 0; 762 }; 763 /** 764 * Returns a boolean indicating if a block has at least one child block with inserter support. 765 * 766 * @param {Object} state Data state. 767 * @param {string} blockName Block type name. 768 * 769 * @return {boolean} True if a block contains at least one child blocks with inserter support 770 * and false otherwise. 771 */ 772 773 const hasChildBlocksWithInserterSupport = (state, blockName) => { 774 return Object(external_lodash_["some"])(getChildBlockNames(state, blockName), childBlockName => { 775 return hasBlockSupport(state, childBlockName, 'inserter', true); 776 }); 777 }; 778 779 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/actions.js 780 /** 781 * External dependencies 782 */ 783 784 /** @typedef {import('../api/registration').WPBlockVariation} WPBlockVariation */ 785 786 /** 787 * Returns an action object used in signalling that block types have been added. 788 * 789 * @param {Array|Object} blockTypes Block types received. 790 * 791 * @return {Object} Action object. 792 */ 793 794 function addBlockTypes(blockTypes) { 795 return { 796 type: 'ADD_BLOCK_TYPES', 797 blockTypes: Object(external_lodash_["castArray"])(blockTypes) 798 }; 799 } 800 /** 801 * Returns an action object used to remove a registered block type. 802 * 803 * @param {string|Array} names Block name. 804 * 805 * @return {Object} Action object. 806 */ 807 808 function removeBlockTypes(names) { 809 return { 810 type: 'REMOVE_BLOCK_TYPES', 811 names: Object(external_lodash_["castArray"])(names) 812 }; 813 } 814 /** 815 * Returns an action object used in signalling that new block styles have been added. 816 * 817 * @param {string} blockName Block name. 818 * @param {Array|Object} styles Block styles. 819 * 820 * @return {Object} Action object. 821 */ 822 823 function addBlockStyles(blockName, styles) { 824 return { 825 type: 'ADD_BLOCK_STYLES', 826 styles: Object(external_lodash_["castArray"])(styles), 827 blockName 828 }; 829 } 830 /** 831 * Returns an action object used in signalling that block styles have been removed. 832 * 833 * @param {string} blockName Block name. 834 * @param {Array|string} styleNames Block style names. 835 * 836 * @return {Object} Action object. 837 */ 838 839 function removeBlockStyles(blockName, styleNames) { 840 return { 841 type: 'REMOVE_BLOCK_STYLES', 842 styleNames: Object(external_lodash_["castArray"])(styleNames), 843 blockName 844 }; 845 } 846 /** 847 * Returns an action object used in signalling that new block variations have been added. 848 * 849 * @param {string} blockName Block name. 850 * @param {WPBlockVariation|WPBlockVariation[]} variations Block variations. 851 * 852 * @return {Object} Action object. 853 */ 854 855 function addBlockVariations(blockName, variations) { 856 return { 857 type: 'ADD_BLOCK_VARIATIONS', 858 variations: Object(external_lodash_["castArray"])(variations), 859 blockName 860 }; 861 } 862 /** 863 * Returns an action object used in signalling that block variations have been removed. 864 * 865 * @param {string} blockName Block name. 866 * @param {string|string[]} variationNames Block variation names. 867 * 868 * @return {Object} Action object. 869 */ 870 871 function removeBlockVariations(blockName, variationNames) { 872 return { 873 type: 'REMOVE_BLOCK_VARIATIONS', 874 variationNames: Object(external_lodash_["castArray"])(variationNames), 875 blockName 876 }; 877 } 878 /** 879 * Returns an action object used to set the default block name. 880 * 881 * @param {string} name Block name. 882 * 883 * @return {Object} Action object. 884 */ 885 886 function setDefaultBlockName(name) { 887 return { 888 type: 'SET_DEFAULT_BLOCK_NAME', 889 name 890 }; 891 } 892 /** 893 * Returns an action object used to set the name of the block used as a fallback 894 * for non-block content. 895 * 896 * @param {string} name Block name. 897 * 898 * @return {Object} Action object. 899 */ 900 901 function setFreeformFallbackBlockName(name) { 902 return { 903 type: 'SET_FREEFORM_FALLBACK_BLOCK_NAME', 904 name 905 }; 906 } 907 /** 908 * Returns an action object used to set the name of the block used as a fallback 909 * for unregistered blocks. 910 * 911 * @param {string} name Block name. 912 * 913 * @return {Object} Action object. 914 */ 915 916 function setUnregisteredFallbackBlockName(name) { 917 return { 918 type: 'SET_UNREGISTERED_FALLBACK_BLOCK_NAME', 919 name 920 }; 921 } 922 /** 923 * Returns an action object used to set the name of the block used 924 * when grouping other blocks 925 * eg: in "Group/Ungroup" interactions 926 * 927 * @param {string} name Block name. 928 * 929 * @return {Object} Action object. 930 */ 931 932 function setGroupingBlockName(name) { 933 return { 934 type: 'SET_GROUPING_BLOCK_NAME', 935 name 936 }; 937 } 938 /** 939 * Returns an action object used to set block categories. 940 * 941 * @param {Object[]} categories Block categories. 942 * 943 * @return {Object} Action object. 944 */ 945 946 function setCategories(categories) { 947 return { 948 type: 'SET_CATEGORIES', 949 categories 950 }; 951 } 952 /** 953 * Returns an action object used to update a category. 954 * 955 * @param {string} slug Block category slug. 956 * @param {Object} category Object containing the category properties that should be updated. 957 * 958 * @return {Object} Action object. 959 */ 960 961 function updateCategory(slug, category) { 962 return { 963 type: 'UPDATE_CATEGORY', 964 slug, 965 category 966 }; 967 } 968 /** 969 * Returns an action object used to add block collections 970 * 971 * @param {string} namespace The namespace of the blocks to put in the collection 972 * @param {string} title The title to display in the block inserter 973 * @param {Object} icon (optional) The icon to display in the block inserter 974 * 975 * @return {Object} Action object. 976 */ 977 978 function addBlockCollection(namespace, title, icon) { 979 return { 980 type: 'ADD_BLOCK_COLLECTION', 981 namespace, 982 title, 983 icon 984 }; 985 } 986 /** 987 * Returns an action object used to remove block collections 988 * 989 * @param {string} namespace The namespace of the blocks to put in the collection 990 * 991 * @return {Object} Action object. 992 */ 993 994 function removeBlockCollection(namespace) { 995 return { 996 type: 'REMOVE_BLOCK_COLLECTION', 997 namespace 998 }; 999 } 1000 1001 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/constants.js 1002 const STORE_NAME = 'core/blocks'; 1003 1004 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/index.js 1005 /** 1006 * WordPress dependencies 1007 */ 1008 1009 /** 1010 * Internal dependencies 1011 */ 1012 1013 1014 1015 1016 1017 /** 1018 * Store definition for the blocks namespace. 1019 * 1020 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore 1021 * 1022 * @type {Object} 1023 */ 1024 1025 const store = Object(external_wp_data_["createReduxStore"])(STORE_NAME, { 1026 reducer: reducer, 1027 selectors: selectors_namespaceObject, 1028 actions: actions_namespaceObject 1029 }); 1030 Object(external_wp_data_["register"])(store); 1031 1032 // EXTERNAL MODULE: ./node_modules/uuid/dist/esm-browser/v4.js + 4 modules 1033 var v4 = __webpack_require__("7Cbv"); 1034 1035 // EXTERNAL MODULE: external ["wp","hooks"] 1036 var external_wp_hooks_ = __webpack_require__("g56x"); 1037 1038 // EXTERNAL MODULE: external ["wp","deprecated"] 1039 var external_wp_deprecated_ = __webpack_require__("NMb1"); 1040 var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_); 1041 1042 // EXTERNAL MODULE: ./node_modules/@wordpress/icons/build-module/library/block-default.js 1043 var block_default = __webpack_require__("//Lo"); 1044 1045 // EXTERNAL MODULE: ./node_modules/tinycolor2/tinycolor.js 1046 var tinycolor = __webpack_require__("Zss7"); 1047 var tinycolor_default = /*#__PURE__*/__webpack_require__.n(tinycolor); 1048 1049 // EXTERNAL MODULE: external ["wp","element"] 1050 var external_wp_element_ = __webpack_require__("GRId"); 1051 1052 // EXTERNAL MODULE: external ["wp","dom"] 1053 var external_wp_dom_ = __webpack_require__("1CF3"); 1054 1055 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/utils.js 1056 /** 1057 * External dependencies 1058 */ 1059 1060 1061 /** 1062 * WordPress dependencies 1063 */ 1064 1065 1066 1067 1068 /** 1069 * Internal dependencies 1070 */ 1071 1072 1073 1074 /** 1075 * Array of icon colors containing a color to be used if the icon color 1076 * was not explicitly set but the icon background color was. 1077 * 1078 * @type {Object} 1079 */ 1080 1081 const ICON_COLORS = ['#191e23', '#f8f9f9']; 1082 /** 1083 * Determines whether the block is a default block 1084 * and its attributes are equal to the default attributes 1085 * which means the block is unmodified. 1086 * 1087 * @param {WPBlock} block Block Object 1088 * 1089 * @return {boolean} Whether the block is an unmodified default block 1090 */ 1091 1092 function isUnmodifiedDefaultBlock(block) { 1093 const defaultBlockName = registration_getDefaultBlockName(); 1094 1095 if (block.name !== defaultBlockName) { 1096 return false; 1097 } // Cache a created default block if no cache exists or the default block 1098 // name changed. 1099 1100 1101 if (!isUnmodifiedDefaultBlock.block || isUnmodifiedDefaultBlock.block.name !== defaultBlockName) { 1102 isUnmodifiedDefaultBlock.block = createBlock(defaultBlockName); 1103 } 1104 1105 const newDefaultBlock = isUnmodifiedDefaultBlock.block; 1106 const blockType = registration_getBlockType(defaultBlockName); 1107 return Object(external_lodash_["every"])(blockType.attributes, (value, key) => newDefaultBlock.attributes[key] === block.attributes[key]); 1108 } 1109 /** 1110 * Function that checks if the parameter is a valid icon. 1111 * 1112 * @param {*} icon Parameter to be checked. 1113 * 1114 * @return {boolean} True if the parameter is a valid icon and false otherwise. 1115 */ 1116 1117 function isValidIcon(icon) { 1118 return !!icon && (Object(external_lodash_["isString"])(icon) || Object(external_wp_element_["isValidElement"])(icon) || Object(external_lodash_["isFunction"])(icon) || icon instanceof external_wp_element_["Component"]); 1119 } 1120 /** 1121 * Function that receives an icon as set by the blocks during the registration 1122 * and returns a new icon object that is normalized so we can rely on just on possible icon structure 1123 * in the codebase. 1124 * 1125 * @param {WPBlockTypeIconRender} icon Render behavior of a block type icon; 1126 * one of a Dashicon slug, an element, or a 1127 * component. 1128 * 1129 * @return {WPBlockTypeIconDescriptor} Object describing the icon. 1130 */ 1131 1132 function normalizeIconObject(icon) { 1133 if (isValidIcon(icon)) { 1134 return { 1135 src: icon 1136 }; 1137 } 1138 1139 if (Object(external_lodash_["has"])(icon, ['background'])) { 1140 const tinyBgColor = tinycolor_default()(icon.background); 1141 return { ...icon, 1142 foreground: icon.foreground ? icon.foreground : Object(tinycolor["mostReadable"])(tinyBgColor, ICON_COLORS, { 1143 includeFallbackColors: true, 1144 level: 'AA', 1145 size: 'large' 1146 }).toHexString(), 1147 shadowColor: tinyBgColor.setAlpha(0.3).toRgbString() 1148 }; 1149 } 1150 1151 return icon; 1152 } 1153 /** 1154 * Normalizes block type passed as param. When string is passed then 1155 * it converts it to the matching block type object. 1156 * It passes the original object otherwise. 1157 * 1158 * @param {string|Object} blockTypeOrName Block type or name. 1159 * 1160 * @return {?Object} Block type. 1161 */ 1162 1163 function normalizeBlockType(blockTypeOrName) { 1164 if (Object(external_lodash_["isString"])(blockTypeOrName)) { 1165 return registration_getBlockType(blockTypeOrName); 1166 } 1167 1168 return blockTypeOrName; 1169 } 1170 /** 1171 * Get the label for the block, usually this is either the block title, 1172 * or the value of the block's `label` function when that's specified. 1173 * 1174 * @param {Object} blockType The block type. 1175 * @param {Object} attributes The values of the block's attributes. 1176 * @param {Object} context The intended use for the label. 1177 * 1178 * @return {string} The block label. 1179 */ 1180 1181 function getBlockLabel(blockType, attributes, context = 'visual') { 1182 const { 1183 __experimentalLabel: getLabel, 1184 title 1185 } = blockType; 1186 const label = getLabel && getLabel(attributes, { 1187 context 1188 }); 1189 1190 if (!label) { 1191 return title; 1192 } // Strip any HTML (i.e. RichText formatting) before returning. 1193 1194 1195 return Object(external_wp_dom_["__unstableStripHTML"])(label); 1196 } 1197 /** 1198 * Get a label for the block for use by screenreaders, this is more descriptive 1199 * than the visual label and includes the block title and the value of the 1200 * `getLabel` function if it's specified. 1201 * 1202 * @param {Object} blockType The block type. 1203 * @param {Object} attributes The values of the block's attributes. 1204 * @param {?number} position The position of the block in the block list. 1205 * @param {string} [direction='vertical'] The direction of the block layout. 1206 * 1207 * @return {string} The block label. 1208 */ 1209 1210 function getAccessibleBlockLabel(blockType, attributes, position, direction = 'vertical') { 1211 // `title` is already localized, `label` is a user-supplied value. 1212 const { 1213 title 1214 } = blockType; 1215 const label = getBlockLabel(blockType, attributes, 'accessibility'); 1216 const hasPosition = position !== undefined; // getBlockLabel returns the block title as a fallback when there's no label, 1217 // if it did return the title, this function needs to avoid adding the 1218 // title twice within the accessible label. Use this `hasLabel` boolean to 1219 // handle that. 1220 1221 const hasLabel = label && label !== title; 1222 1223 if (hasPosition && direction === 'vertical') { 1224 if (hasLabel) { 1225 return Object(external_wp_i18n_["sprintf"])( 1226 /* translators: accessibility text. 1: The block title. 2: The block row number. 3: The block label.. */ 1227 Object(external_wp_i18n_["__"])('%1$s Block. Row %2$d. %3$s'), title, position, label); 1228 } 1229 1230 return Object(external_wp_i18n_["sprintf"])( 1231 /* translators: accessibility text. 1: The block title. 2: The block row number. */ 1232 Object(external_wp_i18n_["__"])('%1$s Block. Row %2$d'), title, position); 1233 } else if (hasPosition && direction === 'horizontal') { 1234 if (hasLabel) { 1235 return Object(external_wp_i18n_["sprintf"])( 1236 /* translators: accessibility text. 1: The block title. 2: The block column number. 3: The block label.. */ 1237 Object(external_wp_i18n_["__"])('%1$s Block. Column %2$d. %3$s'), title, position, label); 1238 } 1239 1240 return Object(external_wp_i18n_["sprintf"])( 1241 /* translators: accessibility text. 1: The block title. 2: The block column number. */ 1242 Object(external_wp_i18n_["__"])('%1$s Block. Column %2$d'), title, position); 1243 } 1244 1245 if (hasLabel) { 1246 return Object(external_wp_i18n_["sprintf"])( 1247 /* translators: accessibility text. %1: The block title. %2: The block label. */ 1248 Object(external_wp_i18n_["__"])('%1$s Block. %2$s'), title, label); 1249 } 1250 1251 return Object(external_wp_i18n_["sprintf"])( 1252 /* translators: accessibility text. %s: The block title. */ 1253 Object(external_wp_i18n_["__"])('%s Block'), title); 1254 } 1255 /** 1256 * Ensure attributes contains only values defined by block type, and merge 1257 * default values for missing attributes. 1258 * 1259 * @param {string} name The block's name. 1260 * @param {Object} attributes The block's attributes. 1261 * @return {Object} The sanitized attributes. 1262 */ 1263 1264 function __experimentalSanitizeBlockAttributes(name, attributes) { 1265 // Get the type definition associated with a registered block. 1266 const blockType = registration_getBlockType(name); 1267 1268 if (undefined === blockType) { 1269 throw new Error(`Block type '$name}' is not registered.`); 1270 } 1271 1272 return Object(external_lodash_["reduce"])(blockType.attributes, (accumulator, schema, key) => { 1273 const value = attributes[key]; 1274 1275 if (undefined !== value) { 1276 accumulator[key] = value; 1277 } else if (schema.hasOwnProperty('default')) { 1278 accumulator[key] = schema.default; 1279 } 1280 1281 if (['node', 'children'].indexOf(schema.source) !== -1) { 1282 // Ensure value passed is always an array, which we're expecting in 1283 // the RichText component to handle the deprecated value. 1284 if (typeof accumulator[key] === 'string') { 1285 accumulator[key] = [accumulator[key]]; 1286 } else if (!Array.isArray(accumulator[key])) { 1287 accumulator[key] = []; 1288 } 1289 } 1290 1291 return accumulator; 1292 }, {}); 1293 } 1294 /** 1295 * Filter block attributes by `role` and return their names. 1296 * 1297 * @param {string} name Block attribute's name. 1298 * @param {string} role The role of a block attribute. 1299 * 1300 * @return {string[]} The attribute names that have the provided role. 1301 */ 1302 1303 function __experimentalGetBlockAttributesNamesByRole(name, role) { 1304 var _getBlockType; 1305 1306 const attributes = (_getBlockType = registration_getBlockType(name)) === null || _getBlockType === void 0 ? void 0 : _getBlockType.attributes; 1307 if (!attributes) return []; 1308 const attributesNames = Object.keys(attributes); 1309 if (!role) return attributesNames; 1310 return attributesNames.filter(attributeName => { 1311 var _attributes$attribute; 1312 1313 return ((_attributes$attribute = attributes[attributeName]) === null || _attributes$attribute === void 0 ? void 0 : _attributes$attribute.__experimentalRole) === role; 1314 }); 1315 } 1316 1317 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/constants.js 1318 /** 1319 * Array of valid keys in a block type settings deprecation object. 1320 * 1321 * @type {string[]} 1322 */ 1323 const DEPRECATED_ENTRY_KEYS = ['attributes', 'supports', 'save', 'migrate', 'isEligible', 'apiVersion']; 1324 const __EXPERIMENTAL_STYLE_PROPERTY = { 1325 //kept for back-compatibility purposes. 1326 '--wp--style--color--link': { 1327 value: ['color', 'link'], 1328 support: ['color', 'link'] 1329 }, 1330 background: { 1331 value: ['color', 'gradient'], 1332 support: ['color', 'gradients'] 1333 }, 1334 backgroundColor: { 1335 value: ['color', 'background'], 1336 support: ['color'] 1337 }, 1338 borderColor: { 1339 value: ['border', 'color'], 1340 support: ['__experimentalBorder', 'color'] 1341 }, 1342 borderRadius: { 1343 value: ['border', 'radius'], 1344 support: ['__experimentalBorder', 'radius'] 1345 }, 1346 borderStyle: { 1347 value: ['border', 'style'], 1348 support: ['__experimentalBorder', 'style'] 1349 }, 1350 borderWidth: { 1351 value: ['border', 'width'], 1352 support: ['__experimentalBorder', 'width'] 1353 }, 1354 color: { 1355 value: ['color', 'text'], 1356 support: ['color'] 1357 }, 1358 linkColor: { 1359 value: ['elements', 'link', 'color', 'text'], 1360 support: ['color', 'link'] 1361 }, 1362 fontFamily: { 1363 value: ['typography', 'fontFamily'], 1364 support: ['typography', '__experimentalFontFamily'] 1365 }, 1366 fontSize: { 1367 value: ['typography', 'fontSize'], 1368 support: ['typography', 'fontSize'] 1369 }, 1370 fontStyle: { 1371 value: ['typography', 'fontStyle'], 1372 support: ['typography', '__experimentalFontStyle'] 1373 }, 1374 fontWeight: { 1375 value: ['typography', 'fontWeight'], 1376 support: ['typography', '__experimentalFontWeight'] 1377 }, 1378 lineHeight: { 1379 value: ['typography', 'lineHeight'], 1380 support: ['typography', 'lineHeight'] 1381 }, 1382 margin: { 1383 value: ['spacing', 'margin'], 1384 support: ['spacing', 'margin'], 1385 properties: ['top', 'right', 'bottom', 'left'] 1386 }, 1387 padding: { 1388 value: ['spacing', 'padding'], 1389 support: ['spacing', 'padding'], 1390 properties: ['top', 'right', 'bottom', 'left'] 1391 }, 1392 textDecoration: { 1393 value: ['typography', 'textDecoration'], 1394 support: ['typography', '__experimentalTextDecoration'] 1395 }, 1396 textTransform: { 1397 value: ['typography', 'textTransform'], 1398 support: ['typography', '__experimentalTextTransform'] 1399 } 1400 }; 1401 const __EXPERIMENTAL_ELEMENTS = { 1402 link: 'a', 1403 h1: 'h1', 1404 h2: 'h2', 1405 h3: 'h3', 1406 h4: 'h4', 1407 h5: 'h5', 1408 h6: 'h6' 1409 }; 1410 1411 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/registration.js 1412 /* eslint no-console: [ 'error', { allow: [ 'error', 'warn' ] } ] */ 1413 1414 /** 1415 * External dependencies 1416 */ 1417 1418 /** 1419 * WordPress dependencies 1420 */ 1421 1422 1423 1424 1425 1426 1427 /** 1428 * Internal dependencies 1429 */ 1430 1431 const i18nBlockSchema = { 1432 title: "block title", 1433 description: "block description", 1434 keywords: ["block keyword"], 1435 styles: [{ 1436 label: "block style label" 1437 }], 1438 variations: [{ 1439 title: "block variation title", 1440 description: "block variation description", 1441 keywords: ["block variation keyword"] 1442 }] 1443 }; 1444 1445 1446 1447 /** 1448 * An icon type definition. One of a Dashicon slug, an element, 1449 * or a component. 1450 * 1451 * @typedef {(string|WPElement|WPComponent)} WPIcon 1452 * 1453 * @see https://developer.wordpress.org/resource/dashicons/ 1454 */ 1455 1456 /** 1457 * Render behavior of a block type icon; one of a Dashicon slug, an element, 1458 * or a component. 1459 * 1460 * @typedef {WPIcon} WPBlockTypeIconRender 1461 */ 1462 1463 /** 1464 * An object describing a normalized block type icon. 1465 * 1466 * @typedef {Object} WPBlockTypeIconDescriptor 1467 * 1468 * @property {WPBlockTypeIconRender} src Render behavior of the icon, 1469 * one of a Dashicon slug, an 1470 * element, or a component. 1471 * @property {string} background Optimal background hex string 1472 * color when displaying icon. 1473 * @property {string} foreground Optimal foreground hex string 1474 * color when displaying icon. 1475 * @property {string} shadowColor Optimal shadow hex string 1476 * color when displaying icon. 1477 */ 1478 1479 /** 1480 * Value to use to render the icon for a block type in an editor interface, 1481 * either a Dashicon slug, an element, a component, or an object describing 1482 * the icon. 1483 * 1484 * @typedef {(WPBlockTypeIconDescriptor|WPBlockTypeIconRender)} WPBlockTypeIcon 1485 */ 1486 1487 /** 1488 * Named block variation scopes. 1489 * 1490 * @typedef {'block'|'inserter'|'transform'} WPBlockVariationScope 1491 */ 1492 1493 /** 1494 * An object describing a variation defined for the block type. 1495 * 1496 * @typedef {Object} WPBlockVariation 1497 * 1498 * @property {string} name The unique and machine-readable name. 1499 * @property {string} title A human-readable variation title. 1500 * @property {string} [description] A detailed variation description. 1501 * @property {string} [category] Block type category classification, 1502 * used in search interfaces to arrange 1503 * block types by category. 1504 * @property {WPIcon} [icon] An icon helping to visualize the variation. 1505 * @property {boolean} [isDefault] Indicates whether the current variation is 1506 * the default one. Defaults to `false`. 1507 * @property {Object} [attributes] Values which override block attributes. 1508 * @property {Array[]} [innerBlocks] Initial configuration of nested blocks. 1509 * @property {Object} [example] Example provides structured data for 1510 * the block preview. You can set to 1511 * `undefined` to disable the preview shown 1512 * for the block type. 1513 * @property {WPBlockVariationScope[]} [scope] The list of scopes where the variation 1514 * is applicable. When not provided, it 1515 * assumes all available scopes. 1516 * @property {string[]} [keywords] An array of terms (which can be translated) 1517 * that help users discover the variation 1518 * while searching. 1519 * @property {Function|string[]} [isActive] This can be a function or an array of block attributes. 1520 * Function that accepts a block's attributes and the 1521 * variation's attributes and determines if a variation is active. 1522 * This function doesn't try to find a match dynamically based 1523 * on all block's attributes, as in many cases some attributes are irrelevant. 1524 * An example would be for `embed` block where we only care 1525 * about `providerNameSlug` attribute's value. 1526 * We can also use a `string[]` to tell which attributes 1527 * should be compared as a shorthand. Each attributes will 1528 * be matched and the variation will be active if all of them are matching. 1529 */ 1530 1531 /** 1532 * Defined behavior of a block type. 1533 * 1534 * @typedef {Object} WPBlock 1535 * 1536 * @property {string} name Block type's namespaced name. 1537 * @property {string} title Human-readable block type label. 1538 * @property {string} [description] A detailed block type description. 1539 * @property {string} [category] Block type category classification, 1540 * used in search interfaces to arrange 1541 * block types by category. 1542 * @property {WPBlockTypeIcon} [icon] Block type icon. 1543 * @property {string[]} [keywords] Additional keywords to produce block 1544 * type as result in search interfaces. 1545 * @property {Object} [attributes] Block type attributes. 1546 * @property {WPComponent} [save] Optional component describing 1547 * serialized markup structure of a 1548 * block type. 1549 * @property {WPComponent} edit Component rendering an element to 1550 * manipulate the attributes of a block 1551 * in the context of an editor. 1552 * @property {WPBlockVariation[]} [variations] The list of block variations. 1553 * @property {Object} [example] Example provides structured data for 1554 * the block preview. When not defined 1555 * then no preview is shown. 1556 */ 1557 1558 /** 1559 * Mapping of legacy category slugs to their latest normal values, used to 1560 * accommodate updates of the default set of block categories. 1561 * 1562 * @type {Record<string,string>} 1563 */ 1564 1565 const LEGACY_CATEGORY_MAPPING = { 1566 common: 'text', 1567 formatting: 'text', 1568 layout: 'design' 1569 }; 1570 const serverSideBlockDefinitions = {}; 1571 /** 1572 * Sets the server side block definition of blocks. 1573 * 1574 * @param {Object} definitions Server-side block definitions 1575 */ 1576 // eslint-disable-next-line camelcase 1577 1578 function unstable__bootstrapServerSideBlockDefinitions(definitions) { 1579 for (const blockName of Object.keys(definitions)) { 1580 // Don't overwrite if already set. It covers the case when metadata 1581 // was initialized from the server. 1582 if (serverSideBlockDefinitions[blockName]) { 1583 // We still need to polyfill `apiVersion` for WordPress version 1584 // lower than 5.7. If it isn't present in the definition shared 1585 // from the server, we try to fallback to the definition passed. 1586 // @see https://github.com/WordPress/gutenberg/pull/29279 1587 if (serverSideBlockDefinitions[blockName].apiVersion === undefined && definitions[blockName].apiVersion) { 1588 serverSideBlockDefinitions[blockName].apiVersion = definitions[blockName].apiVersion; 1589 } 1590 1591 continue; 1592 } 1593 1594 serverSideBlockDefinitions[blockName] = Object(external_lodash_["mapKeys"])(Object(external_lodash_["pickBy"])(definitions[blockName], value => !Object(external_lodash_["isNil"])(value)), (value, key) => Object(external_lodash_["camelCase"])(key)); 1595 } 1596 } 1597 /** 1598 * Gets block settings from metadata loaded from `block.json` file. 1599 * 1600 * @param {Object} metadata Block metadata loaded from `block.json`. 1601 * @param {string} metadata.textdomain Textdomain to use with translations. 1602 * 1603 * @return {Object} Block settings. 1604 */ 1605 1606 function getBlockSettingsFromMetadata({ 1607 textdomain, 1608 ...metadata 1609 }) { 1610 const allowedFields = ['apiVersion', 'title', 'category', 'parent', 'icon', 'description', 'keywords', 'attributes', 'providesContext', 'usesContext', 'supports', 'styles', 'example', 'variations']; 1611 const settings = Object(external_lodash_["pick"])(metadata, allowedFields); 1612 1613 if (textdomain) { 1614 Object.keys(i18nBlockSchema).forEach(key => { 1615 if (!settings[key]) { 1616 return; 1617 } 1618 1619 settings[key] = translateBlockSettingUsingI18nSchema(i18nBlockSchema[key], settings[key], textdomain); 1620 }); 1621 } 1622 1623 return settings; 1624 } 1625 /** 1626 * Registers a new block provided a unique name and an object defining its 1627 * behavior. Once registered, the block is made available as an option to any 1628 * editor interface where blocks are implemented. 1629 * 1630 * @param {string|Object} blockNameOrMetadata Block type name or its metadata. 1631 * @param {Object} settings Block settings. 1632 * 1633 * @return {?WPBlock} The block, if it has been successfully registered; 1634 * otherwise `undefined`. 1635 */ 1636 1637 1638 function registerBlockType(blockNameOrMetadata, settings) { 1639 const name = Object(external_lodash_["isObject"])(blockNameOrMetadata) ? blockNameOrMetadata.name : blockNameOrMetadata; 1640 1641 if (typeof name !== 'string') { 1642 console.error('Block names must be strings.'); 1643 return; 1644 } 1645 1646 if (Object(external_lodash_["isObject"])(blockNameOrMetadata)) { 1647 unstable__bootstrapServerSideBlockDefinitions({ 1648 [name]: getBlockSettingsFromMetadata(blockNameOrMetadata) 1649 }); 1650 } 1651 1652 settings = { 1653 name, 1654 icon: block_default["a" /* default */], 1655 keywords: [], 1656 attributes: {}, 1657 providesContext: {}, 1658 usesContext: [], 1659 supports: {}, 1660 styles: [], 1661 save: () => null, 1662 ...(serverSideBlockDefinitions === null || serverSideBlockDefinitions === void 0 ? void 0 : serverSideBlockDefinitions[name]), 1663 ...settings 1664 }; 1665 1666 if (!/^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/.test(name)) { 1667 console.error('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'); 1668 return; 1669 } 1670 1671 if (Object(external_wp_data_["select"])(store).getBlockType(name)) { 1672 console.error('Block "' + name + '" is already registered.'); 1673 return; 1674 } 1675 1676 const preFilterSettings = { ...settings 1677 }; 1678 settings = Object(external_wp_hooks_["applyFilters"])('blocks.registerBlockType', settings, name); 1679 1680 if (settings.deprecated) { 1681 settings.deprecated = settings.deprecated.map(deprecation => Object(external_lodash_["pick"])( // Only keep valid deprecation keys. 1682 Object(external_wp_hooks_["applyFilters"])('blocks.registerBlockType', // Merge deprecation keys with pre-filter settings 1683 // so that filters that depend on specific keys being 1684 // present don't fail. 1685 { // Omit deprecation keys here so that deprecations 1686 // can opt out of specific keys like "supports". 1687 ...Object(external_lodash_["omit"])(preFilterSettings, DEPRECATED_ENTRY_KEYS), 1688 ...deprecation 1689 }, name), DEPRECATED_ENTRY_KEYS)); 1690 } 1691 1692 if (!Object(external_lodash_["isPlainObject"])(settings)) { 1693 console.error('Block settings must be a valid object.'); 1694 return; 1695 } 1696 1697 if (!Object(external_lodash_["isFunction"])(settings.save)) { 1698 console.error('The "save" property must be a valid function.'); 1699 return; 1700 } 1701 1702 if ('edit' in settings && !Object(external_lodash_["isFunction"])(settings.edit)) { 1703 console.error('The "edit" property must be a valid function.'); 1704 return; 1705 } // Canonicalize legacy categories to equivalent fallback. 1706 1707 1708 if (LEGACY_CATEGORY_MAPPING.hasOwnProperty(settings.category)) { 1709 settings.category = LEGACY_CATEGORY_MAPPING[settings.category]; 1710 } 1711 1712 if ('category' in settings && !Object(external_lodash_["some"])(Object(external_wp_data_["select"])(store).getCategories(), { 1713 slug: settings.category 1714 })) { 1715 console.warn('The block "' + name + '" is registered with an invalid category "' + settings.category + '".'); 1716 delete settings.category; 1717 } 1718 1719 if (!('title' in settings) || settings.title === '') { 1720 console.error('The block "' + name + '" must have a title.'); 1721 return; 1722 } 1723 1724 if (typeof settings.title !== 'string') { 1725 console.error('Block titles must be strings.'); 1726 return; 1727 } 1728 1729 settings.icon = normalizeIconObject(settings.icon); 1730 1731 if (!isValidIcon(settings.icon.src)) { 1732 console.error('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'); 1733 return; 1734 } 1735 1736 Object(external_wp_data_["dispatch"])(store).addBlockTypes(settings); 1737 return settings; 1738 } 1739 /** 1740 * Translates block settings provided with metadata using the i18n schema. 1741 * 1742 * @param {string|string[]|Object[]} i18nSchema I18n schema for the block setting. 1743 * @param {string|string[]|Object[]} settingValue Value for the block setting. 1744 * @param {string} textdomain Textdomain to use with translations. 1745 * 1746 * @return {string|string[]|Object[]} Translated setting. 1747 */ 1748 1749 function translateBlockSettingUsingI18nSchema(i18nSchema, settingValue, textdomain) { 1750 if (Object(external_lodash_["isString"])(i18nSchema) && Object(external_lodash_["isString"])(settingValue)) { 1751 // eslint-disable-next-line @wordpress/i18n-no-variables, @wordpress/i18n-text-domain 1752 return Object(external_wp_i18n_["_x"])(settingValue, i18nSchema, textdomain); 1753 } 1754 1755 if (Object(external_lodash_["isArray"])(i18nSchema) && !Object(external_lodash_["isEmpty"])(i18nSchema) && Object(external_lodash_["isArray"])(settingValue)) { 1756 return settingValue.map(value => translateBlockSettingUsingI18nSchema(i18nSchema[0], value, textdomain)); 1757 } 1758 1759 if (Object(external_lodash_["isObject"])(i18nSchema) && !Object(external_lodash_["isEmpty"])(i18nSchema) && Object(external_lodash_["isObject"])(settingValue)) { 1760 return Object.keys(settingValue).reduce((accumulator, key) => { 1761 if (!i18nSchema[key]) { 1762 accumulator[key] = settingValue[key]; 1763 return accumulator; 1764 } 1765 1766 accumulator[key] = translateBlockSettingUsingI18nSchema(i18nSchema[key], settingValue[key], textdomain); 1767 return accumulator; 1768 }, {}); 1769 } 1770 1771 return settingValue; 1772 } 1773 /** 1774 * Registers a new block provided from metadata stored in `block.json` file. 1775 * 1776 * @deprecated Use `registerBlockType` instead. 1777 * 1778 * @param {Object} metadata Block metadata loaded from `block.json`. 1779 * @param {Object} additionalSettings Additional block settings. 1780 * 1781 * @return {?WPBlock} The block, if it has been successfully registered; 1782 * otherwise `undefined`. 1783 */ 1784 1785 1786 function registerBlockTypeFromMetadata(metadata, additionalSettings) { 1787 external_wp_deprecated_default()('wp.blocks.registerBlockTypeFromMetadata', { 1788 since: '10.7', 1789 plugin: 'Gutenberg', 1790 alternative: 'wp.blocks.registerBlockType', 1791 version: '11.0' 1792 }); 1793 return registerBlockType(metadata, additionalSettings); 1794 } 1795 /** 1796 * Registers a new block collection to group blocks in the same namespace in the inserter. 1797 * 1798 * @param {string} namespace The namespace to group blocks by in the inserter; corresponds to the block namespace. 1799 * @param {Object} settings The block collection settings. 1800 * @param {string} settings.title The title to display in the block inserter. 1801 * @param {Object} [settings.icon] The icon to display in the block inserter. 1802 */ 1803 1804 function registerBlockCollection(namespace, { 1805 title, 1806 icon 1807 }) { 1808 Object(external_wp_data_["dispatch"])(store).addBlockCollection(namespace, title, icon); 1809 } 1810 /** 1811 * Unregisters a block collection 1812 * 1813 * @param {string} namespace The namespace to group blocks by in the inserter; corresponds to the block namespace 1814 * 1815 */ 1816 1817 function unregisterBlockCollection(namespace) { 1818 Object(external_wp_data_["dispatch"])(store).removeBlockCollection(namespace); 1819 } 1820 /** 1821 * Unregisters a block. 1822 * 1823 * @param {string} name Block name. 1824 * 1825 * @return {?WPBlock} The previous block value, if it has been successfully 1826 * unregistered; otherwise `undefined`. 1827 */ 1828 1829 function unregisterBlockType(name) { 1830 const oldBlock = Object(external_wp_data_["select"])(store).getBlockType(name); 1831 1832 if (!oldBlock) { 1833 console.error('Block "' + name + '" is not registered.'); 1834 return; 1835 } 1836 1837 Object(external_wp_data_["dispatch"])(store).removeBlockTypes(name); 1838 return oldBlock; 1839 } 1840 /** 1841 * Assigns name of block for handling non-block content. 1842 * 1843 * @param {string} blockName Block name. 1844 */ 1845 1846 function setFreeformContentHandlerName(blockName) { 1847 Object(external_wp_data_["dispatch"])(store).setFreeformFallbackBlockName(blockName); 1848 } 1849 /** 1850 * Retrieves name of block handling non-block content, or undefined if no 1851 * handler has been defined. 1852 * 1853 * @return {?string} Block name. 1854 */ 1855 1856 function getFreeformContentHandlerName() { 1857 return Object(external_wp_data_["select"])(store).getFreeformFallbackBlockName(); 1858 } 1859 /** 1860 * Retrieves name of block used for handling grouping interactions. 1861 * 1862 * @return {?string} Block name. 1863 */ 1864 1865 function registration_getGroupingBlockName() { 1866 return Object(external_wp_data_["select"])(store).getGroupingBlockName(); 1867 } 1868 /** 1869 * Assigns name of block handling unregistered block types. 1870 * 1871 * @param {string} blockName Block name. 1872 */ 1873 1874 function setUnregisteredTypeHandlerName(blockName) { 1875 Object(external_wp_data_["dispatch"])(store).setUnregisteredFallbackBlockName(blockName); 1876 } 1877 /** 1878 * Retrieves name of block handling unregistered block types, or undefined if no 1879 * handler has been defined. 1880 * 1881 * @return {?string} Block name. 1882 */ 1883 1884 function getUnregisteredTypeHandlerName() { 1885 return Object(external_wp_data_["select"])(store).getUnregisteredFallbackBlockName(); 1886 } 1887 /** 1888 * Assigns the default block name. 1889 * 1890 * @param {string} name Block name. 1891 */ 1892 1893 function registration_setDefaultBlockName(name) { 1894 Object(external_wp_data_["dispatch"])(store).setDefaultBlockName(name); 1895 } 1896 /** 1897 * Assigns name of block for handling block grouping interactions. 1898 * 1899 * @param {string} name Block name. 1900 */ 1901 1902 function registration_setGroupingBlockName(name) { 1903 Object(external_wp_data_["dispatch"])(store).setGroupingBlockName(name); 1904 } 1905 /** 1906 * Retrieves the default block name. 1907 * 1908 * @return {?string} Block name. 1909 */ 1910 1911 function registration_getDefaultBlockName() { 1912 return Object(external_wp_data_["select"])(store).getDefaultBlockName(); 1913 } 1914 /** 1915 * Returns a registered block type. 1916 * 1917 * @param {string} name Block name. 1918 * 1919 * @return {?Object} Block type. 1920 */ 1921 1922 function registration_getBlockType(name) { 1923 return Object(external_wp_data_["select"])(store).getBlockType(name); 1924 } 1925 /** 1926 * Returns all registered blocks. 1927 * 1928 * @return {Array} Block settings. 1929 */ 1930 1931 function registration_getBlockTypes() { 1932 return Object(external_wp_data_["select"])(store).getBlockTypes(); 1933 } 1934 /** 1935 * Returns the block support value for a feature, if defined. 1936 * 1937 * @param {(string|Object)} nameOrType Block name or type object 1938 * @param {string} feature Feature to retrieve 1939 * @param {*} defaultSupports Default value to return if not 1940 * explicitly defined 1941 * 1942 * @return {?*} Block support value 1943 */ 1944 1945 function registration_getBlockSupport(nameOrType, feature, defaultSupports) { 1946 return Object(external_wp_data_["select"])(store).getBlockSupport(nameOrType, feature, defaultSupports); 1947 } 1948 /** 1949 * Returns true if the block defines support for a feature, or false otherwise. 1950 * 1951 * @param {(string|Object)} nameOrType Block name or type object. 1952 * @param {string} feature Feature to test. 1953 * @param {boolean} defaultSupports Whether feature is supported by 1954 * default if not explicitly defined. 1955 * 1956 * @return {boolean} Whether block supports feature. 1957 */ 1958 1959 function registration_hasBlockSupport(nameOrType, feature, defaultSupports) { 1960 return Object(external_wp_data_["select"])(store).hasBlockSupport(nameOrType, feature, defaultSupports); 1961 } 1962 /** 1963 * Determines whether or not the given block is a reusable block. This is a 1964 * special block type that is used to point to a global block stored via the 1965 * API. 1966 * 1967 * @param {Object} blockOrType Block or Block Type to test. 1968 * 1969 * @return {boolean} Whether the given block is a reusable block. 1970 */ 1971 1972 function isReusableBlock(blockOrType) { 1973 return blockOrType.name === 'core/block'; 1974 } 1975 /** 1976 * Determines whether or not the given block is a template part. This is a 1977 * special block type that allows composing a page template out of reusable 1978 * design elements. 1979 * 1980 * @param {Object} blockOrType Block or Block Type to test. 1981 * 1982 * @return {boolean} Whether the given block is a template part. 1983 */ 1984 1985 function isTemplatePart(blockOrType) { 1986 return blockOrType.name === 'core/template-part'; 1987 } 1988 /** 1989 * Returns an array with the child blocks of a given block. 1990 * 1991 * @param {string} blockName Name of block (example: “latest-posts”). 1992 * 1993 * @return {Array} Array of child block names. 1994 */ 1995 1996 const registration_getChildBlockNames = blockName => { 1997 return Object(external_wp_data_["select"])(store).getChildBlockNames(blockName); 1998 }; 1999 /** 2000 * Returns a boolean indicating if a block has child blocks or not. 2001 * 2002 * @param {string} blockName Name of block (example: “latest-posts”). 2003 * 2004 * @return {boolean} True if a block contains child blocks and false otherwise. 2005 */ 2006 2007 const registration_hasChildBlocks = blockName => { 2008 return Object(external_wp_data_["select"])(store).hasChildBlocks(blockName); 2009 }; 2010 /** 2011 * Returns a boolean indicating if a block has at least one child block with inserter support. 2012 * 2013 * @param {string} blockName Block type name. 2014 * 2015 * @return {boolean} True if a block contains at least one child blocks with inserter support 2016 * and false otherwise. 2017 */ 2018 2019 const registration_hasChildBlocksWithInserterSupport = blockName => { 2020 return Object(external_wp_data_["select"])(store).hasChildBlocksWithInserterSupport(blockName); 2021 }; 2022 /** 2023 * Registers a new block style variation for the given block. 2024 * 2025 * @param {string} blockName Name of block (example: “core/latest-posts”). 2026 * @param {Object} styleVariation Object containing `name` which is the class name applied to the block and `label` which identifies the variation to the user. 2027 */ 2028 2029 const registerBlockStyle = (blockName, styleVariation) => { 2030 Object(external_wp_data_["dispatch"])(store).addBlockStyles(blockName, styleVariation); 2031 }; 2032 /** 2033 * Unregisters a block style variation for the given block. 2034 * 2035 * @param {string} blockName Name of block (example: “core/latest-posts”). 2036 * @param {string} styleVariationName Name of class applied to the block. 2037 */ 2038 2039 const unregisterBlockStyle = (blockName, styleVariationName) => { 2040 Object(external_wp_data_["dispatch"])(store).removeBlockStyles(blockName, styleVariationName); 2041 }; 2042 /** 2043 * Returns an array with the variations of a given block type. 2044 * 2045 * @param {string} blockName Name of block (example: “core/columns”). 2046 * @param {WPBlockVariationScope} [scope] Block variation scope name. 2047 * 2048 * @return {(WPBlockVariation[]|void)} Block variations. 2049 */ 2050 2051 const registration_getBlockVariations = (blockName, scope) => { 2052 return Object(external_wp_data_["select"])(store).getBlockVariations(blockName, scope); 2053 }; 2054 /** 2055 * Registers a new block variation for the given block type. 2056 * 2057 * @param {string} blockName Name of the block (example: “core/columns”). 2058 * @param {WPBlockVariation} variation Object describing a block variation. 2059 */ 2060 2061 const registerBlockVariation = (blockName, variation) => { 2062 Object(external_wp_data_["dispatch"])(store).addBlockVariations(blockName, variation); 2063 }; 2064 /** 2065 * Unregisters a block variation defined for the given block type. 2066 * 2067 * @param {string} blockName Name of the block (example: “core/columns”). 2068 * @param {string} variationName Name of the variation defined for the block. 2069 */ 2070 2071 const unregisterBlockVariation = (blockName, variationName) => { 2072 Object(external_wp_data_["dispatch"])(store).removeBlockVariations(blockName, variationName); 2073 }; 2074 2075 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/factory.js 2076 /** 2077 * External dependencies 2078 */ 2079 2080 2081 /** 2082 * WordPress dependencies 2083 */ 2084 2085 2086 /** 2087 * Internal dependencies 2088 */ 2089 2090 2091 2092 /** 2093 * Returns a block object given its type and attributes. 2094 * 2095 * @param {string} name Block name. 2096 * @param {Object} attributes Block attributes. 2097 * @param {?Array} innerBlocks Nested blocks. 2098 * 2099 * @return {Object} Block object. 2100 */ 2101 2102 function createBlock(name, attributes = {}, innerBlocks = []) { 2103 const sanitizedAttributes = __experimentalSanitizeBlockAttributes(name, attributes); 2104 2105 const clientId = Object(v4["a" /* default */])(); // Blocks are stored with a unique ID, the assigned type name, the block 2106 // attributes, and their inner blocks. 2107 2108 return { 2109 clientId, 2110 name, 2111 isValid: true, 2112 attributes: sanitizedAttributes, 2113 innerBlocks 2114 }; 2115 } 2116 /** 2117 * Given an array of InnerBlocks templates or Block Objects, 2118 * returns an array of created Blocks from them. 2119 * It handles the case of having InnerBlocks as Blocks by 2120 * converting them to the proper format to continue recursively. 2121 * 2122 * @param {Array} innerBlocksOrTemplate Nested blocks or InnerBlocks templates. 2123 * 2124 * @return {Object[]} Array of Block objects. 2125 */ 2126 2127 function createBlocksFromInnerBlocksTemplate(innerBlocksOrTemplate = []) { 2128 return innerBlocksOrTemplate.map(innerBlock => { 2129 const innerBlockTemplate = Array.isArray(innerBlock) ? innerBlock : [innerBlock.name, innerBlock.attributes, innerBlock.innerBlocks]; 2130 const [name, attributes, innerBlocks = []] = innerBlockTemplate; 2131 return createBlock(name, attributes, createBlocksFromInnerBlocksTemplate(innerBlocks)); 2132 }); 2133 } 2134 /** 2135 * Given a block object, returns a copy of the block object while sanitizing its attributes, 2136 * optionally merging new attributes and/or replacing its inner blocks. 2137 * 2138 * @param {Object} block Block instance. 2139 * @param {Object} mergeAttributes Block attributes. 2140 * @param {?Array} newInnerBlocks Nested blocks. 2141 * 2142 * @return {Object} A cloned block. 2143 */ 2144 2145 function __experimentalCloneSanitizedBlock(block, mergeAttributes = {}, newInnerBlocks) { 2146 const clientId = Object(v4["a" /* default */])(); 2147 2148 const sanitizedAttributes = __experimentalSanitizeBlockAttributes(block.name, { ...block.attributes, 2149 ...mergeAttributes 2150 }); 2151 2152 return { ...block, 2153 clientId, 2154 attributes: sanitizedAttributes, 2155 innerBlocks: newInnerBlocks || block.innerBlocks.map(innerBlock => __experimentalCloneSanitizedBlock(innerBlock)) 2156 }; 2157 } 2158 /** 2159 * Given a block object, returns a copy of the block object, 2160 * optionally merging new attributes and/or replacing its inner blocks. 2161 * 2162 * @param {Object} block Block instance. 2163 * @param {Object} mergeAttributes Block attributes. 2164 * @param {?Array} newInnerBlocks Nested blocks. 2165 * 2166 * @return {Object} A cloned block. 2167 */ 2168 2169 function cloneBlock(block, mergeAttributes = {}, newInnerBlocks) { 2170 const clientId = Object(v4["a" /* default */])(); 2171 return { ...block, 2172 clientId, 2173 attributes: { ...block.attributes, 2174 ...mergeAttributes 2175 }, 2176 innerBlocks: newInnerBlocks || block.innerBlocks.map(innerBlock => cloneBlock(innerBlock)) 2177 }; 2178 } 2179 /** 2180 * Returns a boolean indicating whether a transform is possible based on 2181 * various bits of context. 2182 * 2183 * @param {Object} transform The transform object to validate. 2184 * @param {string} direction Is this a 'from' or 'to' transform. 2185 * @param {Array} blocks The blocks to transform from. 2186 * 2187 * @return {boolean} Is the transform possible? 2188 */ 2189 2190 const isPossibleTransformForSource = (transform, direction, blocks) => { 2191 if (Object(external_lodash_["isEmpty"])(blocks)) { 2192 return false; 2193 } // If multiple blocks are selected, only multi block transforms 2194 // or wildcard transforms are allowed. 2195 2196 2197 const isMultiBlock = blocks.length > 1; 2198 const firstBlockName = Object(external_lodash_["first"])(blocks).name; 2199 const isValidForMultiBlocks = isWildcardBlockTransform(transform) || !isMultiBlock || transform.isMultiBlock; 2200 2201 if (!isValidForMultiBlocks) { 2202 return false; 2203 } // Check non-wildcard transforms to ensure that transform is valid 2204 // for a block selection of multiple blocks of different types 2205 2206 2207 if (!isWildcardBlockTransform(transform) && !Object(external_lodash_["every"])(blocks, { 2208 name: firstBlockName 2209 })) { 2210 return false; 2211 } // Only consider 'block' type transforms as valid. 2212 2213 2214 const isBlockType = transform.type === 'block'; 2215 2216 if (!isBlockType) { 2217 return false; 2218 } // Check if the transform's block name matches the source block (or is a wildcard) 2219 // only if this is a transform 'from'. 2220 2221 2222 const sourceBlock = Object(external_lodash_["first"])(blocks); 2223 const hasMatchingName = direction !== 'from' || transform.blocks.indexOf(sourceBlock.name) !== -1 || isWildcardBlockTransform(transform); 2224 2225 if (!hasMatchingName) { 2226 return false; 2227 } // Don't allow single Grouping blocks to be transformed into 2228 // a Grouping block. 2229 2230 2231 if (!isMultiBlock && isContainerGroupBlock(sourceBlock.name) && isContainerGroupBlock(transform.blockName)) { 2232 return false; 2233 } // If the transform has a `isMatch` function specified, check that it returns true. 2234 2235 2236 if (Object(external_lodash_["isFunction"])(transform.isMatch)) { 2237 const attributes = transform.isMultiBlock ? blocks.map(block => block.attributes) : sourceBlock.attributes; 2238 2239 if (!transform.isMatch(attributes)) { 2240 return false; 2241 } 2242 } 2243 2244 if (transform.usingMobileTransformations && isWildcardBlockTransform(transform) && !isContainerGroupBlock(sourceBlock.name)) { 2245 return false; 2246 } 2247 2248 return true; 2249 }; 2250 /** 2251 * Returns block types that the 'blocks' can be transformed into, based on 2252 * 'from' transforms on other blocks. 2253 * 2254 * @param {Array} blocks The blocks to transform from. 2255 * 2256 * @return {Array} Block types that the blocks can be transformed into. 2257 */ 2258 2259 2260 const getBlockTypesForPossibleFromTransforms = blocks => { 2261 if (Object(external_lodash_["isEmpty"])(blocks)) { 2262 return []; 2263 } 2264 2265 const allBlockTypes = registration_getBlockTypes(); // filter all blocks to find those with a 'from' transform. 2266 2267 const blockTypesWithPossibleFromTransforms = Object(external_lodash_["filter"])(allBlockTypes, blockType => { 2268 const fromTransforms = getBlockTransforms('from', blockType.name); 2269 return !!findTransform(fromTransforms, transform => { 2270 return isPossibleTransformForSource(transform, 'from', blocks); 2271 }); 2272 }); 2273 return blockTypesWithPossibleFromTransforms; 2274 }; 2275 /** 2276 * Returns block types that the 'blocks' can be transformed into, based on 2277 * the source block's own 'to' transforms. 2278 * 2279 * @param {Array} blocks The blocks to transform from. 2280 * 2281 * @return {Array} Block types that the source can be transformed into. 2282 */ 2283 2284 2285 const getBlockTypesForPossibleToTransforms = blocks => { 2286 if (Object(external_lodash_["isEmpty"])(blocks)) { 2287 return []; 2288 } 2289 2290 const sourceBlock = Object(external_lodash_["first"])(blocks); 2291 const blockType = registration_getBlockType(sourceBlock.name); 2292 const transformsTo = getBlockTransforms('to', blockType.name); // filter all 'to' transforms to find those that are possible. 2293 2294 const possibleTransforms = Object(external_lodash_["filter"])(transformsTo, transform => { 2295 return transform && isPossibleTransformForSource(transform, 'to', blocks); 2296 }); // Build a list of block names using the possible 'to' transforms. 2297 2298 const blockNames = Object(external_lodash_["flatMap"])(possibleTransforms, transformation => transformation.blocks); // Map block names to block types. 2299 2300 return blockNames.map(name => registration_getBlockType(name)); 2301 }; 2302 /** 2303 * Determines whether transform is a "block" type 2304 * and if so whether it is a "wildcard" transform 2305 * ie: targets "any" block type 2306 * 2307 * @param {Object} t the Block transform object 2308 * 2309 * @return {boolean} whether transform is a wildcard transform 2310 */ 2311 2312 2313 const isWildcardBlockTransform = t => t && t.type === 'block' && Array.isArray(t.blocks) && t.blocks.includes('*'); 2314 /** 2315 * Determines whether the given Block is the core Block which 2316 * acts as a container Block for other Blocks as part of the 2317 * Grouping mechanics 2318 * 2319 * @param {string} name the name of the Block to test against 2320 * 2321 * @return {boolean} whether or not the Block is the container Block type 2322 */ 2323 2324 const isContainerGroupBlock = name => name === registration_getGroupingBlockName(); 2325 /** 2326 * Returns an array of block types that the set of blocks received as argument 2327 * can be transformed into. 2328 * 2329 * @param {Array} blocks Blocks array. 2330 * 2331 * @return {Array} Block types that the blocks argument can be transformed to. 2332 */ 2333 2334 function getPossibleBlockTransformations(blocks) { 2335 if (Object(external_lodash_["isEmpty"])(blocks)) { 2336 return []; 2337 } 2338 2339 const blockTypesForFromTransforms = getBlockTypesForPossibleFromTransforms(blocks); 2340 const blockTypesForToTransforms = getBlockTypesForPossibleToTransforms(blocks); 2341 return Object(external_lodash_["uniq"])([...blockTypesForFromTransforms, ...blockTypesForToTransforms]); 2342 } 2343 /** 2344 * Given an array of transforms, returns the highest-priority transform where 2345 * the predicate function returns a truthy value. A higher-priority transform 2346 * is one with a lower priority value (i.e. first in priority order). Returns 2347 * null if the transforms set is empty or the predicate function returns a 2348 * falsey value for all entries. 2349 * 2350 * @param {Object[]} transforms Transforms to search. 2351 * @param {Function} predicate Function returning true on matching transform. 2352 * 2353 * @return {?Object} Highest-priority transform candidate. 2354 */ 2355 2356 function findTransform(transforms, predicate) { 2357 // The hooks library already has built-in mechanisms for managing priority 2358 // queue, so leverage via locally-defined instance. 2359 const hooks = Object(external_wp_hooks_["createHooks"])(); 2360 2361 for (let i = 0; i < transforms.length; i++) { 2362 const candidate = transforms[i]; 2363 2364 if (predicate(candidate)) { 2365 hooks.addFilter('transform', 'transform/' + i.toString(), result => result ? result : candidate, candidate.priority); 2366 } 2367 } // Filter name is arbitrarily chosen but consistent with above aggregation. 2368 2369 2370 return hooks.applyFilters('transform', null); 2371 } 2372 /** 2373 * Returns normal block transforms for a given transform direction, optionally 2374 * for a specific block by name, or an empty array if there are no transforms. 2375 * If no block name is provided, returns transforms for all blocks. A normal 2376 * transform object includes `blockName` as a property. 2377 * 2378 * @param {string} direction Transform direction ("to", "from"). 2379 * @param {string|Object} blockTypeOrName Block type or name. 2380 * 2381 * @return {Array} Block transforms for direction. 2382 */ 2383 2384 function getBlockTransforms(direction, blockTypeOrName) { 2385 // When retrieving transforms for all block types, recurse into self. 2386 if (blockTypeOrName === undefined) { 2387 return Object(external_lodash_["flatMap"])(registration_getBlockTypes(), ({ 2388 name 2389 }) => getBlockTransforms(direction, name)); 2390 } // Validate that block type exists and has array of direction. 2391 2392 2393 const blockType = normalizeBlockType(blockTypeOrName); 2394 const { 2395 name: blockName, 2396 transforms 2397 } = blockType || {}; 2398 2399 if (!transforms || !Array.isArray(transforms[direction])) { 2400 return []; 2401 } 2402 2403 const usingMobileTransformations = transforms.supportedMobileTransforms && Array.isArray(transforms.supportedMobileTransforms); 2404 const filteredTransforms = usingMobileTransformations ? Object(external_lodash_["filter"])(transforms[direction], t => { 2405 if (t.type === 'raw') { 2406 return true; 2407 } 2408 2409 if (!t.blocks || !t.blocks.length) { 2410 return false; 2411 } 2412 2413 if (isWildcardBlockTransform(t)) { 2414 return true; 2415 } 2416 2417 return Object(external_lodash_["every"])(t.blocks, transformBlockName => transforms.supportedMobileTransforms.includes(transformBlockName)); 2418 }) : transforms[direction]; // Map transforms to normal form. 2419 2420 return filteredTransforms.map(transform => ({ ...transform, 2421 blockName, 2422 usingMobileTransformations 2423 })); 2424 } 2425 /** 2426 * Switch one or more blocks into one or more blocks of the new block type. 2427 * 2428 * @param {Array|Object} blocks Blocks array or block object. 2429 * @param {string} name Block name. 2430 * 2431 * @return {?Array} Array of blocks or null. 2432 */ 2433 2434 function switchToBlockType(blocks, name) { 2435 const blocksArray = Object(external_lodash_["castArray"])(blocks); 2436 const isMultiBlock = blocksArray.length > 1; 2437 const firstBlock = blocksArray[0]; 2438 const sourceName = firstBlock.name; // Find the right transformation by giving priority to the "to" 2439 // transformation. 2440 2441 const transformationsFrom = getBlockTransforms('from', name); 2442 const transformationsTo = getBlockTransforms('to', sourceName); 2443 const transformation = findTransform(transformationsTo, t => t.type === 'block' && (isWildcardBlockTransform(t) || t.blocks.indexOf(name) !== -1) && (!isMultiBlock || t.isMultiBlock)) || findTransform(transformationsFrom, t => t.type === 'block' && (isWildcardBlockTransform(t) || t.blocks.indexOf(sourceName) !== -1) && (!isMultiBlock || t.isMultiBlock)); // Stop if there is no valid transformation. 2444 2445 if (!transformation) { 2446 return null; 2447 } 2448 2449 let transformationResults; 2450 2451 if (transformation.isMultiBlock) { 2452 if (Object(external_lodash_["has"])(transformation, '__experimentalConvert')) { 2453 transformationResults = transformation.__experimentalConvert(blocksArray); 2454 } else { 2455 transformationResults = transformation.transform(blocksArray.map(currentBlock => currentBlock.attributes), blocksArray.map(currentBlock => currentBlock.innerBlocks)); 2456 } 2457 } else if (Object(external_lodash_["has"])(transformation, '__experimentalConvert')) { 2458 transformationResults = transformation.__experimentalConvert(firstBlock); 2459 } else { 2460 transformationResults = transformation.transform(firstBlock.attributes, firstBlock.innerBlocks); 2461 } // Ensure that the transformation function returned an object or an array 2462 // of objects. 2463 2464 2465 if (!Object(external_lodash_["isObjectLike"])(transformationResults)) { 2466 return null; 2467 } // If the transformation function returned a single object, we want to work 2468 // with an array instead. 2469 2470 2471 transformationResults = Object(external_lodash_["castArray"])(transformationResults); // Ensure that every block object returned by the transformation has a 2472 // valid block type. 2473 2474 if (transformationResults.some(result => !registration_getBlockType(result.name))) { 2475 return null; 2476 } 2477 2478 const hasSwitchedBlock = Object(external_lodash_["some"])(transformationResults, result => result.name === name); // Ensure that at least one block object returned by the transformation has 2479 // the expected "destination" block type. 2480 2481 if (!hasSwitchedBlock) { 2482 return null; 2483 } 2484 2485 const ret = transformationResults.map(result => { 2486 /** 2487 * Filters an individual transform result from block transformation. 2488 * All of the original blocks are passed, since transformations are 2489 * many-to-many, not one-to-one. 2490 * 2491 * @param {Object} transformedBlock The transformed block. 2492 * @param {Object[]} blocks Original blocks transformed. 2493 */ 2494 return Object(external_wp_hooks_["applyFilters"])('blocks.switchToBlockType.transformedBlock', result, blocks); 2495 }); 2496 return ret; 2497 } 2498 /** 2499 * Create a block object from the example API. 2500 * 2501 * @param {string} name 2502 * @param {Object} example 2503 * 2504 * @return {Object} block. 2505 */ 2506 2507 const getBlockFromExample = (name, example) => { 2508 return createBlock(name, example.attributes, Object(external_lodash_["map"])(example.innerBlocks, innerBlock => getBlockFromExample(innerBlock.name, innerBlock))); 2509 }; 2510 2511 // CONCATENATED MODULE: ./node_modules/hpq/es/get-path.js 2512 /** 2513 * Given object and string of dot-delimited path segments, returns value at 2514 * path or undefined if path cannot be resolved. 2515 * 2516 * @param {Object} object Lookup object 2517 * @param {string} path Path to resolve 2518 * @return {?*} Resolved value 2519 */ 2520 function getPath(object, path) { 2521 var segments = path.split('.'); 2522 var segment; 2523 2524 while (segment = segments.shift()) { 2525 if (!(segment in object)) { 2526 return; 2527 } 2528 2529 object = object[segment]; 2530 } 2531 2532 return object; 2533 } 2534 // CONCATENATED MODULE: ./node_modules/hpq/es/index.js 2535 /** 2536 * Internal dependencies 2537 */ 2538 2539 /** 2540 * Function returning a DOM document created by `createHTMLDocument`. The same 2541 * document is returned between invocations. 2542 * 2543 * @return {Document} DOM document. 2544 */ 2545 2546 var getDocument = function () { 2547 var doc; 2548 return function () { 2549 if (!doc) { 2550 doc = document.implementation.createHTMLDocument(''); 2551 } 2552 2553 return doc; 2554 }; 2555 }(); 2556 /** 2557 * Given a markup string or DOM element, creates an object aligning with the 2558 * shape of the matchers object, or the value returned by the matcher. 2559 * 2560 * @param {(string|Element)} source Source content 2561 * @param {(Object|Function)} matchers Matcher function or object of matchers 2562 * @return {(Object|*)} Matched value(s), shaped by object 2563 */ 2564 2565 2566 function parse(source, matchers) { 2567 if (!matchers) { 2568 return; 2569 } // Coerce to element 2570 2571 2572 if ('string' === typeof source) { 2573 var doc = getDocument(); 2574 doc.body.innerHTML = source; 2575 source = doc.body; 2576 } // Return singular value 2577 2578 2579 if ('function' === typeof matchers) { 2580 return matchers(source); 2581 } // Bail if we can't handle matchers 2582 2583 2584 if (Object !== matchers.constructor) { 2585 return; 2586 } // Shape result by matcher object 2587 2588 2589 return Object.keys(matchers).reduce(function (memo, key) { 2590 memo[key] = parse(source, matchers[key]); 2591 return memo; 2592 }, {}); 2593 } 2594 /** 2595 * Generates a function which matches node of type selector, returning an 2596 * attribute by property if the attribute exists. If no selector is passed, 2597 * returns property of the query element. 2598 * 2599 * @param {?string} selector Optional selector 2600 * @param {string} name Property name 2601 * @return {*} Property value 2602 */ 2603 2604 function prop(selector, name) { 2605 if (1 === arguments.length) { 2606 name = selector; 2607 selector = undefined; 2608 } 2609 2610 return function (node) { 2611 var match = node; 2612 2613 if (selector) { 2614 match = node.querySelector(selector); 2615 } 2616 2617 if (match) { 2618 return getPath(match, name); 2619 } 2620 }; 2621 } 2622 /** 2623 * Generates a function which matches node of type selector, returning an 2624 * attribute by name if the attribute exists. If no selector is passed, 2625 * returns attribute of the query element. 2626 * 2627 * @param {?string} selector Optional selector 2628 * @param {string} name Attribute name 2629 * @return {?string} Attribute value 2630 */ 2631 2632 function attr(selector, name) { 2633 if (1 === arguments.length) { 2634 name = selector; 2635 selector = undefined; 2636 } 2637 2638 return function (node) { 2639 var attributes = prop(selector, 'attributes')(node); 2640 2641 if (attributes && attributes.hasOwnProperty(name)) { 2642 return attributes[name].value; 2643 } 2644 }; 2645 } 2646 /** 2647 * Convenience for `prop( selector, 'innerHTML' )`. 2648 * 2649 * @see prop() 2650 * 2651 * @param {?string} selector Optional selector 2652 * @return {string} Inner HTML 2653 */ 2654 2655 function es_html(selector) { 2656 return prop(selector, 'innerHTML'); 2657 } 2658 /** 2659 * Convenience for `prop( selector, 'textContent' )`. 2660 * 2661 * @see prop() 2662 * 2663 * @param {?string} selector Optional selector 2664 * @return {string} Text content 2665 */ 2666 2667 function es_text(selector) { 2668 return prop(selector, 'textContent'); 2669 } 2670 /** 2671 * Creates a new matching context by first finding elements matching selector 2672 * using querySelectorAll before then running another `parse` on `matchers` 2673 * scoped to the matched elements. 2674 * 2675 * @see parse() 2676 * 2677 * @param {string} selector Selector to match 2678 * @param {(Object|Function)} matchers Matcher function or object of matchers 2679 * @return {Array.<*,Object>} Array of matched value(s) 2680 */ 2681 2682 function query(selector, matchers) { 2683 return function (node) { 2684 var matches = node.querySelectorAll(selector); 2685 return [].map.call(matches, function (match) { 2686 return parse(match, matchers); 2687 }); 2688 }; 2689 } 2690 // EXTERNAL MODULE: external ["wp","autop"] 2691 var external_wp_autop_ = __webpack_require__("UuzZ"); 2692 2693 // EXTERNAL MODULE: external ["wp","blockSerializationDefaultParser"] 2694 var external_wp_blockSerializationDefaultParser_ = __webpack_require__("ouCq"); 2695 2696 // CONCATENATED MODULE: ./node_modules/simple-html-tokenizer/dist/es6/index.js 2697 /** 2698 * generated from https://raw.githubusercontent.com/w3c/html/26b5126f96f736f796b9e29718138919dd513744/entities.json 2699 * do not edit 2700 */ 2701 var namedCharRefs = { 2702 Aacute: "Á", aacute: "á", Abreve: "Ă", abreve: "ă", ac: "∾", acd: "∿", acE: "∾̳", Acirc: "Â", acirc: "â", acute: "´", Acy: "А", acy: "а", AElig: "Æ", aelig: "æ", af: "\u2061", Afr: "𝔄", afr: "𝔞", Agrave: "À", agrave: "à", alefsym: "ℵ", aleph: "ℵ", Alpha: "Α", alpha: "α", Amacr: "Ā", amacr: "ā", amalg: "⨿", amp: "&", AMP: "&", andand: "⩕", And: "⩓", and: "∧", andd: "⩜", andslope: "⩘", andv: "⩚", ang: "∠", ange: "⦤", angle: "∠", angmsdaa: "⦨", angmsdab: "⦩", angmsdac: "⦪", angmsdad: "⦫", angmsdae: "⦬", angmsdaf: "⦭", angmsdag: "⦮", angmsdah: "⦯", angmsd: "∡", angrt: "∟", angrtvb: "⊾", angrtvbd: "⦝", angsph: "∢", angst: "Å", angzarr: "⍼", Aogon: "Ą", aogon: "ą", Aopf: "𝔸", aopf: "𝕒", apacir: "⩯", ap: "≈", apE: "⩰", ape: "≊", apid: "≋", apos: "'", ApplyFunction: "\u2061", approx: "≈", approxeq: "≊", Aring: "Å", aring: "å", Ascr: "𝒜", ascr: "𝒶", Assign: "≔", ast: "*", asymp: "≈", asympeq: "≍", Atilde: "Ã", atilde: "ã", Auml: "Ä", auml: "ä", awconint: "∳", awint: "⨑", backcong: "≌", backepsilon: "϶", backprime: "‵", backsim: "∽", backsimeq: "⋍", Backslash: "∖", Barv: "⫧", barvee: "⊽", barwed: "⌅", Barwed: "⌆", barwedge: "⌅", bbrk: "⎵", bbrktbrk: "⎶", bcong: "≌", Bcy: "Б", bcy: "б", bdquo: "„", becaus: "∵", because: "∵", Because: "∵", bemptyv: "⦰", bepsi: "϶", bernou: "ℬ", Bernoullis: "ℬ", Beta: "Β", beta: "β", beth: "ℶ", between: "≬", Bfr: "𝔅", bfr: "𝔟", bigcap: "⋂", bigcirc: "◯", bigcup: "⋃", bigodot: "⨀", bigoplus: "⨁", bigotimes: "⨂", bigsqcup: "⨆", bigstar: "★", bigtriangledown: "▽", bigtriangleup: "△", biguplus: "⨄", bigvee: "⋁", bigwedge: "⋀", bkarow: "⤍", blacklozenge: "⧫", blacksquare: "▪", blacktriangle: "▴", blacktriangledown: "▾", blacktriangleleft: "◂", blacktriangleright: "▸", blank: "␣", blk12: "▒", blk14: "░", blk34: "▓", block: "█", bne: "=⃥", bnequiv: "≡⃥", bNot: "⫭", bnot: "⌐", Bopf: "𝔹", bopf: "𝕓", bot: "⊥", bottom: "⊥", bowtie: "⋈", boxbox: "⧉", boxdl: "┐", boxdL: "╕", boxDl: "╖", boxDL: "╗", boxdr: "┌", boxdR: "╒", boxDr: "╓", boxDR: "╔", boxh: "─", boxH: "═", boxhd: "┬", boxHd: "╤", boxhD: "╥", boxHD: "╦", boxhu: "┴", boxHu: "╧", boxhU: "╨", boxHU: "╩", boxminus: "⊟", boxplus: "⊞", boxtimes: "⊠", boxul: "┘", boxuL: "╛", boxUl: "╜", boxUL: "╝", boxur: "└", boxuR: "╘", boxUr: "╙", boxUR: "╚", boxv: "│", boxV: "║", boxvh: "┼", boxvH: "╪", boxVh: "╫", boxVH: "╬", boxvl: "┤", boxvL: "╡", boxVl: "╢", boxVL: "╣", boxvr: "├", boxvR: "╞", boxVr: "╟", boxVR: "╠", bprime: "‵", breve: "˘", Breve: "˘", brvbar: "¦", bscr: "𝒷", Bscr: "ℬ", bsemi: "⁏", bsim: "∽", bsime: "⋍", bsolb: "⧅", bsol: "\\", bsolhsub: "⟈", bull: "•", bullet: "•", bump: "≎", bumpE: "⪮", bumpe: "≏", Bumpeq: "≎", bumpeq: "≏", Cacute: "Ć", cacute: "ć", capand: "⩄", capbrcup: "⩉", capcap: "⩋", cap: "∩", Cap: "⋒", capcup: "⩇", capdot: "⩀", CapitalDifferentialD: "ⅅ", caps: "∩︀", caret: "⁁", caron: "ˇ", Cayleys: "ℭ", ccaps: "⩍", Ccaron: "Č", ccaron: "č", Ccedil: "Ç", ccedil: "ç", Ccirc: "Ĉ", ccirc: "ĉ", Cconint: "∰", ccups: "⩌", ccupssm: "⩐", Cdot: "Ċ", cdot: "ċ", cedil: "¸", Cedilla: "¸", cemptyv: "⦲", cent: "¢", centerdot: "·", CenterDot: "·", cfr: "𝔠", Cfr: "ℭ", CHcy: "Ч", chcy: "ч", check: "✓", checkmark: "✓", Chi: "Χ", chi: "χ", circ: "ˆ", circeq: "≗", circlearrowleft: "↺", circlearrowright: "↻", circledast: "⊛", circledcirc: "⊚", circleddash: "⊝", CircleDot: "⊙", circledR: "®", circledS: "Ⓢ", CircleMinus: "⊖", CirclePlus: "⊕", CircleTimes: "⊗", cir: "○", cirE: "⧃", cire: "≗", cirfnint: "⨐", cirmid: "⫯", cirscir: "⧂", ClockwiseContourIntegral: "∲", CloseCurlyDoubleQuote: "”", CloseCurlyQuote: "’", clubs: "♣", clubsuit: "♣", colon: ":", Colon: "∷", Colone: "⩴", colone: "≔", coloneq: "≔", comma: ",", commat: "@", comp: "∁", compfn: "∘", complement: "∁", complexes: "ℂ", cong: "≅", congdot: "⩭", Congruent: "≡", conint: "∮", Conint: "∯", ContourIntegral: "∮", copf: "𝕔", Copf: "ℂ", coprod: "∐", Coproduct: "∐", copy: "©", COPY: "©", copysr: "℗", CounterClockwiseContourIntegral: "∳", crarr: "↵", cross: "✗", Cross: "⨯", Cscr: "𝒞", cscr: "𝒸", csub: "⫏", csube: "⫑", csup: "⫐", csupe: "⫒", ctdot: "⋯", cudarrl: "⤸", cudarrr: "⤵", cuepr: "⋞", cuesc: "⋟", cularr: "↶", cularrp: "⤽", cupbrcap: "⩈", cupcap: "⩆", CupCap: "≍", cup: "∪", Cup: "⋓", cupcup: "⩊", cupdot: "⊍", cupor: "⩅", cups: "∪︀", curarr: "↷", curarrm: "⤼", curlyeqprec: "⋞", curlyeqsucc: "⋟", curlyvee: "⋎", curlywedge: "⋏", curren: "¤", curvearrowleft: "↶", curvearrowright: "↷", cuvee: "⋎", cuwed: "⋏", cwconint: "∲", cwint: "∱", cylcty: "⌭", dagger: "†", Dagger: "‡", daleth: "ℸ", darr: "↓", Darr: "↡", dArr: "⇓", dash: "‐", Dashv: "⫤", dashv: "⊣", dbkarow: "⤏", dblac: "˝", Dcaron: "Ď", dcaron: "ď", Dcy: "Д", dcy: "д", ddagger: "‡", ddarr: "⇊", DD: "ⅅ", dd: "ⅆ", DDotrahd: "⤑", ddotseq: "⩷", deg: "°", Del: "∇", Delta: "Δ", delta: "δ", demptyv: "⦱", dfisht: "⥿", Dfr: "𝔇", dfr: "𝔡", dHar: "⥥", dharl: "⇃", dharr: "⇂", DiacriticalAcute: "´", DiacriticalDot: "˙", DiacriticalDoubleAcute: "˝", DiacriticalGrave: "`", DiacriticalTilde: "˜", diam: "⋄", diamond: "⋄", Diamond: "⋄", diamondsuit: "♦", diams: "♦", die: "¨", DifferentialD: "ⅆ", digamma: "ϝ", disin: "⋲", div: "÷", divide: "÷", divideontimes: "⋇", divonx: "⋇", DJcy: "Ђ", djcy: "ђ", dlcorn: "⌞", dlcrop: "⌍", dollar: "$", Dopf: "𝔻", dopf: "𝕕", Dot: "¨", dot: "˙", DotDot: "⃜", doteq: "≐", doteqdot: "≑", DotEqual: "≐", dotminus: "∸", dotplus: "∔", dotsquare: "⊡", doublebarwedge: "⌆", DoubleContourIntegral: "∯", DoubleDot: "¨", DoubleDownArrow: "⇓", DoubleLeftArrow: "⇐", DoubleLeftRightArrow: "⇔", DoubleLeftTee: "⫤", DoubleLongLeftArrow: "⟸", DoubleLongLeftRightArrow: "⟺", DoubleLongRightArrow: "⟹", DoubleRightArrow: "⇒", DoubleRightTee: "⊨", DoubleUpArrow: "⇑", DoubleUpDownArrow: "⇕", DoubleVerticalBar: "∥", DownArrowBar: "⤓", downarrow: "↓", DownArrow: "↓", Downarrow: "⇓", DownArrowUpArrow: "⇵", DownBreve: "̑", downdownarrows: "⇊", downharpoonleft: "⇃", downharpoonright: "⇂", DownLeftRightVector: "⥐", DownLeftTeeVector: "⥞", DownLeftVectorBar: "⥖", DownLeftVector: "↽", DownRightTeeVector: "⥟", DownRightVectorBar: "⥗", DownRightVector: "⇁", DownTeeArrow: "↧", DownTee: "⊤", drbkarow: "⤐", drcorn: "⌟", drcrop: "⌌", Dscr: "𝒟", dscr: "𝒹", DScy: "Ѕ", dscy: "ѕ", dsol: "⧶", Dstrok: "Đ", dstrok: "đ", dtdot: "⋱", dtri: "▿", dtrif: "▾", duarr: "⇵", duhar: "⥯", dwangle: "⦦", DZcy: "Џ", dzcy: "џ", dzigrarr: "⟿", Eacute: "É", eacute: "é", easter: "⩮", Ecaron: "Ě", ecaron: "ě", Ecirc: "Ê", ecirc: "ê", ecir: "≖", ecolon: "≕", Ecy: "Э", ecy: "э", eDDot: "⩷", Edot: "Ė", edot: "ė", eDot: "≑", ee: "ⅇ", efDot: "≒", Efr: "𝔈", efr: "𝔢", eg: "⪚", Egrave: "È", egrave: "è", egs: "⪖", egsdot: "⪘", el: "⪙", Element: "∈", elinters: "⏧", ell: "ℓ", els: "⪕", elsdot: "⪗", Emacr: "Ē", emacr: "ē", empty: "∅", emptyset: "∅", EmptySmallSquare: "◻", emptyv: "∅", EmptyVerySmallSquare: "▫", emsp13: " ", emsp14: " ", emsp: " ", ENG: "Ŋ", eng: "ŋ", ensp: " ", Eogon: "Ę", eogon: "ę", Eopf: "𝔼", eopf: "𝕖", epar: "⋕", eparsl: "⧣", eplus: "⩱", epsi: "ε", Epsilon: "Ε", epsilon: "ε", epsiv: "ϵ", eqcirc: "≖", eqcolon: "≕", eqsim: "≂", eqslantgtr: "⪖", eqslantless: "⪕", Equal: "⩵", equals: "=", EqualTilde: "≂", equest: "≟", Equilibrium: "⇌", equiv: "≡", equivDD: "⩸", eqvparsl: "⧥", erarr: "⥱", erDot: "≓", escr: "ℯ", Escr: "ℰ", esdot: "≐", Esim: "⩳", esim: "≂", Eta: "Η", eta: "η", ETH: "Ð", eth: "ð", Euml: "Ë", euml: "ë", euro: "€", excl: "!", exist: "∃", Exists: "∃", expectation: "ℰ", exponentiale: "ⅇ", ExponentialE: "ⅇ", fallingdotseq: "≒", Fcy: "Ф", fcy: "ф", female: "♀", ffilig: "ffi", fflig: "ff", ffllig: "ffl", Ffr: "𝔉", ffr: "𝔣", filig: "fi", FilledSmallSquare: "◼", FilledVerySmallSquare: "▪", fjlig: "fj", flat: "♭", fllig: "fl", fltns: "▱", fnof: "ƒ", Fopf: "𝔽", fopf: "𝕗", forall: "∀", ForAll: "∀", fork: "⋔", forkv: "⫙", Fouriertrf: "ℱ", fpartint: "⨍", frac12: "½", frac13: "⅓", frac14: "¼", frac15: "⅕", frac16: "⅙", frac18: "⅛", frac23: "⅔", frac25: "⅖", frac34: "¾", frac35: "⅗", frac38: "⅜", frac45: "⅘", frac56: "⅚", frac58: "⅝", frac78: "⅞", frasl: "⁄", frown: "⌢", fscr: "𝒻", Fscr: "ℱ", gacute: "ǵ", Gamma: "Γ", gamma: "γ", Gammad: "Ϝ", gammad: "ϝ", gap: "⪆", Gbreve: "Ğ", gbreve: "ğ", Gcedil: "Ģ", Gcirc: "Ĝ", gcirc: "ĝ", Gcy: "Г", gcy: "г", Gdot: "Ġ", gdot: "ġ", ge: "≥", gE: "≧", gEl: "⪌", gel: "⋛", geq: "≥", geqq: "≧", geqslant: "⩾", gescc: "⪩", ges: "⩾", gesdot: "⪀", gesdoto: "⪂", gesdotol: "⪄", gesl: "⋛︀", gesles: "⪔", Gfr: "𝔊", gfr: "𝔤", gg: "≫", Gg: "⋙", ggg: "⋙", gimel: "ℷ", GJcy: "Ѓ", gjcy: "ѓ", gla: "⪥", gl: "≷", glE: "⪒", glj: "⪤", gnap: "⪊", gnapprox: "⪊", gne: "⪈", gnE: "≩", gneq: "⪈", gneqq: "≩", gnsim: "⋧", Gopf: "𝔾", gopf: "𝕘", grave: "`", GreaterEqual: "≥", GreaterEqualLess: "⋛", GreaterFullEqual: "≧", GreaterGreater: "⪢", GreaterLess: "≷", GreaterSlantEqual: "⩾", GreaterTilde: "≳", Gscr: "𝒢", gscr: "ℊ", gsim: "≳", gsime: "⪎", gsiml: "⪐", gtcc: "⪧", gtcir: "⩺", gt: ">", GT: ">", Gt: "≫", gtdot: "⋗", gtlPar: "⦕", gtquest: "⩼", gtrapprox: "⪆", gtrarr: "⥸", gtrdot: "⋗", gtreqless: "⋛", gtreqqless: "⪌", gtrless: "≷", gtrsim: "≳", gvertneqq: "≩︀", gvnE: "≩︀", Hacek: "ˇ", hairsp: " ", half: "½", hamilt: "ℋ", HARDcy: "Ъ", hardcy: "ъ", harrcir: "⥈", harr: "↔", hArr: "⇔", harrw: "↭", Hat: "^", hbar: "ℏ", Hcirc: "Ĥ", hcirc: "ĥ", hearts: "♥", heartsuit: "♥", hellip: "…", hercon: "⊹", hfr: "𝔥", Hfr: "ℌ", HilbertSpace: "ℋ", hksearow: "⤥", hkswarow: "⤦", hoarr: "⇿", homtht: "∻", hookleftarrow: "↩", hookrightarrow: "↪", hopf: "𝕙", Hopf: "ℍ", horbar: "―", HorizontalLine: "─", hscr: "𝒽", Hscr: "ℋ", hslash: "ℏ", Hstrok: "Ħ", hstrok: "ħ", HumpDownHump: "≎", HumpEqual: "≏", hybull: "⁃", hyphen: "‐", Iacute: "Í", iacute: "í", ic: "\u2063", Icirc: "Î", icirc: "î", Icy: "И", icy: "и", Idot: "İ", IEcy: "Е", iecy: "е", iexcl: "¡", iff: "⇔", ifr: "𝔦", Ifr: "ℑ", Igrave: "Ì", igrave: "ì", ii: "ⅈ", iiiint: "⨌", iiint: "∭", iinfin: "⧜", iiota: "℩", IJlig: "IJ", ijlig: "ij", Imacr: "Ī", imacr: "ī", image: "ℑ", ImaginaryI: "ⅈ", imagline: "ℐ", imagpart: "ℑ", imath: "ı", Im: "ℑ", imof: "⊷", imped: "Ƶ", Implies: "⇒", incare: "℅", in: "∈", infin: "∞", infintie: "⧝", inodot: "ı", intcal: "⊺", int: "∫", Int: "∬", integers: "ℤ", Integral: "∫", intercal: "⊺", Intersection: "⋂", intlarhk: "⨗", intprod: "⨼", InvisibleComma: "\u2063", InvisibleTimes: "\u2062", IOcy: "Ё", iocy: "ё", Iogon: "Į", iogon: "į", Iopf: "𝕀", iopf: "𝕚", Iota: "Ι", iota: "ι", iprod: "⨼", iquest: "¿", iscr: "𝒾", Iscr: "ℐ", isin: "∈", isindot: "⋵", isinE: "⋹", isins: "⋴", isinsv: "⋳", isinv: "∈", it: "\u2062", Itilde: "Ĩ", itilde: "ĩ", Iukcy: "І", iukcy: "і", Iuml: "Ï", iuml: "ï", Jcirc: "Ĵ", jcirc: "ĵ", Jcy: "Й", jcy: "й", Jfr: "𝔍", jfr: "𝔧", jmath: "ȷ", Jopf: "𝕁", jopf: "𝕛", Jscr: "𝒥", jscr: "𝒿", Jsercy: "Ј", jsercy: "ј", Jukcy: "Є", jukcy: "є", Kappa: "Κ", kappa: "κ", kappav: "ϰ", Kcedil: "Ķ", kcedil: "ķ", Kcy: "К", kcy: "к", Kfr: "𝔎", kfr: "𝔨", kgreen: "ĸ", KHcy: "Х", khcy: "х", KJcy: "Ќ", kjcy: "ќ", Kopf: "𝕂", kopf: "𝕜", Kscr: "𝒦", kscr: "𝓀", lAarr: "⇚", Lacute: "Ĺ", lacute: "ĺ", laemptyv: "⦴", lagran: "ℒ", Lambda: "Λ", lambda: "λ", lang: "⟨", Lang: "⟪", langd: "⦑", langle: "⟨", lap: "⪅", Laplacetrf: "ℒ", laquo: "«", larrb: "⇤", larrbfs: "⤟", larr: "←", Larr: "↞", lArr: "⇐", larrfs: "⤝", larrhk: "↩", larrlp: "↫", larrpl: "⤹", larrsim: "⥳", larrtl: "↢", latail: "⤙", lAtail: "⤛", lat: "⪫", late: "⪭", lates: "⪭︀", lbarr: "⤌", lBarr: "⤎", lbbrk: "❲", lbrace: "{", lbrack: "[", lbrke: "⦋", lbrksld: "⦏", lbrkslu: "⦍", Lcaron: "Ľ", lcaron: "ľ", Lcedil: "Ļ", lcedil: "ļ", lceil: "⌈", lcub: "{", Lcy: "Л", lcy: "л", ldca: "⤶", ldquo: "“", ldquor: "„", ldrdhar: "⥧", ldrushar: "⥋", ldsh: "↲", le: "≤", lE: "≦", LeftAngleBracket: "⟨", LeftArrowBar: "⇤", leftarrow: "←", LeftArrow: "←", Leftarrow: "⇐", LeftArrowRightArrow: "⇆", leftarrowtail: "↢", LeftCeiling: "⌈", LeftDoubleBracket: "⟦", LeftDownTeeVector: "⥡", LeftDownVectorBar: "⥙", LeftDownVector: "⇃", LeftFloor: "⌊", leftharpoondown: "↽", leftharpoonup: "↼", leftleftarrows: "⇇", leftrightarrow: "↔", LeftRightArrow: "↔", Leftrightarrow: "⇔", leftrightarrows: "⇆", leftrightharpoons: "⇋", leftrightsquigarrow: "↭", LeftRightVector: "⥎", LeftTeeArrow: "↤", LeftTee: "⊣", LeftTeeVector: "⥚", leftthreetimes: "⋋", LeftTriangleBar: "⧏", LeftTriangle: "⊲", LeftTriangleEqual: "⊴", LeftUpDownVector: "⥑", LeftUpTeeVector: "⥠", LeftUpVectorBar: "⥘", LeftUpVector: "↿", LeftVectorBar: "⥒", LeftVector: "↼", lEg: "⪋", leg: "⋚", leq: "≤", leqq: "≦", leqslant: "⩽", lescc: "⪨", les: "⩽", lesdot: "⩿", lesdoto: "⪁", lesdotor: "⪃", lesg: "⋚︀", lesges: "⪓", lessapprox: "⪅", lessdot: "⋖", lesseqgtr: "⋚", lesseqqgtr: "⪋", LessEqualGreater: "⋚", LessFullEqual: "≦", LessGreater: "≶", lessgtr: "≶", LessLess: "⪡", lesssim: "≲", LessSlantEqual: "⩽", LessTilde: "≲", lfisht: "⥼", lfloor: "⌊", Lfr: "𝔏", lfr: "𝔩", lg: "≶", lgE: "⪑", lHar: "⥢", lhard: "↽", lharu: "↼", lharul: "⥪", lhblk: "▄", LJcy: "Љ", ljcy: "љ", llarr: "⇇", ll: "≪", Ll: "⋘", llcorner: "⌞", Lleftarrow: "⇚", llhard: "⥫", lltri: "◺", Lmidot: "Ŀ", lmidot: "ŀ", lmoustache: "⎰", lmoust: "⎰", lnap: "⪉", lnapprox: "⪉", lne: "⪇", lnE: "≨", lneq: "⪇", lneqq: "≨", lnsim: "⋦", loang: "⟬", loarr: "⇽", lobrk: "⟦", longleftarrow: "⟵", LongLeftArrow: "⟵", Longleftarrow: "⟸", longleftrightarrow: "⟷", LongLeftRightArrow: "⟷", Longleftrightarrow: "⟺", longmapsto: "⟼", longrightarrow: "⟶", LongRightArrow: "⟶", Longrightarrow: "⟹", looparrowleft: "↫", looparrowright: "↬", lopar: "⦅", Lopf: "𝕃", lopf: "𝕝", loplus: "⨭", lotimes: "⨴", lowast: "∗", lowbar: "_", LowerLeftArrow: "↙", LowerRightArrow: "↘", loz: "◊", lozenge: "◊", lozf: "⧫", lpar: "(", lparlt: "⦓", lrarr: "⇆", lrcorner: "⌟", lrhar: "⇋", lrhard: "⥭", lrm: "\u200e", lrtri: "⊿", lsaquo: "‹", lscr: "𝓁", Lscr: "ℒ", lsh: "↰", Lsh: "↰", lsim: "≲", lsime: "⪍", lsimg: "⪏", lsqb: "[", lsquo: "‘", lsquor: "‚", Lstrok: "Ł", lstrok: "ł", ltcc: "⪦", ltcir: "⩹", lt: "<", LT: "<", Lt: "≪", ltdot: "⋖", lthree: "⋋", ltimes: "⋉", ltlarr: "⥶", ltquest: "⩻", ltri: "◃", ltrie: "⊴", ltrif: "◂", ltrPar: "⦖", lurdshar: "⥊", luruhar: "⥦", lvertneqq: "≨︀", lvnE: "≨︀", macr: "¯", male: "♂", malt: "✠", maltese: "✠", Map: "⤅", map: "↦", mapsto: "↦", mapstodown: "↧", mapstoleft: "↤", mapstoup: "↥", marker: "▮", mcomma: "⨩", Mcy: "М", mcy: "м", mdash: "—", mDDot: "∺", measuredangle: "∡", MediumSpace: " ", Mellintrf: "ℳ", Mfr: "𝔐", mfr: "𝔪", mho: "℧", micro: "µ", midast: "*", midcir: "⫰", mid: "∣", middot: "·", minusb: "⊟", minus: "−", minusd: "∸", minusdu: "⨪", MinusPlus: "∓", mlcp: "⫛", mldr: "…", mnplus: "∓", models: "⊧", Mopf: "𝕄", mopf: "𝕞", mp: "∓", mscr: "𝓂", Mscr: "ℳ", mstpos: "∾", Mu: "Μ", mu: "μ", multimap: "⊸", mumap: "⊸", nabla: "∇", Nacute: "Ń", nacute: "ń", nang: "∠⃒", nap: "≉", napE: "⩰̸", napid: "≋̸", napos: "ʼn", napprox: "≉", natural: "♮", naturals: "ℕ", natur: "♮", nbsp: " ", nbump: "≎̸", nbumpe: "≏̸", ncap: "⩃", Ncaron: "Ň", ncaron: "ň", Ncedil: "Ņ", ncedil: "ņ", ncong: "≇", ncongdot: "⩭̸", ncup: "⩂", Ncy: "Н", ncy: "н", ndash: "–", nearhk: "⤤", nearr: "↗", neArr: "⇗", nearrow: "↗", ne: "≠", nedot: "≐̸", NegativeMediumSpace: "", NegativeThickSpace: "", NegativeThinSpace: "", NegativeVeryThinSpace: "", nequiv: "≢", nesear: "⤨", nesim: "≂̸", NestedGreaterGreater: "≫", NestedLessLess: "≪", NewLine: "\u000a", nexist: "∄", nexists: "∄", Nfr: "𝔑", nfr: "𝔫", ngE: "≧̸", nge: "≱", ngeq: "≱", ngeqq: "≧̸", ngeqslant: "⩾̸", nges: "⩾̸", nGg: "⋙̸", ngsim: "≵", nGt: "≫⃒", ngt: "≯", ngtr: "≯", nGtv: "≫̸", nharr: "↮", nhArr: "⇎", nhpar: "⫲", ni: "∋", nis: "⋼", nisd: "⋺", niv: "∋", NJcy: "Њ", njcy: "њ", nlarr: "↚", nlArr: "⇍", nldr: "‥", nlE: "≦̸", nle: "≰", nleftarrow: "↚", nLeftarrow: "⇍", nleftrightarrow: "↮", nLeftrightarrow: "⇎", nleq: "≰", nleqq: "≦̸", nleqslant: "⩽̸", nles: "⩽̸", nless: "≮", nLl: "⋘̸", nlsim: "≴", nLt: "≪⃒", nlt: "≮", nltri: "⋪", nltrie: "⋬", nLtv: "≪̸", nmid: "∤", NoBreak: "\u2060", NonBreakingSpace: " ", nopf: "𝕟", Nopf: "ℕ", Not: "⫬", not: "¬", NotCongruent: "≢", NotCupCap: "≭", NotDoubleVerticalBar: "∦", NotElement: "∉", NotEqual: "≠", NotEqualTilde: "≂̸", NotExists: "∄", NotGreater: "≯", NotGreaterEqual: "≱", NotGreaterFullEqual: "≧̸", NotGreaterGreater: "≫̸", NotGreaterLess: "≹", NotGreaterSlantEqual: "⩾̸", NotGreaterTilde: "≵", NotHumpDownHump: "≎̸", NotHumpEqual: "≏̸", notin: "∉", notindot: "⋵̸", notinE: "⋹̸", notinva: "∉", notinvb: "⋷", notinvc: "⋶", NotLeftTriangleBar: "⧏̸", NotLeftTriangle: "⋪", NotLeftTriangleEqual: "⋬", NotLess: "≮", NotLessEqual: "≰", NotLessGreater: "≸", NotLessLess: "≪̸", NotLessSlantEqual: "⩽̸", NotLessTilde: "≴", NotNestedGreaterGreater: "⪢̸", NotNestedLessLess: "⪡̸", notni: "∌", notniva: "∌", notnivb: "⋾", notnivc: "⋽", NotPrecedes: "⊀", NotPrecedesEqual: "⪯̸", NotPrecedesSlantEqual: "⋠", NotReverseElement: "∌", NotRightTriangleBar: "⧐̸", NotRightTriangle: "⋫", NotRightTriangleEqual: "⋭", NotSquareSubset: "⊏̸", NotSquareSubsetEqual: "⋢", NotSquareSuperset: "⊐̸", NotSquareSupersetEqual: "⋣", NotSubset: "⊂⃒", NotSubsetEqual: "⊈", NotSucceeds: "⊁", NotSucceedsEqual: "⪰̸", NotSucceedsSlantEqual: "⋡", NotSucceedsTilde: "≿̸", NotSuperset: "⊃⃒", NotSupersetEqual: "⊉", NotTilde: "≁", NotTildeEqual: "≄", NotTildeFullEqual: "≇", NotTildeTilde: "≉", NotVerticalBar: "∤", nparallel: "∦", npar: "∦", nparsl: "⫽⃥", npart: "∂̸", npolint: "⨔", npr: "⊀", nprcue: "⋠", nprec: "⊀", npreceq: "⪯̸", npre: "⪯̸", nrarrc: "⤳̸", nrarr: "↛", nrArr: "⇏", nrarrw: "↝̸", nrightarrow: "↛", nRightarrow: "⇏", nrtri: "⋫", nrtrie: "⋭", nsc: "⊁", nsccue: "⋡", nsce: "⪰̸", Nscr: "𝒩", nscr: "𝓃", nshortmid: "∤", nshortparallel: "∦", nsim: "≁", nsime: "≄", nsimeq: "≄", nsmid: "∤", nspar: "∦", nsqsube: "⋢", nsqsupe: "⋣", nsub: "⊄", nsubE: "⫅̸", nsube: "⊈", nsubset: "⊂⃒", nsubseteq: "⊈", nsubseteqq: "⫅̸", nsucc: "⊁", nsucceq: "⪰̸", nsup: "⊅", nsupE: "⫆̸", nsupe: "⊉", nsupset: "⊃⃒", nsupseteq: "⊉", nsupseteqq: "⫆̸", ntgl: "≹", Ntilde: "Ñ", ntilde: "ñ", ntlg: "≸", ntriangleleft: "⋪", ntrianglelefteq: "⋬", ntriangleright: "⋫", ntrianglerighteq: "⋭", Nu: "Ν", nu: "ν", num: "#", numero: "№", numsp: " ", nvap: "≍⃒", nvdash: "⊬", nvDash: "⊭", nVdash: "⊮", nVDash: "⊯", nvge: "≥⃒", nvgt: ">⃒", nvHarr: "⤄", nvinfin: "⧞", nvlArr: "⤂", nvle: "≤⃒", nvlt: "<⃒", nvltrie: "⊴⃒", nvrArr: "⤃", nvrtrie: "⊵⃒", nvsim: "∼⃒", nwarhk: "⤣", nwarr: "↖", nwArr: "⇖", nwarrow: "↖", nwnear: "⤧", Oacute: "Ó", oacute: "ó", oast: "⊛", Ocirc: "Ô", ocirc: "ô", ocir: "⊚", Ocy: "О", ocy: "о", odash: "⊝", Odblac: "Ő", odblac: "ő", odiv: "⨸", odot: "⊙", odsold: "⦼", OElig: "Œ", oelig: "œ", ofcir: "⦿", Ofr: "𝔒", ofr: "𝔬", ogon: "˛", Ograve: "Ò", ograve: "ò", ogt: "⧁", ohbar: "⦵", ohm: "Ω", oint: "∮", olarr: "↺", olcir: "⦾", olcross: "⦻", oline: "‾", olt: "⧀", Omacr: "Ō", omacr: "ō", Omega: "Ω", omega: "ω", Omicron: "Ο", omicron: "ο", omid: "⦶", ominus: "⊖", Oopf: "𝕆", oopf: "𝕠", opar: "⦷", OpenCurlyDoubleQuote: "“", OpenCurlyQuote: "‘", operp: "⦹", oplus: "⊕", orarr: "↻", Or: "⩔", or: "∨", ord: "⩝", order: "ℴ", orderof: "ℴ", ordf: "ª", ordm: "º", origof: "⊶", oror: "⩖", orslope: "⩗", orv: "⩛", oS: "Ⓢ", Oscr: "𝒪", oscr: "ℴ", Oslash: "Ø", oslash: "ø", osol: "⊘", Otilde: "Õ", otilde: "õ", otimesas: "⨶", Otimes: "⨷", otimes: "⊗", Ouml: "Ö", ouml: "ö", ovbar: "⌽", OverBar: "‾", OverBrace: "⏞", OverBracket: "⎴", OverParenthesis: "⏜", para: "¶", parallel: "∥", par: "∥", parsim: "⫳", parsl: "⫽", part: "∂", PartialD: "∂", Pcy: "П", pcy: "п", percnt: "%", period: ".", permil: "‰", perp: "⊥", pertenk: "‱", Pfr: "𝔓", pfr: "𝔭", Phi: "Φ", phi: "φ", phiv: "ϕ", phmmat: "ℳ", phone: "☎", Pi: "Π", pi: "π", pitchfork: "⋔", piv: "ϖ", planck: "ℏ", planckh: "ℎ", plankv: "ℏ", plusacir: "⨣", plusb: "⊞", pluscir: "⨢", plus: "+", plusdo: "∔", plusdu: "⨥", pluse: "⩲", PlusMinus: "±", plusmn: "±", plussim: "⨦", plustwo: "⨧", pm: "±", Poincareplane: "ℌ", pointint: "⨕", popf: "𝕡", Popf: "ℙ", pound: "£", prap: "⪷", Pr: "⪻", pr: "≺", prcue: "≼", precapprox: "⪷", prec: "≺", preccurlyeq: "≼", Precedes: "≺", PrecedesEqual: "⪯", PrecedesSlantEqual: "≼", PrecedesTilde: "≾", preceq: "⪯", precnapprox: "⪹", precneqq: "⪵", precnsim: "⋨", pre: "⪯", prE: "⪳", precsim: "≾", prime: "′", Prime: "″", primes: "ℙ", prnap: "⪹", prnE: "⪵", prnsim: "⋨", prod: "∏", Product: "∏", profalar: "⌮", profline: "⌒", profsurf: "⌓", prop: "∝", Proportional: "∝", Proportion: "∷", propto: "∝", prsim: "≾", prurel: "⊰", Pscr: "𝒫", pscr: "𝓅", Psi: "Ψ", psi: "ψ", puncsp: " ", Qfr: "𝔔", qfr: "𝔮", qint: "⨌", qopf: "𝕢", Qopf: "ℚ", qprime: "⁗", Qscr: "𝒬", qscr: "𝓆", quaternions: "ℍ", quatint: "⨖", quest: "?", questeq: "≟", quot: "\"", QUOT: "\"", rAarr: "⇛", race: "∽̱", Racute: "Ŕ", racute: "ŕ", radic: "√", raemptyv: "⦳", rang: "⟩", Rang: "⟫", rangd: "⦒", range: "⦥", rangle: "⟩", raquo: "»", rarrap: "⥵", rarrb: "⇥", rarrbfs: "⤠", rarrc: "⤳", rarr: "→", Rarr: "↠", rArr: "⇒", rarrfs: "⤞", rarrhk: "↪", rarrlp: "↬", rarrpl: "⥅", rarrsim: "⥴", Rarrtl: "⤖", rarrtl: "↣", rarrw: "↝", ratail: "⤚", rAtail: "⤜", ratio: "∶", rationals: "ℚ", rbarr: "⤍", rBarr: "⤏", RBarr: "⤐", rbbrk: "❳", rbrace: "}", rbrack: "]", rbrke: "⦌", rbrksld: "⦎", rbrkslu: "⦐", Rcaron: "Ř", rcaron: "ř", Rcedil: "Ŗ", rcedil: "ŗ", rceil: "⌉", rcub: "}", Rcy: "Р", rcy: "р", rdca: "⤷", rdldhar: "⥩", rdquo: "”", rdquor: "”", rdsh: "↳", real: "ℜ", realine: "ℛ", realpart: "ℜ", reals: "ℝ", Re: "ℜ", rect: "▭", reg: "®", REG: "®", ReverseElement: "∋", ReverseEquilibrium: "⇋", ReverseUpEquilibrium: "⥯", rfisht: "⥽", rfloor: "⌋", rfr: "𝔯", Rfr: "ℜ", rHar: "⥤", rhard: "⇁", rharu: "⇀", rharul: "⥬", Rho: "Ρ", rho: "ρ", rhov: "ϱ", RightAngleBracket: "⟩", RightArrowBar: "⇥", rightarrow: "→", RightArrow: "→", Rightarrow: "⇒", RightArrowLeftArrow: "⇄", rightarrowtail: "↣", RightCeiling: "⌉", RightDoubleBracket: "⟧", RightDownTeeVector: "⥝", RightDownVectorBar: "⥕", RightDownVector: "⇂", RightFloor: "⌋", rightharpoondown: "⇁", rightharpoonup: "⇀", rightleftarrows: "⇄", rightleftharpoons: "⇌", rightrightarrows: "⇉", rightsquigarrow: "↝", RightTeeArrow: "↦", RightTee: "⊢", RightTeeVector: "⥛", rightthreetimes: "⋌", RightTriangleBar: "⧐", RightTriangle: "⊳", RightTriangleEqual: "⊵", RightUpDownVector: "⥏", RightUpTeeVector: "⥜", RightUpVectorBar: "⥔", RightUpVector: "↾", RightVectorBar: "⥓", RightVector: "⇀", ring: "˚", risingdotseq: "≓", rlarr: "⇄", rlhar: "⇌", rlm: "\u200f", rmoustache: "⎱", rmoust: "⎱", rnmid: "⫮", roang: "⟭", roarr: "⇾", robrk: "⟧", ropar: "⦆", ropf: "𝕣", Ropf: "ℝ", roplus: "⨮", rotimes: "⨵", RoundImplies: "⥰", rpar: ")", rpargt: "⦔", rppolint: "⨒", rrarr: "⇉", Rrightarrow: "⇛", rsaquo: "›", rscr: "𝓇", Rscr: "ℛ", rsh: "↱", Rsh: "↱", rsqb: "]", rsquo: "’", rsquor: "’", rthree: "⋌", rtimes: "⋊", rtri: "▹", rtrie: "⊵", rtrif: "▸", rtriltri: "⧎", RuleDelayed: "⧴", ruluhar: "⥨", rx: "℞", Sacute: "Ś", sacute: "ś", sbquo: "‚", scap: "⪸", Scaron: "Š", scaron: "š", Sc: "⪼", sc: "≻", sccue: "≽", sce: "⪰", scE: "⪴", Scedil: "Ş", scedil: "ş", Scirc: "Ŝ", scirc: "ŝ", scnap: "⪺", scnE: "⪶", scnsim: "⋩", scpolint: "⨓", scsim: "≿", Scy: "С", scy: "с", sdotb: "⊡", sdot: "⋅", sdote: "⩦", searhk: "⤥", searr: "↘", seArr: "⇘", searrow: "↘", sect: "§", semi: ";", seswar: "⤩", setminus: "∖", setmn: "∖", sext: "✶", Sfr: "𝔖", sfr: "𝔰", sfrown: "⌢", sharp: "♯", SHCHcy: "Щ", shchcy: "щ", SHcy: "Ш", shcy: "ш", ShortDownArrow: "↓", ShortLeftArrow: "←", shortmid: "∣", shortparallel: "∥", ShortRightArrow: "→", ShortUpArrow: "↑", shy: "\u00ad", Sigma: "Σ", sigma: "σ", sigmaf: "ς", sigmav: "ς", sim: "∼", simdot: "⩪", sime: "≃", simeq: "≃", simg: "⪞", simgE: "⪠", siml: "⪝", simlE: "⪟", simne: "≆", simplus: "⨤", simrarr: "⥲", slarr: "←", SmallCircle: "∘", smallsetminus: "∖", smashp: "⨳", smeparsl: "⧤", smid: "∣", smile: "⌣", smt: "⪪", smte: "⪬", smtes: "⪬︀", SOFTcy: "Ь", softcy: "ь", solbar: "⌿", solb: "⧄", sol: "/", Sopf: "𝕊", sopf: "𝕤", spades: "♠", spadesuit: "♠", spar: "∥", sqcap: "⊓", sqcaps: "⊓︀", sqcup: "⊔", sqcups: "⊔︀", Sqrt: "√", sqsub: "⊏", sqsube: "⊑", sqsubset: "⊏", sqsubseteq: "⊑", sqsup: "⊐", sqsupe: "⊒", sqsupset: "⊐", sqsupseteq: "⊒", square: "□", Square: "□", SquareIntersection: "⊓", SquareSubset: "⊏", SquareSubsetEqual: "⊑", SquareSuperset: "⊐", SquareSupersetEqual: "⊒", SquareUnion: "⊔", squarf: "▪", squ: "□", squf: "▪", srarr: "→", Sscr: "𝒮", sscr: "𝓈", ssetmn: "∖", ssmile: "⌣", sstarf: "⋆", Star: "⋆", star: "☆", starf: "★", straightepsilon: "ϵ", straightphi: "ϕ", strns: "¯", sub: "⊂", Sub: "⋐", subdot: "⪽", subE: "⫅", sube: "⊆", subedot: "⫃", submult: "⫁", subnE: "⫋", subne: "⊊", subplus: "⪿", subrarr: "⥹", subset: "⊂", Subset: "⋐", subseteq: "⊆", subseteqq: "⫅", SubsetEqual: "⊆", subsetneq: "⊊", subsetneqq: "⫋", subsim: "⫇", subsub: "⫕", subsup: "⫓", succapprox: "⪸", succ: "≻", succcurlyeq: "≽", Succeeds: "≻", SucceedsEqual: "⪰", SucceedsSlantEqual: "≽", SucceedsTilde: "≿", succeq: "⪰", succnapprox: "⪺", succneqq: "⪶", succnsim: "⋩", succsim: "≿", SuchThat: "∋", sum: "∑", Sum: "∑", sung: "♪", sup1: "¹", sup2: "²", sup3: "³", sup: "⊃", Sup: "⋑", supdot: "⪾", supdsub: "⫘", supE: "⫆", supe: "⊇", supedot: "⫄", Superset: "⊃", SupersetEqual: "⊇", suphsol: "⟉", suphsub: "⫗", suplarr: "⥻", supmult: "⫂", supnE: "⫌", supne: "⊋", supplus: "⫀", supset: "⊃", Supset: "⋑", supseteq: "⊇", supseteqq: "⫆", supsetneq: "⊋", supsetneqq: "⫌", supsim: "⫈", supsub: "⫔", supsup: "⫖", swarhk: "⤦", swarr: "↙", swArr: "⇙", swarrow: "↙", swnwar: "⤪", szlig: "ß", Tab: "\u0009", target: "⌖", Tau: "Τ", tau: "τ", tbrk: "⎴", Tcaron: "Ť", tcaron: "ť", Tcedil: "Ţ", tcedil: "ţ", Tcy: "Т", tcy: "т", tdot: "⃛", telrec: "⌕", Tfr: "𝔗", tfr: "𝔱", there4: "∴", therefore: "∴", Therefore: "∴", Theta: "Θ", theta: "θ", thetasym: "ϑ", thetav: "ϑ", thickapprox: "≈", thicksim: "∼", ThickSpace: " ", ThinSpace: " ", thinsp: " ", thkap: "≈", thksim: "∼", THORN: "Þ", thorn: "þ", tilde: "˜", Tilde: "∼", TildeEqual: "≃", TildeFullEqual: "≅", TildeTilde: "≈", timesbar: "⨱", timesb: "⊠", times: "×", timesd: "⨰", tint: "∭", toea: "⤨", topbot: "⌶", topcir: "⫱", top: "⊤", Topf: "𝕋", topf: "𝕥", topfork: "⫚", tosa: "⤩", tprime: "‴", trade: "™", TRADE: "™", triangle: "▵", triangledown: "▿", triangleleft: "◃", trianglelefteq: "⊴", triangleq: "≜", triangleright: "▹", trianglerighteq: "⊵", tridot: "◬", trie: "≜", triminus: "⨺", TripleDot: "⃛", triplus: "⨹", trisb: "⧍", tritime: "⨻", trpezium: "⏢", Tscr: "𝒯", tscr: "𝓉", TScy: "Ц", tscy: "ц", TSHcy: "Ћ", tshcy: "ћ", Tstrok: "Ŧ", tstrok: "ŧ", twixt: "≬", twoheadleftarrow: "↞", twoheadrightarrow: "↠", Uacute: "Ú", uacute: "ú", uarr: "↑", Uarr: "↟", uArr: "⇑", Uarrocir: "⥉", Ubrcy: "Ў", ubrcy: "ў", Ubreve: "Ŭ", ubreve: "ŭ", Ucirc: "Û", ucirc: "û", Ucy: "У", ucy: "у", udarr: "⇅", Udblac: "Ű", udblac: "ű", udhar: "⥮", ufisht: "⥾", Ufr: "𝔘", ufr: "𝔲", Ugrave: "Ù", ugrave: "ù", uHar: "⥣", uharl: "↿", uharr: "↾", uhblk: "▀", ulcorn: "⌜", ulcorner: "⌜", ulcrop: "⌏", ultri: "◸", Umacr: "Ū", umacr: "ū", uml: "¨", UnderBar: "_", UnderBrace: "⏟", UnderBracket: "⎵", UnderParenthesis: "⏝", Union: "⋃", UnionPlus: "⊎", Uogon: "Ų", uogon: "ų", Uopf: "𝕌", uopf: "𝕦", UpArrowBar: "⤒", uparrow: "↑", UpArrow: "↑", Uparrow: "⇑", UpArrowDownArrow: "⇅", updownarrow: "↕", UpDownArrow: "↕", Updownarrow: "⇕", UpEquilibrium: "⥮", upharpoonleft: "↿", upharpoonright: "↾", uplus: "⊎", UpperLeftArrow: "↖", UpperRightArrow: "↗", upsi: "υ", Upsi: "ϒ", upsih: "ϒ", Upsilon: "Υ", upsilon: "υ", UpTeeArrow: "↥", UpTee: "⊥", upuparrows: "⇈", urcorn: "⌝", urcorner: "⌝", urcrop: "⌎", Uring: "Ů", uring: "ů", urtri: "◹", Uscr: "𝒰", uscr: "𝓊", utdot: "⋰", Utilde: "Ũ", utilde: "ũ", utri: "▵", utrif: "▴", uuarr: "⇈", Uuml: "Ü", uuml: "ü", uwangle: "⦧", vangrt: "⦜", varepsilon: "ϵ", varkappa: "ϰ", varnothing: "∅", varphi: "ϕ", varpi: "ϖ", varpropto: "∝", varr: "↕", vArr: "⇕", varrho: "ϱ", varsigma: "ς", varsubsetneq: "⊊︀", varsubsetneqq: "⫋︀", varsupsetneq: "⊋︀", varsupsetneqq: "⫌︀", vartheta: "ϑ", vartriangleleft: "⊲", vartriangleright: "⊳", vBar: "⫨", Vbar: "⫫", vBarv: "⫩", Vcy: "В", vcy: "в", vdash: "⊢", vDash: "⊨", Vdash: "⊩", VDash: "⊫", Vdashl: "⫦", veebar: "⊻", vee: "∨", Vee: "⋁", veeeq: "≚", vellip: "⋮", verbar: "|", Verbar: "‖", vert: "|", Vert: "‖", VerticalBar: "∣", VerticalLine: "|", VerticalSeparator: "❘", VerticalTilde: "≀", VeryThinSpace: " ", Vfr: "𝔙", vfr: "𝔳", vltri: "⊲", vnsub: "⊂⃒", vnsup: "⊃⃒", Vopf: "𝕍", vopf: "𝕧", vprop: "∝", vrtri: "⊳", Vscr: "𝒱", vscr: "𝓋", vsubnE: "⫋︀", vsubne: "⊊︀", vsupnE: "⫌︀", vsupne: "⊋︀", Vvdash: "⊪", vzigzag: "⦚", Wcirc: "Ŵ", wcirc: "ŵ", wedbar: "⩟", wedge: "∧", Wedge: "⋀", wedgeq: "≙", weierp: "℘", Wfr: "𝔚", wfr: "𝔴", Wopf: "𝕎", wopf: "𝕨", wp: "℘", wr: "≀", wreath: "≀", Wscr: "𝒲", wscr: "𝓌", xcap: "⋂", xcirc: "◯", xcup: "⋃", xdtri: "▽", Xfr: "𝔛", xfr: "𝔵", xharr: "⟷", xhArr: "⟺", Xi: "Ξ", xi: "ξ", xlarr: "⟵", xlArr: "⟸", xmap: "⟼", xnis: "⋻", xodot: "⨀", Xopf: "𝕏", xopf: "𝕩", xoplus: "⨁", xotime: "⨂", xrarr: "⟶", xrArr: "⟹", Xscr: "𝒳", xscr: "𝓍", xsqcup: "⨆", xuplus: "⨄", xutri: "△", xvee: "⋁", xwedge: "⋀", Yacute: "Ý", yacute: "ý", YAcy: "Я", yacy: "я", Ycirc: "Ŷ", ycirc: "ŷ", Ycy: "Ы", ycy: "ы", yen: "¥", Yfr: "𝔜", yfr: "𝔶", YIcy: "Ї", yicy: "ї", Yopf: "𝕐", yopf: "𝕪", Yscr: "𝒴", yscr: "𝓎", YUcy: "Ю", yucy: "ю", yuml: "ÿ", Yuml: "Ÿ", Zacute: "Ź", zacute: "ź", Zcaron: "Ž", zcaron: "ž", Zcy: "З", zcy: "з", Zdot: "Ż", zdot: "ż", zeetrf: "ℨ", ZeroWidthSpace: "", Zeta: "Ζ", zeta: "ζ", zfr: "𝔷", Zfr: "ℨ", ZHcy: "Ж", zhcy: "ж", zigrarr: "⇝", zopf: "𝕫", Zopf: "ℤ", Zscr: "𝒵", zscr: "𝓏", zwj: "\u200d", zwnj: "\u200c" 2703 }; 2704 2705 var HEXCHARCODE = /^#[xX]([A-Fa-f0-9]+)$/; 2706 var CHARCODE = /^#([0-9]+)$/; 2707 var NAMED = /^([A-Za-z0-9]+)$/; 2708 var EntityParser = /** @class */ (function () { 2709 function EntityParser(named) { 2710 this.named = named; 2711 } 2712 EntityParser.prototype.parse = function (entity) { 2713 if (!entity) { 2714 return; 2715 } 2716 var matches = entity.match(HEXCHARCODE); 2717 if (matches) { 2718 return String.fromCharCode(parseInt(matches[1], 16)); 2719 } 2720 matches = entity.match(CHARCODE); 2721 if (matches) { 2722 return String.fromCharCode(parseInt(matches[1], 10)); 2723 } 2724 matches = entity.match(NAMED); 2725 if (matches) { 2726 return this.named[matches[1]]; 2727 } 2728 }; 2729 return EntityParser; 2730 }()); 2731 2732 var WSP = /[\t\n\f ]/; 2733 var ALPHA = /[A-Za-z]/; 2734 var CRLF = /\r\n?/g; 2735 function isSpace(char) { 2736 return WSP.test(char); 2737 } 2738 function isAlpha(char) { 2739 return ALPHA.test(char); 2740 } 2741 function preprocessInput(input) { 2742 return input.replace(CRLF, '\n'); 2743 } 2744 2745 var EventedTokenizer = /** @class */ (function () { 2746 function EventedTokenizer(delegate, entityParser, mode) { 2747 if (mode === void 0) { mode = 'precompile'; } 2748 this.delegate = delegate; 2749 this.entityParser = entityParser; 2750 this.mode = mode; 2751 this.state = "beforeData" /* beforeData */; 2752 this.line = -1; 2753 this.column = -1; 2754 this.input = ''; 2755 this.index = -1; 2756 this.tagNameBuffer = ''; 2757 this.states = { 2758 beforeData: function () { 2759 var char = this.peek(); 2760 if (char === '<' && !this.isIgnoredEndTag()) { 2761 this.transitionTo("tagOpen" /* tagOpen */); 2762 this.markTagStart(); 2763 this.consume(); 2764 } 2765 else { 2766 if (this.mode === 'precompile' && char === '\n') { 2767 var tag = this.tagNameBuffer.toLowerCase(); 2768 if (tag === 'pre' || tag === 'textarea') { 2769 this.consume(); 2770 } 2771 } 2772 this.transitionTo("data" /* data */); 2773 this.delegate.beginData(); 2774 } 2775 }, 2776 data: function () { 2777 var char = this.peek(); 2778 var tag = this.tagNameBuffer; 2779 if (char === '<' && !this.isIgnoredEndTag()) { 2780 this.delegate.finishData(); 2781 this.transitionTo("tagOpen" /* tagOpen */); 2782 this.markTagStart(); 2783 this.consume(); 2784 } 2785 else if (char === '&' && tag !== 'script' && tag !== 'style') { 2786 this.consume(); 2787 this.delegate.appendToData(this.consumeCharRef() || '&'); 2788 } 2789 else { 2790 this.consume(); 2791 this.delegate.appendToData(char); 2792 } 2793 }, 2794 tagOpen: function () { 2795 var char = this.consume(); 2796 if (char === '!') { 2797 this.transitionTo("markupDeclarationOpen" /* markupDeclarationOpen */); 2798 } 2799 else if (char === '/') { 2800 this.transitionTo("endTagOpen" /* endTagOpen */); 2801 } 2802 else if (char === '@' || char === ':' || isAlpha(char)) { 2803 this.transitionTo("tagName" /* tagName */); 2804 this.tagNameBuffer = ''; 2805 this.delegate.beginStartTag(); 2806 this.appendToTagName(char); 2807 } 2808 }, 2809 markupDeclarationOpen: function () { 2810 var char = this.consume(); 2811 if (char === '-' && this.peek() === '-') { 2812 this.consume(); 2813 this.transitionTo("commentStart" /* commentStart */); 2814 this.delegate.beginComment(); 2815 } 2816 else { 2817 var maybeDoctype = char.toUpperCase() + this.input.substring(this.index, this.index + 6).toUpperCase(); 2818 if (maybeDoctype === 'DOCTYPE') { 2819 this.consume(); 2820 this.consume(); 2821 this.consume(); 2822 this.consume(); 2823 this.consume(); 2824 this.consume(); 2825 this.transitionTo("doctype" /* doctype */); 2826 if (this.delegate.beginDoctype) 2827 this.delegate.beginDoctype(); 2828 } 2829 } 2830 }, 2831 doctype: function () { 2832 var char = this.consume(); 2833 if (isSpace(char)) { 2834 this.transitionTo("beforeDoctypeName" /* beforeDoctypeName */); 2835 } 2836 }, 2837 beforeDoctypeName: function () { 2838 var char = this.consume(); 2839 if (isSpace(char)) { 2840 return; 2841 } 2842 else { 2843 this.transitionTo("doctypeName" /* doctypeName */); 2844 if (this.delegate.appendToDoctypeName) 2845 this.delegate.appendToDoctypeName(char.toLowerCase()); 2846 } 2847 }, 2848 doctypeName: function () { 2849 var char = this.consume(); 2850 if (isSpace(char)) { 2851 this.transitionTo("afterDoctypeName" /* afterDoctypeName */); 2852 } 2853 else if (char === '>') { 2854 if (this.delegate.endDoctype) 2855 this.delegate.endDoctype(); 2856 this.transitionTo("beforeData" /* beforeData */); 2857 } 2858 else { 2859 if (this.delegate.appendToDoctypeName) 2860 this.delegate.appendToDoctypeName(char.toLowerCase()); 2861 } 2862 }, 2863 afterDoctypeName: function () { 2864 var char = this.consume(); 2865 if (isSpace(char)) { 2866 return; 2867 } 2868 else if (char === '>') { 2869 if (this.delegate.endDoctype) 2870 this.delegate.endDoctype(); 2871 this.transitionTo("beforeData" /* beforeData */); 2872 } 2873 else { 2874 var nextSixChars = char.toUpperCase() + this.input.substring(this.index, this.index + 5).toUpperCase(); 2875 var isPublic = nextSixChars.toUpperCase() === 'PUBLIC'; 2876 var isSystem = nextSixChars.toUpperCase() === 'SYSTEM'; 2877 if (isPublic || isSystem) { 2878 this.consume(); 2879 this.consume(); 2880 this.consume(); 2881 this.consume(); 2882 this.consume(); 2883 this.consume(); 2884 } 2885 if (isPublic) { 2886 this.transitionTo("afterDoctypePublicKeyword" /* afterDoctypePublicKeyword */); 2887 } 2888 else if (isSystem) { 2889 this.transitionTo("afterDoctypeSystemKeyword" /* afterDoctypeSystemKeyword */); 2890 } 2891 } 2892 }, 2893 afterDoctypePublicKeyword: function () { 2894 var char = this.peek(); 2895 if (isSpace(char)) { 2896 this.transitionTo("beforeDoctypePublicIdentifier" /* beforeDoctypePublicIdentifier */); 2897 this.consume(); 2898 } 2899 else if (char === '"') { 2900 this.transitionTo("doctypePublicIdentifierDoubleQuoted" /* doctypePublicIdentifierDoubleQuoted */); 2901 this.consume(); 2902 } 2903 else if (char === "'") { 2904 this.transitionTo("doctypePublicIdentifierSingleQuoted" /* doctypePublicIdentifierSingleQuoted */); 2905 this.consume(); 2906 } 2907 else if (char === '>') { 2908 this.consume(); 2909 if (this.delegate.endDoctype) 2910 this.delegate.endDoctype(); 2911 this.transitionTo("beforeData" /* beforeData */); 2912 } 2913 }, 2914 doctypePublicIdentifierDoubleQuoted: function () { 2915 var char = this.consume(); 2916 if (char === '"') { 2917 this.transitionTo("afterDoctypePublicIdentifier" /* afterDoctypePublicIdentifier */); 2918 } 2919 else if (char === '>') { 2920 if (this.delegate.endDoctype) 2921 this.delegate.endDoctype(); 2922 this.transitionTo("beforeData" /* beforeData */); 2923 } 2924 else { 2925 if (this.delegate.appendToDoctypePublicIdentifier) 2926 this.delegate.appendToDoctypePublicIdentifier(char); 2927 } 2928 }, 2929 doctypePublicIdentifierSingleQuoted: function () { 2930 var char = this.consume(); 2931 if (char === "'") { 2932 this.transitionTo("afterDoctypePublicIdentifier" /* afterDoctypePublicIdentifier */); 2933 } 2934 else if (char === '>') { 2935 if (this.delegate.endDoctype) 2936 this.delegate.endDoctype(); 2937 this.transitionTo("beforeData" /* beforeData */); 2938 } 2939 else { 2940 if (this.delegate.appendToDoctypePublicIdentifier) 2941 this.delegate.appendToDoctypePublicIdentifier(char); 2942 } 2943 }, 2944 afterDoctypePublicIdentifier: function () { 2945 var char = this.consume(); 2946 if (isSpace(char)) { 2947 this.transitionTo("betweenDoctypePublicAndSystemIdentifiers" /* betweenDoctypePublicAndSystemIdentifiers */); 2948 } 2949 else if (char === '>') { 2950 if (this.delegate.endDoctype) 2951 this.delegate.endDoctype(); 2952 this.transitionTo("beforeData" /* beforeData */); 2953 } 2954 else if (char === '"') { 2955 this.transitionTo("doctypeSystemIdentifierDoubleQuoted" /* doctypeSystemIdentifierDoubleQuoted */); 2956 } 2957 else if (char === "'") { 2958 this.transitionTo("doctypeSystemIdentifierSingleQuoted" /* doctypeSystemIdentifierSingleQuoted */); 2959 } 2960 }, 2961 betweenDoctypePublicAndSystemIdentifiers: function () { 2962 var char = this.consume(); 2963 if (isSpace(char)) { 2964 return; 2965 } 2966 else if (char === '>') { 2967 if (this.delegate.endDoctype) 2968 this.delegate.endDoctype(); 2969 this.transitionTo("beforeData" /* beforeData */); 2970 } 2971 else if (char === '"') { 2972 this.transitionTo("doctypeSystemIdentifierDoubleQuoted" /* doctypeSystemIdentifierDoubleQuoted */); 2973 } 2974 else if (char === "'") { 2975 this.transitionTo("doctypeSystemIdentifierSingleQuoted" /* doctypeSystemIdentifierSingleQuoted */); 2976 } 2977 }, 2978 doctypeSystemIdentifierDoubleQuoted: function () { 2979 var char = this.consume(); 2980 if (char === '"') { 2981 this.transitionTo("afterDoctypeSystemIdentifier" /* afterDoctypeSystemIdentifier */); 2982 } 2983 else if (char === '>') { 2984 if (this.delegate.endDoctype) 2985 this.delegate.endDoctype(); 2986 this.transitionTo("beforeData" /* beforeData */); 2987 } 2988 else { 2989 if (this.delegate.appendToDoctypeSystemIdentifier) 2990 this.delegate.appendToDoctypeSystemIdentifier(char); 2991 } 2992 }, 2993 doctypeSystemIdentifierSingleQuoted: function () { 2994 var char = this.consume(); 2995 if (char === "'") { 2996 this.transitionTo("afterDoctypeSystemIdentifier" /* afterDoctypeSystemIdentifier */); 2997 } 2998 else if (char === '>') { 2999 if (this.delegate.endDoctype) 3000 this.delegate.endDoctype(); 3001 this.transitionTo("beforeData" /* beforeData */); 3002 } 3003 else { 3004 if (this.delegate.appendToDoctypeSystemIdentifier) 3005 this.delegate.appendToDoctypeSystemIdentifier(char); 3006 } 3007 }, 3008 afterDoctypeSystemIdentifier: function () { 3009 var char = this.consume(); 3010 if (isSpace(char)) { 3011 return; 3012 } 3013 else if (char === '>') { 3014 if (this.delegate.endDoctype) 3015 this.delegate.endDoctype(); 3016 this.transitionTo("beforeData" /* beforeData */); 3017 } 3018 }, 3019 commentStart: function () { 3020 var char = this.consume(); 3021 if (char === '-') { 3022 this.transitionTo("commentStartDash" /* commentStartDash */); 3023 } 3024 else if (char === '>') { 3025 this.delegate.finishComment(); 3026 this.transitionTo("beforeData" /* beforeData */); 3027 } 3028 else { 3029 this.delegate.appendToCommentData(char); 3030 this.transitionTo("comment" /* comment */); 3031 } 3032 }, 3033 commentStartDash: function () { 3034 var char = this.consume(); 3035 if (char === '-') { 3036 this.transitionTo("commentEnd" /* commentEnd */); 3037 } 3038 else if (char === '>') { 3039 this.delegate.finishComment(); 3040 this.transitionTo("beforeData" /* beforeData */); 3041 } 3042 else { 3043 this.delegate.appendToCommentData('-'); 3044 this.transitionTo("comment" /* comment */); 3045 } 3046 }, 3047 comment: function () { 3048 var char = this.consume(); 3049 if (char === '-') { 3050 this.transitionTo("commentEndDash" /* commentEndDash */); 3051 } 3052 else { 3053 this.delegate.appendToCommentData(char); 3054 } 3055 }, 3056 commentEndDash: function () { 3057 var char = this.consume(); 3058 if (char === '-') { 3059 this.transitionTo("commentEnd" /* commentEnd */); 3060 } 3061 else { 3062 this.delegate.appendToCommentData('-' + char); 3063 this.transitionTo("comment" /* comment */); 3064 } 3065 }, 3066 commentEnd: function () { 3067 var char = this.consume(); 3068 if (char === '>') { 3069 this.delegate.finishComment(); 3070 this.transitionTo("beforeData" /* beforeData */); 3071 } 3072 else { 3073 this.delegate.appendToCommentData('--' + char); 3074 this.transitionTo("comment" /* comment */); 3075 } 3076 }, 3077 tagName: function () { 3078 var char = this.consume(); 3079 if (isSpace(char)) { 3080 this.transitionTo("beforeAttributeName" /* beforeAttributeName */); 3081 } 3082 else if (char === '/') { 3083 this.transitionTo("selfClosingStartTag" /* selfClosingStartTag */); 3084 } 3085 else if (char === '>') { 3086 this.delegate.finishTag(); 3087 this.transitionTo("beforeData" /* beforeData */); 3088 } 3089 else { 3090 this.appendToTagName(char); 3091 } 3092 }, 3093 endTagName: function () { 3094 var char = this.consume(); 3095 if (isSpace(char)) { 3096 this.transitionTo("beforeAttributeName" /* beforeAttributeName */); 3097 this.tagNameBuffer = ''; 3098 } 3099 else if (char === '/') { 3100 this.transitionTo("selfClosingStartTag" /* selfClosingStartTag */); 3101 this.tagNameBuffer = ''; 3102 } 3103 else if (char === '>') { 3104 this.delegate.finishTag(); 3105 this.transitionTo("beforeData" /* beforeData */); 3106 this.tagNameBuffer = ''; 3107 } 3108 else { 3109 this.appendToTagName(char); 3110 } 3111 }, 3112 beforeAttributeName: function () { 3113 var char = this.peek(); 3114 if (isSpace(char)) { 3115 this.consume(); 3116 return; 3117 } 3118 else if (char === '/') { 3119 this.transitionTo("selfClosingStartTag" /* selfClosingStartTag */); 3120 this.consume(); 3121 } 3122 else if (char === '>') { 3123 this.consume(); 3124 this.delegate.finishTag(); 3125 this.transitionTo("beforeData" /* beforeData */); 3126 } 3127 else if (char === '=') { 3128 this.delegate.reportSyntaxError('attribute name cannot start with equals sign'); 3129 this.transitionTo("attributeName" /* attributeName */); 3130 this.delegate.beginAttribute(); 3131 this.consume(); 3132 this.delegate.appendToAttributeName(char); 3133 } 3134 else { 3135 this.transitionTo("attributeName" /* attributeName */); 3136 this.delegate.beginAttribute(); 3137 } 3138 }, 3139 attributeName: function () { 3140 var char = this.peek(); 3141 if (isSpace(char)) { 3142 this.transitionTo("afterAttributeName" /* afterAttributeName */); 3143 this.consume(); 3144 } 3145 else if (char === '/') { 3146 this.delegate.beginAttributeValue(false); 3147 this.delegate.finishAttributeValue(); 3148 this.consume(); 3149 this.transitionTo("selfClosingStartTag" /* selfClosingStartTag */); 3150 } 3151 else if (char === '=') { 3152 this.transitionTo("beforeAttributeValue" /* beforeAttributeValue */); 3153 this.consume(); 3154 } 3155 else if (char === '>') { 3156 this.delegate.beginAttributeValue(false); 3157 this.delegate.finishAttributeValue(); 3158 this.consume(); 3159 this.delegate.finishTag(); 3160 this.transitionTo("beforeData" /* beforeData */); 3161 } 3162 else if (char === '"' || char === "'" || char === '<') { 3163 this.delegate.reportSyntaxError(char + ' is not a valid character within attribute names'); 3164 this.consume(); 3165 this.delegate.appendToAttributeName(char); 3166 } 3167 else { 3168 this.consume(); 3169 this.delegate.appendToAttributeName(char); 3170 } 3171 }, 3172 afterAttributeName: function () { 3173 var char = this.peek(); 3174 if (isSpace(char)) { 3175 this.consume(); 3176 return; 3177 } 3178 else if (char === '/') { 3179 this.delegate.beginAttributeValue(false); 3180 this.delegate.finishAttributeValue(); 3181 this.consume(); 3182 this.transitionTo("selfClosingStartTag" /* selfClosingStartTag */); 3183 } 3184 else if (char === '=') { 3185 this.consume(); 3186 this.transitionTo("beforeAttributeValue" /* beforeAttributeValue */); 3187 } 3188 else if (char === '>') { 3189 this.delegate.beginAttributeValue(false); 3190 this.delegate.finishAttributeValue(); 3191 this.consume(); 3192 this.delegate.finishTag(); 3193 this.transitionTo("beforeData" /* beforeData */); 3194 } 3195 else { 3196 this.delegate.beginAttributeValue(false); 3197 this.delegate.finishAttributeValue(); 3198 this.transitionTo("attributeName" /* attributeName */); 3199 this.delegate.beginAttribute(); 3200 this.consume(); 3201 this.delegate.appendToAttributeName(char); 3202 } 3203 }, 3204 beforeAttributeValue: function () { 3205 var char = this.peek(); 3206 if (isSpace(char)) { 3207 this.consume(); 3208 } 3209 else if (char === '"') { 3210 this.transitionTo("attributeValueDoubleQuoted" /* attributeValueDoubleQuoted */); 3211 this.delegate.beginAttributeValue(true); 3212 this.consume(); 3213 } 3214 else if (char === "'") { 3215 this.transitionTo("attributeValueSingleQuoted" /* attributeValueSingleQuoted */); 3216 this.delegate.beginAttributeValue(true); 3217 this.consume(); 3218 } 3219 else if (char === '>') { 3220 this.delegate.beginAttributeValue(false); 3221 this.delegate.finishAttributeValue(); 3222 this.consume(); 3223 this.delegate.finishTag(); 3224 this.transitionTo("beforeData" /* beforeData */); 3225 } 3226 else { 3227 this.transitionTo("attributeValueUnquoted" /* attributeValueUnquoted */); 3228 this.delegate.beginAttributeValue(false); 3229 this.consume(); 3230 this.delegate.appendToAttributeValue(char); 3231 } 3232 }, 3233 attributeValueDoubleQuoted: function () { 3234 var char = this.consume(); 3235 if (char === '"') { 3236 this.delegate.finishAttributeValue(); 3237 this.transitionTo("afterAttributeValueQuoted" /* afterAttributeValueQuoted */); 3238 } 3239 else if (char === '&') { 3240 this.delegate.appendToAttributeValue(this.consumeCharRef() || '&'); 3241 } 3242 else { 3243 this.delegate.appendToAttributeValue(char); 3244 } 3245 }, 3246 attributeValueSingleQuoted: function () { 3247 var char = this.consume(); 3248 if (char === "'") { 3249 this.delegate.finishAttributeValue(); 3250 this.transitionTo("afterAttributeValueQuoted" /* afterAttributeValueQuoted */); 3251 } 3252 else if (char === '&') { 3253 this.delegate.appendToAttributeValue(this.consumeCharRef() || '&'); 3254 } 3255 else { 3256 this.delegate.appendToAttributeValue(char); 3257 } 3258 }, 3259 attributeValueUnquoted: function () { 3260 var char = this.peek(); 3261 if (isSpace(char)) { 3262 this.delegate.finishAttributeValue(); 3263 this.consume(); 3264 this.transitionTo("beforeAttributeName" /* beforeAttributeName */); 3265 } 3266 else if (char === '/') { 3267 this.delegate.finishAttributeValue(); 3268 this.consume(); 3269 this.transitionTo("selfClosingStartTag" /* selfClosingStartTag */); 3270 } 3271 else if (char === '&') { 3272 this.consume(); 3273 this.delegate.appendToAttributeValue(this.consumeCharRef() || '&'); 3274 } 3275 else if (char === '>') { 3276 this.delegate.finishAttributeValue(); 3277 this.consume(); 3278 this.delegate.finishTag(); 3279 this.transitionTo("beforeData" /* beforeData */); 3280 } 3281 else { 3282 this.consume(); 3283 this.delegate.appendToAttributeValue(char); 3284 } 3285 }, 3286 afterAttributeValueQuoted: function () { 3287 var char = this.peek(); 3288 if (isSpace(char)) { 3289 this.consume(); 3290 this.transitionTo("beforeAttributeName" /* beforeAttributeName */); 3291 } 3292 else if (char === '/') { 3293 this.consume(); 3294 this.transitionTo("selfClosingStartTag" /* selfClosingStartTag */); 3295 } 3296 else if (char === '>') { 3297 this.consume(); 3298 this.delegate.finishTag(); 3299 this.transitionTo("beforeData" /* beforeData */); 3300 } 3301 else { 3302 this.transitionTo("beforeAttributeName" /* beforeAttributeName */); 3303 } 3304 }, 3305 selfClosingStartTag: function () { 3306 var char = this.peek(); 3307 if (char === '>') { 3308 this.consume(); 3309 this.delegate.markTagAsSelfClosing(); 3310 this.delegate.finishTag(); 3311 this.transitionTo("beforeData" /* beforeData */); 3312 } 3313 else { 3314 this.transitionTo("beforeAttributeName" /* beforeAttributeName */); 3315 } 3316 }, 3317 endTagOpen: function () { 3318 var char = this.consume(); 3319 if (char === '@' || char === ':' || isAlpha(char)) { 3320 this.transitionTo("endTagName" /* endTagName */); 3321 this.tagNameBuffer = ''; 3322 this.delegate.beginEndTag(); 3323 this.appendToTagName(char); 3324 } 3325 } 3326 }; 3327 this.reset(); 3328 } 3329 EventedTokenizer.prototype.reset = function () { 3330 this.transitionTo("beforeData" /* beforeData */); 3331 this.input = ''; 3332 this.tagNameBuffer = ''; 3333 this.index = 0; 3334 this.line = 1; 3335 this.column = 0; 3336 this.delegate.reset(); 3337 }; 3338 EventedTokenizer.prototype.transitionTo = function (state) { 3339 this.state = state; 3340 }; 3341 EventedTokenizer.prototype.tokenize = function (input) { 3342 this.reset(); 3343 this.tokenizePart(input); 3344 this.tokenizeEOF(); 3345 }; 3346 EventedTokenizer.prototype.tokenizePart = function (input) { 3347 this.input += preprocessInput(input); 3348 while (this.index < this.input.length) { 3349 var handler = this.states[this.state]; 3350 if (handler !== undefined) { 3351 handler.call(this); 3352 } 3353 else { 3354 throw new Error("unhandled state " + this.state); 3355 } 3356 } 3357 }; 3358 EventedTokenizer.prototype.tokenizeEOF = function () { 3359 this.flushData(); 3360 }; 3361 EventedTokenizer.prototype.flushData = function () { 3362 if (this.state === 'data') { 3363 this.delegate.finishData(); 3364 this.transitionTo("beforeData" /* beforeData */); 3365 } 3366 }; 3367 EventedTokenizer.prototype.peek = function () { 3368 return this.input.charAt(this.index); 3369 }; 3370 EventedTokenizer.prototype.consume = function () { 3371 var char = this.peek(); 3372 this.index++; 3373 if (char === '\n') { 3374 this.line++; 3375 this.column = 0; 3376 } 3377 else { 3378 this.column++; 3379 } 3380 return char; 3381 }; 3382 EventedTokenizer.prototype.consumeCharRef = function () { 3383 var endIndex = this.input.indexOf(';', this.index); 3384 if (endIndex === -1) { 3385 return; 3386 } 3387 var entity = this.input.slice(this.index, endIndex); 3388 var chars = this.entityParser.parse(entity); 3389 if (chars) { 3390 var count = entity.length; 3391 // consume the entity chars 3392 while (count) { 3393 this.consume(); 3394 count--; 3395 } 3396 // consume the `;` 3397 this.consume(); 3398 return chars; 3399 } 3400 }; 3401 EventedTokenizer.prototype.markTagStart = function () { 3402 this.delegate.tagOpen(); 3403 }; 3404 EventedTokenizer.prototype.appendToTagName = function (char) { 3405 this.tagNameBuffer += char; 3406 this.delegate.appendToTagName(char); 3407 }; 3408 EventedTokenizer.prototype.isIgnoredEndTag = function () { 3409 var tag = this.tagNameBuffer; 3410 return (tag === 'title' && this.input.substring(this.index, this.index + 8) !== '</title>') || 3411 (tag === 'style' && this.input.substring(this.index, this.index + 8) !== '</style>') || 3412 (tag === 'script' && this.input.substring(this.index, this.index + 9) !== '</script>'); 3413 }; 3414 return EventedTokenizer; 3415 }()); 3416 3417 var Tokenizer = /** @class */ (function () { 3418 function Tokenizer(entityParser, options) { 3419 if (options === void 0) { options = {}; } 3420 this.options = options; 3421 this.token = null; 3422 this.startLine = 1; 3423 this.startColumn = 0; 3424 this.tokens = []; 3425 this.tokenizer = new EventedTokenizer(this, entityParser, options.mode); 3426 this._currentAttribute = undefined; 3427 } 3428 Tokenizer.prototype.tokenize = function (input) { 3429 this.tokens = []; 3430 this.tokenizer.tokenize(input); 3431 return this.tokens; 3432 }; 3433 Tokenizer.prototype.tokenizePart = function (input) { 3434 this.tokens = []; 3435 this.tokenizer.tokenizePart(input); 3436 return this.tokens; 3437 }; 3438 Tokenizer.prototype.tokenizeEOF = function () { 3439 this.tokens = []; 3440 this.tokenizer.tokenizeEOF(); 3441 return this.tokens[0]; 3442 }; 3443 Tokenizer.prototype.reset = function () { 3444 this.token = null; 3445 this.startLine = 1; 3446 this.startColumn = 0; 3447 }; 3448 Tokenizer.prototype.current = function () { 3449 var token = this.token; 3450 if (token === null) { 3451 throw new Error('token was unexpectedly null'); 3452 } 3453 if (arguments.length === 0) { 3454 return token; 3455 } 3456 for (var i = 0; i < arguments.length; i++) { 3457 if (token.type === arguments[i]) { 3458 return token; 3459 } 3460 } 3461 throw new Error("token type was unexpectedly " + token.type); 3462 }; 3463 Tokenizer.prototype.push = function (token) { 3464 this.token = token; 3465 this.tokens.push(token); 3466 }; 3467 Tokenizer.prototype.currentAttribute = function () { 3468 return this._currentAttribute; 3469 }; 3470 Tokenizer.prototype.addLocInfo = function () { 3471 if (this.options.loc) { 3472 this.current().loc = { 3473 start: { 3474 line: this.startLine, 3475 column: this.startColumn 3476 }, 3477 end: { 3478 line: this.tokenizer.line, 3479 column: this.tokenizer.column 3480 } 3481 }; 3482 } 3483 this.startLine = this.tokenizer.line; 3484 this.startColumn = this.tokenizer.column; 3485 }; 3486 // Data 3487 Tokenizer.prototype.beginDoctype = function () { 3488 this.push({ 3489 type: "Doctype" /* Doctype */, 3490 name: '', 3491 }); 3492 }; 3493 Tokenizer.prototype.appendToDoctypeName = function (char) { 3494 this.current("Doctype" /* Doctype */).name += char; 3495 }; 3496 Tokenizer.prototype.appendToDoctypePublicIdentifier = function (char) { 3497 var doctype = this.current("Doctype" /* Doctype */); 3498 if (doctype.publicIdentifier === undefined) { 3499 doctype.publicIdentifier = char; 3500 } 3501 else { 3502 doctype.publicIdentifier += char; 3503 } 3504 }; 3505 Tokenizer.prototype.appendToDoctypeSystemIdentifier = function (char) { 3506 var doctype = this.current("Doctype" /* Doctype */); 3507 if (doctype.systemIdentifier === undefined) { 3508 doctype.systemIdentifier = char; 3509 } 3510 else { 3511 doctype.systemIdentifier += char; 3512 } 3513 }; 3514 Tokenizer.prototype.endDoctype = function () { 3515 this.addLocInfo(); 3516 }; 3517 Tokenizer.prototype.beginData = function () { 3518 this.push({ 3519 type: "Chars" /* Chars */, 3520 chars: '' 3521 }); 3522 }; 3523 Tokenizer.prototype.appendToData = function (char) { 3524 this.current("Chars" /* Chars */).chars += char; 3525 }; 3526 Tokenizer.prototype.finishData = function () { 3527 this.addLocInfo(); 3528 }; 3529 // Comment 3530 Tokenizer.prototype.beginComment = function () { 3531 this.push({ 3532 type: "Comment" /* Comment */, 3533 chars: '' 3534 }); 3535 }; 3536 Tokenizer.prototype.appendToCommentData = function (char) { 3537 this.current("Comment" /* Comment */).chars += char; 3538 }; 3539 Tokenizer.prototype.finishComment = function () { 3540 this.addLocInfo(); 3541 }; 3542 // Tags - basic 3543 Tokenizer.prototype.tagOpen = function () { }; 3544 Tokenizer.prototype.beginStartTag = function () { 3545 this.push({ 3546 type: "StartTag" /* StartTag */, 3547 tagName: '', 3548 attributes: [], 3549 selfClosing: false 3550 }); 3551 }; 3552 Tokenizer.prototype.beginEndTag = function () { 3553 this.push({ 3554 type: "EndTag" /* EndTag */, 3555 tagName: '' 3556 }); 3557 }; 3558 Tokenizer.prototype.finishTag = function () { 3559 this.addLocInfo(); 3560 }; 3561 Tokenizer.prototype.markTagAsSelfClosing = function () { 3562 this.current("StartTag" /* StartTag */).selfClosing = true; 3563 }; 3564 // Tags - name 3565 Tokenizer.prototype.appendToTagName = function (char) { 3566 this.current("StartTag" /* StartTag */, "EndTag" /* EndTag */).tagName += char; 3567 }; 3568 // Tags - attributes 3569 Tokenizer.prototype.beginAttribute = function () { 3570 this._currentAttribute = ['', '', false]; 3571 }; 3572 Tokenizer.prototype.appendToAttributeName = function (char) { 3573 this.currentAttribute()[0] += char; 3574 }; 3575 Tokenizer.prototype.beginAttributeValue = function (isQuoted) { 3576 this.currentAttribute()[2] = isQuoted; 3577 }; 3578 Tokenizer.prototype.appendToAttributeValue = function (char) { 3579 this.currentAttribute()[1] += char; 3580 }; 3581 Tokenizer.prototype.finishAttributeValue = function () { 3582 this.current("StartTag" /* StartTag */).attributes.push(this._currentAttribute); 3583 }; 3584 Tokenizer.prototype.reportSyntaxError = function (message) { 3585 this.current().syntaxError = message; 3586 }; 3587 return Tokenizer; 3588 }()); 3589 3590 function tokenize(input, options) { 3591 var tokenizer = new Tokenizer(new EntityParser(namedCharRefs), options); 3592 return tokenizer.tokenize(input); 3593 } 3594 3595 3596 3597 // EXTERNAL MODULE: external ["wp","htmlEntities"] 3598 var external_wp_htmlEntities_ = __webpack_require__("rmEH"); 3599 3600 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/validation/logger.js 3601 function createLogger() { 3602 /** 3603 * Creates a log handler with block validation prefix. 3604 * 3605 * @param {Function} logger Original logger function. 3606 * 3607 * @return {Function} Augmented logger function. 3608 */ 3609 function createLogHandler(logger) { 3610 let log = (message, ...args) => logger('Block validation: ' + message, ...args); // In test environments, pre-process string substitutions to improve 3611 // readability of error messages. We'd prefer to avoid pulling in this 3612 // dependency in runtime environments, and it can be dropped by a combo 3613 // of Webpack env substitution + UglifyJS dead code elimination. 3614 3615 3616 if (false) {} 3617 3618 return log; 3619 } 3620 3621 return { 3622 // eslint-disable-next-line no-console 3623 error: createLogHandler(console.error), 3624 // eslint-disable-next-line no-console 3625 warning: createLogHandler(console.warn), 3626 3627 getItems() { 3628 return []; 3629 } 3630 3631 }; 3632 } 3633 function createQueuedLogger() { 3634 /** 3635 * The list of enqueued log actions to print. 3636 * 3637 * @type {Array} 3638 */ 3639 const queue = []; 3640 const logger = createLogger(); 3641 return { 3642 error(...args) { 3643 queue.push({ 3644 log: logger.error, 3645 args 3646 }); 3647 }, 3648 3649 warning(...args) { 3650 queue.push({ 3651 log: logger.warning, 3652 args 3653 }); 3654 }, 3655 3656 getItems() { 3657 return queue; 3658 } 3659 3660 }; 3661 } 3662 3663 // EXTERNAL MODULE: external ["wp","isShallowEqual"] 3664 var external_wp_isShallowEqual_ = __webpack_require__("rl8x"); 3665 var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_); 3666 3667 // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js 3668 var esm_extends = __webpack_require__("wx14"); 3669 3670 // EXTERNAL MODULE: external ["wp","compose"] 3671 var external_wp_compose_ = __webpack_require__("K9lf"); 3672 3673 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/block-content-provider/index.js 3674 3675 3676 3677 /** 3678 * WordPress dependencies 3679 */ 3680 3681 3682 /** 3683 * Internal dependencies 3684 */ 3685 3686 3687 const { 3688 Consumer, 3689 Provider 3690 } = Object(external_wp_element_["createContext"])(() => {}); 3691 /** 3692 * An internal block component used in block content serialization to inject 3693 * nested block content within the `save` implementation of the ancestor 3694 * component in which it is nested. The component provides a pre-bound 3695 * `BlockContent` component via context, which is used by the developer-facing 3696 * `InnerBlocks.Content` component to render block content. 3697 * 3698 * @example 3699 * 3700 * ```jsx 3701 * <BlockContentProvider innerBlocks={ innerBlocks }> 3702 * { blockSaveElement } 3703 * </BlockContentProvider> 3704 * ``` 3705 * 3706 * @param {Object} props Component props. 3707 * @param {WPElement} props.children Block save result. 3708 * @param {Array} props.innerBlocks Block(s) to serialize. 3709 * 3710 * @return {WPComponent} Element with BlockContent injected via context. 3711 */ 3712 3713 const BlockContentProvider = ({ 3714 children, 3715 innerBlocks 3716 }) => { 3717 const BlockContent = () => { 3718 // Value is an array of blocks, so defer to block serializer 3719 const html = serialize(innerBlocks, { 3720 isInnerBlocks: true 3721 }); // Use special-cased raw HTML tag to avoid default escaping 3722 3723 return Object(external_wp_element_["createElement"])(external_wp_element_["RawHTML"], null, html); 3724 }; 3725 3726 return Object(external_wp_element_["createElement"])(Provider, { 3727 value: BlockContent 3728 }, children); 3729 }; 3730 /** 3731 * A Higher Order Component used to inject BlockContent using context to the 3732 * wrapped component. 3733 * 3734 * @return {WPComponent} Enhanced component with injected BlockContent as prop. 3735 */ 3736 3737 3738 const withBlockContentContext = Object(external_wp_compose_["createHigherOrderComponent"])(OriginalComponent => { 3739 return props => Object(external_wp_element_["createElement"])(Consumer, null, context => Object(external_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, props, { 3740 BlockContent: context 3741 }))); 3742 }, 'withBlockContentContext'); 3743 /* harmony default export */ var block_content_provider = (BlockContentProvider); 3744 3745 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/serializer.js 3746 3747 3748 /** 3749 * External dependencies 3750 */ 3751 3752 /** 3753 * WordPress dependencies 3754 */ 3755 3756 3757 3758 3759 3760 /** 3761 * Internal dependencies 3762 */ 3763 3764 3765 3766 3767 /** 3768 * @typedef {Object} WPBlockSerializationOptions Serialization Options. 3769 * 3770 * @property {boolean} isInnerBlocks Whether we are serializing inner blocks. 3771 */ 3772 3773 /** 3774 * Returns the block's default classname from its name. 3775 * 3776 * @param {string} blockName The block name. 3777 * 3778 * @return {string} The block's default class. 3779 */ 3780 3781 function getBlockDefaultClassName(blockName) { 3782 // Generated HTML classes for blocks follow the `wp-block-{name}` nomenclature. 3783 // Blocks provided by WordPress drop the prefixes 'core/' or 'core-' (historically used in 'core-embed/'). 3784 const className = 'wp-block-' + blockName.replace(/\//, '-').replace(/^core-/, ''); 3785 return Object(external_wp_hooks_["applyFilters"])('blocks.getBlockDefaultClassName', className, blockName); 3786 } 3787 /** 3788 * Returns the block's default menu item classname from its name. 3789 * 3790 * @param {string} blockName The block name. 3791 * 3792 * @return {string} The block's default menu item class. 3793 */ 3794 3795 function getBlockMenuDefaultClassName(blockName) { 3796 // Generated HTML classes for blocks follow the `editor-block-list-item-{name}` nomenclature. 3797 // Blocks provided by WordPress drop the prefixes 'core/' or 'core-' (historically used in 'core-embed/'). 3798 const className = 'editor-block-list-item-' + blockName.replace(/\//, '-').replace(/^core-/, ''); 3799 return Object(external_wp_hooks_["applyFilters"])('blocks.getBlockMenuDefaultClassName', className, blockName); 3800 } 3801 const blockPropsProvider = {}; 3802 /** 3803 * Call within a save function to get the props for the block wrapper. 3804 * 3805 * @param {Object} props Optional. Props to pass to the element. 3806 */ 3807 3808 function getBlockProps(props = {}) { 3809 const { 3810 blockType, 3811 attributes 3812 } = blockPropsProvider; 3813 return Object(external_wp_hooks_["applyFilters"])('blocks.getSaveContent.extraProps', { ...props 3814 }, blockType, attributes); 3815 } 3816 /** 3817 * Given a block type containing a save render implementation and attributes, returns the 3818 * enhanced element to be saved or string when raw HTML expected. 3819 * 3820 * @param {string|Object} blockTypeOrName Block type or name. 3821 * @param {Object} attributes Block attributes. 3822 * @param {?Array} innerBlocks Nested blocks. 3823 * 3824 * @return {Object|string} Save element or raw HTML string. 3825 */ 3826 3827 function getSaveElement(blockTypeOrName, attributes, innerBlocks = []) { 3828 const blockType = normalizeBlockType(blockTypeOrName); 3829 let { 3830 save 3831 } = blockType; // Component classes are unsupported for save since serialization must 3832 // occur synchronously. For improved interoperability with higher-order 3833 // components which often return component class, emulate basic support. 3834 3835 if (save.prototype instanceof external_wp_element_["Component"]) { 3836 const instance = new save({ 3837 attributes 3838 }); 3839 save = instance.render.bind(instance); 3840 } 3841 3842 blockPropsProvider.blockType = blockType; 3843 blockPropsProvider.attributes = attributes; 3844 let element = save({ 3845 attributes, 3846 innerBlocks 3847 }); 3848 const hasLightBlockWrapper = blockType.apiVersion > 1 || registration_hasBlockSupport(blockType, 'lightBlockWrapper', false); 3849 3850 if (Object(external_lodash_["isObject"])(element) && Object(external_wp_hooks_["hasFilter"])('blocks.getSaveContent.extraProps') && !hasLightBlockWrapper) { 3851 /** 3852 * Filters the props applied to the block save result element. 3853 * 3854 * @param {Object} props Props applied to save element. 3855 * @param {WPBlock} blockType Block type definition. 3856 * @param {Object} attributes Block attributes. 3857 */ 3858 const props = Object(external_wp_hooks_["applyFilters"])('blocks.getSaveContent.extraProps', { ...element.props 3859 }, blockType, attributes); 3860 3861 if (!external_wp_isShallowEqual_default()(props, element.props)) { 3862 element = Object(external_wp_element_["cloneElement"])(element, props); 3863 } 3864 } 3865 /** 3866 * Filters the save result of a block during serialization. 3867 * 3868 * @param {WPElement} element Block save result. 3869 * @param {WPBlock} blockType Block type definition. 3870 * @param {Object} attributes Block attributes. 3871 */ 3872 3873 3874 element = Object(external_wp_hooks_["applyFilters"])('blocks.getSaveElement', element, blockType, attributes); 3875 return Object(external_wp_element_["createElement"])(block_content_provider, { 3876 innerBlocks: innerBlocks 3877 }, element); 3878 } 3879 /** 3880 * Given a block type containing a save render implementation and attributes, returns the 3881 * static markup to be saved. 3882 * 3883 * @param {string|Object} blockTypeOrName Block type or name. 3884 * @param {Object} attributes Block attributes. 3885 * @param {?Array} innerBlocks Nested blocks. 3886 * 3887 * @return {string} Save content. 3888 */ 3889 3890 function getSaveContent(blockTypeOrName, attributes, innerBlocks) { 3891 const blockType = normalizeBlockType(blockTypeOrName); 3892 return Object(external_wp_element_["renderToString"])(getSaveElement(blockType, attributes, innerBlocks)); 3893 } 3894 /** 3895 * Returns attributes which are to be saved and serialized into the block 3896 * comment delimiter. 3897 * 3898 * When a block exists in memory it contains as its attributes both those 3899 * parsed the block comment delimiter _and_ those which matched from the 3900 * contents of the block. 3901 * 3902 * This function returns only those attributes which are needed to persist and 3903 * which cannot be matched from the block content. 3904 * 3905 * @param {Object<string,*>} blockType Block type. 3906 * @param {Object<string,*>} attributes Attributes from in-memory block data. 3907 * 3908 * @return {Object<string,*>} Subset of attributes for comment serialization. 3909 */ 3910 3911 function getCommentAttributes(blockType, attributes) { 3912 return Object(external_lodash_["reduce"])(blockType.attributes, (accumulator, attributeSchema, key) => { 3913 const value = attributes[key]; // Ignore undefined values. 3914 3915 if (undefined === value) { 3916 return accumulator; 3917 } // Ignore all attributes but the ones with an "undefined" source 3918 // "undefined" source refers to attributes saved in the block comment. 3919 3920 3921 if (attributeSchema.source !== undefined) { 3922 return accumulator; 3923 } // Ignore default value. 3924 3925 3926 if ('default' in attributeSchema && attributeSchema.default === value) { 3927 return accumulator; 3928 } // Otherwise, include in comment set. 3929 3930 3931 accumulator[key] = value; 3932 return accumulator; 3933 }, {}); 3934 } 3935 /** 3936 * Given an attributes object, returns a string in the serialized attributes 3937 * format prepared for post content. 3938 * 3939 * @param {Object} attributes Attributes object. 3940 * 3941 * @return {string} Serialized attributes. 3942 */ 3943 3944 function serializeAttributes(attributes) { 3945 return JSON.stringify(attributes) // Don't break HTML comments. 3946 .replace(/--/g, '\\u002d\\u002d') // Don't break non-standard-compliant tools. 3947 .replace(/</g, '\\u003c').replace(/>/g, '\\u003e').replace(/&/g, '\\u0026') // Bypass server stripslashes behavior which would unescape stringify's 3948 // escaping of quotation mark. 3949 // 3950 // See: https://developer.wordpress.org/reference/functions/wp_kses_stripslashes/ 3951 .replace(/\\"/g, '\\u0022'); 3952 } 3953 /** 3954 * Given a block object, returns the Block's Inner HTML markup. 3955 * 3956 * @param {Object} block Block instance. 3957 * 3958 * @return {string} HTML. 3959 */ 3960 3961 function getBlockInnerHTML(block) { 3962 // If block was parsed as invalid or encounters an error while generating 3963 // save content, use original content instead to avoid content loss. If a 3964 // block contains nested content, exempt it from this condition because we 3965 // otherwise have no access to its original content and content loss would 3966 // still occur. 3967 let saveContent = block.originalContent; 3968 3969 if (block.isValid || block.innerBlocks.length) { 3970 try { 3971 saveContent = getSaveContent(block.name, block.attributes, block.innerBlocks); 3972 } catch (error) {} 3973 } 3974 3975 return saveContent; 3976 } 3977 /** 3978 * Returns the content of a block, including comment delimiters. 3979 * 3980 * @param {string} rawBlockName Block name. 3981 * @param {Object} attributes Block attributes. 3982 * @param {string} content Block save content. 3983 * 3984 * @return {string} Comment-delimited block content. 3985 */ 3986 3987 function getCommentDelimitedContent(rawBlockName, attributes, content) { 3988 const serializedAttributes = !Object(external_lodash_["isEmpty"])(attributes) ? serializeAttributes(attributes) + ' ' : ''; // Strip core blocks of their namespace prefix. 3989 3990 const blockName = Object(external_lodash_["startsWith"])(rawBlockName, 'core/') ? rawBlockName.slice(5) : rawBlockName; // @todo make the `wp:` prefix potentially configurable. 3991 3992 if (!content) { 3993 return `<!-- wp:$blockName} $serializedAttributes}/-->`; 3994 } 3995 3996 return `<!-- wp:$blockName} $serializedAttributes}-->\n` + content + `\n<!-- /wp:$blockName} -->`; 3997 } 3998 /** 3999 * Returns the content of a block, including comment delimiters, determining 4000 * serialized attributes and content form from the current state of the block. 4001 * 4002 * @param {Object} block Block instance. 4003 * @param {WPBlockSerializationOptions} options Serialization options. 4004 * 4005 * @return {string} Serialized block. 4006 */ 4007 4008 function serializeBlock(block, { 4009 isInnerBlocks = false 4010 } = {}) { 4011 const blockName = block.name; 4012 const saveContent = getBlockInnerHTML(block); 4013 4014 if (blockName === getUnregisteredTypeHandlerName() || !isInnerBlocks && blockName === getFreeformContentHandlerName()) { 4015 return saveContent; 4016 } 4017 4018 const blockType = registration_getBlockType(blockName); 4019 const saveAttributes = getCommentAttributes(blockType, block.attributes); 4020 return getCommentDelimitedContent(blockName, saveAttributes, saveContent); 4021 } 4022 function __unstableSerializeAndClean(blocks) { 4023 // A single unmodified default block is assumed to 4024 // be equivalent to an empty post. 4025 if (blocks.length === 1 && isUnmodifiedDefaultBlock(blocks[0])) { 4026 blocks = []; 4027 } 4028 4029 let content = serialize(blocks); // For compatibility, treat a post consisting of a 4030 // single freeform block as legacy content and apply 4031 // pre-block-editor removep'd content formatting. 4032 4033 if (blocks.length === 1 && blocks[0].name === getFreeformContentHandlerName()) { 4034 content = Object(external_wp_autop_["removep"])(content); 4035 } 4036 4037 return content; 4038 } 4039 /** 4040 * Takes a block or set of blocks and returns the serialized post content. 4041 * 4042 * @param {Array} blocks Block(s) to serialize. 4043 * @param {WPBlockSerializationOptions} options Serialization options. 4044 * 4045 * @return {string} The post content. 4046 */ 4047 4048 function serialize(blocks, options) { 4049 return Object(external_lodash_["castArray"])(blocks).map(block => serializeBlock(block, options)).join('\n\n'); 4050 } 4051 4052 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/validation/index.js 4053 /** 4054 * External dependencies 4055 */ 4056 4057 4058 /** 4059 * WordPress dependencies 4060 */ 4061 4062 4063 /** 4064 * Internal dependencies 4065 */ 4066 4067 4068 4069 4070 /** 4071 * Globally matches any consecutive whitespace 4072 * 4073 * @type {RegExp} 4074 */ 4075 4076 const REGEXP_WHITESPACE = /[\t\n\r\v\f ]+/g; 4077 /** 4078 * Matches a string containing only whitespace 4079 * 4080 * @type {RegExp} 4081 */ 4082 4083 const REGEXP_ONLY_WHITESPACE = /^[\t\n\r\v\f ]*$/; 4084 /** 4085 * Matches a CSS URL type value 4086 * 4087 * @type {RegExp} 4088 */ 4089 4090 const REGEXP_STYLE_URL_TYPE = /^url\s*\(['"\s]*(.*?)['"\s]*\)$/; 4091 /** 4092 * Boolean attributes are attributes whose presence as being assigned is 4093 * meaningful, even if only empty. 4094 * 4095 * See: https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#boolean-attributes 4096 * Extracted from: https://html.spec.whatwg.org/multipage/indices.html#attributes-3 4097 * 4098 * Object.keys( Array.from( document.querySelectorAll( '#attributes-1 > tbody > tr' ) ) 4099 * .filter( ( tr ) => tr.lastChild.textContent.indexOf( 'Boolean attribute' ) !== -1 ) 4100 * .reduce( ( result, tr ) => Object.assign( result, { 4101 * [ tr.firstChild.textContent.trim() ]: true 4102 * } ), {} ) ).sort(); 4103 * 4104 * @type {Array} 4105 */ 4106 4107 const 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']; 4108 /** 4109 * Enumerated attributes are attributes which must be of a specific value form. 4110 * Like boolean attributes, these are meaningful if specified, even if not of a 4111 * valid enumerated value. 4112 * 4113 * See: https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#enumerated-attribute 4114 * Extracted from: https://html.spec.whatwg.org/multipage/indices.html#attributes-3 4115 * 4116 * Object.keys( Array.from( document.querySelectorAll( '#attributes-1 > tbody > tr' ) ) 4117 * .filter( ( tr ) => /^("(.+?)";?\s*)+/.test( tr.lastChild.textContent.trim() ) ) 4118 * .reduce( ( result, tr ) => Object.assign( result, { 4119 * [ tr.firstChild.textContent.trim() ]: true 4120 * } ), {} ) ).sort(); 4121 * 4122 * @type {Array} 4123 */ 4124 4125 const 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']; 4126 /** 4127 * Meaningful attributes are those who cannot be safely ignored when omitted in 4128 * one HTML markup string and not another. 4129 * 4130 * @type {Array} 4131 */ 4132 4133 const MEANINGFUL_ATTRIBUTES = [...BOOLEAN_ATTRIBUTES, ...ENUMERATED_ATTRIBUTES]; 4134 /** 4135 * Array of functions which receive a text string on which to apply normalizing 4136 * behavior for consideration in text token equivalence, carefully ordered from 4137 * least-to-most expensive operations. 4138 * 4139 * @type {Array} 4140 */ 4141 4142 const TEXT_NORMALIZATIONS = [external_lodash_["identity"], getTextWithCollapsedWhitespace]; 4143 /** 4144 * Regular expression matching a named character reference. In lieu of bundling 4145 * a full set of references, the pattern covers the minimal necessary to test 4146 * positively against the full set. 4147 * 4148 * "The ampersand must be followed by one of the names given in the named 4149 * character references section, using the same case." 4150 * 4151 * Tested aginst "12.5 Named character references": 4152 * 4153 * ``` 4154 * const references = Array.from( document.querySelectorAll( 4155 * '#named-character-references-table tr[id^=entity-] td:first-child' 4156 * ) ).map( ( code ) => code.textContent ) 4157 * references.every( ( reference ) => /^[\da-z]+$/i.test( reference ) ) 4158 * ``` 4159 * 4160 * @see https://html.spec.whatwg.org/multipage/syntax.html#character-references 4161 * @see https://html.spec.whatwg.org/multipage/named-characters.html#named-character-references 4162 * 4163 * @type {RegExp} 4164 */ 4165 4166 const REGEXP_NAMED_CHARACTER_REFERENCE = /^[\da-z]+$/i; 4167 /** 4168 * Regular expression matching a decimal character reference. 4169 * 4170 * "The ampersand must be followed by a U+0023 NUMBER SIGN character (#), 4171 * followed by one or more ASCII digits, representing a base-ten integer" 4172 * 4173 * @see https://html.spec.whatwg.org/multipage/syntax.html#character-references 4174 * 4175 * @type {RegExp} 4176 */ 4177 4178 const REGEXP_DECIMAL_CHARACTER_REFERENCE = /^#\d+$/; 4179 /** 4180 * Regular expression matching a hexadecimal character reference. 4181 * 4182 * "The ampersand must be followed by a U+0023 NUMBER SIGN character (#), which 4183 * must be followed by either a U+0078 LATIN SMALL LETTER X character (x) or a 4184 * U+0058 LATIN CAPITAL LETTER X character (X), which must then be followed by 4185 * one or more ASCII hex digits, representing a hexadecimal integer" 4186 * 4187 * @see https://html.spec.whatwg.org/multipage/syntax.html#character-references 4188 * 4189 * @type {RegExp} 4190 */ 4191 4192 const REGEXP_HEXADECIMAL_CHARACTER_REFERENCE = /^#x[\da-f]+$/i; 4193 /** 4194 * Returns true if the given string is a valid character reference segment, or 4195 * false otherwise. The text should be stripped of `&` and `;` demarcations. 4196 * 4197 * @param {string} text Text to test. 4198 * 4199 * @return {boolean} Whether text is valid character reference. 4200 */ 4201 4202 function isValidCharacterReference(text) { 4203 return REGEXP_NAMED_CHARACTER_REFERENCE.test(text) || REGEXP_DECIMAL_CHARACTER_REFERENCE.test(text) || REGEXP_HEXADECIMAL_CHARACTER_REFERENCE.test(text); 4204 } 4205 /** 4206 * Subsitute EntityParser class for `simple-html-tokenizer` which uses the 4207 * implementation of `decodeEntities` from `html-entities`, in order to avoid 4208 * bundling a massive named character reference. 4209 * 4210 * @see https://github.com/tildeio/simple-html-tokenizer/tree/HEAD/src/entity-parser.ts 4211 */ 4212 4213 class validation_DecodeEntityParser { 4214 /** 4215 * Returns a substitute string for an entity string sequence between `&` 4216 * and `;`, or undefined if no substitution should occur. 4217 * 4218 * @param {string} entity Entity fragment discovered in HTML. 4219 * 4220 * @return {?string} Entity substitute value. 4221 */ 4222 parse(entity) { 4223 if (isValidCharacterReference(entity)) { 4224 return Object(external_wp_htmlEntities_["decodeEntities"])('&' + entity + ';'); 4225 } 4226 } 4227 4228 } 4229 /** 4230 * Given a specified string, returns an array of strings split by consecutive 4231 * whitespace, ignoring leading or trailing whitespace. 4232 * 4233 * @param {string} text Original text. 4234 * 4235 * @return {string[]} Text pieces split on whitespace. 4236 */ 4237 4238 function getTextPiecesSplitOnWhitespace(text) { 4239 return text.trim().split(REGEXP_WHITESPACE); 4240 } 4241 /** 4242 * Given a specified string, returns a new trimmed string where all consecutive 4243 * whitespace is collapsed to a single space. 4244 * 4245 * @param {string} text Original text. 4246 * 4247 * @return {string} Trimmed text with consecutive whitespace collapsed. 4248 */ 4249 4250 function getTextWithCollapsedWhitespace(text) { 4251 // This is an overly simplified whitespace comparison. The specification is 4252 // more prescriptive of whitespace behavior in inline and block contexts. 4253 // 4254 // See: https://medium.com/@patrickbrosset/when-does-white-space-matter-in-html-b90e8a7cdd33 4255 return getTextPiecesSplitOnWhitespace(text).join(' '); 4256 } 4257 /** 4258 * Returns attribute pairs of the given StartTag token, including only pairs 4259 * where the value is non-empty or the attribute is a boolean attribute, an 4260 * enumerated attribute, or a custom data- attribute. 4261 * 4262 * @see MEANINGFUL_ATTRIBUTES 4263 * 4264 * @param {Object} token StartTag token. 4265 * 4266 * @return {Array[]} Attribute pairs. 4267 */ 4268 4269 function getMeaningfulAttributePairs(token) { 4270 return token.attributes.filter(pair => { 4271 const [key, value] = pair; 4272 return value || key.indexOf('data-') === 0 || Object(external_lodash_["includes"])(MEANINGFUL_ATTRIBUTES, key); 4273 }); 4274 } 4275 /** 4276 * Returns true if two text tokens (with `chars` property) are equivalent, or 4277 * false otherwise. 4278 * 4279 * @param {Object} actual Actual token. 4280 * @param {Object} expected Expected token. 4281 * @param {Object} logger Validation logger object. 4282 * 4283 * @return {boolean} Whether two text tokens are equivalent. 4284 */ 4285 4286 function isEquivalentTextTokens(actual, expected, logger = createLogger()) { 4287 // This function is intentionally written as syntactically "ugly" as a hot 4288 // path optimization. Text is progressively normalized in order from least- 4289 // to-most operationally expensive, until the earliest point at which text 4290 // can be confidently inferred as being equal. 4291 let actualChars = actual.chars; 4292 let expectedChars = expected.chars; 4293 4294 for (let i = 0; i < TEXT_NORMALIZATIONS.length; i++) { 4295 const normalize = TEXT_NORMALIZATIONS[i]; 4296 actualChars = normalize(actualChars); 4297 expectedChars = normalize(expectedChars); 4298 4299 if (actualChars === expectedChars) { 4300 return true; 4301 } 4302 } 4303 4304 logger.warning('Expected text `%s`, saw `%s`.', expected.chars, actual.chars); 4305 return false; 4306 } 4307 /** 4308 * Given a CSS length value, returns a normalized CSS length value for strict equality 4309 * comparison. 4310 * 4311 * @param {string} value CSS length value. 4312 * 4313 * @return {string} Normalized CSS length value. 4314 */ 4315 4316 function getNormalizedLength(value) { 4317 return 0 === parseFloat(value) ? '0' : value; 4318 } 4319 /** 4320 * Given a style value, returns a normalized style value for strict equality 4321 * comparison. 4322 * 4323 * @param {string} value Style value. 4324 * 4325 * @return {string} Normalized style value. 4326 */ 4327 4328 function getNormalizedStyleValue(value) { 4329 const textPieces = getTextPiecesSplitOnWhitespace(value); 4330 const normalizedPieces = textPieces.map(getNormalizedLength); 4331 const result = normalizedPieces.join(' '); 4332 return result // Normalize URL type to omit whitespace or quotes 4333 .replace(REGEXP_STYLE_URL_TYPE, 'url($1)'); 4334 } 4335 /** 4336 * Given a style attribute string, returns an object of style properties. 4337 * 4338 * @param {string} text Style attribute. 4339 * 4340 * @return {Object} Style properties. 4341 */ 4342 4343 function getStyleProperties(text) { 4344 const pairs = text // Trim ending semicolon (avoid including in split) 4345 .replace(/;?\s*$/, '') // Split on property assignment 4346 .split(';') // For each property assignment... 4347 .map(style => { 4348 // ...split further into key-value pairs 4349 const [key, ...valueParts] = style.split(':'); 4350 const value = valueParts.join(':'); 4351 return [key.trim(), getNormalizedStyleValue(value.trim())]; 4352 }); 4353 return Object(external_lodash_["fromPairs"])(pairs); 4354 } 4355 /** 4356 * Attribute-specific equality handlers 4357 * 4358 * @type {Object} 4359 */ 4360 4361 const isEqualAttributesOfName = { 4362 class: (actual, expected) => { 4363 // Class matches if members are the same, even if out of order or 4364 // superfluous whitespace between. 4365 return !Object(external_lodash_["xor"])(...[actual, expected].map(getTextPiecesSplitOnWhitespace)).length; 4366 }, 4367 style: (actual, expected) => { 4368 return Object(external_lodash_["isEqual"])(...[actual, expected].map(getStyleProperties)); 4369 }, 4370 // For each boolean attribute, mere presence of attribute in both is enough 4371 // to assume equivalence. 4372 ...Object(external_lodash_["fromPairs"])(BOOLEAN_ATTRIBUTES.map(attribute => [attribute, external_lodash_["stubTrue"]])) 4373 }; 4374 /** 4375 * Given two sets of attribute tuples, returns true if the attribute sets are 4376 * equivalent. 4377 * 4378 * @param {Array[]} actual Actual attributes tuples. 4379 * @param {Array[]} expected Expected attributes tuples. 4380 * @param {Object} logger Validation logger object. 4381 * 4382 * @return {boolean} Whether attributes are equivalent. 4383 */ 4384 4385 function isEqualTagAttributePairs(actual, expected, logger = createLogger()) { 4386 // Attributes is tokenized as tuples. Their lengths should match. This also 4387 // avoids us needing to check both attributes sets, since if A has any keys 4388 // which do not exist in B, we know the sets to be different. 4389 if (actual.length !== expected.length) { 4390 logger.warning('Expected attributes %o, instead saw %o.', expected, actual); 4391 return false; 4392 } // Attributes are not guaranteed to occur in the same order. For validating 4393 // actual attributes, first convert the set of expected attribute values to 4394 // an object, for lookup by key. 4395 4396 4397 const expectedAttributes = {}; 4398 4399 for (let i = 0; i < expected.length; i++) { 4400 expectedAttributes[expected[i][0].toLowerCase()] = expected[i][1]; 4401 } 4402 4403 for (let i = 0; i < actual.length; i++) { 4404 const [name, actualValue] = actual[i]; 4405 const nameLower = name.toLowerCase(); // As noted above, if missing member in B, assume different 4406 4407 if (!expectedAttributes.hasOwnProperty(nameLower)) { 4408 logger.warning('Encountered unexpected attribute `%s`.', name); 4409 return false; 4410 } 4411 4412 const expectedValue = expectedAttributes[nameLower]; 4413 const isEqualAttributes = isEqualAttributesOfName[nameLower]; 4414 4415 if (isEqualAttributes) { 4416 // Defer custom attribute equality handling 4417 if (!isEqualAttributes(actualValue, expectedValue)) { 4418 logger.warning('Expected attribute `%s` of value `%s`, saw `%s`.', name, expectedValue, actualValue); 4419 return false; 4420 } 4421 } else if (actualValue !== expectedValue) { 4422 // Otherwise strict inequality should bail 4423 logger.warning('Expected attribute `%s` of value `%s`, saw `%s`.', name, expectedValue, actualValue); 4424 return false; 4425 } 4426 } 4427 4428 return true; 4429 } 4430 /** 4431 * Token-type-specific equality handlers 4432 * 4433 * @type {Object} 4434 */ 4435 4436 const isEqualTokensOfType = { 4437 StartTag: (actual, expected, logger = createLogger()) => { 4438 if (actual.tagName !== expected.tagName && // Optimization: Use short-circuit evaluation to defer case- 4439 // insensitive check on the assumption that the majority case will 4440 // have exactly equal tag names. 4441 actual.tagName.toLowerCase() !== expected.tagName.toLowerCase()) { 4442 logger.warning('Expected tag name `%s`, instead saw `%s`.', expected.tagName, actual.tagName); 4443 return false; 4444 } 4445 4446 return isEqualTagAttributePairs(...[actual, expected].map(getMeaningfulAttributePairs), logger); 4447 }, 4448 Chars: isEquivalentTextTokens, 4449 Comment: isEquivalentTextTokens 4450 }; 4451 /** 4452 * Given an array of tokens, returns the first token which is not purely 4453 * whitespace. 4454 * 4455 * Mutates the tokens array. 4456 * 4457 * @param {Object[]} tokens Set of tokens to search. 4458 * 4459 * @return {Object} Next non-whitespace token. 4460 */ 4461 4462 function getNextNonWhitespaceToken(tokens) { 4463 let token; 4464 4465 while (token = tokens.shift()) { 4466 if (token.type !== 'Chars') { 4467 return token; 4468 } 4469 4470 if (!REGEXP_ONLY_WHITESPACE.test(token.chars)) { 4471 return token; 4472 } 4473 } 4474 } 4475 /** 4476 * Tokenize an HTML string, gracefully handling any errors thrown during 4477 * underlying tokenization. 4478 * 4479 * @param {string} html HTML string to tokenize. 4480 * @param {Object} logger Validation logger object. 4481 * 4482 * @return {Object[]|null} Array of valid tokenized HTML elements, or null on error 4483 */ 4484 4485 function getHTMLTokens(html, logger = createLogger()) { 4486 try { 4487 return new Tokenizer(new validation_DecodeEntityParser()).tokenize(html); 4488 } catch (e) { 4489 logger.warning('Malformed HTML detected: %s', html); 4490 } 4491 4492 return null; 4493 } 4494 /** 4495 * Returns true if the next HTML token closes the current token. 4496 * 4497 * @param {Object} currentToken Current token to compare with. 4498 * @param {Object|undefined} nextToken Next token to compare against. 4499 * 4500 * @return {boolean} true if `nextToken` closes `currentToken`, false otherwise 4501 */ 4502 4503 4504 function isClosedByToken(currentToken, nextToken) { 4505 // Ensure this is a self closed token 4506 if (!currentToken.selfClosing) { 4507 return false; 4508 } // Check token names and determine if nextToken is the closing tag for currentToken 4509 4510 4511 if (nextToken && nextToken.tagName === currentToken.tagName && nextToken.type === 'EndTag') { 4512 return true; 4513 } 4514 4515 return false; 4516 } 4517 /** 4518 * Returns true if the given HTML strings are effectively equivalent, or 4519 * false otherwise. Invalid HTML is not considered equivalent, even if the 4520 * strings directly match. 4521 * 4522 * @param {string} actual Actual HTML string. 4523 * @param {string} expected Expected HTML string. 4524 * @param {Object} logger Validation logger object. 4525 * 4526 * @return {boolean} Whether HTML strings are equivalent. 4527 */ 4528 4529 function isEquivalentHTML(actual, expected, logger = createLogger()) { 4530 // Short-circuit if markup is identical. 4531 if (actual === expected) { 4532 return true; 4533 } // Tokenize input content and reserialized save content 4534 4535 4536 const [actualTokens, expectedTokens] = [actual, expected].map(html => getHTMLTokens(html, logger)); // If either is malformed then stop comparing - the strings are not equivalent 4537 4538 if (!actualTokens || !expectedTokens) { 4539 return false; 4540 } 4541 4542 let actualToken, expectedToken; 4543 4544 while (actualToken = getNextNonWhitespaceToken(actualTokens)) { 4545 expectedToken = getNextNonWhitespaceToken(expectedTokens); // Inequal if exhausted all expected tokens 4546 4547 if (!expectedToken) { 4548 logger.warning('Expected end of content, instead saw %o.', actualToken); 4549 return false; 4550 } // Inequal if next non-whitespace token of each set are not same type 4551 4552 4553 if (actualToken.type !== expectedToken.type) { 4554 logger.warning('Expected token of type `%s` (%o), instead saw `%s` (%o).', expectedToken.type, expectedToken, actualToken.type, actualToken); 4555 return false; 4556 } // Defer custom token type equality handling, otherwise continue and 4557 // assume as equal 4558 4559 4560 const isEqualTokens = isEqualTokensOfType[actualToken.type]; 4561 4562 if (isEqualTokens && !isEqualTokens(actualToken, expectedToken, logger)) { 4563 return false; 4564 } // Peek at the next tokens (actual and expected) to see if they close 4565 // a self-closing tag 4566 4567 4568 if (isClosedByToken(actualToken, expectedTokens[0])) { 4569 // Consume the next expected token that closes the current actual 4570 // self-closing token 4571 getNextNonWhitespaceToken(expectedTokens); 4572 } else if (isClosedByToken(expectedToken, actualTokens[0])) { 4573 // Consume the next actual token that closes the current expected 4574 // self-closing token 4575 getNextNonWhitespaceToken(actualTokens); 4576 } 4577 } 4578 4579 if (expectedToken = getNextNonWhitespaceToken(expectedTokens)) { 4580 // If any non-whitespace tokens remain in expected token set, this 4581 // indicates inequality 4582 logger.warning('Expected %o, instead saw end of content.', expectedToken); 4583 return false; 4584 } 4585 4586 return true; 4587 } 4588 /** 4589 * Returns an object with `isValid` property set to `true` if the parsed block 4590 * is valid given the input content. A block is considered valid if, when serialized 4591 * with assumed attributes, the content matches the original value. If block is 4592 * invalid, this function returns all validations issues as well. 4593 * 4594 * @param {string|Object} blockTypeOrName Block type. 4595 * @param {Object} attributes Parsed block attributes. 4596 * @param {string} originalBlockContent Original block content. 4597 * @param {Object} logger Validation logger object. 4598 * 4599 * @return {Object} Whether block is valid and contains validation messages. 4600 */ 4601 4602 function getBlockContentValidationResult(blockTypeOrName, attributes, originalBlockContent, logger = createQueuedLogger()) { 4603 const blockType = normalizeBlockType(blockTypeOrName); 4604 let generatedBlockContent; 4605 4606 try { 4607 generatedBlockContent = getSaveContent(blockType, attributes); 4608 } catch (error) { 4609 logger.error('Block validation failed because an error occurred while generating block content:\n\n%s', error.toString()); 4610 return { 4611 isValid: false, 4612 validationIssues: logger.getItems() 4613 }; 4614 } 4615 4616 const isValid = isEquivalentHTML(originalBlockContent, generatedBlockContent, logger); 4617 4618 if (!isValid) { 4619 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, originalBlockContent); 4620 } 4621 4622 return { 4623 isValid, 4624 validationIssues: logger.getItems() 4625 }; 4626 } 4627 /** 4628 * Returns true if the parsed block is valid given the input content. A block 4629 * is considered valid if, when serialized with assumed attributes, the content 4630 * matches the original value. 4631 * 4632 * Logs to console in development environments when invalid. 4633 * 4634 * @param {string|Object} blockTypeOrName Block type. 4635 * @param {Object} attributes Parsed block attributes. 4636 * @param {string} originalBlockContent Original block content. 4637 * 4638 * @return {boolean} Whether block is valid. 4639 */ 4640 4641 function isValidBlockContent(blockTypeOrName, attributes, originalBlockContent) { 4642 const { 4643 isValid 4644 } = getBlockContentValidationResult(blockTypeOrName, attributes, originalBlockContent, createLogger()); 4645 return isValid; 4646 } 4647 4648 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/matchers.js 4649 /** 4650 * External dependencies 4651 */ 4652 4653 /** 4654 * Internal dependencies 4655 */ 4656 4657 4658 4659 function matchers_html(selector, multilineTag) { 4660 return domNode => { 4661 let match = domNode; 4662 4663 if (selector) { 4664 match = domNode.querySelector(selector); 4665 } 4666 4667 if (!match) { 4668 return ''; 4669 } 4670 4671 if (multilineTag) { 4672 let value = ''; 4673 const length = match.children.length; 4674 4675 for (let index = 0; index < length; index++) { 4676 const child = match.children[index]; 4677 4678 if (child.nodeName.toLowerCase() !== multilineTag) { 4679 continue; 4680 } 4681 4682 value += child.outerHTML; 4683 } 4684 4685 return value; 4686 } 4687 4688 return match.innerHTML; 4689 }; 4690 } 4691 4692 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/node.js 4693 /** 4694 * Internal dependencies 4695 */ 4696 4697 /** 4698 * A representation of a single node within a block's rich text value. If 4699 * representing a text node, the value is simply a string of the node value. 4700 * As representing an element node, it is an object of: 4701 * 4702 * 1. `type` (string): Tag name. 4703 * 2. `props` (object): Attributes and children array of WPBlockNode. 4704 * 4705 * @typedef {string|Object} WPBlockNode 4706 */ 4707 4708 /** 4709 * Given a single node and a node type (e.g. `'br'`), returns true if the node 4710 * corresponds to that type, false otherwise. 4711 * 4712 * @param {WPBlockNode} node Block node to test 4713 * @param {string} type Node to type to test against. 4714 * 4715 * @return {boolean} Whether node is of intended type. 4716 */ 4717 4718 function isNodeOfType(node, type) { 4719 return node && node.type === type; 4720 } 4721 /** 4722 * Given an object implementing the NamedNodeMap interface, returns a plain 4723 * object equivalent value of name, value key-value pairs. 4724 * 4725 * @see https://dom.spec.whatwg.org/#interface-namednodemap 4726 * 4727 * @param {NamedNodeMap} nodeMap NamedNodeMap to convert to object. 4728 * 4729 * @return {Object} Object equivalent value of NamedNodeMap. 4730 */ 4731 4732 4733 function getNamedNodeMapAsObject(nodeMap) { 4734 const result = {}; 4735 4736 for (let i = 0; i < nodeMap.length; i++) { 4737 const { 4738 name, 4739 value 4740 } = nodeMap[i]; 4741 result[name] = value; 4742 } 4743 4744 return result; 4745 } 4746 /** 4747 * Given a DOM Element or Text node, returns an equivalent block node. Throws 4748 * if passed any node type other than element or text. 4749 * 4750 * @throws {TypeError} If non-element/text node is passed. 4751 * 4752 * @param {Node} domNode DOM node to convert. 4753 * 4754 * @return {WPBlockNode} Block node equivalent to DOM node. 4755 */ 4756 4757 function fromDOM(domNode) { 4758 if (domNode.nodeType === domNode.TEXT_NODE) { 4759 return domNode.nodeValue; 4760 } 4761 4762 if (domNode.nodeType !== domNode.ELEMENT_NODE) { 4763 throw new TypeError('A block node can only be created from a node of type text or ' + 'element.'); 4764 } 4765 4766 return { 4767 type: domNode.nodeName.toLowerCase(), 4768 props: { ...getNamedNodeMapAsObject(domNode.attributes), 4769 children: children_fromDOM(domNode.childNodes) 4770 } 4771 }; 4772 } 4773 /** 4774 * Given a block node, returns its HTML string representation. 4775 * 4776 * @param {WPBlockNode} node Block node to convert to string. 4777 * 4778 * @return {string} String HTML representation of block node. 4779 */ 4780 4781 function toHTML(node) { 4782 return children_toHTML([node]); 4783 } 4784 /** 4785 * Given a selector, returns an hpq matcher generating a WPBlockNode value 4786 * matching the selector result. 4787 * 4788 * @param {string} selector DOM selector. 4789 * 4790 * @return {Function} hpq matcher. 4791 */ 4792 4793 function node_matcher(selector) { 4794 return domNode => { 4795 let match = domNode; 4796 4797 if (selector) { 4798 match = domNode.querySelector(selector); 4799 } 4800 4801 try { 4802 return fromDOM(match); 4803 } catch (error) { 4804 return null; 4805 } 4806 }; 4807 } 4808 /** 4809 * Object of utility functions used in managing block attribute values of 4810 * source `node`. 4811 * 4812 * @see https://github.com/WordPress/gutenberg/pull/10439 4813 * 4814 * @deprecated since 4.0. The `node` source should not be used, and can be 4815 * replaced by the `html` source. 4816 * 4817 * @private 4818 */ 4819 4820 /* harmony default export */ var api_node = ({ 4821 isNodeOfType, 4822 fromDOM, 4823 toHTML, 4824 matcher: node_matcher 4825 }); 4826 4827 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/children.js 4828 /** 4829 * External dependencies 4830 */ 4831 4832 /** 4833 * WordPress dependencies 4834 */ 4835 4836 4837 /** 4838 * Internal dependencies 4839 */ 4840 4841 4842 /** 4843 * A representation of a block's rich text value. 4844 * 4845 * @typedef {WPBlockNode[]} WPBlockChildren 4846 */ 4847 4848 /** 4849 * Given block children, returns a serialize-capable WordPress element. 4850 * 4851 * @param {WPBlockChildren} children Block children object to convert. 4852 * 4853 * @return {WPElement} A serialize-capable element. 4854 */ 4855 4856 function getSerializeCapableElement(children) { 4857 // The fact that block children are compatible with the element serializer is 4858 // merely an implementation detail that currently serves to be true, but 4859 // should not be mistaken as being a guarantee on the external API. The 4860 // public API only offers guarantees to work with strings (toHTML) and DOM 4861 // elements (fromDOM), and should provide utilities to manipulate the value 4862 // rather than expect consumers to inspect or construct its shape (concat). 4863 return children; 4864 } 4865 /** 4866 * Given block children, returns an array of block nodes. 4867 * 4868 * @param {WPBlockChildren} children Block children object to convert. 4869 * 4870 * @return {Array<WPBlockNode>} An array of individual block nodes. 4871 */ 4872 4873 function getChildrenArray(children) { 4874 // The fact that block children are compatible with the element serializer 4875 // is merely an implementation detail that currently serves to be true, but 4876 // should not be mistaken as being a guarantee on the external API. 4877 return children; 4878 } 4879 /** 4880 * Given two or more block nodes, returns a new block node representing a 4881 * concatenation of its values. 4882 * 4883 * @param {...WPBlockChildren} blockNodes Block nodes to concatenate. 4884 * 4885 * @return {WPBlockChildren} Concatenated block node. 4886 */ 4887 4888 4889 function concat(...blockNodes) { 4890 const result = []; 4891 4892 for (let i = 0; i < blockNodes.length; i++) { 4893 const blockNode = Object(external_lodash_["castArray"])(blockNodes[i]); 4894 4895 for (let j = 0; j < blockNode.length; j++) { 4896 const child = blockNode[j]; 4897 const canConcatToPreviousString = typeof child === 'string' && typeof result[result.length - 1] === 'string'; 4898 4899 if (canConcatToPreviousString) { 4900 result[result.length - 1] += child; 4901 } else { 4902 result.push(child); 4903 } 4904 } 4905 } 4906 4907 return result; 4908 } 4909 /** 4910 * Given an iterable set of DOM nodes, returns equivalent block children. 4911 * Ignores any non-element/text nodes included in set. 4912 * 4913 * @param {Iterable.<Node>} domNodes Iterable set of DOM nodes to convert. 4914 * 4915 * @return {WPBlockChildren} Block children equivalent to DOM nodes. 4916 */ 4917 4918 function children_fromDOM(domNodes) { 4919 const result = []; 4920 4921 for (let i = 0; i < domNodes.length; i++) { 4922 try { 4923 result.push(fromDOM(domNodes[i])); 4924 } catch (error) {// Simply ignore if DOM node could not be converted. 4925 } 4926 } 4927 4928 return result; 4929 } 4930 /** 4931 * Given a block node, returns its HTML string representation. 4932 * 4933 * @param {WPBlockChildren} children Block node(s) to convert to string. 4934 * 4935 * @return {string} String HTML representation of block node. 4936 */ 4937 4938 function children_toHTML(children) { 4939 const element = getSerializeCapableElement(children); 4940 return Object(external_wp_element_["renderToString"])(element); 4941 } 4942 /** 4943 * Given a selector, returns an hpq matcher generating a WPBlockChildren value 4944 * matching the selector result. 4945 * 4946 * @param {string} selector DOM selector. 4947 * 4948 * @return {Function} hpq matcher. 4949 */ 4950 4951 function children_matcher(selector) { 4952 return domNode => { 4953 let match = domNode; 4954 4955 if (selector) { 4956 match = domNode.querySelector(selector); 4957 } 4958 4959 if (match) { 4960 return children_fromDOM(match.childNodes); 4961 } 4962 4963 return []; 4964 }; 4965 } 4966 /** 4967 * Object of utility functions used in managing block attribute values of 4968 * source `children`. 4969 * 4970 * @see https://github.com/WordPress/gutenberg/pull/10439 4971 * 4972 * @deprecated since 4.0. The `children` source should not be used, and can be 4973 * replaced by the `html` source. 4974 * 4975 * @private 4976 */ 4977 4978 /* harmony default export */ var api_children = ({ 4979 concat, 4980 getChildrenArray, 4981 fromDOM: children_fromDOM, 4982 toHTML: children_toHTML, 4983 matcher: children_matcher 4984 }); 4985 4986 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/parser.js 4987 /** 4988 * External dependencies 4989 */ 4990 4991 4992 /** 4993 * WordPress dependencies 4994 */ 4995 4996 4997 4998 4999 /** 5000 * Internal dependencies 5001 */ 5002 5003 5004 5005 5006 5007 5008 5009 5010 /** 5011 * Sources which are guaranteed to return a string value. 5012 * 5013 * @type {Set} 5014 */ 5015 5016 const STRING_SOURCES = new Set(['attribute', 'html', 'text', 'tag']); 5017 /** 5018 * Higher-order hpq matcher which enhances an attribute matcher to return true 5019 * or false depending on whether the original matcher returns undefined. This 5020 * is useful for boolean attributes (e.g. disabled) whose attribute values may 5021 * be technically falsey (empty string), though their mere presence should be 5022 * enough to infer as true. 5023 * 5024 * @param {Function} matcher Original hpq matcher. 5025 * 5026 * @return {Function} Enhanced hpq matcher. 5027 */ 5028 5029 const toBooleanAttributeMatcher = matcher => Object(external_lodash_["flow"])([matcher, // Expected values from `attr( 'disabled' )`: 5030 // 5031 // <input> 5032 // - Value: `undefined` 5033 // - Transformed: `false` 5034 // 5035 // <input disabled> 5036 // - Value: `''` 5037 // - Transformed: `true` 5038 // 5039 // <input disabled="disabled"> 5040 // - Value: `'disabled'` 5041 // - Transformed: `true` 5042 value => value !== undefined]); 5043 /** 5044 * Returns true if value is of the given JSON schema type, or false otherwise. 5045 * 5046 * @see http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.25 5047 * 5048 * @param {*} value Value to test. 5049 * @param {string} type Type to test. 5050 * 5051 * @return {boolean} Whether value is of type. 5052 */ 5053 5054 function isOfType(value, type) { 5055 switch (type) { 5056 case 'string': 5057 return typeof value === 'string'; 5058 5059 case 'boolean': 5060 return typeof value === 'boolean'; 5061 5062 case 'object': 5063 return !!value && value.constructor === Object; 5064 5065 case 'null': 5066 return value === null; 5067 5068 case 'array': 5069 return Array.isArray(value); 5070 5071 case 'integer': 5072 case 'number': 5073 return typeof value === 'number'; 5074 } 5075 5076 return true; 5077 } 5078 /** 5079 * Returns true if value is of an array of given JSON schema types, or false 5080 * otherwise. 5081 * 5082 * @see http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.25 5083 * 5084 * @param {*} value Value to test. 5085 * @param {string[]} types Types to test. 5086 * 5087 * @return {boolean} Whether value is of types. 5088 */ 5089 5090 function isOfTypes(value, types) { 5091 return types.some(type => isOfType(value, type)); 5092 } 5093 /** 5094 * Returns true if value is valid per the given block attribute schema type 5095 * definition, or false otherwise. 5096 * 5097 * @see https://json-schema.org/latest/json-schema-validation.html#rfc.section.6.1.1 5098 * 5099 * @param {*} value Value to test. 5100 * @param {?(Array<string>|string)} type Block attribute schema type. 5101 * 5102 * @return {boolean} Whether value is valid. 5103 */ 5104 5105 function isValidByType(value, type) { 5106 return type === undefined || isOfTypes(value, Object(external_lodash_["castArray"])(type)); 5107 } 5108 /** 5109 * Returns true if value is valid per the given block attribute schema enum 5110 * definition, or false otherwise. 5111 * 5112 * @see https://json-schema.org/latest/json-schema-validation.html#rfc.section.6.1.2 5113 * 5114 * @param {*} value Value to test. 5115 * @param {?Array} enumSet Block attribute schema enum. 5116 * 5117 * @return {boolean} Whether value is valid. 5118 */ 5119 5120 function isValidByEnum(value, enumSet) { 5121 return !Array.isArray(enumSet) || enumSet.includes(value); 5122 } 5123 /** 5124 * Returns true if the given attribute schema describes a value which may be 5125 * an ambiguous string. 5126 * 5127 * Some sources are ambiguously serialized as strings, for which value casting 5128 * is enabled. This is only possible when a singular type is assigned to the 5129 * attribute schema, since the string ambiguity makes it impossible to know the 5130 * correct type of multiple to which to cast. 5131 * 5132 * @param {Object} attributeSchema Attribute's schema. 5133 * 5134 * @return {boolean} Whether attribute schema defines an ambiguous string 5135 * source. 5136 */ 5137 5138 function isAmbiguousStringSource(attributeSchema) { 5139 const { 5140 source, 5141 type 5142 } = attributeSchema; 5143 const isStringSource = STRING_SOURCES.has(source); 5144 const isSingleType = typeof type === 'string'; 5145 return isStringSource && isSingleType; 5146 } 5147 /** 5148 * Returns an hpq matcher given a source object. 5149 * 5150 * @param {Object} sourceConfig Attribute Source object. 5151 * 5152 * @return {Function} A hpq Matcher. 5153 */ 5154 5155 function matcherFromSource(sourceConfig) { 5156 switch (sourceConfig.source) { 5157 case 'attribute': 5158 let matcher = attr(sourceConfig.selector, sourceConfig.attribute); 5159 5160 if (sourceConfig.type === 'boolean') { 5161 matcher = toBooleanAttributeMatcher(matcher); 5162 } 5163 5164 return matcher; 5165 5166 case 'html': 5167 return matchers_html(sourceConfig.selector, sourceConfig.multiline); 5168 5169 case 'text': 5170 return es_text(sourceConfig.selector); 5171 5172 case 'children': 5173 return children_matcher(sourceConfig.selector); 5174 5175 case 'node': 5176 return node_matcher(sourceConfig.selector); 5177 5178 case 'query': 5179 const subMatchers = Object(external_lodash_["mapValues"])(sourceConfig.query, matcherFromSource); 5180 return query(sourceConfig.selector, subMatchers); 5181 5182 case 'tag': 5183 return Object(external_lodash_["flow"])([prop(sourceConfig.selector, 'nodeName'), nodeName => nodeName ? nodeName.toLowerCase() : undefined]); 5184 5185 default: 5186 // eslint-disable-next-line no-console 5187 console.error(`Unknown source type "$sourceConfig.source}"`); 5188 } 5189 } 5190 /** 5191 * Given a block's raw content and an attribute's schema returns the attribute's 5192 * value depending on its source. 5193 * 5194 * @param {string} innerHTML Block's raw content. 5195 * @param {Object} attributeSchema Attribute's schema. 5196 * 5197 * @return {*} Attribute value. 5198 */ 5199 5200 function parseWithAttributeSchema(innerHTML, attributeSchema) { 5201 return parse(innerHTML, matcherFromSource(attributeSchema)); 5202 } 5203 /** 5204 * Given an attribute key, an attribute's schema, a block's raw content and the 5205 * commentAttributes returns the attribute value depending on its source 5206 * definition of the given attribute key. 5207 * 5208 * @param {string} attributeKey Attribute key. 5209 * @param {Object} attributeSchema Attribute's schema. 5210 * @param {string} innerHTML Block's raw content. 5211 * @param {Object} commentAttributes Block's comment attributes. 5212 * 5213 * @return {*} Attribute value. 5214 */ 5215 5216 function getBlockAttribute(attributeKey, attributeSchema, innerHTML, commentAttributes) { 5217 const { 5218 type, 5219 enum: enumSet 5220 } = attributeSchema; 5221 let value; 5222 5223 switch (attributeSchema.source) { 5224 // An undefined source means that it's an attribute serialized to the 5225 // block's "comment". 5226 case undefined: 5227 value = commentAttributes ? commentAttributes[attributeKey] : undefined; 5228 break; 5229 5230 case 'attribute': 5231 case 'property': 5232 case 'html': 5233 case 'text': 5234 case 'children': 5235 case 'node': 5236 case 'query': 5237 case 'tag': 5238 value = parseWithAttributeSchema(innerHTML, attributeSchema); 5239 break; 5240 } 5241 5242 if (!isValidByType(value, type) || !isValidByEnum(value, enumSet)) { 5243 // Reject the value if it is not valid. Reverting to the undefined 5244 // value ensures the default is respected, if applicable. 5245 value = undefined; 5246 } 5247 5248 if (value === undefined) { 5249 return attributeSchema.default; 5250 } 5251 5252 return value; 5253 } 5254 /** 5255 * Returns the block attributes of a registered block node given its type. 5256 * 5257 * @param {string|Object} blockTypeOrName Block type or name. 5258 * @param {string} innerHTML Raw block content. 5259 * @param {?Object} attributes Known block attributes (from delimiters). 5260 * 5261 * @return {Object} All block attributes. 5262 */ 5263 5264 function getBlockAttributes(blockTypeOrName, innerHTML, attributes = {}) { 5265 const blockType = normalizeBlockType(blockTypeOrName); 5266 const blockAttributes = Object(external_lodash_["mapValues"])(blockType.attributes, (attributeSchema, attributeKey) => { 5267 return getBlockAttribute(attributeKey, attributeSchema, innerHTML, attributes); 5268 }); 5269 return Object(external_wp_hooks_["applyFilters"])('blocks.getBlockAttributes', blockAttributes, blockType, innerHTML, attributes); 5270 } 5271 /** 5272 * Given a block object, returns a new copy of the block with any applicable 5273 * deprecated migrations applied, or the original block if it was both valid 5274 * and no eligible migrations exist. 5275 * 5276 * @param {WPBlock} block Original block object. 5277 * @param {Object} parsedAttributes Attributes as parsed from the initial 5278 * block markup. 5279 * 5280 * @return {WPBlock} Migrated block object. 5281 */ 5282 5283 function getMigratedBlock(block, parsedAttributes) { 5284 const blockType = registration_getBlockType(block.name); 5285 const { 5286 deprecated: deprecatedDefinitions 5287 } = blockType; // Bail early if there are no registered deprecations to be handled. 5288 5289 if (!deprecatedDefinitions || !deprecatedDefinitions.length) { 5290 return block; 5291 } 5292 5293 const { 5294 originalContent, 5295 innerBlocks 5296 } = block; // By design, blocks lack any sort of version tracking. Instead, to process 5297 // outdated content the system operates a queue out of all the defined 5298 // attribute shapes and tries each definition until the input produces a 5299 // valid result. This mechanism seeks to avoid polluting the user-space with 5300 // machine-specific code. An invalid block is thus a block that could not be 5301 // matched successfully with any of the registered deprecation definitions. 5302 5303 for (let i = 0; i < deprecatedDefinitions.length; i++) { 5304 // A block can opt into a migration even if the block is valid by 5305 // defining `isEligible` on its deprecation. If the block is both valid 5306 // and does not opt to migrate, skip. 5307 const { 5308 isEligible = external_lodash_["stubFalse"] 5309 } = deprecatedDefinitions[i]; 5310 5311 if (block.isValid && !isEligible(parsedAttributes, innerBlocks)) { 5312 continue; 5313 } // Block type properties which could impact either serialization or 5314 // parsing are not considered in the deprecated block type by default, 5315 // and must be explicitly provided. 5316 5317 5318 const deprecatedBlockType = Object.assign(Object(external_lodash_["omit"])(blockType, DEPRECATED_ENTRY_KEYS), deprecatedDefinitions[i]); 5319 let migratedAttributes = getBlockAttributes(deprecatedBlockType, originalContent, parsedAttributes); // Ignore the deprecation if it produces a block which is not valid. 5320 5321 const { 5322 isValid, 5323 validationIssues 5324 } = getBlockContentValidationResult(deprecatedBlockType, migratedAttributes, originalContent); // An invalid block does not imply incorrect HTML but the fact block 5325 // source information could be lost on reserialization. 5326 5327 if (!isValid) { 5328 block = { ...block, 5329 validationIssues: [...Object(external_lodash_["get"])(block, 'validationIssues', []), ...validationIssues] 5330 }; 5331 continue; 5332 } 5333 5334 let migratedInnerBlocks = innerBlocks; // A block may provide custom behavior to assign new attributes and/or 5335 // inner blocks. 5336 5337 const { 5338 migrate 5339 } = deprecatedBlockType; 5340 5341 if (migrate) { 5342 [migratedAttributes = parsedAttributes, migratedInnerBlocks = innerBlocks] = Object(external_lodash_["castArray"])(migrate(migratedAttributes, innerBlocks)); 5343 } 5344 5345 block = { ...block, 5346 attributes: migratedAttributes, 5347 innerBlocks: migratedInnerBlocks, 5348 isValid: true 5349 }; 5350 } 5351 5352 return block; 5353 } 5354 /** 5355 * Convert legacy blocks to their canonical form. This function is used 5356 * both in the parser level for previous content and to convert such blocks 5357 * used in Custom Post Types templates. 5358 * 5359 * @param {string} name The block's name 5360 * @param {Object} attributes The block's attributes 5361 * 5362 * @return {Object} The block's name and attributes, changed accordingly if a match was found 5363 */ 5364 5365 function convertLegacyBlocks(name, attributes) { 5366 const newAttributes = { ...attributes 5367 }; // Convert 'core/cover-image' block in existing content to 'core/cover'. 5368 5369 if ('core/cover-image' === name) { 5370 name = 'core/cover'; 5371 } // Convert 'core/text' blocks in existing content to 'core/paragraph'. 5372 5373 5374 if ('core/text' === name || 'core/cover-text' === name) { 5375 name = 'core/paragraph'; 5376 } // Convert derivative blocks such as 'core/social-link-wordpress' to the 5377 // canonical form 'core/social-link'. 5378 5379 5380 if (name && name.indexOf('core/social-link-') === 0) { 5381 // Capture `social-link-wordpress` into `{"service":"wordpress"}` 5382 newAttributes.service = name.substring(17); 5383 name = 'core/social-link'; 5384 } // Convert derivative blocks such as 'core-embed/instagram' to the 5385 // canonical form 'core/embed'. 5386 5387 5388 if (name && name.indexOf('core-embed/') === 0) { 5389 // Capture `core-embed/instagram` into `{"providerNameSlug":"instagram"}` 5390 const providerSlug = name.substring(11); 5391 const deprecated = { 5392 speaker: 'speaker-deck', 5393 polldaddy: 'crowdsignal' 5394 }; 5395 newAttributes.providerNameSlug = providerSlug in deprecated ? deprecated[providerSlug] : providerSlug; // this is needed as the `responsive` attribute was passed 5396 // in a different way before the refactoring to block variations 5397 5398 if (!['amazon-kindle', 'wordpress'].includes(providerSlug)) { 5399 newAttributes.responsive = true; 5400 } 5401 5402 name = 'core/embed'; 5403 } // Convert 'core/query-loop' blocks in existing content to 'core/post-template'. 5404 // TODO: Remove this check when WordPress 5.9 is released. 5405 5406 5407 if (name === 'core/query-loop') { 5408 name = 'core/post-template'; 5409 } 5410 5411 return { 5412 name, 5413 attributes: newAttributes 5414 }; 5415 } 5416 /** 5417 * Creates a block with fallback to the unknown type handler. 5418 * 5419 * @param {Object} blockNode Parsed block node. 5420 * 5421 * @return {?Object} An initialized block object (if possible). 5422 */ 5423 5424 function createBlockWithFallback(blockNode) { 5425 const { 5426 blockName: originalName 5427 } = blockNode; // The fundamental structure of a blocktype includes its attributes, inner 5428 // blocks, and inner HTML. It is important to distinguish inner blocks from 5429 // the HTML content of the block as only the latter is relevant for block 5430 // validation and edit operations. 5431 5432 let { 5433 attrs: attributes, 5434 innerBlocks = [], 5435 innerHTML 5436 } = blockNode; 5437 const { 5438 innerContent 5439 } = blockNode; // Blocks that don't have a registered handler are considered freeform. 5440 5441 const freeformContentFallbackBlock = getFreeformContentHandlerName(); 5442 const unregisteredFallbackBlock = getUnregisteredTypeHandlerName() || freeformContentFallbackBlock; 5443 attributes = attributes || {}; // Trim content to avoid creation of intermediary freeform segments. 5444 5445 innerHTML = innerHTML.trim(); // Use type from block content if available. Otherwise, default to the 5446 // freeform content fallback. 5447 5448 let name = originalName || freeformContentFallbackBlock; 5449 ({ 5450 name, 5451 attributes 5452 } = convertLegacyBlocks(name, attributes)); // Fallback content may be upgraded from classic content expecting implicit 5453 // automatic paragraphs, so preserve them. Assumes wpautop is idempotent, 5454 // meaning there are no negative consequences to repeated autop calls. 5455 5456 if (name === freeformContentFallbackBlock) { 5457 innerHTML = Object(external_wp_autop_["autop"])(innerHTML).trim(); 5458 } // Try finding the type for known block name, else fall back again. 5459 5460 5461 let blockType = registration_getBlockType(name); 5462 5463 if (!blockType) { 5464 // Since the constituents of the block node are extracted at the start 5465 // of the present function, construct a new object rather than reuse 5466 // `blockNode`. 5467 const reconstitutedBlockNode = { 5468 attrs: attributes, 5469 blockName: originalName, 5470 innerBlocks, 5471 innerContent 5472 }; // Preserve undelimited content for use by the unregistered type 5473 // handler. A block node's `innerHTML` isn't enough, as that field only 5474 // carries the block's own HTML and not its nested blocks. 5475 5476 const originalUndelimitedContent = serializeBlockNode(reconstitutedBlockNode, { 5477 isCommentDelimited: false 5478 }); // Preserve full block content for use by the unregistered type 5479 // handler, block boundaries included. 5480 5481 const originalContent = serializeBlockNode(reconstitutedBlockNode, { 5482 isCommentDelimited: true 5483 }); // If detected as a block which is not registered, preserve comment 5484 // delimiters in content of unregistered type handler. 5485 5486 if (name) { 5487 innerHTML = originalContent; 5488 } 5489 5490 name = unregisteredFallbackBlock; 5491 attributes = { 5492 originalName, 5493 originalContent, 5494 originalUndelimitedContent 5495 }; 5496 blockType = registration_getBlockType(name); 5497 } // Coerce inner blocks from parsed form to canonical form. 5498 5499 5500 innerBlocks = innerBlocks.map(createBlockWithFallback); // Remove `undefined` innerBlocks. 5501 // 5502 // This is a temporary fix to prevent unrecoverable TypeErrors when handling unexpectedly 5503 // empty freeform block nodes. See https://github.com/WordPress/gutenberg/pull/17164. 5504 5505 innerBlocks = innerBlocks.filter(innerBlock => innerBlock); 5506 const isFallbackBlock = name === freeformContentFallbackBlock || name === unregisteredFallbackBlock; // Include in set only if type was determined. 5507 5508 if (!blockType || !innerHTML && isFallbackBlock) { 5509 return; 5510 } 5511 5512 let block = createBlock(name, getBlockAttributes(blockType, innerHTML, attributes), innerBlocks); // Block validation assumes an idempotent operation from source block to serialized block 5513 // provided there are no changes in attributes. The validation procedure thus compares the 5514 // provided source value with the serialized output before there are any modifications to 5515 // the block. When both match, the block is marked as valid. 5516 5517 if (!isFallbackBlock) { 5518 const { 5519 isValid, 5520 validationIssues 5521 } = getBlockContentValidationResult(blockType, block.attributes, innerHTML); 5522 block.isValid = isValid; 5523 block.validationIssues = validationIssues; 5524 } // Preserve original content for future use in case the block is parsed 5525 // as invalid, or future serialization attempt results in an error. 5526 5527 5528 block.originalContent = block.originalContent || innerHTML; // Ensure all necessary migrations are applied to the block. 5529 5530 block = getMigratedBlock(block, attributes); 5531 5532 if (block.validationIssues && block.validationIssues.length > 0) { 5533 if (block.isValid) { 5534 // eslint-disable-next-line no-console 5535 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, block.attributes), block.originalContent); 5536 } else { 5537 block.validationIssues.forEach(({ 5538 log, 5539 args 5540 }) => log(...args)); 5541 } 5542 } 5543 5544 return block; 5545 } 5546 /** 5547 * Serializes a block node into the native HTML-comment-powered block format. 5548 * CAVEAT: This function is intended for reserializing blocks as parsed by 5549 * valid parsers and skips any validation steps. This is NOT a generic 5550 * serialization function for in-memory blocks. For most purposes, see the 5551 * following functions available in the `@wordpress/blocks` package: 5552 * 5553 * @see serializeBlock 5554 * @see serialize 5555 * 5556 * For more on the format of block nodes as returned by valid parsers: 5557 * 5558 * @see `@wordpress/block-serialization-default-parser` package 5559 * @see `@wordpress/block-serialization-spec-parser` package 5560 * 5561 * @param {Object} blockNode A block node as returned by a valid parser. 5562 * @param {?Object} options Serialization options. 5563 * @param {?boolean} options.isCommentDelimited Whether to output HTML comments around blocks. 5564 * 5565 * @return {string} An HTML string representing a block. 5566 */ 5567 5568 function serializeBlockNode(blockNode, options = {}) { 5569 const { 5570 isCommentDelimited = true 5571 } = options; 5572 const { 5573 blockName, 5574 attrs = {}, 5575 innerBlocks = [], 5576 innerContent = [] 5577 } = blockNode; 5578 let childIndex = 0; 5579 const content = innerContent.map(item => // `null` denotes a nested block, otherwise we have an HTML fragment. 5580 item !== null ? item : serializeBlockNode(innerBlocks[childIndex++], options)).join('\n').replace(/\n+/g, '\n').trim(); 5581 return isCommentDelimited ? getCommentDelimitedContent(blockName, attrs, content) : content; 5582 } 5583 /** 5584 * Creates a parse implementation for the post content which returns a list of blocks. 5585 * 5586 * @param {Function} parseImplementation Parse implementation. 5587 * 5588 * @return {Function} An implementation which parses the post content. 5589 */ 5590 5591 const createParse = parseImplementation => content => parseImplementation(content).reduce((accumulator, blockNode) => { 5592 const block = createBlockWithFallback(blockNode); 5593 5594 if (block) { 5595 accumulator.push(block); 5596 } 5597 5598 return accumulator; 5599 }, []); 5600 /** 5601 * Utilizes an optimized token-driven parser based on the Gutenberg grammar spec 5602 * defined through a parsing expression grammar to take advantage of the regular 5603 * cadence provided by block delimiters -- composed syntactically through HTML 5604 * comments -- which, given a general HTML document as an input, returns a block 5605 * list array representation. 5606 * 5607 * This is a recursive-descent parser that scans linearly once through the input 5608 * document. Instead of directly recursing it utilizes a trampoline mechanism to 5609 * prevent stack overflow. This initial pass is mainly interested in separating 5610 * and isolating the blocks serialized in the document and manifestly not in the 5611 * content within the blocks. 5612 * 5613 * @see 5614 * https://developer.wordpress.org/block-editor/packages/packages-block-serialization-default-parser/ 5615 * 5616 * @param {string} content The post content. 5617 * 5618 * @return {Array} Block list. 5619 */ 5620 5621 5622 const parseWithGrammar = createParse(external_wp_blockSerializationDefaultParser_["parse"]); 5623 /* harmony default export */ var parser = (parseWithGrammar); 5624 5625 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/get-raw-transforms.js 5626 /** 5627 * External dependencies 5628 */ 5629 5630 /** 5631 * Internal dependencies 5632 */ 5633 5634 5635 function getRawTransforms() { 5636 return Object(external_lodash_["filter"])(getBlockTransforms('from'), { 5637 type: 'raw' 5638 }).map(transform => { 5639 return transform.isMatch ? transform : { ...transform, 5640 isMatch: node => transform.selector && node.matches(transform.selector) 5641 }; 5642 }); 5643 } 5644 5645 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/html-to-blocks.js 5646 /** 5647 * Internal dependencies 5648 */ 5649 5650 5651 5652 /** 5653 * Converts HTML directly to blocks. Looks for a matching transform for each 5654 * top-level tag. The HTML should be filtered to not have any text between 5655 * top-level tags and formatted in a way that blocks can handle the HTML. 5656 * 5657 * @param {string} html HTML to convert. 5658 * 5659 * @return {Array} An array of blocks. 5660 */ 5661 5662 function htmlToBlocks(html) { 5663 const doc = document.implementation.createHTMLDocument(''); 5664 doc.body.innerHTML = html; 5665 return Array.from(doc.body.children).flatMap(node => { 5666 const rawTransform = findTransform(getRawTransforms(), ({ 5667 isMatch 5668 }) => isMatch(node)); 5669 5670 if (!rawTransform) { 5671 return createBlock( // Should not be hardcoded. 5672 'core/html', getBlockAttributes('core/html', node.outerHTML)); 5673 } 5674 5675 const { 5676 transform, 5677 blockName 5678 } = rawTransform; 5679 5680 if (transform) { 5681 return transform(node); 5682 } 5683 5684 return createBlock(blockName, getBlockAttributes(blockName, node.outerHTML)); 5685 }); 5686 } 5687 5688 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/normalise-blocks.js 5689 /** 5690 * WordPress dependencies 5691 */ 5692 5693 function normaliseBlocks(HTML) { 5694 const decuDoc = document.implementation.createHTMLDocument(''); 5695 const accuDoc = document.implementation.createHTMLDocument(''); 5696 const decu = decuDoc.body; 5697 const accu = accuDoc.body; 5698 decu.innerHTML = HTML; 5699 5700 while (decu.firstChild) { 5701 const node = decu.firstChild; // Text nodes: wrap in a paragraph, or append to previous. 5702 5703 if (node.nodeType === node.TEXT_NODE) { 5704 if (Object(external_wp_dom_["isEmpty"])(node)) { 5705 decu.removeChild(node); 5706 } else { 5707 if (!accu.lastChild || accu.lastChild.nodeName !== 'P') { 5708 accu.appendChild(accuDoc.createElement('P')); 5709 } 5710 5711 accu.lastChild.appendChild(node); 5712 } // Element nodes. 5713 5714 } else if (node.nodeType === node.ELEMENT_NODE) { 5715 // BR nodes: create a new paragraph on double, or append to previous. 5716 if (node.nodeName === 'BR') { 5717 if (node.nextSibling && node.nextSibling.nodeName === 'BR') { 5718 accu.appendChild(accuDoc.createElement('P')); 5719 decu.removeChild(node.nextSibling); 5720 } // Don't append to an empty paragraph. 5721 5722 5723 if (accu.lastChild && accu.lastChild.nodeName === 'P' && accu.lastChild.hasChildNodes()) { 5724 accu.lastChild.appendChild(node); 5725 } else { 5726 decu.removeChild(node); 5727 } 5728 } else if (node.nodeName === 'P') { 5729 // Only append non-empty paragraph nodes. 5730 if (Object(external_wp_dom_["isEmpty"])(node)) { 5731 decu.removeChild(node); 5732 } else { 5733 accu.appendChild(node); 5734 } 5735 } else if (Object(external_wp_dom_["isPhrasingContent"])(node)) { 5736 if (!accu.lastChild || accu.lastChild.nodeName !== 'P') { 5737 accu.appendChild(accuDoc.createElement('P')); 5738 } 5739 5740 accu.lastChild.appendChild(node); 5741 } else { 5742 accu.appendChild(node); 5743 } 5744 } else { 5745 decu.removeChild(node); 5746 } 5747 } 5748 5749 return accu.innerHTML; 5750 } 5751 5752 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/special-comment-converter.js 5753 /** 5754 * WordPress dependencies 5755 */ 5756 5757 /** 5758 * Looks for `<!--nextpage-->` and `<!--more-->` comments, as well as the 5759 * `<!--more Some text-->` variant and its `<!--noteaser-->` companion, 5760 * and replaces them with a custom element representing a future block. 5761 * 5762 * The custom element is a way to bypass the rest of the `raw-handling` 5763 * transforms, which would eliminate other kinds of node with which to carry 5764 * `<!--more-->`'s data: nodes with `data` attributes, empty paragraphs, etc. 5765 * 5766 * The custom element is then expected to be recognized by any registered 5767 * block's `raw` transform. 5768 * 5769 * @param {Node} node The node to be processed. 5770 * @param {Document} doc The document of the node. 5771 * @return {void} 5772 */ 5773 5774 function specialCommentConverter(node, doc) { 5775 if (node.nodeType !== node.COMMENT_NODE) { 5776 return; 5777 } 5778 5779 if (node.nodeValue === 'nextpage') { 5780 Object(external_wp_dom_["replace"])(node, createNextpage(doc)); 5781 return; 5782 } 5783 5784 if (node.nodeValue.indexOf('more') === 0) { 5785 // Grab any custom text in the comment. 5786 const customText = node.nodeValue.slice(4).trim(); 5787 /* 5788 * When a `<!--more-->` comment is found, we need to look for any 5789 * `<!--noteaser-->` sibling, but it may not be a direct sibling 5790 * (whitespace typically lies in between) 5791 */ 5792 5793 let sibling = node; 5794 let noTeaser = false; 5795 5796 while (sibling = sibling.nextSibling) { 5797 if (sibling.nodeType === sibling.COMMENT_NODE && sibling.nodeValue === 'noteaser') { 5798 noTeaser = true; 5799 Object(external_wp_dom_["remove"])(sibling); 5800 break; 5801 } 5802 } 5803 5804 Object(external_wp_dom_["replace"])(node, createMore(customText, noTeaser, doc)); 5805 } 5806 } 5807 5808 function createMore(customText, noTeaser, doc) { 5809 const node = doc.createElement('wp-block'); 5810 node.dataset.block = 'core/more'; 5811 5812 if (customText) { 5813 node.dataset.customText = customText; 5814 } 5815 5816 if (noTeaser) { 5817 // "Boolean" data attribute 5818 node.dataset.noTeaser = ''; 5819 } 5820 5821 return node; 5822 } 5823 5824 function createNextpage(doc) { 5825 const node = doc.createElement('wp-block'); 5826 node.dataset.block = 'core/nextpage'; 5827 return node; 5828 } 5829 5830 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/comment-remover.js 5831 /** 5832 * WordPress dependencies 5833 */ 5834 5835 /** 5836 * Looks for comments, and removes them. 5837 * 5838 * @param {Node} node The node to be processed. 5839 * @return {void} 5840 */ 5841 5842 function commentRemover(node) { 5843 if (node.nodeType === node.COMMENT_NODE) { 5844 Object(external_wp_dom_["remove"])(node); 5845 } 5846 } 5847 5848 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/is-inline-content.js 5849 /** 5850 * External dependencies 5851 */ 5852 5853 /** 5854 * WordPress dependencies 5855 */ 5856 5857 5858 /** 5859 * Checks if the given node should be considered inline content, optionally 5860 * depending on a context tag. 5861 * 5862 * @param {Node} node Node name. 5863 * @param {string} contextTag Tag name. 5864 * 5865 * @return {boolean} True if the node is inline content, false if nohe. 5866 */ 5867 5868 function isInline(node, contextTag) { 5869 if (Object(external_wp_dom_["isTextContent"])(node)) { 5870 return true; 5871 } 5872 5873 if (!contextTag) { 5874 return false; 5875 } 5876 5877 const tag = node.nodeName.toLowerCase(); 5878 const inlineAllowedTagGroups = [['ul', 'li', 'ol'], ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']]; 5879 return inlineAllowedTagGroups.some(tagGroup => Object(external_lodash_["difference"])([tag, contextTag], tagGroup).length === 0); 5880 } 5881 5882 function deepCheck(nodes, contextTag) { 5883 return nodes.every(node => isInline(node, contextTag) && deepCheck(Array.from(node.children), contextTag)); 5884 } 5885 5886 function isDoubleBR(node) { 5887 return node.nodeName === 'BR' && node.previousSibling && node.previousSibling.nodeName === 'BR'; 5888 } 5889 5890 function isInlineContent(HTML, contextTag) { 5891 const doc = document.implementation.createHTMLDocument(''); 5892 doc.body.innerHTML = HTML; 5893 const nodes = Array.from(doc.body.children); 5894 return !nodes.some(isDoubleBR) && deepCheck(nodes, contextTag); 5895 } 5896 5897 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/phrasing-content-reducer.js 5898 /** 5899 * External dependencies 5900 */ 5901 5902 /** 5903 * WordPress dependencies 5904 */ 5905 5906 5907 function phrasingContentReducer(node, doc) { 5908 // In jsdom-jscore, 'node.style' can be null. 5909 // TODO: Explore fixing this by patching jsdom-jscore. 5910 if (node.nodeName === 'SPAN' && node.style) { 5911 const { 5912 fontWeight, 5913 fontStyle, 5914 textDecorationLine, 5915 textDecoration, 5916 verticalAlign 5917 } = node.style; 5918 5919 if (fontWeight === 'bold' || fontWeight === '700') { 5920 Object(external_wp_dom_["wrap"])(doc.createElement('strong'), node); 5921 } 5922 5923 if (fontStyle === 'italic') { 5924 Object(external_wp_dom_["wrap"])(doc.createElement('em'), node); 5925 } // Some DOM implementations (Safari, JSDom) don't support 5926 // style.textDecorationLine, so we check style.textDecoration as a 5927 // fallback. 5928 5929 5930 if (textDecorationLine === 'line-through' || Object(external_lodash_["includes"])(textDecoration, 'line-through')) { 5931 Object(external_wp_dom_["wrap"])(doc.createElement('s'), node); 5932 } 5933 5934 if (verticalAlign === 'super') { 5935 Object(external_wp_dom_["wrap"])(doc.createElement('sup'), node); 5936 } else if (verticalAlign === 'sub') { 5937 Object(external_wp_dom_["wrap"])(doc.createElement('sub'), node); 5938 } 5939 } else if (node.nodeName === 'B') { 5940 node = Object(external_wp_dom_["replaceTag"])(node, 'strong'); 5941 } else if (node.nodeName === 'I') { 5942 node = Object(external_wp_dom_["replaceTag"])(node, 'em'); 5943 } else if (node.nodeName === 'A') { 5944 // In jsdom-jscore, 'node.target' can be null. 5945 // TODO: Explore fixing this by patching jsdom-jscore. 5946 if (node.target && node.target.toLowerCase() === '_blank') { 5947 node.rel = 'noreferrer noopener'; 5948 } else { 5949 node.removeAttribute('target'); 5950 node.removeAttribute('rel'); 5951 } 5952 } 5953 } 5954 5955 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/head-remover.js 5956 function headRemover(node) { 5957 if (node.nodeName !== 'SCRIPT' && node.nodeName !== 'NOSCRIPT' && node.nodeName !== 'TEMPLATE' && node.nodeName !== 'STYLE') { 5958 return; 5959 } 5960 5961 node.parentNode.removeChild(node); 5962 } 5963 5964 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/ms-list-converter.js 5965 /** 5966 * Browser dependencies 5967 */ 5968 const { 5969 parseInt: ms_list_converter_parseInt 5970 } = window; 5971 5972 function isList(node) { 5973 return node.nodeName === 'OL' || node.nodeName === 'UL'; 5974 } 5975 5976 function msListConverter(node, doc) { 5977 if (node.nodeName !== 'P') { 5978 return; 5979 } 5980 5981 const style = node.getAttribute('style'); 5982 5983 if (!style) { 5984 return; 5985 } // Quick check. 5986 5987 5988 if (style.indexOf('mso-list') === -1) { 5989 return; 5990 } 5991 5992 const matches = /mso-list\s*:[^;]+level([0-9]+)/i.exec(style); 5993 5994 if (!matches) { 5995 return; 5996 } 5997 5998 let level = ms_list_converter_parseInt(matches[1], 10) - 1 || 0; 5999 const prevNode = node.previousElementSibling; // Add new list if no previous. 6000 6001 if (!prevNode || !isList(prevNode)) { 6002 // See https://html.spec.whatwg.org/multipage/grouping-content.html#attr-ol-type. 6003 const type = node.textContent.trim().slice(0, 1); 6004 const isNumeric = /[1iIaA]/.test(type); 6005 const newListNode = doc.createElement(isNumeric ? 'ol' : 'ul'); 6006 6007 if (isNumeric) { 6008 newListNode.setAttribute('type', type); 6009 } 6010 6011 node.parentNode.insertBefore(newListNode, node); 6012 } 6013 6014 const listNode = node.previousElementSibling; 6015 const listType = listNode.nodeName; 6016 const listItem = doc.createElement('li'); 6017 let receivingNode = listNode; // Remove the first span with list info. 6018 6019 node.removeChild(node.firstElementChild); // Add content. 6020 6021 while (node.firstChild) { 6022 listItem.appendChild(node.firstChild); 6023 } // Change pointer depending on indentation level. 6024 6025 6026 while (level--) { 6027 receivingNode = receivingNode.lastElementChild || receivingNode; // If it's a list, move pointer to the last item. 6028 6029 if (isList(receivingNode)) { 6030 receivingNode = receivingNode.lastElementChild || receivingNode; 6031 } 6032 } // Make sure we append to a list. 6033 6034 6035 if (!isList(receivingNode)) { 6036 receivingNode = receivingNode.appendChild(doc.createElement(listType)); 6037 } // Append the list item to the list. 6038 6039 6040 receivingNode.appendChild(listItem); // Remove the wrapper paragraph. 6041 6042 node.parentNode.removeChild(node); 6043 } 6044 6045 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/list-reducer.js 6046 /** 6047 * WordPress dependencies 6048 */ 6049 6050 6051 function list_reducer_isList(node) { 6052 return node.nodeName === 'OL' || node.nodeName === 'UL'; 6053 } 6054 6055 function shallowTextContent(element) { 6056 return Array.from(element.childNodes).map(({ 6057 nodeValue = '' 6058 }) => nodeValue).join(''); 6059 } 6060 6061 function listReducer(node) { 6062 if (!list_reducer_isList(node)) { 6063 return; 6064 } 6065 6066 const list = node; 6067 const prevElement = node.previousElementSibling; // Merge with previous list if: 6068 // * There is a previous list of the same type. 6069 // * There is only one list item. 6070 6071 if (prevElement && prevElement.nodeName === node.nodeName && list.children.length === 1) { 6072 // Move all child nodes, including any text nodes, if any. 6073 while (list.firstChild) { 6074 prevElement.appendChild(list.firstChild); 6075 } 6076 6077 list.parentNode.removeChild(list); 6078 } 6079 6080 const parentElement = node.parentNode; // Nested list with empty parent item. 6081 6082 if (parentElement && parentElement.nodeName === 'LI' && parentElement.children.length === 1 && !/\S/.test(shallowTextContent(parentElement))) { 6083 const parentListItem = parentElement; 6084 const prevListItem = parentListItem.previousElementSibling; 6085 const parentList = parentListItem.parentNode; 6086 6087 if (prevListItem) { 6088 prevListItem.appendChild(list); 6089 parentList.removeChild(parentListItem); 6090 } else { 6091 parentList.parentNode.insertBefore(list, parentList); 6092 parentList.parentNode.removeChild(parentList); 6093 } 6094 } // Invalid: OL/UL > OL/UL. 6095 6096 6097 if (parentElement && list_reducer_isList(parentElement)) { 6098 const prevListItem = node.previousElementSibling; 6099 6100 if (prevListItem) { 6101 prevListItem.appendChild(node); 6102 } else { 6103 Object(external_wp_dom_["unwrap"])(node); 6104 } 6105 } 6106 } 6107 6108 // EXTERNAL MODULE: external ["wp","blob"] 6109 var external_wp_blob_ = __webpack_require__("xTGt"); 6110 6111 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/image-corrector.js 6112 /** 6113 * WordPress dependencies 6114 */ 6115 6116 /** 6117 * Browser dependencies 6118 */ 6119 6120 const { 6121 atob, 6122 File 6123 } = window; 6124 function imageCorrector(node) { 6125 if (node.nodeName !== 'IMG') { 6126 return; 6127 } 6128 6129 if (node.src.indexOf('file:') === 0) { 6130 node.src = ''; 6131 } // This piece cannot be tested outside a browser env. 6132 6133 6134 if (node.src.indexOf('data:') === 0) { 6135 const [properties, data] = node.src.split(','); 6136 const [type] = properties.slice(5).split(';'); 6137 6138 if (!data || !type) { 6139 node.src = ''; 6140 return; 6141 } 6142 6143 let decoded; // Can throw DOMException! 6144 6145 try { 6146 decoded = atob(data); 6147 } catch (e) { 6148 node.src = ''; 6149 return; 6150 } 6151 6152 const uint8Array = new Uint8Array(decoded.length); 6153 6154 for (let i = 0; i < uint8Array.length; i++) { 6155 uint8Array[i] = decoded.charCodeAt(i); 6156 } 6157 6158 const name = type.replace('/', '.'); 6159 const file = new File([uint8Array], name, { 6160 type 6161 }); 6162 node.src = Object(external_wp_blob_["createBlobURL"])(file); 6163 } // Remove trackers and hardly visible images. 6164 6165 6166 if (node.height === 1 || node.width === 1) { 6167 node.parentNode.removeChild(node); 6168 } 6169 } 6170 6171 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/blockquote-normaliser.js 6172 /** 6173 * Internal dependencies 6174 */ 6175 6176 function blockquoteNormaliser(node) { 6177 if (node.nodeName !== 'BLOCKQUOTE') { 6178 return; 6179 } 6180 6181 node.innerHTML = normaliseBlocks(node.innerHTML); 6182 } 6183 6184 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/figure-content-reducer.js 6185 /** 6186 * External dependencies 6187 */ 6188 6189 /** 6190 * WordPress dependencies 6191 */ 6192 6193 6194 /** 6195 * Whether or not the given node is figure content. 6196 * 6197 * @param {Node} node The node to check. 6198 * @param {Object} schema The schema to use. 6199 * 6200 * @return {boolean} True if figure content, false if not. 6201 */ 6202 6203 function isFigureContent(node, schema) { 6204 const tag = node.nodeName.toLowerCase(); // We are looking for tags that can be a child of the figure tag, excluding 6205 // `figcaption` and any phrasing content. 6206 6207 if (tag === 'figcaption' || Object(external_wp_dom_["isTextContent"])(node)) { 6208 return false; 6209 } 6210 6211 return Object(external_lodash_["has"])(schema, ['figure', 'children', tag]); 6212 } 6213 /** 6214 * Whether or not the given node can have an anchor. 6215 * 6216 * @param {Node} node The node to check. 6217 * @param {Object} schema The schema to use. 6218 * 6219 * @return {boolean} True if it can, false if not. 6220 */ 6221 6222 6223 function canHaveAnchor(node, schema) { 6224 const tag = node.nodeName.toLowerCase(); 6225 return Object(external_lodash_["has"])(schema, ['figure', 'children', 'a', 'children', tag]); 6226 } 6227 /** 6228 * Wraps the given element in a figure element. 6229 * 6230 * @param {Element} element The element to wrap. 6231 * @param {Element} beforeElement The element before which to place the figure. 6232 */ 6233 6234 6235 function wrapFigureContent(element, beforeElement = element) { 6236 const figure = element.ownerDocument.createElement('figure'); 6237 beforeElement.parentNode.insertBefore(figure, beforeElement); 6238 figure.appendChild(element); 6239 } 6240 /** 6241 * This filter takes figure content out of paragraphs, wraps it in a figure 6242 * element, and moves any anchors with it if needed. 6243 * 6244 * @param {Node} node The node to filter. 6245 * @param {Document} doc The document of the node. 6246 * @param {Object} schema The schema to use. 6247 * 6248 * @return {void} 6249 */ 6250 6251 6252 function figureContentReducer(node, doc, schema) { 6253 if (!isFigureContent(node, schema)) { 6254 return; 6255 } 6256 6257 let nodeToInsert = node; 6258 const parentNode = node.parentNode; // If the figure content can have an anchor and its parent is an anchor with 6259 // only the figure content, take the anchor out instead of just the content. 6260 6261 if (canHaveAnchor(node, schema) && parentNode.nodeName === 'A' && parentNode.childNodes.length === 1) { 6262 nodeToInsert = node.parentNode; 6263 } 6264 6265 const wrapper = nodeToInsert.closest('p,div'); // If wrapped in a paragraph or div, only extract if it's aligned or if 6266 // there is no text content. 6267 // Otherwise, if directly at the root, wrap in a figure element. 6268 6269 if (wrapper) { 6270 // In jsdom-jscore, 'node.classList' can be undefined. 6271 // In this case, default to extract as it offers a better UI experience on mobile. 6272 if (!node.classList) { 6273 wrapFigureContent(nodeToInsert, wrapper); 6274 } else if (node.classList.contains('alignright') || node.classList.contains('alignleft') || node.classList.contains('aligncenter') || !wrapper.textContent.trim()) { 6275 wrapFigureContent(nodeToInsert, wrapper); 6276 } 6277 } else if (nodeToInsert.parentNode.nodeName === 'BODY') { 6278 wrapFigureContent(nodeToInsert); 6279 } 6280 } 6281 6282 // EXTERNAL MODULE: external ["wp","shortcode"] 6283 var external_wp_shortcode_ = __webpack_require__("SVSp"); 6284 6285 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/shortcode-converter.js 6286 /** 6287 * External dependencies 6288 */ 6289 6290 /** 6291 * WordPress dependencies 6292 */ 6293 6294 6295 /** 6296 * Internal dependencies 6297 */ 6298 6299 6300 6301 6302 6303 function segmentHTMLToShortcodeBlock(HTML, lastIndex = 0, excludedBlockNames = []) { 6304 // Get all matches. 6305 const transformsFrom = getBlockTransforms('from'); 6306 const transformation = findTransform(transformsFrom, transform => excludedBlockNames.indexOf(transform.blockName) === -1 && transform.type === 'shortcode' && Object(external_lodash_["some"])(Object(external_lodash_["castArray"])(transform.tag), tag => Object(external_wp_shortcode_["regexp"])(tag).test(HTML))); 6307 6308 if (!transformation) { 6309 return [HTML]; 6310 } 6311 6312 const transformTags = Object(external_lodash_["castArray"])(transformation.tag); 6313 const transformTag = Object(external_lodash_["find"])(transformTags, tag => Object(external_wp_shortcode_["regexp"])(tag).test(HTML)); 6314 let match; 6315 const previousIndex = lastIndex; 6316 6317 if (match = Object(external_wp_shortcode_["next"])(transformTag, HTML, lastIndex)) { 6318 lastIndex = match.index + match.content.length; 6319 const beforeHTML = HTML.substr(0, match.index); 6320 const afterHTML = HTML.substr(lastIndex); // If the shortcode content does not contain HTML and the shortcode is 6321 // not on a new line (or in paragraph from Markdown converter), 6322 // consider the shortcode as inline text, and thus skip conversion for 6323 // this segment. 6324 6325 if (!Object(external_lodash_["includes"])(match.shortcode.content || '', '<') && !(/(\n|<p>)\s*$/.test(beforeHTML) && /^\s*(\n|<\/p>)/.test(afterHTML))) { 6326 return segmentHTMLToShortcodeBlock(HTML, lastIndex); 6327 } // If a transformation's `isMatch` predicate fails for the inbound 6328 // shortcode, try again by excluding the current block type. 6329 // 6330 // This is the only call to `segmentHTMLToShortcodeBlock` that should 6331 // ever carry over `excludedBlockNames`. Other calls in the module 6332 // should skip that argument as a way to reset the exclusion state, so 6333 // that one `isMatch` fail in an HTML fragment doesn't prevent any 6334 // valid matches in subsequent fragments. 6335 6336 6337 if (transformation.isMatch && !transformation.isMatch(match.shortcode.attrs)) { 6338 return segmentHTMLToShortcodeBlock(HTML, previousIndex, [...excludedBlockNames, transformation.blockName]); 6339 } 6340 6341 const attributes = Object(external_lodash_["mapValues"])(Object(external_lodash_["pickBy"])(transformation.attributes, schema => schema.shortcode), // Passing all of `match` as second argument is intentionally broad 6342 // but shouldn't be too relied upon. 6343 // 6344 // See: https://github.com/WordPress/gutenberg/pull/3610#discussion_r152546926 6345 schema => schema.shortcode(match.shortcode.attrs, match)); 6346 const block = createBlock(transformation.blockName, getBlockAttributes({ ...registration_getBlockType(transformation.blockName), 6347 attributes: transformation.attributes 6348 }, match.shortcode.content, attributes)); 6349 return [...segmentHTMLToShortcodeBlock(beforeHTML), block, ...segmentHTMLToShortcodeBlock(afterHTML)]; 6350 } 6351 6352 return [HTML]; 6353 } 6354 6355 /* harmony default export */ var shortcode_converter = (segmentHTMLToShortcodeBlock); 6356 6357 // EXTERNAL MODULE: ./node_modules/showdown/dist/showdown.js 6358 var showdown = __webpack_require__("M55E"); 6359 var showdown_default = /*#__PURE__*/__webpack_require__.n(showdown); 6360 6361 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/markdown-converter.js 6362 /** 6363 * External dependencies 6364 */ 6365 // Reuse the same showdown converter. 6366 6367 const converter = new showdown_default.a.Converter({ 6368 noHeaderId: true, 6369 tables: true, 6370 literalMidWordUnderscores: true, 6371 omitExtraWLInCodeBlocks: true, 6372 simpleLineBreaks: true, 6373 strikethrough: true 6374 }); 6375 /** 6376 * Corrects the Slack Markdown variant of the code block. 6377 * If uncorrected, it will be converted to inline code. 6378 * 6379 * @see https://get.slack.help/hc/en-us/articles/202288908-how-can-i-add-formatting-to-my-messages-#code-blocks 6380 * 6381 * @param {string} text The potential Markdown text to correct. 6382 * 6383 * @return {string} The corrected Markdown. 6384 */ 6385 6386 function slackMarkdownVariantCorrector(text) { 6387 return text.replace(/((?:^|\n)```)([^\n`]+)(```(?:$|\n))/, (match, p1, p2, p3) => `$p1}\n$p2}\n$p3}`); 6388 } 6389 /** 6390 * Converts a piece of text into HTML based on any Markdown present. 6391 * Also decodes any encoded HTML. 6392 * 6393 * @param {string} text The plain text to convert. 6394 * 6395 * @return {string} HTML. 6396 */ 6397 6398 6399 function markdownConverter(text) { 6400 return converter.makeHtml(slackMarkdownVariantCorrector(text)); 6401 } 6402 6403 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/iframe-remover.js 6404 /** 6405 * Removes iframes. 6406 * 6407 * @param {Node} node The node to check. 6408 * 6409 * @return {void} 6410 */ 6411 function iframeRemover(node) { 6412 if (node.nodeName === 'IFRAME') { 6413 const text = node.ownerDocument.createTextNode(node.src); 6414 node.parentNode.replaceChild(text, node); 6415 } 6416 } 6417 6418 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/google-docs-uid-remover.js 6419 /** 6420 * WordPress dependencies 6421 */ 6422 6423 function googleDocsUIdRemover(node) { 6424 if (!node.id || node.id.indexOf('docs-internal-guid-') !== 0) { 6425 return; 6426 } 6427 6428 Object(external_wp_dom_["unwrap"])(node); 6429 } 6430 6431 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/utils.js 6432 /** 6433 * External dependencies 6434 */ 6435 6436 /** 6437 * WordPress dependencies 6438 */ 6439 6440 6441 /** 6442 * Internal dependencies 6443 */ 6444 6445 6446 6447 function getBlockContentSchemaFromTransforms(transforms, context) { 6448 const phrasingContentSchema = Object(external_wp_dom_["getPhrasingContentSchema"])(context); 6449 const schemaArgs = { 6450 phrasingContentSchema, 6451 isPaste: context === 'paste' 6452 }; 6453 const schemas = transforms.map(({ 6454 isMatch, 6455 blockName, 6456 schema 6457 }) => { 6458 const hasAnchorSupport = registration_hasBlockSupport(blockName, 'anchor'); 6459 schema = Object(external_lodash_["isFunction"])(schema) ? schema(schemaArgs) : schema; // If the block does not has anchor support and the transform does not 6460 // provides an isMatch we can return the schema right away. 6461 6462 if (!hasAnchorSupport && !isMatch) { 6463 return schema; 6464 } 6465 6466 return Object(external_lodash_["mapValues"])(schema, value => { 6467 let attributes = value.attributes || []; // If the block supports the "anchor" functionality, it needs to keep its ID attribute. 6468 6469 if (hasAnchorSupport) { 6470 attributes = [...attributes, 'id']; 6471 } 6472 6473 return { ...value, 6474 attributes, 6475 isMatch: isMatch ? isMatch : undefined 6476 }; 6477 }); 6478 }); 6479 return Object(external_lodash_["mergeWith"])({}, ...schemas, (objValue, srcValue, key) => { 6480 switch (key) { 6481 case 'children': 6482 { 6483 if (objValue === '*' || srcValue === '*') { 6484 return '*'; 6485 } 6486 6487 return { ...objValue, 6488 ...srcValue 6489 }; 6490 } 6491 6492 case 'attributes': 6493 case 'require': 6494 { 6495 return [...(objValue || []), ...(srcValue || [])]; 6496 } 6497 6498 case 'isMatch': 6499 { 6500 // If one of the values being merge is undefined (matches everything), 6501 // the result of the merge will be undefined. 6502 if (!objValue || !srcValue) { 6503 return undefined; 6504 } // When merging two isMatch functions, the result is a new function 6505 // that returns if one of the source functions returns true. 6506 6507 6508 return (...args) => { 6509 return objValue(...args) || srcValue(...args); 6510 }; 6511 } 6512 } 6513 }); 6514 } 6515 /** 6516 * Gets the block content schema, which is extracted and merged from all 6517 * registered blocks with raw transfroms. 6518 * 6519 * @param {string} context Set to "paste" when in paste context, where the 6520 * schema is more strict. 6521 * 6522 * @return {Object} A complete block content schema. 6523 */ 6524 6525 function getBlockContentSchema(context) { 6526 return getBlockContentSchemaFromTransforms(getRawTransforms(), context); 6527 } 6528 /** 6529 * Checks whether HTML can be considered plain text. That is, it does not contain 6530 * any elements that are not line breaks. 6531 * 6532 * @param {string} HTML The HTML to check. 6533 * 6534 * @return {boolean} Whether the HTML can be considered plain text. 6535 */ 6536 6537 function isPlain(HTML) { 6538 return !/<(?!br[ />])/i.test(HTML); 6539 } 6540 /** 6541 * Given node filters, deeply filters and mutates a NodeList. 6542 * 6543 * @param {NodeList} nodeList The nodeList to filter. 6544 * @param {Array} filters An array of functions that can mutate with the provided node. 6545 * @param {Document} doc The document of the nodeList. 6546 * @param {Object} schema The schema to use. 6547 */ 6548 6549 function deepFilterNodeList(nodeList, filters, doc, schema) { 6550 Array.from(nodeList).forEach(node => { 6551 deepFilterNodeList(node.childNodes, filters, doc, schema); 6552 filters.forEach(item => { 6553 // Make sure the node is still attached to the document. 6554 if (!doc.contains(node)) { 6555 return; 6556 } 6557 6558 item(node, doc, schema); 6559 }); 6560 }); 6561 } 6562 /** 6563 * Given node filters, deeply filters HTML tags. 6564 * Filters from the deepest nodes to the top. 6565 * 6566 * @param {string} HTML The HTML to filter. 6567 * @param {Array} filters An array of functions that can mutate with the provided node. 6568 * @param {Object} schema The schema to use. 6569 * 6570 * @return {string} The filtered HTML. 6571 */ 6572 6573 function deepFilterHTML(HTML, filters = [], schema) { 6574 const doc = document.implementation.createHTMLDocument(''); 6575 doc.body.innerHTML = HTML; 6576 deepFilterNodeList(doc.body.childNodes, filters, doc, schema); 6577 return doc.body.innerHTML; 6578 } 6579 /** 6580 * Gets a sibling within text-level context. 6581 * 6582 * @param {Element} node The subject node. 6583 * @param {string} which "next" or "previous". 6584 */ 6585 6586 function getSibling(node, which) { 6587 const sibling = node[`$which}Sibling`]; 6588 6589 if (sibling && Object(external_wp_dom_["isPhrasingContent"])(sibling)) { 6590 return sibling; 6591 } 6592 6593 const { 6594 parentNode 6595 } = node; 6596 6597 if (!parentNode || !Object(external_wp_dom_["isPhrasingContent"])(parentNode)) { 6598 return; 6599 } 6600 6601 return getSibling(parentNode, which); 6602 } 6603 6604 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/html-formatting-remover.js 6605 /** 6606 * Internal dependencies 6607 */ 6608 6609 6610 function isFormattingSpace(character) { 6611 return character === ' ' || character === '\r' || character === '\n' || character === '\t'; 6612 } 6613 /** 6614 * Removes spacing that formats HTML. 6615 * 6616 * @see https://www.w3.org/TR/css-text-3/#white-space-processing 6617 * 6618 * @param {Node} node The node to be processed. 6619 * @return {void} 6620 */ 6621 6622 6623 function htmlFormattingRemover(node) { 6624 if (node.nodeType !== node.TEXT_NODE) { 6625 return; 6626 } // Ignore pre content. Note that this does not use Element#closest due to 6627 // a combination of (a) node may not be Element and (b) node.parentElement 6628 // does not have full support in all browsers (Internet Exporer). 6629 // 6630 // See: https://developer.mozilla.org/en-US/docs/Web/API/Node/parentElement#Browser_compatibility 6631 6632 /** @type {Node?} */ 6633 6634 6635 let parent = node; 6636 6637 while (parent = parent.parentNode) { 6638 if (parent.nodeType === parent.ELEMENT_NODE && parent.nodeName === 'PRE') { 6639 return; 6640 } 6641 } // First, replace any sequence of HTML formatting space with a single space. 6642 6643 6644 let newData = node.data.replace(/[ \r\n\t]+/g, ' '); // Remove the leading space if the text element is at the start of a block, 6645 // is preceded by a line break element, or has a space in the previous 6646 // node. 6647 6648 if (newData[0] === ' ') { 6649 const previousSibling = getSibling(node, 'previous'); 6650 6651 if (!previousSibling || previousSibling.nodeName === 'BR' || previousSibling.textContent.slice(-1) === ' ') { 6652 newData = newData.slice(1); 6653 } 6654 } // Remove the trailing space if the text element is at the end of a block, 6655 // is succeded by a line break element, or has a space in the next text 6656 // node. 6657 6658 6659 if (newData[newData.length - 1] === ' ') { 6660 const nextSibling = getSibling(node, 'next'); 6661 6662 if (!nextSibling || nextSibling.nodeName === 'BR' || nextSibling.nodeType === nextSibling.TEXT_NODE && isFormattingSpace(nextSibling.textContent[0])) { 6663 newData = newData.slice(0, -1); 6664 } 6665 } // If there's no data left, remove the node, so `previousSibling` stays 6666 // accurate. Otherwise, update the node data. 6667 6668 6669 if (!newData) { 6670 node.parentNode.removeChild(node); 6671 } else { 6672 node.data = newData; 6673 } 6674 } 6675 6676 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/br-remover.js 6677 /** 6678 * Internal dependencies 6679 */ 6680 6681 /** 6682 * Removes trailing br elements from text-level content. 6683 * 6684 * @param {Element} node Node to check. 6685 */ 6686 6687 function brRemover(node) { 6688 if (node.nodeName !== 'BR') { 6689 return; 6690 } 6691 6692 if (getSibling(node, 'next')) { 6693 return; 6694 } 6695 6696 node.parentNode.removeChild(node); 6697 } 6698 6699 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/empty-paragraph-remover.js 6700 /** 6701 * Removes empty paragraph elements. 6702 * 6703 * @param {Element} node Node to check. 6704 */ 6705 function emptyParagraphRemover(node) { 6706 if (node.nodeName !== 'P') { 6707 return; 6708 } 6709 6710 if (node.hasChildNodes()) { 6711 return; 6712 } 6713 6714 node.parentNode.removeChild(node); 6715 } 6716 6717 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/paste-handler.js 6718 /** 6719 * External dependencies 6720 */ 6721 6722 /** 6723 * WordPress dependencies 6724 */ 6725 6726 6727 /** 6728 * Internal dependencies 6729 */ 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 /** 6755 * Browser dependencies 6756 */ 6757 6758 const { 6759 console: paste_handler_console 6760 } = window; 6761 /** 6762 * Filters HTML to only contain phrasing content. 6763 * 6764 * @param {string} HTML The HTML to filter. 6765 * @param {boolean} preserveWhiteSpace Whether or not to preserve consequent white space. 6766 * 6767 * @return {string} HTML only containing phrasing content. 6768 */ 6769 6770 function filterInlineHTML(HTML, preserveWhiteSpace) { 6771 HTML = deepFilterHTML(HTML, [googleDocsUIdRemover, phrasingContentReducer, commentRemover]); 6772 HTML = Object(external_wp_dom_["removeInvalidHTML"])(HTML, Object(external_wp_dom_["getPhrasingContentSchema"])('paste'), { 6773 inline: true 6774 }); 6775 6776 if (!preserveWhiteSpace) { 6777 HTML = deepFilterHTML(HTML, [htmlFormattingRemover, brRemover]); 6778 } // Allows us to ask for this information when we get a report. 6779 6780 6781 paste_handler_console.log('Processed inline HTML:\n\n', HTML); 6782 return HTML; 6783 } 6784 /** 6785 * Converts an HTML string to known blocks. Strips everything else. 6786 * 6787 * @param {Object} options 6788 * @param {string} [options.HTML] The HTML to convert. 6789 * @param {string} [options.plainText] Plain text version. 6790 * @param {string} [options.mode] Handle content as blocks or inline content. 6791 * * 'AUTO': Decide based on the content passed. 6792 * * 'INLINE': Always handle as inline content, and return string. 6793 * * 'BLOCKS': Always handle as blocks, and return array of blocks. 6794 * @param {Array} [options.tagName] The tag into which content will be inserted. 6795 * @param {boolean} [options.preserveWhiteSpace] Whether or not to preserve consequent white space. 6796 * 6797 * @return {Array|string} A list of blocks or a string, depending on `handlerMode`. 6798 */ 6799 6800 6801 function pasteHandler({ 6802 HTML = '', 6803 plainText = '', 6804 mode = 'AUTO', 6805 tagName, 6806 preserveWhiteSpace 6807 }) { 6808 // First of all, strip any meta tags. 6809 HTML = HTML.replace(/<meta[^>]+>/g, ''); // Strip Windows markers. 6810 6811 HTML = HTML.replace(/^\s*<html[^>]*>\s*<body[^>]*>(?:\s*<!--\s*StartFragment\s*-->)?/i, ''); 6812 HTML = HTML.replace(/(?:<!--\s*EndFragment\s*-->\s*)?<\/body>\s*<\/html>\s*$/i, ''); // If we detect block delimiters in HTML, parse entirely as blocks. 6813 6814 if (mode !== 'INLINE') { 6815 // Check plain text if there is no HTML. 6816 const content = HTML ? HTML : plainText; 6817 6818 if (content.indexOf('<!-- wp:') !== -1) { 6819 return parseWithGrammar(content); 6820 } 6821 } // Normalize unicode to use composed characters. 6822 // This is unsupported in IE 11 but it's a nice-to-have feature, not mandatory. 6823 // Not normalizing the content will only affect older browsers and won't 6824 // entirely break the app. 6825 // See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize 6826 // See: https://core.trac.wordpress.org/ticket/30130 6827 // See: https://github.com/WordPress/gutenberg/pull/6983#pullrequestreview-125151075 6828 6829 6830 if (String.prototype.normalize) { 6831 HTML = HTML.normalize(); 6832 } // Parse Markdown (and encoded HTML) if: 6833 // * There is a plain text version. 6834 // * There is no HTML version, or it has no formatting. 6835 6836 6837 if (plainText && (!HTML || isPlain(HTML))) { 6838 HTML = plainText; // The markdown converter (Showdown) trims whitespace. 6839 6840 if (!/^\s+$/.test(plainText)) { 6841 HTML = markdownConverter(HTML); 6842 } // Switch to inline mode if: 6843 // * The current mode is AUTO. 6844 // * The original plain text had no line breaks. 6845 // * The original plain text was not an HTML paragraph. 6846 // * The converted text is just a paragraph. 6847 6848 6849 if (mode === 'AUTO' && plainText.indexOf('\n') === -1 && plainText.indexOf('<p>') !== 0 && HTML.indexOf('<p>') === 0) { 6850 mode = 'INLINE'; 6851 } 6852 } 6853 6854 if (mode === 'INLINE') { 6855 return filterInlineHTML(HTML, preserveWhiteSpace); 6856 } // An array of HTML strings and block objects. The blocks replace matched 6857 // shortcodes. 6858 6859 6860 const pieces = shortcode_converter(HTML); // The call to shortcodeConverter will always return more than one element 6861 // if shortcodes are matched. The reason is when shortcodes are matched 6862 // empty HTML strings are included. 6863 6864 const hasShortcodes = pieces.length > 1; 6865 6866 if (mode === 'AUTO' && !hasShortcodes && isInlineContent(HTML, tagName)) { 6867 return filterInlineHTML(HTML, preserveWhiteSpace); 6868 } 6869 6870 const phrasingContentSchema = Object(external_wp_dom_["getPhrasingContentSchema"])('paste'); 6871 const blockContentSchema = getBlockContentSchema('paste'); 6872 const blocks = Object(external_lodash_["compact"])(Object(external_lodash_["flatMap"])(pieces, piece => { 6873 // Already a block from shortcode. 6874 if (typeof piece !== 'string') { 6875 return piece; 6876 } 6877 6878 const filters = [googleDocsUIdRemover, msListConverter, headRemover, listReducer, imageCorrector, phrasingContentReducer, specialCommentConverter, commentRemover, iframeRemover, figureContentReducer, blockquoteNormaliser]; 6879 const schema = { ...blockContentSchema, 6880 // Keep top-level phrasing content, normalised by `normaliseBlocks`. 6881 ...phrasingContentSchema 6882 }; 6883 piece = deepFilterHTML(piece, filters, blockContentSchema); 6884 piece = Object(external_wp_dom_["removeInvalidHTML"])(piece, schema); 6885 piece = normaliseBlocks(piece); 6886 piece = deepFilterHTML(piece, [htmlFormattingRemover, brRemover, emptyParagraphRemover], blockContentSchema); // Allows us to ask for this information when we get a report. 6887 6888 paste_handler_console.log('Processed HTML piece:\n\n', piece); 6889 return htmlToBlocks(piece); 6890 })); // If we're allowed to return inline content, and there is only one 6891 // inlineable block, and the original plain text content does not have any 6892 // line breaks, then treat it as inline paste. 6893 6894 if (mode === 'AUTO' && blocks.length === 1 && registration_hasBlockSupport(blocks[0].name, '__unstablePasteTextInline', false)) { 6895 // Don't catch line breaks at the start or end. 6896 const trimmedPlainText = plainText.replace(/^[\n]+|[\n]+$/g, ''); 6897 6898 if (trimmedPlainText !== '' && trimmedPlainText.indexOf('\n') === -1) { 6899 return Object(external_wp_dom_["removeInvalidHTML"])(getBlockInnerHTML(blocks[0]), phrasingContentSchema); 6900 } 6901 } 6902 6903 return blocks; 6904 } 6905 6906 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/raw-handling/index.js 6907 /** 6908 * External dependencies 6909 */ 6910 6911 /** 6912 * WordPress dependencies 6913 */ 6914 6915 6916 6917 /** 6918 * Internal dependencies 6919 */ 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 function deprecatedGetPhrasingContentSchema(context) { 6932 external_wp_deprecated_default()('wp.blocks.getPhrasingContentSchema', { 6933 since: '5.6', 6934 alternative: 'wp.dom.getPhrasingContentSchema' 6935 }); 6936 return Object(external_wp_dom_["getPhrasingContentSchema"])(context); 6937 } 6938 /** 6939 * Converts an HTML string to known blocks. 6940 * 6941 * @param {Object} $1 6942 * @param {string} $1.HTML The HTML to convert. 6943 * 6944 * @return {Array} A list of blocks. 6945 */ 6946 6947 function rawHandler({ 6948 HTML = '' 6949 }) { 6950 // If we detect block delimiters, parse entirely as blocks. 6951 if (HTML.indexOf('<!-- wp:') !== -1) { 6952 return parseWithGrammar(HTML); 6953 } // An array of HTML strings and block objects. The blocks replace matched 6954 // shortcodes. 6955 6956 6957 const pieces = shortcode_converter(HTML); 6958 const blockContentSchema = getBlockContentSchema(); 6959 return Object(external_lodash_["compact"])(Object(external_lodash_["flatMap"])(pieces, piece => { 6960 // Already a block from shortcode. 6961 if (typeof piece !== 'string') { 6962 return piece; 6963 } // These filters are essential for some blocks to be able to transform 6964 // from raw HTML. These filters move around some content or add 6965 // additional tags, they do not remove any content. 6966 6967 6968 const filters = [// Needed to adjust invalid lists. 6969 listReducer, // Needed to create more and nextpage blocks. 6970 specialCommentConverter, // Needed to create media blocks. 6971 figureContentReducer, // Needed to create the quote block, which cannot handle text 6972 // without wrapper paragraphs. 6973 blockquoteNormaliser]; 6974 piece = deepFilterHTML(piece, filters, blockContentSchema); 6975 piece = normaliseBlocks(piece); 6976 return htmlToBlocks(piece); 6977 })); 6978 } 6979 6980 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/categories.js 6981 /** 6982 * WordPress dependencies 6983 */ 6984 6985 /** 6986 * Internal dependencies 6987 */ 6988 6989 6990 /** @typedef {import('../store/reducer').WPBlockCategory} WPBlockCategory */ 6991 6992 /** 6993 * Returns all the block categories. 6994 * 6995 * @return {WPBlockCategory[]} Block categories. 6996 */ 6997 6998 function categories_getCategories() { 6999 return Object(external_wp_data_["select"])(store).getCategories(); 7000 } 7001 /** 7002 * Sets the block categories. 7003 * 7004 * @param {WPBlockCategory[]} categories Block categories. 7005 */ 7006 7007 function categories_setCategories(categories) { 7008 Object(external_wp_data_["dispatch"])(store).setCategories(categories); 7009 } 7010 /** 7011 * Updates a category. 7012 * 7013 * @param {string} slug Block category slug. 7014 * @param {WPBlockCategory} category Object containing the category properties 7015 * that should be updated. 7016 */ 7017 7018 function categories_updateCategory(slug, category) { 7019 Object(external_wp_data_["dispatch"])(store).updateCategory(slug, category); 7020 } 7021 7022 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/templates.js 7023 /** 7024 * External dependencies 7025 */ 7026 7027 /** 7028 * WordPress dependencies 7029 */ 7030 7031 7032 /** 7033 * Internal dependencies 7034 */ 7035 7036 7037 7038 7039 /** 7040 * Checks whether a list of blocks matches a template by comparing the block names. 7041 * 7042 * @param {Array} blocks Block list. 7043 * @param {Array} template Block template. 7044 * 7045 * @return {boolean} Whether the list of blocks matches a templates 7046 */ 7047 7048 function doBlocksMatchTemplate(blocks = [], template = []) { 7049 return blocks.length === template.length && Object(external_lodash_["every"])(template, ([name,, innerBlocksTemplate], index) => { 7050 const block = blocks[index]; 7051 return name === block.name && doBlocksMatchTemplate(block.innerBlocks, innerBlocksTemplate); 7052 }); 7053 } 7054 /** 7055 * Synchronize a block list with a block template. 7056 * 7057 * Synchronizing a block list with a block template means that we loop over the blocks 7058 * keep the block as is if it matches the block at the same position in the template 7059 * (If it has the same name) and if doesn't match, we create a new block based on the template. 7060 * Extra blocks not present in the template are removed. 7061 * 7062 * @param {Array} blocks Block list. 7063 * @param {Array} template Block template. 7064 * 7065 * @return {Array} Updated Block list. 7066 */ 7067 7068 function synchronizeBlocksWithTemplate(blocks = [], template) { 7069 // If no template is provided, return blocks unmodified. 7070 if (!template) { 7071 return blocks; 7072 } 7073 7074 return Object(external_lodash_["map"])(template, ([name, attributes, innerBlocksTemplate], index) => { 7075 const block = blocks[index]; 7076 7077 if (block && block.name === name) { 7078 const innerBlocks = synchronizeBlocksWithTemplate(block.innerBlocks, innerBlocksTemplate); 7079 return { ...block, 7080 innerBlocks 7081 }; 7082 } // To support old templates that were using the "children" format 7083 // for the attributes using "html" strings now, we normalize the template attributes 7084 // before creating the blocks. 7085 7086 7087 const blockType = registration_getBlockType(name); 7088 7089 const isHTMLAttribute = attributeDefinition => Object(external_lodash_["get"])(attributeDefinition, ['source']) === 'html'; 7090 7091 const isQueryAttribute = attributeDefinition => Object(external_lodash_["get"])(attributeDefinition, ['source']) === 'query'; 7092 7093 const normalizeAttributes = (schema, values) => { 7094 return Object(external_lodash_["mapValues"])(values, (value, key) => { 7095 return normalizeAttribute(schema[key], value); 7096 }); 7097 }; 7098 7099 const normalizeAttribute = (definition, value) => { 7100 if (isHTMLAttribute(definition) && Object(external_lodash_["isArray"])(value)) { 7101 // Introduce a deprecated call at this point 7102 // When we're confident that "children" format should be removed from the templates. 7103 return Object(external_wp_element_["renderToString"])(value); 7104 } 7105 7106 if (isQueryAttribute(definition) && value) { 7107 return value.map(subValues => { 7108 return normalizeAttributes(definition.query, subValues); 7109 }); 7110 } 7111 7112 return value; 7113 }; 7114 7115 const normalizedAttributes = normalizeAttributes(Object(external_lodash_["get"])(blockType, ['attributes'], {}), attributes); 7116 const { 7117 name: blockName, 7118 attributes: blockAttributes 7119 } = convertLegacyBlocks(name, normalizedAttributes); 7120 return createBlock(blockName, blockAttributes, synchronizeBlocksWithTemplate([], innerBlocksTemplate)); 7121 }); 7122 } 7123 7124 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/index.js 7125 // The blocktype is the most important concept within the block API. It defines 7126 // all aspects of the block configuration and its interfaces, including `edit` 7127 // and `save`. The transforms specification allows converting one blocktype to 7128 // another through formulas defined by either the source or the destination. 7129 // Switching a blocktype is to be considered a one-way operation implying a 7130 // transformation in the opposite way has to be handled explicitly. 7131 // The block tree is composed of a collection of block nodes. Blocks contained 7132 // within other blocks are called inner blocks. An important design 7133 // consideration is that inner blocks are -- conceptually -- not part of the 7134 // territory established by the parent block that contains them. 7135 // 7136 // This has multiple practical implications: when parsing, we can safely dispose 7137 // of any block boundary found within a block from the innerHTML property when 7138 // transfering to state. Not doing so would have a compounding effect on memory 7139 // and uncertainty over the source of truth. This can be illustrated in how, 7140 // given a tree of `n` nested blocks, the entry node would have to contain the 7141 // actual content of each block while each subsequent block node in the state 7142 // tree would replicate the entire chain `n-1`, meaning the extreme end node 7143 // would have been replicated `n` times as the tree is traversed and would 7144 // generate uncertainty as to which one is to hold the current value of the 7145 // block. For composition, it also means inner blocks can effectively be child 7146 // components whose mechanisms can be shielded from the `edit` implementation 7147 // and just passed along. 7148 7149 // While block transformations account for a specific surface of the API, there 7150 // are also raw transformations which handle arbitrary sources not made out of 7151 // blocks but producing block basaed on various heursitics. This includes 7152 // pasting rich text or HTML data. 7153 7154 // The process of serialization aims to deflate the internal memory of the block 7155 // editor and its state representation back into an HTML valid string. This 7156 // process restores the document integrity and inserts invisible delimiters 7157 // around each block with HTML comment boundaries which can contain any extra 7158 // attributes needed to operate with the block later on. 7159 7160 // Validation is the process of comparing a block source with its output before 7161 // there is any user input or interaction with a block. When this operation 7162 // fails -- for whatever reason -- the block is to be considered invalid. As 7163 // part of validating a block the system will attempt to run the source against 7164 // any provided deprecation definitions. 7165 // 7166 // Worth emphasizing that validation is not a case of whether the markup is 7167 // merely HTML spec-compliant but about how the editor knows to create such 7168 // markup and that its inability to create an identical result can be a strong 7169 // indicator of potential data loss (the invalidation is then a protective 7170 // measure). 7171 // 7172 // The invalidation process can also be deconstructed in phases: 1) validate the 7173 // block exists; 2) validate the source matches the output; 3) validate the 7174 // source matches deprecated outputs; 4) work through the significance of 7175 // differences. These are stacked in a way that favors performance and optimizes 7176 // for the majority of cases. That is to say, the evaluation logic can become 7177 // more sophisticated the further down it goes in the process as the cost is 7178 // accounted for. The first logic checks have to be extremely efficient since 7179 // they will be run for all valid and invalid blocks alike. However, once a 7180 // block is detected as invalid -- failing the three first steps -- it is 7181 // adequate to spend more time determining validity before throwing a conflict. 7182 7183 7184 // Blocks are inherently indifferent about where the data they operate with ends 7185 // up being saved. For example, all blocks can have a static and dynamic aspect 7186 // to them depending on the needs. The static nature of a block is the `save()` 7187 // definition that is meant to be serialized into HTML and which can be left 7188 // void. Any block can also register a `render_callback` on the server, which 7189 // makes its output dynamic either in part or in its totality. 7190 // 7191 // Child blocks are defined as a relationship that builds on top of the inner 7192 // blocks mechanism. A child block is a block node of a particular type that can 7193 // only exist within the inner block boundaries of a specific parent type. This 7194 // allows block authors to compose specific blocks that are not meant to be used 7195 // outside of a specified parent block context. Thus, child blocks extend the 7196 // concept of inner blocks to support a more direct relationship between sets of 7197 // blocks. The addition of parent–child would be a subset of the inner block 7198 // functionality under the premise that certain blocks only make sense as 7199 // children of another block. 7200 7201 7202 // Templates are, in a general sense, a basic collection of block nodes with any 7203 // given set of predefined attributes that are supplied as the initial state of 7204 // an inner blocks group. These nodes can, in turn, contain any number of nested 7205 // blocks within their definition. Templates allow both to specify a default 7206 // state for an editor session or a default set of blocks for any inner block 7207 // implementation within a specific block. 7208 7209 7210 7211 7212 7213 7214 // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/index.js 7215 // A "block" is the abstract term used to describe units of markup that, 7216 // when composed together, form the content or layout of a page. 7217 // The API for blocks is exposed via `wp.blocks`. 7218 // 7219 // Supported blocks are registered by calling `registerBlockType`. Once registered, 7220 // the block is made available as an option to the editor interface. 7221 // 7222 // Blocks are inferred from the HTML source of a post through a parsing mechanism 7223 // and then stored as objects in state, from which it is then rendered for editing. 7224 7225 7226 7227 7228 7229 /***/ }), 7230 7231 /***/ "1CF3": 7232 /***/ (function(module, exports) { 7233 7234 (function() { module.exports = window["wp"]["dom"]; }()); 7235 7236 /***/ }), 7237 7238 /***/ "1ZqX": 7239 /***/ (function(module, exports) { 7240 7241 (function() { module.exports = window["wp"]["data"]; }()); 7242 7243 /***/ }), 7244 7245 /***/ "7Cbv": 7246 /***/ (function(module, __webpack_exports__, __webpack_require__) { 7247 7248 "use strict"; 7249 7250 // CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/rng.js 7251 // Unique ID creation requires a high quality random # generator. In the browser we therefore 7252 // require the crypto API and do not support built-in fallback to lower quality random number 7253 // generators (like Math.random()). 7254 var getRandomValues; 7255 var rnds8 = new Uint8Array(16); 7256 function rng() { 7257 // lazy load so that environments that need to polyfill have a chance to do so 7258 if (!getRandomValues) { 7259 // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also, 7260 // find the complete implementation of crypto (msCrypto) on IE11. 7261 getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto); 7262 7263 if (!getRandomValues) { 7264 throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported'); 7265 } 7266 } 7267 7268 return getRandomValues(rnds8); 7269 } 7270 // CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/regex.js 7271 /* harmony default export */ var regex = (/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i); 7272 // CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/validate.js 7273 7274 7275 function validate(uuid) { 7276 return typeof uuid === 'string' && regex.test(uuid); 7277 } 7278 7279 /* harmony default export */ var esm_browser_validate = (validate); 7280 // CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/stringify.js 7281 7282 /** 7283 * Convert array of 16 byte values to UUID string format of the form: 7284 * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX 7285 */ 7286 7287 var byteToHex = []; 7288 7289 for (var stringify_i = 0; stringify_i < 256; ++stringify_i) { 7290 byteToHex.push((stringify_i + 0x100).toString(16).substr(1)); 7291 } 7292 7293 function stringify(arr) { 7294 var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 7295 // Note: Be careful editing this code! It's been tuned for performance 7296 // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 7297 var uuid = (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(); // Consistency check for valid UUID. If this throws, it's likely due to one 7298 // of the following: 7299 // - One or more input array values don't map to a hex octet (leading to 7300 // "undefined" in the uuid) 7301 // - Invalid input values for the RFC `version` or `variant` fields 7302 7303 if (!esm_browser_validate(uuid)) { 7304 throw TypeError('Stringified UUID is invalid'); 7305 } 7306 7307 return uuid; 7308 } 7309 7310 /* harmony default export */ var esm_browser_stringify = (stringify); 7311 // CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/v4.js 7312 7313 7314 7315 function v4(options, buf, offset) { 7316 options = options || {}; 7317 var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` 7318 7319 rnds[6] = rnds[6] & 0x0f | 0x40; 7320 rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided 7321 7322 if (buf) { 7323 offset = offset || 0; 7324 7325 for (var i = 0; i < 16; ++i) { 7326 buf[offset + i] = rnds[i]; 7327 } 7328 7329 return buf; 7330 } 7331 7332 return esm_browser_stringify(rnds); 7333 } 7334 7335 /* harmony default export */ var esm_browser_v4 = __webpack_exports__["a"] = (v4); 7336 7337 /***/ }), 7338 7339 /***/ "GRId": 7340 /***/ (function(module, exports) { 7341 7342 (function() { module.exports = window["wp"]["element"]; }()); 7343 7344 /***/ }), 7345 7346 /***/ "K9lf": 7347 /***/ (function(module, exports) { 7348 7349 (function() { module.exports = window["wp"]["compose"]; }()); 7350 7351 /***/ }), 7352 7353 /***/ "M55E": 7354 /***/ (function(module, exports, __webpack_require__) { 7355 7356 var __WEBPACK_AMD_DEFINE_RESULT__;;/*! showdown v 1.9.1 - 02-11-2019 */ 7357 (function(){ 7358 /** 7359 * Created by Tivie on 13-07-2015. 7360 */ 7361 7362 function getDefaultOpts (simple) { 7363 'use strict'; 7364 7365 var defaultOptions = { 7366 omitExtraWLInCodeBlocks: { 7367 defaultValue: false, 7368 describe: 'Omit the default extra whiteline added to code blocks', 7369 type: 'boolean' 7370 }, 7371 noHeaderId: { 7372 defaultValue: false, 7373 describe: 'Turn on/off generated header id', 7374 type: 'boolean' 7375 }, 7376 prefixHeaderId: { 7377 defaultValue: false, 7378 describe: 'Add a prefix to the generated header ids. Passing a string will prefix that string to the header id. Setting to true will add a generic \'section-\' prefix', 7379 type: 'string' 7380 }, 7381 rawPrefixHeaderId: { 7382 defaultValue: false, 7383 describe: 'Setting this option to true will prevent showdown from modifying the prefix. This might result in malformed IDs (if, for instance, the " char is used in the prefix)', 7384 type: 'boolean' 7385 }, 7386 ghCompatibleHeaderId: { 7387 defaultValue: false, 7388 describe: 'Generate header ids compatible with github style (spaces are replaced with dashes, a bunch of non alphanumeric chars are removed)', 7389 type: 'boolean' 7390 }, 7391 rawHeaderId: { 7392 defaultValue: false, 7393 describe: 'Remove only spaces, \' and " from generated header ids (including prefixes), replacing them with dashes (-). WARNING: This might result in malformed ids', 7394 type: 'boolean' 7395 }, 7396 headerLevelStart: { 7397 defaultValue: false, 7398 describe: 'The header blocks level start', 7399 type: 'integer' 7400 }, 7401 parseImgDimensions: { 7402 defaultValue: false, 7403 describe: 'Turn on/off image dimension parsing', 7404 type: 'boolean' 7405 }, 7406 simplifiedAutoLink: { 7407 defaultValue: false, 7408 describe: 'Turn on/off GFM autolink style', 7409 type: 'boolean' 7410 }, 7411 excludeTrailingPunctuationFromURLs: { 7412 defaultValue: false, 7413 describe: 'Excludes trailing punctuation from links generated with autoLinking', 7414 type: 'boolean' 7415 }, 7416 literalMidWordUnderscores: { 7417 defaultValue: false, 7418 describe: 'Parse midword underscores as literal underscores', 7419 type: 'boolean' 7420 }, 7421 literalMidWordAsterisks: { 7422 defaultValue: false, 7423 describe: 'Parse midword asterisks as literal asterisks', 7424 type: 'boolean' 7425 }, 7426 strikethrough: { 7427 defaultValue: false, 7428 describe: 'Turn on/off strikethrough support', 7429 type: 'boolean' 7430 }, 7431 tables: { 7432 defaultValue: false, 7433 describe: 'Turn on/off tables support', 7434 type: 'boolean' 7435 }, 7436 tablesHeaderId: { 7437 defaultValue: false, 7438 describe: 'Add an id to table headers', 7439 type: 'boolean' 7440 }, 7441 ghCodeBlocks: { 7442 defaultValue: true, 7443 describe: 'Turn on/off GFM fenced code blocks support', 7444 type: 'boolean' 7445 }, 7446 tasklists: { 7447 defaultValue: false, 7448 describe: 'Turn on/off GFM tasklist support', 7449 type: 'boolean' 7450 }, 7451 smoothLivePreview: { 7452 defaultValue: false, 7453 describe: 'Prevents weird effects in live previews due to incomplete input', 7454 type: 'boolean' 7455 }, 7456 smartIndentationFix: { 7457 defaultValue: false, 7458 description: 'Tries to smartly fix indentation in es6 strings', 7459 type: 'boolean' 7460 }, 7461 disableForced4SpacesIndentedSublists: { 7462 defaultValue: false, 7463 description: 'Disables the requirement of indenting nested sublists by 4 spaces', 7464 type: 'boolean' 7465 }, 7466 simpleLineBreaks: { 7467 defaultValue: false, 7468 description: 'Parses simple line breaks as <br> (GFM Style)', 7469 type: 'boolean' 7470 }, 7471 requireSpaceBeforeHeadingText: { 7472 defaultValue: false, 7473 description: 'Makes adding a space between `#` and the header text mandatory (GFM Style)', 7474 type: 'boolean' 7475 }, 7476 ghMentions: { 7477 defaultValue: false, 7478 description: 'Enables github @mentions', 7479 type: 'boolean' 7480 }, 7481 ghMentionsLink: { 7482 defaultValue: 'https://github.com/{u}', 7483 description: 'Changes the link generated by @mentions. Only applies if ghMentions option is enabled.', 7484 type: 'string' 7485 }, 7486 encodeEmails: { 7487 defaultValue: true, 7488 description: 'Encode e-mail addresses through the use of Character Entities, transforming ASCII e-mail addresses into its equivalent decimal entities', 7489 type: 'boolean' 7490 }, 7491 openLinksInNewWindow: { 7492 defaultValue: false, 7493 description: 'Open all links in new windows', 7494 type: 'boolean' 7495 }, 7496 backslashEscapesHTMLTags: { 7497 defaultValue: false, 7498 description: 'Support for HTML Tag escaping. ex: \<div>foo\</div>', 7499 type: 'boolean' 7500 }, 7501 emoji: { 7502 defaultValue: false, 7503 description: 'Enable emoji support. Ex: `this is a :smile: emoji`', 7504 type: 'boolean' 7505 }, 7506 underline: { 7507 defaultValue: false, 7508 description: 'Enable support for underline. Syntax is double or triple underscores: `__underline word__`. With this option enabled, underscores no longer parses into `<em>` and `<strong>`', 7509 type: 'boolean' 7510 }, 7511 completeHTMLDocument: { 7512 defaultValue: false, 7513 description: 'Outputs a complete html document, including `<html>`, `<head>` and `<body>` tags', 7514 type: 'boolean' 7515 }, 7516 metadata: { 7517 defaultValue: false, 7518 description: 'Enable support for document metadata (defined at the top of the document between `«««` and `»»»` or between `---` and `---`).', 7519 type: 'boolean' 7520 }, 7521 splitAdjacentBlockquotes: { 7522 defaultValue: false, 7523 description: 'Split adjacent blockquote blocks', 7524 type: 'boolean' 7525 } 7526 }; 7527 if (simple === false) { 7528 return JSON.parse(JSON.stringify(defaultOptions)); 7529 } 7530 var ret = {}; 7531 for (var opt in defaultOptions) { 7532 if (defaultOptions.hasOwnProperty(opt)) { 7533 ret[opt] = defaultOptions[opt].defaultValue; 7534 } 7535 } 7536 return ret; 7537 } 7538 7539 function allOptionsOn () { 7540 'use strict'; 7541 var options = getDefaultOpts(true), 7542 ret = {}; 7543 for (var opt in options) { 7544 if (options.hasOwnProperty(opt)) { 7545 ret[opt] = true; 7546 } 7547 } 7548 return ret; 7549 } 7550 7551 /** 7552 * Created by Tivie on 06-01-2015. 7553 */ 7554 7555 // Private properties 7556 var showdown = {}, 7557 parsers = {}, 7558 extensions = {}, 7559 globalOptions = getDefaultOpts(true), 7560 setFlavor = 'vanilla', 7561 flavor = { 7562 github: { 7563 omitExtraWLInCodeBlocks: true, 7564 simplifiedAutoLink: true, 7565 excludeTrailingPunctuationFromURLs: true, 7566 literalMidWordUnderscores: true, 7567 strikethrough: true, 7568 tables: true, 7569 tablesHeaderId: true, 7570 ghCodeBlocks: true, 7571 tasklists: true, 7572 disableForced4SpacesIndentedSublists: true, 7573 simpleLineBreaks: true, 7574 requireSpaceBeforeHeadingText: true, 7575 ghCompatibleHeaderId: true, 7576 ghMentions: true, 7577 backslashEscapesHTMLTags: true, 7578 emoji: true, 7579 splitAdjacentBlockquotes: true 7580 }, 7581 original: { 7582 noHeaderId: true, 7583 ghCodeBlocks: false 7584 }, 7585 ghost: { 7586 omitExtraWLInCodeBlocks: true, 7587 parseImgDimensions: true, 7588 simplifiedAutoLink: true, 7589 excludeTrailingPunctuationFromURLs: true, 7590 literalMidWordUnderscores: true, 7591 strikethrough: true, 7592 tables: true, 7593 tablesHeaderId: true, 7594 ghCodeBlocks: true, 7595 tasklists: true, 7596 smoothLivePreview: true, 7597 simpleLineBreaks: true, 7598 requireSpaceBeforeHeadingText: true, 7599 ghMentions: false, 7600 encodeEmails: true 7601 }, 7602 vanilla: getDefaultOpts(true), 7603 allOn: allOptionsOn() 7604 }; 7605 7606 /** 7607 * helper namespace 7608 * @type {{}} 7609 */ 7610 showdown.helper = {}; 7611 7612 /** 7613 * TODO LEGACY SUPPORT CODE 7614 * @type {{}} 7615 */ 7616 showdown.extensions = {}; 7617 7618 /** 7619 * Set a global option 7620 * @static 7621 * @param {string} key 7622 * @param {*} value 7623 * @returns {showdown} 7624 */ 7625 showdown.setOption = function (key, value) { 7626 'use strict'; 7627 globalOptions[key] = value; 7628 return this; 7629 }; 7630 7631 /** 7632 * Get a global option 7633 * @static 7634 * @param {string} key 7635 * @returns {*} 7636 */ 7637 showdown.getOption = function (key) { 7638 'use strict'; 7639 return globalOptions[key]; 7640 }; 7641 7642 /** 7643 * Get the global options 7644 * @static 7645 * @returns {{}} 7646 */ 7647 showdown.getOptions = function () { 7648 'use strict'; 7649 return globalOptions; 7650 }; 7651 7652 /** 7653 * Reset global options to the default values 7654 * @static 7655 */ 7656 showdown.resetOptions = function () { 7657 'use strict'; 7658 globalOptions = getDefaultOpts(true); 7659 }; 7660 7661 /** 7662 * Set the flavor showdown should use as default 7663 * @param {string} name 7664 */ 7665 showdown.setFlavor = function (name) { 7666 'use strict'; 7667 if (!flavor.hasOwnProperty(name)) { 7668 throw Error(name + ' flavor was not found'); 7669 } 7670 showdown.resetOptions(); 7671 var preset = flavor[name]; 7672 setFlavor = name; 7673 for (var option in preset) { 7674 if (preset.hasOwnProperty(option)) { 7675 globalOptions[option] = preset[option]; 7676 } 7677 } 7678 }; 7679 7680 /** 7681 * Get the currently set flavor 7682 * @returns {string} 7683 */ 7684 showdown.getFlavor = function () { 7685 'use strict'; 7686 return setFlavor; 7687 }; 7688 7689 /** 7690 * Get the options of a specified flavor. Returns undefined if the flavor was not found 7691 * @param {string} name Name of the flavor 7692 * @returns {{}|undefined} 7693 */ 7694 showdown.getFlavorOptions = function (name) { 7695 'use strict'; 7696 if (flavor.hasOwnProperty(name)) { 7697 return flavor[name]; 7698 } 7699 }; 7700 7701 /** 7702 * Get the default options 7703 * @static 7704 * @param {boolean} [simple=true] 7705 * @returns {{}} 7706 */ 7707 showdown.getDefaultOptions = function (simple) { 7708 'use strict'; 7709 return getDefaultOpts(simple); 7710 }; 7711 7712 /** 7713 * Get or set a subParser 7714 * 7715 * subParser(name) - Get a registered subParser 7716 * subParser(name, func) - Register a subParser 7717 * @static 7718 * @param {string} name 7719 * @param {function} [func] 7720 * @returns {*} 7721 */ 7722 showdown.subParser = function (name, func) { 7723 'use strict'; 7724 if (showdown.helper.isString(name)) { 7725 if (typeof func !== 'undefined') { 7726 parsers[name] = func; 7727 } else { 7728 if (parsers.hasOwnProperty(name)) { 7729 return parsers[name]; 7730 } else { 7731 throw Error('SubParser named ' + name + ' not registered!'); 7732 } 7733 } 7734 } 7735 }; 7736 7737 /** 7738 * Gets or registers an extension 7739 * @static 7740 * @param {string} name 7741 * @param {object|function=} ext 7742 * @returns {*} 7743 */ 7744 showdown.extension = function (name, ext) { 7745 'use strict'; 7746 7747 if (!showdown.helper.isString(name)) { 7748 throw Error('Extension \'name\' must be a string'); 7749 } 7750 7751 name = showdown.helper.stdExtName(name); 7752 7753 // Getter 7754 if (showdown.helper.isUndefined(ext)) { 7755 if (!extensions.hasOwnProperty(name)) { 7756 throw Error('Extension named ' + name + ' is not registered!'); 7757 } 7758 return extensions[name]; 7759 7760 // Setter 7761 } else { 7762 // Expand extension if it's wrapped in a function 7763 if (typeof ext === 'function') { 7764 ext = ext(); 7765 } 7766 7767 // Ensure extension is an array 7768 if (!showdown.helper.isArray(ext)) { 7769 ext = [ext]; 7770 } 7771 7772 var validExtension = validate(ext, name); 7773 7774 if (validExtension.valid) { 7775 extensions[name] = ext; 7776 } else { 7777 throw Error(validExtension.error); 7778 } 7779 } 7780 }; 7781 7782 /** 7783 * Gets all extensions registered 7784 * @returns {{}} 7785 */ 7786 showdown.getAllExtensions = function () { 7787 'use strict'; 7788 return extensions; 7789 }; 7790 7791 /** 7792 * Remove an extension 7793 * @param {string} name 7794 */ 7795 showdown.removeExtension = function (name) { 7796 'use strict'; 7797 delete extensions[name]; 7798 }; 7799 7800 /** 7801 * Removes all extensions 7802 */ 7803 showdown.resetExtensions = function () { 7804 'use strict'; 7805 extensions = {}; 7806 }; 7807 7808 /** 7809 * Validate extension 7810 * @param {array} extension 7811 * @param {string} name 7812 * @returns {{valid: boolean, error: string}} 7813 */ 7814 function validate (extension, name) { 7815 'use strict'; 7816 7817 var errMsg = (name) ? 'Error in ' + name + ' extension->' : 'Error in unnamed extension', 7818 ret = { 7819 valid: true, 7820 error: '' 7821 }; 7822 7823 if (!showdown.helper.isArray(extension)) { 7824 extension = [extension]; 7825 } 7826 7827