mirror of
https://github.com/WordPress/WordPress.git
synced 2024-06-27 23:35:04 +02:00
8614d14887
We decided to split the media webpack config into it's own file. The main webpack config then combines this file with the packages config. Include vendor scripts by copying them. We copy the minified files if they are available. If they aren't available we minify the original files ourselves. Props omarreiss, herregroen, gziolo, youknowriad, netweb, adamsilverstein. Merges [43719] to trunk. See #45065. Built from https://develop.svn.wordpress.org/trunk@44112 git-svn-id: http://core.svn.wordpress.org/trunk@43942 1a063a9b-81f0-0310-95a4-ce76da25c4cd
1 line
113 KiB
Plaintext
1 line
113 KiB
Plaintext
{"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":""} |