[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/dist/ -> core-data.js (source)

   1  this["wp"] = this["wp"] || {}; this["wp"]["coreData"] =
   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 = 350);
  86  /******/ })
  87  /************************************************************************/
  88  /******/ ({
  89  
  90  /***/ 134:
  91  /***/ (function(module, exports) {
  92  
  93  module.exports = function(originalModule) {
  94      if (!originalModule.webpackPolyfill) {
  95          var module = Object.create(originalModule);
  96          // module.parent = undefined by default
  97          if (!module.children) module.children = [];
  98          Object.defineProperty(module, "loaded", {
  99              enumerable: true,
 100              get: function() {
 101                  return module.l;
 102              }
 103          });
 104          Object.defineProperty(module, "id", {
 105              enumerable: true,
 106              get: function() {
 107                  return module.i;
 108              }
 109          });
 110          Object.defineProperty(module, "exports", {
 111              enumerable: true
 112          });
 113          module.webpackPolyfill = 1;
 114      }
 115      return module;
 116  };
 117  
 118  
 119  /***/ }),
 120  
 121  /***/ 15:
 122  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 123  
 124  "use strict";
 125  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; });
 126  function _defineProperty(obj, key, value) {
 127    if (key in obj) {
 128      Object.defineProperty(obj, key, {
 129        value: value,
 130        enumerable: true,
 131        configurable: true,
 132        writable: true
 133      });
 134    } else {
 135      obj[key] = value;
 136    }
 137  
 138    return obj;
 139  }
 140  
 141  /***/ }),
 142  
 143  /***/ 17:
 144  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 145  
 146  "use strict";
 147  
 148  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
 149  function _arrayWithoutHoles(arr) {
 150    if (Array.isArray(arr)) {
 151      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
 152        arr2[i] = arr[i];
 153      }
 154  
 155      return arr2;
 156    }
 157  }
 158  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
 159  var iterableToArray = __webpack_require__(34);
 160  
 161  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
 162  function _nonIterableSpread() {
 163    throw new TypeError("Invalid attempt to spread non-iterable instance");
 164  }
 165  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
 166  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _toConsumableArray; });
 167  
 168  
 169  
 170  function _toConsumableArray(arr) {
 171    return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || _nonIterableSpread();
 172  }
 173  
 174  /***/ }),
 175  
 176  /***/ 2:
 177  /***/ (function(module, exports) {
 178  
 179  (function() { module.exports = this["lodash"]; }());
 180  
 181  /***/ }),
 182  
 183  /***/ 23:
 184  /***/ (function(module, exports, __webpack_require__) {
 185  
 186  module.exports = __webpack_require__(54);
 187  
 188  
 189  /***/ }),
 190  
 191  /***/ 25:
 192  /***/ (function(module, exports) {
 193  
 194  (function() { module.exports = this["wp"]["url"]; }());
 195  
 196  /***/ }),
 197  
 198  /***/ 28:
 199  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 200  
 201  "use strict";
 202  
 203  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
 204  var arrayWithHoles = __webpack_require__(37);
 205  
 206  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
 207  function _iterableToArrayLimit(arr, i) {
 208    var _arr = [];
 209    var _n = true;
 210    var _d = false;
 211    var _e = undefined;
 212  
 213    try {
 214      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
 215        _arr.push(_s.value);
 216  
 217        if (i && _arr.length === i) break;
 218      }
 219    } catch (err) {
 220      _d = true;
 221      _e = err;
 222    } finally {
 223      try {
 224        if (!_n && _i["return"] != null) _i["return"]();
 225      } finally {
 226        if (_d) throw _e;
 227      }
 228    }
 229  
 230    return _arr;
 231  }
 232  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
 233  var nonIterableRest = __webpack_require__(38);
 234  
 235  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
 236  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _slicedToArray; });
 237  
 238  
 239  
 240  function _slicedToArray(arr, i) {
 241    return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(nonIterableRest["a" /* default */])();
 242  }
 243  
 244  /***/ }),
 245  
 246  /***/ 30:
 247  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 248  
 249  "use strict";
 250  
 251  
 252  var LEAF_KEY, hasWeakMap;
 253  
 254  /**
 255   * Arbitrary value used as key for referencing cache object in WeakMap tree.
 256   *
 257   * @type {Object}
 258   */
 259  LEAF_KEY = {};
 260  
 261  /**
 262   * Whether environment supports WeakMap.
 263   *
 264   * @type {boolean}
 265   */
 266  hasWeakMap = typeof WeakMap !== 'undefined';
 267  
 268  /**
 269   * Returns the first argument as the sole entry in an array.
 270   *
 271   * @param {*} value Value to return.
 272   *
 273   * @return {Array} Value returned as entry in array.
 274   */
 275  function arrayOf( value ) {
 276      return [ value ];
 277  }
 278  
 279  /**
 280   * Returns true if the value passed is object-like, or false otherwise. A value
 281   * is object-like if it can support property assignment, e.g. object or array.
 282   *
 283   * @param {*} value Value to test.
 284   *
 285   * @return {boolean} Whether value is object-like.
 286   */
 287  function isObjectLike( value ) {
 288      return !! value && 'object' === typeof value;
 289  }
 290  
 291  /**
 292   * Creates and returns a new cache object.
 293   *
 294   * @return {Object} Cache object.
 295   */
 296  function createCache() {
 297      var cache = {
 298          clear: function() {
 299              cache.head = null;
 300          },
 301      };
 302  
 303      return cache;
 304  }
 305  
 306  /**
 307   * Returns true if entries within the two arrays are strictly equal by
 308   * reference from a starting index.
 309   *
 310   * @param {Array}  a         First array.
 311   * @param {Array}  b         Second array.
 312   * @param {number} fromIndex Index from which to start comparison.
 313   *
 314   * @return {boolean} Whether arrays are shallowly equal.
 315   */
 316  function isShallowEqual( a, b, fromIndex ) {
 317      var i;
 318  
 319      if ( a.length !== b.length ) {
 320          return false;
 321      }
 322  
 323      for ( i = fromIndex; i < a.length; i++ ) {
 324          if ( a[ i ] !== b[ i ] ) {
 325              return false;
 326          }
 327      }
 328  
 329      return true;
 330  }
 331  
 332  /**
 333   * Returns a memoized selector function. The getDependants function argument is
 334   * called before the memoized selector and is expected to return an immutable
 335   * reference or array of references on which the selector depends for computing
 336   * its own return value. The memoize cache is preserved only as long as those
 337   * dependant references remain the same. If getDependants returns a different
 338   * reference(s), the cache is cleared and the selector value regenerated.
 339   *
 340   * @param {Function} selector      Selector function.
 341   * @param {Function} getDependants Dependant getter returning an immutable
 342   *                                 reference or array of reference used in
 343   *                                 cache bust consideration.
 344   *
 345   * @return {Function} Memoized selector.
 346   */
 347  /* harmony default export */ __webpack_exports__["a"] = (function( selector, getDependants ) {
 348      var rootCache, getCache;
 349  
 350      // Use object source as dependant if getter not provided
 351      if ( ! getDependants ) {
 352          getDependants = arrayOf;
 353      }
 354  
 355      /**
 356       * Returns the root cache. If WeakMap is supported, this is assigned to the
 357       * root WeakMap cache set, otherwise it is a shared instance of the default
 358       * cache object.
 359       *
 360       * @return {(WeakMap|Object)} Root cache object.
 361       */
 362  	function getRootCache() {
 363          return rootCache;
 364      }
 365  
 366      /**
 367       * Returns the cache for a given dependants array. When possible, a WeakMap
 368       * will be used to create a unique cache for each set of dependants. This
 369       * is feasible due to the nature of WeakMap in allowing garbage collection
 370       * to occur on entries where the key object is no longer referenced. Since
 371       * WeakMap requires the key to be an object, this is only possible when the
 372       * dependant is object-like. The root cache is created as a hierarchy where
 373       * each top-level key is the first entry in a dependants set, the value a
 374       * WeakMap where each key is the next dependant, and so on. This continues
 375       * so long as the dependants are object-like. If no dependants are object-
 376       * like, then the cache is shared across all invocations.
 377       *
 378       * @see isObjectLike
 379       *
 380       * @param {Array} dependants Selector dependants.
 381       *
 382       * @return {Object} Cache object.
 383       */
 384  	function getWeakMapCache( dependants ) {
 385          var caches = rootCache,
 386              isUniqueByDependants = true,
 387              i, dependant, map, cache;
 388  
 389          for ( i = 0; i < dependants.length; i++ ) {
 390              dependant = dependants[ i ];
 391  
 392              // Can only compose WeakMap from object-like key.
 393              if ( ! isObjectLike( dependant ) ) {
 394                  isUniqueByDependants = false;
 395                  break;
 396              }
 397  
 398              // Does current segment of cache already have a WeakMap?
 399              if ( caches.has( dependant ) ) {
 400                  // Traverse into nested WeakMap.
 401                  caches = caches.get( dependant );
 402              } else {
 403                  // Create, set, and traverse into a new one.
 404                  map = new WeakMap();
 405                  caches.set( dependant, map );
 406                  caches = map;
 407              }
 408          }
 409  
 410          // We use an arbitrary (but consistent) object as key for the last item
 411          // in the WeakMap to serve as our running cache.
 412          if ( ! caches.has( LEAF_KEY ) ) {
 413              cache = createCache();
 414              cache.isUniqueByDependants = isUniqueByDependants;
 415              caches.set( LEAF_KEY, cache );
 416          }
 417  
 418          return caches.get( LEAF_KEY );
 419      }
 420  
 421      // Assign cache handler by availability of WeakMap
 422      getCache = hasWeakMap ? getWeakMapCache : getRootCache;
 423  
 424      /**
 425       * Resets root memoization cache.
 426       */
 427  	function clear() {
 428          rootCache = hasWeakMap ? new WeakMap() : createCache();
 429      }
 430  
 431      // eslint-disable-next-line jsdoc/check-param-names
 432      /**
 433       * The augmented selector call, considering first whether dependants have
 434       * changed before passing it to underlying memoize function.
 435       *
 436       * @param {Object} source    Source object for derivation.
 437       * @param {...*}   extraArgs Additional arguments to pass to selector.
 438       *
 439       * @return {*} Selector result.
 440       */
 441  	function callSelector( /* source, ...extraArgs */ ) {
 442          var len = arguments.length,
 443              cache, node, i, args, dependants;
 444  
 445          // Create copy of arguments (avoid leaking deoptimization).
 446          args = new Array( len );
 447          for ( i = 0; i < len; i++ ) {
 448              args[ i ] = arguments[ i ];
 449          }
 450  
 451          dependants = getDependants.apply( null, args );
 452          cache = getCache( dependants );
 453  
 454          // If not guaranteed uniqueness by dependants (primitive type or lack
 455          // of WeakMap support), shallow compare against last dependants and, if
 456          // references have changed, destroy cache to recalculate result.
 457          if ( ! cache.isUniqueByDependants ) {
 458              if ( cache.lastDependants && ! isShallowEqual( dependants, cache.lastDependants, 0 ) ) {
 459                  cache.clear();
 460              }
 461  
 462              cache.lastDependants = dependants;
 463          }
 464  
 465          node = cache.head;
 466          while ( node ) {
 467              // Check whether node arguments match arguments
 468              if ( ! isShallowEqual( node.args, args, 1 ) ) {
 469                  node = node.next;
 470                  continue;
 471              }
 472  
 473              // At this point we can assume we've found a match
 474  
 475              // Surface matched node to head if not already
 476              if ( node !== cache.head ) {
 477                  // Adjust siblings to point to each other.
 478                  node.prev.next = node.next;
 479                  if ( node.next ) {
 480                      node.next.prev = node.prev;
 481                  }
 482  
 483                  node.next = cache.head;
 484                  node.prev = null;
 485                  cache.head.prev = node;
 486                  cache.head = node;
 487              }
 488  
 489              // Return immediately
 490              return node.val;
 491          }
 492  
 493          // No cached value found. Continue to insertion phase:
 494  
 495          node = {
 496              // Generate the result from original function
 497              val: selector.apply( null, args ),
 498          };
 499  
 500          // Avoid including the source object in the cache.
 501          args[ 0 ] = null;
 502          node.args = args;
 503  
 504          // Don't need to check whether node is already head, since it would
 505          // have been returned above already if it was
 506  
 507          // Shift existing head down list
 508          if ( cache.head ) {
 509              cache.head.prev = node;
 510              node.next = cache.head;
 511          }
 512  
 513          cache.head = node;
 514  
 515          return node.val;
 516      }
 517  
 518      callSelector.getDependants = getDependants;
 519      callSelector.clear = clear;
 520      clear();
 521  
 522      return callSelector;
 523  });
 524  
 525  
 526  /***/ }),
 527  
 528  /***/ 33:
 529  /***/ (function(module, exports) {
 530  
 531  (function() { module.exports = this["wp"]["apiFetch"]; }());
 532  
 533  /***/ }),
 534  
 535  /***/ 34:
 536  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 537  
 538  "use strict";
 539  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; });
 540  function _iterableToArray(iter) {
 541    if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
 542  }
 543  
 544  /***/ }),
 545  
 546  /***/ 350:
 547  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 548  
 549  "use strict";
 550  __webpack_require__.r(__webpack_exports__);
 551  var build_module_actions_namespaceObject = {};
 552  __webpack_require__.r(build_module_actions_namespaceObject);
 553  __webpack_require__.d(build_module_actions_namespaceObject, "receiveUserQuery", function() { return receiveUserQuery; });
 554  __webpack_require__.d(build_module_actions_namespaceObject, "addEntities", function() { return addEntities; });
 555  __webpack_require__.d(build_module_actions_namespaceObject, "receiveEntityRecords", function() { return receiveEntityRecords; });
 556  __webpack_require__.d(build_module_actions_namespaceObject, "receiveThemeSupports", function() { return receiveThemeSupports; });
 557  __webpack_require__.d(build_module_actions_namespaceObject, "receiveEmbedPreview", function() { return receiveEmbedPreview; });
 558  __webpack_require__.d(build_module_actions_namespaceObject, "saveEntityRecord", function() { return saveEntityRecord; });
 559  __webpack_require__.d(build_module_actions_namespaceObject, "receiveUploadPermissions", function() { return receiveUploadPermissions; });
 560  __webpack_require__.d(build_module_actions_namespaceObject, "receiveUserPermission", function() { return receiveUserPermission; });
 561  var build_module_selectors_namespaceObject = {};
 562  __webpack_require__.r(build_module_selectors_namespaceObject);
 563  __webpack_require__.d(build_module_selectors_namespaceObject, "isRequestingEmbedPreview", function() { return isRequestingEmbedPreview; });
 564  __webpack_require__.d(build_module_selectors_namespaceObject, "getAuthors", function() { return getAuthors; });
 565  __webpack_require__.d(build_module_selectors_namespaceObject, "getUserQueryResults", function() { return getUserQueryResults; });
 566  __webpack_require__.d(build_module_selectors_namespaceObject, "getEntitiesByKind", function() { return getEntitiesByKind; });
 567  __webpack_require__.d(build_module_selectors_namespaceObject, "getEntity", function() { return getEntity; });
 568  __webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecord", function() { return getEntityRecord; });
 569  __webpack_require__.d(build_module_selectors_namespaceObject, "getEntityRecords", function() { return getEntityRecords; });
 570  __webpack_require__.d(build_module_selectors_namespaceObject, "getThemeSupports", function() { return getThemeSupports; });
 571  __webpack_require__.d(build_module_selectors_namespaceObject, "getEmbedPreview", function() { return getEmbedPreview; });
 572  __webpack_require__.d(build_module_selectors_namespaceObject, "isPreviewEmbedFallback", function() { return isPreviewEmbedFallback; });
 573  __webpack_require__.d(build_module_selectors_namespaceObject, "hasUploadPermissions", function() { return hasUploadPermissions; });
 574  __webpack_require__.d(build_module_selectors_namespaceObject, "canUser", function() { return canUser; });
 575  var resolvers_namespaceObject = {};
 576  __webpack_require__.r(resolvers_namespaceObject);
 577  __webpack_require__.d(resolvers_namespaceObject, "getAuthors", function() { return resolvers_getAuthors; });
 578  __webpack_require__.d(resolvers_namespaceObject, "getEntityRecord", function() { return resolvers_getEntityRecord; });
 579  __webpack_require__.d(resolvers_namespaceObject, "getEntityRecords", function() { return resolvers_getEntityRecords; });
 580  __webpack_require__.d(resolvers_namespaceObject, "getThemeSupports", function() { return resolvers_getThemeSupports; });
 581  __webpack_require__.d(resolvers_namespaceObject, "getEmbedPreview", function() { return resolvers_getEmbedPreview; });
 582  __webpack_require__.d(resolvers_namespaceObject, "hasUploadPermissions", function() { return resolvers_hasUploadPermissions; });
 583  __webpack_require__.d(resolvers_namespaceObject, "canUser", function() { return resolvers_canUser; });
 584  
 585  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread.js
 586  var objectSpread = __webpack_require__(7);
 587  
 588  // EXTERNAL MODULE: external {"this":["wp","data"]}
 589  var external_this_wp_data_ = __webpack_require__(5);
 590  
 591  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
 592  var slicedToArray = __webpack_require__(28);
 593  
 594  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
 595  var toConsumableArray = __webpack_require__(17);
 596  
 597  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
 598  var defineProperty = __webpack_require__(15);
 599  
 600  // EXTERNAL MODULE: external "lodash"
 601  var external_lodash_ = __webpack_require__(2);
 602  
 603  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/if-matching-action.js
 604  /**
 605   * A higher-order reducer creator which invokes the original reducer only if
 606   * the dispatching action matches the given predicate, **OR** if state is
 607   * initializing (undefined).
 608   *
 609   * @param {Function} isMatch Function predicate for allowing reducer call.
 610   *
 611   * @return {Function} Higher-order reducer.
 612   */
 613  var ifMatchingAction = function ifMatchingAction(isMatch) {
 614    return function (reducer) {
 615      return function (state, action) {
 616        if (state === undefined || isMatch(action)) {
 617          return reducer(state, action);
 618        }
 619  
 620        return state;
 621      };
 622    };
 623  };
 624  
 625  /* harmony default export */ var if_matching_action = (ifMatchingAction);
 626  
 627  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/on-sub-key.js
 628  
 629  
 630  
 631  /**
 632   * Higher-order reducer creator which creates a combined reducer object, keyed
 633   * by a property on the action object.
 634   *
 635   * @param {string} actionProperty Action property by which to key object.
 636   *
 637   * @return {Function} Higher-order reducer.
 638   */
 639  var on_sub_key_onSubKey = function onSubKey(actionProperty) {
 640    return function (reducer) {
 641      return function () {
 642        var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 643        var action = arguments.length > 1 ? arguments[1] : undefined;
 644        // Retrieve subkey from action. Do not track if undefined; useful for cases
 645        // where reducer is scoped by action shape.
 646        var key = action[actionProperty];
 647  
 648        if (key === undefined) {
 649          return state;
 650        } // Avoid updating state if unchanged. Note that this also accounts for a
 651        // reducer which returns undefined on a key which is not yet tracked.
 652  
 653  
 654        var nextKeyState = reducer(state[key], action);
 655  
 656        if (nextKeyState === state[key]) {
 657          return state;
 658        }
 659  
 660        return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, key, nextKeyState));
 661      };
 662    };
 663  };
 664  /* harmony default export */ var on_sub_key = (on_sub_key_onSubKey);
 665  
 666  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/replace-action.js
 667  /**
 668   * Higher-order reducer creator which substitutes the action object before
 669   * passing to the original reducer.
 670   *
 671   * @param {Function} replacer Function mapping original action to replacement.
 672   *
 673   * @return {Function} Higher-order reducer.
 674   */
 675  var replaceAction = function replaceAction(replacer) {
 676    return function (reducer) {
 677      return function (state, action) {
 678        return reducer(state, replacer(action));
 679      };
 680    };
 681  };
 682  
 683  /* harmony default export */ var replace_action = (replaceAction);
 684  
 685  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/with-weak-map-cache.js
 686  /**
 687   * External dependencies
 688   */
 689  
 690  /**
 691   * Given a function, returns an enhanced function which caches the result and
 692   * tracks in WeakMap. The result is only cached if the original function is
 693   * passed a valid object-like argument (requirement for WeakMap key).
 694   *
 695   * @param {Function} fn Original function.
 696   *
 697   * @return {Function} Enhanced caching function.
 698   */
 699  
 700  function withWeakMapCache(fn) {
 701    var cache = new WeakMap();
 702    return function (key) {
 703      var value;
 704  
 705      if (cache.has(key)) {
 706        value = cache.get(key);
 707      } else {
 708        value = fn(key); // Can reach here if key is not valid for WeakMap, since `has`
 709        // will return false for invalid key. Since `set` will throw,
 710        // ensure that key is valid before setting into cache.
 711  
 712        if (Object(external_lodash_["isObjectLike"])(key)) {
 713          cache.set(key, value);
 714        }
 715      }
 716  
 717      return value;
 718    };
 719  }
 720  
 721  /* harmony default export */ var with_weak_map_cache = (withWeakMapCache);
 722  
 723  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/utils/index.js
 724  
 725  
 726  
 727  
 728  
 729  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/actions.js
 730  
 731  
 732  /**
 733   * External dependencies
 734   */
 735  
 736  /**
 737   * Returns an action object used in signalling that items have been received.
 738   *
 739   * @param {Array} items Items received.
 740   *
 741   * @return {Object} Action object.
 742   */
 743  
 744  function receiveItems(items) {
 745    return {
 746      type: 'RECEIVE_ITEMS',
 747      items: Object(external_lodash_["castArray"])(items)
 748    };
 749  }
 750  /**
 751   * Returns an action object used in signalling that queried data has been
 752   * received.
 753   *
 754   * @param {Array}   items Queried items received.
 755   * @param {?Object} query Optional query object.
 756   *
 757   * @return {Object} Action object.
 758   */
 759  
 760  function receiveQueriedItems(items) {
 761    var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 762    return Object(objectSpread["a" /* default */])({}, receiveItems(items), {
 763      query: query
 764    });
 765  }
 766  
 767  // EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js
 768  var rememo = __webpack_require__(30);
 769  
 770  // EXTERNAL MODULE: ./node_modules/equivalent-key-map/equivalent-key-map.js
 771  var equivalent_key_map = __webpack_require__(75);
 772  var equivalent_key_map_default = /*#__PURE__*/__webpack_require__.n(equivalent_key_map);
 773  
 774  // EXTERNAL MODULE: external {"this":["wp","url"]}
 775  var external_this_wp_url_ = __webpack_require__(25);
 776  
 777  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/get-query-parts.js
 778  
 779  
 780  /**
 781   * WordPress dependencies
 782   */
 783  
 784  /**
 785   * Internal dependencies
 786   */
 787  
 788  
 789  /**
 790   * An object of properties describing a specific query.
 791   *
 792   * @typedef {WPQueriedDataQueryParts}
 793   *
 794   * @property {number} page      The query page (1-based index, default 1).
 795   * @property {number} perPage   Items per page for query (default 10).
 796   * @property {string} stableKey An encoded stable string of all non-pagination
 797   *                              query parameters.
 798   */
 799  
 800  /**
 801   * Given a query object, returns an object of parts, including pagination
 802   * details (`page` and `perPage`, or default values). All other properties are
 803   * encoded into a stable (idempotent) `stableKey` value.
 804   *
 805   * @param {Object} query Optional query object.
 806   *
 807   * @return {WPQueriedDataQueryParts} Query parts.
 808   */
 809  
 810  function getQueryParts(query) {
 811    /**
 812     * @type {WPQueriedDataQueryParts}
 813     */
 814    var parts = {
 815      stableKey: '',
 816      page: 1,
 817      perPage: 10
 818    }; // Ensure stable key by sorting keys. Also more efficient for iterating.
 819  
 820    var keys = Object.keys(query).sort();
 821  
 822    for (var i = 0; i < keys.length; i++) {
 823      var key = keys[i];
 824      var value = query[key];
 825  
 826      switch (key) {
 827        case 'page':
 828          parts[key] = Number(value);
 829          break;
 830  
 831        case 'per_page':
 832          parts.perPage = Number(value);
 833          break;
 834  
 835        default:
 836          // While it could be any deterministic string, for simplicity's
 837          // sake mimic querystring encoding for stable key.
 838          //
 839          // TODO: For consistency with PHP implementation, addQueryArgs
 840          // should accept a key value pair, which may optimize its
 841          // implementation for our use here, vs. iterating an object
 842          // with only a single key.
 843          parts.stableKey += (parts.stableKey ? '&' : '') + Object(external_this_wp_url_["addQueryArgs"])('', Object(defineProperty["a" /* default */])({}, key, value)).slice(1);
 844      }
 845    }
 846  
 847    return parts;
 848  }
 849  /* harmony default export */ var get_query_parts = (with_weak_map_cache(getQueryParts));
 850  
 851  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/selectors.js
 852  /**
 853   * External dependencies
 854   */
 855  
 856  
 857  /**
 858   * Internal dependencies
 859   */
 860  
 861  
 862  /**
 863   * Cache of state keys to EquivalentKeyMap where the inner map tracks queries
 864   * to their resulting items set. WeakMap allows garbage collection on expired
 865   * state references.
 866   *
 867   * @type {WeakMap<Object,EquivalentKeyMap>}
 868   */
 869  
 870  var queriedItemsCacheByState = new WeakMap();
 871  /**
 872   * Returns items for a given query, or null if the items are not known.
 873   *
 874   * @param {Object}  state State object.
 875   * @param {?Object} query Optional query.
 876   *
 877   * @return {?Array} Query items.
 878   */
 879  
 880  function getQueriedItemsUncached(state, query) {
 881    var _getQueryParts = get_query_parts(query),
 882        stableKey = _getQueryParts.stableKey,
 883        page = _getQueryParts.page,
 884        perPage = _getQueryParts.perPage;
 885  
 886    if (!state.queries[stableKey]) {
 887      return null;
 888    }
 889  
 890    var itemIds = state.queries[stableKey];
 891  
 892    if (!itemIds) {
 893      return null;
 894    }
 895  
 896    var startOffset = perPage === -1 ? 0 : (page - 1) * perPage;
 897    var endOffset = perPage === -1 ? itemIds.length : Math.min(startOffset + perPage, itemIds.length);
 898    var items = [];
 899  
 900    for (var i = startOffset; i < endOffset; i++) {
 901      var itemId = itemIds[i];
 902      items.push(state.items[itemId]);
 903    }
 904  
 905    return items;
 906  }
 907  /**
 908   * Returns items for a given query, or null if the items are not known. Caches
 909   * result both per state (by reference) and per query (by deep equality).
 910   * The caching approach is intended to be durable to query objects which are
 911   * deeply but not referentially equal, since otherwise:
 912   *
 913   * `getQueriedItems( state, {} ) !== getQueriedItems( state, {} )`
 914   *
 915   * @param {Object}  state State object.
 916   * @param {?Object} query Optional query.
 917   *
 918   * @return {?Array} Query items.
 919   */
 920  
 921  
 922  var getQueriedItems = Object(rememo["a" /* default */])(function (state) {
 923    var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 924    var queriedItemsCache = queriedItemsCacheByState.get(state);
 925  
 926    if (queriedItemsCache) {
 927      var queriedItems = queriedItemsCache.get(query);
 928  
 929      if (queriedItems !== undefined) {
 930        return queriedItems;
 931      }
 932    } else {
 933      queriedItemsCache = new equivalent_key_map_default.a();
 934      queriedItemsCacheByState.set(state, queriedItemsCache);
 935    }
 936  
 937    var items = getQueriedItemsUncached(state, query);
 938    queriedItemsCache.set(query, items);
 939    return items;
 940  });
 941  
 942  // EXTERNAL MODULE: ./node_modules/redux/es/redux.js
 943  var redux = __webpack_require__(71);
 944  
 945  // EXTERNAL MODULE: ./node_modules/@babel/runtime/regenerator/index.js
 946  var regenerator = __webpack_require__(23);
 947  var regenerator_default = /*#__PURE__*/__webpack_require__.n(regenerator);
 948  
 949  // EXTERNAL MODULE: external {"this":["wp","apiFetch"]}
 950  var external_this_wp_apiFetch_ = __webpack_require__(33);
 951  var external_this_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_apiFetch_);
 952  
 953  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/controls.js
 954  
 955  
 956  /**
 957   * WordPress dependencies
 958   */
 959  
 960  
 961  /**
 962   * Trigger an API Fetch request.
 963   *
 964   * @param {Object} request API Fetch Request Object.
 965   * @return {Object} control descriptor.
 966   */
 967  
 968  function apiFetch(request) {
 969    return {
 970      type: 'API_FETCH',
 971      request: request
 972    };
 973  }
 974  /**
 975   * Calls a selector using the current state.
 976   * @param {string} selectorName Selector name.
 977   * @param  {Array} args         Selector arguments.
 978   *
 979   * @return {Object} control descriptor.
 980   */
 981  
 982  function controls_select(selectorName) {
 983    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
 984      args[_key - 1] = arguments[_key];
 985    }
 986  
 987    return {
 988      type: 'SELECT',
 989      selectorName: selectorName,
 990      args: args
 991    };
 992  }
 993  var controls = {
 994    API_FETCH: function API_FETCH(_ref) {
 995      var request = _ref.request;
 996      return external_this_wp_apiFetch_default()(request);
 997    },
 998    SELECT: Object(external_this_wp_data_["createRegistryControl"])(function (registry) {
 999      return function (_ref2) {
1000        var _registry$select;
1001  
1002        var selectorName = _ref2.selectorName,
1003            args = _ref2.args;
1004        return (_registry$select = registry.select('core'))[selectorName].apply(_registry$select, Object(toConsumableArray["a" /* default */])(args));
1005      };
1006    })
1007  };
1008  /* harmony default export */ var build_module_controls = (controls);
1009  
1010  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/actions.js
1011  
1012  
1013  
1014  var _marked =
1015  /*#__PURE__*/
1016  regenerator_default.a.mark(saveEntityRecord);
1017  
1018  /**
1019   * External dependencies
1020   */
1021  
1022  /**
1023   * Internal dependencies
1024   */
1025  
1026  
1027  
1028  
1029  /**
1030   * Returns an action object used in signalling that authors have been received.
1031   *
1032   * @param {string}       queryID Query ID.
1033   * @param {Array|Object} users   Users received.
1034   *
1035   * @return {Object} Action object.
1036   */
1037  
1038  function receiveUserQuery(queryID, users) {
1039    return {
1040      type: 'RECEIVE_USER_QUERY',
1041      users: Object(external_lodash_["castArray"])(users),
1042      queryID: queryID
1043    };
1044  }
1045  /**
1046   * Returns an action object used in adding new entities.
1047   *
1048   * @param {Array} entities  Entities received.
1049   *
1050   * @return {Object} Action object.
1051   */
1052  
1053  function addEntities(entities) {
1054    return {
1055      type: 'ADD_ENTITIES',
1056      entities: entities
1057    };
1058  }
1059  /**
1060   * Returns an action object used in signalling that entity records have been received.
1061   *
1062   * @param {string}       kind            Kind of the received entity.
1063   * @param {string}       name            Name of the received entity.
1064   * @param {Array|Object} records         Records received.
1065   * @param {?Object}      query           Query Object.
1066   * @param {?boolean}     invalidateCache Should invalidate query caches
1067   *
1068   * @return {Object} Action object.
1069   */
1070  
1071  function receiveEntityRecords(kind, name, records, query) {
1072    var invalidateCache = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
1073    var action;
1074  
1075    if (query) {
1076      action = receiveQueriedItems(records, query);
1077    } else {
1078      action = receiveItems(records);
1079    }
1080  
1081    return Object(objectSpread["a" /* default */])({}, action, {
1082      kind: kind,
1083      name: name,
1084      invalidateCache: invalidateCache
1085    });
1086  }
1087  /**
1088   * Returns an action object used in signalling that the index has been received.
1089   *
1090   * @param {Object} themeSupports Theme support for the current theme.
1091   *
1092   * @return {Object} Action object.
1093   */
1094  
1095  function receiveThemeSupports(themeSupports) {
1096    return {
1097      type: 'RECEIVE_THEME_SUPPORTS',
1098      themeSupports: themeSupports
1099    };
1100  }
1101  /**
1102   * Returns an action object used in signalling that the preview data for
1103   * a given URl has been received.
1104   *
1105   * @param {string}  url      URL to preview the embed for.
1106   * @param {Mixed}   preview  Preview data.
1107   *
1108   * @return {Object} Action object.
1109   */
1110  
1111  function receiveEmbedPreview(url, preview) {
1112    return {
1113      type: 'RECEIVE_EMBED_PREVIEW',
1114      url: url,
1115      preview: preview
1116    };
1117  }
1118  /**
1119   * Action triggered to save an entity record.
1120   *
1121   * @param {string} kind    Kind of the received entity.
1122   * @param {string} name    Name of the received entity.
1123   * @param {Object} record  Record to be saved.
1124   *
1125   * @return {Object} Updated record.
1126   */
1127  
1128  function saveEntityRecord(kind, name, record) {
1129    var entities, entity, key, recordId, updatedRecord;
1130    return regenerator_default.a.wrap(function saveEntityRecord$(_context) {
1131      while (1) {
1132        switch (_context.prev = _context.next) {
1133          case 0:
1134            _context.next = 2;
1135            return getKindEntities(kind);
1136  
1137          case 2:
1138            entities = _context.sent;
1139            entity = Object(external_lodash_["find"])(entities, {
1140              kind: kind,
1141              name: name
1142            });
1143  
1144            if (entity) {
1145              _context.next = 6;
1146              break;
1147            }
1148  
1149            return _context.abrupt("return");
1150  
1151          case 6:
1152            key = entity.key || DEFAULT_ENTITY_KEY;
1153            recordId = record[key];
1154            _context.next = 10;
1155            return apiFetch({
1156              path: "".concat(entity.baseURL).concat(recordId ? '/' + recordId : ''),
1157              method: recordId ? 'PUT' : 'POST',
1158              data: record
1159            });
1160  
1161          case 10:
1162            updatedRecord = _context.sent;
1163            _context.next = 13;
1164            return receiveEntityRecords(kind, name, updatedRecord, undefined, true);
1165  
1166          case 13:
1167            return _context.abrupt("return", updatedRecord);
1168  
1169          case 14:
1170          case "end":
1171            return _context.stop();
1172        }
1173      }
1174    }, _marked, this);
1175  }
1176  /**
1177   * Returns an action object used in signalling that Upload permissions have been received.
1178   *
1179   * @param {boolean} hasUploadPermissions Does the user have permission to upload files?
1180   *
1181   * @return {Object} Action object.
1182   */
1183  
1184  function receiveUploadPermissions(hasUploadPermissions) {
1185    return {
1186      type: 'RECEIVE_USER_PERMISSION',
1187      key: 'create/media',
1188      isAllowed: hasUploadPermissions
1189    };
1190  }
1191  /**
1192   * Returns an action object used in signalling that the current user has
1193   * permission to perform an action on a REST resource.
1194   *
1195   * @param {string}  key       A key that represents the action and REST resource.
1196   * @param {boolean} isAllowed Whether or not the user can perform the action.
1197   *
1198   * @return {Object} Action object.
1199   */
1200  
1201  function receiveUserPermission(key, isAllowed) {
1202    return {
1203      type: 'RECEIVE_USER_PERMISSION',
1204      key: key,
1205      isAllowed: isAllowed
1206    };
1207  }
1208  
1209  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/entities.js
1210  
1211  
1212  var entities_marked =
1213  /*#__PURE__*/
1214  regenerator_default.a.mark(loadPostTypeEntities),
1215      _marked2 =
1216  /*#__PURE__*/
1217  regenerator_default.a.mark(loadTaxonomyEntities),
1218      _marked3 =
1219  /*#__PURE__*/
1220  regenerator_default.a.mark(getKindEntities);
1221  
1222  /**
1223   * External dependencies
1224   */
1225  
1226  /**
1227   * Internal dependencies
1228   */
1229  
1230  
1231  
1232  var DEFAULT_ENTITY_KEY = 'id';
1233  var defaultEntities = [{
1234    name: 'postType',
1235    kind: 'root',
1236    key: 'slug',
1237    baseURL: '/wp/v2/types'
1238  }, {
1239    name: 'media',
1240    kind: 'root',
1241    baseURL: '/wp/v2/media',
1242    plural: 'mediaItems'
1243  }, {
1244    name: 'taxonomy',
1245    kind: 'root',
1246    key: 'slug',
1247    baseURL: '/wp/v2/taxonomies',
1248    plural: 'taxonomies'
1249  }];
1250  var kinds = [{
1251    name: 'postType',
1252    loadEntities: loadPostTypeEntities
1253  }, {
1254    name: 'taxonomy',
1255    loadEntities: loadTaxonomyEntities
1256  }];
1257  /**
1258   * Returns the list of post type entities.
1259   *
1260   * @return {Promise} Entities promise
1261   */
1262  
1263  function loadPostTypeEntities() {
1264    var postTypes;
1265    return regenerator_default.a.wrap(function loadPostTypeEntities$(_context) {
1266      while (1) {
1267        switch (_context.prev = _context.next) {
1268          case 0:
1269            _context.next = 2;
1270            return apiFetch({
1271              path: '/wp/v2/types?context=edit'
1272            });
1273  
1274          case 2:
1275            postTypes = _context.sent;
1276            return _context.abrupt("return", Object(external_lodash_["map"])(postTypes, function (postType, name) {
1277              return {
1278                kind: 'postType',
1279                baseURL: '/wp/v2/' + postType.rest_base,
1280                name: name
1281              };
1282            }));
1283  
1284          case 4:
1285          case "end":
1286            return _context.stop();
1287        }
1288      }
1289    }, entities_marked, this);
1290  }
1291  /**
1292   * Returns the list of the taxonomies entities.
1293   *
1294   * @return {Promise} Entities promise
1295   */
1296  
1297  
1298  function loadTaxonomyEntities() {
1299    var taxonomies;
1300    return regenerator_default.a.wrap(function loadTaxonomyEntities$(_context2) {
1301      while (1) {
1302        switch (_context2.prev = _context2.next) {
1303          case 0:
1304            _context2.next = 2;
1305            return apiFetch({
1306              path: '/wp/v2/taxonomies?context=edit'
1307            });
1308  
1309          case 2:
1310            taxonomies = _context2.sent;
1311            return _context2.abrupt("return", Object(external_lodash_["map"])(taxonomies, function (taxonomy, name) {
1312              return {
1313                kind: 'taxonomy',
1314                baseURL: '/wp/v2/' + taxonomy.rest_base,
1315                name: name
1316              };
1317            }));
1318  
1319          case 4:
1320          case "end":
1321            return _context2.stop();
1322        }
1323      }
1324    }, _marked2, this);
1325  }
1326  /**
1327   * Returns the entity's getter method name given its kind and name.
1328   *
1329   * @param {string}  kind      Entity kind.
1330   * @param {string}  name      Entity name.
1331   * @param {string}  prefix    Function prefix.
1332   * @param {boolean} usePlural Whether to use the plural form or not.
1333   *
1334   * @return {string} Method name
1335   */
1336  
1337  
1338  var entities_getMethodName = function getMethodName(kind, name) {
1339    var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'get';
1340    var usePlural = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
1341    var entity = Object(external_lodash_["find"])(defaultEntities, {
1342      kind: kind,
1343      name: name
1344    });
1345    var kindPrefix = kind === 'root' ? '' : Object(external_lodash_["upperFirst"])(Object(external_lodash_["camelCase"])(kind));
1346    var nameSuffix = Object(external_lodash_["upperFirst"])(Object(external_lodash_["camelCase"])(name)) + (usePlural ? 's' : '');
1347    var suffix = usePlural && entity.plural ? Object(external_lodash_["upperFirst"])(Object(external_lodash_["camelCase"])(entity.plural)) : nameSuffix;
1348    return "".concat(prefix).concat(kindPrefix).concat(suffix);
1349  };
1350  /**
1351   * Loads the kind entities into the store.
1352   *
1353   * @param {string} kind  Kind
1354   *
1355   * @return {Array} Entities
1356   */
1357  
1358  function getKindEntities(kind) {
1359    var entities, kindConfig;
1360    return regenerator_default.a.wrap(function getKindEntities$(_context3) {
1361      while (1) {
1362        switch (_context3.prev = _context3.next) {
1363          case 0:
1364            _context3.next = 2;
1365            return controls_select('getEntitiesByKind', kind);
1366  
1367          case 2:
1368            entities = _context3.sent;
1369  
1370            if (!(entities && entities.length !== 0)) {
1371              _context3.next = 5;
1372              break;
1373            }
1374  
1375            return _context3.abrupt("return", entities);
1376  
1377          case 5:
1378            kindConfig = Object(external_lodash_["find"])(kinds, {
1379              name: kind
1380            });
1381  
1382            if (kindConfig) {
1383              _context3.next = 8;
1384              break;
1385            }
1386  
1387            return _context3.abrupt("return", []);
1388  
1389          case 8:
1390            _context3.next = 10;
1391            return kindConfig.loadEntities();
1392  
1393          case 10:
1394            entities = _context3.sent;
1395            _context3.next = 13;
1396            return addEntities(entities);
1397  
1398          case 13:
1399            return _context3.abrupt("return", entities);
1400  
1401          case 14:
1402          case "end":
1403            return _context3.stop();
1404        }
1405      }
1406    }, _marked3, this);
1407  }
1408  
1409  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/reducer.js
1410  
1411  
1412  /**
1413   * External dependencies
1414   */
1415  
1416  
1417  /**
1418   * Internal dependencies
1419   */
1420  
1421  
1422  
1423  
1424  /**
1425   * Returns a merged array of item IDs, given details of the received paginated
1426   * items. The array is sparse-like with `undefined` entries where holes exist.
1427   *
1428   * @param {?Array<number>} itemIds     Original item IDs (default empty array).
1429   * @param {number[]}       nextItemIds Item IDs to merge.
1430   * @param {number}         page        Page of items merged.
1431   * @param {number}         perPage     Number of items per page.
1432   *
1433   * @return {number[]} Merged array of item IDs.
1434   */
1435  
1436  function getMergedItemIds(itemIds, nextItemIds, page, perPage) {
1437    var nextItemIdsStartIndex = (page - 1) * perPage; // If later page has already been received, default to the larger known
1438    // size of the existing array, else calculate as extending the existing.
1439  
1440    var size = Math.max(itemIds.length, nextItemIdsStartIndex + nextItemIds.length); // Preallocate array since size is known.
1441  
1442    var mergedItemIds = new Array(size);
1443  
1444    for (var i = 0; i < size; i++) {
1445      // Preserve existing item ID except for subset of range of next items.
1446      var isInNextItemsRange = i >= nextItemIdsStartIndex && i < nextItemIdsStartIndex + nextItemIds.length;
1447      mergedItemIds[i] = isInNextItemsRange ? nextItemIds[i - nextItemIdsStartIndex] : itemIds[i];
1448    }
1449  
1450    return mergedItemIds;
1451  }
1452  /**
1453   * Reducer tracking items state, keyed by ID. Items are assumed to be normal,
1454   * where identifiers are common across all queries.
1455   *
1456   * @param {Object} state  Current state.
1457   * @param {Object} action Dispatched action.
1458   *
1459   * @return {Object} Next state.
1460   */
1461  
1462  function reducer_items() {
1463    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
1464    var action = arguments.length > 1 ? arguments[1] : undefined;
1465  
1466    switch (action.type) {
1467      case 'RECEIVE_ITEMS':
1468        return Object(objectSpread["a" /* default */])({}, state, Object(external_lodash_["keyBy"])(action.items, action.key || DEFAULT_ENTITY_KEY));
1469    }
1470  
1471    return state;
1472  }
1473  /**
1474   * Reducer tracking queries state, keyed by stable query key. Each reducer
1475   * query object includes `itemIds` and `requestingPageByPerPage`.
1476   *
1477   * @param {Object} state  Current state.
1478   * @param {Object} action Dispatched action.
1479   *
1480   * @return {Object} Next state.
1481   */
1482  
1483  
1484  var queries = Object(external_lodash_["flowRight"])([// Limit to matching action type so we don't attempt to replace action on
1485  // an unhandled action.
1486  if_matching_action(function (action) {
1487    return 'query' in action;
1488  }), // Inject query parts into action for use both in `onSubKey` and reducer.
1489  replace_action(function (action) {
1490    // `ifMatchingAction` still passes on initialization, where state is
1491    // undefined and a query is not assigned. Avoid attempting to parse
1492    // parts. `onSubKey` will omit by lack of `stableKey`.
1493    if (action.query) {
1494      return Object(objectSpread["a" /* default */])({}, action, get_query_parts(action.query));
1495    }
1496  
1497    return action;
1498  }), // Queries shape is shared, but keyed by query `stableKey` part. Original
1499  // reducer tracks only a single query object.
1500  on_sub_key('stableKey')])(function () {
1501    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
1502    var action = arguments.length > 1 ? arguments[1] : undefined;
1503    var type = action.type,
1504        page = action.page,
1505        perPage = action.perPage,
1506        _action$key = action.key,
1507        key = _action$key === void 0 ? DEFAULT_ENTITY_KEY : _action$key;
1508  
1509    if (type !== 'RECEIVE_ITEMS') {
1510      return state;
1511    }
1512  
1513    return getMergedItemIds(state || [], Object(external_lodash_["map"])(action.items, key), page, perPage);
1514  });
1515  /* harmony default export */ var queried_data_reducer = (Object(redux["b" /* combineReducers */])({
1516    items: reducer_items,
1517    queries: queries
1518  }));
1519  
1520  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/index.js
1521  
1522  
1523  
1524  
1525  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/reducer.js
1526  
1527  
1528  
1529  
1530  
1531  /**
1532   * External dependencies
1533   */
1534  
1535  /**
1536   * WordPress dependencies
1537   */
1538  
1539  
1540  /**
1541   * Internal dependencies
1542   */
1543  
1544  
1545  
1546  
1547  /**
1548   * Reducer managing terms state. Keyed by taxonomy slug, the value is either
1549   * undefined (if no request has been made for given taxonomy), null (if a
1550   * request is in-flight for given taxonomy), or the array of terms for the
1551   * taxonomy.
1552   *
1553   * @param {Object} state  Current state.
1554   * @param {Object} action Dispatched action.
1555   *
1556   * @return {Object} Updated state.
1557   */
1558  
1559  function terms() {
1560    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
1561    var action = arguments.length > 1 ? arguments[1] : undefined;
1562  
1563    switch (action.type) {
1564      case 'RECEIVE_TERMS':
1565        return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, action.taxonomy, action.terms));
1566    }
1567  
1568    return state;
1569  }
1570  /**
1571   * Reducer managing authors state. Keyed by id.
1572   *
1573   * @param {Object} state  Current state.
1574   * @param {Object} action Dispatched action.
1575   *
1576   * @return {Object} Updated state.
1577   */
1578  
1579  function reducer_users() {
1580    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
1581      byId: {},
1582      queries: {}
1583    };
1584    var action = arguments.length > 1 ? arguments[1] : undefined;
1585  
1586    switch (action.type) {
1587      case 'RECEIVE_USER_QUERY':
1588        return {
1589          byId: Object(objectSpread["a" /* default */])({}, state.byId, Object(external_lodash_["keyBy"])(action.users, 'id')),
1590          queries: Object(objectSpread["a" /* default */])({}, state.queries, Object(defineProperty["a" /* default */])({}, action.queryID, Object(external_lodash_["map"])(action.users, function (user) {
1591            return user.id;
1592          })))
1593        };
1594    }
1595  
1596    return state;
1597  }
1598  /**
1599   * Reducer managing taxonomies.
1600   *
1601   * @param {Object} state  Current state.
1602   * @param {Object} action Dispatched action.
1603   *
1604   * @return {Object} Updated state.
1605   */
1606  
1607  function reducer_taxonomies() {
1608    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
1609    var action = arguments.length > 1 ? arguments[1] : undefined;
1610  
1611    switch (action.type) {
1612      case 'RECEIVE_TAXONOMIES':
1613        return action.taxonomies;
1614    }
1615  
1616    return state;
1617  }
1618  /**
1619   * Reducer managing theme supports data.
1620   *
1621   * @param {Object} state  Current state.
1622   * @param {Object} action Dispatched action.
1623   *
1624   * @return {Object} Updated state.
1625   */
1626  
1627  function themeSupports() {
1628    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
1629    var action = arguments.length > 1 ? arguments[1] : undefined;
1630  
1631    switch (action.type) {
1632      case 'RECEIVE_THEME_SUPPORTS':
1633        return Object(objectSpread["a" /* default */])({}, state, action.themeSupports);
1634    }
1635  
1636    return state;
1637  }
1638  /**
1639   * Higher Order Reducer for a given entity config. It supports:
1640   *
1641   *  - Fetching a record by primary key
1642   *
1643   * @param {Object} entityConfig  Entity config.
1644   *
1645   * @return {Function} Reducer.
1646   */
1647  
1648  function reducer_entity(entityConfig) {
1649    return Object(external_lodash_["flowRight"])([// Limit to matching action type so we don't attempt to replace action on
1650    // an unhandled action.
1651    if_matching_action(function (action) {
1652      return action.name && action.kind && action.name === entityConfig.name && action.kind === entityConfig.kind;
1653    }), // Inject the entity config into the action.
1654    replace_action(function (action) {
1655      return Object(objectSpread["a" /* default */])({}, action, {
1656        key: entityConfig.key || DEFAULT_ENTITY_KEY
1657      });
1658    })])(queried_data_reducer);
1659  }
1660  /**
1661   * Reducer keeping track of the registered entities.
1662   *
1663   * @param {Object} state  Current state.
1664   * @param {Object} action Dispatched action.
1665   *
1666   * @return {Object} Updated state.
1667   */
1668  
1669  
1670  function entitiesConfig() {
1671    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultEntities;
1672    var action = arguments.length > 1 ? arguments[1] : undefined;
1673  
1674    switch (action.type) {
1675      case 'ADD_ENTITIES':
1676        return [].concat(Object(toConsumableArray["a" /* default */])(state), Object(toConsumableArray["a" /* default */])(action.entities));
1677    }
1678  
1679    return state;
1680  }
1681  /**
1682   * Reducer keeping track of the registered entities config and data.
1683   *
1684   * @param {Object} state  Current state.
1685   * @param {Object} action Dispatched action.
1686   *
1687   * @return {Object} Updated state.
1688   */
1689  
1690  var reducer_entities = function entities() {
1691    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
1692    var action = arguments.length > 1 ? arguments[1] : undefined;
1693    var newConfig = entitiesConfig(state.config, action); // Generates a dynamic reducer for the entities
1694  
1695    var entitiesDataReducer = state.reducer;
1696  
1697    if (!entitiesDataReducer || newConfig !== state.config) {
1698      var entitiesByKind = Object(external_lodash_["groupBy"])(newConfig, 'kind');
1699      entitiesDataReducer = Object(external_this_wp_data_["combineReducers"])(Object.entries(entitiesByKind).reduce(function (memo, _ref) {
1700        var _ref2 = Object(slicedToArray["a" /* default */])(_ref, 2),
1701            kind = _ref2[0],
1702            subEntities = _ref2[1];
1703  
1704        var kindReducer = Object(external_this_wp_data_["combineReducers"])(subEntities.reduce(function (kindMemo, entityConfig) {
1705          return Object(objectSpread["a" /* default */])({}, kindMemo, Object(defineProperty["a" /* default */])({}, entityConfig.name, reducer_entity(entityConfig)));
1706        }, {}));
1707        memo[kind] = kindReducer;
1708        return memo;
1709      }, {}));
1710    }
1711  
1712    var newData = entitiesDataReducer(state.data, action);
1713  
1714    if (newData === state.data && newConfig === state.config && entitiesDataReducer === state.reducer) {
1715      return state;
1716    }
1717  
1718    return {
1719      reducer: entitiesDataReducer,
1720      data: newData,
1721      config: newConfig
1722    };
1723  };
1724  /**
1725   * Reducer managing embed preview data.
1726   *
1727   * @param {Object} state  Current state.
1728   * @param {Object} action Dispatched action.
1729   *
1730   * @return {Object} Updated state.
1731   */
1732  
1733  function embedPreviews() {
1734    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
1735    var action = arguments.length > 1 ? arguments[1] : undefined;
1736  
1737    switch (action.type) {
1738      case 'RECEIVE_EMBED_PREVIEW':
1739        var url = action.url,
1740            preview = action.preview;
1741        return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, url, preview));
1742    }
1743  
1744    return state;
1745  }
1746  /**
1747   * State which tracks whether the user can perform an action on a REST
1748   * resource.
1749   *
1750   * @param  {Object} state  Current state.
1751   * @param  {Object} action Dispatched action.
1752   *
1753   * @return {Object} Updated state.
1754   */
1755  
1756  function userPermissions() {
1757    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
1758    var action = arguments.length > 1 ? arguments[1] : undefined;
1759  
1760    switch (action.type) {
1761      case 'RECEIVE_USER_PERMISSION':
1762        return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, action.key, action.isAllowed));
1763    }
1764  
1765    return state;
1766  }
1767  /* harmony default export */ var build_module_reducer = (Object(external_this_wp_data_["combineReducers"])({
1768    terms: terms,
1769    users: reducer_users,
1770    taxonomies: reducer_taxonomies,
1771    themeSupports: themeSupports,
1772    entities: reducer_entities,
1773    embedPreviews: embedPreviews,
1774    userPermissions: userPermissions
1775  }));
1776  
1777  // EXTERNAL MODULE: external {"this":["wp","deprecated"]}
1778  var external_this_wp_deprecated_ = __webpack_require__(49);
1779  var external_this_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_deprecated_);
1780  
1781  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/name.js
1782  /**
1783   * The reducer key used by core data in store registration.
1784   * This is defined in a separate file to avoid cycle-dependency
1785   *
1786   * @type {string}
1787   */
1788  var REDUCER_KEY = 'core';
1789  
1790  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/selectors.js
1791  /**
1792   * External dependencies
1793   */
1794  
1795  
1796  /**
1797   * WordPress dependencies
1798   */
1799  
1800  
1801  
1802  /**
1803   * Internal dependencies
1804   */
1805  
1806  
1807  
1808  /**
1809   * Returns true if a request is in progress for embed preview data, or false
1810   * otherwise.
1811   *
1812   * @param {Object} state Data state.
1813   * @param {string} url   URL the preview would be for.
1814   *
1815   * @return {boolean} Whether a request is in progress for an embed preview.
1816   */
1817  
1818  var isRequestingEmbedPreview = Object(external_this_wp_data_["createRegistrySelector"])(function (select) {
1819    return function (state, url) {
1820      return select('core/data').isResolving(REDUCER_KEY, 'getEmbedPreview', [url]);
1821    };
1822  });
1823  /**
1824   * Returns all available authors.
1825   *
1826   * @param {Object} state Data state.
1827   *
1828   * @return {Array} Authors list.
1829   */
1830  
1831  function getAuthors(state) {
1832    return getUserQueryResults(state, 'authors');
1833  }
1834  /**
1835   * Returns all the users returned by a query ID.
1836   *
1837   * @param {Object} state   Data state.
1838   * @param {string} queryID Query ID.
1839   *
1840   * @return {Array} Users list.
1841   */
1842  
1843  var getUserQueryResults = Object(rememo["a" /* default */])(function (state, queryID) {
1844    var queryResults = state.users.queries[queryID];
1845    return Object(external_lodash_["map"])(queryResults, function (id) {
1846      return state.users.byId[id];
1847    });
1848  }, function (state, queryID) {
1849    return [state.users.queries[queryID], state.users.byId];
1850  });
1851  /**
1852   * Returns whether the entities for the give kind are loaded.
1853   *
1854   * @param {Object} state   Data state.
1855   * @param {string} kind  Entity kind.
1856   *
1857   * @return {boolean} Whether the entities are loaded
1858   */
1859  
1860  function getEntitiesByKind(state, kind) {
1861    return Object(external_lodash_["filter"])(state.entities.config, {
1862      kind: kind
1863    });
1864  }
1865  /**
1866   * Returns the entity object given its kind and name.
1867   *
1868   * @param {Object} state   Data state.
1869   * @param {string} kind  Entity kind.
1870   * @param {string} name  Entity name.
1871   *
1872   * @return {Object} Entity
1873   */
1874  
1875  function getEntity(state, kind, name) {
1876    return Object(external_lodash_["find"])(state.entities.config, {
1877      kind: kind,
1878      name: name
1879    });
1880  }
1881  /**
1882   * Returns the Entity's record object by key.
1883   *
1884   * @param {Object} state  State tree
1885   * @param {string} kind   Entity kind.
1886   * @param {string} name   Entity name.
1887   * @param {number} key    Record's key
1888   *
1889   * @return {Object?} Record.
1890   */
1891  
1892  function getEntityRecord(state, kind, name, key) {
1893    return Object(external_lodash_["get"])(state.entities.data, [kind, name, 'items', key]);
1894  }
1895  /**
1896   * Returns the Entity's records.
1897   *
1898   * @param {Object}  state  State tree
1899   * @param {string}  kind   Entity kind.
1900   * @param {string}  name   Entity name.
1901   * @param {?Object} query  Optional terms query.
1902   *
1903   * @return {Array} Records.
1904   */
1905  
1906  function getEntityRecords(state, kind, name, query) {
1907    var queriedState = Object(external_lodash_["get"])(state.entities.data, [kind, name]);
1908  
1909    if (!queriedState) {
1910      return [];
1911    }
1912  
1913    return getQueriedItems(queriedState, query);
1914  }
1915  /**
1916   * Return theme supports data in the index.
1917   *
1918   * @param {Object} state Data state.
1919   *
1920   * @return {*}           Index data.
1921   */
1922  
1923  function getThemeSupports(state) {
1924    return state.themeSupports;
1925  }
1926  /**
1927   * Returns the embed preview for the given URL.
1928   *
1929   * @param {Object} state    Data state.
1930   * @param {string} url      Embedded URL.
1931   *
1932   * @return {*} Undefined if the preview has not been fetched, otherwise, the preview fetched from the embed preview API.
1933   */
1934  
1935  function getEmbedPreview(state, url) {
1936    return state.embedPreviews[url];
1937  }
1938  /**
1939   * Determines if the returned preview is an oEmbed link fallback.
1940   *
1941   * WordPress can be configured to return a simple link to a URL if it is not embeddable.
1942   * We need to be able to determine if a URL is embeddable or not, based on what we
1943   * get back from the oEmbed preview API.
1944   *
1945   * @param {Object} state    Data state.
1946   * @param {string} url      Embedded URL.
1947   *
1948   * @return {booleans} Is the preview for the URL an oEmbed link fallback.
1949   */
1950  
1951  function isPreviewEmbedFallback(state, url) {
1952    var preview = state.embedPreviews[url];
1953    var oEmbedLinkCheck = '<a href="' + url + '">' + url + '</a>';
1954  
1955    if (!preview) {
1956      return false;
1957    }
1958  
1959    return preview.html === oEmbedLinkCheck;
1960  }
1961  /**
1962   * Returns whether the current user can upload media.
1963   *
1964   * Calling this may trigger an OPTIONS request to the REST API via the
1965   * `canUser()` resolver.
1966   *
1967   * https://developer.wordpress.org/rest-api/reference/
1968   *
1969   * @deprecated since 5.0. Callers should use the more generic `canUser()` selector instead of
1970   *             `hasUploadPermissions()`, e.g. `canUser( 'create', 'media' )`.
1971   *
1972   * @param {Object} state Data state.
1973   *
1974   * @return {boolean} Whether or not the user can upload media. Defaults to `true` if the OPTIONS
1975   *                   request is being made.
1976   */
1977  
1978  function hasUploadPermissions(state) {
1979    external_this_wp_deprecated_default()("select( 'core' ).hasUploadPermissions()", {
1980      alternative: "select( 'core' ).canUser( 'create', 'media' )"
1981    });
1982    return Object(external_lodash_["defaultTo"])(canUser(state, 'create', 'media'), true);
1983  }
1984  /**
1985   * Returns whether the current user can perform the given action on the given
1986   * REST resource.
1987   *
1988   * Calling this may trigger an OPTIONS request to the REST API via the
1989   * `canUser()` resolver.
1990   *
1991   * https://developer.wordpress.org/rest-api/reference/
1992   *
1993   * @param {Object}   state            Data state.
1994   * @param {string}   action           Action to check. One of: 'create', 'read', 'update', 'delete'.
1995   * @param {string}   resource         REST resource to check, e.g. 'media' or 'posts'.
1996   * @param {string=}  id               Optional ID of the rest resource to check.
1997   *
1998   * @return {boolean|undefined} Whether or not the user can perform the action,
1999   *                             or `undefined` if the OPTIONS request is still being made.
2000   */
2001  
2002  function canUser(state, action, resource, id) {
2003    var key = Object(external_lodash_["compact"])([action, resource, id]).join('/');
2004    return Object(external_lodash_["get"])(state, ['userPermissions', key]);
2005  }
2006  
2007  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/resolvers.js
2008  
2009  
2010  
2011  var resolvers_marked =
2012  /*#__PURE__*/
2013  regenerator_default.a.mark(resolvers_getAuthors),
2014      resolvers_marked2 =
2015  /*#__PURE__*/
2016  regenerator_default.a.mark(resolvers_getEntityRecord),
2017      resolvers_marked3 =
2018  /*#__PURE__*/
2019  regenerator_default.a.mark(resolvers_getEntityRecords),
2020      _marked4 =
2021  /*#__PURE__*/
2022  regenerator_default.a.mark(resolvers_getThemeSupports),
2023      _marked5 =
2024  /*#__PURE__*/
2025  regenerator_default.a.mark(resolvers_getEmbedPreview),
2026      _marked6 =
2027  /*#__PURE__*/
2028  regenerator_default.a.mark(resolvers_hasUploadPermissions),
2029      _marked7 =
2030  /*#__PURE__*/
2031  regenerator_default.a.mark(resolvers_canUser);
2032  
2033  /**
2034   * External dependencies
2035   */
2036  
2037  /**
2038   * WordPress dependencies
2039   */
2040  
2041  
2042  
2043  /**
2044   * Internal dependencies
2045   */
2046  
2047  
2048  
2049  
2050  /**
2051   * Requests authors from the REST API.
2052   */
2053  
2054  function resolvers_getAuthors() {
2055    var users;
2056    return regenerator_default.a.wrap(function getAuthors$(_context) {
2057      while (1) {
2058        switch (_context.prev = _context.next) {
2059          case 0:
2060            _context.next = 2;
2061            return apiFetch({
2062              path: '/wp/v2/users/?who=authors&per_page=-1'
2063            });
2064  
2065          case 2:
2066            users = _context.sent;
2067            _context.next = 5;
2068            return receiveUserQuery('authors', users);
2069  
2070          case 5:
2071          case "end":
2072            return _context.stop();
2073        }
2074      }
2075    }, resolvers_marked, this);
2076  }
2077  /**
2078   * Requests an entity's record from the REST API.
2079   *
2080   * @param {string} kind   Entity kind.
2081   * @param {string} name   Entity name.
2082   * @param {number} key    Record's key
2083   */
2084  
2085  function resolvers_getEntityRecord(kind, name, key) {
2086    var entities, entity, record;
2087    return regenerator_default.a.wrap(function getEntityRecord$(_context2) {
2088      while (1) {
2089        switch (_context2.prev = _context2.next) {
2090          case 0:
2091            _context2.next = 2;
2092            return getKindEntities(kind);
2093  
2094          case 2:
2095            entities = _context2.sent;
2096            entity = Object(external_lodash_["find"])(entities, {
2097              kind: kind,
2098              name: name
2099            });
2100  
2101            if (entity) {
2102              _context2.next = 6;
2103              break;
2104            }
2105  
2106            return _context2.abrupt("return");
2107  
2108          case 6:
2109            _context2.next = 8;
2110            return apiFetch({
2111              path: "".concat(entity.baseURL, "/").concat(key, "?context=edit")
2112            });
2113  
2114          case 8:
2115            record = _context2.sent;
2116            _context2.next = 11;
2117            return receiveEntityRecords(kind, name, record);
2118  
2119          case 11:
2120          case "end":
2121            return _context2.stop();
2122        }
2123      }
2124    }, resolvers_marked2, this);
2125  }
2126  /**
2127   * Requests the entity's records from the REST API.
2128   *
2129   * @param {string}  kind   Entity kind.
2130   * @param {string}  name   Entity name.
2131   * @param {Object?} query  Query Object.
2132   */
2133  
2134  function resolvers_getEntityRecords(kind, name) {
2135    var query,
2136        entities,
2137        entity,
2138        path,
2139        records,
2140        _args3 = arguments;
2141    return regenerator_default.a.wrap(function getEntityRecords$(_context3) {
2142      while (1) {
2143        switch (_context3.prev = _context3.next) {
2144          case 0:
2145            query = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : {};
2146            _context3.next = 3;
2147            return getKindEntities(kind);
2148  
2149          case 3:
2150            entities = _context3.sent;
2151            entity = Object(external_lodash_["find"])(entities, {
2152              kind: kind,
2153              name: name
2154            });
2155  
2156            if (entity) {
2157              _context3.next = 7;
2158              break;
2159            }
2160  
2161            return _context3.abrupt("return");
2162  
2163          case 7:
2164            path = Object(external_this_wp_url_["addQueryArgs"])(entity.baseURL, Object(objectSpread["a" /* default */])({}, query, {
2165              context: 'edit'
2166            }));
2167            _context3.next = 10;
2168            return apiFetch({
2169              path: path
2170            });
2171  
2172          case 10:
2173            records = _context3.sent;
2174            _context3.next = 13;
2175            return receiveEntityRecords(kind, name, Object.values(records), query);
2176  
2177          case 13:
2178          case "end":
2179            return _context3.stop();
2180        }
2181      }
2182    }, resolvers_marked3, this);
2183  }
2184  
2185  resolvers_getEntityRecords.shouldInvalidate = function (action, kind, name) {
2186    return action.type === 'RECEIVE_ITEMS' && action.invalidateCache && kind === action.kind && name === action.name;
2187  };
2188  /**
2189   * Requests theme supports data from the index.
2190   */
2191  
2192  
2193  function resolvers_getThemeSupports() {
2194    var activeThemes;
2195    return regenerator_default.a.wrap(function getThemeSupports$(_context4) {
2196      while (1) {
2197        switch (_context4.prev = _context4.next) {
2198          case 0:
2199            _context4.next = 2;
2200            return apiFetch({
2201              path: '/wp/v2/themes?status=active'
2202            });
2203  
2204          case 2:
2205            activeThemes = _context4.sent;
2206            _context4.next = 5;
2207            return receiveThemeSupports(activeThemes[0].theme_supports);
2208  
2209          case 5:
2210          case "end":
2211            return _context4.stop();
2212        }
2213      }
2214    }, _marked4, this);
2215  }
2216  /**
2217   * Requests a preview from the from the Embed API.
2218   *
2219   * @param {string} url   URL to get the preview for.
2220   */
2221  
2222  function resolvers_getEmbedPreview(url) {
2223    var embedProxyResponse;
2224    return regenerator_default.a.wrap(function getEmbedPreview$(_context5) {
2225      while (1) {
2226        switch (_context5.prev = _context5.next) {
2227          case 0:
2228            _context5.prev = 0;
2229            _context5.next = 3;
2230            return apiFetch({
2231              path: Object(external_this_wp_url_["addQueryArgs"])('/oembed/1.0/proxy', {
2232                url: url
2233              })
2234            });
2235  
2236          case 3:
2237            embedProxyResponse = _context5.sent;
2238            _context5.next = 6;
2239            return receiveEmbedPreview(url, embedProxyResponse);
2240  
2241          case 6:
2242            _context5.next = 12;
2243            break;
2244  
2245          case 8:
2246            _context5.prev = 8;
2247            _context5.t0 = _context5["catch"](0);
2248            _context5.next = 12;
2249            return receiveEmbedPreview(url, false);
2250  
2251          case 12:
2252          case "end":
2253            return _context5.stop();
2254        }
2255      }
2256    }, _marked5, this, [[0, 8]]);
2257  }
2258  /**
2259   * Requests Upload Permissions from the REST API.
2260   *
2261   * @deprecated since 5.0. Callers should use the more generic `canUser()` selector instead of
2262   *            `hasUploadPermissions()`, e.g. `canUser( 'create', 'media' )`.
2263   */
2264  
2265  function resolvers_hasUploadPermissions() {
2266    return regenerator_default.a.wrap(function hasUploadPermissions$(_context6) {
2267      while (1) {
2268        switch (_context6.prev = _context6.next) {
2269          case 0:
2270            external_this_wp_deprecated_default()("select( 'core' ).hasUploadPermissions()", {
2271              alternative: "select( 'core' ).canUser( 'create', 'media' )"
2272            });
2273            return _context6.delegateYield(resolvers_canUser('create', 'media'), "t0", 2);
2274  
2275          case 2:
2276          case "end":
2277            return _context6.stop();
2278        }
2279      }
2280    }, _marked6, this);
2281  }
2282  /**
2283   * Checks whether the current user can perform the given action on the given
2284   * REST resource.
2285   *
2286   * @param {string}  action   Action to check. One of: 'create', 'read', 'update',
2287   *                           'delete'.
2288   * @param {string}  resource REST resource to check, e.g. 'media' or 'posts'.
2289   * @param {?string} id       ID of the rest resource to check.
2290   */
2291  
2292  function resolvers_canUser(action, resource, id) {
2293    var methods, method, path, response, allowHeader, key, isAllowed;
2294    return regenerator_default.a.wrap(function canUser$(_context7) {
2295      while (1) {
2296        switch (_context7.prev = _context7.next) {
2297          case 0:
2298            methods = {
2299              create: 'POST',
2300              read: 'GET',
2301              update: 'PUT',
2302              delete: 'DELETE'
2303            };
2304            method = methods[action];
2305  
2306            if (method) {
2307              _context7.next = 4;
2308              break;
2309            }
2310  
2311            throw new Error("'".concat(action, "' is not a valid action."));
2312  
2313          case 4:
2314            path = id ? "/wp/v2/".concat(resource, "/").concat(id) : "/wp/v2/".concat(resource);
2315            _context7.prev = 5;
2316            _context7.next = 8;
2317            return apiFetch({
2318              path: path,
2319              // Ideally this would always be an OPTIONS request, but unfortunately there's
2320              // a bug in the REST API which causes the Allow header to not be sent on
2321              // OPTIONS requests to /posts/:id routes.
2322              // https://core.trac.wordpress.org/ticket/45753
2323              method: id ? 'GET' : 'OPTIONS',
2324              parse: false
2325            });
2326  
2327          case 8:
2328            response = _context7.sent;
2329            _context7.next = 14;
2330            break;
2331  
2332          case 11:
2333            _context7.prev = 11;
2334            _context7.t0 = _context7["catch"](5);
2335            return _context7.abrupt("return");
2336  
2337          case 14:
2338            if (Object(external_lodash_["hasIn"])(response, ['headers', 'get'])) {
2339              // If the request is fetched using the fetch api, the header can be
2340              // retrieved using the 'get' method.
2341              allowHeader = response.headers.get('allow');
2342            } else {
2343              // If the request was preloaded server-side and is returned by the
2344              // preloading middleware, the header will be a simple property.
2345              allowHeader = Object(external_lodash_["get"])(response, ['headers', 'Allow'], '');
2346            }
2347  
2348            key = Object(external_lodash_["compact"])([action, resource, id]).join('/');
2349            isAllowed = Object(external_lodash_["includes"])(allowHeader, method);
2350            _context7.next = 19;
2351            return receiveUserPermission(key, isAllowed);
2352  
2353          case 19:
2354          case "end":
2355            return _context7.stop();
2356        }
2357      }
2358    }, _marked7, this, [[5, 11]]);
2359  }
2360  
2361  // CONCATENATED MODULE: ./node_modules/@wordpress/core-data/build-module/index.js
2362  
2363  
2364  /**
2365   * WordPress dependencies
2366   */
2367  
2368  /**
2369   * Internal dependencies
2370   */
2371  
2372  
2373  
2374  
2375  
2376  
2377  
2378   // The entity selectors/resolvers and actions are shortcuts to their generic equivalents
2379  // (getEntityRecord, getEntityRecords, updateEntityRecord, updateEntityRecordss)
2380  // Instead of getEntityRecord, the consumer could use more user-frieldly named selector: getPostType, getTaxonomy...
2381  // The "kind" and the "name" of the entity are combined to generate these shortcuts.
2382  
2383  var entitySelectors = defaultEntities.reduce(function (result, entity) {
2384    var kind = entity.kind,
2385        name = entity.name;
2386  
2387    result[entities_getMethodName(kind, name)] = function (state, key) {
2388      return getEntityRecord(state, kind, name, key);
2389    };
2390  
2391    result[entities_getMethodName(kind, name, 'get', true)] = function (state) {
2392      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
2393        args[_key - 1] = arguments[_key];
2394      }
2395  
2396      return getEntityRecords.apply(build_module_selectors_namespaceObject, [state, kind, name].concat(args));
2397    };
2398  
2399    return result;
2400  }, {});
2401  var entityResolvers = defaultEntities.reduce(function (result, entity) {
2402    var kind = entity.kind,
2403        name = entity.name;
2404  
2405    result[entities_getMethodName(kind, name)] = function (key) {
2406      return resolvers_getEntityRecord(kind, name, key);
2407    };
2408  
2409    var pluralMethodName = entities_getMethodName(kind, name, 'get', true);
2410  
2411    result[pluralMethodName] = function () {
2412      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
2413        args[_key2] = arguments[_key2];
2414      }
2415  
2416      return resolvers_getEntityRecords.apply(resolvers_namespaceObject, [kind, name].concat(args));
2417    };
2418  
2419    result[pluralMethodName].shouldInvalidate = function (action) {
2420      var _resolvers$getEntityR;
2421  
2422      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
2423        args[_key3 - 1] = arguments[_key3];
2424      }
2425  
2426      return (_resolvers$getEntityR = resolvers_getEntityRecords).shouldInvalidate.apply(_resolvers$getEntityR, [action, kind, name].concat(args));
2427    };
2428  
2429    return result;
2430  }, {});
2431  var entityActions = defaultEntities.reduce(function (result, entity) {
2432    var kind = entity.kind,
2433        name = entity.name;
2434  
2435    result[entities_getMethodName(kind, name, 'save')] = function (key) {
2436      return saveEntityRecord(kind, name, key);
2437    };
2438  
2439    return result;
2440  }, {});
2441  Object(external_this_wp_data_["registerStore"])(REDUCER_KEY, {
2442    reducer: build_module_reducer,
2443    controls: build_module_controls,
2444    actions: Object(objectSpread["a" /* default */])({}, build_module_actions_namespaceObject, entityActions),
2445    selectors: Object(objectSpread["a" /* default */])({}, build_module_selectors_namespaceObject, entitySelectors),
2446    resolvers: Object(objectSpread["a" /* default */])({}, resolvers_namespaceObject, entityResolvers)
2447  });
2448  
2449  
2450  /***/ }),
2451  
2452  /***/ 37:
2453  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2454  
2455  "use strict";
2456  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; });
2457  function _arrayWithHoles(arr) {
2458    if (Array.isArray(arr)) return arr;
2459  }
2460  
2461  /***/ }),
2462  
2463  /***/ 38:
2464  /***/ (function(module, __webpack_exports__, __webpack_require__) {
2465  
2466  "use strict";
2467  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; });
2468  function _nonIterableRest() {
2469    throw new TypeError("Invalid attempt to destructure non-iterable instance");
2470  }
2471  
2472  /***/ }),
2473  
2474  /***/ 49:
2475  /***/ (function(module, exports) {
2476  
2477  (function() { module.exports = this["wp"]["deprecated"]; }());
2478  
2479  /***/ }),
2480  
2481  /***/ 5:
2482  /***/ (function(module, exports) {
2483  
2484  (function() { module.exports = this["wp"]["data"]; }());
2485  
2486  /***/ }),
2487  
2488  /***/ 54:
2489  /***/ (function(module, exports, __webpack_require__) {
2490  
2491  /**
2492   * Copyright (c) 2014-present, Facebook, Inc.
2493   *
2494   * This source code is licensed under the MIT license found in the
2495   * LICENSE file in the root directory of this source tree.
2496   */
2497  
2498  var runtime = (function (exports) {
2499    "use strict";
2500  
2501    var Op = Object.prototype;
2502    var hasOwn = Op.hasOwnProperty;
2503    var undefined; // More compressible than void 0.
2504    var $Symbol = typeof Symbol === "function" ? Symbol : {};
2505    var iteratorSymbol = $Symbol.iterator || "@@iterator";
2506    var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
2507    var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
2508  
2509    function wrap(innerFn, outerFn, self, tryLocsList) {
2510      // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
2511      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
2512      var generator = Object.create(protoGenerator.prototype);
2513      var context = new Context(tryLocsList || []);
2514  
2515      // The ._invoke method unifies the implementations of the .next,
2516      // .throw, and .return methods.
2517      generator._invoke = makeInvokeMethod(innerFn, self, context);
2518  
2519      return generator;
2520    }
2521    exports.wrap = wrap;
2522  
2523    // Try/catch helper to minimize deoptimizations. Returns a completion
2524    // record like context.tryEntries[i].completion. This interface could
2525    // have been (and was previously) designed to take a closure to be
2526    // invoked without arguments, but in all the cases we care about we
2527    // already have an existing method we want to call, so there's no need
2528    // to create a new function object. We can even get away with assuming
2529    // the method takes exactly one argument, since that happens to be true
2530    // in every case, so we don't have to touch the arguments object. The
2531    // only additional allocation required is the completion record, which
2532    // has a stable shape and so hopefully should be cheap to allocate.
2533    function tryCatch(fn, obj, arg) {
2534      try {
2535        return { type: "normal", arg: fn.call(obj, arg) };
2536      } catch (err) {
2537        return { type: "throw", arg: err };
2538      }
2539    }
2540  
2541    var GenStateSuspendedStart = "suspendedStart";
2542    var GenStateSuspendedYield = "suspendedYield";
2543    var GenStateExecuting = "executing";
2544    var GenStateCompleted = "completed";
2545  
2546    // Returning this object from the innerFn has the same effect as
2547    // breaking out of the dispatch switch statement.
2548    var ContinueSentinel = {};
2549  
2550    // Dummy constructor functions that we use as the .constructor and
2551    // .constructor.prototype properties for functions that return Generator
2552    // objects. For full spec compliance, you may wish to configure your
2553    // minifier not to mangle the names of these two functions.
2554    function Generator() {}
2555    function GeneratorFunction() {}
2556    function GeneratorFunctionPrototype() {}
2557  
2558    // This is a polyfill for %IteratorPrototype% for environments that
2559    // don't natively support it.
2560    var IteratorPrototype = {};
2561    IteratorPrototype[iteratorSymbol] = function () {
2562      return this;
2563    };
2564  
2565    var getProto = Object.getPrototypeOf;
2566    var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
2567    if (NativeIteratorPrototype &&
2568        NativeIteratorPrototype !== Op &&
2569        hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
2570      // This environment has a native %IteratorPrototype%; use it instead
2571      // of the polyfill.
2572      IteratorPrototype = NativeIteratorPrototype;
2573    }
2574  
2575    var Gp = GeneratorFunctionPrototype.prototype =
2576      Generator.prototype = Object.create(IteratorPrototype);
2577    GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
2578    GeneratorFunctionPrototype.constructor = GeneratorFunction;
2579    GeneratorFunctionPrototype[toStringTagSymbol] =
2580      GeneratorFunction.displayName = "GeneratorFunction";
2581  
2582    // Helper for defining the .next, .throw, and .return methods of the
2583    // Iterator interface in terms of a single ._invoke method.
2584    function defineIteratorMethods(prototype) {
2585      ["next", "throw", "return"].forEach(function(method) {
2586        prototype[method] = function(arg) {
2587          return this._invoke(method, arg);
2588        };
2589      });
2590    }
2591  
2592    exports.isGeneratorFunction = function(genFun) {
2593      var ctor = typeof genFun === "function" && genFun.constructor;
2594      return ctor
2595        ? ctor === GeneratorFunction ||
2596          // For the native GeneratorFunction constructor, the best we can
2597          // do is to check its .name property.
2598          (ctor.displayName || ctor.name) === "GeneratorFunction"
2599        : false;
2600    };
2601  
2602    exports.mark = function(genFun) {
2603      if (Object.setPrototypeOf) {
2604        Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
2605      } else {
2606        genFun.__proto__ = GeneratorFunctionPrototype;
2607        if (!(toStringTagSymbol in genFun)) {
2608          genFun[toStringTagSymbol] = "GeneratorFunction";
2609        }
2610      }
2611      genFun.prototype = Object.create(Gp);
2612      return genFun;
2613    };
2614  
2615    // Within the body of any async function, `await x` is transformed to
2616    // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
2617    // `hasOwn.call(value, "__await")` to determine if the yielded value is
2618    // meant to be awaited.
2619    exports.awrap = function(arg) {
2620      return { __await: arg };
2621    };
2622  
2623    function AsyncIterator(generator) {
2624      function invoke(method, arg, resolve, reject) {
2625        var record = tryCatch(generator[method], generator, arg);
2626        if (record.type === "throw") {
2627          reject(record.arg);
2628        } else {
2629          var result = record.arg;
2630          var value = result.value;
2631          if (value &&
2632              typeof value === "object" &&
2633              hasOwn.call(value, "__await")) {
2634            return Promise.resolve(value.__await).then(function(value) {
2635              invoke("next", value, resolve, reject);
2636            }, function(err) {
2637              invoke("throw", err, resolve, reject);
2638            });
2639          }
2640  
2641          return Promise.resolve(value).then(function(unwrapped) {
2642            // When a yielded Promise is resolved, its final value becomes
2643            // the .value of the Promise<{value,done}> result for the
2644            // current iteration.
2645            result.value = unwrapped;
2646            resolve(result);
2647          }, function(error) {
2648            // If a rejected Promise was yielded, throw the rejection back
2649            // into the async generator function so it can be handled there.
2650            return invoke("throw", error, resolve, reject);
2651          });
2652        }
2653      }
2654  
2655      var previousPromise;
2656  
2657      function enqueue(method, arg) {
2658        function callInvokeWithMethodAndArg() {
2659          return new Promise(function(resolve, reject) {
2660            invoke(method, arg, resolve, reject);
2661          });
2662        }
2663  
2664        return previousPromise =
2665          // If enqueue has been called before, then we want to wait until
2666          // all previous Promises have been resolved before calling invoke,
2667          // so that results are always delivered in the correct order. If
2668          // enqueue has not been called before, then it is important to
2669          // call invoke immediately, without waiting on a callback to fire,
2670          // so that the async generator function has the opportunity to do
2671          // any necessary setup in a predictable way. This predictability
2672          // is why the Promise constructor synchronously invokes its
2673          // executor callback, and why async functions synchronously
2674          // execute code before the first await. Since we implement simple
2675          // async functions in terms of async generators, it is especially
2676          // important to get this right, even though it requires care.
2677          previousPromise ? previousPromise.then(
2678            callInvokeWithMethodAndArg,
2679            // Avoid propagating failures to Promises returned by later
2680            // invocations of the iterator.
2681            callInvokeWithMethodAndArg
2682          ) : callInvokeWithMethodAndArg();
2683      }
2684  
2685      // Define the unified helper method that is used to implement .next,
2686      // .throw, and .return (see defineIteratorMethods).
2687      this._invoke = enqueue;
2688    }
2689  
2690    defineIteratorMethods(AsyncIterator.prototype);
2691    AsyncIterator.prototype[asyncIteratorSymbol] = function () {
2692      return this;
2693    };
2694    exports.AsyncIterator = AsyncIterator;
2695  
2696    // Note that simple async functions are implemented on top of
2697    // AsyncIterator objects; they just return a Promise for the value of
2698    // the final result produced by the iterator.
2699    exports.async = function(innerFn, outerFn, self, tryLocsList) {
2700      var iter = new AsyncIterator(
2701        wrap(innerFn, outerFn, self, tryLocsList)
2702      );
2703  
2704      return exports.isGeneratorFunction(outerFn)
2705        ? iter // If outerFn is a generator, return the full iterator.
2706        : iter.next().then(function(result) {
2707            return result.done ? result.value : iter.next();
2708          });
2709    };
2710  
2711    function makeInvokeMethod(innerFn, self, context) {
2712      var state = GenStateSuspendedStart;
2713  
2714      return function invoke(method, arg) {
2715        if (state === GenStateExecuting) {
2716          throw new Error("Generator is already running");
2717        }
2718  
2719        if (state === GenStateCompleted) {
2720          if (method === "throw") {
2721            throw arg;
2722          }
2723  
2724          // Be forgiving, per 25.3.3.3.3 of the spec:
2725          // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
2726          return doneResult();
2727        }
2728  
2729        context.method = method;
2730        context.arg = arg;
2731  
2732        while (true) {
2733          var delegate = context.delegate;
2734          if (delegate) {
2735            var delegateResult = maybeInvokeDelegate(delegate, context);
2736            if (delegateResult) {
2737              if (delegateResult === ContinueSentinel) continue;
2738              return delegateResult;
2739            }
2740          }
2741  
2742          if (context.method === "next") {
2743            // Setting context._sent for legacy support of Babel's
2744            // function.sent implementation.
2745            context.sent = context._sent = context.arg;
2746  
2747          } else if (context.method === "throw") {
2748            if (state === GenStateSuspendedStart) {
2749              state = GenStateCompleted;
2750              throw context.arg;
2751            }
2752  
2753            context.dispatchException(context.arg);
2754  
2755          } else if (context.method === "return") {
2756            context.abrupt("return", context.arg);
2757          }
2758  
2759          state = GenStateExecuting;
2760  
2761          var record = tryCatch(innerFn, self, context);
2762          if (record.type === "normal") {
2763            // If an exception is thrown from innerFn, we leave state ===
2764            // GenStateExecuting and loop back for another invocation.
2765            state = context.done
2766              ? GenStateCompleted
2767              : GenStateSuspendedYield;
2768  
2769            if (record.arg === ContinueSentinel) {
2770              continue;
2771            }
2772  
2773            return {
2774              value: record.arg,
2775              done: context.done
2776            };
2777  
2778          } else if (record.type === "throw") {
2779            state = GenStateCompleted;
2780            // Dispatch the exception by looping back around to the
2781            // context.dispatchException(context.arg) call above.
2782            context.method = "throw";
2783            context.arg = record.arg;
2784          }
2785        }
2786      };
2787    }
2788  
2789    // Call delegate.iterator[context.method](context.arg) and handle the
2790    // result, either by returning a { value, done } result from the
2791    // delegate iterator, or by modifying context.method and context.arg,
2792    // setting context.delegate to null, and returning the ContinueSentinel.
2793    function maybeInvokeDelegate(delegate, context) {
2794      var method = delegate.iterator[context.method];
2795      if (method === undefined) {
2796        // A .throw or .return when the delegate iterator has no .throw
2797        // method always terminates the yield* loop.
2798        context.delegate = null;
2799  
2800        if (context.method === "throw") {
2801          // Note: ["return"] must be used for ES3 parsing compatibility.
2802          if (delegate.iterator["return"]) {
2803            // If the delegate iterator has a return method, give it a
2804            // chance to clean up.
2805            context.method = "return";
2806            context.arg = undefined;
2807            maybeInvokeDelegate(delegate, context);
2808  
2809            if (context.method === "throw") {
2810              // If maybeInvokeDelegate(context) changed context.method from
2811              // "return" to "throw", let that override the TypeError below.
2812              return ContinueSentinel;
2813            }
2814          }
2815  
2816          context.method = "throw";
2817          context.arg = new TypeError(
2818            "The iterator does not provide a 'throw' method");
2819        }
2820  
2821        return ContinueSentinel;
2822      }
2823  
2824      var record = tryCatch(method, delegate.iterator, context.arg);
2825  
2826      if (record.type === "throw") {
2827        context.method = "throw";
2828        context.arg = record.arg;
2829        context.delegate = null;
2830        return ContinueSentinel;
2831      }
2832  
2833      var info = record.arg;
2834  
2835      if (! info) {
2836        context.method = "throw";
2837        context.arg = new TypeError("iterator result is not an object");
2838        context.delegate = null;
2839        return ContinueSentinel;
2840      }
2841  
2842      if (info.done) {
2843        // Assign the result of the finished delegate to the temporary
2844        // variable specified by delegate.resultName (see delegateYield).
2845        context[delegate.resultName] = info.value;
2846  
2847        // Resume execution at the desired location (see delegateYield).
2848        context.next = delegate.nextLoc;
2849  
2850        // If context.method was "throw" but the delegate handled the
2851        // exception, let the outer generator proceed normally. If
2852        // context.method was "next", forget context.arg since it has been
2853        // "consumed" by the delegate iterator. If context.method was
2854        // "return", allow the original .return call to continue in the
2855        // outer generator.
2856        if (context.method !== "return") {
2857          context.method = "next";
2858          context.arg = undefined;
2859        }
2860  
2861      } else {
2862        // Re-yield the result returned by the delegate method.
2863        return info;
2864      }
2865  
2866      // The delegate iterator is finished, so forget it and continue with
2867      // the outer generator.
2868      context.delegate = null;
2869      return ContinueSentinel;
2870    }
2871  
2872    // Define Generator.prototype.{next,throw,return} in terms of the
2873    // unified ._invoke helper method.
2874    defineIteratorMethods(Gp);
2875  
2876    Gp[toStringTagSymbol] = "Generator";
2877  
2878    // A Generator should always return itself as the iterator object when the
2879    // @@iterator function is called on it. Some browsers' implementations of the
2880    // iterator prototype chain incorrectly implement this, causing the Generator
2881    // object to not be returned from this call. This ensures that doesn't happen.
2882    // See https://github.com/facebook/regenerator/issues/274 for more details.
2883    Gp[iteratorSymbol] = function() {
2884      return this;
2885    };
2886  
2887    Gp.toString = function() {
2888      return "[object Generator]";
2889    };
2890  
2891    function pushTryEntry(locs) {
2892      var entry = { tryLoc: locs[0] };
2893  
2894      if (1 in locs) {
2895        entry.catchLoc = locs[1];
2896      }
2897  
2898      if (2 in locs) {
2899        entry.finallyLoc = locs[2];
2900        entry.afterLoc = locs[3];
2901      }
2902  
2903      this.tryEntries.push(entry);
2904    }
2905  
2906    function resetTryEntry(entry) {
2907      var record = entry.completion || {};
2908      record.type = "normal";
2909      delete record.arg;
2910      entry.completion = record;
2911    }
2912  
2913    function Context(tryLocsList) {
2914      // The root entry object (effectively a try statement without a catch
2915      // or a finally block) gives us a place to store values thrown from
2916      // locations where there is no enclosing try statement.
2917      this.tryEntries = [{ tryLoc: "root" }];
2918      tryLocsList.forEach(pushTryEntry, this);
2919      this.reset(true);
2920    }
2921  
2922    exports.keys = function(object) {
2923      var keys = [];
2924      for (var key in object) {
2925        keys.push(key);
2926      }
2927      keys.reverse();
2928  
2929      // Rather than returning an object with a next method, we keep
2930      // things simple and return the next function itself.
2931      return function next() {
2932        while (keys.length) {
2933          var key = keys.pop();
2934          if (key in object) {
2935            next.value = key;
2936            next.done = false;
2937            return next;
2938          }
2939        }
2940  
2941        // To avoid creating an additional object, we just hang the .value
2942        // and .done properties off the next function object itself. This
2943        // also ensures that the minifier will not anonymize the function.
2944        next.done = true;
2945        return next;
2946      };
2947    };
2948  
2949    function values(iterable) {
2950      if (iterable) {
2951        var iteratorMethod = iterable[iteratorSymbol];
2952        if (iteratorMethod) {
2953          return iteratorMethod.call(iterable);
2954        }
2955  
2956        if (typeof iterable.next === "function") {
2957          return iterable;
2958        }
2959  
2960        if (!isNaN(iterable.length)) {
2961          var i = -1, next = function next() {
2962            while (++i < iterable.length) {
2963              if (hasOwn.call(iterable, i)) {
2964                next.value = iterable[i];
2965                next.done = false;
2966                return next;
2967              }
2968            }
2969  
2970            next.value = undefined;
2971            next.done = true;
2972  
2973            return next;
2974          };
2975  
2976          return next.next = next;
2977        }
2978      }
2979  
2980      // Return an iterator with no values.
2981      return { next: doneResult };
2982    }
2983    exports.values = values;
2984  
2985    function doneResult() {
2986      return { value: undefined, done: true };
2987    }
2988  
2989    Context.prototype = {
2990      constructor: Context,
2991  
2992      reset: function(skipTempReset) {
2993        this.prev = 0;
2994        this.next = 0;
2995        // Resetting context._sent for legacy support of Babel's
2996        // function.sent implementation.
2997        this.sent = this._sent = undefined;
2998        this.done = false;
2999        this.delegate = null;
3000  
3001        this.method = "next";
3002        this.arg = undefined;
3003  
3004        this.tryEntries.forEach(resetTryEntry);
3005  
3006        if (!skipTempReset) {
3007          for (var name in this) {
3008            // Not sure about the optimal order of these conditions:
3009            if (name.charAt(0) === "t" &&
3010                hasOwn.call(this, name) &&
3011                !isNaN(+name.slice(1))) {
3012              this[name] = undefined;
3013            }
3014          }
3015        }
3016      },
3017  
3018      stop: function() {
3019        this.done = true;
3020  
3021        var rootEntry = this.tryEntries[0];
3022        var rootRecord = rootEntry.completion;
3023        if (rootRecord.type === "throw") {
3024          throw rootRecord.arg;
3025        }
3026  
3027        return this.rval;
3028      },
3029  
3030      dispatchException: function(exception) {
3031        if (this.done) {
3032          throw exception;
3033        }
3034  
3035        var context = this;
3036        function handle(loc, caught) {
3037          record.type = "throw";
3038          record.arg = exception;
3039          context.next = loc;
3040  
3041          if (caught) {
3042            // If the dispatched exception was caught by a catch block,
3043            // then let that catch block handle the exception normally.
3044            context.method = "next";
3045            context.arg = undefined;
3046          }
3047  
3048          return !! caught;
3049        }
3050  
3051        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
3052          var entry = this.tryEntries[i];
3053          var record = entry.completion;
3054  
3055          if (entry.tryLoc === "root") {
3056            // Exception thrown outside of any try block that could handle
3057            // it, so set the completion value of the entire function to
3058            // throw the exception.
3059            return handle("end");
3060          }
3061  
3062          if (entry.tryLoc <= this.prev) {
3063            var hasCatch = hasOwn.call(entry, "catchLoc");
3064            var hasFinally = hasOwn.call(entry, "finallyLoc");
3065  
3066            if (hasCatch && hasFinally) {
3067              if (this.prev < entry.catchLoc) {
3068                return handle(entry.catchLoc, true);
3069              } else if (this.prev < entry.finallyLoc) {
3070                return handle(entry.finallyLoc);
3071              }
3072  
3073            } else if (hasCatch) {
3074              if (this.prev < entry.catchLoc) {
3075                return handle(entry.catchLoc, true);
3076              }
3077  
3078            } else if (hasFinally) {
3079              if (this.prev < entry.finallyLoc) {
3080                return handle(entry.finallyLoc);
3081              }
3082  
3083            } else {
3084              throw new Error("try statement without catch or finally");
3085            }
3086          }
3087        }
3088      },
3089  
3090      abrupt: function(type, arg) {
3091        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
3092          var entry = this.tryEntries[i];
3093          if (entry.tryLoc <= this.prev &&
3094              hasOwn.call(entry, "finallyLoc") &&
3095              this.prev < entry.finallyLoc) {
3096            var finallyEntry = entry;
3097            break;
3098          }
3099        }
3100  
3101        if (finallyEntry &&
3102            (type === "break" ||
3103             type === "continue") &&
3104            finallyEntry.tryLoc <= arg &&
3105            arg <= finallyEntry.finallyLoc) {
3106          // Ignore the finally entry if control is not jumping to a
3107          // location outside the try/catch block.
3108          finallyEntry = null;
3109        }
3110  
3111        var record = finallyEntry ? finallyEntry.completion : {};
3112        record.type = type;
3113        record.arg = arg;
3114  
3115        if (finallyEntry) {
3116          this.method = "next";
3117          this.next = finallyEntry.finallyLoc;
3118          return ContinueSentinel;
3119        }
3120  
3121        return this.complete(record);
3122      },
3123  
3124      complete: function(record, afterLoc) {
3125        if (record.type === "throw") {
3126          throw record.arg;
3127        }
3128  
3129        if (record.type === "break" ||
3130            record.type === "continue") {
3131          this.next = record.arg;
3132        } else if (record.type === "return") {
3133          this.rval = this.arg = record.arg;
3134          this.method = "return";
3135          this.next = "end";
3136        } else if (record.type === "normal" && afterLoc) {
3137          this.next = afterLoc;
3138        }
3139  
3140        return ContinueSentinel;
3141      },
3142  
3143      finish: function(finallyLoc) {
3144        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
3145          var entry = this.tryEntries[i];
3146          if (entry.finallyLoc === finallyLoc) {
3147            this.complete(entry.completion, entry.afterLoc);
3148            resetTryEntry(entry);
3149            return ContinueSentinel;
3150          }
3151        }
3152      },
3153  
3154      "catch": function(tryLoc) {
3155        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
3156          var entry = this.tryEntries[i];
3157          if (entry.tryLoc === tryLoc) {
3158            var record = entry.completion;
3159            if (record.type === "throw") {
3160              var thrown = record.arg;
3161              resetTryEntry(entry);
3162            }
3163            return thrown;
3164          }
3165        }
3166  
3167        // The context.catch method must only be called with a location
3168        // argument that corresponds to a known catch block.
3169        throw new Error("illegal catch attempt");
3170      },
3171  
3172      delegateYield: function(iterable, resultName, nextLoc) {
3173        this.delegate = {
3174          iterator: values(iterable),
3175          resultName: resultName,
3176          nextLoc: nextLoc
3177        };
3178  
3179        if (this.method === "next") {
3180          // Deliberately forget the last sent value so that we don't
3181          // accidentally pass it on to the delegate.
3182          this.arg = undefined;
3183        }
3184  
3185        return ContinueSentinel;
3186      }
3187    };
3188  
3189    // Regardless of whether this script is executing as a CommonJS module
3190    // or not, return the runtime object so that we can declare the variable
3191    // regeneratorRuntime in the outer scope, which allows this module to be
3192    // injected easily by `bin/regenerator --include-runtime script.js`.
3193    return exports;
3194  
3195  }(
3196    // If this script is executing as a CommonJS module, use module.exports
3197    // as the regeneratorRuntime namespace. Otherwise create a new empty
3198    // object. Either way, the resulting object will be used to initialize
3199    // the regeneratorRuntime variable at the top of this file.
3200     true ? module.exports : undefined
3201  ));
3202  
3203  try {
3204    regeneratorRuntime = runtime;
3205  } catch (accidentalStrictMode) {
3206    // This module should not be running in strict mode, so the above
3207    // assignment should always work unless something is misconfigured. Just
3208    // in case runtime.js accidentally runs in strict mode, we can escape
3209    // strict mode using a global Function call. This could conceivably fail
3210    // if a Content Security Policy forbids using Function, but in that case
3211    // the proper solution is to fix the accidental strict mode problem. If
3212    // you've misconfigured your bundler to force strict mode and applied a
3213    // CSP to forbid Function, and you're not willing to fix either of those
3214    // problems, please detail your unique predicament in a GitHub issue.
3215    Function("r", "regeneratorRuntime = r")(runtime);
3216  }
3217  
3218  
3219  /***/ }),
3220  
3221  /***/ 58:
3222  /***/ (function(module, exports) {
3223  
3224  var g;
3225  
3226  // This works in non-strict mode
3227  g = (function() {
3228      return this;
3229  })();
3230  
3231  try {
3232      // This works if eval is allowed (see CSP)
3233      g = g || new Function("return this")();
3234  } catch (e) {
3235      // This works if the window reference is available
3236      if (typeof window === "object") g = window;
3237  }
3238  
3239  // g can still be undefined, but nothing to do about it...
3240  // We return undefined, instead of nothing here, so it's
3241  // easier to handle this case. if(!global) { ...}
3242  
3243  module.exports = g;
3244  
3245  
3246  /***/ }),
3247  
3248  /***/ 7:
3249  /***/ (function(module, __webpack_exports__, __webpack_require__) {
3250  
3251  "use strict";
3252  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectSpread; });
3253  /* harmony import */ var _defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15);
3254  
3255  function _objectSpread(target) {
3256    for (var i = 1; i < arguments.length; i++) {
3257      var source = arguments[i] != null ? arguments[i] : {};
3258      var ownKeys = Object.keys(source);
3259  
3260      if (typeof Object.getOwnPropertySymbols === 'function') {
3261        ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
3262          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
3263        }));
3264      }
3265  
3266      ownKeys.forEach(function (key) {
3267        Object(_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(target, key, source[key]);
3268      });
3269    }
3270  
3271    return target;
3272  }
3273  
3274  /***/ }),
3275  
3276  /***/ 71:
3277  /***/ (function(module, __webpack_exports__, __webpack_require__) {
3278  
3279  "use strict";
3280  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return createStore; });
3281  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return combineReducers; });
3282  /* unused harmony export bindActionCreators */
3283  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return applyMiddleware; });
3284  /* unused harmony export compose */
3285  /* unused harmony export __DO_NOT_USE__ActionTypes */
3286  /* harmony import */ var symbol_observable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(76);
3287  
3288  
3289  /**
3290   * These are private action types reserved by Redux.
3291   * For any unknown actions, you must return the current state.
3292   * If the current state is undefined, you must return the initial state.
3293   * Do not reference these action types directly in your code.
3294   */
3295  var randomString = function randomString() {
3296    return Math.random().toString(36).substring(7).split('').join('.');
3297  };
3298  
3299  var ActionTypes = {
3300    INIT: "@@redux/INIT" + randomString(),
3301    REPLACE: "@@redux/REPLACE" + randomString(),
3302    PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {
3303      return "@@redux/PROBE_UNKNOWN_ACTION" + randomString();
3304    }
3305  };
3306  
3307  /**
3308   * @param {any} obj The object to inspect.
3309   * @returns {boolean} True if the argument appears to be a plain object.
3310   */
3311  function isPlainObject(obj) {
3312    if (typeof obj !== 'object' || obj === null) return false;
3313    var proto = obj;
3314  
3315    while (Object.getPrototypeOf(proto) !== null) {
3316      proto = Object.getPrototypeOf(proto);
3317    }
3318  
3319    return Object.getPrototypeOf(obj) === proto;
3320  }
3321  
3322  /**
3323   * Creates a Redux store that holds the state tree.
3324   * The only way to change the data in the store is to call `dispatch()` on it.
3325   *
3326   * There should only be a single store in your app. To specify how different
3327   * parts of the state tree respond to actions, you may combine several reducers
3328   * into a single reducer function by using `combineReducers`.
3329   *
3330   * @param {Function} reducer A function that returns the next state tree, given
3331   * the current state tree and the action to handle.
3332   *
3333   * @param {any} [preloadedState] The initial state. You may optionally specify it
3334   * to hydrate the state from the server in universal apps, or to restore a
3335   * previously serialized user session.
3336   * If you use `combineReducers` to produce the root reducer function, this must be
3337   * an object with the same shape as `combineReducers` keys.
3338   *
3339   * @param {Function} [enhancer] The store enhancer. You may optionally specify it
3340   * to enhance the store with third-party capabilities such as middleware,
3341   * time travel, persistence, etc. The only store enhancer that ships with Redux
3342   * is `applyMiddleware()`.
3343   *
3344   * @returns {Store} A Redux store that lets you read the state, dispatch actions
3345   * and subscribe to changes.
3346   */
3347  
3348  function createStore(reducer, preloadedState, enhancer) {
3349    var _ref2;
3350  
3351    if (typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments[3] === 'function') {
3352      throw new Error('It looks like you are passing several store enhancers to ' + 'createStore(). This is not supported. Instead, compose them ' + 'together to a single function');
3353    }
3354  
3355    if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
3356      enhancer = preloadedState;
3357      preloadedState = undefined;
3358    }
3359  
3360    if (typeof enhancer !== 'undefined') {
3361      if (typeof enhancer !== 'function') {
3362        throw new Error('Expected the enhancer to be a function.');
3363      }
3364  
3365      return enhancer(createStore)(reducer, preloadedState);
3366    }
3367  
3368    if (typeof reducer !== 'function') {
3369      throw new Error('Expected the reducer to be a function.');
3370    }
3371  
3372    var currentReducer = reducer;
3373    var currentState = preloadedState;
3374    var currentListeners = [];
3375    var nextListeners = currentListeners;
3376    var isDispatching = false;
3377  
3378    function ensureCanMutateNextListeners() {
3379      if (nextListeners === currentListeners) {
3380        nextListeners = currentListeners.slice();
3381      }
3382    }
3383    /**
3384     * Reads the state tree managed by the store.
3385     *
3386     * @returns {any} The current state tree of your application.
3387     */
3388  
3389  
3390    function getState() {
3391      if (isDispatching) {
3392        throw new Error('You may not call store.getState() while the reducer is executing. ' + 'The reducer has already received the state as an argument. ' + 'Pass it down from the top reducer instead of reading it from the store.');
3393      }
3394  
3395      return currentState;
3396    }
3397    /**
3398     * Adds a change listener. It will be called any time an action is dispatched,
3399     * and some part of the state tree may potentially have changed. You may then
3400     * call `getState()` to read the current state tree inside the callback.
3401     *
3402     * You may call `dispatch()` from a change listener, with the following
3403     * caveats:
3404     *
3405     * 1. The subscriptions are snapshotted just before every `dispatch()` call.
3406     * If you subscribe or unsubscribe while the listeners are being invoked, this
3407     * will not have any effect on the `dispatch()` that is currently in progress.
3408     * However, the next `dispatch()` call, whether nested or not, will use a more
3409     * recent snapshot of the subscription list.
3410     *
3411     * 2. The listener should not expect to see all state changes, as the state
3412     * might have been updated multiple times during a nested `dispatch()` before
3413     * the listener is called. It is, however, guaranteed that all subscribers
3414     * registered before the `dispatch()` started will be called with the latest
3415     * state by the time it exits.
3416     *
3417     * @param {Function} listener A callback to be invoked on every dispatch.
3418     * @returns {Function} A function to remove this change listener.
3419     */
3420  
3421  
3422    function subscribe(listener) {
3423      if (typeof listener !== 'function') {
3424        throw new Error('Expected the listener to be a function.');
3425      }
3426  
3427      if (isDispatching) {
3428        throw new Error('You may not call store.subscribe() while the reducer is executing. ' + 'If you would like to be notified after the store has been updated, subscribe from a ' + 'component and invoke store.getState() in the callback to access the latest state. ' + 'See https://redux.js.org/api-reference/store#subscribe(listener) for more details.');
3429      }
3430  
3431      var isSubscribed = true;
3432      ensureCanMutateNextListeners();
3433      nextListeners.push(listener);
3434      return function unsubscribe() {
3435        if (!isSubscribed) {
3436          return;
3437        }
3438  
3439        if (isDispatching) {
3440          throw new Error('You may not unsubscribe from a store listener while the reducer is executing. ' + 'See https://redux.js.org/api-reference/store#subscribe(listener) for more details.');
3441        }
3442  
3443        isSubscribed = false;
3444        ensureCanMutateNextListeners();
3445        var index = nextListeners.indexOf(listener);
3446        nextListeners.splice(index, 1);
3447      };
3448    }
3449    /**
3450     * Dispatches an action. It is the only way to trigger a state change.
3451     *
3452     * The `reducer` function, used to create the store, will be called with the
3453     * current state tree and the given `action`. Its return value will
3454     * be considered the **next** state of the tree, and the change listeners
3455     * will be notified.
3456     *
3457     * The base implementation only supports plain object actions. If you want to
3458     * dispatch a Promise, an Observable, a thunk, or something else, you need to
3459     * wrap your store creating function into the corresponding middleware. For
3460     * example, see the documentation for the `redux-thunk` package. Even the
3461     * middleware will eventually dispatch plain object actions using this method.
3462     *
3463     * @param {Object} action A plain object representing “what changed”. It is
3464     * a good idea to keep actions serializable so you can record and replay user
3465     * sessions, or use the time travelling `redux-devtools`. An action must have
3466     * a `type` property which may not be `undefined`. It is a good idea to use
3467     * string constants for action types.
3468     *
3469     * @returns {Object} For convenience, the same action object you dispatched.
3470     *
3471     * Note that, if you use a custom middleware, it may wrap `dispatch()` to
3472     * return something else (for example, a Promise you can await).
3473     */
3474  
3475  
3476    function dispatch(action) {
3477      if (!isPlainObject(action)) {
3478        throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');
3479      }
3480  
3481      if (typeof action.type === 'undefined') {
3482        throw new Error('Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?');
3483      }
3484  
3485      if (isDispatching) {
3486        throw new Error('Reducers may not dispatch actions.');
3487      }
3488  
3489      try {
3490        isDispatching = true;
3491        currentState = currentReducer(currentState, action);
3492      } finally {
3493        isDispatching = false;
3494      }
3495  
3496      var listeners = currentListeners = nextListeners;
3497  
3498      for (var i = 0; i < listeners.length; i++) {
3499        var listener = listeners[i];
3500        listener();
3501      }
3502  
3503      return action;
3504    }
3505    /**
3506     * Replaces the reducer currently used by the store to calculate the state.
3507     *
3508     * You might need this if your app implements code splitting and you want to
3509     * load some of the reducers dynamically. You might also need this if you
3510     * implement a hot reloading mechanism for Redux.
3511     *
3512     * @param {Function} nextReducer The reducer for the store to use instead.
3513     * @returns {void}
3514     */
3515  
3516  
3517    function replaceReducer(nextReducer) {
3518      if (typeof nextReducer !== 'function') {
3519        throw new Error('Expected the nextReducer to be a function.');
3520      }
3521  
3522      currentReducer = nextReducer;
3523      dispatch({
3524        type: ActionTypes.REPLACE
3525      });
3526    }
3527    /**
3528     * Interoperability point for observable/reactive libraries.
3529     * @returns {observable} A minimal observable of state changes.
3530     * For more information, see the observable proposal:
3531     * https://github.com/tc39/proposal-observable
3532     */
3533  
3534  
3535    function observable() {
3536      var _ref;
3537  
3538      var outerSubscribe = subscribe;
3539      return _ref = {
3540        /**
3541         * The minimal observable subscription method.
3542         * @param {Object} observer Any object that can be used as an observer.
3543         * The observer object should have a `next` method.
3544         * @returns {subscription} An object with an `unsubscribe` method that can
3545         * be used to unsubscribe the observable from the store, and prevent further
3546         * emission of values from the observable.
3547         */
3548        subscribe: function subscribe(observer) {
3549          if (typeof observer !== 'object' || observer === null) {
3550            throw new TypeError('Expected the observer to be an object.');
3551          }
3552  
3553          function observeState() {
3554            if (observer.next) {
3555              observer.next(getState());
3556            }
3557          }
3558  
3559          observeState();
3560          var unsubscribe = outerSubscribe(observeState);
3561          return {
3562            unsubscribe: unsubscribe
3563          };
3564        }
3565      }, _ref[symbol_observable__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"]] = function () {
3566        return this;
3567      }, _ref;
3568    } // When a store is created, an "INIT" action is dispatched so that every
3569    // reducer returns their initial state. This effectively populates
3570    // the initial state tree.
3571  
3572  
3573    dispatch({
3574      type: ActionTypes.INIT
3575    });
3576    return _ref2 = {
3577      dispatch: dispatch,
3578      subscribe: subscribe,
3579      getState: getState,
3580      replaceReducer: replaceReducer
3581    }, _ref2[symbol_observable__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"]] = observable, _ref2;
3582  }
3583  
3584  /**
3585   * Prints a warning in the console if it exists.
3586   *
3587   * @param {String} message The warning message.
3588   * @returns {void}
3589   */
3590  function warning(message) {
3591    /* eslint-disable no-console */
3592    if (typeof console !== 'undefined' && typeof console.error === 'function') {
3593      console.error(message);
3594    }
3595    /* eslint-enable no-console */
3596  
3597  
3598    try {
3599      // This error was thrown as a convenience so that if you enable
3600      // "break on all exceptions" in your console,
3601      // it would pause the execution at this line.
3602      throw new Error(message);
3603    } catch (e) {} // eslint-disable-line no-empty
3604  
3605  }
3606  
3607  function getUndefinedStateErrorMessage(key, action) {
3608    var actionType = action && action.type;
3609    var actionDescription = actionType && "action \"" + String(actionType) + "\"" || 'an action';
3610    return "Given " + actionDescription + ", reducer \"" + key + "\" returned undefined. " + "To ignore an action, you must explicitly return the previous state. " + "If you want this reducer to hold no value, you can return null instead of undefined.";
3611  }
3612  
3613  function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
3614    var reducerKeys = Object.keys(reducers);
3615    var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer';
3616  
3617    if (reducerKeys.length === 0) {
3618      return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.';
3619    }
3620  
3621    if (!isPlainObject(inputState)) {
3622      return "The " + argumentName + " has unexpected type of \"" + {}.toString.call(inputState).match(/\s([a-z|A-Z]+)/)[1] + "\". Expected argument to be an object with the following " + ("keys: \"" + reducerKeys.join('", "') + "\"");
3623    }
3624  
3625    var unexpectedKeys = Object.keys(inputState).filter(function (key) {
3626      return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key];
3627    });
3628    unexpectedKeys.forEach(function (key) {
3629      unexpectedKeyCache[key] = true;
3630    });
3631    if (action && action.type === ActionTypes.REPLACE) return;
3632  
3633    if (unexpectedKeys.length > 0) {
3634      return "Unexpected " + (unexpectedKeys.length > 1 ? 'keys' : 'key') + " " + ("\"" + unexpectedKeys.join('", "') + "\" found in " + argumentName + ". ") + "Expected to find one of the known reducer keys instead: " + ("\"" + reducerKeys.join('", "') + "\". Unexpected keys will be ignored.");
3635    }
3636  }
3637  
3638  function assertReducerShape(reducers) {
3639    Object.keys(reducers).forEach(function (key) {
3640      var reducer = reducers[key];
3641      var initialState = reducer(undefined, {
3642        type: ActionTypes.INIT
3643      });
3644  
3645      if (typeof initialState === 'undefined') {
3646        throw new Error("Reducer \"" + key + "\" returned undefined during initialization. " + "If the state passed to the reducer is undefined, you must " + "explicitly return the initial state. The initial state may " + "not be undefined. If you don't want to set a value for this reducer, " + "you can use null instead of undefined.");
3647      }
3648  
3649      if (typeof reducer(undefined, {
3650        type: ActionTypes.PROBE_UNKNOWN_ACTION()
3651      }) === 'undefined') {
3652        throw new Error("Reducer \"" + key + "\" returned undefined when probed with a random type. " + ("Don't try to handle " + ActionTypes.INIT + " or other actions in \"redux/*\" ") + "namespace. They are considered private. Instead, you must return the " + "current state for any unknown actions, unless it is undefined, " + "in which case you must return the initial state, regardless of the " + "action type. The initial state may not be undefined, but can be null.");
3653      }
3654    });
3655  }
3656  /**
3657   * Turns an object whose values are different reducer functions, into a single
3658   * reducer function. It will call every child reducer, and gather their results
3659   * into a single state object, whose keys correspond to the keys of the passed
3660   * reducer functions.
3661   *
3662   * @param {Object} reducers An object whose values correspond to different
3663   * reducer functions that need to be combined into one. One handy way to obtain
3664   * it is to use ES6 `import * as reducers` syntax. The reducers may never return
3665   * undefined for any action. Instead, they should return their initial state
3666   * if the state passed to them was undefined, and the current state for any
3667   * unrecognized action.
3668   *
3669   * @returns {Function} A reducer function that invokes every reducer inside the
3670   * passed object, and builds a state object with the same shape.
3671   */
3672  
3673  
3674  function combineReducers(reducers) {
3675    var reducerKeys = Object.keys(reducers);
3676    var finalReducers = {};
3677  
3678    for (var i = 0; i < reducerKeys.length; i++) {
3679      var key = reducerKeys[i];
3680  
3681      if (false) {}
3682  
3683      if (typeof reducers[key] === 'function') {
3684        finalReducers[key] = reducers[key];
3685      }
3686    }
3687  
3688    var finalReducerKeys = Object.keys(finalReducers);
3689    var unexpectedKeyCache;
3690  
3691    if (false) {}
3692  
3693    var shapeAssertionError;
3694  
3695    try {
3696      assertReducerShape(finalReducers);
3697    } catch (e) {
3698      shapeAssertionError = e;
3699    }
3700  
3701    return function combination(state, action) {
3702      if (state === void 0) {
3703        state = {};
3704      }
3705  
3706      if (shapeAssertionError) {
3707        throw shapeAssertionError;
3708      }
3709  
3710      if (false) { var warningMessage; }
3711  
3712      var hasChanged = false;
3713      var nextState = {};
3714  
3715      for (var _i = 0; _i < finalReducerKeys.length; _i++) {
3716        var _key = finalReducerKeys[_i];
3717        var reducer = finalReducers[_key];
3718        var previousStateForKey = state[_key];
3719        var nextStateForKey = reducer(previousStateForKey, action);
3720  
3721        if (typeof nextStateForKey === 'undefined') {
3722          var errorMessage = getUndefinedStateErrorMessage(_key, action);
3723          throw new Error(errorMessage);
3724        }
3725  
3726        nextState[_key] = nextStateForKey;
3727        hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
3728      }
3729  
3730      return hasChanged ? nextState : state;
3731    };
3732  }
3733  
3734  function bindActionCreator(actionCreator, dispatch) {
3735    return function () {
3736      return dispatch(actionCreator.apply(this, arguments));
3737    };
3738  }
3739  /**
3740   * Turns an object whose values are action creators, into an object with the
3741   * same keys, but with every function wrapped into a `dispatch` call so they
3742   * may be invoked directly. This is just a convenience method, as you can call
3743   * `store.dispatch(MyActionCreators.doSomething())` yourself just fine.
3744   *
3745   * For convenience, you can also pass a single function as the first argument,
3746   * and get a function in return.
3747   *
3748   * @param {Function|Object} actionCreators An object whose values are action
3749   * creator functions. One handy way to obtain it is to use ES6 `import * as`
3750   * syntax. You may also pass a single function.
3751   *
3752   * @param {Function} dispatch The `dispatch` function available on your Redux
3753   * store.
3754   *
3755   * @returns {Function|Object} The object mimicking the original object, but with
3756   * every action creator wrapped into the `dispatch` call. If you passed a
3757   * function as `actionCreators`, the return value will also be a single
3758   * function.
3759   */
3760  
3761  
3762  function bindActionCreators(actionCreators, dispatch) {
3763    if (typeof actionCreators === 'function') {
3764      return bindActionCreator(actionCreators, dispatch);
3765    }
3766  
3767    if (typeof actionCreators !== 'object' || actionCreators === null) {
3768      throw new Error("bindActionCreators expected an object or a function, instead received " + (actionCreators === null ? 'null' : typeof actionCreators) + ". " + "Did you write \"import ActionCreators from\" instead of \"import * as ActionCreators from\"?");
3769    }
3770  
3771    var keys = Object.keys(actionCreators);
3772    var boundActionCreators = {};
3773  
3774    for (var i = 0; i < keys.length; i++) {
3775      var key = keys[i];
3776      var actionCreator = actionCreators[key];
3777  
3778      if (typeof actionCreator === 'function') {
3779        boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);
3780      }
3781    }
3782  
3783    return boundActionCreators;
3784  }
3785  
3786  function _defineProperty(obj, key, value) {
3787    if (key in obj) {
3788      Object.defineProperty(obj, key, {
3789        value: value,
3790        enumerable: true,
3791        configurable: true,
3792        writable: true
3793      });
3794    } else {
3795      obj[key] = value;
3796    }
3797  
3798    return obj;
3799  }
3800  
3801  function _objectSpread(target) {
3802    for (var i = 1; i < arguments.length; i++) {
3803      var source = arguments[i] != null ? arguments[i] : {};
3804      var ownKeys = Object.keys(source);
3805  
3806      if (typeof Object.getOwnPropertySymbols === 'function') {
3807        ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
3808          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
3809        }));
3810      }
3811  
3812      ownKeys.forEach(function (key) {
3813        _defineProperty(target, key, source[key]);
3814      });
3815    }
3816  
3817    return target;
3818  }
3819  
3820  /**
3821   * Composes single-argument functions from right to left. The rightmost
3822   * function can take multiple arguments as it provides the signature for
3823   * the resulting composite function.
3824   *
3825   * @param {...Function} funcs The functions to compose.
3826   * @returns {Function} A function obtained by composing the argument functions
3827   * from right to left. For example, compose(f, g, h) is identical to doing
3828   * (...args) => f(g(h(...args))).
3829   */
3830  function compose() {
3831    for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
3832      funcs[_key] = arguments[_key];
3833    }
3834  
3835    if (funcs.length === 0) {
3836      return function (arg) {
3837        return arg;
3838      };
3839    }
3840  
3841    if (funcs.length === 1) {
3842      return funcs[0];
3843    }
3844  
3845    return funcs.reduce(function (a, b) {
3846      return function () {
3847        return a(b.apply(void 0, arguments));
3848      };
3849    });
3850  }
3851  
3852  /**
3853   * Creates a store enhancer that applies middleware to the dispatch method
3854   * of the Redux store. This is handy for a variety of tasks, such as expressing
3855   * asynchronous actions in a concise manner, or logging every action payload.
3856   *
3857   * See `redux-thunk` package as an example of the Redux middleware.
3858   *
3859   * Because middleware is potentially asynchronous, this should be the first
3860   * store enhancer in the composition chain.
3861   *
3862   * Note that each middleware will be given the `dispatch` and `getState` functions
3863   * as named arguments.
3864   *
3865   * @param {...Function} middlewares The middleware chain to be applied.
3866   * @returns {Function} A store enhancer applying the middleware.
3867   */
3868  
3869  function applyMiddleware() {
3870    for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) {
3871      middlewares[_key] = arguments[_key];
3872    }
3873  
3874    return function (createStore) {
3875      return function () {
3876        var store = createStore.apply(void 0, arguments);
3877  
3878        var _dispatch = function dispatch() {
3879          throw new Error("Dispatching while constructing your middleware is not allowed. " + "Other middleware would not be applied to this dispatch.");
3880        };
3881  
3882        var middlewareAPI = {
3883          getState: store.getState,
3884          dispatch: function dispatch() {
3885            return _dispatch.apply(void 0, arguments);
3886          }
3887        };
3888        var chain = middlewares.map(function (middleware) {
3889          return middleware(middlewareAPI);
3890        });
3891        _dispatch = compose.apply(void 0, chain)(store.dispatch);
3892        return _objectSpread({}, store, {
3893          dispatch: _dispatch
3894        });
3895      };
3896    };
3897  }
3898  
3899  /*
3900   * This is a dummy function to check if the function name has been altered by minification.
3901   * If the function has been minified and NODE_ENV !== 'production', warn the user.
3902   */
3903  
3904  function isCrushed() {}
3905  
3906  if (false) {}
3907  
3908  
3909  
3910  
3911  /***/ }),
3912  
3913  /***/ 75:
3914  /***/ (function(module, exports, __webpack_require__) {
3915  
3916  "use strict";
3917  
3918  
3919  function _typeof(obj) {
3920    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
3921      _typeof = function (obj) {
3922        return typeof obj;
3923      };
3924    } else {
3925      _typeof = function (obj) {
3926        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
3927      };
3928    }
3929  
3930    return _typeof(obj);
3931  }
3932  
3933  function _classCallCheck(instance, Constructor) {
3934    if (!(instance instanceof Constructor)) {
3935      throw new TypeError("Cannot call a class as a function");
3936    }
3937  }
3938  
3939  function _defineProperties(target, props) {
3940    for (var i = 0; i < props.length; i++) {
3941      var descriptor = props[i];
3942      descriptor.enumerable = descriptor.enumerable || false;
3943      descriptor.configurable = true;
3944      if ("value" in descriptor) descriptor.writable = true;
3945      Object.defineProperty(target, descriptor.key, descriptor);
3946    }
3947  }
3948  
3949  function _createClass(Constructor, protoProps, staticProps) {
3950    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
3951    if (staticProps) _defineProperties(Constructor, staticProps);
3952    return Constructor;
3953  }
3954  
3955  /**
3956   * Given an instance of EquivalentKeyMap, returns its internal value pair tuple
3957   * for a key, if one exists. The tuple members consist of the last reference
3958   * value for the key (used in efficient subsequent lookups) and the value
3959   * assigned for the key at the leaf node.
3960   *
3961   * @param {EquivalentKeyMap} instance EquivalentKeyMap instance.
3962   * @param {*} key                     The key for which to return value pair.
3963   *
3964   * @return {?Array} Value pair, if exists.
3965   */
3966  function getValuePair(instance, key) {
3967    var _map = instance._map,
3968        _arrayTreeMap = instance._arrayTreeMap,
3969        _objectTreeMap = instance._objectTreeMap; // Map keeps a reference to the last object-like key used to set the
3970    // value, which can be used to shortcut immediately to the value.
3971  
3972    if (_map.has(key)) {
3973      return _map.get(key);
3974    } // Sort keys to ensure stable retrieval from tree.
3975  
3976  
3977    var properties = Object.keys(key).sort(); // Tree by type to avoid conflicts on numeric object keys, empty value.
3978  
3979    var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap;
3980  
3981    for (var i = 0; i < properties.length; i++) {
3982      var property = properties[i];
3983      map = map.get(property);
3984  
3985      if (map === undefined) {
3986        return;
3987      }
3988  
3989      var propertyValue = key[property];
3990      map = map.get(propertyValue);
3991  
3992      if (map === undefined) {
3993        return;
3994      }
3995    }
3996  
3997    var valuePair = map.get('_ekm_value');
3998  
3999    if (!valuePair) {
4000      return;
4001    } // If reached, it implies that an object-like key was set with another
4002    // reference, so delete the reference and replace with the current.
4003  
4004  
4005    _map.delete(valuePair[0]);
4006  
4007    valuePair[0] = key;
4008    map.set('_ekm_value', valuePair);
4009  
4010    _map.set(key, valuePair);
4011  
4012    return valuePair;
4013  }
4014  /**
4015   * Variant of a Map object which enables lookup by equivalent (deeply equal)
4016   * object and array keys.
4017   */
4018  
4019  
4020  var EquivalentKeyMap =
4021  /*#__PURE__*/
4022  function () {
4023    /**
4024     * Constructs a new instance of EquivalentKeyMap.
4025     *
4026     * @param {Iterable.<*>} iterable Initial pair of key, value for map.
4027     */
4028    function EquivalentKeyMap(iterable) {
4029      _classCallCheck(this, EquivalentKeyMap);
4030  
4031      this.clear();
4032  
4033      if (iterable instanceof EquivalentKeyMap) {
4034        // Map#forEach is only means of iterating with support for IE11.
4035        var iterablePairs = [];
4036        iterable.forEach(function (value, key) {
4037          iterablePairs.push([key, value]);
4038        });
4039        iterable = iterablePairs;
4040      }
4041  
4042      if (iterable != null) {
4043        for (var i = 0; i < iterable.length; i++) {
4044          this.set(iterable[i][0], iterable[i][1]);
4045        }
4046      }
4047    }
4048    /**
4049     * Accessor property returning the number of elements.
4050     *
4051     * @return {number} Number of elements.
4052     */
4053  
4054  
4055    _createClass(EquivalentKeyMap, [{
4056      key: "set",
4057  
4058      /**
4059       * Add or update an element with a specified key and value.
4060       *
4061       * @param {*} key   The key of the element to add.
4062       * @param {*} value The value of the element to add.
4063       *
4064       * @return {EquivalentKeyMap} Map instance.
4065       */
4066      value: function set(key, value) {
4067        // Shortcut non-object-like to set on internal Map.
4068        if (key === null || _typeof(key) !== 'object') {
4069          this._map.set(key, value);
4070  
4071          return this;
4072        } // Sort keys to ensure stable assignment into tree.
4073  
4074  
4075        var properties = Object.keys(key).sort();
4076        var valuePair = [key, value]; // Tree by type to avoid conflicts on numeric object keys, empty value.
4077  
4078        var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap;
4079  
4080        for (var i = 0; i < properties.length; i++) {
4081          var property = properties[i];
4082  
4083          if (!map.has(property)) {
4084            map.set(property, new EquivalentKeyMap());
4085          }
4086  
4087          map = map.get(property);
4088          var propertyValue = key[property];
4089  
4090          if (!map.has(propertyValue)) {
4091            map.set(propertyValue, new EquivalentKeyMap());
4092          }
4093  
4094          map = map.get(propertyValue);
4095        } // If an _ekm_value exists, there was already an equivalent key. Before
4096        // overriding, ensure that the old key reference is removed from map to
4097        // avoid memory leak of accumulating equivalent keys. This is, in a
4098        // sense, a poor man's WeakMap, while still enabling iterability.
4099  
4100  
4101        var previousValuePair = map.get('_ekm_value');
4102  
4103        if (previousValuePair) {
4104          this._map.delete(previousValuePair[0]);
4105        }
4106  
4107        map.set('_ekm_value', valuePair);
4108  
4109        this._map.set(key, valuePair);
4110  
4111        return this;
4112      }
4113      /**
4114       * Returns a specified element.
4115       *
4116       * @param {*} key The key of the element to return.
4117       *
4118       * @return {?*} The element associated with the specified key or undefined
4119       *              if the key can't be found.
4120       */
4121  
4122    }, {
4123      key: "get",
4124      value: function get(key) {
4125        // Shortcut non-object-like to get from internal Map.
4126        if (key === null || _typeof(key) !== 'object') {
4127          return this._map.get(key);
4128        }
4129  
4130        var valuePair = getValuePair(this, key);
4131  
4132        if (valuePair) {
4133          return valuePair[1];
4134        }
4135      }
4136      /**
4137       * Returns a boolean indicating whether an element with the specified key
4138       * exists or not.
4139       *
4140       * @param {*} key The key of the element to test for presence.
4141       *
4142       * @return {boolean} Whether an element with the specified key exists.
4143       */
4144  
4145    }, {
4146      key: "has",
4147      value: function has(key) {
4148        if (key === null || _typeof(key) !== 'object') {
4149          return this._map.has(key);
4150        } // Test on the _presence_ of the pair, not its value, as even undefined
4151        // can be a valid member value for a key.
4152  
4153  
4154        return getValuePair(this, key) !== undefined;
4155      }
4156      /**
4157       * Removes the specified element.
4158       *
4159       * @param {*} key The key of the element to remove.
4160       *
4161       * @return {boolean} Returns true if an element existed and has been
4162       *                   removed, or false if the element does not exist.
4163       */
4164  
4165    }, {
4166      key: "delete",
4167      value: function _delete(key) {
4168        if (!this.has(key)) {
4169          return false;
4170        } // This naive implementation will leave orphaned child trees. A better
4171        // implementation should traverse and remove orphans.
4172  
4173  
4174        this.set(key, undefined);
4175        return true;
4176      }
4177      /**
4178       * Executes a provided function once per each key/value pair, in insertion
4179       * order.
4180       *
4181       * @param {Function} callback Function to execute for each element.
4182       * @param {*}        thisArg  Value to use as `this` when executing
4183       *                            `callback`.
4184       */
4185  
4186    }, {
4187      key: "forEach",
4188      value: function forEach(callback) {
4189        var _this = this;
4190  
4191        var thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;
4192  
4193        this._map.forEach(function (value, key) {
4194          // Unwrap value from object-like value pair.
4195          if (key !== null && _typeof(key) === 'object') {
4196            value = value[1];
4197          }
4198  
4199          callback.call(thisArg, value, key, _this);
4200        });
4201      }
4202      /**
4203       * Removes all elements.
4204       */
4205  
4206    }, {
4207      key: "clear",
4208      value: function clear() {
4209        this._map = new Map();
4210        this._arrayTreeMap = new Map();
4211        this._objectTreeMap = new Map();
4212      }
4213    }, {
4214      key: "size",
4215      get: function get() {
4216        return this._map.size;
4217      }
4218    }]);
4219  
4220    return EquivalentKeyMap;
4221  }();
4222  
4223  module.exports = EquivalentKeyMap;
4224  
4225  
4226  /***/ }),
4227  
4228  /***/ 76:
4229  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4230  
4231  "use strict";
4232  /* WEBPACK VAR INJECTION */(function(global, module) {/* harmony import */ var _ponyfill_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(98);
4233  /* global window */
4234  
4235  
4236  var root;
4237  
4238  if (typeof self !== 'undefined') {
4239    root = self;
4240  } else if (typeof window !== 'undefined') {
4241    root = window;
4242  } else if (typeof global !== 'undefined') {
4243    root = global;
4244  } else if (true) {
4245    root = module;
4246  } else {}
4247  
4248  var result = Object(_ponyfill_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(root);
4249  /* harmony default export */ __webpack_exports__["a"] = (result);
4250  
4251  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(58), __webpack_require__(134)(module)))
4252  
4253  /***/ }),
4254  
4255  /***/ 98:
4256  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4257  
4258  "use strict";
4259  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return symbolObservablePonyfill; });
4260  function symbolObservablePonyfill(root) {
4261      var result;
4262      var Symbol = root.Symbol;
4263  
4264      if (typeof Symbol === 'function') {
4265          if (Symbol.observable) {
4266              result = Symbol.observable;
4267          } else {
4268              result = Symbol('observable');
4269              Symbol.observable = result;
4270          }
4271      } else {
4272          result = '@@observable';
4273      }
4274  
4275      return result;
4276  };
4277  
4278  
4279  /***/ })
4280  
4281  /******/ });


Generated: Wed Sep 18 01:00:03 2019 Cross-referenced by PHPXref 0.7.1