@modern-js/plugin 1.0.0 → 1.1.2

package/dist/js/treeshaking/waterfall/async.js

@@ -1,3 +1,13 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
@@ -12,20 +22,13 @@ function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToAr
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-import { createAsyncCounter } from "../counter";
-import { runHooks, fromContainer, createContainer, useContainer } from "../context";
+import { createAsyncPipeline, useContainer } from 'farrow-pipeline';
 var ASYNC_WATERFALL_SYMBOL = Symbol('ASYNC_WATERFALL_SYMBOL');
 export var getAsyncBrook = function getAsyncBrook(input) {
   if (typeof input === 'function') {
     return input;
-  } else if (input && typeof input.brook === 'function') {
-    return input.brook;
+  } else if (input && typeof input.middlware === 'function') {
+    return input.middlware;
   } // eslint-disable-next-line @typescript-eslint/no-base-to-string,@typescript-eslint/restrict-template-expressions
 
 
@@ -33,124 +36,76 @@ export var getAsyncBrook = function getAsyncBrook(input) {
 };
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 export var createAsyncWaterfall = function createAsyncWaterfall() {
-  var middlewares = [];
-
-  var createCurrentRunner = function createCurrentRunner(hooks) {
-    return createAsyncCounter( /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(index, input, next) {
-        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                if (!(index >= middlewares.length)) {
-                  _context2.next = 2;
-                  break;
-                }
-
-                return _context2.abrupt("return", input);
-
-              case 2:
-                return _context2.abrupt("return", runHooks( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-                  return _regeneratorRuntime.wrap(function _callee$(_context) {
-                    while (1) {
-                      switch (_context.prev = _context.next) {
-                        case 0:
-                          _context.t0 = next;
-                          _context.next = 3;
-                          return middlewares[index](input);
-
-                        case 3:
-                          _context.t1 = _context.sent;
-
-                          if (_context.t1) {
-                            _context.next = 6;
-                            break;
-                          }
-
-                          _context.t1 = input;
-
-                        case 6:
-                          _context.t2 = _context.t1;
-                          return _context.abrupt("return", (0, _context.t0)(_context.t2));
-
-                        case 8:
-                        case "end":
-                          return _context.stop();
-                      }
-                    }
-                  }, _callee);
-                })), hooks));
-
-              case 3:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2);
-      }));
-
-      return function (_x, _x2, _x3) {
-        return _ref.apply(this, arguments);
-      };
-    }());
-  };
-
-  var currentContainer = createContainer();
-  var currentHooks = fromContainer(currentContainer);
-  var currentRunner = createCurrentRunner(currentHooks);
+  var pipeline = createAsyncPipeline();
 
   var use = function use() {
     for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
       input[_key] = arguments[_key];
     }
 
-    middlewares.push.apply(middlewares, _toConsumableArray(input.map(getAsyncBrook)));
+    pipeline.use.apply(pipeline, _toConsumableArray(input.map(getAsyncBrook).map(mapAsyncBrookToAsyncMiddleware)));
     return waterfall;
   };
 
-  var run = /*#__PURE__*/function () {
-    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(input, options) {
-      var _options$container;
-
-      var container, hooks, runner;
-      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-        while (1) {
-          switch (_context3.prev = _context3.next) {
-            case 0:
-              container = (_options$container = options === null || options === void 0 ? void 0 : options.container) !== null && _options$container !== void 0 ? _options$container : currentContainer;
-              hooks = container === currentContainer ? currentHooks : fromContainer(container);
-              runner = container === currentContainer ? currentRunner : createCurrentRunner(hooks);
-              return _context3.abrupt("return", runner.start(input));
-
-            case 4:
-            case "end":
-              return _context3.stop();
-          }
+  var run = function run(input, options) {
+    return (// eslint-disable-next-line @typescript-eslint/no-shadow
+      pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
+        onLast: function onLast(input) {
+          return input;
         }
-      }, _callee3);
-    }));
-
-    return function run(_x4, _x5) {
-      return _ref3.apply(this, arguments);
-    };
-  }();
+      }))
+    );
+  };
 
-  var brook = function brook(input) {
+  var middlware = function middlware(input) {
     // eslint-disable-next-line react-hooks/rules-of-hooks
-    var container = useContainer();
-    return run(input, {
-      container: container
+    var container = useContainer(); // eslint-disable-next-line @typescript-eslint/no-shadow
+
+    return pipeline.run(input, {
+      container: container,
+      onLast: function onLast(input) {
+        return input;
+      }
     });
   };
 
-  var waterfall = _defineProperty({
+  var waterfall = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
     use: use,
     run: run,
-    brook: brook
-  }, ASYNC_WATERFALL_SYMBOL, true);
+    middlware: middlware
+  }, ASYNC_WATERFALL_SYMBOL, true));
 
   return waterfall;
 };
 export var isAsyncWaterfall = function isAsyncWaterfall(input) {
   return Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WATERFALL_SYMBOL]);
