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