| [ Index ] |
PHP Cross Reference of WordPress |
[Summary view] [Print] [Text view]
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 /******/ });
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated: Wed Sep 18 01:00:03 2019 | Cross-referenced by PHPXref 0.7.1 |