+};
+
+var mapAsyncBrookToAsyncMiddleware = function mapAsyncBrookToAsyncMiddleware(brook) {
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(input, next) {
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.t0 = next;
+              _context.next = 3;
+              return brook(input);
+
+            case 3:
+              _context.t1 = _context.sent;
+              return _context.abrupt("return", (0, _context.t0)(_context.t1));
+
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
 };

package/dist/js/treeshaking/waterfall/sync.js

@@ -1,3 +1,7 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
@@ -12,15 +16,13 @@ function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToAr
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-import { createCounter } from "../counter";
-import { runHooks, fromContainer, createContainer, useContainer } from "../context";
-var WATERFALL_SYMBOL = Symbol('WATERFALL_SYMBOL'); // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-
+import { useContainer, createPipeline } from 'farrow-pipeline';
+var WATERFALL_SYMBOL = Symbol('WATERFALL_SYMBOL');
 export var getBrook = function getBrook(input) {
   if (typeof input === 'function') {
     return input;
-  } else if (input && typeof input.brook === 'function') {
-    return input.brook;
+  } else if (input && typeof input.middleware === 'function') {
+    return input.middleware;
   } // eslint-disable-next-line @typescript-eslint/no-base-to-string,@typescript-eslint/restrict-template-expressions
 
 
@@ -28,58 +30,53 @@ export var getBrook = function getBrook(input) {
 };
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 export var createWaterfall = function createWaterfall() {
-  var middlewares = [];
-
-  var createCurrentRunner = function createCurrentRunner(hooks) {
-    return createCounter(function (index, input, next) {
-      if (index >= middlewares.length) {
-        return input;
-      }
-
-      return runHooks(function () {
-        return next(middlewares[index](input) || input);
-      }, hooks);
-    });
-  };
-
-  var currentContainer = createContainer();
-  var currentHooks = fromContainer(currentContainer);
-  var currentRunner = createCurrentRunner(currentHooks);
+  var pipeline = createPipeline();
 
   var use = function use() {
-    for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
-      input[_key] = arguments[_key];
+    for (var _len = arguments.length, brooks = new Array(_len), _key = 0; _key < _len; _key++) {
+      brooks[_key] = arguments[_key];
     }
 
-    middlewares.push.apply(middlewares, _toConsumableArray(input.map(getBrook)));
+    pipeline.use.apply(pipeline, _toConsumableArray(brooks.map(getBrook).map(mapBrookToMiddleware)));
     return waterfall;
   };
 
   var run = function run(input, options) {
-    var _options$container;
-
-    var container = (_options$container = options === null || options === void 0 ? void 0 : options.container) !== null && _options$container !== void 0 ? _options$container : currentContainer;
-    var hooks = container === currentContainer ? currentHooks : fromContainer(container);
-    var runner = container === currentContainer ? currentRunner : createCurrentRunner(hooks);
-    return runner.start(input);
+    return (// eslint-disable-next-line @typescript-eslint/no-shadow
+      pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
+        onLast: function onLast(input) {
+          return input;
+        }
+      }))
+    );
   };
 
-  var brook = function brook(input) {
+  var middleware = function middleware(input) {
     // eslint-disable-next-line react-hooks/rules-of-hooks
-    var container = useContainer();
-    return run(input, {
-      container: container
+    var container = useContainer(); // eslint-disable-next-line @typescript-eslint/no-shadow
+
+    return pipeline.run(input, {
+      container: container,
+      onLast: function onLast(input) {
+        return input;
+      }
     });
   };
 
-  var waterfall = _defineProperty({
+  var waterfall = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
     use: use,
     run: run,
-    brook: brook
-  }, WATERFALL_SYMBOL, true);
+    middleware: middleware
+  }, WATERFALL_SYMBOL, true));
 
   return waterfall;
 };
 export var isWaterfall = function isWaterfall(input) {
   return Boolean(input === null || input === void 0 ? void 0 : input[WATERFALL_SYMBOL]);
+};
+
+var mapBrookToMiddleware = function mapBrookToMiddleware(brook) {
+  return function (input, next) {
+    return next(brook(input));
+  };
 };

package/dist/js/treeshaking/workflow/async.js

