WordPress/js/dist/data.js.map

{"version":3,"sources":["webpack://wp.[name]/webpack/bootstrap","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/AsyncGenerator.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/AwaitValue.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/asyncIterator.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/awaitAsyncGenerator.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/classCallCheck.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/createClass.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/extends.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/inherits.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/objectSpread.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack://wp.[name]/./node_modules/@babel/runtime/helpers/esm/wrapAsyncGenerator.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/components/registry-provider/index.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/components/with-dispatch/index.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/components/with-select/index.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/default-registry.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/index.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/plugins/async-generator/index.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/plugins/async-generator/middleware.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/plugins/controls/index.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/plugins/index.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/plugins/persistence/index.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/plugins/persistence/storage/default.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/plugins/persistence/storage/object.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/promise-middleware.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/registry.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/store/actions.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/store/index.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/store/reducer.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/store/selectors.js","webpack://wp.[name]//Users/gziolo/PhpstormProjects/gutenberg/packages/data/src/store/utils.js","webpack://wp.[name]/./node_modules/equivalent-key-map/equivalent-key-map.js","webpack://wp.[name]/./node_modules/is-promise/index.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]/(webpack)/buildin/global.js","webpack://wp.[name]/(webpack)/buildin/harmony-module.js","webpack://wp.[name]/external {\"this\":[\"wp\",\"compose\"]}","webpack://wp.[name]/external {\"this\":[\"wp\",\"deprecated\"]}","webpack://wp.[name]/external {\"this\":[\"wp\",\"element\"]}","webpack://wp.[name]/external {\"this\":[\"wp\",\"isShallowEqual\"]}","webpack://wp.[name]/external {\"this\":[\"wp\",\"reduxRoutine\"]}","webpack://wp.[name]/external \"lodash\""],"names":["createContext","defaultRegistry","Consumer","Provider","RegistryConsumer","withDispatch","mapDispatchToProps","createHigherOrderComponent","compose","pure","WrappedComponent","ComponentWithDispatch","remountOnPropChange","props","arguments","proxyProps","setProxyProps","propName","args","registry","dispatch","ownProps","propsToDispatchers","mapValues","dispatcher","hasOwnProperty","proxyDispatch","bind","Component","withSelect","mapSelectToProps","DEFAULT_MERGE_PROPS","getNextMergeProps","select","ComponentWithSelect","subscribe","mergeProps","canRunSelection","unsubscribe","nextProps","nextState","hasPropsChanged","isShallowEqual","state","nextMergeProps","setState","createRegistry","registerStore","registerReducer","registerActions","registerSelectors","registerResolvers","use","reducerKey","options","store","enhancer","applyMiddleware","asyncGeneratorMiddleware","createStore","Object","assign","reducer","__experimentalFulfill","selectorName","resolver","get","namespaces","getState","action","fulfill","toAsyncIterable","isActionLike","type","isAsyncIterable","object","Symbol","asyncIterator","isIterable","iterator","deprecated","alternative","plugin","version","maybeAction","next","runtime","fulfillment","controls","middleware","createMiddleware","supportControls","DEFAULT_STORAGE","defaultStorage","DEFAULT_STORAGE_KEY","withInitialState","initialState","createPersistenceInterface","storage","storageKey","data","undefined","persisted","getItem","JSON","parse","error","set","key","value","setItem","stringify","pluginOptions","persistence","createPersistOnChange","keys","lastState","result","Array","isArray","pick","persist","flow","window","localStorage","removeItem","objectStorage","clear","String","create","promiseMiddleware","isPromise","then","resolvedAction","storeConfigs","listeners","globalListener","forEach","listener","enhancers","promise","__REDUX_DEVTOOLS_EXTENSION__","push","name","instanceId","flowRight","hasChanged","newSelectors","createStateSelector","selector","selectors","newResolvers","resolvers","hasStartedResolution","startResolution","finishResolution","fulfillSelector","isFulfilled","newActions","createBoundAction","actions","TypeError","without","withPlugins","attributes","attribute","apply","entries","dataStore","map","config","isResolved","onSubKey","EquivalentKeyMap","isStarting","getIsResolving","hasFinishedResolution","isResolving","actionProperty","nextKeyState"],"mappings":";;AAAA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kDAA0C,gCAAgC;AAC1E;AACA;;AAEA;AACA;AACA;AACA,gEAAwD,kBAAkB;AAC1E;AACA,yDAAiD,cAAc;AAC/D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAyC,iCAAiC;AAC1E,wHAAgH,mBAAmB,EAAE;AACrI;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;;AAGA;AACA;;;;;;;;;;;;;AClFA;AAAA;AAAA;AAAsC;AACvB;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA,0CAA0C,mDAAU;AACpD;AACA;AACA;AACA;AACA;;AAEA;AACA,OAAO;AACP;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;AAEA;;AAEA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,E;;;;;;;;;;;;AChGA;AAAA;AAAe;AACf;AACA,C;;;;;;;;;;;;ACFA;AAAA;AAAe;AACf;AACA,C;;;;;;;;;;;;ACFA;AAAA;AAAe;AACf;AACA;AACA;;AAEA;AACA,C;;;;;;;;;;;;ACNA;AAAA;AAAe;AACf;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,C;;;;;;;;;;;;AChBA;AAAA;AAAA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEe;AACf;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,KAAK;AACL;AACA,C;;;;;;;;;;;;AClCA;AAAA;AAAA;AAAsC;AACvB;AACf,aAAa,mDAAU;AACvB,C;;;;;;;;;;;;ACHA;AAAA;AAAe;AACf;AACA;AACA;AACA,C;;;;;;;;;;;;ACJA;AAAA;AAAA;AACA,iBAAiB,kBAAkB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEe;AACf;AACA;AACA;AACA,C;;;;;;;;;;;;ACdA;AAAA;AAAe;AACf;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA,C;;;;;;;;;;;;ACbA;AAAA;AAAe;AACf;AACA,mBAAmB,sBAAsB;AACzC;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,C;;;;;;;;;;;;AChBA;AAAA;AAAe;AACf;AACA;AACA;AACA;AACA,C;;;;;;;;;;;;ACLA;AAAA;AAAA;AAA8C;AAC/B;AACf;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,kBAAkB,+DAAc;AAChC,C;;;;;;;;;;;;ACdA;AAAA;AAAe;AACf;AACA;AACA;AACA;;AAEA;AACA,6CAA6C,+BAA+B;AAC5E;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA,C;;;;;;;;;;;;ACxBA;AAAA;AAAe;AACf;AACA,C;;;;;;;;;;;;ACFA;AAAA;AAAA;AAA8C;AAC/B;AACf,iBAAiB,sBAAsB;AACvC;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA,MAAM,+DAAc;AACpB,KAAK;AACL;;AAEA;AACA,C;;;;;;;;;;;;AClBA;AAAA;AAAA;AAA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AC1B;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;;AAEA;AACA;AACA;;;;;;;;;;;;;ACJA;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;;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,wCAAwC,EAAE,I;;;;;;;;;;;ACAvD,aAAa,2CAA2C,EAAE,I;;;;;;;;;;;ACA1D,aAAa,wCAAwC,EAAE,I;;;;;;;;;;;ACAvD,aAAa,+CAA+C,EAAE,I;;;;;;;;;;;ACA9D,aAAa,6CAA6C,EAAE,I;;;;;;;;;;;ACA5D,aAAa,iCAAiC,EAAE,I","file":"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/data/build-module/index.js\");\n","import AwaitValue from \"./AwaitValue\";\nexport default function AsyncGenerator(gen) {\n  var front, back;\n\n  function send(key, arg) {\n    return new Promise(function (resolve, reject) {\n      var request = {\n        key: key,\n        arg: arg,\n        resolve: resolve,\n        reject: reject,\n        next: null\n      };\n\n      if (back) {\n        back = back.next = request;\n      } else {\n        front = back = request;\n        resume(key, arg);\n      }\n    });\n  }\n\n  function resume(key, arg) {\n    try {\n      var result = gen[key](arg);\n      var value = result.value;\n      var wrappedAwait = value instanceof AwaitValue;\n      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {\n        if (wrappedAwait) {\n          resume(\"next\", arg);\n          return;\n        }\n\n        settle(result.done ? \"return\" : \"normal\", arg);\n      }, function (err) {\n        resume(\"throw\", err);\n      });\n    } catch (err) {\n      settle(\"throw\", err);\n    }\n  }\n\n  function settle(type, value) {\n    switch (type) {\n      case \"return\":\n        front.resolve({\n          value: value,\n          done: true\n        });\n        break;\n\n      case \"throw\":\n        front.reject(value);\n        break;\n\n      default:\n        front.resolve({\n          value: value,\n          done: false\n        });\n        break;\n    }\n\n    front = front.next;\n\n    if (front) {\n      resume(front.key, front.arg);\n    } else {\n      back = null;\n    }\n  }\n\n  this._invoke = send;\n\n  if (typeof gen.return !== \"function\") {\n    this.return = undefined;\n  }\n}\n\nif (typeof Symbol === \"function\" && Symbol.asyncIterator) {\n  AsyncGenerator.prototype[Symbol.asyncIterator] = function () {\n    return this;\n  };\n}\n\nAsyncGenerator.prototype.next = function (arg) {\n  return this._invoke(\"next\", arg);\n};\n\nAsyncGenerator.prototype.throw = function (arg) {\n  return this._invoke(\"throw\", arg);\n};\n\nAsyncGenerator.prototype.return = function (arg) {\n  return this._invoke(\"return\", arg);\n};","export default function _AwaitValue(value) {\n  this.wrapped = value;\n}","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}","export default function _asyncIterator(iterable) {\n  var method;\n\n  if (typeof Symbol === \"function\") {\n    if (Symbol.asyncIterator) {\n      method = iterable[Symbol.asyncIterator];\n      if (method != null) return method.call(iterable);\n    }\n\n    if (Symbol.iterator) {\n      method = iterable[Symbol.iterator];\n      if (method != null) return method.call(iterable);\n    }\n  }\n\n  throw new TypeError(\"Object is not async iterable\");\n}","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}","import AwaitValue from \"./AwaitValue\";\nexport default function _awaitAsyncGenerator(value) {\n  return new AwaitValue(value);\n}","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","function _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\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\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 _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}","export default function _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}","import setPrototypeOf from \"./setPrototypeOf\";\nexport default function _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\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}","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 _typeof from \"../../helpers/esm/typeof\";\nimport assertThisInitialized from \"./assertThisInitialized\";\nexport default function _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return assertThisInitialized(self);\n}","export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\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}","function _typeof2(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof2(obj); }\n\nexport default function _typeof(obj) {\n  if (typeof Symbol === \"function\" && _typeof2(Symbol.iterator) === \"symbol\") {\n    _typeof = function _typeof(obj) {\n      return _typeof2(obj);\n    };\n  } else {\n    _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : _typeof2(obj);\n    };\n  }\n\n  return _typeof(obj);\n}","import AsyncGenerator from \"./AsyncGenerator\";\nexport default function _wrapAsyncGenerator(fn) {\n  return function () {\n    return new AsyncGenerator(fn.apply(this, arguments));\n  };\n}","/**\n * WordPress dependencies\n */\nimport { createContext } from '@wordpress/element';\n\n/**\n * Internal dependencies\n */\nimport defaultRegistry from '../../default-registry';\n\nconst { Consumer, Provider } = createContext( defaultRegistry );\n\nexport const RegistryConsumer = Consumer;\n\nexport default Provider;\n","/**\n * External dependencies\n */\nimport { mapValues } from 'lodash';\n\n/**\n * WordPress dependencies\n */\nimport { Component } from '@wordpress/element';\nimport { pure, compose, remountOnPropChange, createHigherOrderComponent } from '@wordpress/compose';\n\n/**\n * Internal dependencies\n */\nimport { RegistryConsumer } from '../registry-provider';\n\n/**\n * Higher-order component used to add dispatch props using registered action\n * creators.\n *\n * @param {Object} mapDispatchToProps Object of prop names where value is a\n *                                    dispatch-bound action creator, or a\n *                                    function to be called with with the\n *                                    component's props and returning an\n *                                    action creator.\n *\n * @return {Component} Enhanced component with merged dispatcher props.\n */\nconst withDispatch = ( mapDispatchToProps ) => createHigherOrderComponent(\n\tcompose( [\n\t\tpure,\n\t\t( WrappedComponent ) => {\n\t\t\tconst ComponentWithDispatch = remountOnPropChange( 'registry' )( class extends Component {\n\t\t\t\tconstructor( props ) {\n\t\t\t\t\tsuper( ...arguments );\n\n\t\t\t\t\tthis.proxyProps = {};\n\t\t\t\t\tthis.setProxyProps( props );\n\t\t\t\t}\n\n\t\t\t\tcomponentDidUpdate() {\n\t\t\t\t\tthis.setProxyProps( this.props );\n\t\t\t\t}\n\n\t\t\t\tproxyDispatch( propName, ...args ) {\n\t\t\t\t\t// Original dispatcher is a pre-bound (dispatching) action creator.\n\t\t\t\t\tmapDispatchToProps( this.props.registry.dispatch, this.props.ownProps )[ propName ]( ...args );\n\t\t\t\t}\n\n\t\t\t\tsetProxyProps( props ) {\n\t\t\t\t\t// Assign as instance property so that in reconciling subsequent\n\t\t\t\t\t// renders, the assigned prop values are referentially equal.\n\t\t\t\t\tconst propsToDispatchers = mapDispatchToProps( this.props.registry.dispatch, props.ownProps );\n\t\t\t\t\tthis.proxyProps = mapValues( propsToDispatchers, ( dispatcher, propName ) => {\n\t\t\t\t\t\t// Prebind with prop name so we have reference to the original\n\t\t\t\t\t\t// dispatcher to invoke. Track between re-renders to avoid\n\t\t\t\t\t\t// creating new function references every render.\n\t\t\t\t\t\tif ( this.proxyProps.hasOwnProperty( propName ) ) {\n\t\t\t\t\t\t\treturn this.proxyProps[ propName ];\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\treturn this.proxyDispatch.bind( this, propName );\n\t\t\t\t\t} );\n\t\t\t\t}\n\n\t\t\t\trender() {\n\t\t\t\t\treturn <WrappedComponent { ...this.props.ownProps } { ...this.proxyProps } />;\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\treturn ( ownProps ) => (\n\t\t\t\t<RegistryConsumer>\n\t\t\t\t\t{ ( registry ) => (\n\t\t\t\t\t\t<ComponentWithDispatch\n\t\t\t\t\t\t\townProps={ ownProps }\n\t\t\t\t\t\t\tregistry={ registry }\n\t\t\t\t\t\t/>\n\t\t\t\t\t) }\n\t\t\t\t</RegistryConsumer>\n\t\t\t);\n\t\t},\n\t] ),\n\t'withDispatch'\n);\n\nexport default withDispatch;\n","/**\n * WordPress dependencies\n */\nimport { Component } from '@wordpress/element';\nimport isShallowEqual from '@wordpress/is-shallow-equal';\nimport { remountOnPropChange, createHigherOrderComponent } from '@wordpress/compose';\n\n/**\n * Internal dependencies\n */\nimport { RegistryConsumer } from '../registry-provider';\n\n/**\n * Higher-order component used to inject state-derived props using registered\n * selectors.\n *\n * @param {Function} mapSelectToProps Function called on every state change,\n *                                   expected to return object of props to\n *                                   merge with the component's own props.\n *\n * @return {Component} Enhanced component with merged state data props.\n */\nconst withSelect = ( mapSelectToProps ) => createHigherOrderComponent( ( WrappedComponent ) => {\n\t/**\n\t * Default merge props. A constant value is used as the fallback since it\n\t * can be more efficiently shallow compared in case component is repeatedly\n \t * rendered without its own merge props.\n\t *\n\t * @type {Object}\n\t */\n\tconst DEFAULT_MERGE_PROPS = {};\n\n\t/**\n\t * Given a props object, returns the next merge props by mapSelectToProps.\n\t *\n\t * @param {Object} props Props to pass as argument to mapSelectToProps.\n\t *\n\t * @return {Object} Props to merge into rendered wrapped element.\n\t */\n\tfunction getNextMergeProps( props ) {\n\t\treturn (\n\t\t\tmapSelectToProps( props.registry.select, props.ownProps ) ||\n\t\t\tDEFAULT_MERGE_PROPS\n\t\t);\n\t}\n\n\tconst ComponentWithSelect = remountOnPropChange( 'registry' )( class extends Component {\n\t\tconstructor( props ) {\n\t\t\tsuper( props );\n\n\t\t\tthis.subscribe();\n\n\t\t\tthis.mergeProps = getNextMergeProps( props );\n\t\t}\n\n\t\tcomponentDidMount() {\n\t\t\tthis.canRunSelection = true;\n\t\t}\n\n\t\tcomponentWillUnmount() {\n\t\t\tthis.canRunSelection = false;\n\t\t\tthis.unsubscribe();\n\t\t}\n\n\t\tshouldComponentUpdate( nextProps, nextState ) {\n\t\t\tconst hasPropsChanged = ! isShallowEqual( this.props.ownProps, nextProps.ownProps );\n\n\t\t\t// Only render if props have changed or merge props have been updated\n\t\t\t// from the store subscriber.\n\t\t\tif ( this.state === nextState && ! hasPropsChanged ) {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\t// If merge props change as a result of the incoming props, they\n\t\t\t// should be reflected as such in the upcoming render.\n\t\t\tif ( hasPropsChanged ) {\n\t\t\t\tconst nextMergeProps = getNextMergeProps( nextProps );\n\t\t\t\tif ( ! isShallowEqual( this.mergeProps, nextMergeProps ) ) {\n\t\t\t\t\t// Side effects are typically discouraged in lifecycle methods, but\n\t\t\t\t\t// this component is heavily used and this is the most performant\n\t\t\t\t\t// code we've found thus far.\n\t\t\t\t\t// Prior efforts to use `getDerivedStateFromProps` have demonstrated\n\t\t\t\t\t// miserable performance.\n\t\t\t\t\tthis.mergeProps = nextMergeProps;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn true;\n\t\t}\n\n\t\tsubscribe() {\n\t\t\tconst { subscribe } = this.props.registry;\n\n\t\t\tthis.unsubscribe = subscribe( () => {\n\t\t\t\tif ( ! this.canRunSelection ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tconst nextMergeProps = getNextMergeProps( this.props );\n\t\t\t\tif ( isShallowEqual( this.mergeProps, nextMergeProps ) ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tthis.mergeProps = nextMergeProps;\n\n\t\t\t\t// Schedule an update. Merge props are not assigned to state\n\t\t\t\t// because derivation of merge props from incoming props occurs\n\t\t\t\t// within shouldComponentUpdate, where setState is not allowed.\n\t\t\t\t// setState is used here instead of forceUpdate because forceUpdate\n\t\t\t\t// bypasses shouldComponentUpdate altogether, which isn't desireable\n\t\t\t\t// if both state and props change within the same render.\n\t\t\t\t// Unfortunately this requires that next merge props are generated\n\t\t\t\t// twice.\n\t\t\t\tthis.setState( {} );\n\t\t\t} );\n\t\t}\n\n\t\trender() {\n\t\t\treturn <WrappedComponent { ...this.props.ownProps } { ...this.mergeProps } />;\n\t\t}\n\t} );\n\n\treturn ( ownProps ) => (\n\t\t<RegistryConsumer>\n\t\t\t{ ( registry ) => (\n\t\t\t\t<ComponentWithSelect\n\t\t\t\t\townProps={ ownProps }\n\t\t\t\t\tregistry={ registry }\n\t\t\t\t/>\n\t\t\t) }\n\t\t</RegistryConsumer>\n\t);\n}, 'withSelect' );\n\nexport default withSelect;\n","import { createRegistry } from './registry';\n\nexport default createRegistry();\n","/**\n * External dependencies\n */\nimport { combineReducers } from 'redux';\n\n/**\n * Internal dependencies\n */\nimport defaultRegistry from './default-registry';\nimport * as plugins from './plugins';\n\nexport { default as withSelect } from './components/with-select';\nexport { default as withDispatch } from './components/with-dispatch';\nexport { default as RegistryProvider, RegistryConsumer } from './components/registry-provider';\nexport { createRegistry } from './registry';\nexport { plugins };\n\n/**\n * The combineReducers helper function turns an object whose values are different\n * reducing functions into a single reducing function you can pass to registerReducer.\n *\n * @param {Object} reducers An object whose values correspond to different reducing\n *                          functions that need to be combined into one.\n *\n * @return {Function}       A reducer that invokes every reducer inside the reducers\n *                          object, and constructs a state object with the same shape.\n */\nexport { combineReducers };\n\nexport const select = defaultRegistry.select;\nexport const dispatch = defaultRegistry.dispatch;\nexport const subscribe = defaultRegistry.subscribe;\nexport const registerStore = defaultRegistry.registerStore;\nexport const registerReducer = defaultRegistry.registerReducer;\nexport const registerActions = defaultRegistry.registerActions;\nexport const registerSelectors = defaultRegistry.registerSelectors;\nexport const registerResolvers = defaultRegistry.registerResolvers;\nexport const use = defaultRegistry.use;\n","/**\n * External dependencies\n */\nimport { applyMiddleware } from 'redux';\nimport { get } from 'lodash';\n\n/**\n * Internal dependencies\n */\nimport asyncGeneratorMiddleware, { toAsyncIterable } from './middleware';\n\nexport default function( registry ) {\n\treturn {\n\t\tregisterStore( reducerKey, options ) {\n\t\t\tconst store = registry.registerStore( reducerKey, options );\n\t\t\tconst enhancer = applyMiddleware( asyncGeneratorMiddleware );\n\t\t\tconst createStore = () => store;\n\t\t\tObject.assign(\n\t\t\t\tstore,\n\t\t\t\tenhancer( createStore )( options.reducer )\n\t\t\t);\n\t\t\treturn store;\n\t\t},\n\n\t\tasync __experimentalFulfill( reducerKey, selectorName, ...args ) {\n\t\t\tconst resolver = get( registry.namespaces, [ reducerKey, 'resolvers', selectorName ] );\n\t\t\tif ( ! resolver ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst store = registry.namespaces[ reducerKey ].store;\n\t\t\tconst state = store.getState();\n\t\t\tconst action = resolver.fulfill( state, ...args );\n\t\t\tif ( action ) {\n\t\t\t\tawait store.dispatch( toAsyncIterable( action ) );\n\t\t\t}\n\t\t},\n\t};\n}\n","/**\n * WordPress dependencies\n */\nimport deprecated from '@wordpress/deprecated';\n\n/**\n * Returns true if the given argument appears to be a dispatchable action.\n *\n * @param {*} action Object to test.\n *\n * @return {boolean} Whether object is action-like.\n */\nfunction isActionLike( action ) {\n\treturn (\n\t\t!! action &&\n\t\ttypeof action.type === 'string'\n\t);\n}\n\n/**\n * Returns true if the given object is an async iterable, or false otherwise.\n *\n * @param {*} object Object to test.\n *\n * @return {boolean} Whether object is an async iterable.\n */\nfunction isAsyncIterable( object ) {\n\treturn (\n\t\t!! object &&\n\t\ttypeof object[ Symbol.asyncIterator ] === 'function'\n\t);\n}\n\n/**\n * Returns true if the given object is iterable, or false otherwise.\n *\n * @param {*} object Object to test.\n *\n * @return {boolean} Whether object is iterable.\n */\nfunction isIterable( object ) {\n\treturn (\n\t\t!! object &&\n\t\ttypeof object[ Symbol.iterator ] === 'function'\n\t);\n}\n\n/**\n * Normalizes the given object argument to an async iterable, asynchronously\n * yielding on a singular or array of generator yields or promise resolution.\n *\n * @param {*} object Object to normalize.\n *\n * @return {AsyncGenerator} Async iterable actions.\n */\nexport function toAsyncIterable( object ) {\n\tif ( isAsyncIterable( object ) ) {\n\t\tdeprecated( 'Writing Resolvers as async generators', {\n\t\t\talternative: 'resolvers as generators with controls',\n\t\t\tplugin: 'Gutenberg',\n\t\t\tversion: 4.2,\n\t\t} );\n\t\treturn object;\n\t}\n\n\treturn ( async function* () {\n\t\t// Normalize as iterable...\n\t\tif ( ! isIterable( object ) ) {\n\t\t\tobject = [ object ];\n\t\t}\n\n\t\tfor ( const maybeAction of object ) {\n\t\t\tyield maybeAction;\n\t\t}\n\t}() );\n}\n\n/**\n * Simplest possible promise redux middleware.\n *\n * @param {Object} store Redux store.\n *\n * @return {function} middleware.\n */\nconst asyncGeneratorMiddleware = ( store ) => ( next ) => ( action ) => {\n\tif ( ! isAsyncIterable( action ) ) {\n\t\treturn next( action );\n\t}\n\n\tconst runtime = async ( fulfillment ) => {\n\t\tfor await ( const maybeAction of fulfillment ) {\n\t\t// Dispatch if it quacks like an action.\n\t\t\tif ( isActionLike( maybeAction ) ) {\n\t\t\t\tstore.dispatch( maybeAction );\n\t\t\t}\n\t\t}\n\t};\n\n\treturn runtime( action );\n};\n\nexport default asyncGeneratorMiddleware;\n","/**\n * External dependencies\n */\nimport { applyMiddleware } from 'redux';\nimport { get } from 'lodash';\n\n/**\n * WordPress dependencies\n */\nimport createMiddleware from '@wordpress/redux-routine';\n\nexport default function( registry ) {\n\treturn {\n\t\tregisterStore( reducerKey, options ) {\n\t\t\tconst store = registry.registerStore( reducerKey, options );\n\n\t\t\tif ( options.controls ) {\n\t\t\t\tconst middleware = createMiddleware( options.controls );\n\t\t\t\tconst enhancer = applyMiddleware( middleware );\n\t\t\t\tconst createStore = () => store;\n\n\t\t\t\tObject.assign(\n\t\t\t\t\tstore,\n\t\t\t\t\tenhancer( createStore )( options.reducer )\n\t\t\t\t);\n\n\t\t\t\tregistry.namespaces[ reducerKey ].supportControls = true;\n\t\t\t}\n\n\t\t\treturn store;\n\t\t},\n\n\t\tasync __experimentalFulfill( reducerKey, selectorName, ...args ) {\n\t\t\tif ( ! registry.namespaces[ reducerKey ].supportControls ) {\n\t\t\t\tawait registry.__experimentalFulfill( reducerKey, selectorName, ...args );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst resolver = get( registry.namespaces, [ reducerKey, 'resolvers', selectorName ] );\n\t\t\tif ( ! resolver ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tawait registry.namespaces[ reducerKey ].store.dispatch( resolver.fulfill( ...args ) );\n\t\t},\n\t};\n}\n","export { default as controls } from './controls';\nexport { default as persistence } from './persistence';\nexport { default as asyncGenerator } from './async-generator';\n","/**\n * External dependencies\n */\nimport { pick, flow } from 'lodash';\n\n/**\n * Internal dependencies\n */\nimport defaultStorage from './storage/default';\n\n/**\n * Persistence plugin options.\n *\n * @property {Storage} storage    Persistent storage implementation. This must\n *                                at least implement `getItem` and `setItem` of\n *                                the Web Storage API.\n * @property {string}  storageKey Key on which to set in persistent storage.\n *\n * @typedef {WPDataPersistencePluginOptions}\n */\n\n/**\n * Default plugin storage.\n *\n * @type {Storage}\n */\nconst DEFAULT_STORAGE = defaultStorage;\n\n/**\n * Default plugin storage key.\n *\n * @type {string}\n */\nconst DEFAULT_STORAGE_KEY = 'WP_DATA';\n\n/**\n * Higher-order reducer to provides an initial value when state is undefined.\n *\n * @param {Function} reducer      Original reducer.\n * @param {*}         initialState Value to use as initial state.\n *\n * @return {Function} Enhanced reducer.\n */\nexport function withInitialState( reducer, initialState ) {\n\treturn ( state = initialState, action ) => {\n\t\treturn reducer( state, action );\n\t};\n}\n\n/**\n * Creates a persistence interface, exposing getter and setter methods (`get`\n * and `set` respectively).\n *\n * @param {WPDataPersistencePluginOptions} options Plugin options.\n *\n * @return {Object} Persistence interface.\n */\nexport function createPersistenceInterface( options ) {\n\tconst {\n\t\tstorage = DEFAULT_STORAGE,\n\t\tstorageKey = DEFAULT_STORAGE_KEY,\n\t} = options;\n\n\tlet data;\n\n\t/**\n\t * Returns the persisted data as an object, defaulting to an empty object.\n\t *\n\t * @return {Object} Persisted data.\n\t */\n\tfunction get() {\n\t\tif ( data === undefined ) {\n\t\t\t// If unset, getItem is expected to return null. Fall back to\n\t\t\t// empty object.\n\t\t\tconst persisted = storage.getItem( storageKey );\n\t\t\tif ( persisted === null ) {\n\t\t\t\tdata = {};\n\t\t\t} else {\n\t\t\t\ttry {\n\t\t\t\t\tdata = JSON.parse( persisted );\n\t\t\t\t} catch ( error ) {\n\t\t\t\t\t// Similarly, should any error be thrown during parse of\n\t\t\t\t\t// the string (malformed JSON), fall back to empty object.\n\t\t\t\t\tdata = {};\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn data;\n\t}\n\n\t/**\n\t * Merges an updated reducer state into the persisted data.\n\t *\n\t * @param {string} key   Key to update.\n\t * @param {*}      value Updated value.\n\t */\n\tfunction set( key, value ) {\n\t\tdata = { ...data, [ key ]: value };\n\t\tstorage.setItem( storageKey, JSON.stringify( data ) );\n\t}\n\n\treturn { get, set };\n}\n\n/**\n * Data plugin to persist store state into a single storage key.\n *\n * @param {WPDataRegistry}                  registry      Data registry.\n * @param {?WPDataPersistencePluginOptions} pluginOptions Plugin options.\n *\n * @return {WPDataPlugin} Data plugin.\n */\nexport default function( registry, pluginOptions ) {\n\tconst persistence = createPersistenceInterface( pluginOptions );\n\n\t/**\n\t * Creates an enhanced store dispatch function, triggering the state of the\n\t * given reducer key to be persisted when changed.\n\t *\n\t * @param {Function}       getState   Function which returns current state.\n\t * @param {string}         reducerKey Reducer key.\n\t * @param {?Array<string>} keys       Optional subset of keys to save.\n\t *\n\t * @return {Function} Enhanced dispatch function.\n\t */\n\tfunction createPersistOnChange( getState, reducerKey, keys ) {\n\t\tlet lastState = getState();\n\n\t\treturn ( result ) => {\n\t\t\tlet state = getState();\n\t\t\tif ( state !== lastState ) {\n\t\t\t\tif ( Array.isArray( keys ) ) {\n\t\t\t\t\tstate = pick( state, keys );\n\t\t\t\t}\n\n\t\t\t\tpersistence.set( reducerKey, state );\n\t\t\t\tlastState = state;\n\t\t\t}\n\n\t\t\treturn result;\n\t\t};\n\t}\n\n\treturn {\n\t\tregisterStore( reducerKey, options ) {\n\t\t\tif ( ! options.persist ) {\n\t\t\t\treturn registry.registerStore( reducerKey, options );\n\t\t\t}\n\n\t\t\tconst initialState = persistence.get()[ reducerKey ];\n\n\t\t\toptions = {\n\t\t\t\t...options,\n\t\t\t\treducer: withInitialState( options.reducer, initialState ),\n\t\t\t};\n\n\t\t\tconst store = registry.registerStore( reducerKey, options );\n\n\t\t\tstore.dispatch = flow( [\n\t\t\t\tstore.dispatch,\n\t\t\t\tcreatePersistOnChange(\n\t\t\t\t\tstore.getState,\n\t\t\t\t\treducerKey,\n\t\t\t\t\toptions.persist\n\t\t\t\t),\n\t\t\t] );\n\n\t\t\treturn store;\n\t\t},\n\t};\n}\n","/**\n * Internal dependencies\n */\nimport objectStorage from './object';\n\nlet storage;\n\ntry {\n\t// Private Browsing in Safari 10 and earlier will throw an error when\n\t// attempting to set into localStorage. The test here is intentional in\n\t// causing a thrown error as condition for using fallback object storage.\n\tstorage = window.localStorage;\n\tstorage.setItem( '__wpDataTestLocalStorage', '' );\n\tstorage.removeItem( '__wpDataTestLocalStorage' );\n} catch ( error ) {\n\tstorage = objectStorage;\n}\n\nexport default storage;\n","let objectStorage;\n\nconst storage = {\n\tgetItem( key ) {\n\t\tif ( ! objectStorage || ! objectStorage[ key ] ) {\n\t\t\treturn null;\n\t\t}\n\n\t\treturn objectStorage[ key ];\n\t},\n\tsetItem( key, value ) {\n\t\tif ( ! objectStorage ) {\n\t\t\tstorage.clear();\n\t\t}\n\n\t\tobjectStorage[ key ] = String( value );\n\t},\n\tclear() {\n\t\tobjectStorage = Object.create( null );\n\t},\n};\n\nexport default storage;\n","/**\n * External dependencies\n */\nimport isPromise from 'is-promise';\n\n/**\n * Simplest possible promise redux middleware.\n *\n * @return {function} middleware.\n */\nconst promiseMiddleware = () => ( next ) => ( action ) => {\n\tif ( isPromise( action ) ) {\n\t\treturn action.then( ( resolvedAction ) => {\n\t\t\tif ( resolvedAction ) {\n\t\t\t\treturn next( resolvedAction );\n\t\t\t}\n\t\t} );\n\t}\n\n\treturn next( action );\n};\n\nexport default promiseMiddleware;\n","/**\n * External dependencies\n */\nimport { createStore, applyMiddleware } from 'redux';\nimport {\n\tflowRight,\n\twithout,\n\tmapValues,\n\tget,\n} from 'lodash';\n\n/**\n * Internal dependencies\n */\nimport dataStore from './store';\nimport promise from './promise-middleware';\n\n/**\n * An isolated orchestrator of store registrations.\n *\n * @typedef {WPDataRegistry}\n *\n * @property {Function} registerReducer\n * @property {Function} registerSelectors\n * @property {Function} registerResolvers\n * @property {Function} registerActions\n * @property {Function} registerStore\n * @property {Function} subscribe\n * @property {Function} select\n * @property {Function} dispatch\n * @property {Function} use\n */\n\n/**\n * An object of registry function overrides.\n *\n * @typedef {WPDataPlugin}\n */\n\n/**\n * Creates a new store registry, given an optional object of initial store\n * configurations.\n *\n * @param {Object} storeConfigs Initial store configurations.\n *\n * @return {WPDataRegistry} Data registry.\n */\nexport function createRegistry( storeConfigs = {} ) {\n\tconst namespaces = {};\n\tlet listeners = [];\n\n\t/**\n\t * Global listener called for each store's update.\n\t */\n\tfunction globalListener() {\n\t\tlisteners.forEach( ( listener ) => listener() );\n\t}\n\n\t/**\n\t * Registers a new sub-reducer to the global state and returns a Redux-like\n\t * store object.\n\t *\n\t * @param {string} reducerKey Reducer key.\n\t * @param {Object} reducer    Reducer function.\n\t *\n\t * @return {Object} Store Object.\n\t */\n\tfunction registerReducer( reducerKey, reducer ) {\n\t\tconst enhancers = [\n\t\t\tapplyMiddleware( promise ),\n\t\t];\n\t\tif ( typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__ ) {\n\t\t\tenhancers.push( window.__REDUX_DEVTOOLS_EXTENSION__( { name: reducerKey, instanceId: reducerKey } ) );\n\t\t}\n\t\tconst store = createStore( reducer, flowRight( enhancers ) );\n\t\tnamespaces[ reducerKey ] = { store, reducer };\n\n\t\t// Customize subscribe behavior to call listeners only on effective change,\n\t\t// not on every dispatch.\n\t\tlet lastState = store.getState();\n\t\tstore.subscribe( () => {\n\t\t\tconst state = store.getState();\n\t\t\tconst hasChanged = state !== lastState;\n\t\t\tlastState = state;\n\n\t\t\tif ( hasChanged ) {\n\t\t\t\tglobalListener();\n\t\t\t}\n\t\t} );\n\n\t\treturn store;\n\t}\n\n\t/**\n\t * Registers selectors for external usage.\n\t *\n\t * @param {string} reducerKey   Part of the state shape to register the\n\t *                              selectors for.\n\t * @param {Object} newSelectors Selectors to register. Keys will be used as the\n\t *                              public facing API. Selectors will get passed the\n\t *                              state as first argument.\n\t */\n\tfunction registerSelectors( reducerKey, newSelectors ) {\n\t\tconst store = namespaces[ reducerKey ].store;\n\t\tconst createStateSelector = ( selector ) => ( ...args ) => selector( store.getState(), ...args );\n\t\tnamespaces[ reducerKey ].selectors = mapValues( newSelectors, createStateSelector );\n\t}\n\n\t/**\n\t * Registers resolvers for a given reducer key. Resolvers are side effects\n\t * invoked once per argument set of a given selector call, used in ensuring\n\t * that the data needs for the selector are satisfied.\n\t *\n\t * @param {string} reducerKey   Part of the state shape to register the\n\t *                              resolvers for.\n\t * @param {Object} newResolvers Resolvers to register.\n\t */\n\tfunction registerResolvers( reducerKey, newResolvers ) {\n\t\tnamespaces[ reducerKey ].resolvers = mapValues( newResolvers, ( resolver ) => {\n\t\t\tif ( ! resolver.fulfill ) {\n\t\t\t\tresolver = { fulfill: resolver };\n\t\t\t}\n\n\t\t\treturn resolver;\n\t\t} );\n\n\t\tnamespaces[ reducerKey ].selectors = mapValues( namespaces[ reducerKey ].selectors, ( selector, selectorName ) => {\n\t\t\tconst resolver = newResolvers[ selectorName ];\n\t\t\tif ( ! resolver ) {\n\t\t\t\treturn selector;\n\t\t\t}\n\n\t\t\treturn ( ...args ) => {\n\t\t\t\tconst { hasStartedResolution } = select( 'core/data' );\n\t\t\t\tconst { startResolution, finishResolution } = dispatch( 'core/data' );\n\t\t\t\tasync function fulfillSelector() {\n\t\t\t\t\tconst state = namespaces[ reducerKey ].store.getState();\n\t\t\t\t\tif ( typeof resolver.isFulfilled === 'function' && resolver.isFulfilled( state, ...args ) ) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( hasStartedResolution( reducerKey, selectorName, args ) ) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\tstartResolution( reducerKey, selectorName, args );\n\t\t\t\t\tawait registry.__experimentalFulfill( reducerKey, selectorName, ...args );\n\t\t\t\t\tfinishResolution( reducerKey, selectorName, args );\n\t\t\t\t}\n\n\t\t\t\tfulfillSelector( ...args );\n\t\t\t\treturn selector( ...args );\n\t\t\t};\n\t\t} );\n\t}\n\n\t/**\n\t * Registers actions for external usage.\n\t *\n\t * @param {string} reducerKey   Part of the state shape to register the\n\t *                              selectors for.\n\t * @param {Object} newActions   Actions to register.\n\t */\n\tfunction registerActions( reducerKey, newActions ) {\n\t\tconst store = namespaces[ reducerKey ].store;\n\t\tconst createBoundAction = ( action ) => ( ...args ) => store.dispatch( action( ...args ) );\n\t\tnamespaces[ reducerKey ].actions = mapValues( newActions, createBoundAction );\n\t}\n\n\t/**\n\t * Convenience for registering reducer with actions and selectors.\n\t *\n\t * @param {string} reducerKey Reducer key.\n\t * @param {Object} options    Store description (reducer, actions, selectors, resolvers).\n\t *\n\t * @return {Object} Registered store object.\n\t */\n\tfunction registerStore( reducerKey, options ) {\n\t\tif ( ! options.reducer ) {\n\t\t\tthrow new TypeError( 'Must specify store reducer' );\n\t\t}\n\n\t\tconst store = registerReducer( reducerKey, options.reducer );\n\n\t\tif ( options.actions ) {\n\t\t\tregisterActions( reducerKey, options.actions );\n\t\t}\n\n\t\tif ( options.selectors ) {\n\t\t\tregisterSelectors( reducerKey, options.selectors );\n\t\t}\n\n\t\tif ( options.resolvers ) {\n\t\t\tregisterResolvers( reducerKey, options.resolvers );\n\t\t}\n\n\t\treturn store;\n\t}\n\n\t/**\n\t * Subscribe to changes to any data.\n\t *\n\t * @param {Function}   listener Listener function.\n\t *\n\t * @return {Function}           Unsubscribe function.\n\t */\n\tconst subscribe = ( listener ) => {\n\t\tlisteners.push( listener );\n\n\t\treturn () => {\n\t\t\tlisteners = without( listeners, listener );\n\t\t};\n\t};\n\n\t/**\n\t * Calls a selector given the current state and extra arguments.\n\t *\n\t * @param {string} reducerKey Part of the state shape to register the\n\t *                            selectors for.\n\t *\n\t * @return {*} The selector's returned value.\n\t */\n\tfunction select( reducerKey ) {\n\t\treturn get( namespaces, [ reducerKey, 'selectors' ] );\n\t}\n\n\t/**\n\t * Calls a resolver given  arguments\n\t *\n\t * @param {string} reducerKey   Part of the state shape to register the\n\t *                              selectors for.\n\t * @param {string} selectorName Selector name to fulfill.\n\t * @param {Array} args          Selector Arguments.\n\t */\n\tasync function fulfill( reducerKey, selectorName, ...args ) {\n\t\tconst resolver = get( namespaces, [ reducerKey, 'resolvers', selectorName ] );\n\t\tif ( ! resolver ) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst store = namespaces[ reducerKey ].store;\n\t\tconst action = resolver.fulfill( ...args );\n\t\tif ( action ) {\n\t\t\tawait store.dispatch( action );\n\t\t}\n\t}\n\n\t/**\n\t * Returns the available actions for a part of the state.\n\t *\n\t * @param {string} reducerKey Part of the state shape to dispatch the\n\t *                            action for.\n\t *\n\t * @return {*} The action's returned value.\n\t */\n\tfunction dispatch( reducerKey ) {\n\t\treturn get( namespaces, [ reducerKey, 'actions' ] );\n\t}\n\n\t/**\n\t * Maps an object of function values to proxy invocation through to the\n\t * current internal representation of the registry, which may be enhanced\n\t * by plugins.\n\t *\n\t * @param {Object<string,Function>} attributes Object of function values.\n\t *\n\t * @return {Object<string,Function>} Object enhanced with plugin proxying.\n\t */\n\tfunction withPlugins( attributes ) {\n\t\treturn mapValues( attributes, ( attribute, key ) => {\n\t\t\tif ( typeof attribute !== 'function' ) {\n\t\t\t\treturn attribute;\n\t\t\t}\n\t\t\treturn function() {\n\t\t\t\treturn registry[ key ].apply( null, arguments );\n\t\t\t};\n\t\t} );\n\t}\n\n\tlet registry = {\n\t\tnamespaces,\n\t\tregisterReducer,\n\t\tregisterSelectors,\n\t\tregisterResolvers,\n\t\tregisterActions,\n\t\tregisterStore,\n\t\tsubscribe,\n\t\tselect,\n\t\tdispatch,\n\t\tuse,\n\t\t__experimentalFulfill: fulfill,\n\t};\n\n\t/**\n\t * Enhances the registry with the prescribed set of overrides. Returns the\n\t * enhanced registry to enable plugin chaining.\n\t *\n\t * @param {WPDataPlugin} plugin  Plugin by which to enhance.\n\t * @param {?Object}      options Optional options to pass to plugin.\n\t *\n\t * @return {WPDataRegistry} Enhanced registry.\n\t */\n\tfunction use( plugin, options ) {\n\t\tregistry = {\n\t\t\t...registry,\n\t\t\t...plugin( registry, options ),\n\t\t};\n\n\t\treturn registry;\n\t}\n\n\tObject.entries( {\n\t\t'core/data': dataStore,\n\t\t...storeConfigs,\n\t} ).map( ( [ name, config ] ) => registerStore( name, config ) );\n\n\treturn withPlugins( registry );\n}\n","/**\n * Returns an action object used in signalling that selector resolution has\n * started.\n *\n * @param {string} reducerKey   Registered store reducer key.\n * @param {string} selectorName Name of selector for which resolver triggered.\n * @param {...*}   args         Arguments to associate for uniqueness.\n *\n * @return {Object} Action object.\n */\nexport function startResolution( reducerKey, selectorName, args ) {\n\treturn {\n\t\ttype: 'START_RESOLUTION',\n\t\treducerKey,\n\t\tselectorName,\n\t\targs,\n\t};\n}\n\n/**\n * Returns an action object used in signalling that selector resolution has\n * completed.\n *\n * @param {string} reducerKey   Registered store reducer key.\n * @param {string} selectorName Name of selector for which resolver triggered.\n * @param {...*}   args         Arguments to associate for uniqueness.\n *\n * @return {Object} Action object.\n */\nexport function finishResolution( reducerKey, selectorName, args ) {\n\treturn {\n\t\ttype: 'FINISH_RESOLUTION',\n\t\treducerKey,\n\t\tselectorName,\n\t\targs,\n\t};\n}\n","/**\n * Internal dependencies\n */\nimport reducer from './reducer';\nimport * as selectors from './selectors';\nimport * as actions from './actions';\n\nexport default {\n\treducer,\n\tactions,\n\tselectors,\n};\n","/**\n * External dependencies\n */\nimport { flowRight } from 'lodash';\nimport EquivalentKeyMap from 'equivalent-key-map';\n\n/**\n * Internal dependencies\n */\nimport { onSubKey } from './utils';\n\n/**\n * Reducer function returning next state for selector resolution, object form:\n *\n *  reducerKey -> selectorName -> EquivalentKeyMap<Array,boolean>\n *\n * @param {Object} state  Current state.\n * @param {Object} action Dispatched action.\n *\n * @returns {Object} Next state.\n */\nconst isResolved = flowRight( [\n\tonSubKey( 'reducerKey' ),\n\tonSubKey( 'selectorName' ),\n] )( ( state = new EquivalentKeyMap(), action ) => {\n\tswitch ( action.type ) {\n\t\tcase 'START_RESOLUTION':\n\t\tcase 'FINISH_RESOLUTION':\n\t\t\tconst isStarting = action.type === 'START_RESOLUTION';\n\t\t\tconst nextState = new EquivalentKeyMap( state );\n\t\t\tnextState.set( action.args, isStarting );\n\t\t\treturn nextState;\n\t}\n\n\treturn state;\n} );\n\nexport default isResolved;\n","/**\n * External dependencies\n */\nimport { get } from 'lodash';\n\n/**\n * Returns the raw `isResolving` value for a given reducer key, selector name,\n * and arguments set. May be undefined if the selector has never been resolved\n * or not resolved for the given set of arguments, otherwise true or false for\n * resolution started and completed respectively.\n *\n * @param {Object} state        Data state.\n * @param {string} reducerKey   Registered store reducer key.\n * @param {string} selectorName Selector name.\n * @param {Array}  args         Arguments passed to selector.\n *\n * @return {?boolean} isResolving value.\n */\nexport function getIsResolving( state, reducerKey, selectorName, args ) {\n\tconst map = get( state, [ reducerKey, selectorName ] );\n\tif ( ! map ) {\n\t\treturn;\n\t}\n\n\treturn map.get( args );\n}\n\n/**\n * Returns true if resolution has already been triggered for a given reducer\n * key, selector name, and arguments set.\n *\n * @param {Object} state        Data state.\n * @param {string} reducerKey   Registered store reducer key.\n * @param {string} selectorName Selector name.\n * @param {?Array} args         Arguments passed to selector (default `[]`).\n *\n * @return {boolean} Whether resolution has been triggered.\n */\nexport function hasStartedResolution( state, reducerKey, selectorName, args = [] ) {\n\treturn getIsResolving( state, reducerKey, selectorName, args ) !== undefined;\n}\n\n/**\n * Returns true if resolution has completed for a given reducer key, selector\n * name, and arguments set.\n *\n * @param {Object} state        Data state.\n * @param {string} reducerKey   Registered store reducer key.\n * @param {string} selectorName Selector name.\n * @param {?Array} args         Arguments passed to selector.\n *\n * @return {boolean} Whether resolution has completed.\n */\nexport function hasFinishedResolution( state, reducerKey, selectorName, args = [] ) {\n\treturn getIsResolving( state, reducerKey, selectorName, args ) === false;\n}\n\n/**\n * Returns true if resolution has been triggered but has not yet completed for\n * a given reducer key, selector name, and arguments set.\n *\n * @param {Object} state        Data state.\n * @param {string} reducerKey   Registered store reducer key.\n * @param {string} selectorName Selector name.\n * @param {?Array} args         Arguments passed to selector.\n *\n * @return {boolean} Whether resolution is in progress.\n */\nexport function isResolving( state, reducerKey, selectorName, args = [] ) {\n\treturn getIsResolving( state, reducerKey, selectorName, args ) === true;\n}\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","'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","module.exports = isPromise;\n\nfunction isPromise(obj) {\n  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';\n}\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","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\"][\"compose\"]; }());","(function() { module.exports = this[\"wp\"][\"deprecated\"]; }());","(function() { module.exports = this[\"wp\"][\"element\"]; }());","(function() { module.exports = this[\"wp\"][\"isShallowEqual\"]; }());","(function() { module.exports = this[\"wp\"][\"reduxRoutine\"]; }());","(function() { module.exports = this[\"lodash\"]; }());"],"sourceRoot":""}