[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/dist/ -> rich-text.js (source)

   1  this["wp"] = this["wp"] || {}; this["wp"]["richText"] =
   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 = "yyEc");
  86  /******/ })
  87  /************************************************************************/
  88  /******/ ({
  89  
  90  /***/ "1ZqX":
  91  /***/ (function(module, exports) {
  92  
  93  (function() { module.exports = window["wp"]["data"]; }());
  94  
  95  /***/ }),
  96  
  97  /***/ "GRId":
  98  /***/ (function(module, exports) {
  99  
 100  (function() { module.exports = window["wp"]["element"]; }());
 101  
 102  /***/ }),
 103  
 104  /***/ "K9lf":
 105  /***/ (function(module, exports) {
 106  
 107  (function() { module.exports = window["wp"]["compose"]; }());
 108  
 109  /***/ }),
 110  
 111  /***/ "RxS6":
 112  /***/ (function(module, exports) {
 113  
 114  (function() { module.exports = window["wp"]["keycodes"]; }());
 115  
 116  /***/ }),
 117  
 118  /***/ "Vx3V":
 119  /***/ (function(module, exports) {
 120  
 121  (function() { module.exports = window["wp"]["escapeHtml"]; }());
 122  
 123  /***/ }),
 124  
 125  /***/ "YLtl":
 126  /***/ (function(module, exports) {
 127  
 128  (function() { module.exports = window["lodash"]; }());
 129  
 130  /***/ }),
 131  
 132  /***/ "pPDe":
 133  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 134  
 135  "use strict";
 136  
 137  
 138  var LEAF_KEY, hasWeakMap;
 139  
 140  /**
 141   * Arbitrary value used as key for referencing cache object in WeakMap tree.
 142   *
 143   * @type {Object}
 144   */
 145  LEAF_KEY = {};
 146  
 147  /**
 148   * Whether environment supports WeakMap.
 149   *
 150   * @type {boolean}
 151   */
 152  hasWeakMap = typeof WeakMap !== 'undefined';
 153  
 154  /**
 155   * Returns the first argument as the sole entry in an array.
 156   *
 157   * @param {*} value Value to return.
 158   *
 159   * @return {Array} Value returned as entry in array.
 160   */
 161  function arrayOf( value ) {
 162      return [ value ];
 163  }
 164  
 165  /**
 166   * Returns true if the value passed is object-like, or false otherwise. A value
 167   * is object-like if it can support property assignment, e.g. object or array.
 168   *
 169   * @param {*} value Value to test.
 170   *
 171   * @return {boolean} Whether value is object-like.
 172   */
 173  function isObjectLike( value ) {
 174      return !! value && 'object' === typeof value;
 175  }
 176  
 177  /**
 178   * Creates and returns a new cache object.
 179   *
 180   * @return {Object} Cache object.
 181   */
 182  function createCache() {
 183      var cache = {
 184          clear: function() {
 185              cache.head = null;
 186          },
 187      };
 188  
 189      return cache;
 190  }
 191  
 192  /**
 193   * Returns true if entries within the two arrays are strictly equal by
 194   * reference from a starting index.
 195   *
 196   * @param {Array}  a         First array.
 197   * @param {Array}  b         Second array.
 198   * @param {number} fromIndex Index from which to start comparison.
 199   *
 200   * @return {boolean} Whether arrays are shallowly equal.
 201   */
 202  function isShallowEqual( a, b, fromIndex ) {
 203      var i;
 204  
 205      if ( a.length !== b.length ) {
 206          return false;
 207      }
 208  
 209      for ( i = fromIndex; i < a.length; i++ ) {
 210          if ( a[ i ] !== b[ i ] ) {
 211              return false;
 212          }
 213      }
 214  
 215      return true;
 216  }
 217  
 218  /**
 219   * Returns a memoized selector function. The getDependants function argument is
 220   * called before the memoized selector and is expected to return an immutable
 221   * reference or array of references on which the selector depends for computing
 222   * its own return value. The memoize cache is preserved only as long as those
 223   * dependant references remain the same. If getDependants returns a different
 224   * reference(s), the cache is cleared and the selector value regenerated.
 225   *
 226   * @param {Function} selector      Selector function.
 227   * @param {Function} getDependants Dependant getter returning an immutable
 228   *                                 reference or array of reference used in
 229   *                                 cache bust consideration.
 230   *
 231   * @return {Function} Memoized selector.
 232   */
 233  /* harmony default export */ __webpack_exports__["a"] = (function( selector, getDependants ) {
 234      var rootCache, getCache;
 235  
 236      // Use object source as dependant if getter not provided
 237      if ( ! getDependants ) {
 238          getDependants = arrayOf;
 239      }
 240  
 241      /**
 242       * Returns the root cache. If WeakMap is supported, this is assigned to the
 243       * root WeakMap cache set, otherwise it is a shared instance of the default
 244       * cache object.
 245       *
 246       * @return {(WeakMap|Object)} Root cache object.
 247       */
 248  	function getRootCache() {
 249          return rootCache;
 250      }
 251  
 252      /**
 253       * Returns the cache for a given dependants array. When possible, a WeakMap
 254       * will be used to create a unique cache for each set of dependants. This
 255       * is feasible due to the nature of WeakMap in allowing garbage collection
 256       * to occur on entries where the key object is no longer referenced. Since
 257       * WeakMap requires the key to be an object, this is only possible when the
 258       * dependant is object-like. The root cache is created as a hierarchy where
 259       * each top-level key is the first entry in a dependants set, the value a
 260       * WeakMap where each key is the next dependant, and so on. This continues
 261       * so long as the dependants are object-like. If no dependants are object-
 262       * like, then the cache is shared across all invocations.
 263       *
 264       * @see isObjectLike
 265       *
 266       * @param {Array} dependants Selector dependants.
 267       *
 268       * @return {Object} Cache object.
 269       */
 270  	function getWeakMapCache( dependants ) {
 271          var caches = rootCache,
 272              isUniqueByDependants = true,
 273              i, dependant, map, cache;
 274  
 275          for ( i = 0; i < dependants.length; i++ ) {
 276              dependant = dependants[ i ];
 277  
 278              // Can only compose WeakMap from object-like key.
 279              if ( ! isObjectLike( dependant ) ) {
 280                  isUniqueByDependants = false;
 281                  break;
 282              }
 283  
 284              // Does current segment of cache already have a WeakMap?
 285              if ( caches.has( dependant ) ) {
 286                  // Traverse into nested WeakMap.
 287                  caches = caches.get( dependant );
 288              } else {
 289                  // Create, set, and traverse into a new one.
 290                  map = new WeakMap();
 291                  caches.set( dependant, map );
 292                  caches = map;
 293              }
 294          }
 295  
 296          // We use an arbitrary (but consistent) object as key for the last item
 297          // in the WeakMap to serve as our running cache.
 298          if ( ! caches.has( LEAF_KEY ) ) {
 299              cache = createCache();
 300              cache.isUniqueByDependants = isUniqueByDependants;
 301              caches.set( LEAF_KEY, cache );
 302          }
 303  
 304          return caches.get( LEAF_KEY );
 305      }
 306  
 307      // Assign cache handler by availability of WeakMap
 308      getCache = hasWeakMap ? getWeakMapCache : getRootCache;
 309  
 310      /**
 311       * Resets root memoization cache.
 312       */
 313  	function clear() {
 314          rootCache = hasWeakMap ? new WeakMap() : createCache();
 315      }
 316  
 317      // eslint-disable-next-line jsdoc/check-param-names
 318      /**
 319       * The augmented selector call, considering first whether dependants have
 320       * changed before passing it to underlying memoize function.
 321       *
 322       * @param {Object} source    Source object for derivation.
 323       * @param {...*}   extraArgs Additional arguments to pass to selector.
 324       *
 325       * @return {*} Selector result.
 326       */
 327  	function callSelector( /* source, ...extraArgs */ ) {
 328          var len = arguments.length,
 329              cache, node, i, args, dependants;
 330  
 331          // Create copy of arguments (avoid leaking deoptimization).
 332          args = new Array( len );
 333          for ( i = 0; i < len; i++ ) {
 334              args[ i ] = arguments[ i ];
 335          }
 336  
 337          dependants = getDependants.apply( null, args );
 338          cache = getCache( dependants );
 339  
 340          // If not guaranteed uniqueness by dependants (primitive type or lack
 341          // of WeakMap support), shallow compare against last dependants and, if
 342          // references have changed, destroy cache to recalculate result.
 343          if ( ! cache.isUniqueByDependants ) {
 344              if ( cache.lastDependants && ! isShallowEqual( dependants, cache.lastDependants, 0 ) ) {
 345                  cache.clear();
 346              }
 347  
 348              cache.lastDependants = dependants;
 349          }
 350  
 351          node = cache.head;
 352          while ( node ) {
 353              // Check whether node arguments match arguments
 354              if ( ! isShallowEqual( node.args, args, 1 ) ) {
 355                  node = node.next;
 356                  continue;
 357              }
 358  
 359              // At this point we can assume we've found a match
 360  
 361              // Surface matched node to head if not already
 362              if ( node !== cache.head ) {
 363                  // Adjust siblings to point to each other.
 364                  node.prev.next = node.next;
 365                  if ( node.next ) {
 366                      node.next.prev = node.prev;
 367                  }
 368  
 369                  node.next = cache.head;
 370                  node.prev = null;
 371                  cache.head.prev = node;
 372                  cache.head = node;
 373              }
 374  
 375              // Return immediately
 376              return node.val;
 377          }
 378  
 379          // No cached value found. Continue to insertion phase:
 380  
 381          node = {
 382              // Generate the result from original function
 383              val: selector.apply( null, args ),
 384          };
 385  
 386          // Avoid including the source object in the cache.
 387          args[ 0 ] = null;
 388          node.args = args;
 389  
 390          // Don't need to check whether node is already head, since it would
 391          // have been returned above already if it was
 392  
 393          // Shift existing head down list
 394          if ( cache.head ) {
 395              cache.head.prev = node;
 396              node.next = cache.head;
 397          }
 398  
 399          cache.head = node;
 400  
 401          return node.val;
 402      }
 403  
 404      callSelector.getDependants = getDependants;
 405      callSelector.clear = clear;
 406      clear();
 407  
 408      return callSelector;
 409  });
 410  
 411  
 412  /***/ }),
 413  
 414  /***/ "yyEc":
 415  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 416  
 417  "use strict";
 418  // ESM COMPAT FLAG
 419  __webpack_require__.r(__webpack_exports__);
 420  
 421  // EXPORTS
 422  __webpack_require__.d(__webpack_exports__, "store", function() { return /* reexport */ store; });
 423  __webpack_require__.d(__webpack_exports__, "applyFormat", function() { return /* reexport */ applyFormat; });
 424  __webpack_require__.d(__webpack_exports__, "concat", function() { return /* reexport */ concat; });
 425  __webpack_require__.d(__webpack_exports__, "create", function() { return /* reexport */ create; });
 426  __webpack_require__.d(__webpack_exports__, "getActiveFormat", function() { return /* reexport */ getActiveFormat; });
 427  __webpack_require__.d(__webpack_exports__, "getActiveObject", function() { return /* reexport */ getActiveObject; });
 428  __webpack_require__.d(__webpack_exports__, "getTextContent", function() { return /* reexport */ getTextContent; });
 429  __webpack_require__.d(__webpack_exports__, "__unstableIsListRootSelected", function() { return /* reexport */ isListRootSelected; });
 430  __webpack_require__.d(__webpack_exports__, "__unstableIsActiveListType", function() { return /* reexport */ isActiveListType; });
 431  __webpack_require__.d(__webpack_exports__, "isCollapsed", function() { return /* reexport */ isCollapsed; });
 432  __webpack_require__.d(__webpack_exports__, "isEmpty", function() { return /* reexport */ isEmpty; });
 433  __webpack_require__.d(__webpack_exports__, "__unstableIsEmptyLine", function() { return /* reexport */ isEmptyLine; });
 434  __webpack_require__.d(__webpack_exports__, "join", function() { return /* reexport */ join; });
 435  __webpack_require__.d(__webpack_exports__, "registerFormatType", function() { return /* reexport */ registerFormatType; });
 436  __webpack_require__.d(__webpack_exports__, "removeFormat", function() { return /* reexport */ removeFormat; });
 437  __webpack_require__.d(__webpack_exports__, "remove", function() { return /* reexport */ remove_remove; });
 438  __webpack_require__.d(__webpack_exports__, "replace", function() { return /* reexport */ replace_replace; });
 439  __webpack_require__.d(__webpack_exports__, "insert", function() { return /* reexport */ insert; });
 440  __webpack_require__.d(__webpack_exports__, "__unstableInsertLineSeparator", function() { return /* reexport */ insertLineSeparator; });
 441  __webpack_require__.d(__webpack_exports__, "__unstableRemoveLineSeparator", function() { return /* reexport */ removeLineSeparator; });
 442  __webpack_require__.d(__webpack_exports__, "insertObject", function() { return /* reexport */ insertObject; });
 443  __webpack_require__.d(__webpack_exports__, "slice", function() { return /* reexport */ slice; });
 444  __webpack_require__.d(__webpack_exports__, "split", function() { return /* reexport */ split; });
 445  __webpack_require__.d(__webpack_exports__, "__unstableToDom", function() { return /* reexport */ toDom; });
 446  __webpack_require__.d(__webpack_exports__, "toHTMLString", function() { return /* reexport */ toHTMLString; });
 447  __webpack_require__.d(__webpack_exports__, "toggleFormat", function() { return /* reexport */ toggleFormat; });
 448  __webpack_require__.d(__webpack_exports__, "__UNSTABLE_LINE_SEPARATOR", function() { return /* reexport */ LINE_SEPARATOR; });
 449  __webpack_require__.d(__webpack_exports__, "unregisterFormatType", function() { return /* reexport */ unregisterFormatType; });
 450  __webpack_require__.d(__webpack_exports__, "__unstableCanIndentListItems", function() { return /* reexport */ canIndentListItems; });
 451  __webpack_require__.d(__webpack_exports__, "__unstableCanOutdentListItems", function() { return /* reexport */ canOutdentListItems; });
 452  __webpack_require__.d(__webpack_exports__, "__unstableIndentListItems", function() { return /* reexport */ indentListItems; });
 453  __webpack_require__.d(__webpack_exports__, "__unstableOutdentListItems", function() { return /* reexport */ outdentListItems; });
 454  __webpack_require__.d(__webpack_exports__, "__unstableChangeListType", function() { return /* reexport */ changeListType; });
 455  __webpack_require__.d(__webpack_exports__, "__unstableCreateElement", function() { return /* reexport */ createElement; });
 456  __webpack_require__.d(__webpack_exports__, "useAnchorRef", function() { return /* reexport */ useAnchorRef; });
 457  __webpack_require__.d(__webpack_exports__, "__experimentalRichText", function() { return /* reexport */ __experimentalRichText; });
 458  __webpack_require__.d(__webpack_exports__, "__unstableUseRichText", function() { return /* reexport */ useRichText; });
 459  __webpack_require__.d(__webpack_exports__, "__unstableFormatEdit", function() { return /* reexport */ FormatEdit; });
 460  
 461  // NAMESPACE OBJECT: ./node_modules/@wordpress/rich-text/build-module/store/selectors.js
 462  var selectors_namespaceObject = {};
 463  __webpack_require__.r(selectors_namespaceObject);
 464  __webpack_require__.d(selectors_namespaceObject, "getFormatTypes", function() { return getFormatTypes; });
 465  __webpack_require__.d(selectors_namespaceObject, "getFormatType", function() { return getFormatType; });
 466  __webpack_require__.d(selectors_namespaceObject, "getFormatTypeForBareElement", function() { return getFormatTypeForBareElement; });
 467  __webpack_require__.d(selectors_namespaceObject, "getFormatTypeForClassName", function() { return getFormatTypeForClassName; });
 468  
 469  // NAMESPACE OBJECT: ./node_modules/@wordpress/rich-text/build-module/store/actions.js
 470  var actions_namespaceObject = {};
 471  __webpack_require__.r(actions_namespaceObject);
 472  __webpack_require__.d(actions_namespaceObject, "addFormatTypes", function() { return addFormatTypes; });
 473  __webpack_require__.d(actions_namespaceObject, "removeFormatTypes", function() { return removeFormatTypes; });
 474  
 475  // EXTERNAL MODULE: external ["wp","data"]
 476  var external_wp_data_ = __webpack_require__("1ZqX");
 477  
 478  // EXTERNAL MODULE: external "lodash"
 479  var external_lodash_ = __webpack_require__("YLtl");
 480  
 481  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/store/reducer.js
 482  /**
 483   * External dependencies
 484   */
 485  
 486  /**
 487   * WordPress dependencies
 488   */
 489  
 490  
 491  /**
 492   * Reducer managing the format types
 493   *
 494   * @param {Object} state  Current state.
 495   * @param {Object} action Dispatched action.
 496   *
 497   * @return {Object} Updated state.
 498   */
 499  
 500  function reducer_formatTypes(state = {}, action) {
 501    switch (action.type) {
 502      case 'ADD_FORMAT_TYPES':
 503        return { ...state,
 504          ...Object(external_lodash_["keyBy"])(action.formatTypes, 'name')
 505        };
 506  
 507      case 'REMOVE_FORMAT_TYPES':
 508        return Object(external_lodash_["omit"])(state, action.names);
 509    }
 510  
 511    return state;
 512  }
 513  /* harmony default export */ var reducer = (Object(external_wp_data_["combineReducers"])({
 514    formatTypes: reducer_formatTypes
 515  }));
 516  
 517  // EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js
 518  var rememo = __webpack_require__("pPDe");
 519  
 520  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/store/selectors.js
 521  /**
 522   * External dependencies
 523   */
 524  
 525  
 526  /**
 527   * Returns all the available format types.
 528   *
 529   * @param {Object} state Data state.
 530   *
 531   * @return {Array} Format types.
 532   */
 533  
 534  const getFormatTypes = Object(rememo["a" /* default */])(state => Object.values(state.formatTypes), state => [state.formatTypes]);
 535  /**
 536   * Returns a format type by name.
 537   *
 538   * @param {Object} state Data state.
 539   * @param {string} name Format type name.
 540   *
 541   * @return {Object?} Format type.
 542   */
 543  
 544  function getFormatType(state, name) {
 545    return state.formatTypes[name];
 546  }
 547  /**
 548   * Gets the format type, if any, that can handle a bare element (without a
 549   * data-format-type attribute), given the tag name of this element.
 550   *
 551   * @param {Object} state              Data state.
 552   * @param {string} bareElementTagName The tag name of the element to find a
 553   *                                    format type for.
 554   * @return {?Object} Format type.
 555   */
 556  
 557  function getFormatTypeForBareElement(state, bareElementTagName) {
 558    return Object(external_lodash_["find"])(getFormatTypes(state), ({
 559      className,
 560      tagName
 561    }) => {
 562      return className === null && bareElementTagName === tagName;
 563    });
 564  }
 565  /**
 566   * Gets the format type, if any, that can handle an element, given its classes.
 567   *
 568   * @param {Object} state            Data state.
 569   * @param {string} elementClassName The classes of the element to find a format
 570   *                                  type for.
 571   * @return {?Object} Format type.
 572   */
 573  
 574  function getFormatTypeForClassName(state, elementClassName) {
 575    return Object(external_lodash_["find"])(getFormatTypes(state), ({
 576      className
 577    }) => {
 578      if (className === null) {
 579        return false;
 580      }
 581  
 582      return ` $elementClassName} `.indexOf(` $className} `) >= 0;
 583    });
 584  }
 585  
 586  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/store/actions.js
 587  /**
 588   * External dependencies
 589   */
 590  
 591  /**
 592   * Returns an action object used in signalling that format types have been
 593   * added.
 594   *
 595   * @param {Array|Object} formatTypes Format types received.
 596   *
 597   * @return {Object} Action object.
 598   */
 599  
 600  function addFormatTypes(formatTypes) {
 601    return {
 602      type: 'ADD_FORMAT_TYPES',
 603      formatTypes: Object(external_lodash_["castArray"])(formatTypes)
 604    };
 605  }
 606  /**
 607   * Returns an action object used to remove a registered format type.
 608   *
 609   * @param {string|Array} names Format name.
 610   *
 611   * @return {Object} Action object.
 612   */
 613  
 614  function removeFormatTypes(names) {
 615    return {
 616      type: 'REMOVE_FORMAT_TYPES',
 617      names: Object(external_lodash_["castArray"])(names)
 618    };
 619  }
 620  
 621  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/store/index.js
 622  /**
 623   * WordPress dependencies
 624   */
 625  
 626  /**
 627   * Internal dependencies
 628   */
 629  
 630  
 631  
 632  
 633  const STORE_NAME = 'core/rich-text';
 634  /**
 635   * Store definition for the rich-text namespace.
 636   *
 637   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
 638   *
 639   * @type {Object}
 640   */
 641  
 642  const store = Object(external_wp_data_["createReduxStore"])(STORE_NAME, {
 643    reducer: reducer,
 644    selectors: selectors_namespaceObject,
 645    actions: actions_namespaceObject
 646  });
 647  Object(external_wp_data_["register"])(store);
 648  
 649  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/is-format-equal.js
 650  /** @typedef {import('./create').RichTextFormat} RichTextFormat */
 651  
 652  /**
 653   * Optimised equality check for format objects.
 654   *
 655   * @param {?RichTextFormat} format1 Format to compare.
 656   * @param {?RichTextFormat} format2 Format to compare.
 657   *
 658   * @return {boolean} True if formats are equal, false if not.
 659   */
 660  function isFormatEqual(format1, format2) {
 661    // Both not defined.
 662    if (format1 === format2) {
 663      return true;
 664    } // Either not defined.
 665  
 666  
 667    if (!format1 || !format2) {
 668      return false;
 669    }
 670  
 671    if (format1.type !== format2.type) {
 672      return false;
 673    }
 674  
 675    const attributes1 = format1.attributes;
 676    const attributes2 = format2.attributes; // Both not defined.
 677  
 678    if (attributes1 === attributes2) {
 679      return true;
 680    } // Either not defined.
 681  
 682  
 683    if (!attributes1 || !attributes2) {
 684      return false;
 685    }
 686  
 687    const keys1 = Object.keys(attributes1);
 688    const keys2 = Object.keys(attributes2);
 689  
 690    if (keys1.length !== keys2.length) {
 691      return false;
 692    }
 693  
 694    const length = keys1.length; // Optimise for speed.
 695  
 696    for (let i = 0; i < length; i++) {
 697      const name = keys1[i];
 698  
 699      if (attributes1[name] !== attributes2[name]) {
 700        return false;
 701      }
 702    }
 703  
 704    return true;
 705  }
 706  
 707  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/normalise-formats.js
 708  /**
 709   * Internal dependencies
 710   */
 711  
 712  /** @typedef {import('./create').RichTextValue} RichTextValue */
 713  
 714  /**
 715   * Normalises formats: ensures subsequent adjacent equal formats have the same
 716   * reference.
 717   *
 718   * @param {RichTextValue} value Value to normalise formats of.
 719   *
 720   * @return {RichTextValue} New value with normalised formats.
 721   */
 722  
 723  function normaliseFormats(value) {
 724    const newFormats = value.formats.slice();
 725    newFormats.forEach((formatsAtIndex, index) => {
 726      const formatsAtPreviousIndex = newFormats[index - 1];
 727  
 728      if (formatsAtPreviousIndex) {
 729        const newFormatsAtIndex = formatsAtIndex.slice();
 730        newFormatsAtIndex.forEach((format, formatIndex) => {
 731          const previousFormat = formatsAtPreviousIndex[formatIndex];
 732  
 733          if (isFormatEqual(format, previousFormat)) {
 734            newFormatsAtIndex[formatIndex] = previousFormat;
 735          }
 736        });
 737        newFormats[index] = newFormatsAtIndex;
 738      }
 739    });
 740    return { ...value,
 741      formats: newFormats
 742    };
 743  }
 744  
 745  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/apply-format.js
 746  /**
 747   * External dependencies
 748   */
 749  
 750  /**
 751   * Internal dependencies
 752   */
 753  
 754  
 755  /** @typedef {import('./create').RichTextValue} RichTextValue */
 756  
 757  /** @typedef {import('./create').RichTextFormat} RichTextFormat */
 758  
 759  function replace(array, index, value) {
 760    array = array.slice();
 761    array[index] = value;
 762    return array;
 763  }
 764  /**
 765   * Apply a format object to a Rich Text value from the given `startIndex` to the
 766   * given `endIndex`. Indices are retrieved from the selection if none are
 767   * provided.
 768   *
 769   * @param {RichTextValue}  value        Value to modify.
 770   * @param {RichTextFormat} format       Format to apply.
 771   * @param {number}         [startIndex] Start index.
 772   * @param {number}         [endIndex]   End index.
 773   *
 774   * @return {RichTextValue} A new value with the format applied.
 775   */
 776  
 777  
 778  function applyFormat(value, format, startIndex = value.start, endIndex = value.end) {
 779    const {
 780      formats,
 781      activeFormats
 782    } = value;
 783    const newFormats = formats.slice(); // The selection is collapsed.
 784  
 785    if (startIndex === endIndex) {
 786      const startFormat = Object(external_lodash_["find"])(newFormats[startIndex], {
 787        type: format.type
 788      }); // If the caret is at a format of the same type, expand start and end to
 789      // the edges of the format. This is useful to apply new attributes.
 790  
 791      if (startFormat) {
 792        const index = newFormats[startIndex].indexOf(startFormat);
 793  
 794        while (newFormats[startIndex] && newFormats[startIndex][index] === startFormat) {
 795          newFormats[startIndex] = replace(newFormats[startIndex], index, format);
 796          startIndex--;
 797        }
 798  
 799        endIndex++;
 800  
 801        while (newFormats[endIndex] && newFormats[endIndex][index] === startFormat) {
 802          newFormats[endIndex] = replace(newFormats[endIndex], index, format);
 803          endIndex++;
 804        }
 805      }
 806    } else {
 807      // Determine the highest position the new format can be inserted at.
 808      let position = +Infinity;
 809  
 810      for (let index = startIndex; index < endIndex; index++) {
 811        if (newFormats[index]) {
 812          newFormats[index] = newFormats[index].filter(({
 813            type
 814          }) => type !== format.type);
 815          const length = newFormats[index].length;
 816  
 817          if (length < position) {
 818            position = length;
 819          }
 820        } else {
 821          newFormats[index] = [];
 822          position = 0;
 823        }
 824      }
 825  
 826      for (let index = startIndex; index < endIndex; index++) {
 827        newFormats[index].splice(position, 0, format);
 828      }
 829    }
 830  
 831    return normaliseFormats({ ...value,
 832      formats: newFormats,
 833      // Always revise active formats. This serves as a placeholder for new
 834      // inputs with the format so new input appears with the format applied,
 835      // and ensures a format of the same type uses the latest values.
 836      activeFormats: [...Object(external_lodash_["reject"])(activeFormats, {
 837        type: format.type
 838      }), format]
 839    });
 840  }
 841  
 842  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/create-element.js
 843  /**
 844   * Parse the given HTML into a body element.
 845   *
 846   * Note: The current implementation will return a shared reference, reset on
 847   * each call to `createElement`. Therefore, you should not hold a reference to
 848   * the value to operate upon asynchronously, as it may have unexpected results.
 849   *
 850   * @param {HTMLDocument} document The HTML document to use to parse.
 851   * @param {string}       html     The HTML to parse.
 852   *
 853   * @return {HTMLBodyElement} Body element with parsed HTML.
 854   */
 855  function createElement({
 856    implementation
 857  }, html) {
 858    // Because `createHTMLDocument` is an expensive operation, and with this
 859    // function being internal to `rich-text` (full control in avoiding a risk
 860    // of asynchronous operations on the shared reference), a single document
 861    // is reused and reset for each call to the function.
 862    if (!createElement.body) {
 863      createElement.body = implementation.createHTMLDocument('').body;
 864    }
 865  
 866    createElement.body.innerHTML = html;
 867    return createElement.body;
 868  }
 869  
 870  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/special-characters.js
 871  /**
 872   * Line separator character, used for multiline text.
 873   */
 874  const LINE_SEPARATOR = '\u2028';
 875  /**
 876   * Object replacement character, used as a placeholder for objects.
 877   */
 878  
 879  const OBJECT_REPLACEMENT_CHARACTER = '\ufffc';
 880  /**
 881   * Zero width non-breaking space, used as padding in the editable DOM tree when
 882   * it is empty otherwise.
 883   */
 884  
 885  const ZWNBSP = '\ufeff';
 886  
 887  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/create.js
 888  /**
 889   * WordPress dependencies
 890   */
 891  
 892  /**
 893   * Internal dependencies
 894   */
 895  
 896  
 897  
 898  
 899  
 900  /**
 901   * @typedef {Object} RichTextFormat
 902   *
 903   * @property {string} type Format type.
 904   */
 905  
 906  /**
 907   * @typedef {Array<RichTextFormat>} RichTextFormatList
 908   */
 909  
 910  /**
 911   * @typedef {Object} RichTextValue
 912   *
 913   * @property {string}                    text         Text.
 914   * @property {Array<RichTextFormatList>} formats      Formats.
 915   * @property {Array<RichTextFormat>}     replacements Replacements.
 916   * @property {number|undefined}          start        Selection start.
 917   * @property {number|undefined}          end          Selection end.
 918   */
 919  
 920  function createEmptyValue() {
 921    return {
 922      formats: [],
 923      replacements: [],
 924      text: ''
 925    };
 926  }
 927  
 928  function simpleFindKey(object, value) {
 929    for (const key in object) {
 930      if (object[key] === value) {
 931        return key;
 932      }
 933    }
 934  }
 935  
 936  function toFormat({
 937    type,
 938    attributes
 939  }) {
 940    let formatType;
 941  
 942    if (attributes && attributes.class) {
 943      formatType = Object(external_wp_data_["select"])('core/rich-text').getFormatTypeForClassName(attributes.class);
 944  
 945      if (formatType) {
 946        // Preserve any additional classes.
 947        attributes.class = ` $attributes.class} `.replace(` $formatType.className} `, ' ').trim();
 948  
 949        if (!attributes.class) {
 950          delete attributes.class;
 951        }
 952      }
 953    }
 954  
 955    if (!formatType) {
 956      formatType = Object(external_wp_data_["select"])('core/rich-text').getFormatTypeForBareElement(type);
 957    }
 958  
 959    if (!formatType) {
 960      return attributes ? {
 961        type,
 962        attributes
 963      } : {
 964        type
 965      };
 966    }
 967  
 968    if (formatType.__experimentalCreatePrepareEditableTree && !formatType.__experimentalCreateOnChangeEditableValue) {
 969      return null;
 970    }
 971  
 972    if (!attributes) {
 973      return {
 974        type: formatType.name
 975      };
 976    }
 977  
 978    const registeredAttributes = {};
 979    const unregisteredAttributes = {};
 980  
 981    for (const name in attributes) {
 982      const key = simpleFindKey(formatType.attributes, name);
 983  
 984      if (key) {
 985        registeredAttributes[key] = attributes[name];
 986      } else {
 987        unregisteredAttributes[name] = attributes[name];
 988      }
 989    }
 990  
 991    return {
 992      type: formatType.name,
 993      attributes: registeredAttributes,
 994      unregisteredAttributes
 995    };
 996  }
 997  /**
 998   * Create a RichText value from an `Element` tree (DOM), an HTML string or a
 999   * plain text string, with optionally a `Range` object to set the selection. If
1000   * called without any input, an empty value will be created. If
1001   * `multilineTag` is provided, any content of direct children whose type matches
1002   * `multilineTag` will be separated by two newlines. The optional functions can
1003   * be used to filter out content.
1004   *
1005   * A value will have the following shape, which you are strongly encouraged not
1006   * to modify without the use of helper functions:
1007   *
1008   * ```js
1009   * {
1010   *   text: string,
1011   *   formats: Array,
1012   *   replacements: Array,
1013   *   ?start: number,
1014   *   ?end: number,
1015   * }
1016   * ```
1017   *
1018   * As you can see, text and formatting are separated. `text` holds the text,
1019   * including any replacement characters for objects and lines. `formats`,
1020   * `objects` and `lines` are all sparse arrays of the same length as `text`. It
1021   * holds information about the formatting at the relevant text indices. Finally
1022   * `start` and `end` state which text indices are selected. They are only
1023   * provided if a `Range` was given.
1024   *
1025   * @param {Object}  [$1]                      Optional named arguments.
1026   * @param {Element} [$1.element]              Element to create value from.
1027   * @param {string}  [$1.text]                 Text to create value from.
1028   * @param {string}  [$1.html]                 HTML to create value from.
1029   * @param {Range}   [$1.range]                Range to create value from.
1030   * @param {string}  [$1.multilineTag]         Multiline tag if the structure is
1031   *                                            multiline.
1032   * @param {Array}   [$1.multilineWrapperTags] Tags where lines can be found if
1033   *                                            nesting is possible.
1034   * @param {boolean} [$1.preserveWhiteSpace]   Whether or not to collapse white
1035   *                                            space characters.
1036   * @param {boolean} [$1.__unstableIsEditableTree]
1037   *
1038   * @return {RichTextValue} A rich text value.
1039   */
1040  
1041  
1042  function create({
1043    element,
1044    text,
1045    html,
1046    range,
1047    multilineTag,
1048    multilineWrapperTags,
1049    __unstableIsEditableTree: isEditableTree,
1050    preserveWhiteSpace
1051  } = {}) {
1052    if (typeof text === 'string' && text.length > 0) {
1053      return {
1054        formats: Array(text.length),
1055        replacements: Array(text.length),
1056        text
1057      };
1058    }
1059  
1060    if (typeof html === 'string' && html.length > 0) {
1061      // It does not matter which document this is, we're just using it to
1062      // parse.
1063      element = createElement(document, html);
1064    }
1065  
1066    if (typeof element !== 'object') {
1067      return createEmptyValue();
1068    }
1069  
1070    if (!multilineTag) {
1071      return createFromElement({
1072        element,
1073        range,
1074        isEditableTree,
1075        preserveWhiteSpace
1076      });
1077    }
1078  
1079    return createFromMultilineElement({
1080      element,
1081      range,
1082      multilineTag,
1083      multilineWrapperTags,
1084      isEditableTree,
1085      preserveWhiteSpace
1086    });
1087  }
1088  /**
1089   * Helper to accumulate the value's selection start and end from the current
1090   * node and range.
1091   *
1092   * @param {Object} accumulator Object to accumulate into.
1093   * @param {Node}   node        Node to create value with.
1094   * @param {Range}  range       Range to create value with.
1095   * @param {Object} value       Value that is being accumulated.
1096   */
1097  
1098  function accumulateSelection(accumulator, node, range, value) {
1099    if (!range) {
1100      return;
1101    }
1102  
1103    const {
1104      parentNode
1105    } = node;
1106    const {
1107      startContainer,
1108      startOffset,
1109      endContainer,
1110      endOffset
1111    } = range;
1112    const currentLength = accumulator.text.length; // Selection can be extracted from value.
1113  
1114    if (value.start !== undefined) {
1115      accumulator.start = currentLength + value.start; // Range indicates that the current node has selection.
1116    } else if (node === startContainer && node.nodeType === node.TEXT_NODE) {
1117      accumulator.start = currentLength + startOffset; // Range indicates that the current node is selected.
1118    } else if (parentNode === startContainer && node === startContainer.childNodes[startOffset]) {
1119      accumulator.start = currentLength; // Range indicates that the selection is after the current node.
1120    } else if (parentNode === startContainer && node === startContainer.childNodes[startOffset - 1]) {
1121      accumulator.start = currentLength + value.text.length; // Fallback if no child inside handled the selection.
1122    } else if (node === startContainer) {
1123      accumulator.start = currentLength;
1124    } // Selection can be extracted from value.
1125  
1126  
1127    if (value.end !== undefined) {
1128      accumulator.end = currentLength + value.end; // Range indicates that the current node has selection.
1129    } else if (node === endContainer && node.nodeType === node.TEXT_NODE) {
1130      accumulator.end = currentLength + endOffset; // Range indicates that the current node is selected.
1131    } else if (parentNode === endContainer && node === endContainer.childNodes[endOffset - 1]) {
1132      accumulator.end = currentLength + value.text.length; // Range indicates that the selection is before the current node.
1133    } else if (parentNode === endContainer && node === endContainer.childNodes[endOffset]) {
1134      accumulator.end = currentLength; // Fallback if no child inside handled the selection.
1135    } else if (node === endContainer) {
1136      accumulator.end = currentLength + endOffset;
1137    }
1138  }
1139  /**
1140   * Adjusts the start and end offsets from a range based on a text filter.
1141   *
1142   * @param {Node}     node   Node of which the text should be filtered.
1143   * @param {Range}    range  The range to filter.
1144   * @param {Function} filter Function to use to filter the text.
1145   *
1146   * @return {Object|void} Object containing range properties.
1147   */
1148  
1149  
1150  function filterRange(node, range, filter) {
1151    if (!range) {
1152      return;
1153    }
1154  
1155    const {
1156      startContainer,
1157      endContainer
1158    } = range;
1159    let {
1160      startOffset,
1161      endOffset
1162    } = range;
1163  
1164    if (node === startContainer) {
1165      startOffset = filter(node.nodeValue.slice(0, startOffset)).length;
1166    }
1167  
1168    if (node === endContainer) {
1169      endOffset = filter(node.nodeValue.slice(0, endOffset)).length;
1170    }
1171  
1172    return {
1173      startContainer,
1174      startOffset,
1175      endContainer,
1176      endOffset
1177    };
1178  }
1179  /**
1180   * Collapse any whitespace used for HTML formatting to one space character,
1181   * because it will also be displayed as such by the browser.
1182   *
1183   * @param {string} string
1184   */
1185  
1186  
1187  function collapseWhiteSpace(string) {
1188    return string.replace(/[\n\r\t]+/g, ' ');
1189  }
1190  
1191  const ZWNBSPRegExp = new RegExp(ZWNBSP, 'g');
1192  /**
1193   * Removes padding (zero width non breaking spaces) added by `toTree`.
1194   *
1195   * @param {string} string
1196   */
1197  
1198  function removePadding(string) {
1199    return string.replace(ZWNBSPRegExp, '');
1200  }
1201  /**
1202   * Creates a Rich Text value from a DOM element and range.
1203   *
1204   * @param {Object}  $1                        Named argements.
1205   * @param {Element} [$1.element]              Element to create value from.
1206   * @param {Range}   [$1.range]                Range to create value from.
1207   * @param {string}  [$1.multilineTag]         Multiline tag if the structure is
1208   *                                            multiline.
1209   * @param {Array}   [$1.multilineWrapperTags] Tags where lines can be found if
1210   *                                            nesting is possible.
1211   * @param {boolean} [$1.preserveWhiteSpace]   Whether or not to collapse white
1212   *                                            space characters.
1213   * @param {Array}   [$1.currentWrapperTags]
1214   * @param {boolean} [$1.isEditableTree]
1215   *
1216   * @return {RichTextValue} A rich text value.
1217   */
1218  
1219  
1220  function createFromElement({
1221    element,
1222    range,
1223    multilineTag,
1224    multilineWrapperTags,
1225    currentWrapperTags = [],
1226    isEditableTree,
1227    preserveWhiteSpace
1228  }) {
1229    const accumulator = createEmptyValue();
1230  
1231    if (!element) {
1232      return accumulator;
1233    }
1234  
1235    if (!element.hasChildNodes()) {
1236      accumulateSelection(accumulator, element, range, createEmptyValue());
1237      return accumulator;
1238    }
1239  
1240    const length = element.childNodes.length; // Optimise for speed.
1241  
1242    for (let index = 0; index < length; index++) {
1243      const node = element.childNodes[index];
1244      const type = node.nodeName.toLowerCase();
1245  
1246      if (node.nodeType === node.TEXT_NODE) {
1247        let filter = removePadding;
1248  
1249        if (!preserveWhiteSpace) {
1250          filter = string => removePadding(collapseWhiteSpace(string));
1251        }
1252  
1253        const text = filter(node.nodeValue);
1254        range = filterRange(node, range, filter);
1255        accumulateSelection(accumulator, node, range, {
1256          text
1257        }); // Create a sparse array of the same length as `text`, in which
1258        // formats can be added.
1259  
1260        accumulator.formats.length += text.length;
1261        accumulator.replacements.length += text.length;
1262        accumulator.text += text;
1263        continue;
1264      }
1265  
1266      if (node.nodeType !== node.ELEMENT_NODE) {
1267        continue;
1268      }
1269  
1270      if (isEditableTree && ( // Ignore any placeholders.
1271      node.getAttribute('data-rich-text-placeholder') || // Ignore any line breaks that are not inserted by us.
1272      type === 'br' && !node.getAttribute('data-rich-text-line-break'))) {
1273        accumulateSelection(accumulator, node, range, createEmptyValue());
1274        continue;
1275      }
1276  
1277      if (type === 'script') {
1278        const value = {
1279          formats: [,],
1280          replacements: [{
1281            type,
1282            attributes: {
1283              'data-rich-text-script': node.getAttribute('data-rich-text-script') || encodeURIComponent(node.innerHTML)
1284            }
1285          }],
1286          text: OBJECT_REPLACEMENT_CHARACTER
1287        };
1288        accumulateSelection(accumulator, node, range, value);
1289        mergePair(accumulator, value);
1290        continue;
1291      }
1292  
1293      if (type === 'br') {
1294        accumulateSelection(accumulator, node, range, createEmptyValue());
1295        mergePair(accumulator, create({
1296          text: '\n'
1297        }));
1298        continue;
1299      }
1300  
1301      const lastFormats = accumulator.formats[accumulator.formats.length - 1];
1302      const lastFormat = lastFormats && lastFormats[lastFormats.length - 1];
1303      const newFormat = toFormat({
1304        type,
1305        attributes: getAttributes({
1306          element: node
1307        })
1308      });
1309      const format = isFormatEqual(newFormat, lastFormat) ? lastFormat : newFormat;
1310  
1311      if (multilineWrapperTags && multilineWrapperTags.indexOf(type) !== -1) {
1312        const value = createFromMultilineElement({
1313          element: node,
1314          range,
1315          multilineTag,
1316          multilineWrapperTags,
1317          currentWrapperTags: [...currentWrapperTags, format],
1318          isEditableTree,
1319          preserveWhiteSpace
1320        });
1321        accumulateSelection(accumulator, node, range, value);
1322        mergePair(accumulator, value);
1323        continue;
1324      }
1325  
1326      const value = createFromElement({
1327        element: node,
1328        range,
1329        multilineTag,
1330        multilineWrapperTags,
1331        isEditableTree,
1332        preserveWhiteSpace
1333      });
1334      accumulateSelection(accumulator, node, range, value);
1335  
1336      if (!format) {
1337        mergePair(accumulator, value);
1338      } else if (value.text.length === 0) {
1339        if (format.attributes) {
1340          mergePair(accumulator, {
1341            formats: [,],
1342            replacements: [format],
1343            text: OBJECT_REPLACEMENT_CHARACTER
1344          });
1345        }
1346      } else {
1347        // Indices should share a reference to the same formats array.
1348        // Only create a new reference if `formats` changes.
1349        function mergeFormats(formats) {
1350          if (mergeFormats.formats === formats) {
1351            return mergeFormats.newFormats;
1352          }
1353  
1354          const newFormats = formats ? [format, ...formats] : [format];
1355          mergeFormats.formats = formats;
1356          mergeFormats.newFormats = newFormats;
1357          return newFormats;
1358        } // Since the formats parameter can be `undefined`, preset
1359        // `mergeFormats` with a new reference.
1360  
1361  
1362        mergeFormats.newFormats = [format];
1363        mergePair(accumulator, { ...value,
1364          formats: Array.from(value.formats, mergeFormats)
1365        });
1366      }
1367    }
1368  
1369    return accumulator;
1370  }
1371  /**
1372   * Creates a rich text value from a DOM element and range that should be
1373   * multiline.
1374   *
1375   * @param {Object}  $1                        Named argements.
1376   * @param {Element} [$1.element]              Element to create value from.
1377   * @param {Range}   [$1.range]                Range to create value from.
1378   * @param {string}  [$1.multilineTag]         Multiline tag if the structure is
1379   *                                            multiline.
1380   * @param {Array}   [$1.multilineWrapperTags] Tags where lines can be found if
1381   *                                            nesting is possible.
1382   * @param {boolean} [$1.currentWrapperTags]   Whether to prepend a line
1383   *                                            separator.
1384   * @param {boolean} [$1.preserveWhiteSpace]   Whether or not to collapse white
1385   *                                            space characters.
1386   * @param {boolean} [$1.isEditableTree]
1387   *
1388   * @return {RichTextValue} A rich text value.
1389   */
1390  
1391  
1392  function createFromMultilineElement({
1393    element,
1394    range,
1395    multilineTag,
1396    multilineWrapperTags,
1397    currentWrapperTags = [],
1398    isEditableTree,
1399    preserveWhiteSpace
1400  }) {
1401    const accumulator = createEmptyValue();
1402  
1403    if (!element || !element.hasChildNodes()) {
1404      return accumulator;
1405    }
1406  
1407    const length = element.children.length; // Optimise for speed.
1408  
1409    for (let index = 0; index < length; index++) {
1410      const node = element.children[index];
1411  
1412      if (node.nodeName.toLowerCase() !== multilineTag) {
1413        continue;
1414      }
1415  
1416      const value = createFromElement({
1417        element: node,
1418        range,
1419        multilineTag,
1420        multilineWrapperTags,
1421        currentWrapperTags,
1422        isEditableTree,
1423        preserveWhiteSpace
1424      }); // Multiline value text should be separated by a line separator.
1425  
1426      if (index !== 0 || currentWrapperTags.length > 0) {
1427        mergePair(accumulator, {
1428          formats: [,],
1429          replacements: currentWrapperTags.length > 0 ? [currentWrapperTags] : [,],
1430          text: LINE_SEPARATOR
1431        });
1432      }
1433  
1434      accumulateSelection(accumulator, node, range, value);
1435      mergePair(accumulator, value);
1436    }
1437  
1438    return accumulator;
1439  }
1440  /**
1441   * Gets the attributes of an element in object shape.
1442   *
1443   * @param {Object}  $1         Named argements.
1444   * @param {Element} $1.element Element to get attributes from.
1445   *
1446   * @return {Object|void} Attribute object or `undefined` if the element has no
1447   *                       attributes.
1448   */
1449  
1450  
1451  function getAttributes({
1452    element
1453  }) {
1454    if (!element.hasAttributes()) {
1455      return;
1456    }
1457  
1458    const length = element.attributes.length;
1459    let accumulator; // Optimise for speed.
1460  
1461    for (let i = 0; i < length; i++) {
1462      const {
1463        name,
1464        value
1465      } = element.attributes[i];
1466  
1467      if (name.indexOf('data-rich-text-') === 0) {
1468        continue;
1469      }
1470  
1471      const safeName = /^on/i.test(name) ? 'data-disable-rich-text-' + name : name;
1472      accumulator = accumulator || {};
1473      accumulator[safeName] = value;
1474    }
1475  
1476    return accumulator;
1477  }
1478  
1479  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/concat.js
1480  /**
1481   * Internal dependencies
1482   */
1483  
1484  
1485  /** @typedef {import('./create').RichTextValue} RichTextValue */
1486  
1487  /**
1488   * Concats a pair of rich text values. Not that this mutates `a` and does NOT
1489   * normalise formats!
1490   *
1491   * @param {Object} a Value to mutate.
1492   * @param {Object} b Value to add read from.
1493   *
1494   * @return {Object} `a`, mutated.
1495   */
1496  
1497  function mergePair(a, b) {
1498    a.formats = a.formats.concat(b.formats);
1499    a.replacements = a.replacements.concat(b.replacements);
1500    a.text += b.text;
1501    return a;
1502  }
1503  /**
1504   * Combine all Rich Text values into one. This is similar to
1505   * `String.prototype.concat`.
1506   *
1507   * @param {...RichTextValue} values Objects to combine.
1508   *
1509   * @return {RichTextValue} A new value combining all given records.
1510   */
1511  
1512  function concat(...values) {
1513    return normaliseFormats(values.reduce(mergePair, create()));
1514  }
1515  
1516  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/get-active-formats.js
1517  /** @typedef {import('./create').RichTextValue} RichTextValue */
1518  
1519  /** @typedef {import('./create').RichTextFormatList} RichTextFormatList */
1520  
1521  /**
1522   * Gets the all format objects at the start of the selection.
1523   *
1524   * @param {RichTextValue} value                Value to inspect.
1525   * @param {Array}         EMPTY_ACTIVE_FORMATS Array to return if there are no
1526   *                                             active formats.
1527   *
1528   * @return {RichTextFormatList} Active format objects.
1529   */
1530  function getActiveFormats({
1531    formats,
1532    start,
1533    end,
1534    activeFormats
1535  }, EMPTY_ACTIVE_FORMATS = []) {
1536    if (start === undefined) {
1537      return EMPTY_ACTIVE_FORMATS;
1538    }
1539  
1540    if (start === end) {
1541      // For a collapsed caret, it is possible to override the active formats.
1542      if (activeFormats) {
1543        return activeFormats;
1544      }
1545  
1546      const formatsBefore = formats[start - 1] || EMPTY_ACTIVE_FORMATS;
1547      const formatsAfter = formats[start] || EMPTY_ACTIVE_FORMATS; // By default, select the lowest amount of formats possible (which means
1548      // the caret is positioned outside the format boundary). The user can
1549      // then use arrow keys to define `activeFormats`.
1550  
1551      if (formatsBefore.length < formatsAfter.length) {
1552        return formatsBefore;
1553      }
1554  
1555      return formatsAfter;
1556    }
1557  
1558    return formats[start] || EMPTY_ACTIVE_FORMATS;
1559  }
1560  
1561  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/get-active-format.js
1562  /**
1563   * External dependencies
1564   */
1565  
1566  /**
1567   * Internal dependencies
1568   */
1569  
1570  
1571  /** @typedef {import('./create').RichTextValue} RichTextValue */
1572  
1573  /** @typedef {import('./create').RichTextFormat} RichTextFormat */
1574  
1575  /**
1576   * Gets the format object by type at the start of the selection. This can be
1577   * used to get e.g. the URL of a link format at the current selection, but also
1578   * to check if a format is active at the selection. Returns undefined if there
1579   * is no format at the selection.
1580   *
1581   * @param {RichTextValue} value      Value to inspect.
1582   * @param {string}        formatType Format type to look for.
1583   *
1584   * @return {RichTextFormat|undefined} Active format object of the specified
1585   *                                    type, or undefined.
1586   */
1587  
1588  function getActiveFormat(value, formatType) {
1589    return Object(external_lodash_["find"])(getActiveFormats(value), {
1590      type: formatType
1591    });
1592  }
1593  
1594  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/get-active-object.js
1595  /**
1596   * Internal dependencies
1597   */
1598  
1599  /** @typedef {import('./create').RichTextValue} RichTextValue */
1600  
1601  /** @typedef {import('./create').RichTextFormat} RichTextFormat */
1602  
1603  /**
1604   * Gets the active object, if there is any.
1605   *
1606   * @param {RichTextValue} value Value to inspect.
1607   *
1608   * @return {RichTextFormat|void} Active object, or undefined.
1609   */
1610  
1611  function getActiveObject({
1612    start,
1613    end,
1614    replacements,
1615    text
1616  }) {
1617    if (start + 1 !== end || text[start] !== OBJECT_REPLACEMENT_CHARACTER) {
1618      return;
1619    }
1620  
1621    return replacements[start];
1622  }
1623  
1624  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/get-text-content.js
1625  /**
1626   * Internal dependencies
1627   */
1628  
1629  /** @typedef {import('./create').RichTextValue} RichTextValue */
1630  
1631  /**
1632   * Get the textual content of a Rich Text value. This is similar to
1633   * `Element.textContent`.
1634   *
1635   * @param {RichTextValue} value Value to use.
1636   *
1637   * @return {string} The text content.
1638   */
1639  
1640  function getTextContent({
1641    text
1642  }) {
1643    return text.replace(new RegExp(OBJECT_REPLACEMENT_CHARACTER, 'g'), '').replace(new RegExp(LINE_SEPARATOR, 'g'), '\n');
1644  }
1645  
1646  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/get-line-index.js
1647  /**
1648   * Internal dependencies
1649   */
1650  
1651  /** @typedef {import('./create').RichTextValue} RichTextValue */
1652  
1653  /**
1654   * Gets the currently selected line index, or the first line index if the
1655   * selection spans over multiple items.
1656   *
1657   * @param {RichTextValue}  value      Value to get the line index from.
1658   * @param {boolean}        startIndex Optional index that should be contained by
1659   *                                    the line. Defaults to the selection start
1660   *                                    of the value.
1661   *
1662   * @return {number|void} The line index. Undefined if not found.
1663   */
1664  
1665  function getLineIndex({
1666    start,
1667    text
1668  }, startIndex = start) {
1669    let index = startIndex;
1670  
1671    while (index--) {
1672      if (text[index] === LINE_SEPARATOR) {
1673        return index;
1674      }
1675    }
1676  }
1677  
1678  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/is-list-root-selected.js
1679  /**
1680   * Internal dependencies
1681   */
1682  
1683  /** @typedef {import('./create').RichTextValue} RichTextValue */
1684  
1685  /**
1686   * Whether or not the root list is selected.
1687   *
1688   * @param {RichTextValue} value The value to check.
1689   *
1690   * @return {boolean} True if the root list or nothing is selected, false if an
1691   *                   inner list is selected.
1692   */
1693  
1694  function isListRootSelected(value) {
1695    const {
1696      replacements,
1697      start
1698    } = value;
1699    const lineIndex = getLineIndex(value, start);
1700    const replacement = replacements[lineIndex];
1701    return !replacement || replacement.length < 1;
1702  }
1703  
1704  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/is-active-list-type.js
1705  /**
1706   * Internal dependencies
1707   */
1708  
1709  /** @typedef {import('./create').RichTextValue} RichTextValue */
1710  
1711  /**
1712   * Whether or not the selected list has the given tag name.
1713   *
1714   * @param {RichTextValue} value    The value to check.
1715   * @param {string}        type     The tag name the list should have.
1716   * @param {string}        rootType The current root tag name, to compare with in
1717   *                                 case nothing is selected.
1718   *
1719   * @return {boolean} True if the current list type matches `type`, false if not.
1720   */
1721  
1722  function isActiveListType(value, type, rootType) {
1723    const {
1724      replacements,
1725      start
1726    } = value;
1727    const lineIndex = getLineIndex(value, start);
1728    const replacement = replacements[lineIndex];
1729  
1730    if (!replacement || replacement.length === 0) {
1731      return type === rootType;
1732    }
1733  
1734    const lastFormat = replacement[replacement.length - 1];
1735    return lastFormat.type === type;
1736  }
1737  
1738  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/is-collapsed.js
1739  /** @typedef {import('./create').RichTextValue} RichTextValue */
1740  
1741  /**
1742   * Check if the selection of a Rich Text value is collapsed or not. Collapsed
1743   * means that no characters are selected, but there is a caret present. If there
1744   * is no selection, `undefined` will be returned. This is similar to
1745   * `window.getSelection().isCollapsed()`.
1746   *
1747   * @param {RichTextValue} value The rich text value to check.
1748   *
1749   * @return {boolean|undefined} True if the selection is collapsed, false if not,
1750   *                             undefined if there is no selection.
1751   */
1752  function isCollapsed({
1753    start,
1754    end
1755  }) {
1756    if (start === undefined || end === undefined) {
1757      return;
1758    }
1759  
1760    return start === end;
1761  }
1762  
1763  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/is-empty.js
1764  /**
1765   * Internal dependencies
1766   */
1767  
1768  /** @typedef {import('./create').RichTextValue} RichTextValue */
1769  
1770  /**
1771   * Check if a Rich Text value is Empty, meaning it contains no text or any
1772   * objects (such as images).
1773   *
1774   * @param {RichTextValue} value Value to use.
1775   *
1776   * @return {boolean} True if the value is empty, false if not.
1777   */
1778  
1779  function isEmpty({
1780    text
1781  }) {
1782    return text.length === 0;
1783  }
1784  /**
1785   * Check if the current collapsed selection is on an empty line in case of a
1786   * multiline value.
1787   *
1788   * @param  {RichTextValue} value Value te check.
1789   *
1790   * @return {boolean} True if the line is empty, false if not.
1791   */
1792  
1793  function isEmptyLine({
1794    text,
1795    start,
1796    end
1797  }) {
1798    if (start !== end) {
1799      return false;
1800    }
1801  
1802    if (text.length === 0) {
1803      return true;
1804    }
1805  
1806    if (start === 0 && text.slice(0, 1) === LINE_SEPARATOR) {
1807      return true;
1808    }
1809  
1810    if (start === text.length && text.slice(-1) === LINE_SEPARATOR) {
1811      return true;
1812    }
1813  
1814    return text.slice(start - 1, end + 1) === `$LINE_SEPARATOR}$LINE_SEPARATOR}`;
1815  }
1816  
1817  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/join.js
1818  /**
1819   * Internal dependencies
1820   */
1821  
1822  
1823  /** @typedef {import('./create').RichTextValue} RichTextValue */
1824  
1825  /**
1826   * Combine an array of Rich Text values into one, optionally separated by
1827   * `separator`, which can be a Rich Text value, HTML string, or plain text
1828   * string. This is similar to `Array.prototype.join`.
1829   *
1830   * @param {Array<RichTextValue>} values      An array of values to join.
1831   * @param {string|RichTextValue} [separator] Separator string or value.
1832   *
1833   * @return {RichTextValue} A new combined value.
1834   */
1835  
1836  function join(values, separator = '') {
1837    if (typeof separator === 'string') {
1838      separator = create({
1839        text: separator
1840      });
1841    }
1842  
1843    return normaliseFormats(values.reduce((accumlator, {
1844      formats,
1845      replacements,
1846      text
1847    }) => ({
1848      formats: accumlator.formats.concat(separator.formats, formats),
1849      replacements: accumlator.replacements.concat(separator.replacements, replacements),
1850      text: accumlator.text + separator.text + text
1851    })));
1852  }
1853  
1854  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/register-format-type.js
1855  /**
1856   * WordPress dependencies
1857   */
1858  
1859  /**
1860   * Internal dependencies
1861   */
1862  
1863  
1864  /**
1865   * @typedef {Object} WPFormat
1866   *
1867   * @property {string}   name        A string identifying the format. Must be
1868   *                                  unique across all registered formats.
1869   * @property {string}   tagName     The HTML tag this format will wrap the
1870   *                                  selection with.
1871   * @property {string}   [className] A class to match the format.
1872   * @property {string}   title       Name of the format.
1873   * @property {Function} edit        Should return a component for the user to
1874   *                                  interact with the new registered format.
1875   */
1876  
1877  /**
1878   * Registers a new format provided a unique name and an object defining its
1879   * behavior.
1880   *
1881   * @param {string}   name                 Format name.
1882   * @param {WPFormat} settings             Format settings.
1883   *
1884   * @return {WPFormat|undefined} The format, if it has been successfully
1885   *                              registered; otherwise `undefined`.
1886   */
1887  
1888  function registerFormatType(name, settings) {
1889    settings = {
1890      name,
1891      ...settings
1892    };
1893  
1894    if (typeof settings.name !== 'string') {
1895      window.console.error('Format names must be strings.');
1896      return;
1897    }
1898  
1899    if (!/^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/.test(settings.name)) {
1900      window.console.error('Format names must contain a namespace prefix, include only lowercase alphanumeric characters or dashes, and start with a letter. Example: my-plugin/my-custom-format');
1901      return;
1902    }
1903  
1904    if (Object(external_wp_data_["select"])(store).getFormatType(settings.name)) {
1905      window.console.error('Format "' + settings.name + '" is already registered.');
1906      return;
1907    }
1908  
1909    if (typeof settings.tagName !== 'string' || settings.tagName === '') {
1910      window.console.error('Format tag names must be a string.');
1911      return;
1912    }
1913  
1914    if ((typeof settings.className !== 'string' || settings.className === '') && settings.className !== null) {
1915      window.console.error('Format class names must be a string, or null to handle bare elements.');
1916      return;
1917    }
1918  
1919    if (!/^[_a-zA-Z]+[a-zA-Z0-9-]*$/.test(settings.className)) {
1920      window.console.error('A class name must begin with a letter, followed by any number of hyphens, letters, or numbers.');
1921      return;
1922    }
1923  
1924    if (settings.className === null) {
1925      const formatTypeForBareElement = Object(external_wp_data_["select"])(store).getFormatTypeForBareElement(settings.tagName);
1926  
1927      if (formatTypeForBareElement) {
1928        window.console.error(`Format "$formatTypeForBareElement.name}" is already registered to handle bare tag name "$settings.tagName}".`);
1929        return;
1930      }
1931    } else {
1932      const formatTypeForClassName = Object(external_wp_data_["select"])(store).getFormatTypeForClassName(settings.className);
1933  
1934      if (formatTypeForClassName) {
1935        window.console.error(`Format "$formatTypeForClassName.name}" is already registered to handle class name "$settings.className}".`);
1936        return;
1937      }
1938    }
1939  
1940    if (!('title' in settings) || settings.title === '') {
1941      window.console.error('The format "' + settings.name + '" must have a title.');
1942      return;
1943    }
1944  
1945    if ('keywords' in settings && settings.keywords.length > 3) {
1946      window.console.error('The format "' + settings.name + '" can have a maximum of 3 keywords.');
1947      return;
1948    }
1949  
1950    if (typeof settings.title !== 'string') {
1951      window.console.error('Format titles must be strings.');
1952      return;
1953    }
1954  
1955    Object(external_wp_data_["dispatch"])(store).addFormatTypes(settings);
1956    return settings;
1957  }
1958  
1959  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/remove-format.js
1960  /**
1961   * External dependencies
1962   */
1963  
1964  /**
1965   * Internal dependencies
1966   */
1967  
1968  
1969  /** @typedef {import('./create').RichTextValue} RichTextValue */
1970  
1971  /**
1972   * Remove any format object from a Rich Text value by type from the given
1973   * `startIndex` to the given `endIndex`. Indices are retrieved from the
1974   * selection if none are provided.
1975   *
1976   * @param {RichTextValue} value        Value to modify.
1977   * @param {string}        formatType   Format type to remove.
1978   * @param {number}        [startIndex] Start index.
1979   * @param {number}        [endIndex]   End index.
1980   *
1981   * @return {RichTextValue} A new value with the format applied.
1982   */
1983  
1984  function removeFormat(value, formatType, startIndex = value.start, endIndex = value.end) {
1985    const {
1986      formats,
1987      activeFormats
1988    } = value;
1989    const newFormats = formats.slice(); // If the selection is collapsed, expand start and end to the edges of the
1990    // format.
1991  
1992    if (startIndex === endIndex) {
1993      const format = Object(external_lodash_["find"])(newFormats[startIndex], {
1994        type: formatType
1995      });
1996  
1997      if (format) {
1998        while (Object(external_lodash_["find"])(newFormats[startIndex], format)) {
1999          filterFormats(newFormats, startIndex, formatType);
2000          startIndex--;
2001        }
2002  
2003        endIndex++;
2004  
2005        while (Object(external_lodash_["find"])(newFormats[endIndex], format)) {
2006          filterFormats(newFormats, endIndex, formatType);
2007          endIndex++;
2008        }
2009      }
2010    } else {
2011      for (let i = startIndex; i < endIndex; i++) {
2012        if (newFormats[i]) {
2013          filterFormats(newFormats, i, formatType);
2014        }
2015      }
2016    }
2017  
2018    return normaliseFormats({ ...value,
2019      formats: newFormats,
2020      activeFormats: Object(external_lodash_["reject"])(activeFormats, {
2021        type: formatType
2022      })
2023    });
2024  }
2025  
2026  function filterFormats(formats, index, formatType) {
2027    const newFormats = formats[index].filter(({
2028      type
2029    }) => type !== formatType);
2030  
2031    if (newFormats.length) {
2032      formats[index] = newFormats;
2033    } else {
2034      delete formats[index];
2035    }
2036  }
2037  
2038  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/insert.js
2039  /**
2040   * Internal dependencies
2041   */
2042  
2043  
2044  /** @typedef {import('./create').RichTextValue} RichTextValue */
2045  
2046  /**
2047   * Insert a Rich Text value, an HTML string, or a plain text string, into a
2048   * Rich Text value at the given `startIndex`. Any content between `startIndex`
2049   * and `endIndex` will be removed. Indices are retrieved from the selection if
2050   * none are provided.
2051   *
2052   * @param {RichTextValue}        value         Value to modify.
2053   * @param {RichTextValue|string} valueToInsert Value to insert.
2054   * @param {number}               [startIndex]  Start index.
2055   * @param {number}               [endIndex]    End index.
2056   *
2057   * @return {RichTextValue} A new value with the value inserted.
2058   */
2059  
2060  function insert(value, valueToInsert, startIndex = value.start, endIndex = value.end) {
2061    const {
2062      formats,
2063      replacements,
2064      text
2065    } = value;
2066  
2067    if (typeof valueToInsert === 'string') {
2068      valueToInsert = create({
2069        text: valueToInsert
2070      });
2071    }
2072  
2073    const index = startIndex + valueToInsert.text.length;
2074    return normaliseFormats({
2075      formats: formats.slice(0, startIndex).concat(valueToInsert.formats, formats.slice(endIndex)),
2076      replacements: replacements.slice(0, startIndex).concat(valueToInsert.replacements, replacements.slice(endIndex)),
2077      text: text.slice(0, startIndex) + valueToInsert.text + text.slice(endIndex),
2078      start: index,
2079      end: index
2080    });
2081  }
2082  
2083  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/remove.js
2084  /**
2085   * Internal dependencies
2086   */
2087  
2088  
2089  /** @typedef {import('./create').RichTextValue} RichTextValue */
2090  
2091  /**
2092   * Remove content from a Rich Text value between the given `startIndex` and
2093   * `endIndex`. Indices are retrieved from the selection if none are provided.
2094   *
2095   * @param {RichTextValue} value        Value to modify.
2096   * @param {number}        [startIndex] Start index.
2097   * @param {number}        [endIndex]   End index.
2098   *
2099   * @return {RichTextValue} A new value with the content removed.
2100   */
2101  
2102  function remove_remove(value, startIndex, endIndex) {
2103    return insert(value, create(), startIndex, endIndex);
2104  }
2105  
2106  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/replace.js
2107  /**
2108   * Internal dependencies
2109   */
2110  
2111  /** @typedef {import('./create').RichTextValue} RichTextValue */
2112  
2113  /**
2114   * Search a Rich Text value and replace the match(es) with `replacement`. This
2115   * is similar to `String.prototype.replace`.
2116   *
2117   * @param {RichTextValue}  value        The value to modify.
2118   * @param {RegExp|string}  pattern      A RegExp object or literal. Can also be
2119   *                                      a string. It is treated as a verbatim
2120   *                                      string and is not interpreted as a
2121   *                                      regular expression. Only the first
2122   *                                      occurrence will be replaced.
2123   * @param {Function|string} replacement The match or matches are replaced with
2124   *                                      the specified or the value returned by
2125   *                                      the specified function.
2126   *
2127   * @return {RichTextValue} A new value with replacements applied.
2128   */
2129  
2130  function replace_replace({
2131    formats,
2132    replacements,
2133    text,
2134    start,
2135    end
2136  }, pattern, replacement) {
2137    text = text.replace(pattern, (match, ...rest) => {
2138      const offset = rest[rest.length - 2];
2139      let newText = replacement;
2140      let newFormats;
2141      let newReplacements;
2142  
2143      if (typeof newText === 'function') {
2144        newText = replacement(match, ...rest);
2145      }
2146  
2147      if (typeof newText === 'object') {
2148        newFormats = newText.formats;
2149        newReplacements = newText.replacements;
2150        newText = newText.text;
2151      } else {
2152        newFormats = Array(newText.length);
2153        newReplacements = Array(newText.length);
2154  
2155        if (formats[offset]) {
2156          newFormats = newFormats.fill(formats[offset]);
2157        }
2158      }
2159  
2160      formats = formats.slice(0, offset).concat(newFormats, formats.slice(offset + match.length));
2161      replacements = replacements.slice(0, offset).concat(newReplacements, replacements.slice(offset + match.length));
2162  
2163      if (start) {
2164        start = end = offset + newText.length;
2165      }
2166  
2167      return newText;
2168    });
2169    return normaliseFormats({
2170      formats,
2171      replacements,
2172      text,
2173      start,
2174      end
2175    });
2176  }
2177  
2178  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/insert-line-separator.js
2179  /**
2180   * Internal dependencies
2181   */
2182  
2183  
2184  /** @typedef {import('./create').RichTextValue} RichTextValue */
2185  
2186  /**
2187   * Insert a line break character into a Rich Text value at the given
2188   * `startIndex`. Any content between `startIndex` and `endIndex` will be
2189   * removed. Indices are retrieved from the selection if none are provided.
2190   *
2191   * @param {RichTextValue} value        Value to modify.
2192   * @param {number}        [startIndex] Start index.
2193   * @param {number}        [endIndex]   End index.
2194   *
2195   * @return {RichTextValue} A new value with the value inserted.
2196   */
2197  
2198  function insertLineSeparator(value, startIndex = value.start, endIndex = value.end) {
2199    const beforeText = value.text.slice(0, startIndex);
2200    const previousLineSeparatorIndex = beforeText.lastIndexOf(LINE_SEPARATOR);
2201    const previousLineSeparatorFormats = value.replacements[previousLineSeparatorIndex];
2202    let replacements = [,];
2203  
2204    if (previousLineSeparatorFormats) {
2205      replacements = [previousLineSeparatorFormats];
2206    }
2207  
2208    const valueToInsert = {
2209      formats: [,],
2210      replacements,
2211      text: LINE_SEPARATOR
2212    };
2213    return insert(value, valueToInsert, startIndex, endIndex);
2214  }
2215  
2216  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/remove-line-separator.js
2217  /**
2218   * Internal dependencies
2219   */
2220  
2221  
2222  
2223  /** @typedef {import('./create').RichTextValue} RichTextValue */
2224  
2225  /**
2226   * Removes a line separator character, if existing, from a Rich Text value at
2227   * the current indices. If no line separator exists on the indices it will
2228   * return undefined.
2229   *
2230   * @param {RichTextValue} value    Value to modify.
2231   * @param {boolean}       backward Indicates if are removing from the start
2232   *                                 index or the end index.
2233   *
2234   * @return {RichTextValue|undefined} A new value with the line separator
2235   *                                   removed. Or undefined if no line separator
2236   *                                   is found on the position.
2237   */
2238  
2239  function removeLineSeparator(value, backward = true) {
2240    const {
2241      replacements,
2242      text,
2243      start,
2244      end
2245    } = value;
2246    const collapsed = isCollapsed(value);
2247    let index = start - 1;
2248    let removeStart = collapsed ? start - 1 : start;
2249    let removeEnd = end;
2250  
2251    if (!backward) {
2252      index = end;
2253      removeStart = start;
2254      removeEnd = collapsed ? end + 1 : end;
2255    }
2256  
2257    if (text[index] !== LINE_SEPARATOR) {
2258      return;
2259    }
2260  
2261    let newValue; // If the line separator that is about te be removed
2262    // contains wrappers, remove the wrappers first.
2263  
2264    if (collapsed && replacements[index] && replacements[index].length) {
2265      const newReplacements = replacements.slice();
2266      newReplacements[index] = replacements[index].slice(0, -1);
2267      newValue = { ...value,
2268        replacements: newReplacements
2269      };
2270    } else {
2271      newValue = remove_remove(value, removeStart, removeEnd);
2272    }
2273  
2274    return newValue;
2275  }
2276  
2277  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/insert-object.js
2278  /**
2279   * Internal dependencies
2280   */
2281  
2282  
2283  /** @typedef {import('./create').RichTextValue} RichTextValue */
2284  
2285  /** @typedef {import('./create').RichTextFormat} RichTextFormat */
2286  
2287  /**
2288   * Insert a format as an object into a Rich Text value at the given
2289   * `startIndex`. Any content between `startIndex` and `endIndex` will be
2290   * removed. Indices are retrieved from the selection if none are provided.
2291   *
2292   * @param {RichTextValue}  value          Value to modify.
2293   * @param {RichTextFormat} formatToInsert Format to insert as object.
2294   * @param {number}         [startIndex]   Start index.
2295   * @param {number}         [endIndex]     End index.
2296   *
2297   * @return {RichTextValue} A new value with the object inserted.
2298   */
2299  
2300  function insertObject(value, formatToInsert, startIndex, endIndex) {
2301    const valueToInsert = {
2302      formats: [,],
2303      replacements: [formatToInsert],
2304      text: OBJECT_REPLACEMENT_CHARACTER
2305    };
2306    return insert(value, valueToInsert, startIndex, endIndex);
2307  }
2308  
2309  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/slice.js
2310  /** @typedef {import('./create').RichTextValue} RichTextValue */
2311  
2312  /**
2313   * Slice a Rich Text value from `startIndex` to `endIndex`. Indices are
2314   * retrieved from the selection if none are provided. This is similar to
2315   * `String.prototype.slice`.
2316   *
2317   * @param {RichTextValue} value        Value to modify.
2318   * @param {number}        [startIndex] Start index.
2319   * @param {number}        [endIndex]   End index.
2320   *
2321   * @return {RichTextValue} A new extracted value.
2322   */
2323  function slice(value, startIndex = value.start, endIndex = value.end) {
2324    const {
2325      formats,
2326      replacements,
2327      text
2328    } = value;
2329  
2330    if (startIndex === undefined || endIndex === undefined) {
2331      return { ...value
2332      };
2333    }
2334  
2335    return {
2336      formats: formats.slice(startIndex, endIndex),
2337      replacements: replacements.slice(startIndex, endIndex),
2338      text: text.slice(startIndex, endIndex)
2339    };
2340  }
2341  
2342  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/split.js
2343  /**
2344   * Internal dependencies
2345   */
2346  
2347  /** @typedef {import('./create').RichTextValue} RichTextValue */
2348  
2349  /**
2350   * Split a Rich Text value in two at the given `startIndex` and `endIndex`, or
2351   * split at the given separator. This is similar to `String.prototype.split`.
2352   * Indices are retrieved from the selection if none are provided.
2353   *
2354   * @param {RichTextValue} value
2355   * @param {number|string} [string] Start index, or string at which to split.
2356   *
2357   * @return {Array<RichTextValue>|undefined} An array of new values.
2358   */
2359  
2360  function split({
2361    formats,
2362    replacements,
2363    text,
2364    start,
2365    end
2366  }, string) {
2367    if (typeof string !== 'string') {
2368      return splitAtSelection(...arguments);
2369    }
2370  
2371    let nextStart = 0;
2372    return text.split(string).map(substring => {
2373      const startIndex = nextStart;
2374      const value = {
2375        formats: formats.slice(startIndex, startIndex + substring.length),
2376        replacements: replacements.slice(startIndex, startIndex + substring.length),
2377        text: substring
2378      };
2379      nextStart += string.length + substring.length;
2380  
2381      if (start !== undefined && end !== undefined) {
2382        if (start >= startIndex && start < nextStart) {
2383          value.start = start - startIndex;
2384        } else if (start < startIndex && end > startIndex) {
2385          value.start = 0;
2386        }
2387  
2388        if (end >= startIndex && end < nextStart) {
2389          value.end = end - startIndex;
2390        } else if (start < nextStart && end > nextStart) {
2391          value.end = substring.length;
2392        }
2393      }
2394  
2395      return value;
2396    });
2397  }
2398  
2399  function splitAtSelection({
2400    formats,
2401    replacements,
2402    text,
2403    start,
2404    end
2405  }, startIndex = start, endIndex = end) {
2406    if (start === undefined || end === undefined) {
2407      return;
2408    }
2409  
2410    const before = {
2411      formats: formats.slice(0, startIndex),
2412      replacements: replacements.slice(0, startIndex),
2413      text: text.slice(0, startIndex)
2414    };
2415    const after = {
2416      formats: formats.slice(endIndex),
2417      replacements: replacements.slice(endIndex),
2418      text: text.slice(endIndex),
2419      start: 0,
2420      end: 0
2421    };
2422    return [// Ensure newlines are trimmed.
2423    replace_replace(before, /\u2028+$/, ''), replace_replace(after, /^\u2028+/, '')];
2424  }
2425  
2426  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/get-format-type.js
2427  /**
2428   * WordPress dependencies
2429   */
2430  
2431  /**
2432   * Internal dependencies
2433   */
2434  
2435  
2436  /** @typedef {import('./register-format-type').RichTextFormatType} RichTextFormatType */
2437  
2438  /**
2439   * Returns a registered format type.
2440   *
2441   * @param {string} name Format name.
2442   *
2443   * @return {RichTextFormatType|undefined} Format type.
2444   */
2445  
2446  function get_format_type_getFormatType(name) {
2447    return Object(external_wp_data_["select"])(store).getFormatType(name);
2448  }
2449  
2450  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/to-tree.js
2451  /**
2452   * Internal dependencies
2453   */
2454  
2455  
2456  
2457  
2458  function restoreOnAttributes(attributes, isEditableTree) {
2459    if (isEditableTree) {
2460      return attributes;
2461    }
2462  
2463    const newAttributes = {};
2464  
2465    for (const key in attributes) {
2466      let newKey = key;
2467  
2468      if (key.startsWith('data-disable-rich-text-')) {
2469        newKey = key.slice('data-disable-rich-text-'.length);
2470      }
2471  
2472      newAttributes[newKey] = attributes[key];
2473    }
2474  
2475    return newAttributes;
2476  }
2477  /**
2478   * Converts a format object to information that can be used to create an element
2479   * from (type, attributes and object).
2480   *
2481   * @param  {Object}  $1                        Named parameters.
2482   * @param  {string}  $1.type                   The format type.
2483   * @param  {Object}  $1.attributes             The format attributes.
2484   * @param  {Object}  $1.unregisteredAttributes The unregistered format
2485   *                                             attributes.
2486   * @param  {boolean} $1.object                 Whether or not it is an object
2487   *                                             format.
2488   * @param  {boolean} $1.boundaryClass          Whether or not to apply a boundary
2489   *                                             class.
2490   * @param  {boolean} $1.isEditableTree
2491   *
2492   * @return {Object}                            Information to be used for
2493   *                                             element creation.
2494   */
2495  
2496  
2497  function fromFormat({
2498    type,
2499    attributes,
2500    unregisteredAttributes,
2501    object,
2502    boundaryClass,
2503    isEditableTree
2504  }) {
2505    const formatType = get_format_type_getFormatType(type);
2506    let elementAttributes = {};
2507  
2508    if (boundaryClass) {
2509      elementAttributes['data-rich-text-format-boundary'] = 'true';
2510    }
2511  
2512    if (!formatType) {
2513      if (attributes) {
2514        elementAttributes = { ...attributes,
2515          ...elementAttributes
2516        };
2517      }
2518  
2519      return {
2520        type,
2521        attributes: restoreOnAttributes(elementAttributes, isEditableTree),
2522        object
2523      };
2524    }
2525  
2526    elementAttributes = { ...unregisteredAttributes,
2527      ...elementAttributes
2528    };
2529  
2530    for (const name in attributes) {
2531      const key = formatType.attributes ? formatType.attributes[name] : false;
2532  
2533      if (key) {
2534        elementAttributes[key] = attributes[name];
2535      } else {
2536        elementAttributes[name] = attributes[name];
2537      }
2538    }
2539  
2540    if (formatType.className) {
2541      if (elementAttributes.class) {
2542        elementAttributes.class = `$formatType.className} $elementAttributes.class}`;
2543      } else {
2544        elementAttributes.class = formatType.className;
2545      }
2546    }
2547  
2548    return {
2549      type: formatType.tagName,
2550      object: formatType.object,
2551      attributes: restoreOnAttributes(elementAttributes, isEditableTree)
2552    };
2553  }
2554  /**
2555   * Checks if both arrays of formats up until a certain index are equal.
2556   *
2557   * @param {Array}  a     Array of formats to compare.
2558   * @param {Array}  b     Array of formats to compare.
2559   * @param {number} index Index to check until.
2560   */
2561  
2562  
2563  function isEqualUntil(a, b, index) {
2564    do {
2565      if (a[index] !== b[index]) {
2566        return false;
2567      }
2568    } while (index--);
2569  
2570    return true;
2571  }
2572  
2573  function toTree({
2574    value,
2575    multilineTag,
2576    preserveWhiteSpace,
2577    createEmpty,
2578    append,
2579    getLastChild,
2580    getParent,
2581    isText,
2582    getText,
2583    remove,
2584    appendText,
2585    onStartIndex,
2586    onEndIndex,
2587    isEditableTree,
2588    placeholder
2589  }) {
2590    const {
2591      formats,
2592      replacements,
2593      text,
2594      start,
2595      end
2596    } = value;
2597    const formatsLength = formats.length + 1;
2598    const tree = createEmpty();
2599    const multilineFormat = {
2600      type: multilineTag
2601    };
2602    const activeFormats = getActiveFormats(value);
2603    const deepestActiveFormat = activeFormats[activeFormats.length - 1];
2604    let lastSeparatorFormats;
2605    let lastCharacterFormats;
2606    let lastCharacter; // If we're building a multiline tree, start off with a multiline element.
2607  
2608    if (multilineTag) {
2609      append(append(tree, {
2610        type: multilineTag
2611      }), '');
2612      lastCharacterFormats = lastSeparatorFormats = [multilineFormat];
2613    } else {
2614      append(tree, '');
2615    }
2616  
2617    for (let i = 0; i < formatsLength; i++) {
2618      const character = text.charAt(i);
2619      const shouldInsertPadding = isEditableTree && ( // Pad the line if the line is empty.
2620      !lastCharacter || lastCharacter === LINE_SEPARATOR || // Pad the line if the previous character is a line break, otherwise
2621      // the line break won't be visible.
2622      lastCharacter === '\n');
2623      let characterFormats = formats[i]; // Set multiline tags in queue for building the tree.
2624  
2625      if (multilineTag) {
2626        if (character === LINE_SEPARATOR) {
2627          characterFormats = lastSeparatorFormats = (replacements[i] || []).reduce((accumulator, format) => {
2628            accumulator.push(format, multilineFormat);
2629            return accumulator;
2630          }, [multilineFormat]);
2631        } else {
2632          characterFormats = [...lastSeparatorFormats, ...(characterFormats || [])];
2633        }
2634      }
2635  
2636      let pointer = getLastChild(tree);
2637  
2638      if (shouldInsertPadding && character === LINE_SEPARATOR) {
2639        let node = pointer;
2640  
2641        while (!isText(node)) {
2642          node = getLastChild(node);
2643        }
2644  
2645        append(getParent(node), ZWNBSP);
2646      } // Set selection for the start of line.
2647  
2648  
2649      if (lastCharacter === LINE_SEPARATOR) {
2650        let node = pointer;
2651  
2652        while (!isText(node)) {
2653          node = getLastChild(node);
2654        }
2655  
2656        if (onStartIndex && start === i) {
2657          onStartIndex(tree, node);
2658        }
2659  
2660        if (onEndIndex && end === i) {
2661          onEndIndex(tree, node);
2662        }
2663      }
2664  
2665      if (characterFormats) {
2666        characterFormats.forEach((format, formatIndex) => {
2667          if (pointer && lastCharacterFormats && // Reuse the last element if all formats remain the same.
2668          isEqualUntil(characterFormats, lastCharacterFormats, formatIndex) && ( // Do not reuse the last element if the character is a
2669          // line separator.
2670          character !== LINE_SEPARATOR || characterFormats.length - 1 !== formatIndex)) {
2671            pointer = getLastChild(pointer);
2672            return;
2673          }
2674  
2675          const {
2676            type,
2677            attributes,
2678            unregisteredAttributes
2679          } = format;
2680          const boundaryClass = isEditableTree && character !== LINE_SEPARATOR && format === deepestActiveFormat;
2681          const parent = getParent(pointer);
2682          const newNode = append(parent, fromFormat({
2683            type,
2684            attributes,
2685            unregisteredAttributes,
2686            boundaryClass,
2687            isEditableTree
2688          }));
2689  
2690          if (isText(pointer) && getText(pointer).length === 0) {
2691            remove(pointer);
2692          }
2693  
2694          pointer = append(newNode, '');
2695        });
2696      } // No need for further processing if the character is a line separator.
2697  
2698  
2699      if (character === LINE_SEPARATOR) {
2700        lastCharacterFormats = characterFormats;
2701        lastCharacter = character;
2702        continue;
2703      } // If there is selection at 0, handle it before characters are inserted.
2704  
2705  
2706      if (i === 0) {
2707        if (onStartIndex && start === 0) {
2708          onStartIndex(tree, pointer);
2709        }
2710  
2711        if (onEndIndex && end === 0) {
2712          onEndIndex(tree, pointer);
2713        }
2714      }
2715  
2716      if (character === OBJECT_REPLACEMENT_CHARACTER) {
2717        if (!isEditableTree && replacements[i].type === 'script') {
2718          pointer = append(getParent(pointer), fromFormat({
2719            type: 'script',
2720            isEditableTree
2721          }));
2722          append(pointer, {
2723            html: decodeURIComponent(replacements[i].attributes['data-rich-text-script'])
2724          });
2725        } else {
2726          pointer = append(getParent(pointer), fromFormat({ ...replacements[i],
2727            object: true,
2728            isEditableTree
2729          }));
2730        } // Ensure pointer is text node.
2731  
2732  
2733        pointer = append(getParent(pointer), '');
2734      } else if (!preserveWhiteSpace && character === '\n') {
2735        pointer = append(getParent(pointer), {
2736          type: 'br',
2737          attributes: isEditableTree ? {
2738            'data-rich-text-line-break': 'true'
2739          } : undefined,
2740          object: true
2741        }); // Ensure pointer is text node.
2742  
2743        pointer = append(getParent(pointer), '');
2744      } else if (!isText(pointer)) {
2745        pointer = append(getParent(pointer), character);
2746      } else {
2747        appendText(pointer, character);
2748      }
2749  
2750      if (onStartIndex && start === i + 1) {
2751        onStartIndex(tree, pointer);
2752      }
2753  
2754      if (onEndIndex && end === i + 1) {
2755        onEndIndex(tree, pointer);
2756      }
2757  
2758      if (shouldInsertPadding && i === text.length) {
2759        append(getParent(pointer), ZWNBSP);
2760  
2761        if (placeholder && text.length === 0) {
2762          append(getParent(pointer), {
2763            type: 'span',
2764            attributes: {
2765              'data-rich-text-placeholder': placeholder,
2766              // Necessary to prevent the placeholder from catching
2767              // selection. The placeholder is also not editable after
2768              // all.
2769              contenteditable: 'false',
2770              style: 'pointer-events:none;user-select:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;'
2771            }
2772          });
2773        }
2774      }
2775  
2776      lastCharacterFormats = characterFormats;
2777      lastCharacter = character;
2778    }
2779  
2780    return tree;
2781  }
2782  
2783  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/to-dom.js
2784  /**
2785   * Internal dependencies
2786   */
2787  
2788  
2789  /** @typedef {import('./create').RichTextValue} RichTextValue */
2790  
2791  /**
2792   * Creates a path as an array of indices from the given root node to the given
2793   * node.
2794   *
2795   * @param {Node}        node     Node to find the path of.
2796   * @param {HTMLElement} rootNode Root node to find the path from.
2797   * @param {Array}       path     Initial path to build on.
2798   *
2799   * @return {Array} The path from the root node to the node.
2800   */
2801  
2802  function createPathToNode(node, rootNode, path) {
2803    const parentNode = node.parentNode;
2804    let i = 0;
2805  
2806    while (node = node.previousSibling) {
2807      i++;
2808    }
2809  
2810    path = [i, ...path];
2811  
2812    if (parentNode !== rootNode) {
2813      path = createPathToNode(parentNode, rootNode, path);
2814    }
2815  
2816    return path;
2817  }
2818  /**
2819   * Gets a node given a path (array of indices) from the given node.
2820   *
2821   * @param {HTMLElement} node Root node to find the wanted node in.
2822   * @param {Array}       path Path (indices) to the wanted node.
2823   *
2824   * @return {Object} Object with the found node and the remaining offset (if any).
2825   */
2826  
2827  
2828  function getNodeByPath(node, path) {
2829    path = [...path];
2830  
2831    while (node && path.length > 1) {
2832      node = node.childNodes[path.shift()];
2833    }
2834  
2835    return {
2836      node,
2837      offset: path[0]
2838    };
2839  }
2840  
2841  function to_dom_append(element, child) {
2842    if (typeof child === 'string') {
2843      child = element.ownerDocument.createTextNode(child);
2844    }
2845  
2846    const {
2847      type,
2848      attributes
2849    } = child;
2850  
2851    if (type) {
2852      child = element.ownerDocument.createElement(type);
2853  
2854      for (const key in attributes) {
2855        child.setAttribute(key, attributes[key]);
2856      }
2857    }
2858  
2859    return element.appendChild(child);
2860  }
2861  
2862  function to_dom_appendText(node, text) {
2863    node.appendData(text);
2864  }
2865  
2866  function to_dom_getLastChild({
2867    lastChild
2868  }) {
2869    return lastChild;
2870  }
2871  
2872  function to_dom_getParent({
2873    parentNode
2874  }) {
2875    return parentNode;
2876  }
2877  
2878  function to_dom_isText(node) {
2879    return node.nodeType === node.TEXT_NODE;
2880  }
2881  
2882  function to_dom_getText({
2883    nodeValue
2884  }) {
2885    return nodeValue;
2886  }
2887  
2888  function to_dom_remove(node) {
2889    return node.parentNode.removeChild(node);
2890  }
2891  
2892  function toDom({
2893    value,
2894    multilineTag,
2895    prepareEditableTree,
2896    isEditableTree = true,
2897    placeholder,
2898    doc = document
2899  }) {
2900    let startPath = [];
2901    let endPath = [];
2902  
2903    if (prepareEditableTree) {
2904      value = { ...value,
2905        formats: prepareEditableTree(value)
2906      };
2907    }
2908    /**
2909     * Returns a new instance of a DOM tree upon which RichText operations can be
2910     * applied.
2911     *
2912     * Note: The current implementation will return a shared reference, reset on
2913     * each call to `createEmpty`. Therefore, you should not hold a reference to
2914     * the value to operate upon asynchronously, as it may have unexpected results.
2915     *
2916     * @return {Object} RichText tree.
2917     */
2918  
2919  
2920    const createEmpty = () => createElement(doc, '');
2921  
2922    const tree = toTree({
2923      value,
2924      multilineTag,
2925      createEmpty,
2926      append: to_dom_append,
2927      getLastChild: to_dom_getLastChild,
2928      getParent: to_dom_getParent,
2929      isText: to_dom_isText,
2930      getText: to_dom_getText,
2931      remove: to_dom_remove,
2932      appendText: to_dom_appendText,
2933  
2934      onStartIndex(body, pointer) {
2935        startPath = createPathToNode(pointer, body, [pointer.nodeValue.length]);
2936      },
2937  
2938      onEndIndex(body, pointer) {
2939        endPath = createPathToNode(pointer, body, [pointer.nodeValue.length]);
2940      },
2941  
2942      isEditableTree,
2943      placeholder
2944    });
2945    return {
2946      body: tree,
2947      selection: {
2948        startPath,
2949        endPath
2950      }
2951    };
2952  }
2953  /**
2954   * Create an `Element` tree from a Rich Text value and applies the difference to
2955   * the `Element` tree contained by `current`. If a `multilineTag` is provided,
2956   * text separated by two new lines will be wrapped in an `Element` of that type.
2957   *
2958   * @param {Object}        $1                       Named arguments.
2959   * @param {RichTextValue} $1.value                 Value to apply.
2960   * @param {HTMLElement}   $1.current               The live root node to apply the element tree to.
2961   * @param {string}        [$1.multilineTag]        Multiline tag.
2962   * @param {Function}      [$1.prepareEditableTree] Function to filter editorable formats.
2963   * @param {boolean}       [$1.__unstableDomOnly]   Only apply elements, no selection.
2964   * @param {string}        [$1.placeholder]         Placeholder text.
2965   */
2966  
2967  function apply({
2968    value,
2969    current,
2970    multilineTag,
2971    prepareEditableTree,
2972    __unstableDomOnly,
2973    placeholder
2974  }) {
2975    // Construct a new element tree in memory.
2976    const {
2977      body,
2978      selection
2979    } = toDom({
2980      value,
2981      multilineTag,
2982      prepareEditableTree,
2983      placeholder,
2984      doc: current.ownerDocument
2985    });
2986    applyValue(body, current);
2987  
2988    if (value.start !== undefined && !__unstableDomOnly) {
2989      applySelection(selection, current);
2990    }
2991  }
2992  function applyValue(future, current) {
2993    let i = 0;
2994    let futureChild;
2995  
2996    while (futureChild = future.firstChild) {
2997      const currentChild = current.childNodes[i];
2998  
2999      if (!currentChild) {
3000        current.appendChild(futureChild);
3001      } else if (!currentChild.isEqualNode(futureChild)) {
3002        if (currentChild.nodeName !== futureChild.nodeName || currentChild.nodeType === currentChild.TEXT_NODE && currentChild.data !== futureChild.data) {
3003          current.replaceChild(futureChild, currentChild);
3004        } else {
3005          const currentAttributes = currentChild.attributes;
3006          const futureAttributes = futureChild.attributes;
3007  
3008          if (currentAttributes) {
3009            let ii = currentAttributes.length; // Reverse loop because `removeAttribute` on `currentChild`
3010            // changes `currentAttributes`.
3011  
3012            while (ii--) {
3013              const {
3014                name
3015              } = currentAttributes[ii];
3016  
3017              if (!futureChild.getAttribute(name)) {
3018                currentChild.removeAttribute(name);
3019              }
3020            }
3021          }
3022  
3023          if (futureAttributes) {
3024            for (let ii = 0; ii < futureAttributes.length; ii++) {
3025              const {
3026                name,
3027                value
3028              } = futureAttributes[ii];
3029  
3030              if (currentChild.getAttribute(name) !== value) {
3031                currentChild.setAttribute(name, value);
3032              }
3033            }
3034          }
3035  
3036          applyValue(futureChild, currentChild);
3037          future.removeChild(futureChild);
3038        }
3039      } else {
3040        future.removeChild(futureChild);
3041      }
3042  
3043      i++;
3044    }
3045  
3046    while (current.childNodes[i]) {
3047      current.removeChild(current.childNodes[i]);
3048    }
3049  }
3050  /**
3051   * Returns true if two ranges are equal, or false otherwise. Ranges are
3052   * considered equal if their start and end occur in the same container and
3053   * offset.
3054   *
3055   * @param {Range} a First range object to test.
3056   * @param {Range} b First range object to test.
3057   *
3058   * @return {boolean} Whether the two ranges are equal.
3059   */
3060  
3061  function isRangeEqual(a, b) {
3062    return a.startContainer === b.startContainer && a.startOffset === b.startOffset && a.endContainer === b.endContainer && a.endOffset === b.endOffset;
3063  }
3064  
3065  function applySelection({
3066    startPath,
3067    endPath
3068  }, current) {
3069    const {
3070      node: startContainer,
3071      offset: startOffset
3072    } = getNodeByPath(current, startPath);
3073    const {
3074      node: endContainer,
3075      offset: endOffset
3076    } = getNodeByPath(current, endPath);
3077    const {
3078      ownerDocument
3079    } = current;
3080    const {
3081      defaultView
3082    } = ownerDocument;
3083    const selection = defaultView.getSelection();
3084    const range = ownerDocument.createRange();
3085    range.setStart(startContainer, startOffset);
3086    range.setEnd(endContainer, endOffset);
3087    const {
3088      activeElement
3089    } = ownerDocument;
3090  
3091    if (selection.rangeCount > 0) {
3092      // If the to be added range and the live range are the same, there's no
3093      // need to remove the live range and add the equivalent range.
3094      if (isRangeEqual(range, selection.getRangeAt(0))) {
3095        return;
3096      }
3097  
3098      selection.removeAllRanges();
3099    }
3100  
3101    selection.addRange(range); // This function is not intended to cause a shift in focus. Since the above
3102    // selection manipulations may shift focus, ensure that focus is restored to
3103    // its previous state.
3104  
3105    if (activeElement !== ownerDocument.activeElement) {
3106      // The `instanceof` checks protect against edge cases where the focused
3107      // element is not of the interface HTMLElement (does not have a `focus`
3108      // or `blur` property).
3109      //
3110      // See: https://github.com/Microsoft/TypeScript/issues/5901#issuecomment-431649653
3111      if (activeElement instanceof defaultView.HTMLElement) {
3112        activeElement.focus();
3113      }
3114    }
3115  }
3116  
3117  // EXTERNAL MODULE: external ["wp","escapeHtml"]
3118  var external_wp_escapeHtml_ = __webpack_require__("Vx3V");
3119  
3120  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/to-html-string.js
3121  /**
3122   * WordPress dependencies
3123   */
3124  
3125  /**
3126   * Internal dependencies
3127   */
3128  
3129  
3130  /** @typedef {import('./create').RichTextValue} RichTextValue */
3131  
3132  /**
3133   * Create an HTML string from a Rich Text value. If a `multilineTag` is
3134   * provided, text separated by a line separator will be wrapped in it.
3135   *
3136   * @param {Object}        $1                      Named argements.
3137   * @param {RichTextValue} $1.value                Rich text value.
3138   * @param {string}        [$1.multilineTag]       Multiline tag.
3139   * @param {boolean}       [$1.preserveWhiteSpace] Whether or not to use newline
3140   *                                                characters for line breaks.
3141   *
3142   * @return {string} HTML string.
3143   */
3144  
3145  function toHTMLString({
3146    value,
3147    multilineTag,
3148    preserveWhiteSpace
3149  }) {
3150    const tree = toTree({
3151      value,
3152      multilineTag,
3153      preserveWhiteSpace,
3154      createEmpty: to_html_string_createEmpty,
3155      append: to_html_string_append,
3156      getLastChild: to_html_string_getLastChild,
3157      getParent: to_html_string_getParent,
3158      isText: to_html_string_isText,
3159      getText: to_html_string_getText,
3160      remove: to_html_string_remove,
3161      appendText: to_html_string_appendText
3162    });
3163    return createChildrenHTML(tree.children);
3164  }
3165  
3166  function to_html_string_createEmpty() {
3167    return {};
3168  }
3169  
3170  function to_html_string_getLastChild({
3171    children
3172  }) {
3173    return children && children[children.length - 1];
3174  }
3175  
3176  function to_html_string_append(parent, object) {
3177    if (typeof object === 'string') {
3178      object = {
3179        text: object
3180      };
3181    }
3182  
3183    object.parent = parent;
3184    parent.children = parent.children || [];
3185    parent.children.push(object);
3186    return object;
3187  }
3188  
3189  function to_html_string_appendText(object, text) {
3190    object.text += text;
3191  }
3192  
3193  function to_html_string_getParent({
3194    parent
3195  }) {
3196    return parent;
3197  }
3198  
3199  function to_html_string_isText({
3200    text
3201  }) {
3202    return typeof text === 'string';
3203  }
3204  
3205  function to_html_string_getText({
3206    text
3207  }) {
3208    return text;
3209  }
3210  
3211  function to_html_string_remove(object) {
3212    const index = object.parent.children.indexOf(object);
3213  
3214    if (index !== -1) {
3215      object.parent.children.splice(index, 1);
3216    }
3217  
3218    return object;
3219  }
3220  
3221  function createElementHTML({
3222    type,
3223    attributes,
3224    object,
3225    children
3226  }) {
3227    let attributeString = '';
3228  
3229    for (const key in attributes) {
3230      if (!Object(external_wp_escapeHtml_["isValidAttributeName"])(key)) {
3231        continue;
3232      }
3233  
3234      attributeString += ` $key}="$Object(external_wp_escapeHtml_["escapeAttribute"])(attributes[key])}"`;
3235    }
3236  
3237    if (object) {
3238      return `<$type}$attributeString}>`;
3239    }
3240  
3241    return `<$type}$attributeString}>$createChildrenHTML(children)}</$type}>`;
3242  }
3243  
3244  function createChildrenHTML(children = []) {
3245    return children.map(child => {
3246      if (child.html !== undefined) {
3247        return child.html;
3248      }
3249  
3250      return child.text === undefined ? createElementHTML(child) : Object(external_wp_escapeHtml_["escapeEditableHTML"])(child.text);
3251    }).join('');
3252  }
3253  
3254  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/toggle-format.js
3255  /**
3256   * Internal dependencies
3257   */
3258  
3259  
3260  
3261  /** @typedef {import('./create').RichTextValue} RichTextValue */
3262  
3263  /** @typedef {import('./create').RichTextFormat} RichTextFormat */
3264  
3265  /**
3266   * Toggles a format object to a Rich Text value at the current selection.
3267   *
3268   * @param {RichTextValue}  value  Value to modify.
3269   * @param {RichTextFormat} format Format to apply or remove.
3270   *
3271   * @return {RichTextValue} A new value with the format applied or removed.
3272   */
3273  
3274  function toggleFormat(value, format) {
3275    if (getActiveFormat(value, format.type)) {
3276      return removeFormat(value, format.type);
3277    }
3278  
3279    return applyFormat(value, format);
3280  }
3281  
3282  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/unregister-format-type.js
3283  /**
3284   * WordPress dependencies
3285   */
3286  
3287  /**
3288   * Internal dependencies
3289   */
3290  
3291  
3292  /** @typedef {import('./register-format-type').RichTextFormatType} RichTextFormatType */
3293  
3294  /**
3295   * Unregisters a format.
3296   *
3297   * @param {string} name Format name.
3298   *
3299   * @return {RichTextFormatType|undefined} The previous format value, if it has
3300   *                                        been successfully unregistered;
3301   *                                        otherwise `undefined`.
3302   */
3303  
3304  function unregisterFormatType(name) {
3305    const oldFormat = Object(external_wp_data_["select"])(store).getFormatType(name);
3306  
3307    if (!oldFormat) {
3308      window.console.error(`Format $name} is not registered.`);
3309      return;
3310    }
3311  
3312    Object(external_wp_data_["dispatch"])(store).removeFormatTypes(name);
3313    return oldFormat;
3314  }
3315  
3316  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/can-indent-list-items.js
3317  /**
3318   * Internal dependencies
3319   */
3320  
3321  /** @typedef {import('./create').RichTextValue} RichTextValue */
3322  
3323  /**
3324   * Checks if the selected list item can be indented.
3325   *
3326   * @param {RichTextValue} value Value to check.
3327   *
3328   * @return {boolean} Whether or not the selected list item can be indented.
3329   */
3330  
3331  function canIndentListItems(value) {
3332    const lineIndex = getLineIndex(value); // There is only one line, so the line cannot be indented.
3333  
3334    if (lineIndex === undefined) {
3335      return false;
3336    }
3337  
3338    const {
3339      replacements
3340    } = value;
3341    const previousLineIndex = getLineIndex(value, lineIndex);
3342    const formatsAtLineIndex = replacements[lineIndex] || [];
3343    const formatsAtPreviousLineIndex = replacements[previousLineIndex] || []; // If the indentation of the current line is greater than previous line,
3344    // then the line cannot be furter indented.
3345  
3346    return formatsAtLineIndex.length <= formatsAtPreviousLineIndex.length;
3347  }
3348  
3349  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/can-outdent-list-items.js
3350  /**
3351   * Internal dependencies
3352   */
3353  
3354  /** @typedef {import('./create').RichTextValue} RichTextValue */
3355  
3356  /**
3357   * Checks if the selected list item can be outdented.
3358   *
3359   * @param {RichTextValue} value Value to check.
3360   *
3361   * @return {boolean} Whether or not the selected list item can be outdented.
3362   */
3363  
3364  function canOutdentListItems(value) {
3365    const {
3366      replacements,
3367      start
3368    } = value;
3369    const startingLineIndex = getLineIndex(value, start);
3370    return replacements[startingLineIndex] !== undefined;
3371  }
3372  
3373  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/indent-list-items.js
3374  /**
3375   * Internal dependencies
3376   */
3377  
3378  
3379  
3380  /** @typedef {import('./create').RichTextValue} RichTextValue */
3381  
3382  /** @typedef {import('./create').RichTextFormat} RichTextFormat */
3383  
3384  /**
3385   * Gets the line index of the first previous list item with higher indentation.
3386   *
3387   * @param {RichTextValue} value      Value to search.
3388   * @param {number}        lineIndex  Line index of the list item to compare
3389   *                                   with.
3390   *
3391   * @return {number|void} The line index.
3392   */
3393  
3394  function getTargetLevelLineIndex({
3395    text,
3396    replacements
3397  }, lineIndex) {
3398    const startFormats = replacements[lineIndex] || [];
3399    let index = lineIndex;
3400  
3401    while (index-- >= 0) {
3402      if (text[index] !== LINE_SEPARATOR) {
3403        continue;
3404      }
3405  
3406      const formatsAtIndex = replacements[index] || []; // Return the first line index that is one level higher. If the level is
3407      // lower or equal, there is no result.
3408  
3409      if (formatsAtIndex.length === startFormats.length + 1) {
3410        return index;
3411      } else if (formatsAtIndex.length <= startFormats.length) {
3412        return;
3413      }
3414    }
3415  }
3416  /**
3417   * Indents any selected list items if possible.
3418   *
3419   * @param {RichTextValue}  value      Value to change.
3420   * @param {RichTextFormat} rootFormat Root format.
3421   *
3422   * @return {RichTextValue} The changed value.
3423   */
3424  
3425  
3426  function indentListItems(value, rootFormat) {
3427    if (!canIndentListItems(value)) {
3428      return value;
3429    }
3430  
3431    const lineIndex = getLineIndex(value);
3432    const previousLineIndex = getLineIndex(value, lineIndex);
3433    const {
3434      text,
3435      replacements,
3436      end
3437    } = value;
3438    const newFormats = replacements.slice();
3439    const targetLevelLineIndex = getTargetLevelLineIndex(value, lineIndex);
3440  
3441    for (let index = lineIndex; index < end; index++) {
3442      if (text[index] !== LINE_SEPARATOR) {
3443        continue;
3444      } // Get the previous list, and if there's a child list, take over the
3445      // formats. If not, duplicate the last level and create a new level.
3446  
3447  
3448      if (targetLevelLineIndex) {
3449        const targetFormats = replacements[targetLevelLineIndex] || [];
3450        newFormats[index] = targetFormats.concat((newFormats[index] || []).slice(targetFormats.length - 1));
3451      } else {
3452        const targetFormats = replacements[previousLineIndex] || [];
3453        const lastformat = targetFormats[targetFormats.length - 1] || rootFormat;
3454        newFormats[index] = targetFormats.concat([lastformat], (newFormats[index] || []).slice(targetFormats.length));
3455      }
3456    }
3457  
3458    return { ...value,
3459      replacements: newFormats
3460    };
3461  }
3462  
3463  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/get-parent-line-index.js
3464  /**
3465   * Internal dependencies
3466   */
3467  
3468  /** @typedef {import('./create').RichTextValue} RichTextValue */
3469  
3470  /**
3471   * Gets the index of the first parent list. To get the parent list formats, we
3472   * go through every list item until we find one with exactly one format type
3473   * less.
3474   *
3475   * @param {RichTextValue} value     Value to search.
3476   * @param {number}        lineIndex Line index of a child list item.
3477   *
3478   * @return {number|void} The parent list line index.
3479   */
3480  
3481  function getParentLineIndex({
3482    text,
3483    replacements
3484  }, lineIndex) {
3485    const startFormats = replacements[lineIndex] || [];
3486    let index = lineIndex;
3487  
3488    while (index-- >= 0) {
3489      if (text[index] !== LINE_SEPARATOR) {
3490        continue;
3491      }
3492  
3493      const formatsAtIndex = replacements[index] || [];
3494  
3495      if (formatsAtIndex.length === startFormats.length - 1) {
3496        return index;
3497      }
3498    }
3499  }
3500  
3501  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/get-last-child-index.js
3502  /**
3503   * Internal dependencies
3504   */
3505  
3506  /** @typedef {import('./create').RichTextValue} RichTextValue */
3507  
3508  /**
3509   * Gets the line index of the last child in the list.
3510   *
3511   * @param {RichTextValue} value     Value to search.
3512   * @param {number}        lineIndex Line index of a list item in the list.
3513   *
3514   * @return {number} The index of the last child.
3515   */
3516  
3517  function getLastChildIndex({
3518    text,
3519    replacements
3520  }, lineIndex) {
3521    const lineFormats = replacements[lineIndex] || []; // Use the given line index in case there are no next children.
3522  
3523    let childIndex = lineIndex; // `lineIndex` could be `undefined` if it's the first line.
3524  
3525    for (let index = lineIndex || 0; index < text.length; index++) {
3526      // We're only interested in line indices.
3527      if (text[index] !== LINE_SEPARATOR) {
3528        continue;
3529      }
3530  
3531      const formatsAtIndex = replacements[index] || []; // If the amout of formats is equal or more, store it, then return the
3532      // last one if the amount of formats is less.
3533  
3534      if (formatsAtIndex.length >= lineFormats.length) {
3535        childIndex = index;
3536      } else {
3537        return childIndex;
3538      }
3539    } // If the end of the text is reached, return the last child index.
3540  
3541  
3542    return childIndex;
3543  }
3544  
3545  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/outdent-list-items.js
3546  /**
3547   * Internal dependencies
3548   */
3549  
3550  
3551  
3552  
3553  
3554  /** @typedef {import('./create').RichTextValue} RichTextValue */
3555  
3556  /**
3557   * Outdents any selected list items if possible.
3558   *
3559   * @param {RichTextValue} value Value to change.
3560   *
3561   * @return {RichTextValue} The changed value.
3562   */
3563  
3564  function outdentListItems(value) {
3565    if (!canOutdentListItems(value)) {
3566      return value;
3567    }
3568  
3569    const {
3570      text,
3571      replacements,
3572      start,
3573      end
3574    } = value;
3575    const startingLineIndex = getLineIndex(value, start);
3576    const newFormats = replacements.slice(0);
3577    const parentFormats = replacements[getParentLineIndex(value, startingLineIndex)] || [];
3578    const endingLineIndex = getLineIndex(value, end);
3579    const lastChildIndex = getLastChildIndex(value, endingLineIndex); // Outdent all list items from the starting line index until the last child
3580    // index of the ending list. All children of the ending list need to be
3581    // outdented, otherwise they'll be orphaned.
3582  
3583    for (let index = startingLineIndex; index <= lastChildIndex; index++) {
3584      // Skip indices that are not line separators.
3585      if (text[index] !== LINE_SEPARATOR) {
3586        continue;
3587      } // In the case of level 0, the formats at the index are undefined.
3588  
3589  
3590      const currentFormats = newFormats[index] || []; // Omit the indentation level where the selection starts.
3591  
3592      newFormats[index] = parentFormats.concat(currentFormats.slice(parentFormats.length + 1));
3593  
3594      if (newFormats[index].length === 0) {
3595        delete newFormats[index];
3596      }
3597    }
3598  
3599    return { ...value,
3600      replacements: newFormats
3601    };
3602  }
3603  
3604  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/change-list-type.js
3605  /**
3606   * Internal dependencies
3607   */
3608  
3609  
3610  
3611  /** @typedef {import('./create').RichTextValue} RichTextValue */
3612  
3613  /** @typedef {import('./create').RichTextFormat} RichTextFormat */
3614  
3615  /**
3616   * Changes the list type of the selected indented list, if any. Looks at the
3617   * currently selected list item and takes the parent list, then changes the list
3618   * type of this list. When multiple lines are selected, the parent lists are
3619   * takes and changed.
3620   *
3621   * @param {RichTextValue}  value     Value to change.
3622   * @param {RichTextFormat} newFormat The new list format object. Choose between
3623   *                                   `{ type: 'ol' }` and `{ type: 'ul' }`.
3624   *
3625   * @return {RichTextValue} The changed value.
3626   */
3627  
3628  function changeListType(value, newFormat) {
3629    const {
3630      text,
3631      replacements,
3632      start,
3633      end
3634    } = value;
3635    const startingLineIndex = getLineIndex(value, start);
3636    const startLineFormats = replacements[startingLineIndex] || [];
3637    const endLineFormats = replacements[getLineIndex(value, end)] || [];
3638    const startIndex = getParentLineIndex(value, startingLineIndex);
3639    const newReplacements = replacements.slice();
3640    const startCount = startLineFormats.length - 1;
3641    const endCount = endLineFormats.length - 1;
3642    let changed;
3643  
3644    for (let index = startIndex + 1 || 0; index < text.length; index++) {
3645      if (text[index] !== LINE_SEPARATOR) {
3646        continue;
3647      }
3648  
3649      if ((newReplacements[index] || []).length <= startCount) {
3650        break;
3651      }
3652  
3653      if (!newReplacements[index]) {
3654        continue;
3655      }
3656  
3657      changed = true;
3658      newReplacements[index] = newReplacements[index].map((format, i) => {
3659        return i < startCount || i > endCount ? format : newFormat;
3660      });
3661    }
3662  
3663    if (!changed) {
3664      return value;
3665    }
3666  
3667    return { ...value,
3668      replacements: newReplacements
3669    };
3670  }
3671  
3672  // EXTERNAL MODULE: external ["wp","element"]
3673  var external_wp_element_ = __webpack_require__("GRId");
3674  
3675  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/component/use-anchor-ref.js
3676  /**
3677   * WordPress dependencies
3678   */
3679  
3680  /**
3681   * Internal dependencies
3682   */
3683  
3684  
3685  /** @typedef {import('@wordpress/element').RefObject} RefObject */
3686  
3687  /** @typedef {import('../register-format-type').RichTextFormatType} RichTextFormatType */
3688  
3689  /** @typedef {import('../create').RichTextValue} RichTextValue */
3690  
3691  /**
3692   * This hook, to be used in a format type's Edit component, returns the active
3693   * element that is formatted, or the selection range if no format is active.
3694   * The returned value is meant to be used for positioning UI, e.g. by passing it
3695   * to the `Popover` component.
3696   *
3697   * @param {Object}                 $1          Named parameters.
3698   * @param {RefObject<HTMLElement>} $1.ref      React ref of the element
3699   *                                             containing  the editable content.
3700   * @param {RichTextValue}          $1.value    Value to check for selection.
3701   * @param {RichTextFormatType}     $1.settings The format type's settings.
3702   *
3703   * @return {Element|Range} The active element or selection range.
3704   */
3705  
3706  function useAnchorRef({
3707    ref,
3708    value,
3709    settings = {}
3710  }) {
3711    const {
3712      tagName,
3713      className,
3714      name
3715    } = settings;
3716    const activeFormat = name ? getActiveFormat(value, name) : undefined;
3717    return Object(external_wp_element_["useMemo"])(() => {
3718      if (!ref.current) return;
3719      const {
3720        ownerDocument: {
3721          defaultView
3722        }
3723      } = ref.current;
3724      const selection = defaultView.getSelection();
3725  
3726      if (!selection.rangeCount) {
3727        return;
3728      }
3729  
3730      const range = selection.getRangeAt(0);
3731  
3732      if (!activeFormat) {
3733        return range;
3734      }
3735  
3736      let element = range.startContainer; // If the caret is right before the element, select the next element.
3737  
3738      element = element.nextElementSibling || element;
3739  
3740      while (element.nodeType !== element.ELEMENT_NODE) {
3741        element = element.parentNode;
3742      }
3743  
3744      return element.closest(tagName + (className ? '.' + className : ''));
3745    }, [activeFormat, value.start, value.end, tagName, className]);
3746  }
3747  
3748  // EXTERNAL MODULE: external ["wp","compose"]
3749  var external_wp_compose_ = __webpack_require__("K9lf");
3750  
3751  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/component/use-default-style.js
3752  /**
3753   * WordPress dependencies
3754   */
3755  
3756  /**
3757   * In HTML, leading and trailing spaces are not visible, and multiple spaces
3758   * elsewhere are visually reduced to one space. This rule prevents spaces from
3759   * collapsing so all space is visible in the editor and can be removed. It also
3760   * prevents some browsers from inserting non-breaking spaces at the end of a
3761   * line to prevent the space from visually disappearing. Sometimes these non
3762   * breaking spaces can linger in the editor causing unwanted non breaking spaces
3763   * in between words. If also prevent Firefox from inserting a trailing `br` node
3764   * to visualise any trailing space, causing the element to be saved.
3765   *
3766   * > Authors are encouraged to set the 'white-space' property on editing hosts
3767   * > and on markup that was originally created through these editing mechanisms
3768   * > to the value 'pre-wrap'. Default HTML whitespace handling is not well
3769   * > suited to WYSIWYG editing, and line wrapping will not work correctly in
3770   * > some corner cases if 'white-space' is left at its default value.
3771   *
3772   * https://html.spec.whatwg.org/multipage/interaction.html#best-practices-for-in-page-editors
3773   *
3774   * @type {string}
3775   */
3776  
3777  const whiteSpace = 'pre-wrap';
3778  /**
3779   * A minimum width of 1px will prevent the rich text container from collapsing
3780   * to 0 width and hiding the caret. This is useful for inline containers.
3781   */
3782  
3783  const minWidth = '1px';
3784  function useDefaultStyle() {
3785    return Object(external_wp_element_["useCallback"])(element => {
3786      if (!element) return;
3787      element.style.whiteSpace = whiteSpace;
3788      element.style.minWidth = minWidth;
3789    }, []);
3790  }
3791  
3792  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/component/use-boundary-style.js
3793  /**
3794   * WordPress dependencies
3795   */
3796  
3797  /*
3798   * Calculates and renders the format boundary style when the active formats
3799   * change.
3800   */
3801  
3802  function useBoundaryStyle({
3803    record
3804  }) {
3805    const ref = Object(external_wp_element_["useRef"])();
3806    const {
3807      activeFormats = []
3808    } = record.current;
3809    Object(external_wp_element_["useEffect"])(() => {
3810      // There's no need to recalculate the boundary styles if no formats are
3811      // active, because no boundary styles will be visible.
3812      if (!activeFormats || !activeFormats.length) {
3813        return;
3814      }
3815  
3816      const boundarySelector = '*[data-rich-text-format-boundary]';
3817      const element = ref.current.querySelector(boundarySelector);
3818  
3819      if (!element) {
3820        return;
3821      }
3822  
3823      const {
3824        ownerDocument
3825      } = element;
3826      const {
3827        defaultView
3828      } = ownerDocument;
3829      const computedStyle = defaultView.getComputedStyle(element);
3830      const newColor = computedStyle.color.replace(')', ', 0.2)').replace('rgb', 'rgba');
3831      const selector = `.rich-text:focus $boundarySelector}`;
3832      const rule = `background-color: $newColor}`;
3833      const style = `$selector} {$rule}}`;
3834      const globalStyleId = 'rich-text-boundary-style';
3835      let globalStyle = ownerDocument.getElementById(globalStyleId);
3836  
3837      if (!globalStyle) {
3838        globalStyle = ownerDocument.createElement('style');
3839        globalStyle.id = globalStyleId;
3840        ownerDocument.head.appendChild(globalStyle);
3841      }
3842  
3843      if (globalStyle.innerHTML !== style) {
3844        globalStyle.innerHTML = style;
3845      }
3846    }, [activeFormats]);
3847    return ref;
3848  }
3849  
3850  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/component/use-inline-warning.js
3851  /**
3852   * WordPress dependencies
3853   */
3854  
3855  const message = 'RichText cannot be used with an inline container. Please use a different display property.';
3856  function useInlineWarning() {
3857    const ref = Object(external_wp_element_["useRef"])();
3858    Object(external_wp_element_["useEffect"])(() => {
3859      if (false) {}
3860    }, []);
3861    return ref;
3862  }
3863  
3864  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/component/use-copy-handler.js
3865  /**
3866   * WordPress dependencies
3867   */
3868  
3869  
3870  /**
3871   * Internal dependencies
3872   */
3873  
3874  
3875  
3876  
3877  
3878  function useCopyHandler(props) {
3879    const propsRef = Object(external_wp_element_["useRef"])(props);
3880    propsRef.current = props;
3881    return Object(external_wp_compose_["useRefEffect"])(element => {
3882      function onCopy(event) {
3883        const {
3884          record,
3885          multilineTag,
3886          preserveWhiteSpace
3887        } = propsRef.current;
3888  
3889        if (isCollapsed(record.current) || !element.contains(element.ownerDocument.activeElement)) {
3890          return;
3891        }
3892  
3893        const selectedRecord = slice(record.current);
3894        const plainText = getTextContent(selectedRecord);
3895        const html = toHTMLString({
3896          value: selectedRecord,
3897          multilineTag,
3898          preserveWhiteSpace
3899        });
3900        event.clipboardData.setData('text/plain', plainText);
3901        event.clipboardData.setData('text/html', html);
3902        event.clipboardData.setData('rich-text', 'true');
3903        event.preventDefault();
3904      }
3905  
3906      element.addEventListener('copy', onCopy);
3907      return () => {
3908        element.removeEventListener('copy', onCopy);
3909      };
3910    }, []);
3911  }
3912  
3913  // EXTERNAL MODULE: external ["wp","keycodes"]
3914  var external_wp_keycodes_ = __webpack_require__("RxS6");
3915  
3916  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/component/use-format-boundaries.js
3917  /**
3918   * WordPress dependencies
3919   */
3920  
3921  
3922  
3923  /**
3924   * Internal dependencies
3925   */
3926  
3927  
3928  const EMPTY_ACTIVE_FORMATS = [];
3929  function useFormatBoundaries(props) {
3930    const [, forceRender] = Object(external_wp_element_["useReducer"])(() => ({}));
3931    const propsRef = Object(external_wp_element_["useRef"])(props);
3932    propsRef.current = props;
3933    return Object(external_wp_compose_["useRefEffect"])(element => {
3934      function onKeyDown(event) {
3935        const {
3936          keyCode,
3937          shiftKey,
3938          altKey,
3939          metaKey,
3940          ctrlKey
3941        } = event;
3942  
3943        if ( // Only override left and right keys without modifiers pressed.
3944        shiftKey || altKey || metaKey || ctrlKey || keyCode !== external_wp_keycodes_["LEFT"] && keyCode !== external_wp_keycodes_["RIGHT"]) {
3945          return;
3946        }
3947  
3948        const {
3949          record,
3950          applyRecord
3951        } = propsRef.current;
3952        const {
3953          text,
3954          formats,
3955          start,
3956          end,
3957          activeFormats: currentActiveFormats = []
3958        } = record.current;
3959        const collapsed = isCollapsed(record.current);
3960        const {
3961          ownerDocument
3962        } = element;
3963        const {
3964          defaultView
3965        } = ownerDocument; // To do: ideally, we should look at visual position instead.
3966  
3967        const {
3968          direction
3969        } = defaultView.getComputedStyle(element);
3970        const reverseKey = direction === 'rtl' ? external_wp_keycodes_["RIGHT"] : external_wp_keycodes_["LEFT"];
3971        const isReverse = event.keyCode === reverseKey; // If the selection is collapsed and at the very start, do nothing if
3972        // navigating backward.
3973        // If the selection is collapsed and at the very end, do nothing if
3974        // navigating forward.
3975  
3976        if (collapsed && currentActiveFormats.length === 0) {
3977          if (start === 0 && isReverse) {
3978            return;
3979          }
3980  
3981          if (end === text.length && !isReverse) {
3982            return;
3983          }
3984        } // If the selection is not collapsed, let the browser handle collapsing
3985        // the selection for now. Later we could expand this logic to set
3986        // boundary positions if needed.
3987  
3988  
3989        if (!collapsed) {
3990          return;
3991        }
3992  
3993        const formatsBefore = formats[start - 1] || EMPTY_ACTIVE_FORMATS;
3994        const formatsAfter = formats[start] || EMPTY_ACTIVE_FORMATS;
3995        let newActiveFormatsLength = currentActiveFormats.length;
3996        let source = formatsAfter;
3997  
3998        if (formatsBefore.length > formatsAfter.length) {
3999          source = formatsBefore;
4000        } // If the amount of formats before the caret and after the caret is
4001        // different, the caret is at a format boundary.
4002  
4003  
4004        if (formatsBefore.length < formatsAfter.length) {
4005          if (!isReverse && currentActiveFormats.length < formatsAfter.length) {
4006            newActiveFormatsLength++;
4007          }
4008  
4009          if (isReverse && currentActiveFormats.length > formatsBefore.length) {
4010            newActiveFormatsLength--;
4011          }
4012        } else if (formatsBefore.length > formatsAfter.length) {
4013          if (!isReverse && currentActiveFormats.length > formatsAfter.length) {
4014            newActiveFormatsLength--;
4015          }
4016  
4017          if (isReverse && currentActiveFormats.length < formatsBefore.length) {
4018            newActiveFormatsLength++;
4019          }
4020        }
4021  
4022        if (newActiveFormatsLength === currentActiveFormats.length) {
4023          record.current._newActiveFormats = isReverse ? formatsBefore : formatsAfter;
4024          return;
4025        }
4026  
4027        event.preventDefault();
4028        const newActiveFormats = source.slice(0, newActiveFormatsLength);
4029        const newValue = { ...record.current,
4030          activeFormats: newActiveFormats
4031        };
4032        record.current = newValue;
4033        applyRecord(newValue);
4034        forceRender();
4035      }
4036  
4037      element.addEventListener('keydown', onKeyDown);
4038      return () => {
4039        element.removeEventListener('keydown', onKeyDown);
4040      };
4041    }, []);
4042  }
4043  
4044  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/component/use-select-object.js
4045  /**
4046   * WordPress dependencies
4047   */
4048  
4049  function useSelectObject() {
4050    return Object(external_wp_compose_["useRefEffect"])(element => {
4051      function onClick(event) {
4052        const {
4053          target
4054        } = event; // If the child element has no text content, it must be an object.
4055  
4056        if (target === element || target.textContent) {
4057          return;
4058        }
4059  
4060        const {
4061          ownerDocument
4062        } = target;
4063        const {
4064          defaultView
4065        } = ownerDocument;
4066        const range = ownerDocument.createRange();
4067        const selection = defaultView.getSelection();
4068        range.selectNode(target);
4069        selection.removeAllRanges();
4070        selection.addRange(range);
4071      }
4072  
4073      element.addEventListener('click', onClick);
4074      return () => {
4075        element.removeEventListener('click', onClick);
4076      };
4077    }, []);
4078  }
4079  
4080  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/component/use-indent-list-item-on-space.js
4081  /**
4082   * WordPress dependencies
4083   */
4084  
4085  
4086  
4087  /**
4088   * Internal dependencies
4089   */
4090  
4091  
4092  
4093  
4094  function useIndentListItemOnSpace(props) {
4095    const propsRef = Object(external_wp_element_["useRef"])(props);
4096    propsRef.current = props;
4097    return Object(external_wp_compose_["useRefEffect"])(element => {
4098      function onKeyDown(event) {
4099        const {
4100          keyCode,
4101          shiftKey,
4102          altKey,
4103          metaKey,
4104          ctrlKey
4105        } = event;
4106        const {
4107          multilineTag,
4108          createRecord,
4109          handleChange
4110        } = propsRef.current;
4111  
4112        if ( // Only override when no modifiers are pressed.
4113        shiftKey || altKey || metaKey || ctrlKey || keyCode !== external_wp_keycodes_["SPACE"] || multilineTag !== 'li') {
4114          return;
4115        }
4116  
4117        const currentValue = createRecord();
4118  
4119        if (!isCollapsed(currentValue)) {
4120          return;
4121        }
4122  
4123        const {
4124          text,
4125          start
4126        } = currentValue;
4127        const characterBefore = text[start - 1]; // The caret must be at the start of a line.
4128  
4129        if (characterBefore && characterBefore !== LINE_SEPARATOR) {
4130          return;
4131        }
4132  
4133        handleChange(indentListItems(currentValue, {
4134          type: element.tagName.toLowerCase()
4135        }));
4136        event.preventDefault();
4137      }
4138  
4139      element.addEventListener('keydown', onKeyDown);
4140      return () => {
4141        element.removeEventListener('keydown', onKeyDown);
4142      };
4143    }, []);
4144  }
4145  
4146  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/update-formats.js
4147  /**
4148   * Internal dependencies
4149   */
4150  
4151  /** @typedef {import('./create').RichTextValue} RichTextValue */
4152  
4153  /**
4154   * Efficiently updates all the formats from `start` (including) until `end`
4155   * (excluding) with the active formats. Mutates `value`.
4156   *
4157   * @param  {Object}        $1         Named paramentes.
4158   * @param  {RichTextValue} $1.value   Value te update.
4159   * @param  {number}        $1.start   Index to update from.
4160   * @param  {number}        $1.end     Index to update until.
4161   * @param  {Array}         $1.formats Replacement formats.
4162   *
4163   * @return {RichTextValue} Mutated value.
4164   */
4165  
4166  function updateFormats({
4167    value,
4168    start,
4169    end,
4170    formats
4171  }) {
4172    const formatsBefore = value.formats[start - 1] || [];
4173    const formatsAfter = value.formats[end] || []; // First, fix the references. If any format right before or after are
4174    // equal, the replacement format should use the same reference.
4175  
4176    value.activeFormats = formats.map((format, index) => {
4177      if (formatsBefore[index]) {
4178        if (isFormatEqual(format, formatsBefore[index])) {
4179          return formatsBefore[index];
4180        }
4181      } else if (formatsAfter[index]) {
4182        if (isFormatEqual(format, formatsAfter[index])) {
4183          return formatsAfter[index];
4184        }
4185      }
4186  
4187      return format;
4188    });
4189  
4190    while (--end >= start) {
4191      if (value.activeFormats.length > 0) {
4192        value.formats[end] = value.activeFormats;
4193      } else {
4194        delete value.formats[end];
4195      }
4196    }
4197  
4198    return value;
4199  }
4200  
4201  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/component/use-input-and-selection.js
4202  /**
4203   * WordPress dependencies
4204   */
4205  
4206  
4207  /**
4208   * Internal dependencies
4209   */
4210  
4211  
4212  
4213  /**
4214   * All inserting input types that would insert HTML into the DOM.
4215   *
4216   * @see https://www.w3.org/TR/input-events-2/#interface-InputEvent-Attributes
4217   *
4218   * @type {Set}
4219   */
4220  
4221  const INSERTION_INPUT_TYPES_TO_IGNORE = new Set(['insertParagraph', 'insertOrderedList', 'insertUnorderedList', 'insertHorizontalRule', 'insertLink']);
4222  const use_input_and_selection_EMPTY_ACTIVE_FORMATS = [];
4223  /**
4224   * If the selection is set on the placeholder element, collapse the selection to
4225   * the start (before the placeholder).
4226   *
4227   * @param {Window} defaultView
4228   */
4229  
4230  function fixPlaceholderSelection(defaultView) {
4231    const selection = defaultView.getSelection();
4232    const {
4233      anchorNode,
4234      anchorOffset
4235    } = selection;
4236  
4237    if (anchorNode.nodeType !== anchorNode.ELEMENT_NODE) {
4238      return;
4239    }
4240  
4241    const targetNode = anchorNode.childNodes[anchorOffset];
4242  
4243    if (!targetNode || targetNode.nodeType !== targetNode.ELEMENT_NODE || !targetNode.getAttribute('data-rich-text-placeholder')) {
4244      return;
4245    }
4246  
4247    selection.collapseToStart();
4248  }
4249  
4250  function useInputAndSelection(props) {
4251    const propsRef = Object(external_wp_element_["useRef"])(props);
4252    propsRef.current = props;
4253    return Object(external_wp_compose_["useRefEffect"])(element => {
4254      const {
4255        ownerDocument
4256      } = element;
4257      const {
4258        defaultView
4259      } = ownerDocument;
4260      let isComposing = false;
4261      let rafId;
4262  
4263      function onInput(event) {
4264        // Do not trigger a change if characters are being composed.
4265        // Browsers  will usually emit a final `input` event when the
4266        // characters are composed.
4267        // As of December 2019, Safari doesn't support
4268        // nativeEvent.isComposing.
4269        if (isComposing) {
4270          return;
4271        }
4272  
4273        let inputType;
4274  
4275        if (event) {
4276          inputType = event.inputType;
4277        }
4278  
4279        const {
4280          record,
4281          applyRecord,
4282          createRecord,
4283          handleChange
4284        } = propsRef.current; // The browser formatted something or tried to insert HTML.
4285        // Overwrite it. It will be handled later by the format library if
4286        // needed.
4287  
4288        if (inputType && (inputType.indexOf('format') === 0 || INSERTION_INPUT_TYPES_TO_IGNORE.has(inputType))) {
4289          applyRecord(record.current);
4290          return;
4291        }
4292  
4293        const currentValue = createRecord();
4294        const {
4295          start,
4296          activeFormats: oldActiveFormats = []
4297        } = record.current; // Update the formats between the last and new caret position.
4298  
4299        const change = updateFormats({
4300          value: currentValue,
4301          start,
4302          end: currentValue.start,
4303          formats: oldActiveFormats
4304        });
4305        handleChange(change);
4306      }
4307      /**
4308       * Syncs the selection to local state. A callback for the `selectionchange`
4309       * native events, `keyup`, `mouseup` and `touchend` synthetic events, and
4310       * animation frames after the `focus` event.
4311       *
4312       * @param {Event|DOMHighResTimeStamp} event
4313       */
4314  
4315  
4316      function handleSelectionChange(event) {
4317        if (ownerDocument.activeElement !== element) {
4318          return;
4319        }
4320  
4321        const {
4322          record,
4323          applyRecord,
4324          createRecord,
4325          isSelected,
4326          onSelectionChange
4327        } = propsRef.current;
4328  
4329        if (event.type !== 'selectionchange' && !isSelected) {
4330          return;
4331        } // Check if the implementor disabled editing. `contentEditable`
4332        // does disable input, but not text selection, so we must ignore
4333        // selection changes.
4334  
4335  
4336        if (element.contentEditable !== 'true') {
4337          return;
4338        } // In case of a keyboard event, ignore selection changes during
4339        // composition.
4340  
4341  
4342        if (isComposing) {
4343          return;
4344        }
4345  
4346        const {
4347          start,
4348          end,
4349          text
4350        } = createRecord();
4351        const oldRecord = record.current; // Fallback mechanism for IE11, which doesn't support the input event.
4352        // Any input results in a selection change.
4353  
4354        if (text !== oldRecord.text) {
4355          onInput();
4356          return;
4357        }
4358  
4359        if (start === oldRecord.start && end === oldRecord.end) {
4360          // Sometimes the browser may set the selection on the placeholder
4361          // element, in which case the caret is not visible. We need to set
4362          // the caret before the placeholder if that's the case.
4363          if (oldRecord.text.length === 0 && start === 0) {
4364            fixPlaceholderSelection(defaultView);
4365          }
4366  
4367          return;
4368        }
4369  
4370        const newValue = { ...oldRecord,
4371          start,
4372          end,
4373          // _newActiveFormats may be set on arrow key navigation to control
4374          // the right boundary position. If undefined, getActiveFormats will
4375          // give the active formats according to the browser.
4376          activeFormats: oldRecord._newActiveFormats,
4377          _newActiveFormats: undefined
4378        };
4379        const newActiveFormats = getActiveFormats(newValue, use_input_and_selection_EMPTY_ACTIVE_FORMATS); // Update the value with the new active formats.
4380  
4381        newValue.activeFormats = newActiveFormats; // It is important that the internal value is updated first,
4382        // otherwise the value will be wrong on render!
4383  
4384        record.current = newValue;
4385        applyRecord(newValue, {
4386          domOnly: true
4387        });
4388        onSelectionChange(start, end);
4389      }
4390  
4391      function onCompositionStart() {
4392        isComposing = true; // Do not update the selection when characters are being composed as
4393        // this rerenders the component and might distroy internal browser
4394        // editing state.
4395  
4396        ownerDocument.removeEventListener('selectionchange', handleSelectionChange);
4397      }
4398  
4399      function onCompositionEnd() {
4400        isComposing = false; // Ensure the value is up-to-date for browsers that don't emit a final
4401        // input event after composition.
4402  
4403        onInput({
4404          inputType: 'insertText'
4405        }); // Tracking selection changes can be resumed.
4406  
4407        ownerDocument.addEventListener('selectionchange', handleSelectionChange);
4408      }
4409  
4410      function onFocus() {
4411        const {
4412          record,
4413          isSelected,
4414          onSelectionChange
4415        } = propsRef.current;
4416  
4417        if (!isSelected) {
4418          // We know for certain that on focus, the old selection is invalid.
4419          // It will be recalculated on the next mouseup, keyup, or touchend
4420          // event.
4421          const index = undefined;
4422          record.current = { ...record.current,
4423            start: index,
4424            end: index,
4425            activeFormats: use_input_and_selection_EMPTY_ACTIVE_FORMATS
4426          };
4427          onSelectionChange(index, index);
4428        } else {
4429          onSelectionChange(record.current.start, record.current.end);
4430        } // Update selection as soon as possible, which is at the next animation
4431        // frame. The event listener for selection changes may be added too late
4432        // at this point, but this focus event is still too early to calculate
4433        // the selection.
4434  
4435  
4436        rafId = defaultView.requestAnimationFrame(handleSelectionChange);
4437        ownerDocument.addEventListener('selectionchange', handleSelectionChange);
4438      }
4439  
4440      function onBlur() {
4441        ownerDocument.removeEventListener('selectionchange', handleSelectionChange);
4442      }
4443  
4444      element.addEventListener('input', onInput);
4445      element.addEventListener('compositionstart', onCompositionStart);
4446      element.addEventListener('compositionend', onCompositionEnd);
4447      element.addEventListener('focus', onFocus);
4448      element.addEventListener('blur', onBlur); // Selection updates must be done at these events as they
4449      // happen before the `selectionchange` event. In some cases,
4450      // the `selectionchange` event may not even fire, for
4451      // example when the window receives focus again on click.
4452  
4453      element.addEventListener('keyup', handleSelectionChange);
4454      element.addEventListener('mouseup', handleSelectionChange);
4455      element.addEventListener('touchend', handleSelectionChange);
4456      return () => {
4457        element.removeEventListener('input', onInput);
4458        element.removeEventListener('compositionstart', onCompositionStart);
4459        element.removeEventListener('compositionend', onCompositionEnd);
4460        element.removeEventListener('focus', onFocus);
4461        element.removeEventListener('blur', onBlur);
4462        element.removeEventListener('keyup', handleSelectionChange);
4463        element.removeEventListener('mouseup', handleSelectionChange);
4464        element.removeEventListener('touchend', handleSelectionChange);
4465        ownerDocument.removeEventListener('selectionchange', handleSelectionChange);
4466        defaultView.cancelAnimationFrame(rafId);
4467      };
4468    }, []);
4469  }
4470  
4471  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/component/use-delete.js
4472  /**
4473   * WordPress dependencies
4474   */
4475  
4476  
4477  
4478  /**
4479   * Internal dependencies
4480   */
4481  
4482  
4483  
4484  
4485  function useDelete(props) {
4486    const propsRef = Object(external_wp_element_["useRef"])(props);
4487    propsRef.current = props;
4488    return Object(external_wp_compose_["useRefEffect"])(element => {
4489      function onKeyDown(event) {
4490        const {
4491          keyCode
4492        } = event;
4493        const {
4494          createRecord,
4495          handleChange,
4496          multilineTag
4497        } = propsRef.current;
4498  
4499        if (event.defaultPrevented) {
4500          return;
4501        }
4502  
4503        if (keyCode !== external_wp_keycodes_["DELETE"] && keyCode !== external_wp_keycodes_["BACKSPACE"]) {
4504          return;
4505        }
4506  
4507        const currentValue = createRecord();
4508        const {
4509          start,
4510          end,
4511          text
4512        } = currentValue;
4513        const isReverse = keyCode === external_wp_keycodes_["BACKSPACE"]; // Always handle full content deletion ourselves.
4514  
4515        if (start === 0 && end !== 0 && end === text.length) {
4516          handleChange(remove_remove(currentValue));
4517          event.preventDefault();
4518          return;
4519        }
4520  
4521        if (multilineTag) {
4522          let newValue; // Check to see if we should remove the first item if empty.
4523  
4524          if (isReverse && currentValue.start === 0 && currentValue.end === 0 && isEmptyLine(currentValue)) {
4525            newValue = removeLineSeparator(currentValue, !isReverse);
4526          } else {
4527            newValue = removeLineSeparator(currentValue, isReverse);
4528          }
4529  
4530          if (newValue) {
4531            handleChange(newValue);
4532            event.preventDefault();
4533          }
4534        }
4535      }
4536  
4537      element.addEventListener('keydown', onKeyDown);
4538      return () => {
4539        element.removeEventListener('keydown', onKeyDown);
4540      };
4541    }, []);
4542  }
4543  
4544  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/component/index.js
4545  /**
4546   * WordPress dependencies
4547   */
4548  
4549  
4550  /**
4551   * Internal dependencies
4552   */
4553  
4554  
4555  
4556  
4557  
4558  
4559  
4560  
4561  
4562  
4563  
4564  
4565  
4566  function useRichText({
4567    value = '',
4568    selectionStart,
4569    selectionEnd,
4570    placeholder,
4571    preserveWhiteSpace,
4572    onSelectionChange,
4573    onChange,
4574    __unstableMultilineTag: multilineTag,
4575    __unstableDisableFormats: disableFormats,
4576    __unstableIsSelected: isSelected,
4577    __unstableDependencies,
4578    __unstableAfterParse,
4579    __unstableBeforeSerialize,
4580    __unstableAddInvisibleFormats
4581  }) {
4582    const [, forceRender] = Object(external_wp_element_["useReducer"])(() => ({}));
4583    const ref = Object(external_wp_element_["useRef"])();
4584  
4585    function createRecord() {
4586      const {
4587        ownerDocument: {
4588          defaultView
4589        }
4590      } = ref.current;
4591      const selection = defaultView.getSelection();
4592      const range = selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
4593      return create({
4594        element: ref.current,
4595        range,
4596        multilineTag,
4597        multilineWrapperTags: multilineTag === 'li' ? ['ul', 'ol'] : undefined,
4598        __unstableIsEditableTree: true,
4599        preserveWhiteSpace
4600      });
4601    }
4602  
4603    function applyRecord(newRecord, {
4604      domOnly
4605    } = {}) {
4606      apply({
4607        value: newRecord,
4608        current: ref.current,
4609        multilineTag,
4610        multilineWrapperTags: multilineTag === 'li' ? ['ul', 'ol'] : undefined,
4611        prepareEditableTree: __unstableAddInvisibleFormats,
4612        __unstableDomOnly: domOnly,
4613        placeholder
4614      });
4615    } // Internal values are updated synchronously, unlike props and state.
4616  
4617  
4618    const _value = Object(external_wp_element_["useRef"])(value);
4619  
4620    const record = Object(external_wp_element_["useRef"])();
4621  
4622    function setRecordFromProps() {
4623      _value.current = value;
4624      record.current = create({
4625        html: value,
4626        multilineTag,
4627        multilineWrapperTags: multilineTag === 'li' ? ['ul', 'ol'] : undefined,
4628        preserveWhiteSpace
4629      });
4630  
4631      if (disableFormats) {
4632        record.current.formats = Array(value.length);
4633        record.current.replacements = Array(value.length);
4634      }
4635  
4636      record.current.formats = __unstableAfterParse(record.current);
4637      record.current.start = selectionStart;
4638      record.current.end = selectionEnd;
4639    }
4640  
4641    const hadSelectionUpdate = Object(external_wp_element_["useRef"])(false);
4642  
4643    if (!record.current) {
4644      setRecordFromProps();
4645    } else if (selectionStart !== record.current.start || selectionEnd !== record.current.end) {
4646      hadSelectionUpdate.current = isSelected;
4647      record.current = { ...record.current,
4648        start: selectionStart,
4649        end: selectionEnd
4650      };
4651    }
4652    /**
4653     * Sync the value to global state. The node tree and selection will also be
4654     * updated if differences are found.
4655     *
4656     * @param {Object} newRecord The record to sync and apply.
4657     */
4658  
4659  
4660    function handleChange(newRecord) {
4661      applyRecord(newRecord);
4662  
4663      if (disableFormats) {
4664        _value.current = newRecord.text;
4665      } else {
4666        _value.current = toHTMLString({
4667          value: { ...newRecord,
4668            formats: __unstableBeforeSerialize(newRecord)
4669          },
4670          multilineTag,
4671          preserveWhiteSpace
4672        });
4673      }
4674  
4675      record.current = newRecord;
4676      const {
4677        start,
4678        end,
4679        formats,
4680        text
4681      } = newRecord; // Selection must be updated first, so it is recorded in history when
4682      // the content change happens.
4683  
4684      onSelectionChange(start, end);
4685      onChange(_value.current, {
4686        __unstableFormats: formats,
4687        __unstableText: text
4688      });
4689      forceRender();
4690    }
4691  
4692    function applyFromProps() {
4693      setRecordFromProps();
4694      applyRecord(record.current);
4695    }
4696  
4697    const didMount = Object(external_wp_element_["useRef"])(false); // Value updates must happen synchonously to avoid overwriting newer values.
4698  
4699    Object(external_wp_element_["useLayoutEffect"])(() => {
4700      if (didMount.current && value !== _value.current) {
4701        applyFromProps();
4702      }
4703    }, [value]); // Value updates must happen synchonously to avoid overwriting newer values.
4704  
4705    Object(external_wp_element_["useLayoutEffect"])(() => {
4706      if (!hadSelectionUpdate.current) {
4707        return;
4708      }
4709  
4710      applyFromProps();
4711      hadSelectionUpdate.current = false;
4712    }, [hadSelectionUpdate.current]);
4713  
4714    function focus() {
4715      ref.current.focus();
4716      applyRecord(record.current);
4717    }
4718  
4719    const mergedRefs = Object(external_wp_compose_["useMergeRefs"])([ref, useDefaultStyle(), useBoundaryStyle({
4720      record
4721    }), useInlineWarning(), useCopyHandler({
4722      record,
4723      multilineTag,
4724      preserveWhiteSpace
4725    }), useSelectObject(), useFormatBoundaries({
4726      record,
4727      applyRecord
4728    }), useDelete({
4729      createRecord,
4730      handleChange,
4731      multilineTag
4732    }), useIndentListItemOnSpace({
4733      multilineTag,
4734      createRecord,
4735      handleChange
4736    }), useInputAndSelection({
4737      record,
4738      applyRecord,
4739      createRecord,
4740      handleChange,
4741      isSelected,
4742      onSelectionChange
4743    }), Object(external_wp_compose_["useRefEffect"])(() => {
4744      applyFromProps();
4745      didMount.current = true;
4746    }, [placeholder, ...__unstableDependencies])]);
4747    return {
4748      value: record.current,
4749      onChange: handleChange,
4750      onFocus: focus,
4751      ref: mergedRefs
4752    };
4753  }
4754  function __experimentalRichText() {}
4755  
4756  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/component/format-edit.js
4757  
4758  
4759  /**
4760   * Internal dependencies
4761   */
4762  
4763  
4764  function FormatEdit({
4765    formatTypes,
4766    onChange,
4767    onFocus,
4768    value,
4769    forwardedRef
4770  }) {
4771    return formatTypes.map(settings => {
4772      const {
4773        name,
4774        edit: Edit
4775      } = settings;
4776  
4777      if (!Edit) {
4778        return null;
4779      }
4780  
4781      const activeFormat = getActiveFormat(value, name);
4782      const isActive = activeFormat !== undefined;
4783      const activeObject = getActiveObject(value);
4784      const isObjectActive = activeObject !== undefined && activeObject.type === name;
4785      return Object(external_wp_element_["createElement"])(Edit, {
4786        key: name,
4787        isActive: isActive,
4788        activeAttributes: isActive ? activeFormat.attributes || {} : {},
4789        isObjectActive: isObjectActive,
4790        activeObjectAttributes: isObjectActive ? activeObject.attributes || {} : {},
4791        value: value,
4792        onChange: onChange,
4793        onFocus: onFocus,
4794        contentRef: forwardedRef
4795      });
4796    });
4797  }
4798  
4799  // CONCATENATED MODULE: ./node_modules/@wordpress/rich-text/build-module/index.js
4800  
4801  
4802  
4803  
4804  
4805  
4806  
4807  
4808  
4809  
4810  
4811  
4812  
4813  
4814  
4815  
4816  
4817  
4818  
4819  
4820  
4821  
4822  
4823  
4824  
4825  
4826  
4827  
4828  
4829  
4830  
4831  
4832  
4833  
4834  
4835  
4836  
4837  
4838  /***/ })
4839  
4840  /******/ });


Generated: Wed Sep 22 01:00:04 2021 Cross-referenced by PHPXref 0.7.1