@@ -1,7 +1,17 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
 
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -14,117 +24,108 @@ function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToAr
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-import { createAsyncCounter } from "../counter";
-import { runHooks, fromContainer, createContainer } from "../context";
+import { createAsyncPipeline } from 'farrow-pipeline';
 var ASYNC_WORKFLOW_SYMBOL = Symbol('ASYNC_WORKFLOW_SYMBOL');
 export var isAsyncWorkflow = function isAsyncWorkflow(input) {
   return Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WORKFLOW_SYMBOL]);
 }; // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 
 export var createAsyncWorkflow = function createAsyncWorkflow() {
-  var middlewares = [];
-
-  var createCurrentRunner = function createCurrentRunner(hooks) {
-    return createAsyncCounter( /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(index, input, next) {
-        var middleware;
-        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                if (!(index >= middlewares.length)) {
-                  _context2.next = 2;
-                  break;
-                }
-
-                return _context2.abrupt("return", []);
-
-              case 2:
-                middleware = middlewares[index];
-                return _context2.abrupt("return", runHooks( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-                  var result, rest;
-                  return _regeneratorRuntime.wrap(function _callee$(_context) {
-                    while (1) {
-                      switch (_context.prev = _context.next) {
-                        case 0:
-                          _context.next = 2;
-                          return middleware(input);
-
-                        case 2:
-                          result = _context.sent;
-                          _context.next = 5;
-                          return next(input);
-
-                        case 5:
-                          rest = _context.sent;
-                          return _context.abrupt("return", [result].concat(_toConsumableArray(rest)));
-
-                        case 7:
-                        case "end":
-                          return _context.stop();
-                      }
-                    }
-                  }, _callee);
-                })), hooks));
-
-              case 4:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2);
-      }));
-
-      return function (_x, _x2, _x3) {
-        return _ref.apply(this, arguments);
-      };
-    }());
-  };
-
-  var currentContainer = createContainer();
-  var currentHooks = fromContainer(currentContainer);
-  var currentRunner = createCurrentRunner(currentHooks);
+  var pipeline = createAsyncPipeline();
 
   var use = function use() {
-    middlewares.push.apply(middlewares, arguments);
+    for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
+      input[_key] = arguments[_key];
+    }
+
+    pipeline.use.apply(pipeline, _toConsumableArray(input.map(mapAsyncWorkerToAsyncMiddleware)));
     return workflow;
   };
 
   var run = /*#__PURE__*/function () {
-    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(input, options) {
-      var _options$container;
-
-      var container, hooks, runner;
-      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(input, options) {
+      var result;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) {
-          switch (_context3.prev = _context3.next) {
+          switch (_context.prev = _context.next) {
             case 0:
-              container = (_options$container = options === null || options === void 0 ? void 0 : options.container) !== null && _options$container !== void 0 ? _options$container : currentContainer;
-              hooks = container === currentContainer ? currentHooks : fromContainer(container);
-              runner = container === currentContainer ? currentRunner : createCurrentRunner(hooks);
-              return _context3.abrupt("return", runner.start(input));
+              result = pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
+                onLast: function onLast() {
+                  return [];
+                }
+              }));
+
+              if (!isPromise(result)) {
+                _context.next = 5;
+                break;
+              }
 
-            case 4:
+              return _context.abrupt("return", result.then(function (result) {
+                return result.filter(Boolean);
+              }));
+
+            case 5:
+              return _context.abrupt("return", result.filter(Boolean));
+
+            case 6:
             case "end":
-              return _context3.stop();
+              return _context.stop();
           }
         }
-      }, _callee3);
+      }, _callee);
     }));
 
-    return function run(_x4, _x5) {
-      return _ref3.apply(this, arguments);
+    return function run(_x, _x2) {
+      return _ref.apply(this, arguments);
     };
   }();
 
-  var workflow = _defineProperty({
+  var workflow = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
     use: use,
     run: run
-  }, ASYNC_WORKFLOW_SYMBOL, true);
+  }, ASYNC_WORKFLOW_SYMBOL, true));
 
   return workflow;
-};
+};
+
+var mapAsyncWorkerToAsyncMiddleware = function mapAsyncWorkerToAsyncMiddleware(worker) {
+  return /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(input, next) {
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return worker(input);
+
+            case 2:
+              _context2.t1 = _context2.sent;
+              _context2.t0 = [_context2.t1];
+              _context2.t2 = _toConsumableArray;
+              _context2.next = 7;
+              return next(input);
+
+            case 7:
+              _context2.t3 = _context2.sent;
+              _context2.t4 = (0, _context2.t2)(_context2.t3);
+              return _context2.abrupt("return", _context2.t0.concat.call(_context2.t0, _context2.t4));
+
+            case 10:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function (_x3, _x4) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+};
+
+function isPromise(obj) {
+  /* eslint-disable promise/prefer-await-to-then */
+  return Boolean(obj) && (_typeof(obj) === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
+  /* eslint-enable promise/prefer-await-to-then */
+}