{"version":3,"sources":["webpack://wp.[name]/webpack/bootstrap","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/iterableToArray.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/objectSpread.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/actions.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/controls.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/entities.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/index.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/name.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/queried-data/actions.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/queried-data/get-query-parts.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/queried-data/index.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/queried-data/reducer.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/queried-data/selectors.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/reducer.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/resolvers.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/selectors.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/utils/if-matching-action.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/utils/index.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/utils/on-sub-key.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/utils/replace-action.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/core-data/src/utils/with-weak-map-cache.js","webpack://wp.[name]/./node_modules/equivalent-key-map/equivalent-key-map.js","webpack://wp.[name]/./node_modules/redux/es/redux.js","webpack://wp.[name]/./node_modules/redux/node_modules/symbol-observable/es/index.js","webpack://wp.[name]/./node_modules/redux/node_modules/symbol-observable/es/ponyfill.js","webpack://wp.[name]/./node_modules/rememo/es/rememo.js","webpack://wp.[name]/(webpack)/buildin/global.js","webpack://wp.[name]/(webpack)/buildin/harmony-module.js","webpack://wp.[name]/external {\"this\":[\"wp\",\"apiFetch\"]}","webpack://wp.[name]/external {\"this\":[\"wp\",\"data\"]}","webpack://wp.[name]/external {\"this\":[\"wp\",\"url\"]}","webpack://wp.[name]/external \"lodash\""],"names":["receiveUserQuery","queryID","users","type","castArray","addEntities","entities","receiveEntityRecords","kind","name","records","query","action","receiveQueriedItems","receiveItems","receiveThemeSupportsFromIndex","index","themeSupports","theme_supports","receiveEmbedPreview","url","preview","apiFetch","request","select","selectorName","args","controls","API_FETCH","triggerApiFetch","SELECT","selectData","loadPostTypeEntities","loadTaxonomyEntities","getKindEntities","defaultEntities","key","baseURL","plural","kinds","loadEntities","path","postTypes","map","postType","rest_base","taxonomies","taxonomy","getMethodName","prefix","usePlural","entity","find","kindPrefix","upperFirst","camelCase","nameSuffix","suffix","length","kindConfig","createEntityRecordSelector","source","reduce","result","state","getEntityRecord","getEntityRecords","createEntityRecordResolver","entityResolvers","resolvers","entitySelectors","selectors","store","registerStore","REDUCER_KEY","reducer","actions","items","getQueryParts","parts","stableKey","page","perPage","keys","Object","sort","i","value","Number","addQueryArgs","slice","withWeakMapCache","getMergedItemIds","itemIds","nextItemIds","nextItemIdsStartIndex","size","Math","max","mergedItemIds","Array","isInNextItemsRange","keyBy","queries","flowRight","ifMatchingAction","replaceAction","onSubKey","combineReducers","queriedItemsCacheByState","WeakMap","getQueriedItemsUncached","startOffset","endOffset","min","itemId","push","getQueriedItems","createSelector","queriedItemsCache","get","queriedItems","undefined","EquivalentKeyMap","set","terms","byId","user","id","entityConfig","queriedDataReducer","entitiesConfig","newConfig","config","entitiesDataReducer","entitiesByKind","groupBy","entries","memo","subEntities","kindReducer","kindMemo","newData","data","embedPreviews","getAuthors","getThemeSupports","getEmbedPreview","record","context","values","embedProxyResponse","isResolving","isRequestingEmbedPreview","getUserQueryResults","queryResults","getEntitiesByKind","filter","getEntity","queriedState","isPreviewEmbedFallback","oEmbedLinkCheck","html","isMatch","actionProperty","nextKeyState","replacer","fn","cache","has","isObjectLike"],"mappings":"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iB,kBAAkB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,iBAAiB;AAC5B,WAAW,EAAE;AACb;AACA,YAAY,OAAO;AACnB;AACA;AACA;AACA;AACA,+CAA+C;AAC/C;;AAEA;AACA;AACA,GAAG;;;AAGH,2CAA2C;;AAE3C;;AAEA,iBAAiB,uBAAuB;AACxC;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,GAAG;AACH;;;AAGA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,aAAa;AAC1B;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA,qBAAqB,qBAAqB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,OAAO;AACrB;;;AAGA;AACA;;AAEA;AACA;AACA;AACA,eAAe,EAAE;AACjB,eAAe,EAAE;AACjB;AACA,gBAAgB,iBAAiB;AACjC;AACA;AACA;AACA;AACA;;AAEA;AACA,OAAO;;;AAGP;AACA,mCAAmC;;AAEnC;;AAEA,qBAAqB,uBAAuB;AAC5C;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,OAAO;AACP;AACA;AACA;;;AAGA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB;AACA,gBAAgB,GAAG;AACnB;AACA;;AAEA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB;AACA,gBAAgB,QAAQ;AACxB;;AAEA,GAAG;AACH;AACA;AACA;AACA;AACA,OAAO;AACP;;;AAGA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB;AACA,gBAAgB,QAAQ;AACxB;AACA;;AAEA,GAAG;AACH;AACA;AACA;AACA;AACA,OAAO;AACP;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAAS;AACxB,eAAe,EAAE;AACjB;AACA;;AAEA,GAAG;AACH;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,OAAO;AACP;AACA;AACA;AACA;;AAEA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA,CAAC;;AAED;;;;;;;;;;;;;AClTA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAA6C;;AAE7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,WAAW,IAAI;AACf,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,WAAW,IAAI;AACf;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA;AACA;AACA,aAAa,MAAM;AACnB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,IAAI;AACnB;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,SAAS;AACtB,eAAe,SAAS;AACxB;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;;AAEA,mBAAmB,sBAAsB;AACzC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,SAAS;AACtB,eAAe;AACf;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,eAAe,WAAW;AAC1B;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA,mBAAmB,aAAa;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK,OAAO,yDAAY;AACxB;AACA,KAAK;AACL,GAAG;AACH;AACA;;;AAGA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG,QAAQ,yDAAY;AACvB;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA,GAAG,aAAa;;AAEhB;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,oEAAoE;AACpE;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,SAAS;AACtB;AACA;;;AAGA;AACA;AACA;;AAEA,iBAAiB,wBAAwB;AACzC;;AAEA,QAAQ,IAAqC;AAC7C;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,MAAM,IAAqC;AAC3C;AACA;;AAEA;;AAEA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,QAAQ,IAAqC;AAC7C;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,oBAAoB,8BAA8B;AAClD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,gBAAgB;AAC3B;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,aAAa,gBAAgB;AAC7B;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA,iBAAiB,iBAAiB;AAClC;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA;AACA,iBAAiB,sBAAsB;AACvC;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA,KAAK;AACL;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,YAAY;AACvB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA,sEAAsE,aAAa;AACnF;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,YAAY;AACvB,aAAa,SAAS;AACtB;;AAEA;AACA,4EAA4E,aAAa;AACzF;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,6BAA6B;AAC7B;AACA,OAAO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA,IAAI,KAAqC;AACzC;AACA;;AAEgI;;;;;;;;;;;;;AC3nBhI;AAAA;AAAA;AACqC;;AAErC;;AAEA;AACA;AACA,CAAC;AACD;AACA,CAAC;AACD;AACA,CAAC,UAAU,IAA6B;AACxC;AACA,CAAC,MAAM,EAEN;;AAED,aAAa,4DAAQ;AACN,qEAAM,EAAC;;;;;;;;;;;;;;AClBtB;AAAA;AAAe;AACf;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,EAAE;AACF;AACA;;AAEA;AACA;;;;;;;;;;;;;AChBA;AAAa;;AAEb;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;;AAEA;AACA;AACA;AACA,WAAW,EAAE;AACb;AACA,YAAY,MAAM;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb;AACA,YAAY,QAAQ;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,YAAY,OAAO;AACnB;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB;AACA,YAAY,QAAQ;AACpB;AACA;AACA;;AAEA;AACA;AACA;;AAEA,qBAAqB,cAAc;AACnC;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB;AACA;AACA;AACA,YAAY,SAAS;AACrB;AACe;AACf;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa,iBAAiB;AAC9B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,MAAM;AAClB;AACA,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA,cAAc,uBAAuB;AACrC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,YAAY,OAAO;AACnB,YAAY,KAAK;AACjB;AACA,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;AACA;AACA,cAAc,SAAS;AACvB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,CAAC;;;;;;;;;;;;ACjRD;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;;AAEA;AACA;AACA,4CAA4C;;AAE5C;;;;;;;;;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;;;;;;;;;;;ACvBA,aAAa,yCAAyC,EAAE,I;;;;;;;;;;;ACAxD,aAAa,qCAAqC,EAAE,I;;;;;;;;;;;ACApD,aAAa,oCAAoC,EAAE,I;;;;;;;;;;;ACAnD,aAAa,iCAAiC,EAAE,I","file":"core-data.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./node_modules/@wordpress/core-data/build-module/index.js\");\n","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  }\n}","export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}","export default function _iterableToArray(iter) {\n  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}","export default function _iterableToArrayLimit(arr, i) {\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n}","export default function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}","import defineProperty from \"./defineProperty\";\nexport default function _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n    var ownKeys = Object.keys(source);\n\n    if (typeof Object.getOwnPropertySymbols === 'function') {\n      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n      }));\n    }\n\n    ownKeys.forEach(function (key) {\n      defineProperty(target, key, source[key]);\n    });\n  }\n\n  return target;\n}","import arrayWithHoles from \"./arrayWithHoles\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit\";\nimport nonIterableRest from \"./nonIterableRest\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();\n}","import arrayWithoutHoles from \"./arrayWithoutHoles\";\nimport iterableToArray from \"./iterableToArray\";\nimport nonIterableSpread from \"./nonIterableSpread\";\nexport default function _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();\n}","/**\n * External dependencies\n */\nimport { castArray } from 'lodash';\n\n/**\n * Internal dependencies\n */\nimport {\n\treceiveItems,\n\treceiveQueriedItems,\n} from './queried-data';\n\n/**\n * Returns an action object used in signalling that authors have been received.\n *\n * @param {string}       queryID Query ID.\n * @param {Array|Object} users   Users received.\n *\n * @return {Object} Action object.\n */\nexport function receiveUserQuery( queryID, users ) {\n\treturn {\n\t\ttype: 'RECEIVE_USER_QUERY',\n\t\tusers: castArray( users ),\n\t\tqueryID,\n\t};\n}\n\n/**\n * Returns an action object used in adding new entities.\n *\n * @param {Array} entities  Entities received.\n *\n * @return {Object} Action object.\n */\nexport function addEntities( entities ) {\n\treturn {\n\t\ttype: 'ADD_ENTITIES',\n\t\tentities,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that entity records have been received.\n *\n * @param {string}       kind    Kind of the received entity.\n * @param {string}       name    Name of the received entity.\n * @param {Array|Object} records Records received.\n * @param {?Object}      query  Query Object.\n *\n * @return {Object} Action object.\n */\nexport function receiveEntityRecords( kind, name, records, query ) {\n\tlet action;\n\tif ( query ) {\n\t\taction = receiveQueriedItems( records, query );\n\t} else {\n\t\taction = receiveItems( records );\n\t}\n\n\treturn {\n\t\t...action,\n\t\tkind,\n\t\tname,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that the index has been received.\n *\n * @param {Object} index Index received.\n *\n * @return {Object} Action object.\n */\nexport function receiveThemeSupportsFromIndex( index ) {\n\treturn {\n\t\ttype: 'RECEIVE_THEME_SUPPORTS',\n\t\tthemeSupports: index.theme_supports,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that the preview data for\n * a given URl has been received.\n *\n * @param {string}  url      URL to preview the embed for.\n * @param {Mixed}   preview  Preview data.\n *\n * @return {Object} Action object.\n */\nexport function receiveEmbedPreview( url, preview ) {\n\treturn {\n\t\ttype: 'RECEIVE_EMBED_PREVIEW',\n\t\turl,\n\t\tpreview,\n\t};\n}\n","/**\n * WordPress dependencies\n */\nimport { default as triggerApiFetch } from '@wordpress/api-fetch';\nimport { select as selectData } from '@wordpress/data';\n\n/**\n * Trigger an API Fetch request.\n *\n * @param {Object} request API Fetch Request Object.\n * @return {Object} control descriptor.\n */\nexport function apiFetch( request ) {\n\treturn {\n\t\ttype: 'API_FETCH',\n\t\trequest,\n\t};\n}\n\n/**\n * Calls a selector using the current state.\n * @param {string} selectorName Selector name.\n * @param  {Array} args         Selector arguments.\n *\n * @return {Object} control descriptor.\n */\nexport function select( selectorName, ...args ) {\n\treturn {\n\t\ttype: 'SELECT',\n\t\tselectorName,\n\t\targs,\n\t};\n}\n\nconst controls = {\n\tAPI_FETCH( { request } ) {\n\t\treturn triggerApiFetch( request );\n\t},\n\n\tSELECT( { selectorName, args } ) {\n\t\treturn selectData( 'core' )[ selectorName ]( ...args );\n\t},\n};\n\nexport default controls;\n","/**\n * External dependencies\n */\nimport { upperFirst, camelCase, map, find } from 'lodash';\n\n/**\n * Internal dependencies\n */\nimport { addEntities } from './actions';\nimport { apiFetch, select } from './controls';\n\nexport const defaultEntities = [\n\t{ name: 'postType', kind: 'root', key: 'slug', baseURL: '/wp/v2/types' },\n\t{ name: 'media', kind: 'root', baseURL: '/wp/v2/media', plural: 'mediaItems' },\n\t{ name: 'taxonomy', kind: 'root', key: 'slug', baseURL: '/wp/v2/taxonomies', plural: 'taxonomies' },\n];\n\nexport const kinds = [\n\t{ name: 'postType', loadEntities: loadPostTypeEntities },\n\t{ name: 'taxonomy', loadEntities: loadTaxonomyEntities },\n];\n\n/**\n * Returns the list of post type entities.\n *\n * @return {Promise} Entities promise\n */\nfunction* loadPostTypeEntities() {\n\tconst postTypes = yield apiFetch( { path: '/wp/v2/types?context=edit' } );\n\treturn map( postTypes, ( postType, name ) => {\n\t\treturn {\n\t\t\tkind: 'postType',\n\t\t\tbaseURL: '/wp/v2/' + postType.rest_base,\n\t\t\tname,\n\t\t};\n\t} );\n}\n\n/**\n * Returns the list of the taxonomies entities.\n *\n * @return {Promise} Entities promise\n */\nfunction* loadTaxonomyEntities() {\n\tconst taxonomies = yield apiFetch( { path: '/wp/v2/taxonomies?context=edit' } );\n\treturn map( taxonomies, ( taxonomy, name ) => {\n\t\treturn {\n\t\t\tkind: 'taxonomy',\n\t\t\tbaseURL: '/wp/v2/' + taxonomy.rest_base,\n\t\t\tname,\n\t\t};\n\t} );\n}\n\n/**\n * Returns the entity's getter method name given its kind and name.\n *\n * @param {string}  kind      Entity kind.\n * @param {string}  name      Entity name.\n * @param {string}  prefix    Function prefix.\n * @param {boolean} usePlural Whether to use the plural form or not.\n *\n * @return {string} Method name\n */\nexport const getMethodName = ( kind, name, prefix = 'get', usePlural = false ) => {\n\tconst entity = find( defaultEntities, { kind, name } );\n\tconst kindPrefix = kind === 'root' ? '' : upperFirst( camelCase( kind ) );\n\tconst nameSuffix = upperFirst( camelCase( name ) ) + ( usePlural ? 's' : '' );\n\tconst suffix = usePlural && entity.plural ? upperFirst( camelCase( entity.plural ) ) : nameSuffix;\n\treturn `${ prefix }${ kindPrefix }${ suffix }`;\n};\n\n/**\n * Loads the kind entities into the store.\n *\n * @param {string} kind  Kind\n *\n * @return {Array} Entities\n */\nexport function* getKindEntities( kind ) {\n\tlet entities = yield select( 'getEntitiesByKind', kind );\n\tif ( entities && entities.length !== 0 ) {\n\t\treturn entities;\n\t}\n\n\tconst kindConfig = find( kinds, { name: kind } );\n\tif ( ! kindConfig ) {\n\t\treturn [];\n\t}\n\n\tentities = yield kindConfig.loadEntities();\n\tyield addEntities( entities );\n\n\treturn entities;\n}\n","/**\n * WordPress dependencies\n */\nimport { registerStore } from '@wordpress/data';\n\n/**\n * Internal dependencies\n */\nimport reducer from './reducer';\nimport controls from './controls';\nimport * as selectors from './selectors';\nimport * as actions from './actions';\nimport * as resolvers from './resolvers';\nimport { defaultEntities, getMethodName } from './entities';\nimport { REDUCER_KEY } from './name';\n\nconst createEntityRecordSelector = ( source ) => defaultEntities.reduce( ( result, entity ) => {\n\tconst { kind, name } = entity;\n\tresult[ getMethodName( kind, name ) ] = ( state, key ) => source.getEntityRecord( state, kind, name, key );\n\tresult[ getMethodName( kind, name, 'get', true ) ] = ( state, ...args ) => source.getEntityRecords( state, kind, name, ...args );\n\treturn result;\n}, {} );\n\nconst createEntityRecordResolver = ( source ) => defaultEntities.reduce( ( result, entity ) => {\n\tconst { kind, name } = entity;\n\tresult[ getMethodName( kind, name ) ] = ( key ) => source.getEntityRecord( kind, name, key );\n\tresult[ getMethodName( kind, name, 'get', true ) ] = ( ...args ) => source.getEntityRecords( kind, name, ...args );\n\treturn result;\n}, {} );\n\nconst entityResolvers = createEntityRecordResolver( resolvers );\nconst entitySelectors = createEntityRecordSelector( selectors );\n\nconst store = registerStore( REDUCER_KEY, {\n\treducer,\n\tactions,\n\tcontrols,\n\tselectors: { ...selectors, ...entitySelectors },\n\tresolvers: { ...resolvers, ...entityResolvers },\n} );\n\nexport default store;\n","/**\n * The reducer key used by core data in store registration.\n * This is defined in a separate file to avoid cycle-dependency\n *\n * @type {string}\n */\nexport const REDUCER_KEY = 'core';\n","/**\n * External dependencies\n */\nimport { castArray } from 'lodash';\n\n/**\n * Returns an action object used in signalling that items have been received.\n *\n * @param {Array} items Items received.\n *\n * @return {Object} Action object.\n */\nexport function receiveItems( items ) {\n\treturn {\n\t\ttype: 'RECEIVE_ITEMS',\n\t\titems: castArray( items ),\n\t};\n}\n\n/**\n * Returns an action object used in signalling that queried data has been\n * received.\n *\n * @param {Array}   items Queried items received.\n * @param {?Object} query Optional query object.\n *\n * @return {Object} Action object.\n */\nexport function receiveQueriedItems( items, query = {} ) {\n\treturn {\n\t\t...receiveItems( items ),\n\t\tquery,\n\t};\n}\n","/**\n * WordPress dependencies\n */\nimport { addQueryArgs } from '@wordpress/url';\n\n/**\n * Internal dependencies\n */\nimport { withWeakMapCache } from '../utils';\n\n/**\n * An object of properties describing a specific query.\n *\n * @typedef {WPQueriedDataQueryParts}\n *\n * @property {number} page      The query page (1-based index, default 1).\n * @property {number} perPage   Items per page for query (default 10).\n * @property {string} stableKey An encoded stable string of all non-pagination\n *                              query parameters.\n */\n\n/**\n * Given a query object, returns an object of parts, including pagination\n * details (`page` and `perPage`, or default values). All other properties are\n * encoded into a stable (idempotent) `stableKey` value.\n *\n * @param {Object} query Optional query object.\n *\n * @return {WPQueriedDataQueryParts} Query parts.\n */\nexport function getQueryParts( query ) {\n\t/**\n\t * @type {WPQueriedDataQueryParts}\n\t */\n\tconst parts = {\n\t\tstableKey: '',\n\t\tpage: 1,\n\t\tperPage: 10,\n\t};\n\n\t// Ensure stable key by sorting keys. Also more efficient for iterating.\n\tconst keys = Object.keys( query ).sort();\n\n\tfor ( let i = 0; i < keys.length; i++ ) {\n\t\tconst key = keys[ i ];\n\t\tconst value = query[ key ];\n\n\t\tswitch ( key ) {\n\t\t\tcase 'page':\n\t\t\t\tparts[ key ] = Number( value );\n\t\t\t\tbreak;\n\t\t\tcase 'per_page':\n\t\t\t\tparts.perPage = Number( value );\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\t// While it could be any deterministic string, for simplicity's\n\t\t\t\t// sake mimic querystring encoding for stable key.\n\t\t\t\t//\n\t\t\t\t// TODO: For consistency with PHP implementation, addQueryArgs\n\t\t\t\t// should accept a key value pair, which may optimize its\n\t\t\t\t// implementation for our use here, vs. iterating an object\n\t\t\t\t// with only a single key.\n\t\t\t\tparts.stableKey += (\n\t\t\t\t\t( parts.stableKey ? '&' : '' ) +\n\t\t\t\t\taddQueryArgs( '', { [ key ]: value } ).slice( 1 )\n\t\t\t\t);\n\t\t}\n\t}\n\n\treturn parts;\n}\n\nexport default withWeakMapCache( getQueryParts );\n","export * from './actions';\nexport * from './selectors';\nexport { default as reducer } from './reducer';\n","/**\n * External dependencies\n */\nimport { combineReducers } from 'redux';\nimport { keyBy, map, flowRight } from 'lodash';\n\n/**\n * Internal dependencies\n */\nimport {\n\tifMatchingAction,\n\treplaceAction,\n\tonSubKey,\n} from '../utils';\nimport getQueryParts from './get-query-parts';\n\n/**\n * Returns a merged array of item IDs, given details of the received paginated\n * items. The array is sparse-like with `undefined` entries where holes exist.\n *\n * @param {?Array<number>} itemIds     Original item IDs (default empty array).\n * @param {number[]}       nextItemIds Item IDs to merge.\n * @param {number}         page        Page of items merged.\n * @param {number}         perPage     Number of items per page.\n *\n * @return {number[]} Merged array of item IDs.\n */\nexport function getMergedItemIds( itemIds, nextItemIds, page, perPage ) {\n\tconst nextItemIdsStartIndex = ( page - 1 ) * perPage;\n\n\t// If later page has already been received, default to the larger known\n\t// size of the existing array, else calculate as extending the existing.\n\tconst size = Math.max(\n\t\titemIds.length,\n\t\tnextItemIdsStartIndex + nextItemIds.length\n\t);\n\n\t// Preallocate array since size is known.\n\tconst mergedItemIds = new Array( size );\n\n\tfor ( let i = 0; i < size; i++ ) {\n\t\t// Preserve existing item ID except for subset of range of next items.\n\t\tconst isInNextItemsRange = (\n\t\t\ti >= nextItemIdsStartIndex &&\n\t\t\ti < nextItemIdsStartIndex + nextItemIds.length\n\t\t);\n\n\t\tmergedItemIds[ i ] = isInNextItemsRange ?\n\t\t\tnextItemIds[ i - nextItemIdsStartIndex ] :\n\t\t\titemIds[ i ];\n\t}\n\n\treturn mergedItemIds;\n}\n\n/**\n * Reducer tracking items state, keyed by ID. Items are assumed to be normal,\n * where identifiers are common across all queries.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Next state.\n */\nfunction items( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_ITEMS':\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t...keyBy( action.items, action.key || 'id' ),\n\t\t\t};\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer tracking queries state, keyed by stable query key. Each reducer\n * query object includes `itemIds` and `requestingPageByPerPage`.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Next state.\n */\nconst queries = flowRight( [\n\t// Limit to matching action type so we don't attempt to replace action on\n\t// an unhandled action.\n\tifMatchingAction( ( action ) => 'query' in action ),\n\n\t// Inject query parts into action for use both in `onSubKey` and reducer.\n\treplaceAction( ( action ) => {\n\t\t// `ifMatchingAction` still passes on initialization, where state is\n\t\t// undefined and a query is not assigned. Avoid attempting to parse\n\t\t// parts. `onSubKey` will omit by lack of `stableKey`.\n\t\tif ( action.query ) {\n\t\t\treturn {\n\t\t\t\t...action,\n\t\t\t\t...getQueryParts( action.query ),\n\t\t\t};\n\t\t}\n\n\t\treturn action;\n\t} ),\n\n\t// Queries shape is shared, but keyed by query `stableKey` part. Original\n\t// reducer tracks only a single query object.\n\tonSubKey( 'stableKey' ),\n] )( ( state = null, action ) => {\n\tconst { type, page, perPage, key = 'id' } = action;\n\n\tif ( type !== 'RECEIVE_ITEMS' ) {\n\t\treturn state;\n\t}\n\n\treturn getMergedItemIds(\n\t\tstate || [],\n\t\tmap( action.items, key ),\n\t\tpage,\n\t\tperPage\n\t);\n} );\n\nexport default combineReducers( {\n\titems,\n\tqueries,\n} );\n","/**\n * External dependencies\n */\nimport createSelector from 'rememo';\nimport EquivalentKeyMap from 'equivalent-key-map';\n\n/**\n * Internal dependencies\n */\nimport getQueryParts from './get-query-parts';\n\n/**\n * Cache of state keys to EquivalentKeyMap where the inner map tracks queries\n * to their resulting items set. WeakMap allows garbage collection on expired\n * state references.\n *\n * @type {WeakMap<Object,EquivalentKeyMap>}\n */\nconst queriedItemsCacheByState = new WeakMap();\n\n/**\n * Returns items for a given query, or null if the items are not known.\n *\n * @param {Object}  state State object.\n * @param {?Object} query Optional query.\n *\n * @return {?Array} Query items.\n */\nfunction getQueriedItemsUncached( state, query ) {\n\tconst { stableKey, page, perPage } = getQueryParts( query );\n\n\tif ( ! state.queries[ stableKey ] ) {\n\t\treturn null;\n\t}\n\n\tconst itemIds = state.queries[ stableKey ];\n\tif ( ! itemIds ) {\n\t\treturn null;\n\t}\n\n\tconst startOffset = perPage === -1 ? 0 : ( page - 1 ) * perPage;\n\tconst endOffset = perPage === -1 ? itemIds.length : Math.min(\n\t\tstartOffset + perPage,\n\t\titemIds.length\n\t);\n\n\tconst items = [];\n\tfor ( let i = startOffset; i < endOffset; i++ ) {\n\t\tconst itemId = itemIds[ i ];\n\t\titems.push( state.items[ itemId ] );\n\t}\n\n\treturn items;\n}\n\n/**\n * Returns items for a given query, or null if the items are not known. Caches\n * result both per state (by reference) and per query (by deep equality).\n * The caching approach is intended to be durable to query objects which are\n * deeply but not referentially equal, since otherwise:\n *\n * `getQueriedItems( state, {} ) !== getQueriedItems( state, {} )`\n *\n * @param {Object}  state State object.\n * @param {?Object} query Optional query.\n *\n * @return {?Array} Query items.\n */\nexport const getQueriedItems = createSelector( ( state, query = {} ) => {\n\tlet queriedItemsCache = queriedItemsCacheByState.get( state );\n\tif ( queriedItemsCache ) {\n\t\tconst queriedItems = queriedItemsCache.get( query );\n\t\tif ( queriedItems !== undefined ) {\n\t\t\treturn queriedItems;\n\t\t}\n\t} else {\n\t\tqueriedItemsCache = new EquivalentKeyMap();\n\t\tqueriedItemsCacheByState.set( state, queriedItemsCache );\n\t}\n\n\tconst items = getQueriedItemsUncached( state, query );\n\tqueriedItemsCache.set( query, items );\n\treturn items;\n} );\n","/**\n * External dependencies\n */\nimport { keyBy, map, groupBy, flowRight } from 'lodash';\n\n/**\n * WordPress dependencies\n */\nimport { combineReducers } from '@wordpress/data';\n\n/**\n * Internal dependencies\n */\nimport { ifMatchingAction, replaceAction } from './utils';\nimport { reducer as queriedDataReducer } from './queried-data';\nimport { defaultEntities } from './entities';\n\n/**\n * Reducer managing terms state. Keyed by taxonomy slug, the value is either\n * undefined (if no request has been made for given taxonomy), null (if a\n * request is in-flight for given taxonomy), or the array of terms for the\n * taxonomy.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function terms( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_TERMS':\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ action.taxonomy ]: action.terms,\n\t\t\t};\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer managing authors state. Keyed by id.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function users( state = { byId: {}, queries: {} }, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_USER_QUERY':\n\t\t\treturn {\n\t\t\t\tbyId: {\n\t\t\t\t\t...state.byId,\n\t\t\t\t\t...keyBy( action.users, 'id' ),\n\t\t\t\t},\n\t\t\t\tqueries: {\n\t\t\t\t\t...state.queries,\n\t\t\t\t\t[ action.queryID ]: map( action.users, ( user ) => user.id ),\n\t\t\t\t},\n\t\t\t};\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer managing taxonomies.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function taxonomies( state = [], action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_TAXONOMIES':\n\t\t\treturn action.taxonomies;\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer managing theme supports data.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function themeSupports( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_THEME_SUPPORTS':\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t...action.themeSupports,\n\t\t\t};\n\t}\n\n\treturn state;\n}\n\n/**\n * Higher Order Reducer for a given entity config. It supports:\n *\n *  - Fetching a record by primary key\n *\n * @param {Object} entityConfig  Entity config.\n *\n * @return {Function} Reducer.\n */\nfunction entity( entityConfig ) {\n\treturn flowRight( [\n\t\t// Limit to matching action type so we don't attempt to replace action on\n\t\t// an unhandled action.\n\t\tifMatchingAction( ( action ) => (\n\t\t\taction.name &&\n\t\t\taction.kind &&\n\t\t\taction.name === entityConfig.name &&\n\t\t\taction.kind === entityConfig.kind\n\t\t) ),\n\n\t\t// Inject the entity config into the action.\n\t\treplaceAction( ( action ) => {\n\t\t\treturn {\n\t\t\t\t...action,\n\t\t\t\tkey: entityConfig.key || 'id',\n\t\t\t};\n\t\t} ),\n\t] )( queriedDataReducer );\n}\n\n/**\n * Reducer keeping track of the registered entities.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function entitiesConfig( state = defaultEntities, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'ADD_ENTITIES':\n\t\t\treturn [\n\t\t\t\t...state,\n\t\t\t\t...action.entities,\n\t\t\t];\n\t}\n\n\treturn state;\n}\n\n/**\n * Reducer keeping track of the registered entities config and data.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport const entities = ( state = {}, action ) => {\n\tconst newConfig = entitiesConfig( state.config, action );\n\n\t// Generates a dynamic reducer for the entities\n\tlet entitiesDataReducer = state.reducer;\n\tif ( ! entitiesDataReducer || newConfig !== state.config ) {\n\t\tconst entitiesByKind = groupBy( newConfig, 'kind' );\n\t\tentitiesDataReducer = combineReducers( Object.entries( entitiesByKind ).reduce( ( memo, [ kind, subEntities ] ) => {\n\t\t\tconst kindReducer = combineReducers( subEntities.reduce(\n\t\t\t\t( kindMemo, entityConfig ) => ( {\n\t\t\t\t\t...kindMemo,\n\t\t\t\t\t[ entityConfig.name ]: entity( entityConfig ),\n\t\t\t\t} ),\n\t\t\t\t{}\n\t\t\t) );\n\n\t\t\tmemo[ kind ] = kindReducer;\n\t\t\treturn memo;\n\t\t}, {} ) );\n\t}\n\n\tconst newData = entitiesDataReducer( state.data, action );\n\n\tif (\n\t\tnewData === state.data &&\n\t\tnewConfig === state.config &&\n\t\tentitiesDataReducer === state.reducer\n\t) {\n\t\treturn state;\n\t}\n\n\treturn {\n\t\treducer: entitiesDataReducer,\n\t\tdata: newData,\n\t\tconfig: newConfig,\n\t};\n};\n\n/**\n * Reducer managing embed preview data.\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @return {Object} Updated state.\n */\nexport function embedPreviews( state = {}, action ) {\n\tswitch ( action.type ) {\n\t\tcase 'RECEIVE_EMBED_PREVIEW':\n\t\t\tconst { url, preview } = action;\n\t\t\treturn {\n\t\t\t\t...state,\n\t\t\t\t[ url ]: preview,\n\t\t\t};\n\t}\n\treturn state;\n}\n\nexport default combineReducers( {\n\tterms,\n\tusers,\n\ttaxonomies,\n\tthemeSupports,\n\tentities,\n\tembedPreviews,\n} );\n","/**\n * External dependencies\n */\nimport { find } from 'lodash';\n\n/**\n * WordPress dependencies\n */\nimport { addQueryArgs } from '@wordpress/url';\n\n/**\n * Internal dependencies\n */\nimport {\n\treceiveUserQuery,\n\treceiveEntityRecords,\n\treceiveThemeSupportsFromIndex,\n\treceiveEmbedPreview,\n} from './actions';\nimport { getKindEntities } from './entities';\nimport { apiFetch } from './controls';\n\n/**\n * Requests authors from the REST API.\n */\nexport function* getAuthors() {\n\tconst users = yield apiFetch( { path: '/wp/v2/users/?who=authors&per_page=-1' } );\n\tyield receiveUserQuery( 'authors', users );\n}\n\n/**\n * Requests an entity's record from the REST API.\n *\n * @param {string} kind   Entity kind.\n * @param {string} name   Entity name.\n * @param {number} key    Record's key\n */\nexport function* getEntityRecord( kind, name, key ) {\n\tconst entities = yield getKindEntities( kind );\n\tconst entity = find( entities, { kind, name } );\n\tif ( ! entity ) {\n\t\treturn;\n\t}\n\tconst record = yield apiFetch( { path: `${ entity.baseURL }/${ key }?context=edit` } );\n\tyield receiveEntityRecords( kind, name, record );\n}\n\n/**\n * Requests the entity's records from the REST API.\n *\n * @param {string}  kind   Entity kind.\n * @param {string}  name   Entity name.\n * @param {Object?} query  Query Object.\n */\nexport function* getEntityRecords( kind, name, query = {} ) {\n\tconst entities = yield getKindEntities( kind );\n\tconst entity = find( entities, { kind, name } );\n\tif ( ! entity ) {\n\t\treturn;\n\t}\n\tconst path = addQueryArgs( entity.baseURL, {\n\t\t...query,\n\t\tcontext: 'edit',\n\t} );\n\tconst records = yield apiFetch( { path } );\n\tyield receiveEntityRecords( kind, name, Object.values( records ), query );\n}\n\n/**\n * Requests theme supports data from the index.\n */\nexport function* getThemeSupports() {\n\tconst index = yield apiFetch( { path: '/' } );\n\tyield receiveThemeSupportsFromIndex( index );\n}\n\n/**\n * Requests a preview from the from the Embed API.\n *\n * @param {string} url   URL to get the preview for.\n */\nexport function* getEmbedPreview( url ) {\n\ttry {\n\t\tconst embedProxyResponse = yield apiFetch( { path: addQueryArgs( '/oembed/1.0/proxy', { url } ) } );\n\t\tyield receiveEmbedPreview( url, embedProxyResponse );\n\t} catch ( error ) {\n\t\t// Embed API 404s if the URL cannot be embedded, so we have to catch the error from the apiRequest here.\n\t\tyield receiveEmbedPreview( url, false );\n\t}\n}\n","/**\n * External dependencies\n */\nimport createSelector from 'rememo';\nimport { map, find, get, filter } from 'lodash';\n\n/**\n * WordPress dependencies\n */\nimport { select } from '@wordpress/data';\n\n/**\n * Internal dependencies\n */\nimport { REDUCER_KEY } from './name';\nimport { getQueriedItems } from './queried-data';\n\n/**\n * Returns true if resolution is in progress for the core selector of the given\n * name and arguments.\n *\n * @param {string} selectorName Core data selector name.\n * @param {...*}   args         Arguments passed to selector.\n *\n * @return {boolean} Whether resolution is in progress.\n */\nfunction isResolving( selectorName, ...args ) {\n\treturn select( 'core/data' ).isResolving( REDUCER_KEY, selectorName, args );\n}\n\n/**\n * Returns true if a request is in progress for embed preview data, or false\n * otherwise.\n *\n * @param {Object} state Data state.\n * @param {string} url   URL the preview would be for.\n *\n * @return {boolean} Whether a request is in progress for an embed preview.\n */\nexport function isRequestingEmbedPreview( state, url ) {\n\treturn isResolving( 'getEmbedPreview', url );\n}\n\n/**\n * Returns all available authors.\n *\n * @param {Object} state Data state.\n *\n * @return {Array} Authors list.\n */\nexport function getAuthors( state ) {\n\treturn getUserQueryResults( state, 'authors' );\n}\n\n/**\n * Returns all the users returned by a query ID.\n *\n * @param {Object} state   Data state.\n * @param {string} queryID Query ID.\n *\n * @return {Array} Users list.\n */\nexport const getUserQueryResults = createSelector(\n\t( state, queryID ) => {\n\t\tconst queryResults = state.users.queries[ queryID ];\n\n\t\treturn map( queryResults, ( id ) => state.users.byId[ id ] );\n\t},\n\t( state, queryID ) => [ state.users.queries[ queryID ], state.users.byId ]\n);\n\n/**\n * Returns whether the entities for the give kind are loaded.\n *\n * @param {Object} state   Data state.\n * @param {string} kind  Entity kind.\n *\n * @return {boolean} Whether the entities are loaded\n */\nexport function getEntitiesByKind( state, kind ) {\n\treturn filter( state.entities.config, { kind } );\n}\n\n/**\n * Returns the entity object given its kind and name.\n *\n * @param {Object} state   Data state.\n * @param {string} kind  Entity kind.\n * @param {string} name  Entity name.\n *\n * @return {Object} Entity\n */\nexport function getEntity( state, kind, name ) {\n\treturn find( state.entities.config, { kind, name } );\n}\n\n/**\n * Returns the Entity's record object by key.\n *\n * @param {Object} state  State tree\n * @param {string} kind   Entity kind.\n * @param {string} name   Entity name.\n * @param {number} key    Record's key\n *\n * @return {Object?} Record.\n */\nexport function getEntityRecord( state, kind, name, key ) {\n\treturn get( state.entities.data, [ kind, name, 'items', key ] );\n}\n\n/**\n * Returns the Entity's records.\n *\n * @param {Object}  state  State tree\n * @param {string}  kind   Entity kind.\n * @param {string}  name   Entity name.\n * @param {?Object} query  Optional terms query.\n *\n * @return {Array} Records.\n */\nexport function getEntityRecords( state, kind, name, query ) {\n\tconst queriedState = get( state.entities.data, [ kind, name ] );\n\tif ( ! queriedState ) {\n\t\treturn [];\n\t}\n\treturn getQueriedItems( queriedState, query );\n}\n\n/**\n * Return theme supports data in the index.\n *\n * @param {Object} state Data state.\n *\n * @return {*}           Index data.\n */\nexport function getThemeSupports( state ) {\n\treturn state.themeSupports;\n}\n\n/**\n * Returns the embed preview for the given URL.\n *\n * @param {Object} state    Data state.\n * @param {string} url      Embedded URL.\n *\n * @return {*} Undefined if the preview has not been fetched, otherwise, the preview fetched from the embed preview API.\n */\nexport function getEmbedPreview( state, url ) {\n\treturn state.embedPreviews[ url ];\n}\n\n/**\n * Determines if the returned preview is an oEmbed link fallback.\n *\n * WordPress can be configured to return a simple link to a URL if it is not embeddable.\n * We need to be able to determine if a URL is embeddable or not, based on what we\n * get back from the oEmbed preview API.\n *\n * @param {Object} state    Data state.\n * @param {string} url      Embedded URL.\n *\n * @return {booleans} Is the preview for the URL an oEmbed link fallback.\n */\nexport function isPreviewEmbedFallback( state, url ) {\n\tconst preview = state.embedPreviews[ url ];\n\tconst oEmbedLinkCheck = '<a href=\"' + url + '\">' + url + '</a>';\n\tif ( ! preview ) {\n\t\treturn false;\n\t}\n\treturn preview.html === oEmbedLinkCheck;\n}\n","/**\n * A higher-order reducer creator which invokes the original reducer only if\n * the dispatching action matches the given predicate, **OR** if state is\n * initializing (undefined).\n *\n * @param {Function} isMatch Function predicate for allowing reducer call.\n *\n * @return {Function} Higher-order reducer.\n */\nconst ifMatchingAction = ( isMatch ) => ( reducer ) => ( state, action ) => {\n\tif ( state === undefined || isMatch( action ) ) {\n\t\treturn reducer( state, action );\n\t}\n\n\treturn state;\n};\n\nexport default ifMatchingAction;\n","export { default as ifMatchingAction } from './if-matching-action';\nexport { default as onSubKey } from './on-sub-key';\nexport { default as replaceAction } from './replace-action';\nexport { default as withWeakMapCache } from './with-weak-map-cache';\n","/**\n * Higher-order reducer creator which creates a combined reducer object, keyed\n * by a property on the action object.\n *\n * @param {string} actionProperty Action property by which to key object.\n *\n * @return {Function} Higher-order reducer.\n */\nexport const onSubKey = ( actionProperty ) => ( reducer ) => ( state = {}, action ) => {\n\t// Retrieve subkey from action. Do not track if undefined; useful for cases\n\t// where reducer is scoped by action shape.\n\tconst key = action[ actionProperty ];\n\tif ( key === undefined ) {\n\t\treturn state;\n\t}\n\n\t// Avoid updating state if unchanged. Note that this also accounts for a\n\t// reducer which returns undefined on a key which is not yet tracked.\n\tconst nextKeyState = reducer( state[ key ], action );\n\tif ( nextKeyState === state[ key ] ) {\n\t\treturn state;\n\t}\n\n\treturn {\n\t\t...state,\n\t\t[ key ]: nextKeyState,\n\t};\n};\n\nexport default onSubKey;\n","/**\n * Higher-order reducer creator which substitutes the action object before\n * passing to the original reducer.\n *\n * @param {Function} replacer Function mapping original action to replacement.\n *\n * @return {Function} Higher-order reducer.\n */\nconst replaceAction = ( replacer ) => ( reducer ) => ( state, action ) => {\n\treturn reducer( state, replacer( action ) );\n};\n\nexport default replaceAction;\n","/**\n * External dependencies\n */\nimport { isObjectLike } from 'lodash';\n\n/**\n * Given a function, returns an enhanced function which caches the result and\n * tracks in WeakMap. The result is only cached if the original function is\n * passed a valid object-like argument (requirement for WeakMap key).\n *\n * @param {Function} fn Original function.\n *\n * @return {Function} Enhanced caching function.\n */\nfunction withWeakMapCache( fn ) {\n\tconst cache = new WeakMap();\n\n\treturn function( key ) {\n\t\tlet value;\n\t\tif ( cache.has( key ) ) {\n\t\t\tvalue = cache.get( key );\n\t\t} else {\n\t\t\tvalue = fn( key );\n\n\t\t\t// Can reach here if key is not valid for WeakMap, since `has`\n\t\t\t// will return false for invalid key. Since `set` will throw,\n\t\t\t// ensure that key is valid before setting into cache.\n\t\t\tif ( isObjectLike( key ) ) {\n\t\t\t\tcache.set( key, value );\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t};\n}\n\nexport default withWeakMapCache;\n","'use strict';\n\nfunction _typeof(obj) {\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function (obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function (obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\n/**\n * Given an instance of EquivalentKeyMap, returns its internal value pair tuple\n * for a key, if one exists. The tuple members consist of the last reference\n * value for the key (used in efficient subsequent lookups) and the value\n * assigned for the key at the leaf node.\n *\n * @param {EquivalentKeyMap} instance EquivalentKeyMap instance.\n * @param {*} key                     The key for which to return value pair.\n *\n * @return {?Array} Value pair, if exists.\n */\nfunction getValuePair(instance, key) {\n  var _map = instance._map,\n      _arrayTreeMap = instance._arrayTreeMap,\n      _objectTreeMap = instance._objectTreeMap; // Map keeps a reference to the last object-like key used to set the\n  // value, which can be used to shortcut immediately to the value.\n\n  if (_map.has(key)) {\n    return _map.get(key);\n  } // Sort keys to ensure stable retrieval from tree.\n\n\n  var properties = Object.keys(key).sort(); // Tree by type to avoid conflicts on numeric object keys, empty value.\n\n  var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap;\n\n  for (var i = 0; i < properties.length; i++) {\n    var property = properties[i];\n    map = map.get(property);\n\n    if (map === undefined) {\n      return;\n    }\n\n    var propertyValue = key[property];\n    map = map.get(propertyValue);\n\n    if (map === undefined) {\n      return;\n    }\n  }\n\n  var valuePair = map.get('_ekm_value');\n\n  if (!valuePair) {\n    return;\n  } // If reached, it implies that an object-like key was set with another\n  // reference, so delete the reference and replace with the current.\n\n\n  _map.delete(valuePair[0]);\n\n  valuePair[0] = key;\n  map.set('_ekm_value', valuePair);\n\n  _map.set(key, valuePair);\n\n  return valuePair;\n}\n/**\n * Variant of a Map object which enables lookup by equivalent (deeply equal)\n * object and array keys.\n */\n\n\nvar EquivalentKeyMap =\n/*#__PURE__*/\nfunction () {\n  /**\n   * Constructs a new instance of EquivalentKeyMap.\n   *\n   * @param {Iterable.<*>} iterable Initial pair of key, value for map.\n   */\n  function EquivalentKeyMap(iterable) {\n    _classCallCheck(this, EquivalentKeyMap);\n\n    this.clear();\n\n    if (iterable instanceof EquivalentKeyMap) {\n      // Map#forEach is only means of iterating with support for IE11.\n      var iterablePairs = [];\n      iterable.forEach(function (value, key) {\n        iterablePairs.push([key, value]);\n      });\n      iterable = iterablePairs;\n    }\n\n    if (iterable != null) {\n      for (var i = 0; i < iterable.length; i++) {\n        this.set(iterable[i][0], iterable[i][1]);\n      }\n    }\n  }\n  /**\n   * Accessor property returning the number of elements.\n   *\n   * @return {number} Number of elements.\n   */\n\n\n  _createClass(EquivalentKeyMap, [{\n    key: \"set\",\n\n    /**\n     * Add or update an element with a specified key and value.\n     *\n     * @param {*} key   The key of the element to add.\n     * @param {*} value The value of the element to add.\n     *\n     * @return {EquivalentKeyMap} Map instance.\n     */\n    value: function set(key, value) {\n      // Shortcut non-object-like to set on internal Map.\n      if (key === null || _typeof(key) !== 'object') {\n        this._map.set(key, value);\n\n        return this;\n      } // Sort keys to ensure stable assignment into tree.\n\n\n      var properties = Object.keys(key).sort();\n      var valuePair = [key, value]; // Tree by type to avoid conflicts on numeric object keys, empty value.\n\n      var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap;\n\n      for (var i = 0; i < properties.length; i++) {\n        var property = properties[i];\n\n        if (!map.has(property)) {\n          map.set(property, new EquivalentKeyMap());\n        }\n\n        map = map.get(property);\n        var propertyValue = key[property];\n\n        if (!map.has(propertyValue)) {\n          map.set(propertyValue, new EquivalentKeyMap());\n        }\n\n        map = map.get(propertyValue);\n      } // If an _ekm_value exists, there was already an equivalent key. Before\n      // overriding, ensure that the old key reference is removed from map to\n      // avoid memory leak of accumulating equivalent keys. This is, in a\n      // sense, a poor man's WeakMap, while still enabling iterability.\n\n\n      var previousValuePair = map.get('_ekm_value');\n\n      if (previousValuePair) {\n        this._map.delete(previousValuePair[0]);\n      }\n\n      map.set('_ekm_value', valuePair);\n\n      this._map.set(key, valuePair);\n\n      return this;\n    }\n    /**\n     * Returns a specified element.\n     *\n     * @param {*} key The key of the element to return.\n     *\n     * @return {?*} The element associated with the specified key or undefined\n     *              if the key can't be found.\n     */\n\n  }, {\n    key: \"get\",\n    value: function get(key) {\n      // Shortcut non-object-like to get from internal Map.\n      if (key === null || _typeof(key) !== 'object') {\n        return this._map.get(key);\n      }\n\n      var valuePair = getValuePair(this, key);\n\n      if (valuePair) {\n        return valuePair[1];\n      }\n    }\n    /**\n     * Returns a boolean indicating whether an element with the specified key\n     * exists or not.\n     *\n     * @param {*} key The key of the element to test for presence.\n     *\n     * @return {boolean} Whether an element with the specified key exists.\n     */\n\n  }, {\n    key: \"has\",\n    value: function has(key) {\n      if (key === null || _typeof(key) !== 'object') {\n        return this._map.has(key);\n      } // Test on the _presence_ of the pair, not its value, as even undefined\n      // can be a valid member value for a key.\n\n\n      return getValuePair(this, key) !== undefined;\n    }\n    /**\n     * Removes the specified element.\n     *\n     * @param {*} key The key of the element to remove.\n     *\n     * @return {boolean} Returns true if an element existed and has been\n     *                   removed, or false if the element does not exist.\n     */\n\n  }, {\n    key: \"delete\",\n    value: function _delete(key) {\n      if (!this.has(key)) {\n        return false;\n      } // This naive implementation will leave orphaned child trees. A better\n      // implementation should traverse and remove orphans.\n\n\n      this.set(key, undefined);\n      return true;\n    }\n    /**\n     * Executes a provided function once per each key/value pair, in insertion\n     * order.\n     *\n     * @param {Function} callback Function to execute for each element.\n     * @param {*}        thisArg  Value to use as `this` when executing\n     *                            `callback`.\n     */\n\n  }, {\n    key: \"forEach\",\n    value: function forEach(callback) {\n      var _this = this;\n\n      var thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;\n\n      this._map.forEach(function (value, key) {\n        // Unwrap value from object-like value pair.\n        if (key !== null && _typeof(key) === 'object') {\n          value = value[1];\n        }\n\n        callback.call(thisArg, value, key, _this);\n      });\n    }\n    /**\n     * Removes all elements.\n     */\n\n  }, {\n    key: \"clear\",\n    value: function clear() {\n      this._map = new Map();\n      this._arrayTreeMap = new Map();\n      this._objectTreeMap = new Map();\n    }\n  }, {\n    key: \"size\",\n    get: function get() {\n      return this._map.size;\n    }\n  }]);\n\n  return EquivalentKeyMap;\n}();\n\nmodule.exports = EquivalentKeyMap;\n","import $$observable from 'symbol-observable';\n\n/**\n * These are private action types reserved by Redux.\n * For any unknown actions, you must return the current state.\n * If the current state is undefined, you must return the initial state.\n * Do not reference these action types directly in your code.\n */\nvar randomString = function randomString() {\n  return Math.random().toString(36).substring(7).split('').join('.');\n};\n\nvar ActionTypes = {\n  INIT: \"@@redux/INIT\" + randomString(),\n  REPLACE: \"@@redux/REPLACE\" + randomString(),\n  PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {\n    return \"@@redux/PROBE_UNKNOWN_ACTION\" + randomString();\n  }\n};\n\n/**\n * @param {any} obj The object to inspect.\n * @returns {boolean} True if the argument appears to be a plain object.\n */\nfunction isPlainObject(obj) {\n  if (typeof obj !== 'object' || obj === null) return false;\n  var proto = obj;\n\n  while (Object.getPrototypeOf(proto) !== null) {\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  return Object.getPrototypeOf(obj) === proto;\n}\n\n/**\n * Creates a Redux store that holds the state tree.\n * The only way to change the data in the store is to call `dispatch()` on it.\n *\n * There should only be a single store in your app. To specify how different\n * parts of the state tree respond to actions, you may combine several reducers\n * into a single reducer function by using `combineReducers`.\n *\n * @param {Function} reducer A function that returns the next state tree, given\n * the current state tree and the action to handle.\n *\n * @param {any} [preloadedState] The initial state. You may optionally specify it\n * to hydrate the state from the server in universal apps, or to restore a\n * previously serialized user session.\n * If you use `combineReducers` to produce the root reducer function, this must be\n * an object with the same shape as `combineReducers` keys.\n *\n * @param {Function} [enhancer] The store enhancer. You may optionally specify it\n * to enhance the store with third-party capabilities such as middleware,\n * time travel, persistence, etc. The only store enhancer that ships with Redux\n * is `applyMiddleware()`.\n *\n * @returns {Store} A Redux store that lets you read the state, dispatch actions\n * and subscribe to changes.\n */\n\nfunction createStore(reducer, preloadedState, enhancer) {\n  var _ref2;\n\n  if (typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments[3] === 'function') {\n    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');\n  }\n\n  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {\n    enhancer = preloadedState;\n    preloadedState = undefined;\n  }\n\n  if (typeof enhancer !== 'undefined') {\n    if (typeof enhancer !== 'function') {\n      throw new Error('Expected the enhancer to be a function.');\n    }\n\n    return enhancer(createStore)(reducer, preloadedState);\n  }\n\n  if (typeof reducer !== 'function') {\n    throw new Error('Expected the reducer to be a function.');\n  }\n\n  var currentReducer = reducer;\n  var currentState = preloadedState;\n  var currentListeners = [];\n  var nextListeners = currentListeners;\n  var isDispatching = false;\n\n  function ensureCanMutateNextListeners() {\n    if (nextListeners === currentListeners) {\n      nextListeners = currentListeners.slice();\n    }\n  }\n  /**\n   * Reads the state tree managed by the store.\n   *\n   * @returns {any} The current state tree of your application.\n   */\n\n\n  function getState() {\n    if (isDispatching) {\n      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.');\n    }\n\n    return currentState;\n  }\n  /**\n   * Adds a change listener. It will be called any time an action is dispatched,\n   * and some part of the state tree may potentially have changed. You may then\n   * call `getState()` to read the current state tree inside the callback.\n   *\n   * You may call `dispatch()` from a change listener, with the following\n   * caveats:\n   *\n   * 1. The subscriptions are snapshotted just before every `dispatch()` call.\n   * If you subscribe or unsubscribe while the listeners are being invoked, this\n   * will not have any effect on the `dispatch()` that is currently in progress.\n   * However, the next `dispatch()` call, whether nested or not, will use a more\n   * recent snapshot of the subscription list.\n   *\n   * 2. The listener should not expect to see all state changes, as the state\n   * might have been updated multiple times during a nested `dispatch()` before\n   * the listener is called. It is, however, guaranteed that all subscribers\n   * registered before the `dispatch()` started will be called with the latest\n   * state by the time it exits.\n   *\n   * @param {Function} listener A callback to be invoked on every dispatch.\n   * @returns {Function} A function to remove this change listener.\n   */\n\n\n  function subscribe(listener) {\n    if (typeof listener !== 'function') {\n      throw new Error('Expected the listener to be a function.');\n    }\n\n    if (isDispatching) {\n      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.');\n    }\n\n    var isSubscribed = true;\n    ensureCanMutateNextListeners();\n    nextListeners.push(listener);\n    return function unsubscribe() {\n      if (!isSubscribed) {\n        return;\n      }\n\n      if (isDispatching) {\n        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.');\n      }\n\n      isSubscribed = false;\n      ensureCanMutateNextListeners();\n      var index = nextListeners.indexOf(listener);\n      nextListeners.splice(index, 1);\n    };\n  }\n  /**\n   * Dispatches an action. It is the only way to trigger a state change.\n   *\n   * The `reducer` function, used to create the store, will be called with the\n   * current state tree and the given `action`. Its return value will\n   * be considered the **next** state of the tree, and the change listeners\n   * will be notified.\n   *\n   * The base implementation only supports plain object actions. If you want to\n   * dispatch a Promise, an Observable, a thunk, or something else, you need to\n   * wrap your store creating function into the corresponding middleware. For\n   * example, see the documentation for the `redux-thunk` package. Even the\n   * middleware will eventually dispatch plain object actions using this method.\n   *\n   * @param {Object} action A plain object representing “what changed”. It is\n   * a good idea to keep actions serializable so you can record and replay user\n   * sessions, or use the time travelling `redux-devtools`. An action must have\n   * a `type` property which may not be `undefined`. It is a good idea to use\n   * string constants for action types.\n   *\n   * @returns {Object} For convenience, the same action object you dispatched.\n   *\n   * Note that, if you use a custom middleware, it may wrap `dispatch()` to\n   * return something else (for example, a Promise you can await).\n   */\n\n\n  function dispatch(action) {\n    if (!isPlainObject(action)) {\n      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');\n    }\n\n    if (typeof action.type === 'undefined') {\n      throw new Error('Actions may not have an undefined \"type\" property. ' + 'Have you misspelled a constant?');\n    }\n\n    if (isDispatching) {\n      throw new Error('Reducers may not dispatch actions.');\n    }\n\n    try {\n      isDispatching = true;\n      currentState = currentReducer(currentState, action);\n    } finally {\n      isDispatching = false;\n    }\n\n    var listeners = currentListeners = nextListeners;\n\n    for (var i = 0; i < listeners.length; i++) {\n      var listener = listeners[i];\n      listener();\n    }\n\n    return action;\n  }\n  /**\n   * Replaces the reducer currently used by the store to calculate the state.\n   *\n   * You might need this if your app implements code splitting and you want to\n   * load some of the reducers dynamically. You might also need this if you\n   * implement a hot reloading mechanism for Redux.\n   *\n   * @param {Function} nextReducer The reducer for the store to use instead.\n   * @returns {void}\n   */\n\n\n  function replaceReducer(nextReducer) {\n    if (typeof nextReducer !== 'function') {\n      throw new Error('Expected the nextReducer to be a function.');\n    }\n\n    currentReducer = nextReducer;\n    dispatch({\n      type: ActionTypes.REPLACE\n    });\n  }\n  /**\n   * Interoperability point for observable/reactive libraries.\n   * @returns {observable} A minimal observable of state changes.\n   * For more information, see the observable proposal:\n   * https://github.com/tc39/proposal-observable\n   */\n\n\n  function observable() {\n    var _ref;\n\n    var outerSubscribe = subscribe;\n    return _ref = {\n      /**\n       * The minimal observable subscription method.\n       * @param {Object} observer Any object that can be used as an observer.\n       * The observer object should have a `next` method.\n       * @returns {subscription} An object with an `unsubscribe` method that can\n       * be used to unsubscribe the observable from the store, and prevent further\n       * emission of values from the observable.\n       */\n      subscribe: function subscribe(observer) {\n        if (typeof observer !== 'object' || observer === null) {\n          throw new TypeError('Expected the observer to be an object.');\n        }\n\n        function observeState() {\n          if (observer.next) {\n            observer.next(getState());\n          }\n        }\n\n        observeState();\n        var unsubscribe = outerSubscribe(observeState);\n        return {\n          unsubscribe: unsubscribe\n        };\n      }\n    }, _ref[$$observable] = function () {\n      return this;\n    }, _ref;\n  } // When a store is created, an \"INIT\" action is dispatched so that every\n  // reducer returns their initial state. This effectively populates\n  // the initial state tree.\n\n\n  dispatch({\n    type: ActionTypes.INIT\n  });\n  return _ref2 = {\n    dispatch: dispatch,\n    subscribe: subscribe,\n    getState: getState,\n    replaceReducer: replaceReducer\n  }, _ref2[$$observable] = observable, _ref2;\n}\n\n/**\n * Prints a warning in the console if it exists.\n *\n * @param {String} message The warning message.\n * @returns {void}\n */\nfunction warning(message) {\n  /* eslint-disable no-console */\n  if (typeof console !== 'undefined' && typeof console.error === 'function') {\n    console.error(message);\n  }\n  /* eslint-enable no-console */\n\n\n  try {\n    // This error was thrown as a convenience so that if you enable\n    // \"break on all exceptions\" in your console,\n    // it would pause the execution at this line.\n    throw new Error(message);\n  } catch (e) {} // eslint-disable-line no-empty\n\n}\n\nfunction getUndefinedStateErrorMessage(key, action) {\n  var actionType = action && action.type;\n  var actionDescription = actionType && \"action \\\"\" + String(actionType) + \"\\\"\" || 'an action';\n  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.\";\n}\n\nfunction getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {\n  var reducerKeys = Object.keys(reducers);\n  var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer';\n\n  if (reducerKeys.length === 0) {\n    return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.';\n  }\n\n  if (!isPlainObject(inputState)) {\n    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('\", \"') + \"\\\"\");\n  }\n\n  var unexpectedKeys = Object.keys(inputState).filter(function (key) {\n    return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key];\n  });\n  unexpectedKeys.forEach(function (key) {\n    unexpectedKeyCache[key] = true;\n  });\n  if (action && action.type === ActionTypes.REPLACE) return;\n\n  if (unexpectedKeys.length > 0) {\n    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.\");\n  }\n}\n\nfunction assertReducerShape(reducers) {\n  Object.keys(reducers).forEach(function (key) {\n    var reducer = reducers[key];\n    var initialState = reducer(undefined, {\n      type: ActionTypes.INIT\n    });\n\n    if (typeof initialState === 'undefined') {\n      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.\");\n    }\n\n    if (typeof reducer(undefined, {\n      type: ActionTypes.PROBE_UNKNOWN_ACTION()\n    }) === 'undefined') {\n      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.\");\n    }\n  });\n}\n/**\n * Turns an object whose values are different reducer functions, into a single\n * reducer function. It will call every child reducer, and gather their results\n * into a single state object, whose keys correspond to the keys of the passed\n * reducer functions.\n *\n * @param {Object} reducers An object whose values correspond to different\n * reducer functions that need to be combined into one. One handy way to obtain\n * it is to use ES6 `import * as reducers` syntax. The reducers may never return\n * undefined for any action. Instead, they should return their initial state\n * if the state passed to them was undefined, and the current state for any\n * unrecognized action.\n *\n * @returns {Function} A reducer function that invokes every reducer inside the\n * passed object, and builds a state object with the same shape.\n */\n\n\nfunction combineReducers(reducers) {\n  var reducerKeys = Object.keys(reducers);\n  var finalReducers = {};\n\n  for (var i = 0; i < reducerKeys.length; i++) {\n    var key = reducerKeys[i];\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof reducers[key] === 'undefined') {\n        warning(\"No reducer provided for key \\\"\" + key + \"\\\"\");\n      }\n    }\n\n    if (typeof reducers[key] === 'function') {\n      finalReducers[key] = reducers[key];\n    }\n  }\n\n  var finalReducerKeys = Object.keys(finalReducers);\n  var unexpectedKeyCache;\n\n  if (process.env.NODE_ENV !== 'production') {\n    unexpectedKeyCache = {};\n  }\n\n  var shapeAssertionError;\n\n  try {\n    assertReducerShape(finalReducers);\n  } catch (e) {\n    shapeAssertionError = e;\n  }\n\n  return function combination(state, action) {\n    if (state === void 0) {\n      state = {};\n    }\n\n    if (shapeAssertionError) {\n      throw shapeAssertionError;\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      var warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);\n\n      if (warningMessage) {\n        warning(warningMessage);\n      }\n    }\n\n    var hasChanged = false;\n    var nextState = {};\n\n    for (var _i = 0; _i < finalReducerKeys.length; _i++) {\n      var _key = finalReducerKeys[_i];\n      var reducer = finalReducers[_key];\n      var previousStateForKey = state[_key];\n      var nextStateForKey = reducer(previousStateForKey, action);\n\n      if (typeof nextStateForKey === 'undefined') {\n        var errorMessage = getUndefinedStateErrorMessage(_key, action);\n        throw new Error(errorMessage);\n      }\n\n      nextState[_key] = nextStateForKey;\n      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;\n    }\n\n    return hasChanged ? nextState : state;\n  };\n}\n\nfunction bindActionCreator(actionCreator, dispatch) {\n  return function () {\n    return dispatch(actionCreator.apply(this, arguments));\n  };\n}\n/**\n * Turns an object whose values are action creators, into an object with the\n * same keys, but with every function wrapped into a `dispatch` call so they\n * may be invoked directly. This is just a convenience method, as you can call\n * `store.dispatch(MyActionCreators.doSomething())` yourself just fine.\n *\n * For convenience, you can also pass a single function as the first argument,\n * and get a function in return.\n *\n * @param {Function|Object} actionCreators An object whose values are action\n * creator functions. One handy way to obtain it is to use ES6 `import * as`\n * syntax. You may also pass a single function.\n *\n * @param {Function} dispatch The `dispatch` function available on your Redux\n * store.\n *\n * @returns {Function|Object} The object mimicking the original object, but with\n * every action creator wrapped into the `dispatch` call. If you passed a\n * function as `actionCreators`, the return value will also be a single\n * function.\n */\n\n\nfunction bindActionCreators(actionCreators, dispatch) {\n  if (typeof actionCreators === 'function') {\n    return bindActionCreator(actionCreators, dispatch);\n  }\n\n  if (typeof actionCreators !== 'object' || actionCreators === null) {\n    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\\\"?\");\n  }\n\n  var keys = Object.keys(actionCreators);\n  var boundActionCreators = {};\n\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    var actionCreator = actionCreators[key];\n\n    if (typeof actionCreator === 'function') {\n      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);\n    }\n  }\n\n  return boundActionCreators;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n    var ownKeys = Object.keys(source);\n\n    if (typeof Object.getOwnPropertySymbols === 'function') {\n      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n      }));\n    }\n\n    ownKeys.forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    });\n  }\n\n  return target;\n}\n\n/**\n * Composes single-argument functions from right to left. The rightmost\n * function can take multiple arguments as it provides the signature for\n * the resulting composite function.\n *\n * @param {...Function} funcs The functions to compose.\n * @returns {Function} A function obtained by composing the argument functions\n * from right to left. For example, compose(f, g, h) is identical to doing\n * (...args) => f(g(h(...args))).\n */\nfunction compose() {\n  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {\n    funcs[_key] = arguments[_key];\n  }\n\n  if (funcs.length === 0) {\n    return function (arg) {\n      return arg;\n    };\n  }\n\n  if (funcs.length === 1) {\n    return funcs[0];\n  }\n\n  return funcs.reduce(function (a, b) {\n    return function () {\n      return a(b.apply(void 0, arguments));\n    };\n  });\n}\n\n/**\n * Creates a store enhancer that applies middleware to the dispatch method\n * of the Redux store. This is handy for a variety of tasks, such as expressing\n * asynchronous actions in a concise manner, or logging every action payload.\n *\n * See `redux-thunk` package as an example of the Redux middleware.\n *\n * Because middleware is potentially asynchronous, this should be the first\n * store enhancer in the composition chain.\n *\n * Note that each middleware will be given the `dispatch` and `getState` functions\n * as named arguments.\n *\n * @param {...Function} middlewares The middleware chain to be applied.\n * @returns {Function} A store enhancer applying the middleware.\n */\n\nfunction applyMiddleware() {\n  for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) {\n    middlewares[_key] = arguments[_key];\n  }\n\n  return function (createStore) {\n    return function () {\n      var store = createStore.apply(void 0, arguments);\n\n      var _dispatch = function dispatch() {\n        throw new Error(\"Dispatching while constructing your middleware is not allowed. \" + \"Other middleware would not be applied to this dispatch.\");\n      };\n\n      var middlewareAPI = {\n        getState: store.getState,\n        dispatch: function dispatch() {\n          return _dispatch.apply(void 0, arguments);\n        }\n      };\n      var chain = middlewares.map(function (middleware) {\n        return middleware(middlewareAPI);\n      });\n      _dispatch = compose.apply(void 0, chain)(store.dispatch);\n      return _objectSpread({}, store, {\n        dispatch: _dispatch\n      });\n    };\n  };\n}\n\n/*\n * This is a dummy function to check if the function name has been altered by minification.\n * If the function has been minified and NODE_ENV !== 'production', warn the user.\n */\n\nfunction isCrushed() {}\n\nif (process.env.NODE_ENV !== 'production' && typeof isCrushed.name === 'string' && isCrushed.name !== 'isCrushed') {\n  warning('You are currently using minified code outside of NODE_ENV === \"production\". ' + 'This means that you are running a slower development build of Redux. ' + 'You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify ' + 'or setting mode to production in webpack (https://webpack.js.org/concepts/mode/) ' + 'to ensure you have the correct code for your production build.');\n}\n\nexport { createStore, combineReducers, bindActionCreators, applyMiddleware, compose, ActionTypes as __DO_NOT_USE__ActionTypes };\n","/* global window */\nimport ponyfill from './ponyfill.js';\n\nvar root;\n\nif (typeof self !== 'undefined') {\n  root = self;\n} else if (typeof window !== 'undefined') {\n  root = window;\n} else if (typeof global !== 'undefined') {\n  root = global;\n} else if (typeof module !== 'undefined') {\n  root = module;\n} else {\n  root = Function('return this')();\n}\n\nvar result = ponyfill(root);\nexport default result;\n","export default function symbolObservablePonyfill(root) {\n\tvar result;\n\tvar Symbol = root.Symbol;\n\n\tif (typeof Symbol === 'function') {\n\t\tif (Symbol.observable) {\n\t\t\tresult = Symbol.observable;\n\t\t} else {\n\t\t\tresult = Symbol('observable');\n\t\t\tSymbol.observable = result;\n\t\t}\n\t} else {\n\t\tresult = '@@observable';\n\t}\n\n\treturn result;\n};\n","'use strict';\n\nvar LEAF_KEY, hasWeakMap;\n\n/**\n * Arbitrary value used as key for referencing cache object in WeakMap tree.\n *\n * @type {Object}\n */\nLEAF_KEY = {};\n\n/**\n * Whether environment supports WeakMap.\n *\n * @type {boolean}\n */\nhasWeakMap = typeof WeakMap !== 'undefined';\n\n/**\n * Returns the first argument as the sole entry in an array.\n *\n * @param {*} value Value to return.\n *\n * @return {Array} Value returned as entry in array.\n */\nfunction arrayOf( value ) {\n\treturn [ value ];\n}\n\n/**\n * Returns true if the value passed is object-like, or false otherwise. A value\n * is object-like if it can support property assignment, e.g. object or array.\n *\n * @param {*} value Value to test.\n *\n * @return {boolean} Whether value is object-like.\n */\nfunction isObjectLike( value ) {\n\treturn !! value && 'object' === typeof value;\n}\n\n/**\n * Creates and returns a new cache object.\n *\n * @return {Object} Cache object.\n */\nfunction createCache() {\n\tvar cache = {\n\t\tclear: function() {\n\t\t\tcache.head = null;\n\t\t},\n\t};\n\n\treturn cache;\n}\n\n/**\n * Returns true if entries within the two arrays are strictly equal by\n * reference from a starting index.\n *\n * @param {Array}  a         First array.\n * @param {Array}  b         Second array.\n * @param {number} fromIndex Index from which to start comparison.\n *\n * @return {boolean} Whether arrays are shallowly equal.\n */\nfunction isShallowEqual( a, b, fromIndex ) {\n\tvar i;\n\n\tif ( a.length !== b.length ) {\n\t\treturn false;\n\t}\n\n\tfor ( i = fromIndex; i < a.length; i++ ) {\n\t\tif ( a[ i ] !== b[ i ] ) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n\n/**\n * Returns a memoized selector function. The getDependants function argument is\n * called before the memoized selector and is expected to return an immutable\n * reference or array of references on which the selector depends for computing\n * its own return value. The memoize cache is preserved only as long as those\n * dependant references remain the same. If getDependants returns a different\n * reference(s), the cache is cleared and the selector value regenerated.\n *\n * @param {Function} selector      Selector function.\n * @param {Function} getDependants Dependant getter returning an immutable\n *                                 reference or array of reference used in\n *                                 cache bust consideration.\n *\n * @return {Function} Memoized selector.\n */\nexport default function( selector, getDependants ) {\n\tvar rootCache, getCache;\n\n\t// Use object source as dependant if getter not provided\n\tif ( ! getDependants ) {\n\t\tgetDependants = arrayOf;\n\t}\n\n\t/**\n\t * Returns the root cache. If WeakMap is supported, this is assigned to the\n\t * root WeakMap cache set, otherwise it is a shared instance of the default\n\t * cache object.\n\t *\n\t * @return {(WeakMap|Object)} Root cache object.\n\t */\n\tfunction getRootCache() {\n\t\treturn rootCache;\n\t}\n\n\t/**\n\t * Returns the cache for a given dependants array. When possible, a WeakMap\n\t * will be used to create a unique cache for each set of dependants. This\n\t * is feasible due to the nature of WeakMap in allowing garbage collection\n\t * to occur on entries where the key object is no longer referenced. Since\n\t * WeakMap requires the key to be an object, this is only possible when the\n\t * dependant is object-like. The root cache is created as a hierarchy where\n\t * each top-level key is the first entry in a dependants set, the value a\n\t * WeakMap where each key is the next dependant, and so on. This continues\n\t * so long as the dependants are object-like. If no dependants are object-\n\t * like, then the cache is shared across all invocations.\n\t *\n\t * @see isObjectLike\n\t *\n\t * @param {Array} dependants Selector dependants.\n\t *\n\t * @return {Object} Cache object.\n\t */\n\tfunction getWeakMapCache( dependants ) {\n\t\tvar caches = rootCache,\n\t\t\tisUniqueByDependants = true,\n\t\t\ti, dependant, map, cache;\n\n\t\tfor ( i = 0; i < dependants.length; i++ ) {\n\t\t\tdependant = dependants[ i ];\n\n\t\t\t// Can only compose WeakMap from object-like key.\n\t\t\tif ( ! isObjectLike( dependant ) ) {\n\t\t\t\tisUniqueByDependants = false;\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\t// Does current segment of cache already have a WeakMap?\n\t\t\tif ( caches.has( dependant ) ) {\n\t\t\t\t// Traverse into nested WeakMap.\n\t\t\t\tcaches = caches.get( dependant );\n\t\t\t} else {\n\t\t\t\t// Create, set, and traverse into a new one.\n\t\t\t\tmap = new WeakMap();\n\t\t\t\tcaches.set( dependant, map );\n\t\t\t\tcaches = map;\n\t\t\t}\n\t\t}\n\n\t\t// We use an arbitrary (but consistent) object as key for the last item\n\t\t// in the WeakMap to serve as our running cache.\n\t\tif ( ! caches.has( LEAF_KEY ) ) {\n\t\t\tcache = createCache();\n\t\t\tcache.isUniqueByDependants = isUniqueByDependants;\n\t\t\tcaches.set( LEAF_KEY, cache );\n\t\t}\n\n\t\treturn caches.get( LEAF_KEY );\n\t}\n\n\t// Assign cache handler by availability of WeakMap\n\tgetCache = hasWeakMap ? getWeakMapCache : getRootCache;\n\n\t/**\n\t * Resets root memoization cache.\n\t */\n\tfunction clear() {\n\t\trootCache = hasWeakMap ? new WeakMap() : createCache();\n\t}\n\n\t// eslint-disable-next-line jsdoc/check-param-names\n\t/**\n\t * The augmented selector call, considering first whether dependants have\n\t * changed before passing it to underlying memoize function.\n\t *\n\t * @param {Object} source    Source object for derivation.\n\t * @param {...*}   extraArgs Additional arguments to pass to selector.\n\t *\n\t * @return {*} Selector result.\n\t */\n\tfunction callSelector( /* source, ...extraArgs */ ) {\n\t\tvar len = arguments.length,\n\t\t\tcache, node, i, args, dependants;\n\n\t\t// Create copy of arguments (avoid leaking deoptimization).\n\t\targs = new Array( len );\n\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\targs[ i ] = arguments[ i ];\n\t\t}\n\n\t\tdependants = getDependants.apply( null, args );\n\t\tcache = getCache( dependants );\n\n\t\t// If not guaranteed uniqueness by dependants (primitive type or lack\n\t\t// of WeakMap support), shallow compare against last dependants and, if\n\t\t// references have changed, destroy cache to recalculate result.\n\t\tif ( ! cache.isUniqueByDependants ) {\n\t\t\tif ( cache.lastDependants && ! isShallowEqual( dependants, cache.lastDependants, 0 ) ) {\n\t\t\t\tcache.clear();\n\t\t\t}\n\n\t\t\tcache.lastDependants = dependants;\n\t\t}\n\n\t\tnode = cache.head;\n\t\twhile ( node ) {\n\t\t\t// Check whether node arguments match arguments\n\t\t\tif ( ! isShallowEqual( node.args, args, 1 ) ) {\n\t\t\t\tnode = node.next;\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// At this point we can assume we've found a match\n\n\t\t\t// Surface matched node to head if not already\n\t\t\tif ( node !== cache.head ) {\n\t\t\t\t// Adjust siblings to point to each other.\n\t\t\t\tnode.prev.next = node.next;\n\t\t\t\tif ( node.next ) {\n\t\t\t\t\tnode.next.prev = node.prev;\n\t\t\t\t}\n\n\t\t\t\tnode.next = cache.head;\n\t\t\t\tnode.prev = null;\n\t\t\t\tcache.head.prev = node;\n\t\t\t\tcache.head = node;\n\t\t\t}\n\n\t\t\t// Return immediately\n\t\t\treturn node.val;\n\t\t}\n\n\t\t// No cached value found. Continue to insertion phase:\n\n\t\tnode = {\n\t\t\t// Generate the result from original function\n\t\t\tval: selector.apply( null, args ),\n\t\t};\n\n\t\t// Avoid including the source object in the cache.\n\t\targs[ 0 ] = null;\n\t\tnode.args = args;\n\n\t\t// Don't need to check whether node is already head, since it would\n\t\t// have been returned above already if it was\n\n\t\t// Shift existing head down list\n\t\tif ( cache.head ) {\n\t\t\tcache.head.prev = node;\n\t\t\tnode.next = cache.head;\n\t\t}\n\n\t\tcache.head = node;\n\n\t\treturn node.val;\n\t}\n\n\tcallSelector.getDependants = getDependants;\n\tcallSelector.clear = clear;\n\tclear();\n\n\treturn callSelector;\n}\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","module.exports = function(originalModule) {\n\tif (!originalModule.webpackPolyfill) {\n\t\tvar module = Object.create(originalModule);\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"exports\", {\n\t\t\tenumerable: true\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","(function() { module.exports = this[\"wp\"][\"apiFetch\"]; }());","(function() { module.exports = this[\"wp\"][\"data\"]; }());","(function() { module.exports = this[\"wp\"][\"url\"]; }());","(function() { module.exports = this[\"lodash\"]; }());"],"sourceRoot":""}