85 /******/ 	return __webpack_require__(__webpack_require__.s = 464);

    85 /******/ 	return __webpack_require__(__webpack_require__.s = "+ekt");

    90 /***/ 151:

    90 /***/ "+ekt":

    91 /***/ (function(module, __webpack_exports__, __webpack_require__) {

    92 

    93 "use strict";

    94 // ESM COMPAT FLAG

    95 __webpack_require__.r(__webpack_exports__);

    96 

    97 // EXPORTS

    98 __webpack_require__.d(__webpack_exports__, "default", function() { return /* binding */ createMiddleware; });

    99 

   100 // CONCATENATED MODULE: ./node_modules/@wordpress/redux-routine/build-module/is-generator.js

   101 /**

   102  * Returns true if the given object is a generator, or false otherwise.

   103  *

   104  * @see https://www.ecma-international.org/ecma-262/6.0/#sec-generator-objects

   105  *

   106  * @param {*} object Object to test.

   107  *

   108  * @return {boolean} Whether object is a generator.

   109  */

   110 function isGenerator(object) {

   111   // Check that iterator (next) and iterable (Symbol.iterator) interfaces are satisfied.

   112   // These checks seem to be compatible with several generator helpers as well as the native implementation.

   113   return !!object && typeof object[Symbol.iterator] === 'function' && typeof object.next === 'function';

   114 }

   115 

   116 // EXTERNAL MODULE: ./node_modules/rungen/dist/index.js

   117 var dist = __webpack_require__("hnoU");

   118 

   119 // EXTERNAL MODULE: external "lodash"

   120 var external_lodash_ = __webpack_require__("YLtl");

   121 

   122 // EXTERNAL MODULE: ./node_modules/is-promise/index.js

   123 var is_promise = __webpack_require__("JlUD");

   124 var is_promise_default = /*#__PURE__*/__webpack_require__.n(is_promise);

   125 

   126 // CONCATENATED MODULE: ./node_modules/@wordpress/redux-routine/build-module/is-action.js

   127 /**

   128  * External dependencies

   129  */

   130 

   131 /**

   132  * Returns true if the given object quacks like an action.

   133  *

   134  * @param {*} object Object to test

   135  *

   136  * @return {boolean}  Whether object is an action.

   137  */

   138 

   139 function isAction(object) {

   140   return Object(external_lodash_["isPlainObject"])(object) && Object(external_lodash_["isString"])(object.type);

   141 }

   142 /**

   143  * Returns true if the given object quacks like an action and has a specific

   144  * action type

   145  *

   146  * @param {*}      object       Object to test

   147  * @param {string} expectedType The expected type for the action.

   148  *

   149  * @return {boolean} Whether object is an action and is of specific type.

   150  */

   151 

   152 function isActionOfType(object, expectedType) {

   153   return isAction(object) && object.type === expectedType;

   154 }

   155 

   156 // CONCATENATED MODULE: ./node_modules/@wordpress/redux-routine/build-module/runtime.js

   157 /**

   158  * External dependencies

   159  */

   160 

   161 

   162 

   163 /**

   164  * Internal dependencies

   165  */

   166 

   167 

   168 /**

   169  * Create a co-routine runtime.

   170  *

   171  * @param {Object}    controls Object of control handlers.

   172  * @param {Function}  dispatch Unhandled action dispatch.

   173  *

   174  * @return {Function} co-routine runtime

   175  */

   176 

   177 function createRuntime(controls = {}, dispatch) {

   178   const rungenControls = Object(external_lodash_["map"])(controls, (control, actionType) => (value, next, iterate, yieldNext, yieldError) => {

   179     if (!isActionOfType(value, actionType)) {

   180       return false;

   181     }

   182 

   183     const routine = control(value);

   184 

   185     if (is_promise_default()(routine)) {

   186       // Async control routine awaits resolution.

   187       routine.then(yieldNext, yieldError);

   188     } else {

   189       yieldNext(routine);

   190     }

   191 

   192     return true;

   193   });

   194 

   195   const unhandledActionControl = (value, next) => {

   196     if (!isAction(value)) {

   197       return false;

   198     }

   199 

   200     dispatch(value);

   201     next();

   202     return true;

   203   };

   204 

   205   rungenControls.push(unhandledActionControl);

   206   const rungenRuntime = Object(dist["create"])(rungenControls);

   207   return action => new Promise((resolve, reject) => rungenRuntime(action, result => {

   208     if (isAction(result)) {

   209       dispatch(result);

   210     }

   211 

   212     resolve(result);

   213   }, reject));

   214 }

   215 

   216 // CONCATENATED MODULE: ./node_modules/@wordpress/redux-routine/build-module/index.js

   217 /**

   218  * Internal dependencies

   219  */

   220 

   221 

   222 /**

   223  * Creates a Redux middleware, given an object of controls where each key is an

   224  * action type for which to act upon, the value a function which returns either

   225  * a promise which is to resolve when evaluation of the action should continue,

   226  * or a value. The value or resolved promise value is assigned on the return

   227  * value of the yield assignment. If the control handler returns undefined, the

   228  * execution is not continued.

   229  *

   230  * @param {Object} controls Object of control handlers.

   231  *

   232  * @return {Function} Co-routine runtime

   233  */

   234 

   235 function createMiddleware(controls = {}) {

   236   return store => {

   237     const runtime = createRuntime(controls, store.dispatch);

   238     return next => action => {

   239       if (!isGenerator(action)) {

   240         return next(action);

   241       }

   242 

   243       return runtime(action);

   244     };

   245   };

   246 }

   247 

   248 

   249 /***/ }),

   250 

   251 /***/ "Hkfj":

   252 /***/ (function(module, exports, __webpack_require__) {

   253 

   254 "use strict";

   255 

   256 

   257 Object.defineProperty(exports, "__esModule", {

   258   value: true

   259 });

   260 var createDispatcher = function createDispatcher() {

   261   var listeners = [];

   262 

   263   return {

   264     subscribe: function subscribe(listener) {

   265       listeners.push(listener);

   266       return function () {

   267         listeners = listeners.filter(function (l) {

   268           return l !== listener;

   269         });

   270       };

   271     },

   272     dispatch: function dispatch(action) {

   273       listeners.slice().forEach(function (listener) {

   274         return listener(action);

   275       });

   276     }

   277   };

   278 };

   279 

   280 exports.default = createDispatcher;

   281 

   282 /***/ }),

   283 

   284 /***/ "JlUD":

   103 /***/ 158:

   297 /***/ "PERq":

   112 

   306 exports.cps = exports.call = undefined;

   113 var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

   307 

   114 

   308 var _is = __webpack_require__("qmpp");

   115 var _keys = __webpack_require__(257);

   309 

   116 

   310 var _is2 = _interopRequireDefault(_is);

   117 var _keys2 = _interopRequireDefault(_keys);

   121 var is = {

   314 function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

   122   obj: function obj(value) {

   315 

   123     return (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && !!value;

   316 var call = exports.call = function call(value, next, rungen, yieldNext, raiseNext) {

   124   },

   317   if (!_is2.default.call(value)) return false;

   125   all: function all(value) {

   318   try {

   126     return is.obj(value) && value.type === _keys2.default.all;

   319     next(value.func.apply(value.context, value.args));

   127   },

   320   } catch (err) {

   128   error: function error(value) {

   321     raiseNext(err);

   129     return is.obj(value) && value.type === _keys2.default.error;

   130   },

   131   array: Array.isArray,

   132   func: function func(value) {

   133     return typeof value === 'function';

   134   },

   135   promise: function promise(value) {

   136     return value && is.func(value.then);

   137   },

   138   iterator: function iterator(value) {

   139     return value && is.func(value.next) && is.func(value.throw);

   140   },

   141   fork: function fork(value) {

   142     return is.obj(value) && value.type === _keys2.default.fork;

   143   },

   144   join: function join(value) {

   145     return is.obj(value) && value.type === _keys2.default.join;

   146   },

   147   race: function race(value) {

   148     return is.obj(value) && value.type === _keys2.default.race;

   149   },

   150   call: function call(value) {

   151     return is.obj(value) && value.type === _keys2.default.call;

   152   },

   153   cps: function cps(value) {

   154     return is.obj(value) && value.type === _keys2.default.cps;

   155   },

   156   subscribe: function subscribe(value) {

   157     return is.obj(value) && value.type === _keys2.default.subscribe;

   158   },

   159   channel: function channel(value) {

   160     return is.obj(value) && is.func(value.subscribe);

   162 };

   323   return true;

   163 

   324 };

   164 exports.default = is;

   325 

   165 

   326 var cps = exports.cps = function cps(value, next, rungen, yieldNext, raiseNext) {

   166 /***/ }),

   327   var _value$func;

   167 

   328 

   168 /***/ 2:

   329   if (!_is2.default.cps(value)) return false;

   330   (_value$func = value.func).call.apply(_value$func, [null].concat(_toConsumableArray(value.args), [function (err, result) {

   331     if (err) raiseNext(err);else next(result);

   332   }]));

   333   return true;

   334 };

   335 

   336 exports.default = [call, cps];

   337 

   338 /***/ }),

   339 

   340 /***/ "YLtl":

   171 (function() { module.exports = this["lodash"]; }());

   343 (function() { module.exports = window["lodash"]; }());

   172 

   344 

   173 /***/ }),

   345 /***/ }),

   174 

   346 

   175 /***/ 256:

   347 /***/ "e6BM":

   186 var _keys = __webpack_require__(257);

   358 var _keys = __webpack_require__("tGEh");

   316 /***/ 257:

   488 /***/ "hecb":

   317 /***/ (function(module, exports, __webpack_require__) {

   318 

   319 "use strict";

   320 

   321 

   322 Object.defineProperty(exports, "__esModule", {

   323   value: true

   324 });

   325 var keys = {

   326   all: Symbol('all'),

   327   error: Symbol('error'),

   328   fork: Symbol('fork'),

   329   join: Symbol('join'),

   330   race: Symbol('race'),

   331   call: Symbol('call'),

   332   cps: Symbol('cps'),

   333   subscribe: Symbol('subscribe')

   334 };

   335 

   336 exports.default = keys;

   337 

   338 /***/ }),

   339 

   340 /***/ 277:

   341 /***/ (function(module, exports, __webpack_require__) {

   342 

   343 "use strict";

   344 

   345 

   346 Object.defineProperty(exports, "__esModule", {

   347   value: true

   348 });

   349 exports.wrapControls = exports.asyncControls = exports.create = undefined;

   350 

   351 var _helpers = __webpack_require__(256);

   352 

   353 Object.keys(_helpers).forEach(function (key) {

   354   if (key === "default") return;

   355   Object.defineProperty(exports, key, {

   356     enumerable: true,

   357     get: function get() {

   358       return _helpers[key];

   359     }

   360   });

   361 });

   362 

   363 var _create = __webpack_require__(426);

   364 

   365 var _create2 = _interopRequireDefault(_create);

   366 

   367 var _async = __webpack_require__(428);

   368 

   369 var _async2 = _interopRequireDefault(_async);

   370 

   371 var _wrap = __webpack_require__(430);

   372 

   373 var _wrap2 = _interopRequireDefault(_wrap);

   374 

   375 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

   376 

   377 exports.create = _create2.default;

   378 exports.asyncControls = _async2.default;

   379 exports.wrapControls = _wrap2.default;

   380 

   381 /***/ }),

   382 

   383 /***/ 426:

   384 /***/ (function(module, exports, __webpack_require__) {

   385 

   386 "use strict";

   387 

   388 

   389 Object.defineProperty(exports, "__esModule", {

   390   value: true

   391 });

   392 

   393 var _builtin = __webpack_require__(427);

   394 

   395 var _builtin2 = _interopRequireDefault(_builtin);

   396 

   397 var _is = __webpack_require__(158);

   398 

   399 var _is2 = _interopRequireDefault(_is);

   400 

   401 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

   402 

   403 function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

   404 

   405 var create = function create() {

   406   var userControls = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];

   407 

   408   var controls = [].concat(_toConsumableArray(userControls), _toConsumableArray(_builtin2.default));

   409 

   410   var runtime = function runtime(input) {

   411     var success = arguments.length <= 1 || arguments[1] === undefined ? function () {} : arguments[1];

   412     var error = arguments.length <= 2 || arguments[2] === undefined ? function () {} : arguments[2];

   413 

   414     var iterate = function iterate(gen) {

   415       var yieldValue = function yieldValue(isError) {

   416         return function (ret) {

   417           try {

   418             var _ref = isError ? gen.throw(ret) : gen.next(ret);

   419 

   420             var value = _ref.value;

   421             var done = _ref.done;

   422 

   423             if (done) return success(value);

   424             next(value);

   425           } catch (e) {

   426             return error(e);

   427           }

   428         };

   429       };

   430 

   431       var next = function next(ret) {

   432         controls.some(function (control) {

   433           return control(ret, next, runtime, yieldValue(false), yieldValue(true));

   434         });

   435       };

   436 

   437       yieldValue(false)();

   438     };

   439 

   440     var iterator = _is2.default.iterator(input) ? input : regeneratorRuntime.mark(function _callee() {

   441       return regeneratorRuntime.wrap(function _callee$(_context) {

   442         while (1) {

   443           switch (_context.prev = _context.next) {

   444             case 0:

   445               _context.next = 2;

   446               return input;

   447 

   448             case 2:

   449               return _context.abrupt('return', _context.sent);

   450 

   451             case 3:

   452             case 'end':

   453               return _context.stop();

   454           }

   455         }

   456       }, _callee, this);

   457     })();

   458 

   459     iterate(iterator, success, error);

   460   };

   461 

   462   return runtime;

   463 };

   464 

   465 exports.default = create;

   466 

   467 /***/ }),

   468 

   469 /***/ 427:

   470 /***/ (function(module, exports, __webpack_require__) {

   471 

   472 "use strict";

   473 

   474 

   475 Object.defineProperty(exports, "__esModule", {

   476   value: true

   477 });

   478 exports.iterator = exports.array = exports.object = exports.error = exports.any = undefined;

   479 

   480 var _is = __webpack_require__(158);

   481 

   482 var _is2 = _interopRequireDefault(_is);

   483 

   484 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

   485 

   486 var any = exports.any = function any(value, next, rungen, yieldNext) {

   487   yieldNext(value);

   488   return true;

   489 };

   490 

   491 var error = exports.error = function error(value, next, rungen, yieldNext, raiseNext) {

   492   if (!_is2.default.error(value)) return false;

   493   raiseNext(value.error);

   494   return true;

   495 };

   496 

   497 var object = exports.object = function object(value, next, rungen, yieldNext, raiseNext) {

   498   if (!_is2.default.all(value) || !_is2.default.obj(value.value)) return false;

   499   var result = {};

   500   var keys = Object.keys(value.value);

   501   var count = 0;

   502   var hasError = false;

   503   var gotResultSuccess = function gotResultSuccess(key, ret) {

   504     if (hasError) return;

   505     result[key] = ret;

   506     count++;

   507     if (count === keys.length) {

   508       yieldNext(result);

   509     }

   510   };

   511 

   512   var gotResultError = function gotResultError(key, error) {

   513     if (hasError) return;

   514     hasError = true;

   515     raiseNext(error);

   516   };

   517 

   518   keys.map(function (key) {

   519     rungen(value.value[key], function (ret) {

   520       return gotResultSuccess(key, ret);

   521     }, function (err) {

   522       return gotResultError(key, err);

   523     });

   524   });

   525 

   526   return true;

   527 };

   528 

   529 var array = exports.array = function array(value, next, rungen, yieldNext, raiseNext) {

   530   if (!_is2.default.all(value) || !_is2.default.array(value.value)) return false;

   531   var result = [];

   532   var count = 0;

   533   var hasError = false;

   534   var gotResultSuccess = function gotResultSuccess(key, ret) {

   535     if (hasError) return;

   536     result[key] = ret;

   537     count++;

   538     if (count === value.value.length) {

   539       yieldNext(result);

   540     }

   541   };

   542 

   543   var gotResultError = function gotResultError(key, error) {

   544     if (hasError) return;

   545     hasError = true;

   546     raiseNext(error);

   547   };

   548 

   549   value.value.map(function (v, key) {

   550     rungen(v, function (ret) {

   551       return gotResultSuccess(key, ret);

   552     }, function (err) {

   553       return gotResultError(key, err);

   554     });

   555   });

   556 

   557   return true;

   558 };

   559 

   560 var iterator = exports.iterator = function iterator(value, next, rungen, yieldNext, raiseNext) {

   561   if (!_is2.default.iterator(value)) return false;

   562   rungen(value, next, raiseNext);

   563   return true;

   564 };

   565 

   566 exports.default = [error, iterator, array, object, any];

   567 

   568 /***/ }),

   569 

   570 /***/ 428:

   581 var _is = __webpack_require__(158);

   499 var _is = __webpack_require__("qmpp");

   585 var _helpers = __webpack_require__(256);

   503 var _helpers = __webpack_require__("e6BM");

   586 

   504 

   587 var _dispatcher = __webpack_require__(429);

   505 var _dispatcher = __webpack_require__("Hkfj");

   692 /***/ 429:

   610 /***/ "hnoU":

   701 var createDispatcher = function createDispatcher() {

   619 exports.wrapControls = exports.asyncControls = exports.create = undefined;

   702   var listeners = [];

   620 

   703 

   621 var _helpers = __webpack_require__("e6BM");

   704   return {

   622 

   705     subscribe: function subscribe(listener) {

   623 Object.keys(_helpers).forEach(function (key) {

   706       listeners.push(listener);

   624   if (key === "default") return;

   707       return function () {

   625   Object.defineProperty(exports, key, {

   708         listeners = listeners.filter(function (l) {

   626     enumerable: true,

   709           return l !== listener;

   627     get: function get() {

   710         });

   628       return _helpers[key];

   711       };

   712     },

   713     dispatch: function dispatch(action) {

   714       listeners.slice().forEach(function (listener) {

   715         return listener(action);

   716       });

   718   };

   630   });

   719 };

   631 });

   720 

   632 

   721 exports.default = createDispatcher;

   633 var _create = __webpack_require__("vsQm");

   722 

   634 

   723 /***/ }),

   635 var _create2 = _interopRequireDefault(_create);

   724 

   636 

   725 /***/ 430:

   637 var _async = __webpack_require__("hecb");

   638 

   639 var _async2 = _interopRequireDefault(_async);

   640 

   641 var _wrap = __webpack_require__("PERq");

   642 

   643 var _wrap2 = _interopRequireDefault(_wrap);

   644 

   645 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

   646 

   647 exports.create = _create2.default;

   648 exports.asyncControls = _async2.default;

   649 exports.wrapControls = _wrap2.default;

   650 

   651 /***/ }),

   652 

   653 /***/ "k4FQ":

   734 exports.cps = exports.call = undefined;

   662 exports.iterator = exports.array = exports.object = exports.error = exports.any = undefined;

   735 

   663 

   736 var _is = __webpack_require__(158);

   664 var _is = __webpack_require__("qmpp");

   744 var call = exports.call = function call(value, next, rungen, yieldNext, raiseNext) {

   865 var create = function create() {

   745   if (!_is2.default.call(value)) return false;

   866   var userControls = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];

   746   try {

   867 

   747     next(value.func.apply(value.context, value.args));

   868   var controls = [].concat(_toConsumableArray(userControls), _toConsumableArray(_builtin2.default));

   748   } catch (err) {

   869 

   749     raiseNext(err);

   870   var runtime = function runtime(input) {

   750   }

   871     var success = arguments.length <= 1 || arguments[1] === undefined ? function () {} : arguments[1];

   751   return true;

   872     var error = arguments.length <= 2 || arguments[2] === undefined ? function () {} : arguments[2];

   752 };

   873 

   753 

   874     var iterate = function iterate(gen) {

   754 var cps = exports.cps = function cps(value, next, rungen, yieldNext, raiseNext) {

   875       var yieldValue = function yieldValue(isError) {

   755   var _value$func;

   876         return function (ret) {

   756 

   877           try {

   757   if (!_is2.default.cps(value)) return false;

   878             var _ref = isError ? gen.throw(ret) : gen.next(ret);

   758   (_value$func = value.func).call.apply(_value$func, [null].concat(_toConsumableArray(value.args), [function (err, result) {

   879 

   759     if (err) raiseNext(err);else next(result);

   880             var value = _ref.value;

   760   }]));

   881             var done = _ref.done;

   761   return true;

   882 

   762 };

   883             if (done) return success(value);

   763 

   884             next(value);

   764 exports.default = [call, cps];

   885           } catch (e) {

   765 

   886             return error(e);

   766 /***/ }),

   887           }

   767 

   888         };

   768 /***/ 464:

   889       };

   769 /***/ (function(module, __webpack_exports__, __webpack_require__) {

   890 

   770 

   891       var next = function next(ret) {

   771 "use strict";

   892         controls.some(function (control) {

   772 // ESM COMPAT FLAG

   893           return control(ret, next, runtime, yieldValue(false), yieldValue(true));

   773 __webpack_require__.r(__webpack_exports__);

   894         });

   774 

   895       };

   775 // EXPORTS

   896 

   776 __webpack_require__.d(__webpack_exports__, "default", function() { return /* binding */ createMiddleware; });

   897       yieldValue(false)();

   777 

   778 // CONCATENATED MODULE: ./node_modules/@wordpress/redux-routine/build-module/is-generator.js

   779 /**

   780  * Returns true if the given object is a generator, or false otherwise.

   781  *

   782  * @see https://www.ecma-international.org/ecma-262/6.0/#sec-generator-objects

   783  *

   784  * @param {*} object Object to test.

   785  *

   786  * @return {boolean} Whether object is a generator.

   787  */

   788 function isGenerator(object) {

   789   // Check that iterator (next) and iterable (Symbol.iterator) interfaces are satisfied.

   790   // These checks seem to be compatible with several generator helpers as well as the native implementation.

   791   return !!object && typeof object[Symbol.iterator] === 'function' && typeof object.next === 'function';

   792 }

   793 

   794 // EXTERNAL MODULE: ./node_modules/rungen/dist/index.js

   795 var dist = __webpack_require__(277);

   796 

   797 // EXTERNAL MODULE: external {"this":"lodash"}

   798 var external_this_lodash_ = __webpack_require__(2);

   799 

   800 // EXTERNAL MODULE: ./node_modules/is-promise/index.js

   801 var is_promise = __webpack_require__(151);

   802 var is_promise_default = /*#__PURE__*/__webpack_require__.n(is_promise);

   803 

   804 // CONCATENATED MODULE: ./node_modules/@wordpress/redux-routine/build-module/is-action.js

   805 /**

   806  * External dependencies

   807  */

   808 

   809 /**

   810  * Returns true if the given object quacks like an action.

   811  *

   812  * @param {*} object Object to test

   813  *

   814  * @return {boolean}  Whether object is an action.

   815  */

   816 

   817 function isAction(object) {

   818   return Object(external_this_lodash_["isPlainObject"])(object) && Object(external_this_lodash_["isString"])(object.type);

   819 }

   820 /**

   821  * Returns true if the given object quacks like an action and has a specific

   822  * action type

   823  *

   824  * @param {*}      object       Object to test

   825  * @param {string} expectedType The expected type for the action.

   826  *

   827  * @return {boolean} Whether object is an action and is of specific type.

   828  */

   829 

   830 function isActionOfType(object, expectedType) {

   831   return isAction(object) && object.type === expectedType;

   832 }

   833 

   834 // CONCATENATED MODULE: ./node_modules/@wordpress/redux-routine/build-module/runtime.js

   835 /**

   836  * External dependencies

   837  */

   838 

   839 

   840 

   841 /**

   842  * Internal dependencies

   843  */

   844 

   845 

   846 /**

   847  * Create a co-routine runtime.

   848  *

   849  * @param {Object}    controls Object of control handlers.

   850  * @param {Function}  dispatch Unhandled action dispatch.

   851  *

   852  * @return {Function} co-routine runtime

   853  */

   854 

   855 function createRuntime() {

   856   var controls = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

   857   var dispatch = arguments.length > 1 ? arguments[1] : undefined;

   858   var rungenControls = Object(external_this_lodash_["map"])(controls, function (control, actionType) {

   859     return function (value, next, iterate, yieldNext, yieldError) {

   860       if (!isActionOfType(value, actionType)) {

   861         return false;

   862       }

   863 

   864       var routine = control(value);

   865 

   866       if (is_promise_default()(routine)) {

   867         // Async control routine awaits resolution.

   868         routine.then(yieldNext, yieldError);

   869       } else {

   870         yieldNext(routine);

   871       }

   872 

   873       return true;

   875   });

   899 

   876 

   900     var iterator = _is2.default.iterator(input) ? input : regeneratorRuntime.mark(function _callee() {

   877   var unhandledActionControl = function unhandledActionControl(value, next) {

   901       return regeneratorRuntime.wrap(function _callee$(_context) {

   878     if (!isAction(value)) {

   902         while (1) {

   879       return false;

   903           switch (_context.prev = _context.next) {

   880     }

   904             case 0:

   881 

   905               _context.next = 2;

   882     dispatch(value);

   906               return input;

   883     next();

   907 

   884     return true;

   908             case 2:

   885   };

   909               return _context.abrupt('return', _context.sent);

   886 

   910 

   887   rungenControls.push(unhandledActionControl);

   911             case 3:

   888   var rungenRuntime = Object(dist["create"])(rungenControls);

   912             case 'end':

   889   return function (action) {

   913               return _context.stop();

   890     return new Promise(function (resolve, reject) {

   914           }

   891       return rungenRuntime(action, function (result) {

   892         if (isAction(result)) {

   893           dispatch(result);

   895 

   916       }, _callee, this);

   896         resolve(result);

   917     })();

   897       }, reject);

   918 

   898     });

   919     iterate(iterator, success, error);

   899   };

   920   };

   900 }

   921 

   901 

   922   return runtime;

   902 // CONCATENATED MODULE: ./node_modules/@wordpress/redux-routine/build-module/index.js

   923 };

   903 /**

   924 

   904  * Internal dependencies

   925 exports.default = create;

   905  */

   906 

   907 

   908 /**

   909  * Creates a Redux middleware, given an object of controls where each key is an

   910  * action type for which to act upon, the value a function which returns either

   911  * a promise which is to resolve when evaluation of the action should continue,

   912  * or a value. The value or resolved promise value is assigned on the return

   913  * value of the yield assignment. If the control handler returns undefined, the

   914  * execution is not continued.

   915  *

   916  * @param {Object} controls Object of control handlers.

   917  *

   918  * @return {Function} Co-routine runtime

   919  */

   920 

   921 function createMiddleware() {

   922   var controls = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

   923   return function (store) {

   924     var runtime = createRuntime(controls, store.dispatch);

   925     return function (next) {

   926       return function (action) {

   927         if (!isGenerator(action)) {

   928           return next(action);

   929         }

   930 

   931         return runtime(action);

   932       };

   933     };

   934   };

   935 }

   936