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


Generated: Thu Jul 16 01:00:03 2020 Cross-referenced by PHPXref 0.7.1