[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/dist/ -> block-editor.js (source)

   1  this["wp"] = this["wp"] || {}; this["wp"]["blockEditor"] =
   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 = 448);
  86  /******/ })
  87  /************************************************************************/
  88  /******/ ({
  89  
  90  /***/ 0:
  91  /***/ (function(module, exports) {
  92  
  93  (function() { module.exports = window["wp"]["element"]; }());
  94  
  95  /***/ }),
  96  
  97  /***/ 1:
  98  /***/ (function(module, exports) {
  99  
 100  (function() { module.exports = window["wp"]["i18n"]; }());
 101  
 102  /***/ }),
 103  
 104  /***/ 10:
 105  /***/ (function(module, exports, __webpack_require__) {
 106  
 107  var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
 108    Copyright (c) 2018 Jed Watson.
 109    Licensed under the MIT License (MIT), see
 110    http://jedwatson.github.io/classnames
 111  */
 112  /* global define */
 113  
 114  (function () {
 115      'use strict';
 116  
 117      var hasOwn = {}.hasOwnProperty;
 118  
 119  	function classNames() {
 120          var classes = [];
 121  
 122          for (var i = 0; i < arguments.length; i++) {
 123              var arg = arguments[i];
 124              if (!arg) continue;
 125  
 126              var argType = typeof arg;
 127  
 128              if (argType === 'string' || argType === 'number') {
 129                  classes.push(arg);
 130              } else if (Array.isArray(arg)) {
 131                  if (arg.length) {
 132                      var inner = classNames.apply(null, arg);
 133                      if (inner) {
 134                          classes.push(inner);
 135                      }
 136                  }
 137              } else if (argType === 'object') {
 138                  if (arg.toString === Object.prototype.toString) {
 139                      for (var key in arg) {
 140                          if (hasOwn.call(arg, key) && arg[key]) {
 141                              classes.push(key);
 142                          }
 143                      }
 144                  } else {
 145                      classes.push(arg.toString());
 146                  }
 147              }
 148          }
 149  
 150          return classes.join(' ');
 151      }
 152  
 153      if ( true && module.exports) {
 154          classNames.default = classNames;
 155          module.exports = classNames;
 156      } else if (true) {
 157          // register as 'classnames', consistent with npm package name
 158          !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
 159              return classNames;
 160          }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
 161                  __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
 162      } else {}
 163  }());
 164  
 165  
 166  /***/ }),
 167  
 168  /***/ 11:
 169  /***/ (function(module, exports) {
 170  
 171  (function() { module.exports = window["wp"]["compose"]; }());
 172  
 173  /***/ }),
 174  
 175  /***/ 114:
 176  /***/ (function(module, exports, __webpack_require__) {
 177  
 178  "use strict";
 179  
 180  
 181  Object.defineProperty(exports, '__esModule', { value: true });
 182  
 183  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 184  
 185  var _extends = _interopDefault(__webpack_require__(186));
 186  var _objectWithoutPropertiesLoose = _interopDefault(__webpack_require__(187));
 187  var React = __webpack_require__(14);
 188  var React__default = _interopDefault(React);
 189  var _inheritsLoose = _interopDefault(__webpack_require__(158));
 190  var _assertThisInitialized = _interopDefault(__webpack_require__(189));
 191  
 192  var is = {
 193    arr: Array.isArray,
 194    obj: function obj(a) {
 195      return Object.prototype.toString.call(a) === '[object Object]';
 196    },
 197    fun: function fun(a) {
 198      return typeof a === 'function';
 199    },
 200    str: function str(a) {
 201      return typeof a === 'string';
 202    },
 203    num: function num(a) {
 204      return typeof a === 'number';
 205    },
 206    und: function und(a) {
 207      return a === void 0;
 208    },
 209    nul: function nul(a) {
 210      return a === null;
 211    },
 212    set: function set(a) {
 213      return a instanceof Set;
 214    },
 215    map: function map(a) {
 216      return a instanceof Map;
 217    },
 218    equ: function equ(a, b) {
 219      if (typeof a !== typeof b) return false;
 220      if (is.str(a) || is.num(a)) return a === b;
 221      if (is.obj(a) && is.obj(b) && Object.keys(a).length + Object.keys(b).length === 0) return true;
 222      var i;
 223  
 224      for (i in a) {
 225        if (!(i in b)) return false;
 226      }
 227  
 228      for (i in b) {
 229        if (a[i] !== b[i]) return false;
 230      }
 231  
 232      return is.und(i) ? a === b : true;
 233    }
 234  };
 235  function merge(target, lowercase) {
 236    if (lowercase === void 0) {
 237      lowercase = true;
 238    }
 239  
 240    return function (object) {
 241      return (is.arr(object) ? object : Object.keys(object)).reduce(function (acc, element) {
 242        var key = lowercase ? element[0].toLowerCase() + element.substring(1) : element;
 243        acc[key] = target(key);
 244        return acc;
 245      }, target);
 246    };
 247  }
 248  function useForceUpdate() {
 249    var _useState = React.useState(false),
 250        f = _useState[1];
 251  
 252    var forceUpdate = React.useCallback(function () {
 253      return f(function (v) {
 254        return !v;
 255      });
 256    }, []);
 257    return forceUpdate;
 258  }
 259  function withDefault(value, defaultValue) {
 260    return is.und(value) || is.nul(value) ? defaultValue : value;
 261  }
 262  function toArray(a) {
 263    return !is.und(a) ? is.arr(a) ? a : [a] : [];
 264  }
 265  function callProp(obj) {
 266    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
 267      args[_key - 1] = arguments[_key];
 268    }
 269  
 270    return is.fun(obj) ? obj.apply(void 0, args) : obj;
 271  }
 272  
 273  function getForwardProps(props) {
 274    var to = props.to,
 275        from = props.from,
 276        config = props.config,
 277        onStart = props.onStart,
 278        onRest = props.onRest,
 279        onFrame = props.onFrame,
 280        children = props.children,
 281        reset = props.reset,
 282        reverse = props.reverse,
 283        force = props.force,
 284        immediate = props.immediate,
 285        delay = props.delay,
 286        attach = props.attach,
 287        destroyed = props.destroyed,
 288        interpolateTo = props.interpolateTo,
 289        ref = props.ref,
 290        lazy = props.lazy,
 291        forward = _objectWithoutPropertiesLoose(props, ["to", "from", "config", "onStart", "onRest", "onFrame", "children", "reset", "reverse", "force", "immediate", "delay", "attach", "destroyed", "interpolateTo", "ref", "lazy"]);
 292  
 293    return forward;
 294  }
 295  
 296  function interpolateTo(props) {
 297    var forward = getForwardProps(props);
 298    if (is.und(forward)) return _extends({
 299      to: forward
 300    }, props);
 301    var rest = Object.keys(props).reduce(function (a, k) {
 302      var _extends2;
 303  
 304      return !is.und(forward[k]) ? a : _extends({}, a, (_extends2 = {}, _extends2[k] = props[k], _extends2));
 305    }, {});
 306    return _extends({
 307      to: forward
 308    }, rest);
 309  }
 310  function handleRef(ref, forward) {
 311    if (forward) {
 312      // If it's a function, assume it's a ref callback
 313      if (is.fun(forward)) forward(ref);else if (is.obj(forward)) {
 314        forward.current = ref;
 315      }
 316    }
 317  
 318    return ref;
 319  }
 320  
 321  var Animated =
 322  /*#__PURE__*/
 323  function () {
 324    function Animated() {
 325      this.payload = void 0;
 326      this.children = [];
 327    }
 328  
 329    var _proto = Animated.prototype;
 330  
 331    _proto.getAnimatedValue = function getAnimatedValue() {
 332      return this.getValue();
 333    };
 334  
 335    _proto.getPayload = function getPayload() {
 336      return this.payload || this;
 337    };
 338  
 339    _proto.attach = function attach() {};
 340  
 341    _proto.detach = function detach() {};
 342  
 343    _proto.getChildren = function getChildren() {
 344      return this.children;
 345    };
 346  
 347    _proto.addChild = function addChild(child) {
 348      if (this.children.length === 0) this.attach();
 349      this.children.push(child);
 350    };
 351  
 352    _proto.removeChild = function removeChild(child) {
 353      var index = this.children.indexOf(child);
 354      this.children.splice(index, 1);
 355      if (this.children.length === 0) this.detach();
 356    };
 357  
 358    return Animated;
 359  }();
 360  var AnimatedArray =
 361  /*#__PURE__*/
 362  function (_Animated) {
 363    _inheritsLoose(AnimatedArray, _Animated);
 364  
 365    function AnimatedArray() {
 366      var _this;
 367  
 368      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
 369        args[_key] = arguments[_key];
 370      }
 371  
 372      _this = _Animated.call.apply(_Animated, [this].concat(args)) || this;
 373      _this.payload = [];
 374  
 375      _this.attach = function () {
 376        return _this.payload.forEach(function (p) {
 377          return p instanceof Animated && p.addChild(_assertThisInitialized(_this));
 378        });
 379      };
 380  
 381      _this.detach = function () {
 382        return _this.payload.forEach(function (p) {
 383          return p instanceof Animated && p.removeChild(_assertThisInitialized(_this));
 384        });
 385      };
 386  
 387      return _this;
 388    }
 389  
 390    return AnimatedArray;
 391  }(Animated);
 392  var AnimatedObject =
 393  /*#__PURE__*/
 394  function (_Animated2) {
 395    _inheritsLoose(AnimatedObject, _Animated2);
 396  
 397    function AnimatedObject() {
 398      var _this2;
 399  
 400      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
 401        args[_key3] = arguments[_key3];
 402      }
 403  
 404      _this2 = _Animated2.call.apply(_Animated2, [this].concat(args)) || this;
 405      _this2.payload = {};
 406  
 407      _this2.attach = function () {
 408        return Object.values(_this2.payload).forEach(function (s) {
 409          return s instanceof Animated && s.addChild(_assertThisInitialized(_this2));
 410        });
 411      };
 412  
 413      _this2.detach = function () {
 414        return Object.values(_this2.payload).forEach(function (s) {
 415          return s instanceof Animated && s.removeChild(_assertThisInitialized(_this2));
 416        });
 417      };
 418  
 419      return _this2;
 420    }
 421  
 422    var _proto2 = AnimatedObject.prototype;
 423  
 424    _proto2.getValue = function getValue(animated) {
 425      if (animated === void 0) {
 426        animated = false;
 427      }
 428  
 429      var payload = {};
 430  
 431      for (var _key4 in this.payload) {
 432        var value = this.payload[_key4];
 433        if (animated && !(value instanceof Animated)) continue;
 434        payload[_key4] = value instanceof Animated ? value[animated ? 'getAnimatedValue' : 'getValue']() : value;
 435      }
 436  
 437      return payload;
 438    };
 439  
 440    _proto2.getAnimatedValue = function getAnimatedValue() {
 441      return this.getValue(true);
 442    };
 443  
 444    return AnimatedObject;
 445  }(Animated);
 446  
 447  var applyAnimatedValues;
 448  function injectApplyAnimatedValues(fn, transform) {
 449    applyAnimatedValues = {
 450      fn: fn,
 451      transform: transform
 452    };
 453  }
 454  var colorNames;
 455  function injectColorNames(names) {
 456    colorNames = names;
 457  }
 458  var requestFrame = function requestFrame(cb) {
 459    return typeof window !== 'undefined' ? window.requestAnimationFrame(cb) : -1;
 460  };
 461  var cancelFrame = function cancelFrame(id) {
 462    typeof window !== 'undefined' && window.cancelAnimationFrame(id);
 463  };
 464  function injectFrame(raf, caf) {
 465    requestFrame = raf;
 466    cancelFrame = caf;
 467  }
 468  var interpolation;
 469  function injectStringInterpolator(fn) {
 470    interpolation = fn;
 471  }
 472  var now = function now() {
 473    return Date.now();
 474  };
 475  function injectNow(nowFn) {
 476    now = nowFn;
 477  }
 478  var defaultElement;
 479  function injectDefaultElement(el) {
 480    defaultElement = el;
 481  }
 482  var animatedApi = function animatedApi(node) {
 483    return node.current;
 484  };
 485  function injectAnimatedApi(fn) {
 486    animatedApi = fn;
 487  }
 488  var createAnimatedStyle;
 489  function injectCreateAnimatedStyle(factory) {
 490    createAnimatedStyle = factory;
 491  }
 492  var manualFrameloop;
 493  function injectManualFrameloop(callback) {
 494    manualFrameloop = callback;
 495  }
 496  
 497  var Globals = /*#__PURE__*/Object.freeze({
 498    get applyAnimatedValues () { return applyAnimatedValues; },
 499    injectApplyAnimatedValues: injectApplyAnimatedValues,
 500    get colorNames () { return colorNames; },
 501    injectColorNames: injectColorNames,
 502    get requestFrame () { return requestFrame; },
 503    get cancelFrame () { return cancelFrame; },
 504    injectFrame: injectFrame,
 505    get interpolation () { return interpolation; },
 506    injectStringInterpolator: injectStringInterpolator,
 507    get now () { return now; },
 508    injectNow: injectNow,
 509    get defaultElement () { return defaultElement; },
 510    injectDefaultElement: injectDefaultElement,
 511    get animatedApi () { return animatedApi; },
 512    injectAnimatedApi: injectAnimatedApi,
 513    get createAnimatedStyle () { return createAnimatedStyle; },
 514    injectCreateAnimatedStyle: injectCreateAnimatedStyle,
 515    get manualFrameloop () { return manualFrameloop; },
 516    injectManualFrameloop: injectManualFrameloop
 517  });
 518  
 519  /**
 520   * Wraps the `style` property with `AnimatedStyle`.
 521   */
 522  
 523  var AnimatedProps =
 524  /*#__PURE__*/
 525  function (_AnimatedObject) {
 526    _inheritsLoose(AnimatedProps, _AnimatedObject);
 527  
 528    function AnimatedProps(props, callback) {
 529      var _this;
 530  
 531      _this = _AnimatedObject.call(this) || this;
 532      _this.update = void 0;
 533      _this.payload = !props.style ? props : _extends({}, props, {
 534        style: createAnimatedStyle(props.style)
 535      });
 536      _this.update = callback;
 537  
 538      _this.attach();
 539  
 540      return _this;
 541    }
 542  
 543    return AnimatedProps;
 544  }(AnimatedObject);
 545  
 546  var isFunctionComponent = function isFunctionComponent(val) {
 547    return is.fun(val) && !(val.prototype instanceof React__default.Component);
 548  };
 549  
 550  var createAnimatedComponent = function createAnimatedComponent(Component) {
 551    var AnimatedComponent = React.forwardRef(function (props, ref) {
 552      var forceUpdate = useForceUpdate();
 553      var mounted = React.useRef(true);
 554      var propsAnimated = React.useRef(null);
 555      var node = React.useRef(null);
 556      var attachProps = React.useCallback(function (props) {
 557        var oldPropsAnimated = propsAnimated.current;
 558  
 559        var callback = function callback() {
 560          var didUpdate = false;
 561  
 562          if (node.current) {
 563            didUpdate = applyAnimatedValues.fn(node.current, propsAnimated.current.getAnimatedValue());
 564          }
 565  
 566          if (!node.current || didUpdate === false) {
 567            // If no referenced node has been found, or the update target didn't have a
 568            // native-responder, then forceUpdate the animation ...
 569            forceUpdate();
 570          }
 571        };
 572  
 573        propsAnimated.current = new AnimatedProps(props, callback);
 574        oldPropsAnimated && oldPropsAnimated.detach();
 575      }, []);
 576      React.useEffect(function () {
 577        return function () {
 578          mounted.current = false;
 579          propsAnimated.current && propsAnimated.current.detach();
 580        };
 581      }, []);
 582      React.useImperativeHandle(ref, function () {
 583        return animatedApi(node, mounted, forceUpdate);
 584      });
 585      attachProps(props);
 586  
 587      var _getValue = propsAnimated.current.getValue(),
 588          scrollTop = _getValue.scrollTop,
 589          scrollLeft = _getValue.scrollLeft,
 590          animatedProps = _objectWithoutPropertiesLoose(_getValue, ["scrollTop", "scrollLeft"]); // Functions cannot have refs, see:
 591      // See: https://github.com/react-spring/react-spring/issues/569
 592  
 593  
 594      var refFn = isFunctionComponent(Component) ? undefined : function (childRef) {
 595        return node.current = handleRef(childRef, ref);
 596      };
 597      return React__default.createElement(Component, _extends({}, animatedProps, {
 598        ref: refFn
 599      }));
 600    });
 601    return AnimatedComponent;
 602  };
 603  
 604  var active = false;
 605  var controllers = new Set();
 606  
 607  var update = function update() {
 608    if (!active) return false;
 609    var time = now();
 610  
 611    for (var _iterator = controllers, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
 612      var _ref;
 613  
 614      if (_isArray) {
 615        if (_i >= _iterator.length) break;
 616        _ref = _iterator[_i++];
 617      } else {
 618        _i = _iterator.next();
 619        if (_i.done) break;
 620        _ref = _i.value;
 621      }
 622  
 623      var controller = _ref;
 624      var isActive = false;
 625  
 626      for (var configIdx = 0; configIdx < controller.configs.length; configIdx++) {
 627        var config = controller.configs[configIdx];
 628        var endOfAnimation = void 0,
 629            lastTime = void 0;
 630  
 631        for (var valIdx = 0; valIdx < config.animatedValues.length; valIdx++) {
 632          var animation = config.animatedValues[valIdx]; // If an animation is done, skip, until all of them conclude
 633  
 634          if (animation.done) continue;
 635          var from = config.fromValues[valIdx];
 636          var to = config.toValues[valIdx];
 637          var position = animation.lastPosition;
 638          var isAnimated = to instanceof Animated;
 639          var velocity = Array.isArray(config.initialVelocity) ? config.initialVelocity[valIdx] : config.initialVelocity;
 640          if (isAnimated) to = to.getValue(); // Conclude animation if it's either immediate, or from-values match end-state
 641  
 642          if (config.immediate) {
 643            animation.setValue(to);
 644            animation.done = true;
 645            continue;
 646          } // Break animation when string values are involved
 647  
 648  
 649          if (typeof from === 'string' || typeof to === 'string') {
 650            animation.setValue(to);
 651            animation.done = true;
 652            continue;
 653          }
 654  
 655          if (config.duration !== void 0) {
 656            /** Duration easing */
 657            position = from + config.easing((time - animation.startTime) / config.duration) * (to - from);
 658            endOfAnimation = time >= animation.startTime + config.duration;
 659          } else if (config.decay) {
 660            /** Decay easing */
 661            position = from + velocity / (1 - 0.998) * (1 - Math.exp(-(1 - 0.998) * (time - animation.startTime)));
 662            endOfAnimation = Math.abs(animation.lastPosition - position) < 0.1;
 663            if (endOfAnimation) to = position;
 664          } else {
 665            /** Spring easing */
 666            lastTime = animation.lastTime !== void 0 ? animation.lastTime : time;
 667            velocity = animation.lastVelocity !== void 0 ? animation.lastVelocity : config.initialVelocity; // If we lost a lot of frames just jump to the end.
 668  
 669            if (time > lastTime + 64) lastTime = time; // http://gafferongames.com/game-physics/fix-your-timestep/
 670  
 671            var numSteps = Math.floor(time - lastTime);
 672  
 673            for (var i = 0; i < numSteps; ++i) {
 674              var force = -config.tension * (position - to);
 675              var damping = -config.friction * velocity;
 676              var acceleration = (force + damping) / config.mass;
 677              velocity = velocity + acceleration * 1 / 1000;
 678              position = position + velocity * 1 / 1000;
 679            } // Conditions for stopping the spring animation
 680  
 681  
 682            var isOvershooting = config.clamp && config.tension !== 0 ? from < to ? position > to : position < to : false;
 683            var isVelocity = Math.abs(velocity) <= config.precision;
 684            var isDisplacement = config.tension !== 0 ? Math.abs(to - position) <= config.precision : true;
 685            endOfAnimation = isOvershooting || isVelocity && isDisplacement;
 686            animation.lastVelocity = velocity;
 687            animation.lastTime = time;
 688          } // Trails aren't done until their parents conclude
 689  
 690  
 691          if (isAnimated && !config.toValues[valIdx].done) endOfAnimation = false;
 692  
 693          if (endOfAnimation) {
 694            // Ensure that we end up with a round value
 695            if (animation.value !== to) position = to;
 696            animation.done = true;
 697          } else isActive = true;
 698  
 699          animation.setValue(position);
 700          animation.lastPosition = position;
 701        } // Keep track of updated values only when necessary
 702  
 703  
 704        if (controller.props.onFrame) controller.values[config.name] = config.interpolation.getValue();
 705      } // Update callbacks in the end of the frame
 706  
 707  
 708      if (controller.props.onFrame) controller.props.onFrame(controller.values); // Either call onEnd or next frame
 709  
 710      if (!isActive) {
 711        controllers.delete(controller);
 712        controller.stop(true);
 713      }
 714    } // Loop over as long as there are controllers ...
 715  
 716  
 717    if (controllers.size) {
 718      if (manualFrameloop) manualFrameloop();else requestFrame(update);
 719    } else {
 720      active = false;
 721    }
 722  
 723    return active;
 724  };
 725  
 726  var start = function start(controller) {
 727    if (!controllers.has(controller)) controllers.add(controller);
 728  
 729    if (!active) {
 730      active = true;
 731      if (manualFrameloop) requestFrame(manualFrameloop);else requestFrame(update);
 732    }
 733  };
 734  
 735  var stop = function stop(controller) {
 736    if (controllers.has(controller)) controllers.delete(controller);
 737  };
 738  
 739  function createInterpolator(range, output, extrapolate) {
 740    if (typeof range === 'function') {
 741      return range;
 742    }
 743  
 744    if (Array.isArray(range)) {
 745      return createInterpolator({
 746        range: range,
 747        output: output,
 748        extrapolate: extrapolate
 749      });
 750    }
 751  
 752    if (interpolation && typeof range.output[0] === 'string') {
 753      return interpolation(range);
 754    }
 755  
 756    var config = range;
 757    var outputRange = config.output;
 758    var inputRange = config.range || [0, 1];
 759    var extrapolateLeft = config.extrapolateLeft || config.extrapolate || 'extend';
 760    var extrapolateRight = config.extrapolateRight || config.extrapolate || 'extend';
 761  
 762    var easing = config.easing || function (t) {
 763      return t;
 764    };
 765  
 766    return function (input) {
 767      var range = findRange(input, inputRange);
 768      return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight, config.map);
 769    };
 770  }
 771  
 772  function interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight, map) {
 773    var result = map ? map(input) : input; // Extrapolate
 774  
 775    if (result < inputMin) {
 776      if (extrapolateLeft === 'identity') return result;else if (extrapolateLeft === 'clamp') result = inputMin;
 777    }
 778  
 779    if (result > inputMax) {
 780      if (extrapolateRight === 'identity') return result;else if (extrapolateRight === 'clamp') result = inputMax;
 781    }
 782  
 783    if (outputMin === outputMax) return outputMin;
 784    if (inputMin === inputMax) return input <= inputMin ? outputMin : outputMax; // Input Range
 785  
 786    if (inputMin === -Infinity) result = -result;else if (inputMax === Infinity) result = result - inputMin;else result = (result - inputMin) / (inputMax - inputMin); // Easing
 787  
 788    result = easing(result); // Output Range
 789  
 790    if (outputMin === -Infinity) result = -result;else if (outputMax === Infinity) result = result + outputMin;else result = result * (outputMax - outputMin) + outputMin;
 791    return result;
 792  }
 793  
 794  function findRange(input, inputRange) {
 795    for (var i = 1; i < inputRange.length - 1; ++i) {
 796      if (inputRange[i] >= input) break;
 797    }
 798  
 799    return i - 1;
 800  }
 801  
 802  var AnimatedInterpolation =
 803  /*#__PURE__*/
 804  function (_AnimatedArray) {
 805    _inheritsLoose(AnimatedInterpolation, _AnimatedArray);
 806  
 807    function AnimatedInterpolation(parents, range, output, extrapolate) {
 808      var _this;
 809  
 810      _this = _AnimatedArray.call(this) || this;
 811      _this.calc = void 0;
 812      _this.payload = parents instanceof AnimatedArray && !(parents instanceof AnimatedInterpolation) ? parents.getPayload() : Array.isArray(parents) ? parents : [parents];
 813      _this.calc = createInterpolator(range, output, extrapolate);
 814      return _this;
 815    }
 816  
 817    var _proto = AnimatedInterpolation.prototype;
 818  
 819    _proto.getValue = function getValue() {
 820      return this.calc.apply(this, this.payload.map(function (value) {
 821        return value.getValue();
 822      }));
 823    };
 824  
 825    _proto.updateConfig = function updateConfig(range, output, extrapolate) {
 826      this.calc = createInterpolator(range, output, extrapolate);
 827    };
 828  
 829    _proto.interpolate = function interpolate(range, output, extrapolate) {
 830      return new AnimatedInterpolation(this, range, output, extrapolate);
 831    };
 832  
 833    return AnimatedInterpolation;
 834  }(AnimatedArray);
 835  
 836  var interpolate$1 = function interpolate(parents, range, output) {
 837    return parents && new AnimatedInterpolation(parents, range, output);
 838  };
 839  
 840  var config = {
 841    default: {
 842      tension: 170,
 843      friction: 26
 844    },
 845    gentle: {
 846      tension: 120,
 847      friction: 14
 848    },
 849    wobbly: {
 850      tension: 180,
 851      friction: 12
 852    },
 853    stiff: {
 854      tension: 210,
 855      friction: 20
 856    },
 857    slow: {
 858      tension: 280,
 859      friction: 60
 860    },
 861    molasses: {
 862      tension: 280,
 863      friction: 120
 864    }
 865  };
 866  
 867  /** API
 868   *  useChain(references, timeSteps, timeFrame)
 869   */
 870  
 871  function useChain(refs, timeSteps, timeFrame) {
 872    if (timeFrame === void 0) {
 873      timeFrame = 1000;
 874    }
 875  
 876    var previous = React.useRef();
 877    React.useEffect(function () {
 878      if (is.equ(refs, previous.current)) refs.forEach(function (_ref) {
 879        var current = _ref.current;
 880        return current && current.start();
 881      });else if (timeSteps) {
 882        refs.forEach(function (_ref2, index) {
 883          var current = _ref2.current;
 884  
 885          if (current) {
 886            var ctrls = current.controllers;
 887  
 888            if (ctrls.length) {
 889              var t = timeFrame * timeSteps[index];
 890              ctrls.forEach(function (ctrl) {
 891                ctrl.queue = ctrl.queue.map(function (e) {
 892                  return _extends({}, e, {
 893                    delay: e.delay + t
 894                  });
 895                });
 896                ctrl.start();
 897              });
 898            }
 899          }
 900        });
 901      } else refs.reduce(function (q, _ref3, rI) {
 902        var current = _ref3.current;
 903        return q = q.then(function () {
 904          return current.start();
 905        });
 906      }, Promise.resolve());
 907      previous.current = refs;
 908    });
 909  }
 910  
 911  /**
 912   * Animated works by building a directed acyclic graph of dependencies
 913   * transparently when you render your Animated components.
 914   *
 915   *               new Animated.Value(0)
 916   *     .interpolate()        .interpolate()    new Animated.Value(1)
 917   *         opacity               translateY      scale
 918   *          style                         transform
 919   *         View#234                         style
 920   *                                         View#123
 921   *
 922   * A) Top Down phase
 923   * When an AnimatedValue is updated, we recursively go down through this
 924   * graph in order to find leaf nodes: the views that we flag as needing
 925   * an update.
 926   *
 927   * B) Bottom Up phase
 928   * When a view is flagged as needing an update, we recursively go back up
 929   * in order to build the new value that it needs. The reason why we need
 930   * this two-phases process is to deal with composite props such as
 931   * transform which can receive values from multiple parents.
 932   */
 933  function addAnimatedStyles(node, styles) {
 934    if ('update' in node) {
 935      styles.add(node);
 936    } else {
 937      node.getChildren().forEach(function (child) {
 938        return addAnimatedStyles(child, styles);
 939      });
 940    }
 941  }
 942  
 943  var AnimatedValue =
 944  /*#__PURE__*/
 945  function (_Animated) {
 946    _inheritsLoose(AnimatedValue, _Animated);
 947  
 948    function AnimatedValue(_value) {
 949      var _this;
 950  
 951      _this = _Animated.call(this) || this;
 952      _this.animatedStyles = new Set();
 953      _this.value = void 0;
 954      _this.startPosition = void 0;
 955      _this.lastPosition = void 0;
 956      _this.lastVelocity = void 0;
 957      _this.startTime = void 0;
 958      _this.lastTime = void 0;
 959      _this.done = false;
 960  
 961      _this.setValue = function (value, flush) {
 962        if (flush === void 0) {
 963          flush = true;
 964        }
 965  
 966        _this.value = value;
 967        if (flush) _this.flush();
 968      };
 969  
 970      _this.value = _value;
 971      _this.startPosition = _value;
 972      _this.lastPosition = _value;
 973      return _this;
 974    }
 975  
 976    var _proto = AnimatedValue.prototype;
 977  
 978    _proto.flush = function flush() {
 979      if (this.animatedStyles.size === 0) {
 980        addAnimatedStyles(this, this.animatedStyles);
 981      }
 982  
 983      this.animatedStyles.forEach(function (animatedStyle) {
 984        return animatedStyle.update();
 985      });
 986    };
 987  
 988    _proto.clearStyles = function clearStyles() {
 989      this.animatedStyles.clear();
 990    };
 991  
 992    _proto.getValue = function getValue() {
 993      return this.value;
 994    };
 995  
 996    _proto.interpolate = function interpolate(range, output, extrapolate) {
 997      return new AnimatedInterpolation(this, range, output, extrapolate);
 998    };
 999  
1000    return AnimatedValue;
1001  }(Animated);
1002  
1003  var AnimatedValueArray =
1004  /*#__PURE__*/
1005  function (_AnimatedArray) {
1006    _inheritsLoose(AnimatedValueArray, _AnimatedArray);
1007  
1008    function AnimatedValueArray(values) {
1009      var _this;
1010  
1011      _this = _AnimatedArray.call(this) || this;
1012      _this.payload = values.map(function (n) {
1013        return new AnimatedValue(n);
1014      });
1015      return _this;
1016    }
1017  
1018    var _proto = AnimatedValueArray.prototype;
1019  
1020    _proto.setValue = function setValue(value, flush) {
1021      var _this2 = this;
1022  
1023      if (flush === void 0) {
1024        flush = true;
1025      }
1026  
1027      if (Array.isArray(value)) {
1028        if (value.length === this.payload.length) {
1029          value.forEach(function (v, i) {
1030            return _this2.payload[i].setValue(v, flush);
1031          });
1032        }
1033      } else {
1034        this.payload.forEach(function (p) {
1035          return p.setValue(value, flush);
1036        });
1037      }
1038    };
1039  
1040    _proto.getValue = function getValue() {
1041      return this.payload.map(function (v) {
1042        return v.getValue();
1043      });
1044    };
1045  
1046    _proto.interpolate = function interpolate(range, output) {
1047      return new AnimatedInterpolation(this, range, output);
1048    };
1049  
1050    return AnimatedValueArray;
1051  }(AnimatedArray);
1052  
1053  var G = 0;
1054  
1055  var Controller =
1056  /*#__PURE__*/
1057  function () {
1058    function Controller() {
1059      var _this = this;
1060  
1061      this.id = void 0;
1062      this.idle = true;
1063      this.hasChanged = false;
1064      this.guid = 0;
1065      this.local = 0;
1066      this.props = {};
1067      this.merged = {};
1068      this.animations = {};
1069      this.interpolations = {};
1070      this.values = {};
1071      this.configs = [];
1072      this.listeners = [];
1073      this.queue = [];
1074      this.localQueue = void 0;
1075  
1076      this.getValues = function () {
1077        return _this.interpolations;
1078      };
1079  
1080      this.id = G++;
1081    }
1082    /** update(props)
1083     *  This function filters input props and creates an array of tasks which are executed in .start()
1084     *  Each task is allowed to carry a delay, which means it can execute asnychroneously */
1085  
1086  
1087    var _proto = Controller.prototype;
1088  
1089    _proto.update = function update$$1(args) {
1090      //this._id = n + this.id
1091      if (!args) return this; // Extract delay and the to-prop from props
1092  
1093      var _ref = interpolateTo(args),
1094          _ref$delay = _ref.delay,
1095          delay = _ref$delay === void 0 ? 0 : _ref$delay,
1096          to = _ref.to,
1097          props = _objectWithoutPropertiesLoose(_ref, ["delay", "to"]);
1098  
1099      if (is.arr(to) || is.fun(to)) {
1100        // If config is either a function or an array queue it up as is
1101        this.queue.push(_extends({}, props, {
1102          delay: delay,
1103          to: to
1104        }));
1105      } else if (to) {
1106        // Otherwise go through each key since it could be delayed individually
1107        var ops = {};
1108        Object.entries(to).forEach(function (_ref2) {
1109          var _to;
1110  
1111          var k = _ref2[0],
1112              v = _ref2[1];
1113  
1114          // Fetch delay and create an entry, consisting of the to-props, the delay, and basic props
1115          var entry = _extends({
1116            to: (_to = {}, _to[k] = v, _to),
1117            delay: callProp(delay, k)
1118          }, props);
1119  
1120          var previous = ops[entry.delay] && ops[entry.delay].to;
1121          ops[entry.delay] = _extends({}, ops[entry.delay], entry, {
1122            to: _extends({}, previous, entry.to)
1123          });
1124        });
1125        this.queue = Object.values(ops);
1126      } // Sort queue, so that async calls go last
1127  
1128  
1129      this.queue = this.queue.sort(function (a, b) {
1130        return a.delay - b.delay;
1131      }); // Diff the reduced props immediately (they'll contain the from-prop and some config)
1132  
1133      this.diff(props);
1134      return this;
1135    }
1136    /** start(onEnd)
1137     *  This function either executes a queue, if present, or starts the frameloop, which animates */
1138    ;
1139  
1140    _proto.start = function start$$1(onEnd) {
1141      var _this2 = this;
1142  
1143      // If a queue is present we must excecute it
1144      if (this.queue.length) {
1145        this.idle = false; // Updates can interrupt trailing queues, in that case we just merge values
1146  
1147        if (this.localQueue) {
1148          this.localQueue.forEach(function (_ref3) {
1149            var _ref3$from = _ref3.from,
1150                from = _ref3$from === void 0 ? {} : _ref3$from,
1151                _ref3$to = _ref3.to,
1152                to = _ref3$to === void 0 ? {} : _ref3$to;
1153            if (is.obj(from)) _this2.merged = _extends({}, from, _this2.merged);
1154            if (is.obj(to)) _this2.merged = _extends({}, _this2.merged, to);
1155          });
1156        } // The guid helps us tracking frames, a new queue over an old one means an override
1157        // We discard async calls in that caseÍ
1158  
1159  
1160        var local = this.local = ++this.guid;
1161        var queue = this.localQueue = this.queue;
1162        this.queue = []; // Go through each entry and execute it
1163  
1164        queue.forEach(function (_ref4, index) {
1165          var delay = _ref4.delay,
1166              props = _objectWithoutPropertiesLoose(_ref4, ["delay"]);
1167  
1168          var cb = function cb(finished) {
1169            if (index === queue.length - 1 && local === _this2.guid && finished) {
1170              _this2.idle = true;
1171              if (_this2.props.onRest) _this2.props.onRest(_this2.merged);
1172            }
1173  
1174            if (onEnd) onEnd();
1175          }; // Entries can be delayed, ansyc or immediate
1176  
1177  
1178          var async = is.arr(props.to) || is.fun(props.to);
1179  
1180          if (delay) {
1181            setTimeout(function () {
1182              if (local === _this2.guid) {
1183                if (async) _this2.runAsync(props, cb);else _this2.diff(props).start(cb);
1184              }
1185            }, delay);
1186          } else if (async) _this2.runAsync(props, cb);else _this2.diff(props).start(cb);
1187        });
1188      } // Otherwise we kick of the frameloop
1189      else {
1190          if (is.fun(onEnd)) this.listeners.push(onEnd);
1191          if (this.props.onStart) this.props.onStart();
1192  
1193          start(this);
1194        }
1195  
1196      return this;
1197    };
1198  
1199    _proto.stop = function stop$$1(finished) {
1200      this.listeners.forEach(function (onEnd) {
1201        return onEnd(finished);
1202      });
1203      this.listeners = [];
1204      return this;
1205    }
1206    /** Pause sets onEnd listeners free, but also removes the controller from the frameloop */
1207    ;
1208  
1209    _proto.pause = function pause(finished) {
1210      this.stop(true);
1211      if (finished) stop(this);
1212      return this;
1213    };
1214  
1215    _proto.runAsync = function runAsync(_ref5, onEnd) {
1216      var _this3 = this;
1217  
1218      var delay = _ref5.delay,
1219          props = _objectWithoutPropertiesLoose(_ref5, ["delay"]);
1220  
1221      var local = this.local; // If "to" is either a function or an array it will be processed async, therefor "to" should be empty right now
1222      // If the view relies on certain values "from" has to be present
1223  
1224      var queue = Promise.resolve(undefined);
1225  
1226      if (is.arr(props.to)) {
1227        var _loop = function _loop(i) {
1228          var index = i;
1229  
1230          var fresh = _extends({}, props, interpolateTo(props.to[index]));
1231  
1232          if (is.arr(fresh.config)) fresh.config = fresh.config[index];
1233          queue = queue.then(function () {
1234            //this.stop()
1235            if (local === _this3.guid) return new Promise(function (r) {
1236              return _this3.diff(fresh).start(r);
1237            });
1238          });
1239        };
1240  
1241        for (var i = 0; i < props.to.length; i++) {
1242          _loop(i);
1243        }
1244      } else if (is.fun(props.to)) {
1245        var index = 0;
1246        var last;
1247        queue = queue.then(function () {
1248          return props.to( // next(props)
1249          function (p) {
1250            var fresh = _extends({}, props, interpolateTo(p));
1251  
1252            if (is.arr(fresh.config)) fresh.config = fresh.config[index];
1253            index++; //this.stop()
1254  
1255            if (local === _this3.guid) return last = new Promise(function (r) {
1256              return _this3.diff(fresh).start(r);
1257            });
1258            return;
1259          }, // cancel()
1260          function (finished) {
1261            if (finished === void 0) {
1262              finished = true;
1263            }
1264  
1265            return _this3.stop(finished);
1266          }).then(function () {
1267            return last;
1268          });
1269        });
1270      }
1271  
1272      queue.then(onEnd);
1273    };
1274  
1275    _proto.diff = function diff(props) {
1276      var _this4 = this;
1277  
1278      this.props = _extends({}, this.props, props);
1279      var _this$props = this.props,
1280          _this$props$from = _this$props.from,
1281          from = _this$props$from === void 0 ? {} : _this$props$from,
1282          _this$props$to = _this$props.to,
1283          to = _this$props$to === void 0 ? {} : _this$props$to,
1284          _this$props$config = _this$props.config,
1285          config = _this$props$config === void 0 ? {} : _this$props$config,
1286          reverse = _this$props.reverse,
1287          attach = _this$props.attach,
1288          reset = _this$props.reset,
1289          immediate = _this$props.immediate; // Reverse values when requested
1290  
1291      if (reverse) {
1292        var _ref6 = [to, from];
1293        from = _ref6[0];
1294        to = _ref6[1];
1295      } // This will collect all props that were ever set, reset merged props when necessary
1296  
1297  
1298      this.merged = _extends({}, from, this.merged, to);
1299      this.hasChanged = false; // Attachment handling, trailed springs can "attach" themselves to a previous spring
1300  
1301      var target = attach && attach(this); // Reduces input { name: value } pairs into animated values
1302  
1303      this.animations = Object.entries(this.merged).reduce(function (acc, _ref7) {
1304        var name = _ref7[0],
1305            value = _ref7[1];
1306        // Issue cached entries, except on reset
1307        var entry = acc[name] || {}; // Figure out what the value is supposed to be
1308  
1309        var isNumber = is.num(value);
1310        var isString = is.str(value) && !value.startsWith('#') && !/\d/.test(value) && !colorNames[value];
1311        var isArray = is.arr(value);
1312        var isInterpolation = !isNumber && !isArray && !isString;
1313        var fromValue = !is.und(from[name]) ? from[name] : value;
1314        var toValue = isNumber || isArray ? value : isString ? value : 1;
1315        var toConfig = callProp(config, name);
1316        if (target) toValue = target.animations[name].parent;
1317        var parent = entry.parent,
1318            interpolation$$1 = entry.interpolation,
1319            toValues = toArray(target ? toValue.getPayload() : toValue),
1320            animatedValues;
1321        var newValue = value;
1322        if (isInterpolation) newValue = interpolation({
1323          range: [0, 1],
1324          output: [value, value]
1325        })(1);
1326        var currentValue = interpolation$$1 && interpolation$$1.getValue(); // Change detection flags
1327  
1328        var isFirst = is.und(parent);
1329        var isActive = !isFirst && entry.animatedValues.some(function (v) {
1330          return !v.done;
1331        });
1332        var currentValueDiffersFromGoal = !is.equ(newValue, currentValue);
1333        var hasNewGoal = !is.equ(newValue, entry.previous);
1334        var hasNewConfig = !is.equ(toConfig, entry.config); // Change animation props when props indicate a new goal (new value differs from previous one)
1335        // and current values differ from it. Config changes trigger a new update as well (though probably shouldn't?)
1336  
1337        if (reset || hasNewGoal && currentValueDiffersFromGoal || hasNewConfig) {
1338          var _extends2;
1339  
1340          // Convert regular values into animated values, ALWAYS re-use if possible
1341          if (isNumber || isString) parent = interpolation$$1 = entry.parent || new AnimatedValue(fromValue);else if (isArray) parent = interpolation$$1 = entry.parent || new AnimatedValueArray(fromValue);else if (isInterpolation) {
1342            var prev = entry.interpolation && entry.interpolation.calc(entry.parent.value);
1343            prev = prev !== void 0 && !reset ? prev : fromValue;
1344  
1345            if (entry.parent) {
1346              parent = entry.parent;
1347              parent.setValue(0, false);
1348            } else parent = new AnimatedValue(0);
1349  
1350            var range = {
1351              output: [prev, value]
1352            };
1353  
1354            if (entry.interpolation) {
1355              interpolation$$1 = entry.interpolation;
1356              entry.interpolation.updateConfig(range);
1357            } else interpolation$$1 = parent.interpolate(range);
1358          }
1359          toValues = toArray(target ? toValue.getPayload() : toValue);
1360          animatedValues = toArray(parent.getPayload());
1361          if (reset && !isInterpolation) parent.setValue(fromValue, false);
1362          _this4.hasChanged = true; // Reset animated values
1363  
1364          animatedValues.forEach(function (value) {
1365            value.startPosition = value.value;
1366            value.lastPosition = value.value;
1367            value.lastVelocity = isActive ? value.lastVelocity : undefined;
1368            value.lastTime = isActive ? value.lastTime : undefined;
1369            value.startTime = now();
1370            value.done = false;
1371            value.animatedStyles.clear();
1372          }); // Set immediate values
1373  
1374          if (callProp(immediate, name)) {
1375            parent.setValue(isInterpolation ? toValue : value, false);
1376          }
1377  
1378          return _extends({}, acc, (_extends2 = {}, _extends2[name] = _extends({}, entry, {
1379            name: name,
1380            parent: parent,
1381            interpolation: interpolation$$1,
1382            animatedValues: animatedValues,
1383            toValues: toValues,
1384            previous: newValue,
1385            config: toConfig,
1386            fromValues: toArray(parent.getValue()),
1387            immediate: callProp(immediate, name),
1388            initialVelocity: withDefault(toConfig.velocity, 0),
1389            clamp: withDefault(toConfig.clamp, false),
1390            precision: withDefault(toConfig.precision, 0.01),
1391            tension: withDefault(toConfig.tension, 170),
1392            friction: withDefault(toConfig.friction, 26),
1393            mass: withDefault(toConfig.mass, 1),
1394            duration: toConfig.duration,
1395            easing: withDefault(toConfig.easing, function (t) {
1396              return t;
1397            }),
1398            decay: toConfig.decay
1399          }), _extends2));
1400        } else {
1401          if (!currentValueDiffersFromGoal) {
1402            var _extends3;
1403  
1404            // So ... the current target value (newValue) appears to be different from the previous value,
1405            // which normally constitutes an update, but the actual value (currentValue) matches the target!
1406            // In order to resolve this without causing an animation update we silently flag the animation as done,
1407            // which it technically is. Interpolations also needs a config update with their target set to 1.
1408            if (isInterpolation) {
1409              parent.setValue(1, false);
1410              interpolation$$1.updateConfig({
1411                output: [newValue, newValue]
1412              });
1413            }
1414  
1415            parent.done = true;
1416            _this4.hasChanged = true;
1417            return _extends({}, acc, (_extends3 = {}, _extends3[name] = _extends({}, acc[name], {
1418              previous: newValue
1419            }), _extends3));
1420          }
1421  
1422          return acc;
1423        }
1424      }, this.animations);
1425  
1426      if (this.hasChanged) {
1427        // Make animations available to frameloop
1428        this.configs = Object.values(this.animations);
1429        this.values = {};
1430        this.interpolations = {};
1431  
1432        for (var key in this.animations) {
1433          this.interpolations[key] = this.animations[key].interpolation;
1434          this.values[key] = this.animations[key].interpolation.getValue();
1435        }
1436      }
1437  
1438      return this;
1439    };
1440  
1441    _proto.destroy = function destroy() {
1442      this.stop();
1443      this.props = {};
1444      this.merged = {};
1445      this.animations = {};
1446      this.interpolations = {};
1447      this.values = {};
1448      this.configs = [];
1449      this.local = 0;
1450    };
1451  
1452    return Controller;
1453  }();
1454  
1455  /** API
1456   * const props = useSprings(number, [{ ... }, { ... }, ...])
1457   * const [props, set] = useSprings(number, (i, controller) => ({ ... }))
1458   */
1459  
1460  var useSprings = function useSprings(length, props) {
1461    var mounted = React.useRef(false);
1462    var ctrl = React.useRef();
1463    var isFn = is.fun(props); // The controller maintains the animation values, starts and stops animations
1464  
1465    var _useMemo = React.useMemo(function () {
1466      // Remove old controllers
1467      if (ctrl.current) {
1468        ctrl.current.map(function (c) {
1469          return c.destroy();
1470        });
1471        ctrl.current = undefined;
1472      }
1473  
1474      var ref;
1475      return [new Array(length).fill().map(function (_, i) {
1476        var ctrl = new Controller();
1477        var newProps = isFn ? callProp(props, i, ctrl) : props[i];
1478        if (i === 0) ref = newProps.ref;
1479        ctrl.update(newProps);
1480        if (!ref) ctrl.start();
1481        return ctrl;
1482      }), ref];
1483    }, [length]),
1484        controllers = _useMemo[0],
1485        ref = _useMemo[1];
1486  
1487    ctrl.current = controllers; // The hooks reference api gets defined here ...
1488  
1489    var api = React.useImperativeHandle(ref, function () {
1490      return {
1491        start: function start() {
1492          return Promise.all(ctrl.current.map(function (c) {
1493            return new Promise(function (r) {
1494              return c.start(r);
1495            });
1496          }));
1497        },
1498        stop: function stop(finished) {
1499          return ctrl.current.forEach(function (c) {
1500            return c.stop(finished);
1501          });
1502        },
1503  
1504        get controllers() {
1505          return ctrl.current;
1506        }
1507  
1508      };
1509    }); // This function updates the controllers
1510  
1511    var updateCtrl = React.useMemo(function () {
1512      return function (updateProps) {
1513        return ctrl.current.map(function (c, i) {
1514          c.update(isFn ? callProp(updateProps, i, c) : updateProps[i]);
1515          if (!ref) c.start();
1516        });
1517      };
1518    }, [length]); // Update controller if props aren't functional
1519  
1520    React.useEffect(function () {
1521      if (mounted.current) {
1522        if (!isFn) updateCtrl(props);
1523      } else if (!ref) ctrl.current.forEach(function (c) {
1524        return c.start();
1525      });
1526    }); // Update mounted flag and destroy controller on unmount
1527  
1528    React.useEffect(function () {
1529      return mounted.current = true, function () {
1530        return ctrl.current.forEach(function (c) {
1531          return c.destroy();
1532        });
1533      };
1534    }, []); // Return animated props, or, anim-props + the update-setter above
1535  
1536    var propValues = ctrl.current.map(function (c) {
1537      return c.getValues();
1538    });
1539    return isFn ? [propValues, updateCtrl, function (finished) {
1540      return ctrl.current.forEach(function (c) {
1541        return c.pause(finished);
1542      });
1543    }] : propValues;
1544  };
1545  
1546  /** API
1547   * const props = useSpring({ ... })
1548   * const [props, set] = useSpring(() => ({ ... }))
1549   */
1550  
1551  var useSpring = function useSpring(props) {
1552    var isFn = is.fun(props);
1553  
1554    var _useSprings = useSprings(1, isFn ? props : [props]),
1555        result = _useSprings[0],
1556        set = _useSprings[1],
1557        pause = _useSprings[2];
1558  
1559    return isFn ? [result[0], set, pause] : result;
1560  };
1561  
1562  /** API
1563   * const trails = useTrail(number, { ... })
1564   * const [trails, set] = useTrail(number, () => ({ ... }))
1565   */
1566  
1567  var useTrail = function useTrail(length, props) {
1568    var mounted = React.useRef(false);
1569    var isFn = is.fun(props);
1570    var updateProps = callProp(props);
1571    var instances = React.useRef();
1572  
1573    var _useSprings = useSprings(length, function (i, ctrl) {
1574      if (i === 0) instances.current = [];
1575      instances.current.push(ctrl);
1576      return _extends({}, updateProps, {
1577        config: callProp(updateProps.config, i),
1578        attach: i > 0 && function () {
1579          return instances.current[i - 1];
1580        }
1581      });
1582    }),
1583        result = _useSprings[0],
1584        set = _useSprings[1],
1585        pause = _useSprings[2]; // Set up function to update controller
1586  
1587  
1588    var updateCtrl = React.useMemo(function () {
1589      return function (props) {
1590        return set(function (i, ctrl) {
1591          var last = props.reverse ? i === 0 : length - 1 === i;
1592          var attachIdx = props.reverse ? i + 1 : i - 1;
1593          var attachController = instances.current[attachIdx];
1594          return _extends({}, props, {
1595            config: callProp(props.config || updateProps.config, i),
1596            attach: attachController && function () {
1597              return attachController;
1598            }
1599          });
1600        });
1601      };
1602    }, [length, updateProps.reverse]); // Update controller if props aren't functional
1603  
1604    React.useEffect(function () {
1605      return void (mounted.current && !isFn && updateCtrl(props));
1606    }); // Update mounted flag and destroy controller on unmount
1607  
1608    React.useEffect(function () {
1609      return void (mounted.current = true);
1610    }, []);
1611    return isFn ? [result, updateCtrl, pause] : result;
1612  };
1613  
1614  /** API
1615   * const transitions = useTransition(items, itemKeys, { ... })
1616   * const [transitions, update] = useTransition(items, itemKeys, () => ({ ... }))
1617   */
1618  
1619  var guid = 0;
1620  var ENTER = 'enter';
1621  var LEAVE = 'leave';
1622  var UPDATE = 'update';
1623  
1624  var mapKeys = function mapKeys(items, keys) {
1625    return (typeof keys === 'function' ? items.map(keys) : toArray(keys)).map(String);
1626  };
1627  
1628  var get = function get(props) {
1629    var items = props.items,
1630        _props$keys = props.keys,
1631        keys = _props$keys === void 0 ? function (item) {
1632      return item;
1633    } : _props$keys,
1634        rest = _objectWithoutPropertiesLoose(props, ["items", "keys"]);
1635  
1636    items = toArray(items !== void 0 ? items : null);
1637    return _extends({
1638      items: items,
1639      keys: mapKeys(items, keys)
1640    }, rest);
1641  };
1642  
1643  function useTransition(input, keyTransform, config) {
1644    var props = _extends({
1645      items: input,
1646      keys: keyTransform || function (i) {
1647        return i;
1648      }
1649    }, config);
1650  
1651    var _get = get(props),
1652        _get$lazy = _get.lazy,
1653        lazy = _get$lazy === void 0 ? false : _get$lazy,
1654        _get$unique = _get.unique,
1655        _get$reset = _get.reset,
1656        reset = _get$reset === void 0 ? false : _get$reset,
1657        enter = _get.enter,
1658        leave = _get.leave,
1659        update = _get.update,
1660        onDestroyed = _get.onDestroyed,
1661        keys = _get.keys,
1662        items = _get.items,
1663        onFrame = _get.onFrame,
1664        _onRest = _get.onRest,
1665        onStart = _get.onStart,
1666        ref = _get.ref,
1667        extra = _objectWithoutPropertiesLoose(_get, ["lazy", "unique", "reset", "enter", "leave", "update", "onDestroyed", "keys", "items", "onFrame", "onRest", "onStart", "ref"]);
1668  
1669    var forceUpdate = useForceUpdate();
1670    var mounted = React.useRef(false);
1671    var state = React.useRef({
1672      mounted: false,
1673      first: true,
1674      deleted: [],
1675      current: {},
1676      transitions: [],
1677      prevProps: {},
1678      paused: !!props.ref,
1679      instances: !mounted.current && new Map(),
1680      forceUpdate: forceUpdate
1681    });
1682    React.useImperativeHandle(props.ref, function () {
1683      return {
1684        start: function start() {
1685          return Promise.all(Array.from(state.current.instances).map(function (_ref) {
1686            var c = _ref[1];
1687            return new Promise(function (r) {
1688              return c.start(r);
1689            });
1690          }));
1691        },
1692        stop: function stop(finished) {
1693          return Array.from(state.current.instances).forEach(function (_ref2) {
1694            var c = _ref2[1];
1695            return c.stop(finished);
1696          });
1697        },
1698  
1699        get controllers() {
1700          return Array.from(state.current.instances).map(function (_ref3) {
1701            var c = _ref3[1];
1702            return c;
1703          });
1704        }
1705  
1706      };
1707    }); // Update state
1708  
1709    state.current = diffItems(state.current, props);
1710  
1711    if (state.current.changed) {
1712      // Update state
1713      state.current.transitions.forEach(function (transition) {
1714        var slot = transition.slot,
1715            from = transition.from,
1716            to = transition.to,
1717            config = transition.config,
1718            trail = transition.trail,
1719            key = transition.key,
1720            item = transition.item;
1721        if (!state.current.instances.has(key)) state.current.instances.set(key, new Controller()); // update the map object
1722  
1723        var ctrl = state.current.instances.get(key);
1724  
1725        var newProps = _extends({}, extra, {
1726          to: to,
1727          from: from,
1728          config: config,
1729          ref: ref,
1730          onRest: function onRest(values) {
1731            if (state.current.mounted) {
1732              if (transition.destroyed) {
1733                // If no ref is given delete destroyed items immediately
1734                if (!ref && !lazy) cleanUp(state, key);
1735                if (onDestroyed) onDestroyed(item);
1736              } // A transition comes to rest once all its springs conclude
1737  
1738  
1739              var curInstances = Array.from(state.current.instances);
1740              var active = curInstances.some(function (_ref4) {
1741                var c = _ref4[1];
1742                return !c.idle;
1743              });
1744              if (!active && (ref || lazy) && state.current.deleted.length > 0) cleanUp(state);
1745              if (_onRest) _onRest(item, slot, values);
1746            }
1747          },
1748          onStart: onStart && function () {
1749            return onStart(item, slot);
1750          },
1751          onFrame: onFrame && function (values) {
1752            return onFrame(item, slot, values);
1753          },
1754          delay: trail,
1755          reset: reset && slot === ENTER // Update controller
1756  
1757        });
1758  
1759        ctrl.update(newProps);
1760        if (!state.current.paused) ctrl.start();
1761      });
1762    }
1763  
1764    React.useEffect(function () {
1765      state.current.mounted = mounted.current = true;
1766      return function () {
1767        state.current.mounted = mounted.current = false;
1768        Array.from(state.current.instances).map(function (_ref5) {
1769          var c = _ref5[1];
1770          return c.destroy();
1771        });
1772        state.current.instances.clear();
1773      };
1774    }, []);
1775    return state.current.transitions.map(function (_ref6) {
1776      var item = _ref6.item,
1777          slot = _ref6.slot,
1778          key = _ref6.key;
1779      return {
1780        item: item,
1781        key: key,
1782        state: slot,
1783        props: state.current.instances.get(key).getValues()
1784      };
1785    });
1786  }
1787  
1788  function cleanUp(state, filterKey) {
1789    var deleted = state.current.deleted;
1790  
1791    var _loop = function _loop() {
1792      if (_isArray) {
1793        if (_i >= _iterator.length) return "break";
1794        _ref8 = _iterator[_i++];
1795      } else {
1796        _i = _iterator.next();
1797        if (_i.done) return "break";
1798        _ref8 = _i.value;
1799      }
1800  
1801      var _ref7 = _ref8;
1802      var key = _ref7.key;
1803  
1804      var filter = function filter(t) {
1805        return t.key !== key;
1806      };
1807  
1808      if (is.und(filterKey) || filterKey === key) {
1809        state.current.instances.delete(key);
1810        state.current.transitions = state.current.transitions.filter(filter);
1811        state.current.deleted = state.current.deleted.filter(filter);
1812      }
1813    };
1814  
1815    for (var _iterator = deleted, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
1816      var _ref8;
1817  
1818      var _ret = _loop();
1819  
1820      if (_ret === "break") break;
1821    }
1822  
1823    state.current.forceUpdate();
1824  }
1825  
1826  function diffItems(_ref9, props) {
1827    var first = _ref9.first,
1828        prevProps = _ref9.prevProps,
1829        state = _objectWithoutPropertiesLoose(_ref9, ["first", "prevProps"]);
1830  
1831    var _get2 = get(props),
1832        items = _get2.items,
1833        keys = _get2.keys,
1834        initial = _get2.initial,
1835        from = _get2.from,
1836        enter = _get2.enter,
1837        leave = _get2.leave,
1838        update = _get2.update,
1839        _get2$trail = _get2.trail,
1840        trail = _get2$trail === void 0 ? 0 : _get2$trail,
1841        unique = _get2.unique,
1842        config = _get2.config,
1843        _get2$order = _get2.order,
1844        order = _get2$order === void 0 ? [ENTER, LEAVE, UPDATE] : _get2$order;
1845  
1846    var _get3 = get(prevProps),
1847        _keys = _get3.keys,
1848        _items = _get3.items;
1849  
1850    var current = _extends({}, state.current);
1851  
1852    var deleted = [].concat(state.deleted); // Compare next keys with current keys
1853  
1854    var currentKeys = Object.keys(current);
1855    var currentSet = new Set(currentKeys);
1856    var nextSet = new Set(keys);
1857    var added = keys.filter(function (item) {
1858      return !currentSet.has(item);
1859    });
1860    var removed = state.transitions.filter(function (item) {
1861      return !item.destroyed && !nextSet.has(item.originalKey);
1862    }).map(function (i) {
1863      return i.originalKey;
1864    });
1865    var updated = keys.filter(function (item) {
1866      return currentSet.has(item);
1867    });
1868    var delay = -trail;
1869  
1870    while (order.length) {
1871      var changeType = order.shift();
1872  
1873      switch (changeType) {
1874        case ENTER:
1875          {
1876            added.forEach(function (key, index) {
1877              // In unique mode, remove fading out transitions if their key comes in again
1878              if (unique && deleted.find(function (d) {
1879                return d.originalKey === key;
1880              })) deleted = deleted.filter(function (t) {
1881                return t.originalKey !== key;
1882              });
1883              var keyIndex = keys.indexOf(key);
1884              var item = items[keyIndex];
1885              var slot = first && initial !== void 0 ? 'initial' : ENTER;
1886              current[key] = {
1887                slot: slot,
1888                originalKey: key,
1889                key: unique ? String(key) : guid++,
1890                item: item,
1891                trail: delay = delay + trail,
1892                config: callProp(config, item, slot),
1893                from: callProp(first ? initial !== void 0 ? initial || {} : from : from, item),
1894                to: callProp(enter, item)
1895              };
1896            });
1897            break;
1898          }
1899  
1900        case LEAVE:
1901          {
1902            removed.forEach(function (key) {
1903              var keyIndex = _keys.indexOf(key);
1904  
1905              var item = _items[keyIndex];
1906              var slot = LEAVE;
1907              deleted.unshift(_extends({}, current[key], {
1908                slot: slot,
1909                destroyed: true,
1910                left: _keys[Math.max(0, keyIndex - 1)],
1911                right: _keys[Math.min(_keys.length, keyIndex + 1)],
1912                trail: delay = delay + trail,
1913                config: callProp(config, item, slot),
1914                to: callProp(leave, item)
1915              }));
1916              delete current[key];
1917            });
1918            break;
1919          }
1920  
1921        case UPDATE:
1922          {
1923            updated.forEach(function (key) {
1924              var keyIndex = keys.indexOf(key);
1925              var item = items[keyIndex];
1926              var slot = UPDATE;
1927              current[key] = _extends({}, current[key], {
1928                item: item,
1929                slot: slot,
1930                trail: delay = delay + trail,
1931                config: callProp(config, item, slot),
1932                to: callProp(update, item)
1933              });
1934            });
1935            break;
1936          }
1937      }
1938    }
1939  
1940    var out = keys.map(function (key) {
1941      return current[key];
1942    }); // This tries to restore order for deleted items by finding their last known siblings
1943    // only using the left sibling to keep order placement consistent for all deleted items
1944  
1945    deleted.forEach(function (_ref10) {
1946      var left = _ref10.left,
1947          right = _ref10.right,
1948          item = _objectWithoutPropertiesLoose(_ref10, ["left", "right"]);
1949  
1950      var pos; // Was it the element on the left, if yes, move there ...
1951  
1952      if ((pos = out.findIndex(function (t) {
1953        return t.originalKey === left;
1954      })) !== -1) pos += 1; // And if nothing else helps, move it to the start ¯\_(ツ)_/¯
1955  
1956      pos = Math.max(0, pos);
1957      out = [].concat(out.slice(0, pos), [item], out.slice(pos));
1958    });
1959    return _extends({}, state, {
1960      changed: added.length || removed.length || updated.length,
1961      first: first && added.length === 0,
1962      transitions: out,
1963      current: current,
1964      deleted: deleted,
1965      prevProps: props
1966    });
1967  }
1968  
1969  var AnimatedStyle =
1970  /*#__PURE__*/
1971  function (_AnimatedObject) {
1972    _inheritsLoose(AnimatedStyle, _AnimatedObject);
1973  
1974    function AnimatedStyle(style) {
1975      var _this;
1976  
1977      if (style === void 0) {
1978        style = {};
1979      }
1980  
1981      _this = _AnimatedObject.call(this) || this;
1982  
1983      if (style.transform && !(style.transform instanceof Animated)) {
1984        style = applyAnimatedValues.transform(style);
1985      }
1986  
1987      _this.payload = style;
1988      return _this;
1989    }
1990  
1991    return AnimatedStyle;
1992  }(AnimatedObject);
1993  
1994  // http://www.w3.org/TR/css3-color/#svg-color
1995  var colors = {
1996    transparent: 0x00000000,
1997    aliceblue: 0xf0f8ffff,
1998    antiquewhite: 0xfaebd7ff,
1999    aqua: 0x00ffffff,
2000    aquamarine: 0x7fffd4ff,
2001    azure: 0xf0ffffff,
2002    beige: 0xf5f5dcff,
2003    bisque: 0xffe4c4ff,
2004    black: 0x000000ff,
2005    blanchedalmond: 0xffebcdff,
2006    blue: 0x0000ffff,
2007    blueviolet: 0x8a2be2ff,
2008    brown: 0xa52a2aff,
2009    burlywood: 0xdeb887ff,
2010    burntsienna: 0xea7e5dff,
2011    cadetblue: 0x5f9ea0ff,
2012    chartreuse: 0x7fff00ff,
2013    chocolate: 0xd2691eff,
2014    coral: 0xff7f50ff,
2015    cornflowerblue: 0x6495edff,
2016    cornsilk: 0xfff8dcff,
2017    crimson: 0xdc143cff,
2018    cyan: 0x00ffffff,
2019    darkblue: 0x00008bff,
2020    darkcyan: 0x008b8bff,
2021    darkgoldenrod: 0xb8860bff,
2022    darkgray: 0xa9a9a9ff,
2023    darkgreen: 0x006400ff,
2024    darkgrey: 0xa9a9a9ff,
2025    darkkhaki: 0xbdb76bff,
2026    darkmagenta: 0x8b008bff,
2027    darkolivegreen: 0x556b2fff,
2028    darkorange: 0xff8c00ff,
2029    darkorchid: 0x9932ccff,
2030    darkred: 0x8b0000ff,
2031    darksalmon: 0xe9967aff,
2032    darkseagreen: 0x8fbc8fff,
2033    darkslateblue: 0x483d8bff,
2034    darkslategray: 0x2f4f4fff,
2035    darkslategrey: 0x2f4f4fff,
2036    darkturquoise: 0x00ced1ff,
2037    darkviolet: 0x9400d3ff,
2038    deeppink: 0xff1493ff,
2039    deepskyblue: 0x00bfffff,
2040    dimgray: 0x696969ff,
2041    dimgrey: 0x696969ff,
2042    dodgerblue: 0x1e90ffff,
2043    firebrick: 0xb22222ff,
2044    floralwhite: 0xfffaf0ff,
2045    forestgreen: 0x228b22ff,
2046    fuchsia: 0xff00ffff,
2047    gainsboro: 0xdcdcdcff,
2048    ghostwhite: 0xf8f8ffff,
2049    gold: 0xffd700ff,
2050    goldenrod: 0xdaa520ff,
2051    gray: 0x808080ff,
2052    green: 0x008000ff,
2053    greenyellow: 0xadff2fff,
2054    grey: 0x808080ff,
2055    honeydew: 0xf0fff0ff,
2056    hotpink: 0xff69b4ff,
2057    indianred: 0xcd5c5cff,
2058    indigo: 0x4b0082ff,
2059    ivory: 0xfffff0ff,
2060    khaki: 0xf0e68cff,
2061    lavender: 0xe6e6faff,
2062    lavenderblush: 0xfff0f5ff,
2063    lawngreen: 0x7cfc00ff,
2064    lemonchiffon: 0xfffacdff,
2065    lightblue: 0xadd8e6ff,
2066    lightcoral: 0xf08080ff,
2067    lightcyan: 0xe0ffffff,
2068    lightgoldenrodyellow: 0xfafad2ff,
2069    lightgray: 0xd3d3d3ff,
2070    lightgreen: 0x90ee90ff,
2071    lightgrey: 0xd3d3d3ff,
2072    lightpink: 0xffb6c1ff,
2073    lightsalmon: 0xffa07aff,
2074    lightseagreen: 0x20b2aaff,
2075    lightskyblue: 0x87cefaff,
2076    lightslategray: 0x778899ff,
2077    lightslategrey: 0x778899ff,
2078    lightsteelblue: 0xb0c4deff,
2079    lightyellow: 0xffffe0ff,
2080    lime: 0x00ff00ff,
2081    limegreen: 0x32cd32ff,
2082    linen: 0xfaf0e6ff,
2083    magenta: 0xff00ffff,
2084    maroon: 0x800000ff,
2085    mediumaquamarine: 0x66cdaaff,
2086    mediumblue: 0x0000cdff,
2087    mediumorchid: 0xba55d3ff,
2088    mediumpurple: 0x9370dbff,
2089    mediumseagreen: 0x3cb371ff,
2090    mediumslateblue: 0x7b68eeff,
2091    mediumspringgreen: 0x00fa9aff,
2092    mediumturquoise: 0x48d1ccff,
2093    mediumvioletred: 0xc71585ff,
2094    midnightblue: 0x191970ff,
2095    mintcream: 0xf5fffaff,
2096    mistyrose: 0xffe4e1ff,
2097    moccasin: 0xffe4b5ff,
2098    navajowhite: 0xffdeadff,
2099    navy: 0x000080ff,
2100    oldlace: 0xfdf5e6ff,
2101    olive: 0x808000ff,
2102    olivedrab: 0x6b8e23ff,
2103    orange: 0xffa500ff,
2104    orangered: 0xff4500ff,
2105    orchid: 0xda70d6ff,
2106    palegoldenrod: 0xeee8aaff,
2107    palegreen: 0x98fb98ff,
2108    paleturquoise: 0xafeeeeff,
2109    palevioletred: 0xdb7093ff,
2110    papayawhip: 0xffefd5ff,
2111    peachpuff: 0xffdab9ff,
2112    peru: 0xcd853fff,
2113    pink: 0xffc0cbff,
2114    plum: 0xdda0ddff,
2115    powderblue: 0xb0e0e6ff,
2116    purple: 0x800080ff,
2117    rebeccapurple: 0x663399ff,
2118    red: 0xff0000ff,
2119    rosybrown: 0xbc8f8fff,
2120    royalblue: 0x4169e1ff,
2121    saddlebrown: 0x8b4513ff,
2122    salmon: 0xfa8072ff,
2123    sandybrown: 0xf4a460ff,
2124    seagreen: 0x2e8b57ff,
2125    seashell: 0xfff5eeff,
2126    sienna: 0xa0522dff,
2127    silver: 0xc0c0c0ff,
2128    skyblue: 0x87ceebff,
2129    slateblue: 0x6a5acdff,
2130    slategray: 0x708090ff,
2131    slategrey: 0x708090ff,
2132    snow: 0xfffafaff,
2133    springgreen: 0x00ff7fff,
2134    steelblue: 0x4682b4ff,
2135    tan: 0xd2b48cff,
2136    teal: 0x008080ff,
2137    thistle: 0xd8bfd8ff,
2138    tomato: 0xff6347ff,
2139    turquoise: 0x40e0d0ff,
2140    violet: 0xee82eeff,
2141    wheat: 0xf5deb3ff,
2142    white: 0xffffffff,
2143    whitesmoke: 0xf5f5f5ff,
2144    yellow: 0xffff00ff,
2145    yellowgreen: 0x9acd32ff
2146  };
2147  
2148  // const INTEGER = '[-+]?\\d+';
2149  var NUMBER = '[-+]?\\d*\\.?\\d+';
2150  var PERCENTAGE = NUMBER + '%';
2151  
2152  function call() {
2153    for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) {
2154      parts[_key] = arguments[_key];
2155    }
2156  
2157    return '\\(\\s*(' + parts.join(')\\s*,\\s*(') + ')\\s*\\)';
2158  }
2159  
2160  var rgb = new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER));
2161  var rgba = new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER));
2162  var hsl = new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE));
2163  var hsla = new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER));
2164  var hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
2165  var hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
2166  var hex6 = /^#([0-9a-fA-F]{6})$/;
2167  var hex8 = /^#([0-9a-fA-F]{8})$/;
2168  
2169  /*
2170  https://github.com/react-community/normalize-css-color
2171  
2172  BSD 3-Clause License
2173  
2174  Copyright (c) 2016, React Community
2175  All rights reserved.
2176  
2177  Redistribution and use in source and binary forms, with or without
2178  modification, are permitted provided that the following conditions are met:
2179  
2180  * Redistributions of source code must retain the above copyright notice, this
2181    list of conditions and the following disclaimer.
2182  
2183  * Redistributions in binary form must reproduce the above copyright notice,
2184    this list of conditions and the following disclaimer in the documentation
2185    and/or other materials provided with the distribution.
2186  
2187  * Neither the name of the copyright holder nor the names of its
2188    contributors may be used to endorse or promote products derived from
2189    this software without specific prior written permission.
2190  
2191  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
2192  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
2193  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
2194  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
2195  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
2196  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
2197  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
2198  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
2199  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
2200  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2201  */
2202  function normalizeColor(color) {
2203    var match;
2204  
2205    if (typeof color === 'number') {
2206      return color >>> 0 === color && color >= 0 && color <= 0xffffffff ? color : null;
2207    } // Ordered based on occurrences on Facebook codebase
2208  
2209  
2210    if (match = hex6.exec(color)) return parseInt(match[1] + 'ff', 16) >>> 0;
2211    if (colors.hasOwnProperty(color)) return colors[color];
2212  
2213    if (match = rgb.exec(color)) {
2214      return (parse255(match[1]) << 24 | // r
2215      parse255(match[2]) << 16 | // g
2216      parse255(match[3]) << 8 | // b
2217      0x000000ff) >>> // a
2218      0;
2219    }
2220  
2221    if (match = rgba.exec(color)) {
2222      return (parse255(match[1]) << 24 | // r
2223      parse255(match[2]) << 16 | // g
2224      parse255(match[3]) << 8 | // b
2225      parse1(match[4])) >>> // a
2226      0;
2227    }
2228  
2229    if (match = hex3.exec(color)) {
2230      return parseInt(match[1] + match[1] + // r
2231      match[2] + match[2] + // g
2232      match[3] + match[3] + // b
2233      'ff', // a
2234      16) >>> 0;
2235    } // https://drafts.csswg.org/css-color-4/#hex-notation
2236  
2237  
2238    if (match = hex8.exec(color)) return parseInt(match[1], 16) >>> 0;
2239  
2240    if (match = hex4.exec(color)) {
2241      return parseInt(match[1] + match[1] + // r
2242      match[2] + match[2] + // g
2243      match[3] + match[3] + // b
2244      match[4] + match[4], // a
2245      16) >>> 0;
2246    }
2247  
2248    if (match = hsl.exec(color)) {
2249      return (hslToRgb(parse360(match[1]), // h
2250      parsePercentage(match[2]), // s
2251      parsePercentage(match[3]) // l
2252      ) | 0x000000ff) >>> // a
2253      0;
2254    }
2255  
2256    if (match = hsla.exec(color)) {
2257      return (hslToRgb(parse360(match[1]), // h
2258      parsePercentage(match[2]), // s
2259      parsePercentage(match[3]) // l
2260      ) | parse1(match[4])) >>> // a
2261      0;
2262    }
2263  
2264    return null;
2265  }
2266  
2267  function hue2rgb(p, q, t) {
2268    if (t < 0) t += 1;
2269    if (t > 1) t -= 1;
2270    if (t < 1 / 6) return p + (q - p) * 6 * t;
2271    if (t < 1 / 2) return q;
2272    if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
2273    return p;
2274  }
2275  
2276  function hslToRgb(h, s, l) {
2277    var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
2278    var p = 2 * l - q;
2279    var r = hue2rgb(p, q, h + 1 / 3);
2280    var g = hue2rgb(p, q, h);
2281    var b = hue2rgb(p, q, h - 1 / 3);
2282    return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8;
2283  }
2284  
2285  function parse255(str) {
2286    var int = parseInt(str, 10);
2287    if (int < 0) return 0;
2288    if (int > 255) return 255;
2289    return int;
2290  }
2291  
2292  function parse360(str) {
2293    var int = parseFloat(str);
2294    return (int % 360 + 360) % 360 / 360;
2295  }
2296  
2297  function parse1(str) {
2298    var num = parseFloat(str);
2299    if (num < 0) return 0;
2300    if (num > 1) return 255;
2301    return Math.round(num * 255);
2302  }
2303  
2304  function parsePercentage(str) {
2305    // parseFloat conveniently ignores the final %
2306    var int = parseFloat(str);
2307    if (int < 0) return 0;
2308    if (int > 100) return 1;
2309    return int / 100;
2310  }
2311  
2312  function colorToRgba(input) {
2313    var int32Color = normalizeColor(input);
2314    if (int32Color === null) return input;
2315    int32Color = int32Color || 0;
2316    var r = (int32Color & 0xff000000) >>> 24;
2317    var g = (int32Color & 0x00ff0000) >>> 16;
2318    var b = (int32Color & 0x0000ff00) >>> 8;
2319    var a = (int32Color & 0x000000ff) / 255;
2320    return "rgba(" + r + ", " + g + ", " + b + ", " + a + ")";
2321  } // Problem: https://github.com/animatedjs/animated/pull/102
2322  // Solution: https://stackoverflow.com/questions/638565/parsing-scientific-notation-sensibly/658662
2323  
2324  
2325  var stringShapeRegex = /[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g; // Covers rgb, rgba, hsl, hsla
2326  // Taken from https://gist.github.com/olmokramer/82ccce673f86db7cda5e
2327  
2328  var colorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi; // Covers color names (transparent, blue, etc.)
2329  
2330  var colorNamesRegex = new RegExp("(" + Object.keys(colors).join('|') + ")", 'g');
2331  /**
2332   * Supports string shapes by extracting numbers so new values can be computed,
2333   * and recombines those values into new strings of the same shape.  Supports
2334   * things like:
2335   *
2336   *   rgba(123, 42, 99, 0.36)           // colors
2337   *   -45deg                            // values with units
2338   *   0 2px 2px 0px rgba(0, 0, 0, 0.12) // box shadows
2339   */
2340  
2341  var createStringInterpolator = function createStringInterpolator(config) {
2342    // Replace colors with rgba
2343    var outputRange = config.output.map(function (rangeValue) {
2344      return rangeValue.replace(colorRegex, colorToRgba);
2345    }).map(function (rangeValue) {
2346      return rangeValue.replace(colorNamesRegex, colorToRgba);
2347    });
2348    var outputRanges = outputRange[0].match(stringShapeRegex).map(function () {
2349      return [];
2350    });
2351    outputRange.forEach(function (value) {
2352      value.match(stringShapeRegex).forEach(function (number, i) {
2353        return outputRanges[i].push(+number);
2354      });
2355    });
2356    var interpolations = outputRange[0].match(stringShapeRegex).map(function (_value, i) {
2357      return createInterpolator(_extends({}, config, {
2358        output: outputRanges[i]
2359      }));
2360    });
2361    return function (input) {
2362      var i = 0;
2363      return outputRange[0] // 'rgba(0, 100, 200, 0)'
2364      // ->
2365      // 'rgba(${interpolations[0](input)}, ${interpolations[1](input)}, ...'
2366      .replace(stringShapeRegex, function () {
2367        return interpolations[i++](input);
2368      }) // rgba requires that the r,g,b are integers.... so we want to round them, but we *dont* want to
2369      // round the opacity (4th column).
2370      .replace(/rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi, function (_, p1, p2, p3, p4) {
2371        return "rgba(" + Math.round(p1) + ", " + Math.round(p2) + ", " + Math.round(p3) + ", " + p4 + ")";
2372      });
2373    };
2374  };
2375  
2376  var isUnitlessNumber = {
2377    animationIterationCount: true,
2378    borderImageOutset: true,
2379    borderImageSlice: true,
2380    borderImageWidth: true,
2381    boxFlex: true,
2382    boxFlexGroup: true,
2383    boxOrdinalGroup: true,
2384    columnCount: true,
2385    columns: true,
2386    flex: true,
2387    flexGrow: true,
2388    flexPositive: true,
2389    flexShrink: true,
2390    flexNegative: true,
2391    flexOrder: true,
2392    gridRow: true,
2393    gridRowEnd: true,
2394    gridRowSpan: true,
2395    gridRowStart: true,
2396    gridColumn: true,
2397    gridColumnEnd: true,
2398    gridColumnSpan: true,
2399    gridColumnStart: true,
2400    fontWeight: true,
2401    lineClamp: true,
2402    lineHeight: true,
2403    opacity: true,
2404    order: true,
2405    orphans: true,
2406    tabSize: true,
2407    widows: true,
2408    zIndex: true,
2409    zoom: true,
2410    // SVG-related properties
2411    fillOpacity: true,
2412    floodOpacity: true,
2413    stopOpacity: true,
2414    strokeDasharray: true,
2415    strokeDashoffset: true,
2416    strokeMiterlimit: true,
2417    strokeOpacity: true,
2418    strokeWidth: true
2419  };
2420  
2421  var prefixKey = function prefixKey(prefix, key) {
2422    return prefix + key.charAt(0).toUpperCase() + key.substring(1);
2423  };
2424  
2425  var prefixes = ['Webkit', 'Ms', 'Moz', 'O'];
2426  isUnitlessNumber = Object.keys(isUnitlessNumber).reduce(function (acc, prop) {
2427    prefixes.forEach(function (prefix) {
2428      return acc[prefixKey(prefix, prop)] = acc[prop];
2429    });
2430    return acc;
2431  }, isUnitlessNumber);
2432  
2433  function dangerousStyleValue(name, value, isCustomProperty) {
2434    if (value == null || typeof value === 'boolean' || value === '') return '';
2435    if (!isCustomProperty && typeof value === 'number' && value !== 0 && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) return value + 'px'; // Presumes implicit 'px' suffix for unitless numbers
2436  
2437    return ('' + value).trim();
2438  }
2439  
2440  var attributeCache = {};
2441  injectCreateAnimatedStyle(function (style) {
2442    return new AnimatedStyle(style);
2443  });
2444  injectDefaultElement('div');
2445  injectStringInterpolator(createStringInterpolator);
2446  injectColorNames(colors);
2447  injectApplyAnimatedValues(function (instance, props) {
2448    if (instance.nodeType && instance.setAttribute !== undefined) {
2449      var style = props.style,
2450          children = props.children,
2451          scrollTop = props.scrollTop,
2452          scrollLeft = props.scrollLeft,
2453          attributes = _objectWithoutPropertiesLoose(props, ["style", "children", "scrollTop", "scrollLeft"]);
2454  
2455      var filter = instance.nodeName === 'filter' || instance.parentNode && instance.parentNode.nodeName === 'filter';
2456      if (scrollTop !== void 0) instance.scrollTop = scrollTop;
2457      if (scrollLeft !== void 0) instance.scrollLeft = scrollLeft; // Set textContent, if children is an animatable value
2458  
2459      if (children !== void 0) instance.textContent = children; // Set styles ...
2460  
2461      for (var styleName in style) {
2462        if (!style.hasOwnProperty(styleName)) continue;
2463        var isCustomProperty = styleName.indexOf('--') === 0;
2464        var styleValue = dangerousStyleValue(styleName, style[styleName], isCustomProperty);
2465        if (styleName === 'float') styleName = 'cssFloat';
2466        if (isCustomProperty) instance.style.setProperty(styleName, styleValue);else instance.style[styleName] = styleValue;
2467      } // Set attributes ...
2468  
2469  
2470      for (var name in attributes) {
2471        // Attributes are written in dash case
2472        var dashCase = filter ? name : attributeCache[name] || (attributeCache[name] = name.replace(/([A-Z])/g, function (n) {
2473          return '-' + n.toLowerCase();
2474        }));
2475        if (typeof instance.getAttribute(dashCase) !== 'undefined') instance.setAttribute(dashCase, attributes[name]);
2476      }
2477  
2478      return;
2479    } else return false;
2480  }, function (style) {
2481    return style;
2482  });
2483  
2484  var domElements = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', // SVG
2485  'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan'];
2486  // Extend animated with all the available THREE elements
2487  var apply = merge(createAnimatedComponent, false);
2488  var extendedAnimated = apply(domElements);
2489  
2490  exports.apply = apply;
2491  exports.config = config;
2492  exports.update = update;
2493  exports.animated = extendedAnimated;
2494  exports.a = extendedAnimated;
2495  exports.interpolate = interpolate$1;
2496  exports.Globals = Globals;
2497  exports.useSpring = useSpring;
2498  exports.useTrail = useTrail;
2499  exports.useTransition = useTransition;
2500  exports.useChain = useChain;
2501  exports.useSprings = useSprings;
2502  
2503  
2504  /***/ }),
2505  
2506  /***/ 12:
2507  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2508  
2509  "use strict";
2510  
2511  // EXPORTS
2512  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _slicedToArray; });
2513  
2514  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
2515  var arrayWithHoles = __webpack_require__(37);
2516  
2517  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
2518  function _iterableToArrayLimit(arr, i) {
2519    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
2520    var _arr = [];
2521    var _n = true;
2522    var _d = false;
2523    var _e = undefined;
2524  
2525    try {
2526      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
2527        _arr.push(_s.value);
2528  
2529        if (i && _arr.length === i) break;
2530      }
2531    } catch (err) {
2532      _d = true;
2533      _e = err;
2534    } finally {
2535      try {
2536        if (!_n && _i["return"] != null) _i["return"]();
2537      } finally {
2538        if (_d) throw _e;
2539      }
2540    }
2541  
2542    return _arr;
2543  }
2544  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
2545  var unsupportedIterableToArray = __webpack_require__(28);
2546  
2547  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
2548  var nonIterableRest = __webpack_require__(38);
2549  
2550  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
2551  
2552  
2553  
2554  
2555  function _slicedToArray(arr, i) {
2556    return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(unsupportedIterableToArray["a" /* default */])(arr, i) || Object(nonIterableRest["a" /* default */])();
2557  }
2558  
2559  /***/ }),
2560  
2561  /***/ 124:
2562  /***/ (function(module, exports, __webpack_require__) {
2563  
2564  "use strict";
2565  
2566  
2567  module.exports = __webpack_require__(190);
2568  
2569  /***/ }),
2570  
2571  /***/ 125:
2572  /***/ (function(module, exports) {
2573  
2574  (function() { module.exports = window["wp"]["wordcount"]; }());
2575  
2576  /***/ }),
2577  
2578  /***/ 127:
2579  /***/ (function(module, exports) {
2580  
2581  (function() { module.exports = window["wp"]["shortcode"]; }());
2582  
2583  /***/ }),
2584  
2585  /***/ 13:
2586  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2587  
2588  "use strict";
2589  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutProperties; });
2590  /* harmony import */ var _objectWithoutPropertiesLoose_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(44);
2591  
2592  function _objectWithoutProperties(source, excluded) {
2593    if (source == null) return {};
2594    var target = Object(_objectWithoutPropertiesLoose_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(source, excluded);
2595    var key, i;
2596  
2597    if (Object.getOwnPropertySymbols) {
2598      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
2599  
2600      for (i = 0; i < sourceSymbolKeys.length; i++) {
2601        key = sourceSymbolKeys[i];
2602        if (excluded.indexOf(key) >= 0) continue;
2603        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
2604        target[key] = source[key];
2605      }
2606    }
2607  
2608    return target;
2609  }
2610  
2611  /***/ }),
2612  
2613  /***/ 136:
2614  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2615  
2616  "use strict";
2617  /* harmony import */ var _babel_runtime_helpers_esm_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
2618  /* harmony import */ var _babel_runtime_helpers_esm_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(13);
2619  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(0);
2620  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_2__);
2621  
2622  
2623  
2624  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; }
2625  
2626  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(_babel_runtime_helpers_esm_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(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; }
2627  
2628  /**
2629   * WordPress dependencies
2630   */
2631  
2632  /** @typedef {{icon: JSX.Element, size?: number} & import('@wordpress/primitives').SVGProps} IconProps */
2633  
2634  /**
2635   * Return an SVG icon.
2636   *
2637   * @param {IconProps} props icon is the SVG component to render
2638   *                          size is a number specifiying the icon size in pixels
2639   *                          Other props will be passed to wrapped SVG component
2640   *
2641   * @return {JSX.Element}  Icon component
2642   */
2643  
2644  function Icon(_ref) {
2645    var icon = _ref.icon,
2646        _ref$size = _ref.size,
2647        size = _ref$size === void 0 ? 24 : _ref$size,
2648        props = Object(_babel_runtime_helpers_esm_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(_ref, ["icon", "size"]);
2649  
2650    return Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_2__["cloneElement"])(icon, _objectSpread({
2651      width: size,
2652      height: size
2653    }, props));
2654  }
2655  
2656  /* harmony default export */ __webpack_exports__["a"] = (Icon);
2657  
2658  
2659  /***/ }),
2660  
2661  /***/ 137:
2662  /***/ (function(module, exports, __webpack_require__) {
2663  
2664  "use strict";
2665  /**
2666   * Copyright (c) 2013-present, Facebook, Inc.
2667   *
2668   * This source code is licensed under the MIT license found in the
2669   * LICENSE file in the root directory of this source tree.
2670   */
2671  
2672  
2673  
2674  var ReactPropTypesSecret = __webpack_require__(138);
2675  
2676  function emptyFunction() {}
2677  function emptyFunctionWithReset() {}
2678  emptyFunctionWithReset.resetWarningCache = emptyFunction;
2679  
2680  module.exports = function() {
2681    function shim(props, propName, componentName, location, propFullName, secret) {
2682      if (secret === ReactPropTypesSecret) {
2683        // It is still safe when called from React.
2684        return;
2685      }
2686      var err = new Error(
2687        'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
2688        'Use PropTypes.checkPropTypes() to call them. ' +
2689        'Read more at http://fb.me/use-check-prop-types'
2690      );
2691      err.name = 'Invariant Violation';
2692      throw err;
2693    };
2694    shim.isRequired = shim;
2695    function getShim() {
2696      return shim;
2697    };
2698    // Important!
2699    // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
2700    var ReactPropTypes = {
2701      array: shim,
2702      bool: shim,
2703      func: shim,
2704      number: shim,
2705      object: shim,
2706      string: shim,
2707      symbol: shim,
2708  
2709      any: shim,
2710      arrayOf: getShim,
2711      element: shim,
2712      elementType: shim,
2713      instanceOf: getShim,
2714      node: shim,
2715      objectOf: getShim,
2716      oneOf: getShim,
2717      oneOfType: getShim,
2718      shape: getShim,
2719      exact: getShim,
2720  
2721      checkPropTypes: emptyFunctionWithReset,
2722      resetWarningCache: emptyFunction
2723    };
2724  
2725    ReactPropTypes.PropTypes = ReactPropTypes;
2726  
2727    return ReactPropTypes;
2728  };
2729  
2730  
2731  /***/ }),
2732  
2733  /***/ 138:
2734  /***/ (function(module, exports, __webpack_require__) {
2735  
2736  "use strict";
2737  /**
2738   * Copyright (c) 2013-present, Facebook, Inc.
2739   *
2740   * This source code is licensed under the MIT license found in the
2741   * LICENSE file in the root directory of this source tree.
2742   */
2743  
2744  
2745  
2746  var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
2747  
2748  module.exports = ReactPropTypesSecret;
2749  
2750  
2751  /***/ }),
2752  
2753  /***/ 14:
2754  /***/ (function(module, exports) {
2755  
2756  (function() { module.exports = window["React"]; }());
2757  
2758  /***/ }),
2759  
2760  /***/ 15:
2761  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2762  
2763  "use strict";
2764  
2765  // EXPORTS
2766  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _toConsumableArray; });
2767  
2768  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
2769  var arrayLikeToArray = __webpack_require__(24);
2770  
2771  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
2772  
2773  function _arrayWithoutHoles(arr) {
2774    if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr);
2775  }
2776  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
2777  var iterableToArray = __webpack_require__(39);
2778  
2779  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
2780  var unsupportedIterableToArray = __webpack_require__(28);
2781  
2782  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
2783  function _nonIterableSpread() {
2784    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
2785  }
2786  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
2787  
2788  
2789  
2790  
2791  function _toConsumableArray(arr) {
2792    return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || Object(unsupportedIterableToArray["a" /* default */])(arr) || _nonIterableSpread();
2793  }
2794  
2795  /***/ }),
2796  
2797  /***/ 155:
2798  /***/ (function(module, exports) {
2799  
2800  (function() { module.exports = window["wp"]["tokenList"]; }());
2801  
2802  /***/ }),
2803  
2804  /***/ 158:
2805  /***/ (function(module, exports, __webpack_require__) {
2806  
2807  var setPrototypeOf = __webpack_require__(188);
2808  
2809  function _inheritsLoose(subClass, superClass) {
2810    subClass.prototype = Object.create(superClass.prototype);
2811    subClass.prototype.constructor = subClass;
2812    setPrototypeOf(subClass, superClass);
2813  }
2814  
2815  module.exports = _inheritsLoose;
2816  module.exports["default"] = module.exports, module.exports.__esModule = true;
2817  
2818  /***/ }),
2819  
2820  /***/ 159:
2821  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2822  
2823  "use strict";
2824  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
2825  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
2826  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
2827  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
2828  
2829  
2830  /**
2831   * WordPress dependencies
2832   */
2833  
2834  var closeSmall = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
2835    xmlns: "http://www.w3.org/2000/svg",
2836    viewBox: "0 0 24 24"
2837  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
2838    d: "M12 13.06l3.712 3.713 1.061-1.06L13.061 12l3.712-3.712-1.06-1.06L12 10.938 8.288 7.227l-1.061 1.06L10.939 12l-3.712 3.712 1.06 1.061L12 13.061z"
2839  }));
2840  /* harmony default export */ __webpack_exports__["a"] = (closeSmall);
2841  
2842  
2843  /***/ }),
2844  
2845  /***/ 16:
2846  /***/ (function(module, exports) {
2847  
2848  (function() { module.exports = window["regeneratorRuntime"]; }());
2849  
2850  /***/ }),
2851  
2852  /***/ 160:
2853  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2854  
2855  "use strict";
2856  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
2857  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
2858  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
2859  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
2860  
2861  
2862  /**
2863   * WordPress dependencies
2864   */
2865  
2866  var close = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
2867    xmlns: "http://www.w3.org/2000/svg",
2868    viewBox: "0 0 24 24"
2869  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
2870    d: "M13 11.8l6.1-6.3-1-1-6.1 6.2-6.1-6.2-1 1 6.1 6.3-6.5 6.7 1 1 6.5-6.6 6.5 6.6 1-1z"
2871  }));
2872  /* harmony default export */ __webpack_exports__["a"] = (close);
2873  
2874  
2875  /***/ }),
2876  
2877  /***/ 161:
2878  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2879  
2880  "use strict";
2881  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
2882  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
2883  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
2884  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
2885  
2886  
2887  /**
2888   * WordPress dependencies
2889   */
2890  
2891  var check = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
2892    xmlns: "http://www.w3.org/2000/svg",
2893    viewBox: "0 0 24 24"
2894  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
2895    d: "M18.3 5.6L9.9 16.9l-4.6-3.4-.9 1.2 5.8 4.3 9.3-12.6z"
2896  }));
2897  /* harmony default export */ __webpack_exports__["a"] = (check);
2898  
2899  
2900  /***/ }),
2901  
2902  /***/ 17:
2903  /***/ (function(module, exports) {
2904  
2905  (function() { module.exports = window["wp"]["keycodes"]; }());
2906  
2907  /***/ }),
2908  
2909  /***/ 175:
2910  /***/ (function(module, exports) {
2911  
2912  if (typeof Object.create === 'function') {
2913    // implementation from standard node.js 'util' module
2914    module.exports = function inherits(ctor, superCtor) {
2915      if (superCtor) {
2916        ctor.super_ = superCtor
2917        ctor.prototype = Object.create(superCtor.prototype, {
2918          constructor: {
2919            value: ctor,
2920            enumerable: false,
2921            writable: true,
2922            configurable: true
2923          }
2924        })
2925      }
2926    };
2927  } else {
2928    // old school shim for old browsers
2929    module.exports = function inherits(ctor, superCtor) {
2930      if (superCtor) {
2931        ctor.super_ = superCtor
2932        var TempCtor = function () {}
2933        TempCtor.prototype = superCtor.prototype
2934        ctor.prototype = new TempCtor()
2935        ctor.prototype.constructor = ctor
2936      }
2937    }
2938  }
2939  
2940  
2941  /***/ }),
2942  
2943  /***/ 18:
2944  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2945  
2946  "use strict";
2947  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; });
2948  function _assertThisInitialized(self) {
2949    if (self === void 0) {
2950      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
2951    }
2952  
2953    return self;
2954  }
2955  
2956  /***/ }),
2957  
2958  /***/ 186:
2959  /***/ (function(module, exports) {
2960  
2961  function _extends() {
2962    module.exports = _extends = Object.assign || function (target) {
2963      for (var i = 1; i < arguments.length; i++) {
2964        var source = arguments[i];
2965  
2966        for (var key in source) {
2967          if (Object.prototype.hasOwnProperty.call(source, key)) {
2968            target[key] = source[key];
2969          }
2970        }
2971      }
2972  
2973      return target;
2974    };
2975  
2976    module.exports["default"] = module.exports, module.exports.__esModule = true;
2977    return _extends.apply(this, arguments);
2978  }
2979  
2980  module.exports = _extends;
2981  module.exports["default"] = module.exports, module.exports.__esModule = true;
2982  
2983  /***/ }),
2984  
2985  /***/ 187:
2986  /***/ (function(module, exports) {
2987  
2988  function _objectWithoutPropertiesLoose(source, excluded) {
2989    if (source == null) return {};
2990    var target = {};
2991    var sourceKeys = Object.keys(source);
2992    var key, i;
2993  
2994    for (i = 0; i < sourceKeys.length; i++) {
2995      key = sourceKeys[i];
2996      if (excluded.indexOf(key) >= 0) continue;
2997      target[key] = source[key];
2998    }
2999  
3000    return target;
3001  }
3002  
3003  module.exports = _objectWithoutPropertiesLoose;
3004  module.exports["default"] = module.exports, module.exports.__esModule = true;
3005  
3006  /***/ }),
3007  
3008  /***/ 188:
3009  /***/ (function(module, exports) {
3010  
3011  function _setPrototypeOf(o, p) {
3012    module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
3013      o.__proto__ = p;
3014      return o;
3015    };
3016  
3017    module.exports["default"] = module.exports, module.exports.__esModule = true;
3018    return _setPrototypeOf(o, p);
3019  }
3020  
3021  module.exports = _setPrototypeOf;
3022  module.exports["default"] = module.exports, module.exports.__esModule = true;
3023  
3024  /***/ }),
3025  
3026  /***/ 189:
3027  /***/ (function(module, exports) {
3028  
3029  function _assertThisInitialized(self) {
3030    if (self === void 0) {
3031      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
3032    }
3033  
3034    return self;
3035  }
3036  
3037  module.exports = _assertThisInitialized;
3038  module.exports["default"] = module.exports, module.exports.__esModule = true;
3039  
3040  /***/ }),
3041  
3042  /***/ 19:
3043  /***/ (function(module, exports) {
3044  
3045  (function() { module.exports = window["wp"]["richText"]; }());
3046  
3047  /***/ }),
3048  
3049  /***/ 190:
3050  /***/ (function(module, exports, __webpack_require__) {
3051  
3052  "use strict";
3053  
3054  
3055  var util = __webpack_require__(191);
3056  
3057  function scrollIntoView(elem, container, config) {
3058    config = config || {};
3059    // document 归一化到 window
3060    if (container.nodeType === 9) {
3061      container = util.getWindow(container);
3062    }
3063  
3064    var allowHorizontalScroll = config.allowHorizontalScroll;
3065    var onlyScrollIfNeeded = config.onlyScrollIfNeeded;
3066    var alignWithTop = config.alignWithTop;
3067    var alignWithLeft = config.alignWithLeft;
3068    var offsetTop = config.offsetTop || 0;
3069    var offsetLeft = config.offsetLeft || 0;
3070    var offsetBottom = config.offsetBottom || 0;
3071    var offsetRight = config.offsetRight || 0;
3072  
3073    allowHorizontalScroll = allowHorizontalScroll === undefined ? true : allowHorizontalScroll;
3074  
3075    var isWin = util.isWindow(container);
3076    var elemOffset = util.offset(elem);
3077    var eh = util.outerHeight(elem);
3078    var ew = util.outerWidth(elem);
3079    var containerOffset = undefined;
3080    var ch = undefined;
3081    var cw = undefined;
3082    var containerScroll = undefined;
3083    var diffTop = undefined;
3084    var diffBottom = undefined;
3085    var win = undefined;
3086    var winScroll = undefined;
3087    var ww = undefined;
3088    var wh = undefined;
3089  
3090    if (isWin) {
3091      win = container;
3092      wh = util.height(win);
3093      ww = util.width(win);
3094      winScroll = {
3095        left: util.scrollLeft(win),
3096        top: util.scrollTop(win)
3097      };
3098      // elem 相对 container 可视视窗的距离
3099      diffTop = {
3100        left: elemOffset.left - winScroll.left - offsetLeft,
3101        top: elemOffset.top - winScroll.top - offsetTop
3102      };
3103      diffBottom = {
3104        left: elemOffset.left + ew - (winScroll.left + ww) + offsetRight,
3105        top: elemOffset.top + eh - (winScroll.top + wh) + offsetBottom
3106      };
3107      containerScroll = winScroll;
3108    } else {
3109      containerOffset = util.offset(container);
3110      ch = container.clientHeight;
3111      cw = container.clientWidth;
3112      containerScroll = {
3113        left: container.scrollLeft,
3114        top: container.scrollTop
3115      };
3116      // elem 相对 container 可视视窗的距离
3117      // 注意边框, offset 是边框到根节点
3118      diffTop = {
3119        left: elemOffset.left - (containerOffset.left + (parseFloat(util.css(container, 'borderLeftWidth')) || 0)) - offsetLeft,
3120        top: elemOffset.top - (containerOffset.top + (parseFloat(util.css(container, 'borderTopWidth')) || 0)) - offsetTop
3121      };
3122      diffBottom = {
3123        left: elemOffset.left + ew - (containerOffset.left + cw + (parseFloat(util.css(container, 'borderRightWidth')) || 0)) + offsetRight,
3124        top: elemOffset.top + eh - (containerOffset.top + ch + (parseFloat(util.css(container, 'borderBottomWidth')) || 0)) + offsetBottom
3125      };
3126    }
3127  
3128    if (diffTop.top < 0 || diffBottom.top > 0) {
3129      // 强制向上
3130      if (alignWithTop === true) {
3131        util.scrollTop(container, containerScroll.top + diffTop.top);
3132      } else if (alignWithTop === false) {
3133        util.scrollTop(container, containerScroll.top + diffBottom.top);
3134      } else {
3135        // 自动调整
3136        if (diffTop.top < 0) {
3137          util.scrollTop(container, containerScroll.top + diffTop.top);
3138        } else {
3139          util.scrollTop(container, containerScroll.top + diffBottom.top);
3140        }
3141      }
3142    } else {
3143      if (!onlyScrollIfNeeded) {
3144        alignWithTop = alignWithTop === undefined ? true : !!alignWithTop;
3145        if (alignWithTop) {
3146          util.scrollTop(container, containerScroll.top + diffTop.top);
3147        } else {
3148          util.scrollTop(container, containerScroll.top + diffBottom.top);
3149        }
3150      }
3151    }
3152  
3153    if (allowHorizontalScroll) {
3154      if (diffTop.left < 0 || diffBottom.left > 0) {
3155        // 强制向上
3156        if (alignWithLeft === true) {
3157          util.scrollLeft(container, containerScroll.left + diffTop.left);
3158        } else if (alignWithLeft === false) {
3159          util.scrollLeft(container, containerScroll.left + diffBottom.left);
3160        } else {
3161          // 自动调整
3162          if (diffTop.left < 0) {
3163            util.scrollLeft(container, containerScroll.left + diffTop.left);
3164          } else {
3165            util.scrollLeft(container, containerScroll.left + diffBottom.left);
3166          }
3167        }
3168      } else {
3169        if (!onlyScrollIfNeeded) {
3170          alignWithLeft = alignWithLeft === undefined ? true : !!alignWithLeft;
3171          if (alignWithLeft) {
3172            util.scrollLeft(container, containerScroll.left + diffTop.left);
3173          } else {
3174            util.scrollLeft(container, containerScroll.left + diffBottom.left);
3175          }
3176        }
3177      }
3178    }
3179  }
3180  
3181  module.exports = scrollIntoView;
3182  
3183  /***/ }),
3184  
3185  /***/ 191:
3186  /***/ (function(module, exports, __webpack_require__) {
3187  
3188  "use strict";
3189  
3190  
3191  var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
3192  
3193  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
3194  
3195  var RE_NUM = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source;
3196  
3197  function getClientPosition(elem) {
3198    var box = undefined;
3199    var x = undefined;
3200    var y = undefined;
3201    var doc = elem.ownerDocument;
3202    var body = doc.body;
3203    var docElem = doc && doc.documentElement;
3204    // 根据 GBS 最新数据,A-Grade Browsers 都已支持 getBoundingClientRect 方法,不用再考虑传统的实现方式
3205    box = elem.getBoundingClientRect();
3206  
3207    // 注:jQuery 还考虑减去 docElem.clientLeft/clientTop
3208    // 但测试发现,这样反而会导致当 html 和 body 有边距/边框样式时,获取的值不正确
3209    // 此外,ie6 会忽略 html 的 margin 值,幸运地是没有谁会去设置 html 的 margin
3210  
3211    x = box.left;
3212    y = box.top;
3213  
3214    // In IE, most of the time, 2 extra pixels are added to the top and left
3215    // due to the implicit 2-pixel inset border.  In IE6/7 quirks mode and
3216    // IE6 standards mode, this border can be overridden by setting the
3217    // document element's border to zero -- thus, we cannot rely on the
3218    // offset always being 2 pixels.
3219  
3220    // In quirks mode, the offset can be determined by querying the body's
3221    // clientLeft/clientTop, but in standards mode, it is found by querying
3222    // the document element's clientLeft/clientTop.  Since we already called
3223    // getClientBoundingRect we have already forced a reflow, so it is not
3224    // too expensive just to query them all.
3225  
3226    // ie 下应该减去窗口的边框吧,毕竟默认 absolute 都是相对窗口定位的
3227    // 窗口边框标准是设 documentElement ,quirks 时设置 body
3228    // 最好禁止在 body 和 html 上边框 ,但 ie < 9 html 默认有 2px ,减去
3229    // 但是非 ie 不可能设置窗口边框,body html 也不是窗口 ,ie 可以通过 html,body 设置
3230    // 标准 ie 下 docElem.clientTop 就是 border-top
3231    // ie7 html 即窗口边框改变不了。永远为 2
3232    // 但标准 firefox/chrome/ie9 下 docElem.clientTop 是窗口边框,即使设了 border-top 也为 0
3233  
3234    x -= docElem.clientLeft || body.clientLeft || 0;
3235    y -= docElem.clientTop || body.clientTop || 0;
3236  
3237    return {
3238      left: x,
3239      top: y
3240    };
3241  }
3242  
3243  function getScroll(w, top) {
3244    var ret = w['page' + (top ? 'Y' : 'X') + 'Offset'];
3245    var method = 'scroll' + (top ? 'Top' : 'Left');
3246    if (typeof ret !== 'number') {
3247      var d = w.document;
3248      // ie6,7,8 standard mode
3249      ret = d.documentElement[method];
3250      if (typeof ret !== 'number') {
3251        // quirks mode
3252        ret = d.body[method];
3253      }
3254    }
3255    return ret;
3256  }
3257  
3258  function getScrollLeft(w) {
3259    return getScroll(w);
3260  }
3261  
3262  function getScrollTop(w) {
3263    return getScroll(w, true);
3264  }
3265  
3266  function getOffset(el) {
3267    var pos = getClientPosition(el);
3268    var doc = el.ownerDocument;
3269    var w = doc.defaultView || doc.parentWindow;
3270    pos.left += getScrollLeft(w);
3271    pos.top += getScrollTop(w);
3272    return pos;
3273  }
3274  function _getComputedStyle(elem, name, computedStyle_) {
3275    var val = '';
3276    var d = elem.ownerDocument;
3277    var computedStyle = computedStyle_ || d.defaultView.getComputedStyle(elem, null);
3278  
3279    // https://github.com/kissyteam/kissy/issues/61
3280    if (computedStyle) {
3281      val = computedStyle.getPropertyValue(name) || computedStyle[name];
3282    }
3283  
3284    return val;
3285  }
3286  
3287  var _RE_NUM_NO_PX = new RegExp('^(' + RE_NUM + ')(?!px)[a-z%]+$', 'i');
3288  var RE_POS = /^(top|right|bottom|left)$/;
3289  var CURRENT_STYLE = 'currentStyle';
3290  var RUNTIME_STYLE = 'runtimeStyle';
3291  var LEFT = 'left';
3292  var PX = 'px';
3293  
3294  function _getComputedStyleIE(elem, name) {
3295    // currentStyle maybe null
3296    // http://msdn.microsoft.com/en-us/library/ms535231.aspx
3297    var ret = elem[CURRENT_STYLE] && elem[CURRENT_STYLE][name];
3298  
3299    // 当 width/height 设置为百分比时,通过 pixelLeft 方式转换的 width/height 值
3300    // 一开始就处理了! CUSTOM_STYLE.height,CUSTOM_STYLE.width ,cssHook 解决@2011-08-19
3301    // 在 ie 下不对,需要直接用 offset 方式
3302    // borderWidth 等值也有问题,但考虑到 borderWidth 设为百分比的概率很小,这里就不考虑了
3303  
3304    // From the awesome hack by Dean Edwards
3305    // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
3306    // If we're not dealing with a regular pixel number
3307    // but a number that has a weird ending, we need to convert it to pixels
3308    // exclude left right for relativity
3309    if (_RE_NUM_NO_PX.test(ret) && !RE_POS.test(name)) {
3310      // Remember the original values
3311      var style = elem.style;
3312      var left = style[LEFT];
3313      var rsLeft = elem[RUNTIME_STYLE][LEFT];
3314  
3315      // prevent flashing of content
3316      elem[RUNTIME_STYLE][LEFT] = elem[CURRENT_STYLE][LEFT];
3317  
3318      // Put in the new values to get a computed value out
3319      style[LEFT] = name === 'fontSize' ? '1em' : ret || 0;
3320      ret = style.pixelLeft + PX;
3321  
3322      // Revert the changed values
3323      style[LEFT] = left;
3324  
3325      elem[RUNTIME_STYLE][LEFT] = rsLeft;
3326    }
3327    return ret === '' ? 'auto' : ret;
3328  }
3329  
3330  var getComputedStyleX = undefined;
3331  if (typeof window !== 'undefined') {
3332    getComputedStyleX = window.getComputedStyle ? _getComputedStyle : _getComputedStyleIE;
3333  }
3334  
3335  function each(arr, fn) {
3336    for (var i = 0; i < arr.length; i++) {
3337      fn(arr[i]);
3338    }
3339  }
3340  
3341  function isBorderBoxFn(elem) {
3342    return getComputedStyleX(elem, 'boxSizing') === 'border-box';
3343  }
3344  
3345  var BOX_MODELS = ['margin', 'border', 'padding'];
3346  var CONTENT_INDEX = -1;
3347  var PADDING_INDEX = 2;
3348  var BORDER_INDEX = 1;
3349  var MARGIN_INDEX = 0;
3350  
3351  function swap(elem, options, callback) {
3352    var old = {};
3353    var style = elem.style;
3354    var name = undefined;
3355  
3356    // Remember the old values, and insert the new ones
3357    for (name in options) {
3358      if (options.hasOwnProperty(name)) {
3359        old[name] = style[name];
3360        style[name] = options[name];
3361      }
3362    }
3363  
3364    callback.call(elem);
3365  
3366    // Revert the old values
3367    for (name in options) {
3368      if (options.hasOwnProperty(name)) {
3369        style[name] = old[name];
3370      }
3371    }
3372  }
3373  
3374  function getPBMWidth(elem, props, which) {
3375    var value = 0;
3376    var prop = undefined;
3377    var j = undefined;
3378    var i = undefined;
3379    for (j = 0; j < props.length; j++) {
3380      prop = props[j];
3381      if (prop) {
3382        for (i = 0; i < which.length; i++) {
3383          var cssProp = undefined;
3384          if (prop === 'border') {
3385            cssProp = prop + which[i] + 'Width';
3386          } else {
3387            cssProp = prop + which[i];
3388          }
3389          value += parseFloat(getComputedStyleX(elem, cssProp)) || 0;
3390        }
3391      }
3392    }
3393    return value;
3394  }
3395  
3396  /**
3397   * A crude way of determining if an object is a window
3398   * @member util
3399   */
3400  function isWindow(obj) {
3401    // must use == for ie8
3402    /* eslint eqeqeq:0 */
3403    return obj != null && obj == obj.window;
3404  }
3405  
3406  var domUtils = {};
3407  
3408  each(['Width', 'Height'], function (name) {
3409    domUtils['doc' + name] = function (refWin) {
3410      var d = refWin.document;
3411      return Math.max(
3412      // firefox chrome documentElement.scrollHeight< body.scrollHeight
3413      // ie standard mode : documentElement.scrollHeight> body.scrollHeight
3414      d.documentElement['scroll' + name],
3415      // quirks : documentElement.scrollHeight 最大等于可视窗口多一点?
3416      d.body['scroll' + name], domUtils['viewport' + name](d));
3417    };
3418  
3419    domUtils['viewport' + name] = function (win) {
3420      // pc browser includes scrollbar in window.innerWidth
3421      var prop = 'client' + name;
3422      var doc = win.document;
3423      var body = doc.body;
3424      var documentElement = doc.documentElement;
3425      var documentElementProp = documentElement[prop];
3426      // 标准模式取 documentElement
3427      // backcompat 取 body
3428      return doc.compatMode === 'CSS1Compat' && documentElementProp || body && body[prop] || documentElementProp;
3429    };
3430  });
3431  
3432  /*
3433   得到元素的大小信息
3434   @param elem
3435   @param name
3436   @param {String} [extra]  'padding' : (css width) + padding
3437   'border' : (css width) + padding + border
3438   'margin' : (css width) + padding + border + margin
3439   */
3440  function getWH(elem, name, extra) {
3441    if (isWindow(elem)) {
3442      return name === 'width' ? domUtils.viewportWidth(elem) : domUtils.viewportHeight(elem);
3443    } else if (elem.nodeType === 9) {
3444      return name === 'width' ? domUtils.docWidth(elem) : domUtils.docHeight(elem);
3445    }
3446    var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
3447    var borderBoxValue = name === 'width' ? elem.offsetWidth : elem.offsetHeight;
3448    var computedStyle = getComputedStyleX(elem);
3449    var isBorderBox = isBorderBoxFn(elem, computedStyle);
3450    var cssBoxValue = 0;
3451    if (borderBoxValue == null || borderBoxValue <= 0) {
3452      borderBoxValue = undefined;
3453      // Fall back to computed then un computed css if necessary
3454      cssBoxValue = getComputedStyleX(elem, name);
3455      if (cssBoxValue == null || Number(cssBoxValue) < 0) {
3456        cssBoxValue = elem.style[name] || 0;
3457      }
3458      // Normalize '', auto, and prepare for extra
3459      cssBoxValue = parseFloat(cssBoxValue) || 0;
3460    }
3461    if (extra === undefined) {
3462      extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX;
3463    }
3464    var borderBoxValueOrIsBorderBox = borderBoxValue !== undefined || isBorderBox;
3465    var val = borderBoxValue || cssBoxValue;
3466    if (extra === CONTENT_INDEX) {
3467      if (borderBoxValueOrIsBorderBox) {
3468        return val - getPBMWidth(elem, ['border', 'padding'], which, computedStyle);
3469      }
3470      return cssBoxValue;
3471    }
3472    if (borderBoxValueOrIsBorderBox) {
3473      var padding = extra === PADDING_INDEX ? -getPBMWidth(elem, ['border'], which, computedStyle) : getPBMWidth(elem, ['margin'], which, computedStyle);
3474      return val + (extra === BORDER_INDEX ? 0 : padding);
3475    }
3476    return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which, computedStyle);
3477  }
3478  
3479  var cssShow = {
3480    position: 'absolute',
3481    visibility: 'hidden',
3482    display: 'block'
3483  };
3484  
3485  // fix #119 : https://github.com/kissyteam/kissy/issues/119
3486  function getWHIgnoreDisplay(elem) {
3487    var val = undefined;
3488    var args = arguments;
3489    // in case elem is window
3490    // elem.offsetWidth === undefined
3491    if (elem.offsetWidth !== 0) {
3492      val = getWH.apply(undefined, args);
3493    } else {
3494      swap(elem, cssShow, function () {
3495        val = getWH.apply(undefined, args);
3496      });
3497    }
3498    return val;
3499  }
3500  
3501  function css(el, name, v) {
3502    var value = v;
3503    if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') {
3504      for (var i in name) {
3505        if (name.hasOwnProperty(i)) {
3506          css(el, i, name[i]);
3507        }
3508      }
3509      return undefined;
3510    }
3511    if (typeof value !== 'undefined') {
3512      if (typeof value === 'number') {
3513        value += 'px';
3514      }
3515      el.style[name] = value;
3516      return undefined;
3517    }
3518    return getComputedStyleX(el, name);
3519  }
3520  
3521  each(['width', 'height'], function (name) {
3522    var first = name.charAt(0).toUpperCase() + name.slice(1);
3523    domUtils['outer' + first] = function (el, includeMargin) {
3524      return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX);
3525    };
3526    var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
3527  
3528    domUtils[name] = function (elem, val) {
3529      if (val !== undefined) {
3530        if (elem) {
3531          var computedStyle = getComputedStyleX(elem);
3532          var isBorderBox = isBorderBoxFn(elem);
3533          if (isBorderBox) {
3534            val += getPBMWidth(elem, ['padding', 'border'], which, computedStyle);
3535          }
3536          return css(elem, name, val);
3537        }
3538        return undefined;
3539      }
3540      return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX);
3541    };
3542  });
3543  
3544  // 设置 elem 相对 elem.ownerDocument 的坐标
3545  function setOffset(elem, offset) {
3546    // set position first, in-case top/left are set even on static elem
3547    if (css(elem, 'position') === 'static') {
3548      elem.style.position = 'relative';
3549    }
3550  
3551    var old = getOffset(elem);
3552    var ret = {};
3553    var current = undefined;
3554    var key = undefined;
3555  
3556    for (key in offset) {
3557      if (offset.hasOwnProperty(key)) {
3558        current = parseFloat(css(elem, key)) || 0;
3559        ret[key] = current + offset[key] - old[key];
3560      }
3561    }
3562    css(elem, ret);
3563  }
3564  
3565  module.exports = _extends({
3566    getWindow: function getWindow(node) {
3567      var doc = node.ownerDocument || node;
3568      return doc.defaultView || doc.parentWindow;
3569    },
3570    offset: function offset(el, value) {
3571      if (typeof value !== 'undefined') {
3572        setOffset(el, value);
3573      } else {
3574        return getOffset(el);
3575      }
3576    },
3577  
3578    isWindow: isWindow,
3579    each: each,
3580    css: css,
3581    clone: function clone(obj) {
3582      var ret = {};
3583      for (var i in obj) {
3584        if (obj.hasOwnProperty(i)) {
3585          ret[i] = obj[i];
3586        }
3587      }
3588      var overflow = obj.overflow;
3589      if (overflow) {
3590        for (var i in obj) {
3591          if (obj.hasOwnProperty(i)) {
3592            ret.overflow[i] = obj.overflow[i];
3593          }
3594        }
3595      }
3596      return ret;
3597    },
3598    scrollLeft: function scrollLeft(w, v) {
3599      if (isWindow(w)) {
3600        if (v === undefined) {
3601          return getScrollLeft(w);
3602        }
3603        window.scrollTo(v, getScrollTop(w));
3604      } else {
3605        if (v === undefined) {
3606          return w.scrollLeft;
3607        }
3608        w.scrollLeft = v;
3609      }
3610    },
3611    scrollTop: function scrollTop(w, v) {
3612      if (isWindow(w)) {
3613        if (v === undefined) {
3614          return getScrollTop(w);
3615        }
3616        window.scrollTo(getScrollLeft(w), v);
3617      } else {
3618        if (v === undefined) {
3619          return w.scrollTop;
3620        }
3621        w.scrollTop = v;
3622      }
3623    },
3624  
3625    viewportWidth: 0,
3626    viewportHeight: 0
3627  }, domUtils);
3628  
3629  /***/ }),
3630  
3631  /***/ 192:
3632  /***/ (function(module, exports, __webpack_require__) {
3633  
3634  "use strict";
3635  
3636  var __extends = (this && this.__extends) || (function () {
3637      var extendStatics = Object.setPrototypeOf ||
3638          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
3639          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
3640      return function (d, b) {
3641          extendStatics(d, b);
3642          function __() { this.constructor = d; }
3643          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
3644      };
3645  })();
3646  var __assign = (this && this.__assign) || Object.assign || function(t) {
3647      for (var s, i = 1, n = arguments.length; i < n; i++) {
3648          s = arguments[i];
3649          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
3650              t[p] = s[p];
3651      }
3652      return t;
3653  };
3654  var __rest = (this && this.__rest) || function (s, e) {
3655      var t = {};
3656      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
3657          t[p] = s[p];
3658      if (s != null && typeof Object.getOwnPropertySymbols === "function")
3659          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
3660              t[p[i]] = s[p[i]];
3661      return t;
3662  };
3663  exports.__esModule = true;
3664  var React = __webpack_require__(14);
3665  var PropTypes = __webpack_require__(31);
3666  var autosize = __webpack_require__(193);
3667  var _getLineHeight = __webpack_require__(194);
3668  var getLineHeight = _getLineHeight;
3669  var RESIZED = "autosize:resized";
3670  /**
3671   * A light replacement for built-in textarea component
3672   * which automaticaly adjusts its height to match the content
3673   */
3674  var TextareaAutosizeClass = /** @class */ (function (_super) {
3675      __extends(TextareaAutosizeClass, _super);
3676      function TextareaAutosizeClass() {
3677          var _this = _super !== null && _super.apply(this, arguments) || this;
3678          _this.state = {
3679              lineHeight: null
3680          };
3681          _this.textarea = null;
3682          _this.onResize = function (e) {
3683              if (_this.props.onResize) {
3684                  _this.props.onResize(e);
3685              }
3686          };
3687          _this.updateLineHeight = function () {
3688              if (_this.textarea) {
3689                  _this.setState({
3690                      lineHeight: getLineHeight(_this.textarea)
3691                  });
3692              }
3693          };
3694          _this.onChange = function (e) {
3695              var onChange = _this.props.onChange;
3696              _this.currentValue = e.currentTarget.value;
3697              onChange && onChange(e);
3698          };
3699          return _this;
3700      }
3701      TextareaAutosizeClass.prototype.componentDidMount = function () {
3702          var _this = this;
3703          var _a = this.props, maxRows = _a.maxRows, async = _a.async;
3704          if (typeof maxRows === "number") {
3705              this.updateLineHeight();
3706          }
3707          if (typeof maxRows === "number" || async) {
3708              /*
3709                the defer is needed to:
3710                  - force "autosize" to activate the scrollbar when this.props.maxRows is passed
3711                  - support StyledComponents (see #71)
3712              */
3713              setTimeout(function () { return _this.textarea && autosize(_this.textarea); });
3714          }
3715          else {
3716              this.textarea && autosize(this.textarea);
3717          }
3718          if (this.textarea) {
3719              this.textarea.addEventListener(RESIZED, this.onResize);
3720          }
3721      };
3722      TextareaAutosizeClass.prototype.componentWillUnmount = function () {
3723          if (this.textarea) {
3724              this.textarea.removeEventListener(RESIZED, this.onResize);
3725              autosize.destroy(this.textarea);
3726          }
3727      };
3728      TextareaAutosizeClass.prototype.render = function () {
3729          var _this = this;
3730          var _a = this, _b = _a.props, onResize = _b.onResize, maxRows = _b.maxRows, onChange = _b.onChange, style = _b.style, innerRef = _b.innerRef, children = _b.children, props = __rest(_b, ["onResize", "maxRows", "onChange", "style", "innerRef", "children"]), lineHeight = _a.state.lineHeight;
3731          var maxHeight = maxRows && lineHeight ? lineHeight * maxRows : null;
3732          return (React.createElement("textarea", __assign({}, props, { onChange: this.onChange, style: maxHeight ? __assign({}, style, { maxHeight: maxHeight }) : style, ref: function (element) {
3733                  _this.textarea = element;
3734                  if (typeof _this.props.innerRef === 'function') {
3735                      _this.props.innerRef(element);
3736                  }
3737                  else if (_this.props.innerRef) {
3738                      _this.props.innerRef.current = element;
3739                  }
3740              } }), children));
3741      };
3742      TextareaAutosizeClass.prototype.componentDidUpdate = function () {
3743          this.textarea && autosize.update(this.textarea);
3744      };
3745      TextareaAutosizeClass.defaultProps = {
3746          rows: 1,
3747          async: false
3748      };
3749      TextareaAutosizeClass.propTypes = {
3750          rows: PropTypes.number,
3751          maxRows: PropTypes.number,
3752          onResize: PropTypes.func,
3753          innerRef: PropTypes.any,
3754          async: PropTypes.bool
3755      };
3756      return TextareaAutosizeClass;
3757  }(React.Component));
3758  exports.TextareaAutosize = React.forwardRef(function (props, ref) {
3759      return React.createElement(TextareaAutosizeClass, __assign({}, props, { innerRef: ref }));
3760  });
3761  
3762  
3763  /***/ }),
3764  
3765  /***/ 193:
3766  /***/ (function(module, exports, __webpack_require__) {
3767  
3768  var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
3769      autosize 4.0.2
3770      license: MIT
3771      http://www.jacklmoore.com/autosize
3772  */
3773  (function (global, factory) {
3774      if (true) {
3775          !(__WEBPACK_AMD_DEFINE_ARRAY__ = [module, exports], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
3776                  __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
3777                  (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
3778                  __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
3779      } else { var mod; }
3780  })(this, function (module, exports) {
3781      'use strict';
3782  
3783      var map = typeof Map === "function" ? new Map() : function () {
3784          var keys = [];
3785          var values = [];
3786  
3787          return {
3788              has: function has(key) {
3789                  return keys.indexOf(key) > -1;
3790              },
3791              get: function get(key) {
3792                  return values[keys.indexOf(key)];
3793              },
3794              set: function set(key, value) {
3795                  if (keys.indexOf(key) === -1) {
3796                      keys.push(key);
3797                      values.push(value);
3798                  }
3799              },
3800              delete: function _delete(key) {
3801                  var index = keys.indexOf(key);
3802                  if (index > -1) {
3803                      keys.splice(index, 1);
3804                      values.splice(index, 1);
3805                  }
3806              }
3807          };
3808      }();
3809  
3810      var createEvent = function createEvent(name) {
3811          return new Event(name, { bubbles: true });
3812      };
3813      try {
3814          new Event('test');
3815      } catch (e) {
3816          // IE does not support `new Event()`
3817          createEvent = function createEvent(name) {
3818              var evt = document.createEvent('Event');
3819              evt.initEvent(name, true, false);
3820              return evt;
3821          };
3822      }
3823  
3824  	function assign(ta) {
3825          if (!ta || !ta.nodeName || ta.nodeName !== 'TEXTAREA' || map.has(ta)) return;
3826  
3827          var heightOffset = null;
3828          var clientWidth = null;
3829          var cachedHeight = null;
3830  
3831  		function init() {
3832              var style = window.getComputedStyle(ta, null);
3833  
3834              if (style.resize === 'vertical') {
3835                  ta.style.resize = 'none';
3836              } else if (style.resize === 'both') {
3837                  ta.style.resize = 'horizontal';
3838              }
3839  
3840              if (style.boxSizing === 'content-box') {
3841                  heightOffset = -(parseFloat(style.paddingTop) + parseFloat(style.paddingBottom));
3842              } else {
3843                  heightOffset = parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
3844              }
3845              // Fix when a textarea is not on document body and heightOffset is Not a Number
3846              if (isNaN(heightOffset)) {
3847                  heightOffset = 0;
3848              }
3849  
3850              update();
3851          }
3852  
3853  		function changeOverflow(value) {
3854              {
3855                  // Chrome/Safari-specific fix:
3856                  // When the textarea y-overflow is hidden, Chrome/Safari do not reflow the text to account for the space
3857                  // made available by removing the scrollbar. The following forces the necessary text reflow.
3858                  var width = ta.style.width;
3859                  ta.style.width = '0px';
3860                  // Force reflow:
3861                  /* jshint ignore:start */
3862                  ta.offsetWidth;
3863                  /* jshint ignore:end */
3864                  ta.style.width = width;
3865              }
3866  
3867              ta.style.overflowY = value;
3868          }
3869  
3870  		function getParentOverflows(el) {
3871              var arr = [];
3872  
3873              while (el && el.parentNode && el.parentNode instanceof Element) {
3874                  if (el.parentNode.scrollTop) {
3875                      arr.push({
3876                          node: el.parentNode,
3877                          scrollTop: el.parentNode.scrollTop
3878                      });
3879                  }
3880                  el = el.parentNode;
3881              }
3882  
3883              return arr;
3884          }
3885  
3886  		function resize() {
3887              if (ta.scrollHeight === 0) {
3888                  // If the scrollHeight is 0, then the element probably has display:none or is detached from the DOM.
3889                  return;
3890              }
3891  
3892              var overflows = getParentOverflows(ta);
3893              var docTop = document.documentElement && document.documentElement.scrollTop; // Needed for Mobile IE (ticket #240)
3894  
3895              ta.style.height = '';
3896              ta.style.height = ta.scrollHeight + heightOffset + 'px';
3897  
3898              // used to check if an update is actually necessary on window.resize
3899              clientWidth = ta.clientWidth;
3900  
3901              // prevents scroll-position jumping
3902              overflows.forEach(function (el) {
3903                  el.node.scrollTop = el.scrollTop;
3904              });
3905  
3906              if (docTop) {
3907                  document.documentElement.scrollTop = docTop;
3908              }
3909          }
3910  
3911  		function update() {
3912              resize();
3913  
3914              var styleHeight = Math.round(parseFloat(ta.style.height));
3915              var computed = window.getComputedStyle(ta, null);
3916  
3917              // Using offsetHeight as a replacement for computed.height in IE, because IE does not account use of border-box
3918              var actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(computed.height)) : ta.offsetHeight;
3919  
3920              // The actual height not matching the style height (set via the resize method) indicates that 
3921              // the max-height has been exceeded, in which case the overflow should be allowed.
3922              if (actualHeight < styleHeight) {
3923                  if (computed.overflowY === 'hidden') {
3924                      changeOverflow('scroll');
3925                      resize();
3926                      actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight;
3927                  }
3928              } else {
3929                  // Normally keep overflow set to hidden, to avoid flash of scrollbar as the textarea expands.
3930                  if (computed.overflowY !== 'hidden') {
3931                      changeOverflow('hidden');
3932                      resize();
3933                      actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight;
3934                  }
3935              }
3936  
3937              if (cachedHeight !== actualHeight) {
3938                  cachedHeight = actualHeight;
3939                  var evt = createEvent('autosize:resized');
3940                  try {
3941                      ta.dispatchEvent(evt);
3942                  } catch (err) {
3943                      // Firefox will throw an error on dispatchEvent for a detached element
3944                      // https://bugzilla.mozilla.org/show_bug.cgi?id=889376
3945                  }
3946              }
3947          }
3948  
3949          var pageResize = function pageResize() {
3950              if (ta.clientWidth !== clientWidth) {
3951                  update();
3952              }
3953          };
3954  
3955          var destroy = function (style) {
3956              window.removeEventListener('resize', pageResize, false);
3957              ta.removeEventListener('input', update, false);
3958              ta.removeEventListener('keyup', update, false);
3959              ta.removeEventListener('autosize:destroy', destroy, false);
3960              ta.removeEventListener('autosize:update', update, false);
3961  
3962              Object.keys(style).forEach(function (key) {
3963                  ta.style[key] = style[key];
3964              });
3965  
3966              map.delete(ta);
3967          }.bind(ta, {
3968              height: ta.style.height,
3969              resize: ta.style.resize,
3970              overflowY: ta.style.overflowY,
3971              overflowX: ta.style.overflowX,
3972              wordWrap: ta.style.wordWrap
3973          });
3974  
3975          ta.addEventListener('autosize:destroy', destroy, false);
3976  
3977          // IE9 does not fire onpropertychange or oninput for deletions,
3978          // so binding to onkeyup to catch most of those events.
3979          // There is no way that I know of to detect something like 'cut' in IE9.
3980          if ('onpropertychange' in ta && 'oninput' in ta) {
3981              ta.addEventListener('keyup', update, false);
3982          }
3983  
3984          window.addEventListener('resize', pageResize, false);
3985          ta.addEventListener('input', update, false);
3986          ta.addEventListener('autosize:update', update, false);
3987          ta.style.overflowX = 'hidden';
3988          ta.style.wordWrap = 'break-word';
3989  
3990          map.set(ta, {
3991              destroy: destroy,
3992              update: update
3993          });
3994  
3995          init();
3996      }
3997  
3998  	function destroy(ta) {
3999          var methods = map.get(ta);
4000          if (methods) {
4001              methods.destroy();
4002          }
4003      }
4004  
4005  	function update(ta) {
4006          var methods = map.get(ta);
4007          if (methods) {
4008              methods.update();
4009          }
4010      }
4011  
4012      var autosize = null;
4013  
4014      // Do nothing in Node.js environment and IE8 (or lower)
4015      if (typeof window === 'undefined' || typeof window.getComputedStyle !== 'function') {
4016          autosize = function autosize(el) {
4017              return el;
4018          };
4019          autosize.destroy = function (el) {
4020              return el;
4021          };
4022          autosize.update = function (el) {
4023              return el;
4024          };
4025      } else {
4026          autosize = function autosize(el, options) {
4027              if (el) {
4028                  Array.prototype.forEach.call(el.length ? el : [el], function (x) {
4029                      return assign(x, options);
4030                  });
4031              }
4032              return el;
4033          };
4034          autosize.destroy = function (el) {
4035              if (el) {
4036                  Array.prototype.forEach.call(el.length ? el : [el], destroy);
4037              }
4038              return el;
4039          };
4040          autosize.update = function (el) {
4041              if (el) {
4042                  Array.prototype.forEach.call(el.length ? el : [el], update);
4043              }
4044              return el;
4045          };
4046      }
4047  
4048      exports.default = autosize;
4049      module.exports = exports['default'];
4050  });
4051  
4052  /***/ }),
4053  
4054  /***/ 194:
4055  /***/ (function(module, exports, __webpack_require__) {
4056  
4057  // Load in dependencies
4058  var computedStyle = __webpack_require__(195);
4059  
4060  /**
4061   * Calculate the `line-height` of a given node
4062   * @param {HTMLElement} node Element to calculate line height of. Must be in the DOM.
4063   * @returns {Number} `line-height` of the element in pixels
4064   */
4065  function lineHeight(node) {
4066    // Grab the line-height via style
4067    var lnHeightStr = computedStyle(node, 'line-height');
4068    var lnHeight = parseFloat(lnHeightStr, 10);
4069  
4070    // If the lineHeight did not contain a unit (i.e. it was numeric), convert it to ems (e.g. '2.3' === '2.3em')
4071    if (lnHeightStr === lnHeight + '') {
4072      // Save the old lineHeight style and update the em unit to the element
4073      var _lnHeightStyle = node.style.lineHeight;
4074      node.style.lineHeight = lnHeightStr + 'em';
4075  
4076      // Calculate the em based height
4077      lnHeightStr = computedStyle(node, 'line-height');
4078      lnHeight = parseFloat(lnHeightStr, 10);
4079  
4080      // Revert the lineHeight style
4081      if (_lnHeightStyle) {
4082        node.style.lineHeight = _lnHeightStyle;
4083      } else {
4084        delete node.style.lineHeight;
4085      }
4086    }
4087  
4088    // If the lineHeight is in `pt`, convert it to pixels (4px for 3pt)
4089    // DEV: `em` units are converted to `pt` in IE6
4090    // Conversion ratio from https://developer.mozilla.org/en-US/docs/Web/CSS/length
4091    if (lnHeightStr.indexOf('pt') !== -1) {
4092      lnHeight *= 4;
4093      lnHeight /= 3;
4094    // Otherwise, if the lineHeight is in `mm`, convert it to pixels (96px for 25.4mm)
4095    } else if (lnHeightStr.indexOf('mm') !== -1) {
4096      lnHeight *= 96;
4097      lnHeight /= 25.4;
4098    // Otherwise, if the lineHeight is in `cm`, convert it to pixels (96px for 2.54cm)
4099    } else if (lnHeightStr.indexOf('cm') !== -1) {
4100      lnHeight *= 96;
4101      lnHeight /= 2.54;
4102    // Otherwise, if the lineHeight is in `in`, convert it to pixels (96px for 1in)
4103    } else if (lnHeightStr.indexOf('in') !== -1) {
4104      lnHeight *= 96;
4105    // Otherwise, if the lineHeight is in `pc`, convert it to pixels (12pt for 1pc)
4106    } else if (lnHeightStr.indexOf('pc') !== -1) {
4107      lnHeight *= 16;
4108    }
4109  
4110    // Continue our computation
4111    lnHeight = Math.round(lnHeight);
4112  
4113    // If the line-height is "normal", calculate by font-size
4114    if (lnHeightStr === 'normal') {
4115      // Create a temporary node
4116      var nodeName = node.nodeName;
4117      var _node = document.createElement(nodeName);
4118      _node.innerHTML = '&nbsp;';
4119  
4120      // If we have a text area, reset it to only 1 row
4121      // https://github.com/twolfson/line-height/issues/4
4122      if (nodeName.toUpperCase() === 'TEXTAREA') {
4123        _node.setAttribute('rows', '1');
4124      }
4125  
4126      // Set the font-size of the element
4127      var fontSizeStr = computedStyle(node, 'font-size');
4128      _node.style.fontSize = fontSizeStr;
4129  
4130      // Remove default padding/border which can affect offset height
4131      // https://github.com/twolfson/line-height/issues/4
4132      // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetHeight
4133      _node.style.padding = '0px';
4134      _node.style.border = '0px';
4135  
4136      // Append it to the body
4137      var body = document.body;
4138      body.appendChild(_node);
4139  
4140      // Assume the line height of the element is the height
4141      var height = _node.offsetHeight;
4142      lnHeight = height;
4143  
4144      // Remove our child from the DOM
4145      body.removeChild(_node);
4146    }
4147  
4148    // Return the calculated height
4149    return lnHeight;
4150  }
4151  
4152  // Export lineHeight
4153  module.exports = lineHeight;
4154  
4155  
4156  /***/ }),
4157  
4158  /***/ 195:
4159  /***/ (function(module, exports) {
4160  
4161  // This code has been refactored for 140 bytes
4162  // You can see the original here: https://github.com/twolfson/computedStyle/blob/04cd1da2e30fa45844f95f5cb1ac898e9b9ef050/lib/computedStyle.js
4163  var computedStyle = function (el, prop, getComputedStyle) {
4164    getComputedStyle = window.getComputedStyle;
4165  
4166    // In one fell swoop
4167    return (
4168      // If we have getComputedStyle
4169      getComputedStyle ?
4170        // Query it
4171        // TODO: From CSS-Query notes, we might need (node, null) for FF
4172        getComputedStyle(el) :
4173  
4174      // Otherwise, we are in IE and use currentStyle
4175        el.currentStyle
4176    )[
4177      // Switch to camelCase for CSSOM
4178      // DEV: Grabbed from jQuery
4179      // https://github.com/jquery/jquery/blob/1.9-stable/src/css.js#L191-L194
4180      // https://github.com/jquery/jquery/blob/1.9-stable/src/core.js#L593-L597
4181      prop.replace(/-(\w)/gi, function (word, letter) {
4182        return letter.toUpperCase();
4183      })
4184    ];
4185  };
4186  
4187  module.exports = computedStyle;
4188  
4189  
4190  /***/ }),
4191  
4192  /***/ 196:
4193  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4194  
4195  "use strict";
4196  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
4197  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
4198  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
4199  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
4200  
4201  
4202  /**
4203   * WordPress dependencies
4204   */
4205  
4206  var link = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
4207    xmlns: "http://www.w3.org/2000/svg",
4208    viewBox: "0 0 24 24"
4209  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
4210    d: "M15.6 7.2H14v1.5h1.6c2 0 3.7 1.7 3.7 3.7s-1.7 3.7-3.7 3.7H14v1.5h1.6c2.8 0 5.2-2.3 5.2-5.2 0-2.9-2.3-5.2-5.2-5.2zM4.7 12.4c0-2 1.7-3.7 3.7-3.7H10V7.2H8.4c-2.9 0-5.2 2.3-5.2 5.2 0 2.9 2.3 5.2 5.2 5.2H10v-1.5H8.4c-2 0-3.7-1.7-3.7-3.7zm4.6.9h5.3v-1.5H9.3v1.5z"
4211  }));
4212  /* harmony default export */ __webpack_exports__["a"] = (link);
4213  
4214  
4215  /***/ }),
4216  
4217  /***/ 2:
4218  /***/ (function(module, exports) {
4219  
4220  (function() { module.exports = window["lodash"]; }());
4221  
4222  /***/ }),
4223  
4224  /***/ 213:
4225  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4226  
4227  "use strict";
4228  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
4229  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
4230  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
4231  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
4232  
4233  
4234  /**
4235   * WordPress dependencies
4236   */
4237  
4238  var blockDefault = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
4239    xmlns: "http://www.w3.org/2000/svg",
4240    viewBox: "0 0 24 24"
4241  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
4242    d: "M19 8h-1V6h-5v2h-2V6H6v2H5c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-8c0-1.1-.9-2-2-2zm.5 10c0 .3-.2.5-.5.5H5c-.3 0-.5-.2-.5-.5v-8c0-.3.2-.5.5-.5h14c.3 0 .5.2.5.5v8z"
4243  }));
4244  /* harmony default export */ __webpack_exports__["a"] = (blockDefault);
4245  
4246  
4247  /***/ }),
4248  
4249  /***/ 214:
4250  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4251  
4252  "use strict";
4253  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
4254  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
4255  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
4256  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
4257  
4258  
4259  /**
4260   * WordPress dependencies
4261   */
4262  
4263  var plus = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
4264    xmlns: "http://www.w3.org/2000/svg",
4265    viewBox: "0 0 24 24"
4266  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
4267    d: "M18 11.2h-5.2V6h-1.6v5.2H6v1.6h5.2V18h1.6v-5.2H18z"
4268  }));
4269  /* harmony default export */ __webpack_exports__["a"] = (plus);
4270  
4271  
4272  /***/ }),
4273  
4274  /***/ 215:
4275  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4276  
4277  "use strict";
4278  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
4279  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
4280  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
4281  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
4282  
4283  
4284  /**
4285   * WordPress dependencies
4286   */
4287  
4288  var search = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
4289    xmlns: "http://www.w3.org/2000/svg",
4290    viewBox: "0 0 24 24"
4291  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
4292    d: "M13.5 6C10.5 6 8 8.5 8 11.5c0 1.1.3 2.1.9 3l-3.4 3 1 1.1 3.4-2.9c1 .9 2.2 1.4 3.6 1.4 3 0 5.5-2.5 5.5-5.5C19 8.5 16.5 6 13.5 6zm0 9.5c-2.2 0-4-1.8-4-4s1.8-4 4-4 4 1.8 4 4-1.8 4-4 4z"
4293  }));
4294  /* harmony default export */ __webpack_exports__["a"] = (search);
4295  
4296  
4297  /***/ }),
4298  
4299  /***/ 216:
4300  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4301  
4302  "use strict";
4303  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
4304  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
4305  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
4306  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
4307  
4308  
4309  /**
4310   * WordPress dependencies
4311   */
4312  
4313  var chevronRight = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
4314    xmlns: "http://www.w3.org/2000/svg",
4315    viewBox: "0 0 24 24"
4316  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
4317    d: "M10.6 6L9.4 7l4.6 5-4.6 5 1.2 1 5.4-6z"
4318  }));
4319  /* harmony default export */ __webpack_exports__["a"] = (chevronRight);
4320  
4321  
4322  /***/ }),
4323  
4324  /***/ 217:
4325  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4326  
4327  "use strict";
4328  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
4329  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
4330  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
4331  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
4332  
4333  
4334  /**
4335   * WordPress dependencies
4336   */
4337  
4338  var chevronLeft = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
4339    xmlns: "http://www.w3.org/2000/svg",
4340    viewBox: "0 0 24 24"
4341  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
4342    d: "M14.6 7l-1.2-1L8 12l5.4 6 1.2-1-4.6-5z"
4343  }));
4344  /* harmony default export */ __webpack_exports__["a"] = (chevronLeft);
4345  
4346  
4347  /***/ }),
4348  
4349  /***/ 218:
4350  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4351  
4352  "use strict";
4353  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
4354  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
4355  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
4356  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
4357  
4358  
4359  /**
4360   * WordPress dependencies
4361   */
4362  
4363  var keyboardReturn = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
4364    xmlns: "http://www.w3.org/2000/svg",
4365    viewBox: "-2 -2 24 24"
4366  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
4367    d: "M6.734 16.106l2.176-2.38-1.093-1.028-3.846 4.158 3.846 4.157 1.093-1.027-2.176-2.38h2.811c1.125 0 2.25.03 3.374 0 1.428-.001 3.362-.25 4.963-1.277 1.66-1.065 2.868-2.906 2.868-5.859 0-2.479-1.327-4.896-3.65-5.93-1.82-.813-3.044-.8-4.806-.788l-.567.002v1.5c.184 0 .368 0 .553-.002 1.82-.007 2.704-.014 4.21.657 1.854.827 2.76 2.657 2.76 4.561 0 2.472-.973 3.824-2.178 4.596-1.258.807-2.864 1.04-4.163 1.04h-.02c-1.115.03-2.229 0-3.344 0H6.734z"
4368  }));
4369  /* harmony default export */ __webpack_exports__["a"] = (keyboardReturn);
4370  
4371  
4372  /***/ }),
4373  
4374  /***/ 219:
4375  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4376  
4377  "use strict";
4378  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
4379  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
4380  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
4381  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
4382  
4383  
4384  /**
4385   * WordPress dependencies
4386   */
4387  
4388  var upload = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
4389    xmlns: "http://www.w3.org/2000/svg",
4390    viewBox: "0 0 24 24"
4391  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
4392    d: "M18.5 15v3.5H13V6.7l4.5 4.1 1-1.1-6.2-5.8-5.8 5.8 1 1.1 4-4v11.7h-6V15H4v5h16v-5z"
4393  }));
4394  /* harmony default export */ __webpack_exports__["a"] = (upload);
4395  
4396  
4397  /***/ }),
4398  
4399  /***/ 22:
4400  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4401  
4402  "use strict";
4403  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _getPrototypeOf; });
4404  function _getPrototypeOf(o) {
4405    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
4406      return o.__proto__ || Object.getPrototypeOf(o);
4407    };
4408    return _getPrototypeOf(o);
4409  }
4410  
4411  /***/ }),
4412  
4413  /***/ 24:
4414  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4415  
4416  "use strict";
4417  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; });
4418  function _arrayLikeToArray(arr, len) {
4419    if (len == null || len > arr.length) len = arr.length;
4420  
4421    for (var i = 0, arr2 = new Array(len); i < len; i++) {
4422      arr2[i] = arr[i];
4423    }
4424  
4425    return arr2;
4426  }
4427  
4428  /***/ }),
4429  
4430  /***/ 25:
4431  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4432  
4433  "use strict";
4434  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; });
4435  function _classCallCheck(instance, Constructor) {
4436    if (!(instance instanceof Constructor)) {
4437      throw new TypeError("Cannot call a class as a function");
4438    }
4439  }
4440  
4441  /***/ }),
4442  
4443  /***/ 26:
4444  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4445  
4446  "use strict";
4447  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; });
4448  function _defineProperties(target, props) {
4449    for (var i = 0; i < props.length; i++) {
4450      var descriptor = props[i];
4451      descriptor.enumerable = descriptor.enumerable || false;
4452      descriptor.configurable = true;
4453      if ("value" in descriptor) descriptor.writable = true;
4454      Object.defineProperty(target, descriptor.key, descriptor);
4455    }
4456  }
4457  
4458  function _createClass(Constructor, protoProps, staticProps) {
4459    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
4460    if (staticProps) _defineProperties(Constructor, staticProps);
4461    return Constructor;
4462  }
4463  
4464  /***/ }),
4465  
4466  /***/ 27:
4467  /***/ (function(module, exports) {
4468  
4469  (function() { module.exports = window["wp"]["dom"]; }());
4470  
4471  /***/ }),
4472  
4473  /***/ 272:
4474  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4475  
4476  "use strict";
4477  
4478  // EXTERNAL MODULE: external ["wp","element"]
4479  var external_wp_element_ = __webpack_require__(0);
4480  
4481  // EXTERNAL MODULE: external ["wp","primitives"]
4482  var external_wp_primitives_ = __webpack_require__(7);
4483  
4484  // CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/pencil.js
4485  
4486  
4487  /**
4488   * WordPress dependencies
4489   */
4490  
4491  var pencil = Object(external_wp_element_["createElement"])(external_wp_primitives_["SVG"], {
4492    xmlns: "http://www.w3.org/2000/svg",
4493    viewBox: "0 0 24 24"
4494  }, Object(external_wp_element_["createElement"])(external_wp_primitives_["Path"], {
4495    d: "M20.1 5.1L16.9 2 6.2 12.7l-1.3 4.4 4.5-1.3L20.1 5.1zM4 20.8h8v-1.5H4v1.5z"
4496  }));
4497  /* harmony default export */ var library_pencil = (pencil);
4498  
4499  // CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/edit.js
4500  /**
4501   * Internal dependencies
4502   */
4503  
4504  /* harmony default export */ var edit = __webpack_exports__["a"] = (library_pencil);
4505  
4506  
4507  /***/ }),
4508  
4509  /***/ 275:
4510  /***/ (function(module, exports, __webpack_require__) {
4511  
4512  "use strict";
4513  /*istanbul ignore start*/
4514  
4515  
4516  Object.defineProperty(exports, "__esModule", {
4517    value: true
4518  });
4519  exports.diffChars = diffChars;
4520  exports.characterDiff = void 0;
4521  
4522  /*istanbul ignore end*/
4523  var
4524  /*istanbul ignore start*/
4525  _base = _interopRequireDefault(__webpack_require__(307))
4526  /*istanbul ignore end*/
4527  ;
4528  
4529  /*istanbul ignore start*/ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
4530  
4531  /*istanbul ignore end*/
4532  var characterDiff = new
4533  /*istanbul ignore start*/
4534  _base
4535  /*istanbul ignore end*/
4536  .
4537  /*istanbul ignore start*/
4538  default
4539  /*istanbul ignore end*/
4540  ();
4541  
4542  /*istanbul ignore start*/
4543  exports.characterDiff = characterDiff;
4544  
4545  /*istanbul ignore end*/
4546  function diffChars(oldStr, newStr, options) {
4547    return characterDiff.diff(oldStr, newStr, options);
4548  }
4549  
4550  
4551  /***/ }),
4552  
4553  /***/ 276:
4554  /***/ (function(module, exports, __webpack_require__) {
4555  
4556  "use strict";
4557  /*
4558  Copyright (c) 2014, Yahoo! Inc. All rights reserved.
4559  Copyrights licensed under the New BSD License.
4560  See the accompanying LICENSE file for terms.
4561  */
4562  
4563  
4564  
4565  exports.match = matchQuery;
4566  exports.parse = parseQuery;
4567  
4568  // -----------------------------------------------------------------------------
4569  
4570  var RE_MEDIA_QUERY     = /(?:(only|not)?\s*([^\s\(\)]+)(?:\s*and)?\s*)?(.+)?/i,
4571      RE_MQ_EXPRESSION   = /\(\s*([^\s\:\)]+)\s*(?:\:\s*([^\s\)]+))?\s*\)/,
4572      RE_MQ_FEATURE      = /^(?:(min|max)-)?(.+)/,
4573      RE_LENGTH_UNIT     = /(em|rem|px|cm|mm|in|pt|pc)?$/,
4574      RE_RESOLUTION_UNIT = /(dpi|dpcm|dppx)?$/;
4575  
4576  function matchQuery(mediaQuery, values) {
4577      return parseQuery(mediaQuery).some(function (query) {
4578          var inverse = query.inverse;
4579  
4580          // Either the parsed or specified `type` is "all", or the types must be
4581          // equal for a match.
4582          var typeMatch = query.type === 'all' || values.type === query.type;
4583  
4584          // Quit early when `type` doesn't match, but take "not" into account.
4585          if ((typeMatch && inverse) || !(typeMatch || inverse)) {
4586              return false;
4587          }
4588  
4589          var expressionsMatch = query.expressions.every(function (expression) {
4590              var feature  = expression.feature,
4591                  modifier = expression.modifier,
4592                  expValue = expression.value,
4593                  value    = values[feature];
4594  
4595              // Missing or falsy values don't match.
4596              if (!value) { return false; }
4597  
4598              switch (feature) {
4599                  case 'orientation':
4600                  case 'scan':
4601                      return value.toLowerCase() === expValue.toLowerCase();
4602  
4603                  case 'width':
4604                  case 'height':
4605                  case 'device-width':
4606                  case 'device-height':
4607                      expValue = toPx(expValue);
4608                      value    = toPx(value);
4609                      break;
4610  
4611                  case 'resolution':
4612                      expValue = toDpi(expValue);
4613                      value    = toDpi(value);
4614                      break;
4615  
4616                  case 'aspect-ratio':
4617                  case 'device-aspect-ratio':
4618                  case /* Deprecated */ 'device-pixel-ratio':
4619                      expValue = toDecimal(expValue);
4620                      value    = toDecimal(value);
4621                      break;
4622  
4623                  case 'grid':
4624                  case 'color':
4625                  case 'color-index':
4626                  case 'monochrome':
4627                      expValue = parseInt(expValue, 10) || 1;
4628                      value    = parseInt(value, 10) || 0;
4629                      break;
4630              }
4631  
4632              switch (modifier) {
4633                  case 'min': return value >= expValue;
4634                  case 'max': return value <= expValue;
4635                  default   : return value === expValue;
4636              }
4637          });
4638  
4639          return (expressionsMatch && !inverse) || (!expressionsMatch && inverse);
4640      });
4641  }
4642  
4643  function parseQuery(mediaQuery) {
4644      return mediaQuery.split(',').map(function (query) {
4645          query = query.trim();
4646  
4647          var captures    = query.match(RE_MEDIA_QUERY),
4648              modifier    = captures[1],
4649              type        = captures[2],
4650              expressions = captures[3] || '',
4651              parsed      = {};
4652  
4653          parsed.inverse = !!modifier && modifier.toLowerCase() === 'not';
4654          parsed.type    = type ? type.toLowerCase() : 'all';
4655  
4656          // Split expressions into a list.
4657          expressions = expressions.match(/\([^\)]+\)/g) || [];
4658  
4659          parsed.expressions = expressions.map(function (expression) {
4660              var captures = expression.match(RE_MQ_EXPRESSION),
4661                  feature  = captures[1].toLowerCase().match(RE_MQ_FEATURE);
4662  
4663              return {
4664                  modifier: feature[1],
4665                  feature : feature[2],
4666                  value   : captures[2]
4667              };
4668          });
4669  
4670          return parsed;
4671      });
4672  }
4673  
4674  // -- Utilities ----------------------------------------------------------------
4675  
4676  function toDecimal(ratio) {
4677      var decimal = Number(ratio),
4678          numbers;
4679  
4680      if (!decimal) {
4681          numbers = ratio.match(/^(\d+)\s*\/\s*(\d+)$/);
4682          decimal = numbers[1] / numbers[2];
4683      }
4684  
4685      return decimal;
4686  }
4687  
4688  function toDpi(resolution) {
4689      var value = parseFloat(resolution),
4690          units = String(resolution).match(RE_RESOLUTION_UNIT)[1];
4691  
4692      switch (units) {
4693          case 'dpcm': return value / 2.54;
4694          case 'dppx': return value * 96;
4695          default    : return value;
4696      }
4697  }
4698  
4699  function toPx(length) {
4700      var value = parseFloat(length),
4701          units = String(length).match(RE_LENGTH_UNIT)[1];
4702  
4703      switch (units) {
4704          case 'em' : return value * 16;
4705          case 'rem': return value * 16;
4706          case 'cm' : return value * 96 / 2.54;
4707          case 'mm' : return value * 96 / 2.54 / 10;
4708          case 'in' : return value * 96;
4709          case 'pt' : return value * 72;
4710          case 'pc' : return value * 72 / 12;
4711          default   : return value;
4712      }
4713  }
4714  
4715  
4716  /***/ }),
4717  
4718  /***/ 277:
4719  /***/ (function(module, exports) {
4720  
4721  var traverse = module.exports = function (obj) {
4722      return new Traverse(obj);
4723  };
4724  
4725  function Traverse (obj) {
4726      this.value = obj;
4727  }
4728  
4729  Traverse.prototype.get = function (ps) {
4730      var node = this.value;
4731      for (var i = 0; i < ps.length; i ++) {
4732          var key = ps[i];
4733          if (!node || !hasOwnProperty.call(node, key)) {
4734              node = undefined;
4735              break;
4736          }
4737          node = node[key];
4738      }
4739      return node;
4740  };
4741  
4742  Traverse.prototype.has = function (ps) {
4743      var node = this.value;
4744      for (var i = 0; i < ps.length; i ++) {
4745          var key = ps[i];
4746          if (!node || !hasOwnProperty.call(node, key)) {
4747              return false;
4748          }
4749          node = node[key];
4750      }
4751      return true;
4752  };
4753  
4754  Traverse.prototype.set = function (ps, value) {
4755      var node = this.value;
4756      for (var i = 0; i < ps.length - 1; i ++) {
4757          var key = ps[i];
4758          if (!hasOwnProperty.call(node, key)) node[key] = {};
4759          node = node[key];
4760      }
4761      node[ps[i]] = value;
4762      return value;
4763  };
4764  
4765  Traverse.prototype.map = function (cb) {
4766      return walk(this.value, cb, true);
4767  };
4768  
4769  Traverse.prototype.forEach = function (cb) {
4770      this.value = walk(this.value, cb, false);
4771      return this.value;
4772  };
4773  
4774  Traverse.prototype.reduce = function (cb, init) {
4775      var skip = arguments.length === 1;
4776      var acc = skip ? this.value : init;
4777      this.forEach(function (x) {
4778          if (!this.isRoot || !skip) {
4779              acc = cb.call(this, acc, x);
4780          }
4781      });
4782      return acc;
4783  };
4784  
4785  Traverse.prototype.paths = function () {
4786      var acc = [];
4787      this.forEach(function (x) {
4788          acc.push(this.path); 
4789      });
4790      return acc;
4791  };
4792  
4793  Traverse.prototype.nodes = function () {
4794      var acc = [];
4795      this.forEach(function (x) {
4796          acc.push(this.node);
4797      });
4798      return acc;
4799  };
4800  
4801  Traverse.prototype.clone = function () {
4802      var parents = [], nodes = [];
4803      
4804      return (function clone (src) {
4805          for (var i = 0; i < parents.length; i++) {
4806              if (parents[i] === src) {
4807                  return nodes[i];
4808              }
4809          }
4810          
4811          if (typeof src === 'object' && src !== null) {
4812              var dst = copy(src);
4813              
4814              parents.push(src);
4815              nodes.push(dst);
4816              
4817              forEach(objectKeys(src), function (key) {
4818                  dst[key] = clone(src[key]);
4819              });
4820              
4821              parents.pop();
4822              nodes.pop();
4823              return dst;
4824          }
4825          else {
4826              return src;
4827          }
4828      })(this.value);
4829  };
4830  
4831  function walk (root, cb, immutable) {
4832      var path = [];
4833      var parents = [];
4834      var alive = true;
4835      
4836      return (function walker (node_) {
4837          var node = immutable ? copy(node_) : node_;
4838          var modifiers = {};
4839          
4840          var keepGoing = true;
4841          
4842          var state = {
4843              node : node,
4844              node_ : node_,
4845              path : [].concat(path),
4846              parent : parents[parents.length - 1],
4847              parents : parents,
4848              key : path.slice(-1)[0],
4849              isRoot : path.length === 0,
4850              level : path.length,
4851              circular : null,
4852              update : function (x, stopHere) {
4853                  if (!state.isRoot) {
4854                      state.parent.node[state.key] = x;
4855                  }
4856                  state.node = x;
4857                  if (stopHere) keepGoing = false;
4858              },
4859              'delete' : function (stopHere) {
4860                  delete state.parent.node[state.key];
4861                  if (stopHere) keepGoing = false;
4862              },
4863              remove : function (stopHere) {
4864                  if (isArray(state.parent.node)) {
4865                      state.parent.node.splice(state.key, 1);
4866                  }
4867                  else {
4868                      delete state.parent.node[state.key];
4869                  }
4870                  if (stopHere) keepGoing = false;
4871              },
4872              keys : null,
4873              before : function (f) { modifiers.before = f },
4874              after : function (f) { modifiers.after = f },
4875              pre : function (f) { modifiers.pre = f },
4876              post : function (f) { modifiers.post = f },
4877              stop : function () { alive = false },
4878              block : function () { keepGoing = false }
4879          };
4880          
4881          if (!alive) return state;
4882          
4883          function updateState() {
4884              if (typeof state.node === 'object' && state.node !== null) {
4885                  if (!state.keys || state.node_ !== state.node) {
4886                      state.keys = objectKeys(state.node)
4887                  }
4888                  
4889                  state.isLeaf = state.keys.length == 0;
4890                  
4891                  for (var i = 0; i < parents.length; i++) {
4892                      if (parents[i].node_ === node_) {
4893                          state.circular = parents[i];
4894                          break;
4895                      }
4896                  }
4897              }
4898              else {
4899                  state.isLeaf = true;
4900                  state.keys = null;
4901              }
4902              
4903              state.notLeaf = !state.isLeaf;
4904              state.notRoot = !state.isRoot;
4905          }
4906          
4907          updateState();
4908          
4909          // use return values to update if defined
4910          var ret = cb.call(state, state.node);
4911          if (ret !== undefined && state.update) state.update(ret);
4912          
4913          if (modifiers.before) modifiers.before.call(state, state.node);
4914          
4915          if (!keepGoing) return state;
4916          
4917          if (typeof state.node == 'object'
4918          && state.node !== null && !state.circular) {
4919              parents.push(state);
4920              
4921              updateState();
4922              
4923              forEach(state.keys, function (key, i) {
4924                  path.push(key);
4925                  
4926                  if (modifiers.pre) modifiers.pre.call(state, state.node[key], key);
4927                  
4928                  var child = walker(state.node[key]);
4929                  if (immutable && hasOwnProperty.call(state.node, key)) {
4930                      state.node[key] = child.node;
4931                  }
4932                  
4933                  child.isLast = i == state.keys.length - 1;
4934                  child.isFirst = i == 0;
4935                  
4936                  if (modifiers.post) modifiers.post.call(state, child);
4937                  
4938                  path.pop();
4939              });
4940              parents.pop();
4941          }
4942          
4943          if (modifiers.after) modifiers.after.call(state, state.node);
4944          
4945          return state;
4946      })(root).node;
4947  }
4948  
4949  function copy (src) {
4950      if (typeof src === 'object' && src !== null) {
4951          var dst;
4952          
4953          if (isArray(src)) {
4954              dst = [];
4955          }
4956          else if (isDate(src)) {
4957              dst = new Date(src.getTime ? src.getTime() : src);
4958          }
4959          else if (isRegExp(src)) {
4960              dst = new RegExp(src);
4961          }
4962          else if (isError(src)) {
4963              dst = { message: src.message };
4964          }
4965          else if (isBoolean(src)) {
4966              dst = new Boolean(src);
4967          }
4968          else if (isNumber(src)) {
4969              dst = new Number(src);
4970          }
4971          else if (isString(src)) {
4972              dst = new String(src);
4973          }
4974          else if (Object.create && Object.getPrototypeOf) {
4975              dst = Object.create(Object.getPrototypeOf(src));
4976          }
4977          else if (src.constructor === Object) {
4978              dst = {};
4979          }
4980          else {
4981              var proto =
4982                  (src.constructor && src.constructor.prototype)
4983                  || src.__proto__
4984                  || {}
4985              ;
4986              var T = function () {};
4987              T.prototype = proto;
4988              dst = new T;
4989          }
4990          
4991          forEach(objectKeys(src), function (key) {
4992              dst[key] = src[key];
4993          });
4994          return dst;
4995      }
4996      else return src;
4997  }
4998  
4999  var objectKeys = Object.keys || function keys (obj) {
5000      var res = [];
5001      for (var key in obj) res.push(key)
5002      return res;
5003  };
5004  
5005  function toS (obj) { return Object.prototype.toString.call(obj) }
5006  function isDate (obj) { return toS(obj) === '[object Date]' }
5007  function isRegExp (obj) { return toS(obj) === '[object RegExp]' }
5008  function isError (obj) { return toS(obj) === '[object Error]' }
5009  function isBoolean (obj) { return toS(obj) === '[object Boolean]' }
5010  function isNumber (obj) { return toS(obj) === '[object Number]' }
5011  function isString (obj) { return toS(obj) === '[object String]' }
5012  
5013  var isArray = Array.isArray || function isArray (xs) {
5014      return Object.prototype.toString.call(xs) === '[object Array]';
5015  };
5016  
5017  var forEach = function (xs, fn) {
5018      if (xs.forEach) return xs.forEach(fn)
5019      else for (var i = 0; i < xs.length; i++) {
5020          fn(xs[i], i, xs);
5021      }
5022  };
5023  
5024  forEach(objectKeys(Traverse.prototype), function (key) {
5025      traverse[key] = function (obj) {
5026          var args = [].slice.call(arguments, 1);
5027          var t = new Traverse(obj);
5028          return t[key].apply(t, args);
5029      };
5030  });
5031  
5032  var hasOwnProperty = Object.hasOwnProperty || function (obj, key) {
5033      return key in obj;
5034  };
5035  
5036  
5037  /***/ }),
5038  
5039  /***/ 28:
5040  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5041  
5042  "use strict";
5043  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; });
5044  /* harmony import */ var _arrayLikeToArray_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(24);
5045  
5046  function _unsupportedIterableToArray(o, minLen) {
5047    if (!o) return;
5048    if (typeof o === "string") return Object(_arrayLikeToArray_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
5049    var n = Object.prototype.toString.call(o).slice(8, -1);
5050    if (n === "Object" && o.constructor) n = o.constructor.name;
5051    if (n === "Map" || n === "Set") return Array.from(o);
5052    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_arrayLikeToArray_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
5053  }
5054  
5055  /***/ }),
5056  
5057  /***/ 29:
5058  /***/ (function(module, exports) {
5059  
5060  (function() { module.exports = window["wp"]["url"]; }());
5061  
5062  /***/ }),
5063  
5064  /***/ 3:
5065  /***/ (function(module, exports) {
5066  
5067  (function() { module.exports = window["wp"]["components"]; }());
5068  
5069  /***/ }),
5070  
5071  /***/ 300:
5072  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5073  
5074  "use strict";
5075  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
5076  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
5077  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
5078  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
5079  
5080  
5081  /**
5082   * WordPress dependencies
5083   */
5084  
5085  var formatStrikethrough = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
5086    xmlns: "http://www.w3.org/2000/svg",
5087    viewBox: "0 0 24 24"
5088  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
5089    d: "M9.1 9v-.5c0-.6.2-1.1.7-1.4.5-.3 1.2-.5 2-.5.7 0 1.4.1 2.1.3.7.2 1.4.5 2.1.9l.2-1.9c-.6-.3-1.2-.5-1.9-.7-.8-.1-1.6-.2-2.4-.2-1.5 0-2.7.3-3.6 1-.8.7-1.2 1.5-1.2 2.6V9h2zM20 12H4v1h8.3c.3.1.6.2.8.3.5.2.9.5 1.1.8.3.3.4.7.4 1.2 0 .7-.2 1.1-.8 1.5-.5.3-1.2.5-2.1.5-.8 0-1.6-.1-2.4-.3-.8-.2-1.5-.5-2.2-.8L7 18.1c.5.2 1.2.4 2 .6.8.2 1.6.3 2.4.3 1.7 0 3-.3 3.9-1 .9-.7 1.3-1.6 1.3-2.8 0-.9-.2-1.7-.7-2.2H20v-1z"
5090  }));
5091  /* harmony default export */ __webpack_exports__["a"] = (formatStrikethrough);
5092  
5093  
5094  /***/ }),
5095  
5096  /***/ 301:
5097  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5098  
5099  "use strict";
5100  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
5101  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
5102  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
5103  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
5104  
5105  
5106  /**
5107   * WordPress dependencies
5108   */
5109  
5110  var alignLeft = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
5111    xmlns: "http://www.w3.org/2000/svg",
5112    viewBox: "0 0 24 24"
5113  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
5114    d: "M4 19.8h8.9v-1.5H4v1.5zm8.9-15.6H4v1.5h8.9V4.2zm-8.9 7v1.5h16v-1.5H4z"
5115  }));
5116  /* harmony default export */ __webpack_exports__["a"] = (alignLeft);
5117  
5118  
5119  /***/ }),
5120  
5121  /***/ 302:
5122  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5123  
5124  "use strict";
5125  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
5126  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
5127  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
5128  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
5129  
5130  
5131  /**
5132   * WordPress dependencies
5133   */
5134  
5135  var alignCenter = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
5136    xmlns: "http://www.w3.org/2000/svg",
5137    viewBox: "0 0 24 24"
5138  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
5139    d: "M16.4 4.2H7.6v1.5h8.9V4.2zM4 11.2v1.5h16v-1.5H4zm3.6 8.6h8.9v-1.5H7.6v1.5z"
5140  }));
5141  /* harmony default export */ __webpack_exports__["a"] = (alignCenter);
5142  
5143  
5144  /***/ }),
5145  
5146  /***/ 303:
5147  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5148  
5149  "use strict";
5150  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
5151  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
5152  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
5153  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
5154  
5155  
5156  /**
5157   * WordPress dependencies
5158   */
5159  
5160  var alignRight = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
5161    xmlns: "http://www.w3.org/2000/svg",
5162    viewBox: "0 0 24 24"
5163  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
5164    d: "M11.1 19.8H20v-1.5h-8.9v1.5zm0-15.6v1.5H20V4.2h-8.9zM4 12.8h16v-1.5H4v1.5z"
5165  }));
5166  /* harmony default export */ __webpack_exports__["a"] = (alignRight);
5167  
5168  
5169  /***/ }),
5170  
5171  /***/ 304:
5172  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5173  
5174  "use strict";
5175  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
5176  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
5177  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
5178  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
5179  
5180  
5181  /**
5182   * WordPress dependencies
5183   */
5184  
5185  var chevronUp = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
5186    viewBox: "0 0 24 24",
5187    xmlns: "http://www.w3.org/2000/svg"
5188  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
5189    d: "M6.5 12.4L12 8l5.5 4.4-.9 1.2L12 10l-4.5 3.6-1-1.2z"
5190  }));
5191  /* harmony default export */ __webpack_exports__["a"] = (chevronUp);
5192  
5193  
5194  /***/ }),
5195  
5196  /***/ 305:
5197  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5198  
5199  "use strict";
5200  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
5201  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
5202  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
5203  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
5204  
5205  
5206  /**
5207   * WordPress dependencies
5208   */
5209  
5210  var chevronDown = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
5211    viewBox: "0 0 24 24",
5212    xmlns: "http://www.w3.org/2000/svg"
5213  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
5214    d: "M17.5 11.6L12 16l-5.5-4.4.9-1.2L12 14l4.5-3.6 1 1.2z"
5215  }));
5216  /* harmony default export */ __webpack_exports__["a"] = (chevronDown);
5217  
5218  
5219  /***/ }),
5220  
5221  /***/ 306:
5222  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5223  
5224  "use strict";
5225  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
5226  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
5227  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
5228  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
5229  
5230  
5231  /**
5232   * WordPress dependencies
5233   */
5234  
5235  var moreVertical = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
5236    xmlns: "http://www.w3.org/2000/svg",
5237    viewBox: "0 0 24 24"
5238  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
5239    d: "M13 19h-2v-2h2v2zm0-6h-2v-2h2v2zm0-6h-2V5h2v2z"
5240  }));
5241  /* harmony default export */ __webpack_exports__["a"] = (moreVertical);
5242  
5243  
5244  /***/ }),
5245  
5246  /***/ 307:
5247  /***/ (function(module, exports, __webpack_require__) {
5248  
5249  "use strict";
5250  /*istanbul ignore start*/
5251  
5252  
5253  Object.defineProperty(exports, "__esModule", {
5254    value: true
5255  });
5256  exports.default = Diff;
5257  
5258  /*istanbul ignore end*/
5259  function Diff() {}
5260  
5261  Diff.prototype = {
5262    /*istanbul ignore start*/
5263  
5264    /*istanbul ignore end*/
5265    diff: function diff(oldString, newString) {
5266      /*istanbul ignore start*/
5267      var
5268      /*istanbul ignore end*/
5269      options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
5270      var callback = options.callback;
5271  
5272      if (typeof options === 'function') {
5273        callback = options;
5274        options = {};
5275      }
5276  
5277      this.options = options;
5278      var self = this;
5279  
5280      function done(value) {
5281        if (callback) {
5282          setTimeout(function () {
5283            callback(undefined, value);
5284          }, 0);
5285          return true;
5286        } else {
5287          return value;
5288        }
5289      } // Allow subclasses to massage the input prior to running
5290  
5291  
5292      oldString = this.castInput(oldString);
5293      newString = this.castInput(newString);
5294      oldString = this.removeEmpty(this.tokenize(oldString));
5295      newString = this.removeEmpty(this.tokenize(newString));
5296      var newLen = newString.length,
5297          oldLen = oldString.length;
5298      var editLength = 1;
5299      var maxEditLength = newLen + oldLen;
5300      var bestPath = [{
5301        newPos: -1,
5302        components: []
5303      }]; // Seed editLength = 0, i.e. the content starts with the same values
5304  
5305      var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
5306  
5307      if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
5308        // Identity per the equality and tokenizer
5309        return done([{
5310          value: this.join(newString),
5311          count: newString.length
5312        }]);
5313      } // Main worker method. checks all permutations of a given edit length for acceptance.
5314  
5315  
5316      function execEditLength() {
5317        for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
5318          var basePath =
5319          /*istanbul ignore start*/
5320          void 0
5321          /*istanbul ignore end*/
5322          ;
5323  
5324          var addPath = bestPath[diagonalPath - 1],
5325              removePath = bestPath[diagonalPath + 1],
5326              _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
5327  
5328          if (addPath) {
5329            // No one else is going to attempt to use this value, clear it
5330            bestPath[diagonalPath - 1] = undefined;
5331          }
5332  
5333          var canAdd = addPath && addPath.newPos + 1 < newLen,
5334              canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen;
5335  
5336          if (!canAdd && !canRemove) {
5337            // If this path is a terminal then prune
5338            bestPath[diagonalPath] = undefined;
5339            continue;
5340          } // Select the diagonal that we want to branch from. We select the prior
5341          // path whose position in the new string is the farthest from the origin
5342          // and does not pass the bounds of the diff graph
5343  
5344  
5345          if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
5346            basePath = clonePath(removePath);
5347            self.pushComponent(basePath.components, undefined, true);
5348          } else {
5349            basePath = addPath; // No need to clone, we've pulled it from the list
5350  
5351            basePath.newPos++;
5352            self.pushComponent(basePath.components, true, undefined);
5353          }
5354  
5355          _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done
5356  
5357          if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) {
5358            return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));
5359          } else {
5360            // Otherwise track this path as a potential candidate and continue.
5361            bestPath[diagonalPath] = basePath;
5362          }
5363        }
5364  
5365        editLength++;
5366      } // Performs the length of edit iteration. Is a bit fugly as this has to support the
5367      // sync and async mode which is never fun. Loops over execEditLength until a value
5368      // is produced.
5369  
5370  
5371      if (callback) {
5372        (function exec() {
5373          setTimeout(function () {
5374            // This should not happen, but we want to be safe.
5375  
5376            /* istanbul ignore next */
5377            if (editLength > maxEditLength) {
5378              return callback();
5379            }
5380  
5381            if (!execEditLength()) {
5382              exec();
5383            }
5384          }, 0);
5385        })();
5386      } else {
5387        while (editLength <= maxEditLength) {
5388          var ret = execEditLength();
5389  
5390          if (ret) {
5391            return ret;
5392          }
5393        }
5394      }
5395    },
5396  
5397    /*istanbul ignore start*/
5398  
5399    /*istanbul ignore end*/
5400    pushComponent: function pushComponent(components, added, removed) {
5401      var last = components[components.length - 1];
5402  
5403      if (last && last.added === added && last.removed === removed) {
5404        // We need to clone here as the component clone operation is just
5405        // as shallow array clone
5406        components[components.length - 1] = {
5407          count: last.count + 1,
5408          added: added,
5409          removed: removed
5410        };
5411      } else {
5412        components.push({
5413          count: 1,
5414          added: added,
5415          removed: removed
5416        });
5417      }
5418    },
5419  
5420    /*istanbul ignore start*/
5421  
5422    /*istanbul ignore end*/
5423    extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
5424      var newLen = newString.length,
5425          oldLen = oldString.length,
5426          newPos = basePath.newPos,
5427          oldPos = newPos - diagonalPath,
5428          commonCount = 0;
5429  
5430      while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
5431        newPos++;
5432        oldPos++;
5433        commonCount++;
5434      }
5435  
5436      if (commonCount) {
5437        basePath.components.push({
5438          count: commonCount
5439        });
5440      }
5441  
5442      basePath.newPos = newPos;
5443      return oldPos;
5444    },
5445  
5446    /*istanbul ignore start*/
5447  
5448    /*istanbul ignore end*/
5449    equals: function equals(left, right) {
5450      if (this.options.comparator) {
5451        return this.options.comparator(left, right);
5452      } else {
5453        return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
5454      }
5455    },
5456  
5457    /*istanbul ignore start*/
5458  
5459    /*istanbul ignore end*/
5460    removeEmpty: function removeEmpty(array) {
5461      var ret = [];
5462  
5463      for (var i = 0; i < array.length; i++) {
5464        if (array[i]) {
5465          ret.push(array[i]);
5466        }
5467      }
5468  
5469      return ret;
5470    },
5471  
5472    /*istanbul ignore start*/
5473  
5474    /*istanbul ignore end*/
5475    castInput: function castInput(value) {
5476      return value;
5477    },
5478  
5479    /*istanbul ignore start*/
5480  
5481    /*istanbul ignore end*/
5482    tokenize: function tokenize(value) {
5483      return value.split('');
5484    },
5485  
5486    /*istanbul ignore start*/
5487  
5488    /*istanbul ignore end*/
5489    join: function join(chars) {
5490      return chars.join('');
5491    }
5492  };
5493  
5494  function buildValues(diff, components, newString, oldString, useLongestToken) {
5495    var componentPos = 0,
5496        componentLen = components.length,
5497        newPos = 0,
5498        oldPos = 0;
5499  
5500    for (; componentPos < componentLen; componentPos++) {
5501      var component = components[componentPos];
5502  
5503      if (!component.removed) {
5504        if (!component.added && useLongestToken) {
5505          var value = newString.slice(newPos, newPos + component.count);
5506          value = value.map(function (value, i) {
5507            var oldValue = oldString[oldPos + i];
5508            return oldValue.length > value.length ? oldValue : value;
5509          });
5510          component.value = diff.join(value);
5511        } else {
5512          component.value = diff.join(newString.slice(newPos, newPos + component.count));
5513        }
5514  
5515        newPos += component.count; // Common case
5516  
5517        if (!component.added) {
5518          oldPos += component.count;
5519        }
5520      } else {
5521        component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));
5522        oldPos += component.count; // Reverse add and remove so removes are output first to match common convention
5523        // The diffing algorithm is tied to add then remove output and this is the simplest
5524        // route to get the desired output with minimal overhead.
5525  
5526        if (componentPos && components[componentPos - 1].added) {
5527          var tmp = components[componentPos - 1];
5528          components[componentPos - 1] = components[componentPos];
5529          components[componentPos] = tmp;
5530        }
5531      }
5532    } // Special case handle for when one terminal is ignored (i.e. whitespace).
5533    // For this case we merge the terminal into the prior string and drop the change.
5534    // This is only available for string mode.
5535  
5536  
5537    var lastComponent = components[componentLen - 1];
5538  
5539    if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) {
5540      components[componentLen - 2].value += lastComponent.value;
5541      components.pop();
5542    }
5543  
5544    return components;
5545  }
5546  
5547  function clonePath(path) {
5548    return {
5549      newPos: path.newPos,
5550      components: path.components.slice(0)
5551    };
5552  }
5553  
5554  
5555  /***/ }),
5556  
5557  /***/ 308:
5558  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5559  
5560  "use strict";
5561  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
5562  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
5563  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
5564  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
5565  
5566  
5567  /**
5568   * WordPress dependencies
5569   */
5570  
5571  var layout = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
5572    xmlns: "http://www.w3.org/2000/svg",
5573    viewBox: "0 0 24 24"
5574  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
5575    d: "M18 5.5H6a.5.5 0 00-.5.5v3h13V6a.5.5 0 00-.5-.5zm.5 5H10v8h8a.5.5 0 00.5-.5v-7.5zm-10 0h-3V18a.5.5 0 00.5.5h2.5v-8zM6 4h12a2 2 0 012 2v12a2 2 0 01-2 2H6a2 2 0 01-2-2V6a2 2 0 012-2z"
5576  }));
5577  /* harmony default export */ __webpack_exports__["a"] = (layout);
5578  
5579  
5580  /***/ }),
5581  
5582  /***/ 309:
5583  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5584  
5585  "use strict";
5586  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
5587  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
5588  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
5589  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
5590  
5591  
5592  /**
5593   * WordPress dependencies
5594   */
5595  
5596  var media = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
5597    xmlns: "http://www.w3.org/2000/svg",
5598    viewBox: "0 0 24 24"
5599  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
5600    d: "M18.7 3H5.3C4 3 3 4 3 5.3v13.4C3 20 4 21 5.3 21h13.4c1.3 0 2.3-1 2.3-2.3V5.3C21 4 20 3 18.7 3zm.8 15.7c0 .4-.4.8-.8.8H5.3c-.4 0-.8-.4-.8-.8V5.3c0-.4.4-.8.8-.8h13.4c.4 0 .8.4.8.8v13.4zM10 15l5-3-5-3v6z"
5601  }));
5602  /* harmony default export */ __webpack_exports__["a"] = (media);
5603  
5604  
5605  /***/ }),
5606  
5607  /***/ 31:
5608  /***/ (function(module, exports, __webpack_require__) {
5609  
5610  /**
5611   * Copyright (c) 2013-present, Facebook, Inc.
5612   *
5613   * This source code is licensed under the MIT license found in the
5614   * LICENSE file in the root directory of this source tree.
5615   */
5616  
5617  if (false) { var throwOnDirectAccess, ReactIs; } else {
5618    // By explicitly using `prop-types` you are opting into new production behavior.
5619    // http://fb.me/prop-types-in-prod
5620    module.exports = __webpack_require__(137)();
5621  }
5622  
5623  
5624  /***/ }),
5625  
5626  /***/ 32:
5627  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5628  
5629  "use strict";
5630  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _inherits; });
5631  /* harmony import */ var _setPrototypeOf_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(55);
5632  
5633  function _inherits(subClass, superClass) {
5634    if (typeof superClass !== "function" && superClass !== null) {
5635      throw new TypeError("Super expression must either be null or a function");
5636    }
5637  
5638    subClass.prototype = Object.create(superClass && superClass.prototype, {
5639      constructor: {
5640        value: subClass,
5641        writable: true,
5642        configurable: true
5643      }
5644    });
5645    if (superClass) Object(_setPrototypeOf_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(subClass, superClass);
5646  }
5647  
5648  /***/ }),
5649  
5650  /***/ 33:
5651  /***/ (function(module, exports) {
5652  
5653  (function() { module.exports = window["wp"]["hooks"]; }());
5654  
5655  /***/ }),
5656  
5657  /***/ 34:
5658  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5659  
5660  "use strict";
5661  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; });
5662  /* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59);
5663  /* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__);
5664  /* harmony import */ var _assertThisInitialized_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(18);
5665  
5666  
5667  function _possibleConstructorReturn(self, call) {
5668    if (call && (_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default()(call) === "object" || typeof call === "function")) {
5669      return call;
5670    }
5671  
5672    return Object(_assertThisInitialized_js__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self);
5673  }
5674  
5675  /***/ }),
5676  
5677  /***/ 35:
5678  /***/ (function(module, exports) {
5679  
5680  (function() { module.exports = window["wp"]["deprecated"]; }());
5681  
5682  /***/ }),
5683  
5684  /***/ 37:
5685  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5686  
5687  "use strict";
5688  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; });
5689  function _arrayWithHoles(arr) {
5690    if (Array.isArray(arr)) return arr;
5691  }
5692  
5693  /***/ }),
5694  
5695  /***/ 38:
5696  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5697  
5698  "use strict";
5699  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; });
5700  function _nonIterableRest() {
5701    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
5702  }
5703  
5704  /***/ }),
5705  
5706  /***/ 39:
5707  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5708  
5709  "use strict";
5710  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; });
5711  function _iterableToArray(iter) {
5712    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
5713  }
5714  
5715  /***/ }),
5716  
5717  /***/ 4:
5718  /***/ (function(module, exports) {
5719  
5720  (function() { module.exports = window["wp"]["data"]; }());
5721  
5722  /***/ }),
5723  
5724  /***/ 40:
5725  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5726  
5727  "use strict";
5728  
5729  
5730  var LEAF_KEY, hasWeakMap;
5731  
5732  /**
5733   * Arbitrary value used as key for referencing cache object in WeakMap tree.
5734   *
5735   * @type {Object}
5736   */
5737  LEAF_KEY = {};
5738  
5739  /**
5740   * Whether environment supports WeakMap.
5741   *
5742   * @type {boolean}
5743   */
5744  hasWeakMap = typeof WeakMap !== 'undefined';
5745  
5746  /**
5747   * Returns the first argument as the sole entry in an array.
5748   *
5749   * @param {*} value Value to return.
5750   *
5751   * @return {Array} Value returned as entry in array.
5752   */
5753  function arrayOf( value ) {
5754      return [ value ];
5755  }
5756  
5757  /**
5758   * Returns true if the value passed is object-like, or false otherwise. A value
5759   * is object-like if it can support property assignment, e.g. object or array.
5760   *
5761   * @param {*} value Value to test.
5762   *
5763   * @return {boolean} Whether value is object-like.
5764   */
5765  function isObjectLike( value ) {
5766      return !! value && 'object' === typeof value;
5767  }
5768  
5769  /**
5770   * Creates and returns a new cache object.
5771   *
5772   * @return {Object} Cache object.
5773   */
5774  function createCache() {
5775      var cache = {
5776          clear: function() {
5777              cache.head = null;
5778          },
5779      };
5780  
5781      return cache;
5782  }
5783  
5784  /**
5785   * Returns true if entries within the two arrays are strictly equal by
5786   * reference from a starting index.
5787   *
5788   * @param {Array}  a         First array.
5789   * @param {Array}  b         Second array.
5790   * @param {number} fromIndex Index from which to start comparison.
5791   *
5792   * @return {boolean} Whether arrays are shallowly equal.
5793   */
5794  function isShallowEqual( a, b, fromIndex ) {
5795      var i;
5796  
5797      if ( a.length !== b.length ) {
5798          return false;
5799      }
5800  
5801      for ( i = fromIndex; i < a.length; i++ ) {
5802          if ( a[ i ] !== b[ i ] ) {
5803              return false;
5804          }
5805      }
5806  
5807      return true;
5808  }
5809  
5810  /**
5811   * Returns a memoized selector function. The getDependants function argument is
5812   * called before the memoized selector and is expected to return an immutable
5813   * reference or array of references on which the selector depends for computing
5814   * its own return value. The memoize cache is preserved only as long as those
5815   * dependant references remain the same. If getDependants returns a different
5816   * reference(s), the cache is cleared and the selector value regenerated.
5817   *
5818   * @param {Function} selector      Selector function.
5819   * @param {Function} getDependants Dependant getter returning an immutable
5820   *                                 reference or array of reference used in
5821   *                                 cache bust consideration.
5822   *
5823   * @return {Function} Memoized selector.
5824   */
5825  /* harmony default export */ __webpack_exports__["a"] = (function( selector, getDependants ) {
5826      var rootCache, getCache;
5827  
5828      // Use object source as dependant if getter not provided
5829      if ( ! getDependants ) {
5830          getDependants = arrayOf;
5831      }
5832  
5833      /**
5834       * Returns the root cache. If WeakMap is supported, this is assigned to the
5835       * root WeakMap cache set, otherwise it is a shared instance of the default
5836       * cache object.
5837       *
5838       * @return {(WeakMap|Object)} Root cache object.
5839       */
5840  	function getRootCache() {
5841          return rootCache;
5842      }
5843  
5844      /**
5845       * Returns the cache for a given dependants array. When possible, a WeakMap
5846       * will be used to create a unique cache for each set of dependants. This
5847       * is feasible due to the nature of WeakMap in allowing garbage collection
5848       * to occur on entries where the key object is no longer referenced. Since
5849       * WeakMap requires the key to be an object, this is only possible when the
5850       * dependant is object-like. The root cache is created as a hierarchy where
5851       * each top-level key is the first entry in a dependants set, the value a
5852       * WeakMap where each key is the next dependant, and so on. This continues
5853       * so long as the dependants are object-like. If no dependants are object-
5854       * like, then the cache is shared across all invocations.
5855       *
5856       * @see isObjectLike
5857       *
5858       * @param {Array} dependants Selector dependants.
5859       *
5860       * @return {Object} Cache object.
5861       */
5862  	function getWeakMapCache( dependants ) {
5863          var caches = rootCache,
5864              isUniqueByDependants = true,
5865              i, dependant, map, cache;
5866  
5867          for ( i = 0; i < dependants.length; i++ ) {
5868              dependant = dependants[ i ];
5869  
5870              // Can only compose WeakMap from object-like key.
5871              if ( ! isObjectLike( dependant ) ) {
5872                  isUniqueByDependants = false;
5873                  break;
5874              }
5875  
5876              // Does current segment of cache already have a WeakMap?
5877              if ( caches.has( dependant ) ) {
5878                  // Traverse into nested WeakMap.
5879                  caches = caches.get( dependant );
5880              } else {
5881                  // Create, set, and traverse into a new one.
5882                  map = new WeakMap();
5883                  caches.set( dependant, map );
5884                  caches = map;
5885              }
5886          }
5887  
5888          // We use an arbitrary (but consistent) object as key for the last item
5889          // in the WeakMap to serve as our running cache.
5890          if ( ! caches.has( LEAF_KEY ) ) {
5891              cache = createCache();
5892              cache.isUniqueByDependants = isUniqueByDependants;
5893              caches.set( LEAF_KEY, cache );
5894          }
5895  
5896          return caches.get( LEAF_KEY );
5897      }
5898  
5899      // Assign cache handler by availability of WeakMap
5900      getCache = hasWeakMap ? getWeakMapCache : getRootCache;
5901  
5902      /**
5903       * Resets root memoization cache.
5904       */
5905  	function clear() {
5906          rootCache = hasWeakMap ? new WeakMap() : createCache();
5907      }
5908  
5909      // eslint-disable-next-line jsdoc/check-param-names
5910      /**
5911       * The augmented selector call, considering first whether dependants have
5912       * changed before passing it to underlying memoize function.
5913       *
5914       * @param {Object} source    Source object for derivation.
5915       * @param {...*}   extraArgs Additional arguments to pass to selector.
5916       *
5917       * @return {*} Selector result.
5918       */
5919  	function callSelector( /* source, ...extraArgs */ ) {
5920          var len = arguments.length,
5921              cache, node, i, args, dependants;
5922  
5923          // Create copy of arguments (avoid leaking deoptimization).
5924          args = new Array( len );
5925          for ( i = 0; i < len; i++ ) {
5926              args[ i ] = arguments[ i ];
5927          }
5928  
5929          dependants = getDependants.apply( null, args );
5930          cache = getCache( dependants );
5931  
5932          // If not guaranteed uniqueness by dependants (primitive type or lack
5933          // of WeakMap support), shallow compare against last dependants and, if
5934          // references have changed, destroy cache to recalculate result.
5935          if ( ! cache.isUniqueByDependants ) {
5936              if ( cache.lastDependants && ! isShallowEqual( dependants, cache.lastDependants, 0 ) ) {
5937                  cache.clear();
5938              }
5939  
5940              cache.lastDependants = dependants;
5941          }
5942  
5943          node = cache.head;
5944          while ( node ) {
5945              // Check whether node arguments match arguments
5946              if ( ! isShallowEqual( node.args, args, 1 ) ) {
5947                  node = node.next;
5948                  continue;
5949              }
5950  
5951              // At this point we can assume we've found a match
5952  
5953              // Surface matched node to head if not already
5954              if ( node !== cache.head ) {
5955                  // Adjust siblings to point to each other.
5956                  node.prev.next = node.next;
5957                  if ( node.next ) {
5958                      node.next.prev = node.prev;
5959                  }
5960  
5961                  node.next = cache.head;
5962                  node.prev = null;
5963                  cache.head.prev = node;
5964                  cache.head = node;
5965              }
5966  
5967              // Return immediately
5968              return node.val;
5969          }
5970  
5971          // No cached value found. Continue to insertion phase:
5972  
5973          node = {
5974              // Generate the result from original function
5975              val: selector.apply( null, args ),
5976          };
5977  
5978          // Avoid including the source object in the cache.
5979          args[ 0 ] = null;
5980          node.args = args;
5981  
5982          // Don't need to check whether node is already head, since it would
5983          // have been returned above already if it was
5984  
5985          // Shift existing head down list
5986          if ( cache.head ) {
5987              cache.head.prev = node;
5988              node.next = cache.head;
5989          }
5990  
5991          cache.head = node;
5992  
5993          return node.val;
5994      }
5995  
5996      callSelector.getDependants = getDependants;
5997      callSelector.clear = clear;
5998      clear();
5999  
6000      return callSelector;
6001  });
6002  
6003  
6004  /***/ }),
6005  
6006  /***/ 43:
6007  /***/ (function(module, exports) {
6008  
6009  (function() { module.exports = window["wp"]["blob"]; }());
6010  
6011  /***/ }),
6012  
6013  /***/ 44:
6014  /***/ (function(module, __webpack_exports__, __webpack_require__) {
6015  
6016  "use strict";
6017  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutPropertiesLoose; });
6018  function _objectWithoutPropertiesLoose(source, excluded) {
6019    if (source == null) return {};
6020    var target = {};
6021    var sourceKeys = Object.keys(source);
6022    var key, i;
6023  
6024    for (i = 0; i < sourceKeys.length; i++) {
6025      key = sourceKeys[i];
6026      if (excluded.indexOf(key) >= 0) continue;
6027      target[key] = source[key];
6028    }
6029  
6030    return target;
6031  }
6032  
6033  /***/ }),
6034  
6035  /***/ 448:
6036  /***/ (function(module, __webpack_exports__, __webpack_require__) {
6037  
6038  "use strict";
6039  // ESM COMPAT FLAG
6040  __webpack_require__.r(__webpack_exports__);
6041  
6042  // EXPORTS
6043  __webpack_require__.d(__webpack_exports__, "getColorClassName", function() { return /* reexport */ getColorClassName; });
6044  __webpack_require__.d(__webpack_exports__, "getColorObjectByAttributeValues", function() { return /* reexport */ utils_getColorObjectByAttributeValues; });
6045  __webpack_require__.d(__webpack_exports__, "getColorObjectByColorValue", function() { return /* reexport */ utils_getColorObjectByColorValue; });
6046  __webpack_require__.d(__webpack_exports__, "createCustomColorsHOC", function() { return /* reexport */ createCustomColorsHOC; });
6047  __webpack_require__.d(__webpack_exports__, "withColors", function() { return /* reexport */ withColors; });
6048  __webpack_require__.d(__webpack_exports__, "__experimentalUseColors", function() { return /* reexport */ __experimentalUseColors; });
6049  __webpack_require__.d(__webpack_exports__, "__experimentalGetGradientClass", function() { return /* reexport */ __experimentalGetGradientClass; });
6050  __webpack_require__.d(__webpack_exports__, "getGradientValueBySlug", function() { return /* reexport */ getGradientValueBySlug; });
6051  __webpack_require__.d(__webpack_exports__, "__experimentalGetGradientObjectByGradientValue", function() { return /* reexport */ __experimentalGetGradientObjectByGradientValue; });
6052  __webpack_require__.d(__webpack_exports__, "getGradientSlugByValue", function() { return /* reexport */ getGradientSlugByValue; });
6053  __webpack_require__.d(__webpack_exports__, "__experimentalUseGradient", function() { return /* reexport */ __experimentalUseGradient; });
6054  __webpack_require__.d(__webpack_exports__, "getFontSize", function() { return /* reexport */ utils_getFontSize; });
6055  __webpack_require__.d(__webpack_exports__, "getFontSizeClass", function() { return /* reexport */ getFontSizeClass; });
6056  __webpack_require__.d(__webpack_exports__, "getFontSizeObjectByValue", function() { return /* reexport */ getFontSizeObjectByValue; });
6057  __webpack_require__.d(__webpack_exports__, "FontSizePicker", function() { return /* reexport */ font_size_picker; });
6058  __webpack_require__.d(__webpack_exports__, "withFontSizes", function() { return /* reexport */ with_font_sizes; });
6059  __webpack_require__.d(__webpack_exports__, "AlignmentControl", function() { return /* reexport */ AlignmentControl; });
6060  __webpack_require__.d(__webpack_exports__, "AlignmentToolbar", function() { return /* reexport */ AlignmentToolbar; });
6061  __webpack_require__.d(__webpack_exports__, "Autocomplete", function() { return /* reexport */ autocomplete; });
6062  __webpack_require__.d(__webpack_exports__, "BlockAlignmentControl", function() { return /* reexport */ BlockAlignmentControl; });
6063  __webpack_require__.d(__webpack_exports__, "BlockAlignmentToolbar", function() { return /* reexport */ BlockAlignmentToolbar; });
6064  __webpack_require__.d(__webpack_exports__, "__experimentalBlockFullHeightAligmentControl", function() { return /* reexport */ block_full_height_alignment_control; });
6065  __webpack_require__.d(__webpack_exports__, "__experimentalBlockAlignmentMatrixControl", function() { return /* reexport */ block_alignment_matrix_control; });
6066  __webpack_require__.d(__webpack_exports__, "BlockBreadcrumb", function() { return /* reexport */ block_breadcrumb; });
6067  __webpack_require__.d(__webpack_exports__, "BlockContextProvider", function() { return /* reexport */ BlockContextProvider; });
6068  __webpack_require__.d(__webpack_exports__, "BlockControls", function() { return /* reexport */ block_controls; });
6069  __webpack_require__.d(__webpack_exports__, "BlockFormatControls", function() { return /* reexport */ block_controls_BlockFormatControls; });
6070  __webpack_require__.d(__webpack_exports__, "BlockColorsStyleSelector", function() { return /* reexport */ color_style_selector; });
6071  __webpack_require__.d(__webpack_exports__, "BlockEdit", function() { return /* reexport */ block_edit_BlockEdit; });
6072  __webpack_require__.d(__webpack_exports__, "useBlockEditContext", function() { return /* reexport */ useBlockEditContext; });
6073  __webpack_require__.d(__webpack_exports__, "BlockIcon", function() { return /* reexport */ BlockIcon; });
6074  __webpack_require__.d(__webpack_exports__, "BlockNavigationDropdown", function() { return /* reexport */ dropdown; });
6075  __webpack_require__.d(__webpack_exports__, "__experimentalBlockNavigationBlockFill", function() { return /* reexport */ block_slot_BlockNavigationBlockFill; });
6076  __webpack_require__.d(__webpack_exports__, "__experimentalBlockNavigationEditor", function() { return /* reexport */ BlockNavigationEditor; });
6077  __webpack_require__.d(__webpack_exports__, "__experimentalBlockNavigationTree", function() { return /* reexport */ BlockNavigationTree; });
6078  __webpack_require__.d(__webpack_exports__, "__experimentalBlockVariationPicker", function() { return /* reexport */ block_variation_picker; });
6079  __webpack_require__.d(__webpack_exports__, "__experimentalBlockVariationTransforms", function() { return /* reexport */ block_variation_transforms; });
6080  __webpack_require__.d(__webpack_exports__, "BlockVerticalAlignmentToolbar", function() { return /* reexport */ BlockVerticalAlignmentToolbar; });
6081  __webpack_require__.d(__webpack_exports__, "BlockVerticalAlignmentControl", function() { return /* reexport */ BlockVerticalAlignmentControl; });
6082  __webpack_require__.d(__webpack_exports__, "ButtonBlockerAppender", function() { return /* reexport */ button_block_appender; });
6083  __webpack_require__.d(__webpack_exports__, "ColorPalette", function() { return /* reexport */ color_palette; });
6084  __webpack_require__.d(__webpack_exports__, "ColorPaletteControl", function() { return /* reexport */ ColorPaletteControl; });
6085  __webpack_require__.d(__webpack_exports__, "ContrastChecker", function() { return /* reexport */ contrast_checker; });
6086  __webpack_require__.d(__webpack_exports__, "__experimentalGradientPicker", function() { return /* reexport */ gradient_picker; });
6087  __webpack_require__.d(__webpack_exports__, "__experimentalGradientPickerControl", function() { return /* reexport */ GradientPickerControl; });
6088  __webpack_require__.d(__webpack_exports__, "__experimentalGradientPickerPanel", function() { return /* reexport */ GradientPanel; });
6089  __webpack_require__.d(__webpack_exports__, "__experimentalFontAppearanceControl", function() { return /* reexport */ FontAppearanceControl; });
6090  __webpack_require__.d(__webpack_exports__, "__experimentalFontFamilyControl", function() { return /* reexport */ FontFamilyControl; });
6091  __webpack_require__.d(__webpack_exports__, "__experimentalColorGradientControl", function() { return /* reexport */ control; });
6092  __webpack_require__.d(__webpack_exports__, "__experimentalPanelColorGradientSettings", function() { return /* reexport */ panel_color_gradient_settings; });
6093  __webpack_require__.d(__webpack_exports__, "__experimentalImageSizeControl", function() { return /* reexport */ ImageSizeControl; });
6094  __webpack_require__.d(__webpack_exports__, "InnerBlocks", function() { return /* reexport */ inner_blocks; });
6095  __webpack_require__.d(__webpack_exports__, "__experimentalUseInnerBlocksProps", function() { return /* reexport */ useInnerBlocksProps; });
6096  __webpack_require__.d(__webpack_exports__, "InspectorAdvancedControls", function() { return /* reexport */ inspector_advanced_controls; });
6097  __webpack_require__.d(__webpack_exports__, "InspectorControls", function() { return /* reexport */ inspector_controls; });
6098  __webpack_require__.d(__webpack_exports__, "JustifyToolbar", function() { return /* reexport */ JustifyToolbar; });
6099  __webpack_require__.d(__webpack_exports__, "JustifyContentControl", function() { return /* reexport */ JustifyContentControl; });
6100  __webpack_require__.d(__webpack_exports__, "__experimentalLinkControl", function() { return /* reexport */ link_control; });
6101  __webpack_require__.d(__webpack_exports__, "__experimentalLinkControlSearchInput", function() { return /* reexport */ search_input; });
6102  __webpack_require__.d(__webpack_exports__, "__experimentalLinkControlSearchResults", function() { return /* reexport */ LinkControlSearchResults; });
6103  __webpack_require__.d(__webpack_exports__, "__experimentalLinkControlSearchItem", function() { return /* reexport */ search_item; });
6104  __webpack_require__.d(__webpack_exports__, "LineHeightControl", function() { return /* reexport */ LineHeightControl; });
6105  __webpack_require__.d(__webpack_exports__, "MediaReplaceFlow", function() { return /* reexport */ media_replace_flow; });
6106  __webpack_require__.d(__webpack_exports__, "MediaPlaceholder", function() { return /* reexport */ media_placeholder; });
6107  __webpack_require__.d(__webpack_exports__, "MediaUpload", function() { return /* reexport */ media_upload; });
6108  __webpack_require__.d(__webpack_exports__, "MediaUploadCheck", function() { return /* reexport */ check; });
6109  __webpack_require__.d(__webpack_exports__, "PanelColorSettings", function() { return /* reexport */ panel_color_settings; });
6110  __webpack_require__.d(__webpack_exports__, "PlainText", function() { return /* reexport */ plain_text; });
6111  __webpack_require__.d(__webpack_exports__, "__experimentalResponsiveBlockControl", function() { return /* reexport */ responsive_block_control; });
6112  __webpack_require__.d(__webpack_exports__, "RichText", function() { return /* reexport */ rich_text; });
6113  __webpack_require__.d(__webpack_exports__, "RichTextShortcut", function() { return /* reexport */ RichTextShortcut; });
6114  __webpack_require__.d(__webpack_exports__, "RichTextToolbarButton", function() { return /* reexport */ RichTextToolbarButton; });
6115  __webpack_require__.d(__webpack_exports__, "__unstableRichTextInputEvent", function() { return /* reexport */ input_event_unstableRichTextInputEvent; });
6116  __webpack_require__.d(__webpack_exports__, "ToolSelector", function() { return /* reexport */ tool_selector; });
6117  __webpack_require__.d(__webpack_exports__, "__experimentalUnitControl", function() { return /* reexport */ UnitControl; });
6118  __webpack_require__.d(__webpack_exports__, "URLInput", function() { return /* reexport */ url_input; });
6119  __webpack_require__.d(__webpack_exports__, "URLInputButton", function() { return /* reexport */ url_input_button; });
6120  __webpack_require__.d(__webpack_exports__, "URLPopover", function() { return /* reexport */ url_popover; });
6121  __webpack_require__.d(__webpack_exports__, "__experimentalImageURLInputUI", function() { return /* reexport */ image_url_input_ui_ImageURLInputUI; });
6122  __webpack_require__.d(__webpack_exports__, "withColorContext", function() { return /* reexport */ with_color_context; });
6123  __webpack_require__.d(__webpack_exports__, "__experimentalBlockSettingsMenuFirstItem", function() { return /* reexport */ block_settings_menu_first_item; });
6124  __webpack_require__.d(__webpack_exports__, "__experimentalInserterMenuExtension", function() { return /* reexport */ inserter_menu_extension; });
6125  __webpack_require__.d(__webpack_exports__, "__experimentalPreviewOptions", function() { return /* reexport */ PreviewOptions; });
6126  __webpack_require__.d(__webpack_exports__, "__experimentalUseResizeCanvas", function() { return /* reexport */ useResizeCanvas; });
6127  __webpack_require__.d(__webpack_exports__, "BlockInspector", function() { return /* reexport */ block_inspector; });
6128  __webpack_require__.d(__webpack_exports__, "BlockList", function() { return /* reexport */ BlockList; });
6129  __webpack_require__.d(__webpack_exports__, "useBlockProps", function() { return /* reexport */ useBlockProps; });
6130  __webpack_require__.d(__webpack_exports__, "__experimentalBlock", function() { return /* reexport */ block_wrapper_Block; });
6131  __webpack_require__.d(__webpack_exports__, "__experimentalLayoutStyle", function() { return /* reexport */ LayoutStyle; });
6132  __webpack_require__.d(__webpack_exports__, "BlockMover", function() { return /* reexport */ block_mover; });
6133  __webpack_require__.d(__webpack_exports__, "BlockPreview", function() { return /* reexport */ block_preview; });
6134  __webpack_require__.d(__webpack_exports__, "BlockSelectionClearer", function() { return /* reexport */ BlockSelectionClearer; });
6135  __webpack_require__.d(__webpack_exports__, "__unstableUseBlockSelectionClearer", function() { return /* reexport */ useBlockSelectionClearer; });
6136  __webpack_require__.d(__webpack_exports__, "BlockSettingsMenu", function() { return /* reexport */ block_settings_menu; });
6137  __webpack_require__.d(__webpack_exports__, "BlockSettingsMenuControls", function() { return /* reexport */ block_settings_menu_controls; });
6138  __webpack_require__.d(__webpack_exports__, "BlockTitle", function() { return /* reexport */ BlockTitle; });
6139  __webpack_require__.d(__webpack_exports__, "BlockToolbar", function() { return /* reexport */ BlockToolbar; });
6140  __webpack_require__.d(__webpack_exports__, "CopyHandler", function() { return /* reexport */ copy_handler; });
6141  __webpack_require__.d(__webpack_exports__, "__unstableUseClipboardHandler", function() { return /* reexport */ useClipboardHandler; });
6142  __webpack_require__.d(__webpack_exports__, "DefaultBlockAppender", function() { return /* reexport */ default_block_appender; });
6143  __webpack_require__.d(__webpack_exports__, "__unstableEditorStyles", function() { return /* reexport */ EditorStyles; });
6144  __webpack_require__.d(__webpack_exports__, "Inserter", function() { return /* reexport */ inserter; });
6145  __webpack_require__.d(__webpack_exports__, "__experimentalLibrary", function() { return /* reexport */ library; });
6146  __webpack_require__.d(__webpack_exports__, "__experimentalSearchForm", function() { return /* reexport */ search_form; });
6147  __webpack_require__.d(__webpack_exports__, "BlockEditorKeyboardShortcuts", function() { return /* reexport */ keyboard_shortcuts; });
6148  __webpack_require__.d(__webpack_exports__, "MultiSelectScrollIntoView", function() { return /* reexport */ MultiSelectScrollIntoView; });
6149  __webpack_require__.d(__webpack_exports__, "NavigableToolbar", function() { return /* reexport */ navigable_toolbar; });
6150  __webpack_require__.d(__webpack_exports__, "ObserveTyping", function() { return /* reexport */ observe_typing; });
6151  __webpack_require__.d(__webpack_exports__, "__unstableUseTypingObserver", function() { return /* reexport */ useTypingObserver; });
6152  __webpack_require__.d(__webpack_exports__, "__unstableUseMouseMoveTypingReset", function() { return /* reexport */ useMouseMoveTypingReset; });
6153  __webpack_require__.d(__webpack_exports__, "PreserveScrollInReorder", function() { return /* reexport */ PreserveScrollInReorder; });
6154  __webpack_require__.d(__webpack_exports__, "SkipToSelectedBlock", function() { return /* reexport */ skip_to_selected_block; });
6155  __webpack_require__.d(__webpack_exports__, "Typewriter", function() { return /* reexport */ typewriter; });
6156  __webpack_require__.d(__webpack_exports__, "__unstableUseTypewriter", function() { return /* reexport */ useTypewriter; });
6157  __webpack_require__.d(__webpack_exports__, "Warning", function() { return /* reexport */ warning; });
6158  __webpack_require__.d(__webpack_exports__, "WritingFlow", function() { return /* reexport */ WritingFlow; });
6159  __webpack_require__.d(__webpack_exports__, "__unstableUseCanvasClickRedirect", function() { return /* reexport */ useCanvasClickRedirect; });
6160  __webpack_require__.d(__webpack_exports__, "useBlockDisplayInformation", function() { return /* reexport */ useBlockDisplayInformation; });
6161  __webpack_require__.d(__webpack_exports__, "__unstableIframe", function() { return /* reexport */ iframe; });
6162  __webpack_require__.d(__webpack_exports__, "__experimentalUseNoRecursiveRenders", function() { return /* reexport */ useNoRecursiveRenders; });
6163  __webpack_require__.d(__webpack_exports__, "BlockEditorProvider", function() { return /* reexport */ provider; });
6164  __webpack_require__.d(__webpack_exports__, "__experimentalUseSimulatedMediaQuery", function() { return /* reexport */ useSimulatedMediaQuery; });
6165  __webpack_require__.d(__webpack_exports__, "__experimentalUseEditorFeature", function() { return /* reexport */ useEditorFeature; });
6166  __webpack_require__.d(__webpack_exports__, "transformStyles", function() { return /* reexport */ transform_styles; });
6167  __webpack_require__.d(__webpack_exports__, "validateThemeColors", function() { return /* reexport */ validateThemeColors; });
6168  __webpack_require__.d(__webpack_exports__, "validateThemeGradients", function() { return /* reexport */ validateThemeGradients; });
6169  __webpack_require__.d(__webpack_exports__, "__experimentalGetMatchingVariation", function() { return /* reexport */ block_variation_transforms_experimentalGetMatchingVariation; });
6170  __webpack_require__.d(__webpack_exports__, "storeConfig", function() { return /* reexport */ storeConfig; });
6171  __webpack_require__.d(__webpack_exports__, "store", function() { return /* reexport */ store; });
6172  __webpack_require__.d(__webpack_exports__, "SETTINGS_DEFAULTS", function() { return /* reexport */ SETTINGS_DEFAULTS; });
6173  
6174  // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/selectors.js
6175  var selectors_namespaceObject = {};
6176  __webpack_require__.r(selectors_namespaceObject);
6177  __webpack_require__.d(selectors_namespaceObject, "getBlockName", function() { return selectors_getBlockName; });
6178  __webpack_require__.d(selectors_namespaceObject, "isBlockValid", function() { return selectors_isBlockValid; });
6179  __webpack_require__.d(selectors_namespaceObject, "getBlockAttributes", function() { return selectors_getBlockAttributes; });
6180  __webpack_require__.d(selectors_namespaceObject, "getBlock", function() { return selectors_getBlock; });
6181  __webpack_require__.d(selectors_namespaceObject, "__unstableGetBlockWithoutInnerBlocks", function() { return selectors_unstableGetBlockWithoutInnerBlocks; });
6182  __webpack_require__.d(selectors_namespaceObject, "getBlocks", function() { return selectors_getBlocks; });
6183  __webpack_require__.d(selectors_namespaceObject, "__unstableGetBlockWithBlockTree", function() { return __unstableGetBlockWithBlockTree; });
6184  __webpack_require__.d(selectors_namespaceObject, "__unstableGetBlockTree", function() { return __unstableGetBlockTree; });
6185  __webpack_require__.d(selectors_namespaceObject, "__unstableGetClientIdWithClientIdsTree", function() { return selectors_unstableGetClientIdWithClientIdsTree; });
6186  __webpack_require__.d(selectors_namespaceObject, "__unstableGetClientIdsTree", function() { return selectors_unstableGetClientIdsTree; });
6187  __webpack_require__.d(selectors_namespaceObject, "getClientIdsOfDescendants", function() { return selectors_getClientIdsOfDescendants; });
6188  __webpack_require__.d(selectors_namespaceObject, "getClientIdsWithDescendants", function() { return getClientIdsWithDescendants; });
6189  __webpack_require__.d(selectors_namespaceObject, "getGlobalBlockCount", function() { return selectors_getGlobalBlockCount; });
6190  __webpack_require__.d(selectors_namespaceObject, "getBlocksByClientId", function() { return selectors_getBlocksByClientId; });
6191  __webpack_require__.d(selectors_namespaceObject, "getBlockCount", function() { return selectors_getBlockCount; });
6192  __webpack_require__.d(selectors_namespaceObject, "getSelectionStart", function() { return selectors_getSelectionStart; });
6193  __webpack_require__.d(selectors_namespaceObject, "getSelectionEnd", function() { return selectors_getSelectionEnd; });
6194  __webpack_require__.d(selectors_namespaceObject, "getBlockSelectionStart", function() { return selectors_getBlockSelectionStart; });
6195  __webpack_require__.d(selectors_namespaceObject, "getBlockSelectionEnd", function() { return selectors_getBlockSelectionEnd; });
6196  __webpack_require__.d(selectors_namespaceObject, "getSelectedBlockCount", function() { return selectors_getSelectedBlockCount; });
6197  __webpack_require__.d(selectors_namespaceObject, "hasSelectedBlock", function() { return selectors_hasSelectedBlock; });
6198  __webpack_require__.d(selectors_namespaceObject, "getSelectedBlockClientId", function() { return selectors_getSelectedBlockClientId; });
6199  __webpack_require__.d(selectors_namespaceObject, "getSelectedBlock", function() { return selectors_getSelectedBlock; });
6200  __webpack_require__.d(selectors_namespaceObject, "getBlockRootClientId", function() { return selectors_getBlockRootClientId; });
6201  __webpack_require__.d(selectors_namespaceObject, "getBlockParents", function() { return selectors_getBlockParents; });
6202  __webpack_require__.d(selectors_namespaceObject, "getBlockParentsByBlockName", function() { return getBlockParentsByBlockName; });
6203  __webpack_require__.d(selectors_namespaceObject, "getBlockHierarchyRootClientId", function() { return selectors_getBlockHierarchyRootClientId; });
6204  __webpack_require__.d(selectors_namespaceObject, "getLowestCommonAncestorWithSelectedBlock", function() { return getLowestCommonAncestorWithSelectedBlock; });
6205  __webpack_require__.d(selectors_namespaceObject, "getAdjacentBlockClientId", function() { return getAdjacentBlockClientId; });
6206  __webpack_require__.d(selectors_namespaceObject, "getPreviousBlockClientId", function() { return selectors_getPreviousBlockClientId; });
6207  __webpack_require__.d(selectors_namespaceObject, "getNextBlockClientId", function() { return selectors_getNextBlockClientId; });
6208  __webpack_require__.d(selectors_namespaceObject, "getSelectedBlocksInitialCaretPosition", function() { return selectors_getSelectedBlocksInitialCaretPosition; });
6209  __webpack_require__.d(selectors_namespaceObject, "getSelectedBlockClientIds", function() { return selectors_getSelectedBlockClientIds; });
6210  __webpack_require__.d(selectors_namespaceObject, "getMultiSelectedBlockClientIds", function() { return selectors_getMultiSelectedBlockClientIds; });
6211  __webpack_require__.d(selectors_namespaceObject, "getMultiSelectedBlocks", function() { return selectors_getMultiSelectedBlocks; });
6212  __webpack_require__.d(selectors_namespaceObject, "getFirstMultiSelectedBlockClientId", function() { return selectors_getFirstMultiSelectedBlockClientId; });
6213  __webpack_require__.d(selectors_namespaceObject, "getLastMultiSelectedBlockClientId", function() { return selectors_getLastMultiSelectedBlockClientId; });
6214  __webpack_require__.d(selectors_namespaceObject, "isFirstMultiSelectedBlock", function() { return selectors_isFirstMultiSelectedBlock; });
6215  __webpack_require__.d(selectors_namespaceObject, "isBlockMultiSelected", function() { return selectors_isBlockMultiSelected; });
6216  __webpack_require__.d(selectors_namespaceObject, "isAncestorMultiSelected", function() { return selectors_isAncestorMultiSelected; });
6217  __webpack_require__.d(selectors_namespaceObject, "getMultiSelectedBlocksStartClientId", function() { return selectors_getMultiSelectedBlocksStartClientId; });
6218  __webpack_require__.d(selectors_namespaceObject, "getMultiSelectedBlocksEndClientId", function() { return selectors_getMultiSelectedBlocksEndClientId; });
6219  __webpack_require__.d(selectors_namespaceObject, "getBlockOrder", function() { return selectors_getBlockOrder; });
6220  __webpack_require__.d(selectors_namespaceObject, "getBlockIndex", function() { return selectors_getBlockIndex; });
6221  __webpack_require__.d(selectors_namespaceObject, "isBlockSelected", function() { return selectors_isBlockSelected; });
6222  __webpack_require__.d(selectors_namespaceObject, "hasSelectedInnerBlock", function() { return selectors_hasSelectedInnerBlock; });
6223  __webpack_require__.d(selectors_namespaceObject, "isBlockWithinSelection", function() { return isBlockWithinSelection; });
6224  __webpack_require__.d(selectors_namespaceObject, "hasMultiSelection", function() { return selectors_hasMultiSelection; });
6225  __webpack_require__.d(selectors_namespaceObject, "isMultiSelecting", function() { return selectors_isMultiSelecting; });
6226  __webpack_require__.d(selectors_namespaceObject, "isSelectionEnabled", function() { return selectors_isSelectionEnabled; });
6227  __webpack_require__.d(selectors_namespaceObject, "getBlockMode", function() { return selectors_getBlockMode; });
6228  __webpack_require__.d(selectors_namespaceObject, "isTyping", function() { return selectors_isTyping; });
6229  __webpack_require__.d(selectors_namespaceObject, "isDraggingBlocks", function() { return isDraggingBlocks; });
6230  __webpack_require__.d(selectors_namespaceObject, "getDraggedBlockClientIds", function() { return selectors_getDraggedBlockClientIds; });
6231  __webpack_require__.d(selectors_namespaceObject, "isBlockBeingDragged", function() { return selectors_isBlockBeingDragged; });
6232  __webpack_require__.d(selectors_namespaceObject, "isAncestorBeingDragged", function() { return selectors_isAncestorBeingDragged; });
6233  __webpack_require__.d(selectors_namespaceObject, "isCaretWithinFormattedText", function() { return selectors_isCaretWithinFormattedText; });
6234  __webpack_require__.d(selectors_namespaceObject, "getBlockInsertionPoint", function() { return selectors_getBlockInsertionPoint; });
6235  __webpack_require__.d(selectors_namespaceObject, "isBlockInsertionPointVisible", function() { return selectors_isBlockInsertionPointVisible; });
6236  __webpack_require__.d(selectors_namespaceObject, "isValidTemplate", function() { return selectors_isValidTemplate; });
6237  __webpack_require__.d(selectors_namespaceObject, "getTemplate", function() { return getTemplate; });
6238  __webpack_require__.d(selectors_namespaceObject, "getTemplateLock", function() { return selectors_getTemplateLock; });
6239  __webpack_require__.d(selectors_namespaceObject, "canInsertBlockType", function() { return selectors_canInsertBlockType; });
6240  __webpack_require__.d(selectors_namespaceObject, "canInsertBlocks", function() { return selectors_canInsertBlocks; });
6241  __webpack_require__.d(selectors_namespaceObject, "getInserterItems", function() { return selectors_getInserterItems; });
6242  __webpack_require__.d(selectors_namespaceObject, "getBlockTransformItems", function() { return selectors_getBlockTransformItems; });
6243  __webpack_require__.d(selectors_namespaceObject, "hasInserterItems", function() { return selectors_hasInserterItems; });
6244  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetAllowedBlocks", function() { return selectors_experimentalGetAllowedBlocks; });
6245  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetParsedPattern", function() { return __experimentalGetParsedPattern; });
6246  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetAllowedPatterns", function() { return selectors_experimentalGetAllowedPatterns; });
6247  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetPatternsByBlockTypes", function() { return __experimentalGetPatternsByBlockTypes; });
6248  __webpack_require__.d(selectors_namespaceObject, "getBlockListSettings", function() { return selectors_getBlockListSettings; });
6249  __webpack_require__.d(selectors_namespaceObject, "getSettings", function() { return selectors_getSettings; });
6250  __webpack_require__.d(selectors_namespaceObject, "isLastBlockChangePersistent", function() { return selectors_isLastBlockChangePersistent; });
6251  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetBlockListSettingsForBlocks", function() { return selectors_experimentalGetBlockListSettingsForBlocks; });
6252  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetParsedReusableBlock", function() { return __experimentalGetParsedReusableBlock; });
6253  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetReusableBlockTitle", function() { return selectors_experimentalGetReusableBlockTitle; });
6254  __webpack_require__.d(selectors_namespaceObject, "__unstableIsLastBlockChangeIgnored", function() { return selectors_unstableIsLastBlockChangeIgnored; });
6255  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetLastBlockAttributeChanges", function() { return __experimentalGetLastBlockAttributeChanges; });
6256  __webpack_require__.d(selectors_namespaceObject, "isNavigationMode", function() { return selectors_isNavigationMode; });
6257  __webpack_require__.d(selectors_namespaceObject, "hasBlockMovingClientId", function() { return selectors_hasBlockMovingClientId; });
6258  __webpack_require__.d(selectors_namespaceObject, "didAutomaticChange", function() { return selectors_didAutomaticChange; });
6259  __webpack_require__.d(selectors_namespaceObject, "isBlockHighlighted", function() { return selectors_isBlockHighlighted; });
6260  __webpack_require__.d(selectors_namespaceObject, "areInnerBlocksControlled", function() { return areInnerBlocksControlled; });
6261  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetActiveBlockIdByBlockNames", function() { return __experimentalGetActiveBlockIdByBlockNames; });
6262  
6263  // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/actions.js
6264  var actions_namespaceObject = {};
6265  __webpack_require__.r(actions_namespaceObject);
6266  __webpack_require__.d(actions_namespaceObject, "resetBlocks", function() { return actions_resetBlocks; });
6267  __webpack_require__.d(actions_namespaceObject, "validateBlocksToTemplate", function() { return validateBlocksToTemplate; });
6268  __webpack_require__.d(actions_namespaceObject, "resetSelection", function() { return actions_resetSelection; });
6269  __webpack_require__.d(actions_namespaceObject, "receiveBlocks", function() { return receiveBlocks; });
6270  __webpack_require__.d(actions_namespaceObject, "updateBlockAttributes", function() { return actions_updateBlockAttributes; });
6271  __webpack_require__.d(actions_namespaceObject, "updateBlock", function() { return actions_updateBlock; });
6272  __webpack_require__.d(actions_namespaceObject, "selectBlock", function() { return actions_selectBlock; });
6273  __webpack_require__.d(actions_namespaceObject, "selectPreviousBlock", function() { return selectPreviousBlock; });
6274  __webpack_require__.d(actions_namespaceObject, "selectNextBlock", function() { return selectNextBlock; });
6275  __webpack_require__.d(actions_namespaceObject, "startMultiSelect", function() { return actions_startMultiSelect; });
6276  __webpack_require__.d(actions_namespaceObject, "stopMultiSelect", function() { return actions_stopMultiSelect; });
6277  __webpack_require__.d(actions_namespaceObject, "multiSelect", function() { return actions_multiSelect; });
6278  __webpack_require__.d(actions_namespaceObject, "clearSelectedBlock", function() { return actions_clearSelectedBlock; });
6279  __webpack_require__.d(actions_namespaceObject, "toggleSelection", function() { return actions_toggleSelection; });
6280  __webpack_require__.d(actions_namespaceObject, "replaceBlocks", function() { return actions_replaceBlocks; });
6281  __webpack_require__.d(actions_namespaceObject, "replaceBlock", function() { return actions_replaceBlock; });
6282  __webpack_require__.d(actions_namespaceObject, "moveBlocksDown", function() { return actions_moveBlocksDown; });
6283  __webpack_require__.d(actions_namespaceObject, "moveBlocksUp", function() { return actions_moveBlocksUp; });
6284  __webpack_require__.d(actions_namespaceObject, "moveBlocksToPosition", function() { return actions_moveBlocksToPosition; });
6285  __webpack_require__.d(actions_namespaceObject, "moveBlockToPosition", function() { return actions_moveBlockToPosition; });
6286  __webpack_require__.d(actions_namespaceObject, "insertBlock", function() { return actions_insertBlock; });
6287  __webpack_require__.d(actions_namespaceObject, "insertBlocks", function() { return actions_insertBlocks; });
6288  __webpack_require__.d(actions_namespaceObject, "__unstableSetInsertionPoint", function() { return actions_unstableSetInsertionPoint; });
6289  __webpack_require__.d(actions_namespaceObject, "showInsertionPoint", function() { return actions_showInsertionPoint; });
6290  __webpack_require__.d(actions_namespaceObject, "hideInsertionPoint", function() { return actions_hideInsertionPoint; });
6291  __webpack_require__.d(actions_namespaceObject, "setTemplateValidity", function() { return setTemplateValidity; });
6292  __webpack_require__.d(actions_namespaceObject, "synchronizeTemplate", function() { return synchronizeTemplate; });
6293  __webpack_require__.d(actions_namespaceObject, "mergeBlocks", function() { return actions_mergeBlocks; });
6294  __webpack_require__.d(actions_namespaceObject, "removeBlocks", function() { return actions_removeBlocks; });
6295  __webpack_require__.d(actions_namespaceObject, "removeBlock", function() { return actions_removeBlock; });
6296  __webpack_require__.d(actions_namespaceObject, "replaceInnerBlocks", function() { return actions_replaceInnerBlocks; });
6297  __webpack_require__.d(actions_namespaceObject, "toggleBlockMode", function() { return toggleBlockMode; });
6298  __webpack_require__.d(actions_namespaceObject, "startTyping", function() { return actions_startTyping; });
6299  __webpack_require__.d(actions_namespaceObject, "stopTyping", function() { return actions_stopTyping; });
6300  __webpack_require__.d(actions_namespaceObject, "startDraggingBlocks", function() { return actions_startDraggingBlocks; });
6301  __webpack_require__.d(actions_namespaceObject, "stopDraggingBlocks", function() { return actions_stopDraggingBlocks; });
6302  __webpack_require__.d(actions_namespaceObject, "enterFormattedText", function() { return actions_enterFormattedText; });
6303  __webpack_require__.d(actions_namespaceObject, "exitFormattedText", function() { return actions_exitFormattedText; });
6304  __webpack_require__.d(actions_namespaceObject, "selectionChange", function() { return actions_selectionChange; });
6305  __webpack_require__.d(actions_namespaceObject, "insertDefaultBlock", function() { return actions_insertDefaultBlock; });
6306  __webpack_require__.d(actions_namespaceObject, "updateBlockListSettings", function() { return actions_updateBlockListSettings; });
6307  __webpack_require__.d(actions_namespaceObject, "updateSettings", function() { return actions_updateSettings; });
6308  __webpack_require__.d(actions_namespaceObject, "__unstableSaveReusableBlock", function() { return __unstableSaveReusableBlock; });
6309  __webpack_require__.d(actions_namespaceObject, "__unstableMarkLastChangeAsPersistent", function() { return actions_unstableMarkLastChangeAsPersistent; });
6310  __webpack_require__.d(actions_namespaceObject, "__unstableMarkNextChangeAsNotPersistent", function() { return actions_unstableMarkNextChangeAsNotPersistent; });
6311  __webpack_require__.d(actions_namespaceObject, "__unstableMarkAutomaticChange", function() { return actions_unstableMarkAutomaticChange; });
6312  __webpack_require__.d(actions_namespaceObject, "__unstableMarkAutomaticChangeFinal", function() { return __unstableMarkAutomaticChangeFinal; });
6313  __webpack_require__.d(actions_namespaceObject, "setNavigationMode", function() { return actions_setNavigationMode; });
6314  __webpack_require__.d(actions_namespaceObject, "setBlockMovingClientId", function() { return actions_setBlockMovingClientId; });
6315  __webpack_require__.d(actions_namespaceObject, "duplicateBlocks", function() { return actions_duplicateBlocks; });
6316  __webpack_require__.d(actions_namespaceObject, "insertBeforeBlock", function() { return actions_insertBeforeBlock; });
6317  __webpack_require__.d(actions_namespaceObject, "insertAfterBlock", function() { return actions_insertAfterBlock; });
6318  __webpack_require__.d(actions_namespaceObject, "toggleBlockHighlight", function() { return actions_toggleBlockHighlight; });
6319  __webpack_require__.d(actions_namespaceObject, "flashBlock", function() { return actions_flashBlock; });
6320  __webpack_require__.d(actions_namespaceObject, "setHasControlledInnerBlocks", function() { return actions_setHasControlledInnerBlocks; });
6321  
6322  // EXTERNAL MODULE: external ["wp","richText"]
6323  var external_wp_richText_ = __webpack_require__(19);
6324  
6325  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
6326  var esm_extends = __webpack_require__(8);
6327  
6328  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
6329  var defineProperty = __webpack_require__(5);
6330  
6331  // EXTERNAL MODULE: external ["wp","element"]
6332  var external_wp_element_ = __webpack_require__(0);
6333  
6334  // EXTERNAL MODULE: ./node_modules/classnames/index.js
6335  var classnames = __webpack_require__(10);
6336  var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
6337  
6338  // EXTERNAL MODULE: external "lodash"
6339  var external_lodash_ = __webpack_require__(2);
6340  
6341  // EXTERNAL MODULE: external ["wp","compose"]
6342  var external_wp_compose_ = __webpack_require__(11);
6343  
6344  // EXTERNAL MODULE: external ["wp","hooks"]
6345  var external_wp_hooks_ = __webpack_require__(33);
6346  
6347  // EXTERNAL MODULE: external ["wp","blocks"]
6348  var external_wp_blocks_ = __webpack_require__(9);
6349  
6350  // EXTERNAL MODULE: external ["wp","components"]
6351  var external_wp_components_ = __webpack_require__(3);
6352  
6353  // EXTERNAL MODULE: external ["wp","data"]
6354  var external_wp_data_ = __webpack_require__(4);
6355  
6356  // CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-edit/context.js
6357  /**
6358   * WordPress dependencies
6359   */
6360  
6361  var Context = Object(external_wp_element_["createContext"])({
6362    name: '',
6363    isSelected: false,
6364    clientId: null
6365  });
6366  var context_Provider = Context.Provider;
6367  
6368  /**
6369   * A hook that returns the block edit context.
6370   *
6371   * @return {Object} Block edit context
6372   */
6373  
6374  function useBlockEditContext() {
6375    return Object(external_wp_element_["useContext"])(Context);
6376  }
6377  
6378  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
6379  var objectWithoutProperties = __webpack_require__(13);
6380  
6381  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
6382  var toConsumableArray = __webpack_require__(15);
6383  
6384  // EXTERNAL MODULE: external ["wp","i18n"]
6385  var external_wp_i18n_ = __webpack_require__(1);
6386  
6387  // CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/defaults.js
6388  /**
6389   * WordPress dependencies
6390   */
6391  
6392  var PREFERENCES_DEFAULTS = {
6393    insertUsage: {}
6394  };
6395  /**
6396   * The default editor settings
6397   *
6398   * @typedef {Object} SETTINGS_DEFAULT
6399   * @property {boolean} alignWide Enable/Disable Wide/Full Alignments
6400   * @property {boolean} supportsLayout Enable/disable layouts support in container blocks.
6401   * @property {boolean} imageEditing Image Editing settings set to false to disable.
6402   * @property {Array} imageSizes Available image sizes
6403   * @property {number} maxWidth Max width to constraint resizing
6404   * @property {boolean|Array} allowedBlockTypes Allowed block types
6405   * @property {boolean} hasFixedToolbar Whether or not the editor toolbar is fixed
6406   * @property {boolean} focusMode Whether the focus mode is enabled or not
6407   * @property {Array} styles Editor Styles
6408   * @property {boolean} keepCaretInsideBlock Whether caret should move between blocks in edit mode
6409   * @property {string} bodyPlaceholder Empty post placeholder
6410   * @property {string} titlePlaceholder Empty title placeholder
6411   * @property {boolean} codeEditingEnabled Whether or not the user can switch to the code editor
6412   * @property {boolean} __experimentalCanUserUseUnfilteredHTML Whether the user should be able to use unfiltered HTML or the HTML should be filtered e.g., to remove elements considered insecure like iframes.
6413   * @property {boolean} __experimentalBlockDirectory Whether the user has enabled the Block Directory
6414   * @property {Array} __experimentalBlockPatterns Array of objects representing the block patterns
6415   * @property {Array} __experimentalBlockPatternCategories Array of objects representing the block pattern categories
6416   */
6417  
6418  var SETTINGS_DEFAULTS = {
6419    alignWide: false,
6420    supportsLayout: true,
6421    // colors setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults.
6422    // The setting is only kept for backward compatibility purposes.
6423    colors: [{
6424      name: Object(external_wp_i18n_["__"])('Black'),
6425      slug: 'black',
6426      color: '#000000'
6427    }, {
6428      name: Object(external_wp_i18n_["__"])('Cyan bluish gray'),
6429      slug: 'cyan-bluish-gray',
6430      color: '#abb8c3'
6431    }, {
6432      name: Object(external_wp_i18n_["__"])('White'),
6433      slug: 'white',
6434      color: '#ffffff'
6435    }, {
6436      name: Object(external_wp_i18n_["__"])('Pale pink'),
6437      slug: 'pale-pink',
6438      color: '#f78da7'
6439    }, {
6440      name: Object(external_wp_i18n_["__"])('Vivid red'),
6441      slug: 'vivid-red',
6442      color: '#cf2e2e'
6443    }, {
6444      name: Object(external_wp_i18n_["__"])('Luminous vivid orange'),
6445      slug: 'luminous-vivid-orange',
6446      color: '#ff6900'
6447    }, {
6448      name: Object(external_wp_i18n_["__"])('Luminous vivid amber'),
6449      slug: 'luminous-vivid-amber',
6450      color: '#fcb900'
6451    }, {
6452      name: Object(external_wp_i18n_["__"])('Light green cyan'),
6453      slug: 'light-green-cyan',
6454      color: '#7bdcb5'
6455    }, {
6456      name: Object(external_wp_i18n_["__"])('Vivid green cyan'),
6457      slug: 'vivid-green-cyan',
6458      color: '#00d084'
6459    }, {
6460      name: Object(external_wp_i18n_["__"])('Pale cyan blue'),
6461      slug: 'pale-cyan-blue',
6462      color: '#8ed1fc'
6463    }, {
6464      name: Object(external_wp_i18n_["__"])('Vivid cyan blue'),
6465      slug: 'vivid-cyan-blue',
6466      color: '#0693e3'
6467    }, {
6468      name: Object(external_wp_i18n_["__"])('Vivid purple'),
6469      slug: 'vivid-purple',
6470      color: '#9b51e0'
6471    }],
6472    // fontSizes setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults.
6473    // The setting is only kept for backward compatibility purposes.
6474    fontSizes: [{
6475      name: Object(external_wp_i18n_["_x"])('Small', 'font size name'),
6476      size: 13,
6477      slug: 'small'
6478    }, {
6479      name: Object(external_wp_i18n_["_x"])('Normal', 'font size name'),
6480      size: 16,
6481      slug: 'normal'
6482    }, {
6483      name: Object(external_wp_i18n_["_x"])('Medium', 'font size name'),
6484      size: 20,
6485      slug: 'medium'
6486    }, {
6487      name: Object(external_wp_i18n_["_x"])('Large', 'font size name'),
6488      size: 36,
6489      slug: 'large'
6490    }, {
6491      name: Object(external_wp_i18n_["_x"])('Huge', 'font size name'),
6492      size: 42,
6493      slug: 'huge'
6494    }],
6495    // Image default size slug.
6496    imageDefaultSize: 'large',
6497    imageSizes: [{
6498      slug: 'thumbnail',
6499      name: Object(external_wp_i18n_["__"])('Thumbnail')
6500    }, {
6501      slug: 'medium',
6502      name: Object(external_wp_i18n_["__"])('Medium')
6503    }, {
6504      slug: 'large',
6505      name: Object(external_wp_i18n_["__"])('Large')
6506    }, {
6507      slug: 'full',
6508      name: Object(external_wp_i18n_["__"])('Full Size')
6509    }],
6510    // Allow plugin to disable Image Editor if need be
6511    imageEditing: true,
6512    // This is current max width of the block inner area
6513    // It's used to constraint image resizing and this value could be overridden later by themes
6514    maxWidth: 580,
6515    // Allowed block types for the editor, defaulting to true (all supported).
6516    allowedBlockTypes: true,
6517    // Maximum upload size in bytes allowed for the site.
6518    maxUploadFileSize: 0,
6519    // List of allowed mime types and file extensions.
6520    allowedMimeTypes: null,
6521    __experimentalCanUserUseUnfilteredHTML: false,
6522    __experimentalBlockDirectory: false,
6523    __mobileEnablePageTemplates: false,
6524    __experimentalBlockPatterns: [],
6525    __experimentalBlockPatternCategories: [],
6526    __experimentalSpotlightEntityBlocks: [],
6527    // gradients setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults.
6528    // The setting is only kept for backward compatibility purposes.
6529    gradients: [{
6530      name: Object(external_wp_i18n_["__"])('Vivid cyan blue to vivid purple'),
6531      gradient: 'linear-gradient(135deg,rgba(6,147,227,1) 0%,rgb(155,81,224) 100%)',
6532      slug: 'vivid-cyan-blue-to-vivid-purple'
6533    }, {
6534      name: Object(external_wp_i18n_["__"])('Light green cyan to vivid green cyan'),
6535      gradient: 'linear-gradient(135deg,rgb(122,220,180) 0%,rgb(0,208,130) 100%)',
6536      slug: 'light-green-cyan-to-vivid-green-cyan'
6537    }, {
6538      name: Object(external_wp_i18n_["__"])('Luminous vivid amber to luminous vivid orange'),
6539      gradient: 'linear-gradient(135deg,rgba(252,185,0,1) 0%,rgba(255,105,0,1) 100%)',
6540      slug: 'luminous-vivid-amber-to-luminous-vivid-orange'
6541    }, {
6542      name: Object(external_wp_i18n_["__"])('Luminous vivid orange to vivid red'),
6543      gradient: 'linear-gradient(135deg,rgba(255,105,0,1) 0%,rgb(207,46,46) 100%)',
6544      slug: 'luminous-vivid-orange-to-vivid-red'
6545    }, {
6546      name: Object(external_wp_i18n_["__"])('Very light gray to cyan bluish gray'),
6547      gradient: 'linear-gradient(135deg,rgb(238,238,238) 0%,rgb(169,184,195) 100%)',
6548      slug: 'very-light-gray-to-cyan-bluish-gray'
6549    }, {
6550      name: Object(external_wp_i18n_["__"])('Cool to warm spectrum'),
6551      gradient: 'linear-gradient(135deg,rgb(74,234,220) 0%,rgb(151,120,209) 20%,rgb(207,42,186) 40%,rgb(238,44,130) 60%,rgb(251,105,98) 80%,rgb(254,248,76) 100%)',
6552      slug: 'cool-to-warm-spectrum'
6553    }, {
6554      name: Object(external_wp_i18n_["__"])('Blush light purple'),
6555      gradient: 'linear-gradient(135deg,rgb(255,206,236) 0%,rgb(152,150,240) 100%)',
6556      slug: 'blush-light-purple'
6557    }, {
6558      name: Object(external_wp_i18n_["__"])('Blush bordeaux'),
6559      gradient: 'linear-gradient(135deg,rgb(254,205,165) 0%,rgb(254,45,45) 50%,rgb(107,0,62) 100%)',
6560      slug: 'blush-bordeaux'
6561    }, {
6562      name: Object(external_wp_i18n_["__"])('Luminous dusk'),
6563      gradient: 'linear-gradient(135deg,rgb(255,203,112) 0%,rgb(199,81,192) 50%,rgb(65,88,208) 100%)',
6564      slug: 'luminous-dusk'
6565    }, {
6566      name: Object(external_wp_i18n_["__"])('Pale ocean'),
6567      gradient: 'linear-gradient(135deg,rgb(255,245,203) 0%,rgb(182,227,212) 50%,rgb(51,167,181) 100%)',
6568      slug: 'pale-ocean'
6569    }, {
6570      name: Object(external_wp_i18n_["__"])('Electric grass'),
6571      gradient: 'linear-gradient(135deg,rgb(202,248,128) 0%,rgb(113,206,126) 100%)',
6572      slug: 'electric-grass'
6573    }, {
6574      name: Object(external_wp_i18n_["__"])('Midnight'),
6575      gradient: 'linear-gradient(135deg,rgb(2,3,129) 0%,rgb(40,116,252) 100%)',
6576      slug: 'midnight'
6577    }]
6578  };
6579  
6580  // CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/array.js
6581  
6582  
6583  /**
6584   * External dependencies
6585   */
6586  
6587  /**
6588   * Insert one or multiple elements into a given position of an array.
6589   *
6590   * @param {Array}  array    Source array.
6591   * @param {*}      elements Elements to insert.
6592   * @param {number} index    Insert Position.
6593   *
6594   * @return {Array}          Result.
6595   */
6596  
6597  function insertAt(array, elements, index) {
6598    return [].concat(Object(toConsumableArray["a" /* default */])(array.slice(0, index)), Object(toConsumableArray["a" /* default */])(Object(external_lodash_["castArray"])(elements)), Object(toConsumableArray["a" /* default */])(array.slice(index)));
6599  }
6600  /**
6601   * Moves an element in an array.
6602   *
6603   * @param {Array}  array Source array.
6604   * @param {number} from  Source index.
6605   * @param {number} to    Destination index.
6606   * @param {number} count Number of elements to move.
6607   *
6608   * @return {Array}       Result.
6609   */
6610  
6611  function moveTo(array, from, to) {
6612    var count = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
6613  
6614    var withoutMovedElements = Object(toConsumableArray["a" /* default */])(array);
6615  
6616    withoutMovedElements.splice(from, count);
6617    return insertAt(withoutMovedElements, array.slice(from, from + count), to);
6618  }
6619  
6620  // CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/reducer.js
6621  
6622  
6623  
6624  
6625  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; }
6626  
6627  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; }
6628  
6629  /**
6630   * External dependencies
6631   */
6632  
6633  /**
6634   * WordPress dependencies
6635   */
6636  
6637  
6638  
6639  /**
6640   * Internal dependencies
6641   */
6642  
6643  
6644  
6645  /**
6646   * Given an array of blocks, returns an object where each key is a nesting
6647   * context, the value of which is an array of block client IDs existing within
6648   * that nesting context.
6649   *
6650   * @param {Array}   blocks       Blocks to map.
6651   * @param {?string} rootClientId Assumed root client ID.
6652   *
6653   * @return {Object} Block order map object.
6654   */
6655  
6656  function mapBlockOrder(blocks) {
6657    var rootClientId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
6658  
6659    var result = Object(defineProperty["a" /* default */])({}, rootClientId, []);
6660  
6661    blocks.forEach(function (block) {
6662      var clientId = block.clientId,
6663          innerBlocks = block.innerBlocks;
6664      result[rootClientId].push(clientId);
6665      Object.assign(result, mapBlockOrder(innerBlocks, clientId));
6666    });
6667    return result;
6668  }
6669  /**
6670   * Given an array of blocks, returns an object where each key contains
6671   * the clientId of the block and the value is the parent of the block.
6672   *
6673   * @param {Array}   blocks       Blocks to map.
6674   * @param {?string} rootClientId Assumed root client ID.
6675   *
6676   * @return {Object} Block order map object.
6677   */
6678  
6679  
6680  function mapBlockParents(blocks) {
6681    var rootClientId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
6682    return blocks.reduce(function (result, block) {
6683      return Object.assign(result, Object(defineProperty["a" /* default */])({}, block.clientId, rootClientId), mapBlockParents(block.innerBlocks, block.clientId));
6684    }, {});
6685  }
6686  /**
6687   * Helper method to iterate through all blocks, recursing into inner blocks,
6688   * applying a transformation function to each one.
6689   * Returns a flattened object with the transformed blocks.
6690   *
6691   * @param {Array} blocks Blocks to flatten.
6692   * @param {Function} transform Transforming function to be applied to each block.
6693   *
6694   * @return {Object} Flattened object.
6695   */
6696  
6697  
6698  function flattenBlocks(blocks) {
6699    var transform = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : external_lodash_["identity"];
6700    var result = {};
6701  
6702    var stack = Object(toConsumableArray["a" /* default */])(blocks);
6703  
6704    while (stack.length) {
6705      var _stack$shift = stack.shift(),
6706          innerBlocks = _stack$shift.innerBlocks,
6707          block = Object(objectWithoutProperties["a" /* default */])(_stack$shift, ["innerBlocks"]);
6708  
6709      stack.push.apply(stack, Object(toConsumableArray["a" /* default */])(innerBlocks));
6710      result[block.clientId] = transform(block);
6711    }
6712  
6713    return result;
6714  }
6715  /**
6716   * Given an array of blocks, returns an object containing all blocks, without
6717   * attributes, recursing into inner blocks. Keys correspond to the block client
6718   * ID, the value of which is the attributes object.
6719   *
6720   * @param {Array} blocks Blocks to flatten.
6721   *
6722   * @return {Object} Flattened block attributes object.
6723   */
6724  
6725  
6726  function getFlattenedBlocksWithoutAttributes(blocks) {
6727    return flattenBlocks(blocks, function (block) {
6728      return Object(external_lodash_["omit"])(block, 'attributes');
6729    });
6730  }
6731  /**
6732   * Given an array of blocks, returns an object containing all block attributes,
6733   * recursing into inner blocks. Keys correspond to the block client ID, the
6734   * value of which is the attributes object.
6735   *
6736   * @param {Array} blocks Blocks to flatten.
6737   *
6738   * @return {Object} Flattened block attributes object.
6739   */
6740  
6741  
6742  function getFlattenedBlockAttributes(blocks) {
6743    return flattenBlocks(blocks, function (block) {
6744      return block.attributes;
6745    });
6746  }
6747  /**
6748   * Given a block order map object, returns *all* of the block client IDs that are
6749   * a descendant of the given root client ID.
6750   *
6751   * Calling this with `rootClientId` set to `''` results in a list of client IDs
6752   * that are in the post. That is, it excludes blocks like fetched reusable
6753   * blocks which are stored into state but not visible. It also excludes
6754   * InnerBlocks controllers, like template parts.
6755   *
6756   * It is important to exclude the full inner block controller and not just the
6757   * inner blocks because in many cases, we need to persist the previous value of
6758   * an inner block controller. To do so, it must be excluded from the list of
6759   * client IDs which are considered to be part of the top-level entity.
6760   *
6761   * @param {Object}  blocksOrder  Object that maps block client IDs to a list of
6762   *                               nested block client IDs.
6763   * @param {?string} rootClientId The root client ID to search. Defaults to ''.
6764   * @param {?Object} controlledInnerBlocks The InnerBlocks controller state.
6765   *
6766   * @return {Array} List of descendant client IDs.
6767   */
6768  
6769  
6770  function getNestedBlockClientIds(blocksOrder) {
6771    var rootClientId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
6772    var controlledInnerBlocks = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
6773    return Object(external_lodash_["reduce"])(blocksOrder[rootClientId], function (result, clientId) {
6774      if (!!controlledInnerBlocks[clientId]) {
6775        return result;
6776      }
6777  
6778      return [].concat(Object(toConsumableArray["a" /* default */])(result), [clientId], Object(toConsumableArray["a" /* default */])(getNestedBlockClientIds(blocksOrder, clientId)));
6779    }, []);
6780  }
6781  /**
6782   * Returns an object against which it is safe to perform mutating operations,
6783   * given the original object and its current working copy.
6784   *
6785   * @param {Object} original Original object.
6786   * @param {Object} working  Working object.
6787   *
6788   * @return {Object} Mutation-safe object.
6789   */
6790  
6791  
6792  function getMutateSafeObject(original, working) {
6793    if (original === working) {
6794      return _objectSpread({}, original);
6795    }
6796  
6797    return working;
6798  }
6799  /**
6800   * Returns true if the two object arguments have the same keys, or false
6801   * otherwise.
6802   *
6803   * @param {Object} a First object.
6804   * @param {Object} b Second object.
6805   *
6806   * @return {boolean} Whether the two objects have the same keys.
6807   */
6808  
6809  
6810  function hasSameKeys(a, b) {
6811    return Object(external_lodash_["isEqual"])(Object(external_lodash_["keys"])(a), Object(external_lodash_["keys"])(b));
6812  }
6813  /**
6814   * Returns true if, given the currently dispatching action and the previously
6815   * dispatched action, the two actions are updating the same block attribute, or
6816   * false otherwise.
6817   *
6818   * @param {Object} action     Currently dispatching action.
6819   * @param {Object} lastAction Previously dispatched action.
6820   *
6821   * @return {boolean} Whether actions are updating the same block attribute.
6822   */
6823  
6824  function isUpdatingSameBlockAttribute(action, lastAction) {
6825    return action.type === 'UPDATE_BLOCK_ATTRIBUTES' && lastAction !== undefined && lastAction.type === 'UPDATE_BLOCK_ATTRIBUTES' && Object(external_lodash_["isEqual"])(action.clientIds, lastAction.clientIds) && hasSameKeys(action.attributes, lastAction.attributes);
6826  }
6827  /**
6828   * Utility returning an object with an empty object value for each key.
6829   *
6830   * @param {Array} objectKeys Keys to fill.
6831   * @return {Object} Object filled with empty object as values for each clientId.
6832   */
6833  
6834  var fillKeysWithEmptyObject = function fillKeysWithEmptyObject(objectKeys) {
6835    return objectKeys.reduce(function (result, key) {
6836      result[key] = {};
6837      return result;
6838    }, {});
6839  };
6840  /**
6841   * Higher-order reducer intended to compute a cache key for each block in the post.
6842   * A new instance of the cache key (empty object) is created each time the block object
6843   * needs to be refreshed (for any change in the block or its children).
6844   *
6845   * @param {Function} reducer Original reducer function.
6846   *
6847   * @return {Function} Enhanced reducer function.
6848   */
6849  
6850  
6851  var reducer_withBlockCache = function withBlockCache(reducer) {
6852    return function () {
6853      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
6854      var action = arguments.length > 1 ? arguments[1] : undefined;
6855      var newState = reducer(state, action);
6856  
6857      if (newState === state) {
6858        return state;
6859      }
6860  
6861      newState.cache = state.cache ? state.cache : {};
6862      /**
6863       * For each clientId provided, traverses up parents, adding the provided clientIds
6864       * and each parent's clientId to the returned array.
6865       *
6866       * When calling this function consider that it uses the old state, so any state
6867       * modifications made by the `reducer` will not be present.
6868       *
6869       * @param {Array} clientIds an Array of block clientIds.
6870       *
6871       * @return {Array} The provided clientIds and all of their parent clientIds.
6872       */
6873  
6874      var getBlocksWithParentsClientIds = function getBlocksWithParentsClientIds(clientIds) {
6875        return clientIds.reduce(function (result, clientId) {
6876          var current = clientId;
6877  
6878          do {
6879            result.push(current);
6880            current = state.parents[current];
6881          } while (current && !state.controlledInnerBlocks[current]);
6882  
6883          return result;
6884        }, []);
6885      };
6886  
6887      switch (action.type) {
6888        case 'RESET_BLOCKS':
6889          newState.cache = Object(external_lodash_["mapValues"])(flattenBlocks(action.blocks), function () {
6890            return {};
6891          });
6892          break;
6893  
6894        case 'RECEIVE_BLOCKS':
6895        case 'INSERT_BLOCKS':
6896          {
6897            var updatedBlockUids = Object(external_lodash_["keys"])(flattenBlocks(action.blocks));
6898  
6899            if (action.rootClientId && !state.controlledInnerBlocks[action.rootClientId]) {
6900              updatedBlockUids.push(action.rootClientId);
6901            }
6902  
6903            newState.cache = _objectSpread(_objectSpread({}, newState.cache), fillKeysWithEmptyObject(getBlocksWithParentsClientIds(updatedBlockUids)));
6904            break;
6905          }
6906  
6907        case 'UPDATE_BLOCK':
6908          newState.cache = _objectSpread(_objectSpread({}, newState.cache), fillKeysWithEmptyObject(getBlocksWithParentsClientIds([action.clientId])));
6909          break;
6910  
6911        case 'UPDATE_BLOCK_ATTRIBUTES':
6912          newState.cache = _objectSpread(_objectSpread({}, newState.cache), fillKeysWithEmptyObject(getBlocksWithParentsClientIds(action.clientIds)));
6913          break;
6914  
6915        case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
6916          var parentClientIds = fillKeysWithEmptyObject(getBlocksWithParentsClientIds(action.replacedClientIds));
6917          newState.cache = _objectSpread(_objectSpread(_objectSpread({}, Object(external_lodash_["omit"])(newState.cache, action.replacedClientIds)), Object(external_lodash_["omit"])(parentClientIds, action.replacedClientIds)), fillKeysWithEmptyObject(Object(external_lodash_["keys"])(flattenBlocks(action.blocks))));
6918          break;
6919  
6920        case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
6921          newState.cache = _objectSpread(_objectSpread({}, Object(external_lodash_["omit"])(newState.cache, action.removedClientIds)), fillKeysWithEmptyObject(Object(external_lodash_["difference"])(getBlocksWithParentsClientIds(action.clientIds), action.clientIds)));
6922          break;
6923  
6924        case 'MOVE_BLOCKS_TO_POSITION':
6925          {
6926            var _updatedBlockUids = Object(toConsumableArray["a" /* default */])(action.clientIds);
6927  
6928            if (action.fromRootClientId) {
6929              _updatedBlockUids.push(action.fromRootClientId);
6930            }
6931  
6932            if (action.toRootClientId) {
6933              _updatedBlockUids.push(action.toRootClientId);
6934            }
6935  
6936            newState.cache = _objectSpread(_objectSpread({}, newState.cache), fillKeysWithEmptyObject(getBlocksWithParentsClientIds(_updatedBlockUids)));
6937            break;
6938          }
6939  
6940        case 'MOVE_BLOCKS_UP':
6941        case 'MOVE_BLOCKS_DOWN':
6942          {
6943            var _updatedBlockUids2 = [];
6944  
6945            if (action.rootClientId) {
6946              _updatedBlockUids2.push(action.rootClientId);
6947            }
6948  
6949            newState.cache = _objectSpread(_objectSpread({}, newState.cache), fillKeysWithEmptyObject(getBlocksWithParentsClientIds(_updatedBlockUids2)));
6950            break;
6951          }
6952  
6953        case 'SAVE_REUSABLE_BLOCK_SUCCESS':
6954          {
6955            var _updatedBlockUids3 = Object(external_lodash_["keys"])(Object(external_lodash_["omitBy"])(newState.attributes, function (attributes, clientId) {
6956              return newState.byClientId[clientId].name !== 'core/block' || attributes.ref !== action.updatedId;
6957            }));
6958  
6959            newState.cache = _objectSpread(_objectSpread({}, newState.cache), fillKeysWithEmptyObject(getBlocksWithParentsClientIds(_updatedBlockUids3)));
6960          }
6961      }
6962  
6963      return newState;
6964    };
6965  };
6966  /**
6967   * Higher-order reducer intended to augment the blocks reducer, assigning an
6968   * `isPersistentChange` property value corresponding to whether a change in
6969   * state can be considered as persistent. All changes are considered persistent
6970   * except when updating the same block attribute as in the previous action.
6971   *
6972   * @param {Function} reducer Original reducer function.
6973   *
6974   * @return {Function} Enhanced reducer function.
6975   */
6976  
6977  
6978  function withPersistentBlockChange(reducer) {
6979    var lastAction;
6980    var markNextChangeAsNotPersistent = false;
6981    return function (state, action) {
6982      var nextState = reducer(state, action);
6983      var isExplicitPersistentChange = action.type === 'MARK_LAST_CHANGE_AS_PERSISTENT' || markNextChangeAsNotPersistent; // Defer to previous state value (or default) unless changing or
6984      // explicitly marking as persistent.
6985  
6986      if (state === nextState && !isExplicitPersistentChange) {
6987        var _state$isPersistentCh;
6988  
6989        markNextChangeAsNotPersistent = action.type === 'MARK_NEXT_CHANGE_AS_NOT_PERSISTENT';
6990        var nextIsPersistentChange = (_state$isPersistentCh = state === null || state === void 0 ? void 0 : state.isPersistentChange) !== null && _state$isPersistentCh !== void 0 ? _state$isPersistentCh : true;
6991  
6992        if (state.isPersistentChange === nextIsPersistentChange) {
6993          return state;
6994        }
6995  
6996        return _objectSpread(_objectSpread({}, nextState), {}, {
6997          isPersistentChange: nextIsPersistentChange
6998        });
6999      }
7000  
7001      nextState = _objectSpread(_objectSpread({}, nextState), {}, {
7002        isPersistentChange: isExplicitPersistentChange ? !markNextChangeAsNotPersistent : !isUpdatingSameBlockAttribute(action, lastAction)
7003      }); // In comparing against the previous action, consider only those which
7004      // would have qualified as one which would have been ignored or not
7005      // have resulted in a changed state.
7006  
7007      lastAction = action;
7008      markNextChangeAsNotPersistent = action.type === 'MARK_NEXT_CHANGE_AS_NOT_PERSISTENT';
7009      return nextState;
7010    };
7011  }
7012  /**
7013   * Higher-order reducer intended to augment the blocks reducer, assigning an
7014   * `isIgnoredChange` property value corresponding to whether a change in state
7015   * can be considered as ignored. A change is considered ignored when the result
7016   * of an action not incurred by direct user interaction.
7017   *
7018   * @param {Function} reducer Original reducer function.
7019   *
7020   * @return {Function} Enhanced reducer function.
7021   */
7022  
7023  
7024  function withIgnoredBlockChange(reducer) {
7025    /**
7026     * Set of action types for which a blocks state change should be ignored.
7027     *
7028     * @type {Set}
7029     */
7030    var IGNORED_ACTION_TYPES = new Set(['RECEIVE_BLOCKS']);
7031    return function (state, action) {
7032      var nextState = reducer(state, action);
7033  
7034      if (nextState !== state) {
7035        nextState.isIgnoredChange = IGNORED_ACTION_TYPES.has(action.type);
7036      }
7037  
7038      return nextState;
7039    };
7040  }
7041  /**
7042   * Higher-order reducer targeting the combined blocks reducer, augmenting
7043   * block client IDs in remove action to include cascade of inner blocks.
7044   *
7045   * @param {Function} reducer Original reducer function.
7046   *
7047   * @return {Function} Enhanced reducer function.
7048   */
7049  
7050  
7051  var reducer_withInnerBlocksRemoveCascade = function withInnerBlocksRemoveCascade(reducer) {
7052    return function (state, action) {
7053      // Gets all children which need to be removed.
7054      var getAllChildren = function getAllChildren(clientIds) {
7055        var result = clientIds;
7056  
7057        for (var i = 0; i < result.length; i++) {
7058          var _result2;
7059  
7060          if (!state.order[result[i]] || action.keepControlledInnerBlocks && action.keepControlledInnerBlocks[result[i]]) {
7061            continue;
7062          }
7063  
7064          if (result === clientIds) {
7065            result = Object(toConsumableArray["a" /* default */])(result);
7066          }
7067  
7068          (_result2 = result).push.apply(_result2, Object(toConsumableArray["a" /* default */])(state.order[result[i]]));
7069        }
7070  
7071        return result;
7072      };
7073  
7074      if (state) {
7075        switch (action.type) {
7076          case 'REMOVE_BLOCKS':
7077            action = _objectSpread(_objectSpread({}, action), {}, {
7078              type: 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN',
7079              removedClientIds: getAllChildren(action.clientIds)
7080            });
7081            break;
7082  
7083          case 'REPLACE_BLOCKS':
7084            action = _objectSpread(_objectSpread({}, action), {}, {
7085              type: 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN',
7086              replacedClientIds: getAllChildren(action.clientIds)
7087            });
7088            break;
7089        }
7090      }
7091  
7092      return reducer(state, action);
7093    };
7094  };
7095  /**
7096   * Higher-order reducer which targets the combined blocks reducer and handles
7097   * the `RESET_BLOCKS` action. When dispatched, this action will replace all
7098   * blocks that exist in the post, leaving blocks that exist only in state (e.g.
7099   * reusable blocks and blocks controlled by inner blocks controllers) alone.
7100   *
7101   * @param {Function} reducer Original reducer function.
7102   *
7103   * @return {Function} Enhanced reducer function.
7104   */
7105  
7106  
7107  var reducer_withBlockReset = function withBlockReset(reducer) {
7108    return function (state, action) {
7109      if (state && action.type === 'RESET_BLOCKS') {
7110        /**
7111         * A list of client IDs associated with the top level entity (like a
7112         * post or template). It excludes the client IDs of blocks associated
7113         * with other entities, like inner block controllers or reusable blocks.
7114         */
7115        var visibleClientIds = getNestedBlockClientIds(state.order, '', state.controlledInnerBlocks); // pickBy returns only the truthy values from controlledInnerBlocks
7116  
7117        var controlledInnerBlocks = Object.keys(Object(external_lodash_["pickBy"])(state.controlledInnerBlocks));
7118        /**
7119         * Each update operation consists of a few parts:
7120         * 1. First, the client IDs associated with the top level entity are
7121         *    removed from the existing state key, leaving in place controlled
7122         *    blocks (like reusable blocks and inner block controllers).
7123         * 2. Second, the blocks from the reset action are used to calculate the
7124         *    individual state keys. This will re-populate the clientIDs which
7125         *    were removed in step 1.
7126         * 3. In some cases, we remove the recalculated inner block controllers,
7127         *    letting their old values persist. We need to do this because the
7128         *    reset block action from a top-level entity is not aware of any
7129         *    inner blocks inside InnerBlock controllers. So if the new values
7130         *    were used, it would not take into account the existing InnerBlocks
7131         *    which already exist in the state for inner block controllers. For
7132         *    example, `attributes` uses the newly computed value for controllers
7133         *    since attributes are stored in the top-level entity. But `order`
7134         *    uses the previous value for the controllers since the new value
7135         *    does not include the order of controlled inner blocks. So if the
7136         *    new value was used, template parts would disappear from the editor
7137         *    whenever you try to undo a change in the top level entity.
7138         */
7139  
7140        return _objectSpread(_objectSpread({}, state), {}, {
7141          byClientId: _objectSpread(_objectSpread({}, Object(external_lodash_["omit"])(state.byClientId, visibleClientIds)), getFlattenedBlocksWithoutAttributes(action.blocks)),
7142          attributes: _objectSpread(_objectSpread({}, Object(external_lodash_["omit"])(state.attributes, visibleClientIds)), getFlattenedBlockAttributes(action.blocks)),
7143          order: _objectSpread(_objectSpread({}, Object(external_lodash_["omit"])(state.order, visibleClientIds)), Object(external_lodash_["omit"])(mapBlockOrder(action.blocks), controlledInnerBlocks)),
7144          parents: _objectSpread(_objectSpread({}, Object(external_lodash_["omit"])(state.parents, visibleClientIds)), mapBlockParents(action.blocks)),
7145          cache: _objectSpread(_objectSpread({}, Object(external_lodash_["omit"])(state.cache, visibleClientIds)), Object(external_lodash_["omit"])(Object(external_lodash_["mapValues"])(flattenBlocks(action.blocks), function () {
7146            return {};
7147          }), controlledInnerBlocks))
7148        });
7149      }
7150  
7151      return reducer(state, action);
7152    };
7153  };
7154  /**
7155   * Higher-order reducer which targets the combined blocks reducer and handles
7156   * the `REPLACE_INNER_BLOCKS` action. When dispatched, this action the state
7157   * should become equivalent to the execution of a `REMOVE_BLOCKS` action
7158   * containing all the child's of the root block followed by the execution of
7159   * `INSERT_BLOCKS` with the new blocks.
7160   *
7161   * @param {Function} reducer Original reducer function.
7162   *
7163   * @return {Function} Enhanced reducer function.
7164   */
7165  
7166  
7167  var reducer_withReplaceInnerBlocks = function withReplaceInnerBlocks(reducer) {
7168    return function (state, action) {
7169      if (action.type !== 'REPLACE_INNER_BLOCKS') {
7170        return reducer(state, action);
7171      } // Finds every nested inner block controller. We must check the action blocks
7172      // and not just the block parent state because some inner block controllers
7173      // should be deleted if specified, whereas others should not be deleted. If
7174      // a controlled should not be deleted, then we need to avoid deleting its
7175      // inner blocks from the block state because its inner blocks will not be
7176      // attached to the block in the action.
7177  
7178  
7179      var nestedControllers = {};
7180  
7181      if (Object.keys(state.controlledInnerBlocks).length) {
7182        var stack = Object(toConsumableArray["a" /* default */])(action.blocks);
7183  
7184        while (stack.length) {
7185          var _stack$shift2 = stack.shift(),
7186              innerBlocks = _stack$shift2.innerBlocks,
7187              block = Object(objectWithoutProperties["a" /* default */])(_stack$shift2, ["innerBlocks"]);
7188  
7189          stack.push.apply(stack, Object(toConsumableArray["a" /* default */])(innerBlocks));
7190  
7191          if (!!state.controlledInnerBlocks[block.clientId]) {
7192            nestedControllers[block.clientId] = true;
7193          }
7194        }
7195      } // The `keepControlledInnerBlocks` prop will keep the inner blocks of the
7196      // marked block in the block state so that they can be reattached to the
7197      // marked block when we re-insert everything a few lines below.
7198  
7199  
7200      var stateAfterBlocksRemoval = state;
7201  
7202      if (state.order[action.rootClientId]) {
7203        stateAfterBlocksRemoval = reducer(stateAfterBlocksRemoval, {
7204          type: 'REMOVE_BLOCKS',
7205          keepControlledInnerBlocks: nestedControllers,
7206          clientIds: state.order[action.rootClientId]
7207        });
7208      }
7209  
7210      var stateAfterInsert = stateAfterBlocksRemoval;
7211  
7212      if (action.blocks.length) {
7213        stateAfterInsert = reducer(stateAfterInsert, _objectSpread(_objectSpread({}, action), {}, {
7214          type: 'INSERT_BLOCKS',
7215          index: 0
7216        })); // We need to re-attach the block order of the controlled inner blocks.
7217        // Otherwise, an inner block controller's blocks will be deleted entirely
7218        // from its entity..
7219  
7220        stateAfterInsert.order = _objectSpread(_objectSpread({}, stateAfterInsert.order), Object(external_lodash_["reduce"])(nestedControllers, function (result, value, key) {
7221          if (state.order[key]) {
7222            result[key] = state.order[key];
7223          }
7224  
7225          return result;
7226        }, {}));
7227      }
7228  
7229      return stateAfterInsert;
7230    };
7231  };
7232  /**
7233   * Higher-order reducer which targets the combined blocks reducer and handles
7234   * the `SAVE_REUSABLE_BLOCK_SUCCESS` action. This action can't be handled by
7235   * regular reducers and needs a higher-order reducer since it needs access to
7236   * both `byClientId` and `attributes` simultaneously.
7237   *
7238   * @param {Function} reducer Original reducer function.
7239   *
7240   * @return {Function} Enhanced reducer function.
7241   */
7242  
7243  
7244  var reducer_withSaveReusableBlock = function withSaveReusableBlock(reducer) {
7245    return function (state, action) {
7246      if (state && action.type === 'SAVE_REUSABLE_BLOCK_SUCCESS') {
7247        var id = action.id,
7248            updatedId = action.updatedId; // If a temporary reusable block is saved, we swap the temporary id with the final one
7249  
7250        if (id === updatedId) {
7251          return state;
7252        }
7253  
7254        state = _objectSpread({}, state);
7255        state.attributes = Object(external_lodash_["mapValues"])(state.attributes, function (attributes, clientId) {
7256          var name = state.byClientId[clientId].name;
7257  
7258          if (name === 'core/block' && attributes.ref === id) {
7259            return _objectSpread(_objectSpread({}, attributes), {}, {
7260              ref: updatedId
7261            });
7262          }
7263  
7264          return attributes;
7265        });
7266      }
7267  
7268      return reducer(state, action);
7269    };
7270  };
7271  /**
7272   * Reducer returning the blocks state.
7273   *
7274   * @param {Object} state  Current state.
7275   * @param {Object} action Dispatched action.
7276   *
7277   * @return {Object} Updated state.
7278   */
7279  
7280  
7281  var reducer_blocks = Object(external_lodash_["flow"])(external_wp_data_["combineReducers"], reducer_withSaveReusableBlock, // needs to be before withBlockCache
7282  reducer_withBlockCache, // needs to be before withInnerBlocksRemoveCascade
7283  reducer_withInnerBlocksRemoveCascade, reducer_withReplaceInnerBlocks, // needs to be after withInnerBlocksRemoveCascade
7284  reducer_withBlockReset, withPersistentBlockChange, withIgnoredBlockChange)({
7285    byClientId: function byClientId() {
7286      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
7287      var action = arguments.length > 1 ? arguments[1] : undefined;
7288  
7289      switch (action.type) {
7290        case 'RESET_BLOCKS':
7291          return getFlattenedBlocksWithoutAttributes(action.blocks);
7292  
7293        case 'RECEIVE_BLOCKS':
7294        case 'INSERT_BLOCKS':
7295          return _objectSpread(_objectSpread({}, state), getFlattenedBlocksWithoutAttributes(action.blocks));
7296  
7297        case 'UPDATE_BLOCK':
7298          // Ignore updates if block isn't known
7299          if (!state[action.clientId]) {
7300            return state;
7301          } // Do nothing if only attributes change.
7302  
7303  
7304          var changes = Object(external_lodash_["omit"])(action.updates, 'attributes');
7305  
7306          if (Object(external_lodash_["isEmpty"])(changes)) {
7307            return state;
7308          }
7309  
7310          return _objectSpread(_objectSpread({}, state), {}, Object(defineProperty["a" /* default */])({}, action.clientId, _objectSpread(_objectSpread({}, state[action.clientId]), changes)));
7311  
7312        case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
7313          if (!action.blocks) {
7314            return state;
7315          }
7316  
7317          return _objectSpread(_objectSpread({}, Object(external_lodash_["omit"])(state, action.replacedClientIds)), getFlattenedBlocksWithoutAttributes(action.blocks));
7318  
7319        case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
7320          return Object(external_lodash_["omit"])(state, action.removedClientIds);
7321      }
7322  
7323      return state;
7324    },
7325    attributes: function attributes() {
7326      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
7327      var action = arguments.length > 1 ? arguments[1] : undefined;
7328  
7329      switch (action.type) {
7330        case 'RESET_BLOCKS':
7331          return getFlattenedBlockAttributes(action.blocks);
7332  
7333        case 'RECEIVE_BLOCKS':
7334        case 'INSERT_BLOCKS':
7335          return _objectSpread(_objectSpread({}, state), getFlattenedBlockAttributes(action.blocks));
7336  
7337        case 'UPDATE_BLOCK':
7338          // Ignore updates if block isn't known or there are no attribute changes.
7339          if (!state[action.clientId] || !action.updates.attributes) {
7340            return state;
7341          }
7342  
7343          return _objectSpread(_objectSpread({}, state), {}, Object(defineProperty["a" /* default */])({}, action.clientId, _objectSpread(_objectSpread({}, state[action.clientId]), action.updates.attributes)));
7344  
7345        case 'UPDATE_BLOCK_ATTRIBUTES':
7346          {
7347            // Avoid a state change if none of the block IDs are known.
7348            if (action.clientIds.every(function (id) {
7349              return !state[id];
7350            })) {
7351              return state;
7352            }
7353  
7354            var next = action.clientIds.reduce(function (accumulator, id) {
7355              return _objectSpread(_objectSpread({}, accumulator), {}, Object(defineProperty["a" /* default */])({}, id, Object(external_lodash_["reduce"])(action.uniqueByBlock ? action.attributes[id] : action.attributes, function (result, value, key) {
7356                // Consider as updates only changed values.
7357                if (value !== result[key]) {
7358                  result = getMutateSafeObject(state[id], result);
7359                  result[key] = value;
7360                }
7361  
7362                return result;
7363              }, state[id])));
7364            }, {});
7365  
7366            if (action.clientIds.every(function (id) {
7367              return next[id] === state[id];
7368            })) {
7369              return state;
7370            }
7371  
7372            return _objectSpread(_objectSpread({}, state), next);
7373          }
7374  
7375        case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
7376          if (!action.blocks) {
7377            return state;
7378          }
7379  
7380          return _objectSpread(_objectSpread({}, Object(external_lodash_["omit"])(state, action.replacedClientIds)), getFlattenedBlockAttributes(action.blocks));
7381  
7382        case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
7383          return Object(external_lodash_["omit"])(state, action.removedClientIds);
7384      }
7385  
7386      return state;
7387    },
7388    order: function order() {
7389      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
7390      var action = arguments.length > 1 ? arguments[1] : undefined;
7391  
7392      switch (action.type) {
7393        case 'RESET_BLOCKS':
7394          return mapBlockOrder(action.blocks);
7395  
7396        case 'RECEIVE_BLOCKS':
7397          return _objectSpread(_objectSpread({}, state), Object(external_lodash_["omit"])(mapBlockOrder(action.blocks), ''));
7398  
7399        case 'INSERT_BLOCKS':
7400          {
7401            var _action$rootClientId = action.rootClientId,
7402                rootClientId = _action$rootClientId === void 0 ? '' : _action$rootClientId;
7403            var subState = state[rootClientId] || [];
7404            var mappedBlocks = mapBlockOrder(action.blocks, rootClientId);
7405            var _action$index = action.index,
7406                index = _action$index === void 0 ? subState.length : _action$index;
7407            return _objectSpread(_objectSpread(_objectSpread({}, state), mappedBlocks), {}, Object(defineProperty["a" /* default */])({}, rootClientId, insertAt(subState, mappedBlocks[rootClientId], index)));
7408          }
7409  
7410        case 'MOVE_BLOCKS_TO_POSITION':
7411          {
7412            var _objectSpread7;
7413  
7414            var _action$fromRootClien = action.fromRootClientId,
7415                fromRootClientId = _action$fromRootClien === void 0 ? '' : _action$fromRootClien,
7416                _action$toRootClientI = action.toRootClientId,
7417                toRootClientId = _action$toRootClientI === void 0 ? '' : _action$toRootClientI,
7418                clientIds = action.clientIds;
7419  
7420            var _action$index2 = action.index,
7421                _index = _action$index2 === void 0 ? state[toRootClientId].length : _action$index2; // Moving inside the same parent block
7422  
7423  
7424            if (fromRootClientId === toRootClientId) {
7425              var _subState = state[toRootClientId];
7426  
7427              var fromIndex = _subState.indexOf(clientIds[0]);
7428  
7429              return _objectSpread(_objectSpread({}, state), {}, Object(defineProperty["a" /* default */])({}, toRootClientId, moveTo(state[toRootClientId], fromIndex, _index, clientIds.length)));
7430            } // Moving from a parent block to another
7431  
7432  
7433            return _objectSpread(_objectSpread({}, state), {}, (_objectSpread7 = {}, Object(defineProperty["a" /* default */])(_objectSpread7, fromRootClientId, external_lodash_["without"].apply(void 0, [state[fromRootClientId]].concat(Object(toConsumableArray["a" /* default */])(clientIds)))), Object(defineProperty["a" /* default */])(_objectSpread7, toRootClientId, insertAt(state[toRootClientId], clientIds, _index)), _objectSpread7));
7434          }
7435  
7436        case 'MOVE_BLOCKS_UP':
7437          {
7438            var _clientIds = action.clientIds,
7439                _action$rootClientId2 = action.rootClientId,
7440                _rootClientId = _action$rootClientId2 === void 0 ? '' : _action$rootClientId2;
7441  
7442            var firstClientId = Object(external_lodash_["first"])(_clientIds);
7443            var _subState2 = state[_rootClientId];
7444  
7445            if (!_subState2.length || firstClientId === Object(external_lodash_["first"])(_subState2)) {
7446              return state;
7447            }
7448  
7449            var firstIndex = _subState2.indexOf(firstClientId);
7450  
7451            return _objectSpread(_objectSpread({}, state), {}, Object(defineProperty["a" /* default */])({}, _rootClientId, moveTo(_subState2, firstIndex, firstIndex - 1, _clientIds.length)));
7452          }
7453  
7454        case 'MOVE_BLOCKS_DOWN':
7455          {
7456            var _clientIds2 = action.clientIds,
7457                _action$rootClientId3 = action.rootClientId,
7458                _rootClientId2 = _action$rootClientId3 === void 0 ? '' : _action$rootClientId3;
7459  
7460            var _firstClientId = Object(external_lodash_["first"])(_clientIds2);
7461  
7462            var lastClientId = Object(external_lodash_["last"])(_clientIds2);
7463            var _subState3 = state[_rootClientId2];
7464  
7465            if (!_subState3.length || lastClientId === Object(external_lodash_["last"])(_subState3)) {
7466              return state;
7467            }
7468  
7469            var _firstIndex = _subState3.indexOf(_firstClientId);
7470  
7471            return _objectSpread(_objectSpread({}, state), {}, Object(defineProperty["a" /* default */])({}, _rootClientId2, moveTo(_subState3, _firstIndex, _firstIndex + 1, _clientIds2.length)));
7472          }
7473  
7474        case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
7475          {
7476            var _clientIds3 = action.clientIds;
7477  
7478            if (!action.blocks) {
7479              return state;
7480            }
7481  
7482            var _mappedBlocks = mapBlockOrder(action.blocks);
7483  
7484            return Object(external_lodash_["flow"])([function (nextState) {
7485              return Object(external_lodash_["omit"])(nextState, action.replacedClientIds);
7486            }, function (nextState) {
7487              return _objectSpread(_objectSpread({}, nextState), Object(external_lodash_["omit"])(_mappedBlocks, ''));
7488            }, function (nextState) {
7489              return Object(external_lodash_["mapValues"])(nextState, function (subState) {
7490                return Object(external_lodash_["reduce"])(subState, function (result, clientId) {
7491                  if (clientId === _clientIds3[0]) {
7492                    return [].concat(Object(toConsumableArray["a" /* default */])(result), Object(toConsumableArray["a" /* default */])(_mappedBlocks['']));
7493                  }
7494  
7495                  if (_clientIds3.indexOf(clientId) === -1) {
7496                    result.push(clientId);
7497                  }
7498  
7499                  return result;
7500                }, []);
7501              });
7502            }])(state);
7503          }
7504  
7505        case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
7506          return Object(external_lodash_["flow"])([// Remove inner block ordering for removed blocks
7507          function (nextState) {
7508            return Object(external_lodash_["omit"])(nextState, action.removedClientIds);
7509          }, // Remove deleted blocks from other blocks' orderings
7510          function (nextState) {
7511            return Object(external_lodash_["mapValues"])(nextState, function (subState) {
7512              return external_lodash_["without"].apply(void 0, [subState].concat(Object(toConsumableArray["a" /* default */])(action.removedClientIds)));
7513            });
7514          }])(state);
7515      }
7516  
7517      return state;
7518    },
7519    // While technically redundant data as the inverse of `order`, it serves as
7520    // an optimization for the selectors which derive the ancestry of a block.
7521    parents: function parents() {
7522      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
7523      var action = arguments.length > 1 ? arguments[1] : undefined;
7524  
7525      switch (action.type) {
7526        case 'RESET_BLOCKS':
7527          return mapBlockParents(action.blocks);
7528  
7529        case 'RECEIVE_BLOCKS':
7530          return _objectSpread(_objectSpread({}, state), mapBlockParents(action.blocks));
7531  
7532        case 'INSERT_BLOCKS':
7533          return _objectSpread(_objectSpread({}, state), mapBlockParents(action.blocks, action.rootClientId || ''));
7534  
7535        case 'MOVE_BLOCKS_TO_POSITION':
7536          {
7537            return _objectSpread(_objectSpread({}, state), action.clientIds.reduce(function (accumulator, id) {
7538              accumulator[id] = action.toRootClientId || '';
7539              return accumulator;
7540            }, {}));
7541          }
7542  
7543        case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
7544          return _objectSpread(_objectSpread({}, Object(external_lodash_["omit"])(state, action.replacedClientIds)), mapBlockParents(action.blocks, state[action.clientIds[0]]));
7545  
7546        case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
7547          return Object(external_lodash_["omit"])(state, action.removedClientIds);
7548      }
7549  
7550      return state;
7551    },
7552    controlledInnerBlocks: function controlledInnerBlocks() {
7553      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
7554  
7555      var _ref = arguments.length > 1 ? arguments[1] : undefined,
7556          type = _ref.type,
7557          clientId = _ref.clientId,
7558          hasControlledInnerBlocks = _ref.hasControlledInnerBlocks;
7559  
7560      if (type === 'SET_HAS_CONTROLLED_INNER_BLOCKS') {
7561        return _objectSpread(_objectSpread({}, state), {}, Object(defineProperty["a" /* default */])({}, clientId, hasControlledInnerBlocks));
7562      }
7563  
7564      return state;
7565    }
7566  });
7567  /**
7568   * Reducer returning typing state.
7569   *
7570   * @param {boolean} state  Current state.
7571   * @param {Object}  action Dispatched action.
7572   *
7573   * @return {boolean} Updated state.
7574   */
7575  
7576  function reducer_isTyping() {
7577    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
7578    var action = arguments.length > 1 ? arguments[1] : undefined;
7579  
7580    switch (action.type) {
7581      case 'START_TYPING':
7582        return true;
7583  
7584      case 'STOP_TYPING':
7585        return false;
7586    }
7587  
7588    return state;
7589  }
7590  /**
7591   * Reducer returning dragged block client id.
7592   *
7593   * @param {string[]} state  Current state.
7594   * @param {Object}  action Dispatched action.
7595   *
7596   * @return {string[]} Updated state.
7597   */
7598  
7599  function draggedBlocks() {
7600    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
7601    var action = arguments.length > 1 ? arguments[1] : undefined;
7602  
7603    switch (action.type) {
7604      case 'START_DRAGGING_BLOCKS':
7605        return action.clientIds;
7606  
7607      case 'STOP_DRAGGING_BLOCKS':
7608        return [];
7609    }
7610  
7611    return state;
7612  }
7613  /**
7614   * Reducer returning whether the caret is within formatted text.
7615   *
7616   * @param {boolean} state  Current state.
7617   * @param {Object}  action Dispatched action.
7618   *
7619   * @return {boolean} Updated state.
7620   */
7621  
7622  function reducer_isCaretWithinFormattedText() {
7623    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
7624    var action = arguments.length > 1 ? arguments[1] : undefined;
7625  
7626    switch (action.type) {
7627      case 'ENTER_FORMATTED_TEXT':
7628        return true;
7629  
7630      case 'EXIT_FORMATTED_TEXT':
7631        return false;
7632    }
7633  
7634    return state;
7635  }
7636  /**
7637   * Internal helper reducer for selectionStart and selectionEnd. Can hold a block
7638   * selection, represented by an object with property clientId.
7639   *
7640   * @param {Object} state  Current state.
7641   * @param {Object} action Dispatched action.
7642   *
7643   * @return {Object} Updated state.
7644   */
7645  
7646  function selectionHelper() {
7647    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
7648    var action = arguments.length > 1 ? arguments[1] : undefined;
7649  
7650    switch (action.type) {
7651      case 'CLEAR_SELECTED_BLOCK':
7652        {
7653          if (state.clientId) {
7654            return {};
7655          }
7656  
7657          return state;
7658        }
7659  
7660      case 'SELECT_BLOCK':
7661        if (action.clientId === state.clientId) {
7662          return state;
7663        }
7664  
7665        return {
7666          clientId: action.clientId
7667        };
7668  
7669      case 'REPLACE_INNER_BLOCKS':
7670      case 'INSERT_BLOCKS':
7671        {
7672          if (!action.updateSelection || !action.blocks.length) {
7673            return state;
7674          }
7675  
7676          return {
7677            clientId: action.blocks[0].clientId
7678          };
7679        }
7680  
7681      case 'REMOVE_BLOCKS':
7682        if (!action.clientIds || !action.clientIds.length || action.clientIds.indexOf(state.clientId) === -1) {
7683          return state;
7684        }
7685  
7686        return {};
7687  
7688      case 'REPLACE_BLOCKS':
7689        {
7690          if (action.clientIds.indexOf(state.clientId) === -1) {
7691            return state;
7692          }
7693  
7694          var indexToSelect = action.indexToSelect || action.blocks.length - 1;
7695          var blockToSelect = action.blocks[indexToSelect];
7696  
7697          if (!blockToSelect) {
7698            return {};
7699          }
7700  
7701          if (blockToSelect.clientId === state.clientId) {
7702            return state;
7703          }
7704  
7705          return {
7706            clientId: blockToSelect.clientId
7707          };
7708        }
7709    }
7710  
7711    return state;
7712  }
7713  /**
7714   * Reducer returning the selection state.
7715   *
7716   * @param {boolean} state  Current state.
7717   * @param {Object}  action Dispatched action.
7718   *
7719   * @return {boolean} Updated state.
7720   */
7721  
7722  
7723  function reducer_selection() {
7724    var _state$selectionStart, _state$selectionEnd;
7725  
7726    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
7727    var action = arguments.length > 1 ? arguments[1] : undefined;
7728  
7729    switch (action.type) {
7730      case 'SELECTION_CHANGE':
7731        return {
7732          selectionStart: {
7733            clientId: action.clientId,
7734            attributeKey: action.attributeKey,
7735            offset: action.startOffset
7736          },
7737          selectionEnd: {
7738            clientId: action.clientId,
7739            attributeKey: action.attributeKey,
7740            offset: action.endOffset
7741          }
7742        };
7743  
7744      case 'RESET_SELECTION':
7745        var selectionStart = action.selectionStart,
7746            selectionEnd = action.selectionEnd;
7747        return {
7748          selectionStart: selectionStart,
7749          selectionEnd: selectionEnd
7750        };
7751  
7752      case 'MULTI_SELECT':
7753        var start = action.start,
7754            end = action.end;
7755        return {
7756          selectionStart: {
7757            clientId: start
7758          },
7759          selectionEnd: {
7760            clientId: end
7761          }
7762        };
7763  
7764      case 'RESET_BLOCKS':
7765        var startClientId = state === null || state === void 0 ? void 0 : (_state$selectionStart = state.selectionStart) === null || _state$selectionStart === void 0 ? void 0 : _state$selectionStart.clientId;
7766        var endClientId = state === null || state === void 0 ? void 0 : (_state$selectionEnd = state.selectionEnd) === null || _state$selectionEnd === void 0 ? void 0 : _state$selectionEnd.clientId; // Do nothing if there's no selected block.
7767  
7768        if (!startClientId && !endClientId) {
7769          return state;
7770        } // If the start of the selection won't exist after reset, remove selection.
7771  
7772  
7773        if (!action.blocks.some(function (block) {
7774          return block.clientId === startClientId;
7775        })) {
7776          return {
7777            selectionStart: {},
7778            selectionEnd: {}
7779          };
7780        } // If the end of the selection won't exist after reset, collapse selection.
7781  
7782  
7783        if (!action.blocks.some(function (block) {
7784          return block.clientId === endClientId;
7785        })) {
7786          return _objectSpread(_objectSpread({}, state), {}, {
7787            selectionEnd: state.selectionStart
7788          });
7789        }
7790  
7791    }
7792  
7793    return {
7794      selectionStart: selectionHelper(state.selectionStart, action),
7795      selectionEnd: selectionHelper(state.selectionEnd, action)
7796    };
7797  }
7798  /**
7799   * Reducer returning whether the user is multi-selecting.
7800   *
7801   * @param {boolean} state  Current state.
7802   * @param {Object}  action Dispatched action.
7803   *
7804   * @return {boolean} Updated state.
7805   */
7806  
7807  function reducer_isMultiSelecting() {
7808    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
7809    var action = arguments.length > 1 ? arguments[1] : undefined;
7810  
7811    switch (action.type) {
7812      case 'START_MULTI_SELECT':
7813        return true;
7814  
7815      case 'STOP_MULTI_SELECT':
7816        return false;
7817    }
7818  
7819    return state;
7820  }
7821  /**
7822   * Reducer returning whether selection is enabled.
7823   *
7824   * @param {boolean} state  Current state.
7825   * @param {Object}  action Dispatched action.
7826   *
7827   * @return {boolean} Updated state.
7828   */
7829  
7830  function reducer_isSelectionEnabled() {
7831    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
7832    var action = arguments.length > 1 ? arguments[1] : undefined;
7833  
7834    switch (action.type) {
7835      case 'TOGGLE_SELECTION':
7836        return action.isSelectionEnabled;
7837    }
7838  
7839    return state;
7840  }
7841  /**
7842   * Reducer returning the intial block selection.
7843   *
7844   * Currently this in only used to restore the selection after block deletion and
7845   * pasting new content.This reducer should eventually be removed in favour of setting
7846   * selection directly.
7847   *
7848   * @param {boolean} state  Current state.
7849   * @param {Object}  action Dispatched action.
7850   *
7851   * @return {number|null} Initial position: 0, -1 or null.
7852   */
7853  
7854  function reducer_initialPosition() {
7855    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
7856    var action = arguments.length > 1 ? arguments[1]