@modern-js/plugin 2.14.0 → 2.16.0

package/dist/esm/index.js

@@ -1,743 +1,1229 @@
 // src/farrow-pipeline/context.ts
-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 _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-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 _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-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.");
-}
-function _objectSpread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _defineProperty(target, key, source[key]);
-        });
-    }
-    return target;
-}
-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 _objectSpreadProps(target, source) {
-    source = source != null ? source : {};
-    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 _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
-function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
 var createContext = function(value) {
-    var currentValue = value;
-    return {
-        use: function() {
-            return {
-                get value () {
-                    return currentValue;
-                },
-                set value (v){
-                    currentValue = v;
-                }
-            };
-        },
-        get: function() {
-            return currentValue;
+  var currentValue = value;
+  return {
+    use: function() {
+      return {
+        get value() {
+          return currentValue;
         },
-        set: function(v1) {
-            currentValue = v1;
+        set value(v) {
+          currentValue = v;
         }
-    };
+      };
+    },
+    get: function() {
+      return currentValue;
+    },
+    set: function(v1) {
+      currentValue = v1;
+    }
+  };
 };
+
 // src/farrow-pipeline/counter.ts
 var createCounter = function(callback) {
-    var dispatch = function(index, input) {
-        var next = function() {
-            var nextInput = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : input;
-            return dispatch(index + 1, nextInput);
-        };
-        return callback(index, input, next);
-    };
-    return {
-        start: function(input) {
-            return dispatch(0, input);
-        },
-        dispatch: dispatch
+  var dispatch = function(index, input) {
+    var next = function() {
+      var nextInput = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : input;
+      return dispatch(index + 1, nextInput);
     };
+    return callback(index, input, next);
+  };
+  return {
+    start: function(input) {
+      return dispatch(0, input);
+    },
+    dispatch
+  };
 };
+
 // src/farrow-pipeline/index.ts
+function _array_like_to_array(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 _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _iterable_to_array(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _non_iterable_spread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys8 = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys8 = ownKeys8.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+    ownKeys8.forEach(function(key) {
+      _define_property(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (!o)
+    return;
+  if (typeof o === "string")
+    return _array_like_to_array(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor)
+    n = o.constructor.name;
+  if (n === "Map" || n === "Set")
+    return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _array_like_to_array(o, minLen);
+}
 var isPipeline = function(input) {
-    return Boolean(input === null || input === void 0 ? void 0 : input[PipelineSymbol]);
+  return Boolean(input === null || input === void 0 ? void 0 : input[PipelineSymbol]);
 };
 var PipelineSymbol = Symbol.for("MODERN_PIPELINE");
 var getMiddleware = function(input) {
-    if (typeof input === "function") {
-        return input;
-    } else if (input && typeof input.middleware === "function") {
-        return input.middleware;
-    }
-    throw new Error("".concat(input, " is not a Middleware"));
+  if (typeof input === "function") {
+    return input;
+  } else if (input && typeof input.middleware === "function") {
+    return input.middleware;
+  }
+  throw new Error("".concat(input, " is not a Middleware"));
 };
 var createPipeline = function() {
-    var middlewares = [];
-    var use = function() {
-        for(var _len = arguments.length, inputs = new Array(_len), _key = 0; _key < _len; _key++){
-            inputs[_key] = arguments[_key];
-        }
-        var _middlewares;
-        (_middlewares = middlewares).push.apply(_middlewares, _toConsumableArray(inputs.map(getMiddleware)));
-        return pipeline;
-    };
-    var createCurrentCounter = function(onLast) {
-        return createCounter(function(index, input, next) {
-            if (index >= middlewares.length) {
-                if (onLast) {
-                    return onLast(input);
-                }
-                throw new Error("Expect returning a value, but all middlewares just calling next()");
-            }
-            return middlewares[index](input, next);
-        });
-    };
-    var currentCounter = createCurrentCounter();
-    var getCounter = function(options) {
-        if (!options) {
-            return currentCounter;
-        }
-        return createCurrentCounter(options === null || options === void 0 ? void 0 : options.onLast);
-    };
-    var run = function(input, options) {
-        return getCounter(options).start(input);
-    };
-    var middleware = function(input, next) {
-        return run(input, {
-            onLast: next
-        });
-    };
-    var _obj;
-    var pipeline = (_obj = {}, _defineProperty(_obj, PipelineSymbol, true), _defineProperty(_obj, "use", use), _defineProperty(_obj, "run", run), _defineProperty(_obj, "middleware", middleware), _obj);
+  var middlewares = [];
+  var use = function() {
+    for (var _len = arguments.length, inputs = new Array(_len), _key = 0; _key < _len; _key++) {
+      inputs[_key] = arguments[_key];
+    }
+    var _middlewares;
+    (_middlewares = middlewares).push.apply(_middlewares, _to_consumable_array(inputs.map(getMiddleware)));
     return pipeline;
+  };
+  var createCurrentCounter = function(onLast) {
+    return createCounter(function(index, input, next) {
+      if (index >= middlewares.length) {
+        if (onLast) {
+          return onLast(input);
+        }
+        throw new Error("Expect returning a value, but all middlewares just calling next()");
+      }
+      return middlewares[index](input, next);
+    });
+  };
+  var currentCounter = createCurrentCounter();
+  var getCounter = function(options) {
+    if (!options) {
+      return currentCounter;
+    }
+    return createCurrentCounter(options === null || options === void 0 ? void 0 : options.onLast);
+  };
+  var run = function(input, options) {
+    return getCounter(options).start(input);
+  };
+  var middleware = function(input, next) {
+    return run(input, {
+      onLast: next
+    });
+  };
+  var _obj;
+  var pipeline = (_obj = {}, _define_property(_obj, PipelineSymbol, true), _define_property(_obj, "use", use), _define_property(_obj, "run", run), _define_property(_obj, "middleware", middleware), _obj);
+  return pipeline;
 };
 var createAsyncPipeline = function() {
-    var pipeline = createPipeline();
-    return _objectSpread({}, pipeline);
+  var pipeline = createPipeline();
+  return _object_spread({}, pipeline);
 };
+
 // src/waterfall/sync.ts
+function _array_like_to_array2(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 _array_without_holes2(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array2(arr);
+}
+function _define_property2(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _iterable_to_array2(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _non_iterable_spread2() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys8 = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys8 = ownKeys8.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+    ownKeys8.forEach(function(key) {
+      _define_property2(target, key, source[key]);
+    });
+  }
+  return target;
+}
+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 _object_spread_props(target, source) {
+  source = source != null ? source : {};
+  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 _to_consumable_array2(arr) {
+  return _array_without_holes2(arr) || _iterable_to_array2(arr) || _unsupported_iterable_to_array2(arr) || _non_iterable_spread2();
+}
+function _unsupported_iterable_to_array2(o, minLen) {
+  if (!o)
+    return;
+  if (typeof o === "string")
+    return _array_like_to_array2(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor)
+    n = o.constructor.name;
+  if (n === "Map" || n === "Set")
+    return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _array_like_to_array2(o, minLen);
+}
 var WATERFALL_SYMBOL = Symbol.for("MODERN_WATERFALL");
 var getBrook = function(input) {
-    if (typeof input === "function") {
-        return input;
-    } else if (input && typeof input.middleware === "function") {
-        return input.middleware;
-    }
-    throw new Error("".concat(input, " is not a Brook or { brook: Brook }"));
+  if (typeof input === "function") {
+    return input;
+  } else if (input && typeof input.middleware === "function") {
+    return input.middleware;
+  }
+  throw new Error("".concat(input, " is not a Brook or { brook: Brook }"));
 };
 var createWaterfall = function() {
-    var pipeline = createPipeline();
-    var use = function() {
-        for(var _len = arguments.length, brooks = new Array(_len), _key = 0; _key < _len; _key++){
-            brooks[_key] = arguments[_key];
-        }
-        var _pipeline;
-        (_pipeline = pipeline).use.apply(_pipeline, _toConsumableArray(brooks.map(getBrook).map(mapBrookToMiddleware)));
-        return waterfall;
-    };
-    var run = function(input, options) {
-        return pipeline.run(input, _objectSpreadProps(_objectSpread({}, options), {
-            onLast: function(input2) {
-                return input2;
-            }
-        }));
-    };
-    var middleware = function(input) {
-        return pipeline.run(input, {
-            onLast: function(input2) {
-                return input2;
-            }
-        });
-    };
-    var waterfall = _objectSpreadProps(_objectSpread({}, pipeline), _defineProperty({
-        use: use,
-        run: run,
-        middleware: middleware
-    }, WATERFALL_SYMBOL, true));
+  var pipeline = createPipeline();
+  var use = function() {
+    for (var _len = arguments.length, brooks = new Array(_len), _key = 0; _key < _len; _key++) {
+      brooks[_key] = arguments[_key];
+    }
+    var _pipeline;
+    (_pipeline = pipeline).use.apply(_pipeline, _to_consumable_array2(brooks.map(getBrook).map(mapBrookToMiddleware)));
     return waterfall;
+  };
+  var run = function(input, options) {
+    return pipeline.run(input, _object_spread_props(_object_spread2({}, options), {
+      onLast: function(input2) {
+        return input2;
+      }
+    }));
+  };
+  var middleware = function(input) {
+    return pipeline.run(input, {
+      onLast: function(input2) {
+        return input2;
+      }
+    });
+  };
+  var waterfall = _object_spread_props(_object_spread2({}, pipeline), _define_property2({
+    use,
+    run,
+    middleware
+  }, WATERFALL_SYMBOL, true));
+  return waterfall;
 };
 var isWaterfall = function(input) {
-    return Boolean(input === null || input === void 0 ? void 0 : input[WATERFALL_SYMBOL]);
+  return Boolean(input === null || input === void 0 ? void 0 : input[WATERFALL_SYMBOL]);
 };
 var mapBrookToMiddleware = function(brook) {
-    return function(input, next) {
-        return next(brook(input));
-    };
+  return function(input, next) {
+    return next(brook(input));
+  };
 };
+
 // src/waterfall/async.ts
-var ASYNC_WATERFALL_SYMBOL = Symbol.for("MODERN_ASYNC_WATERFALL");
-var getAsyncBrook = function(input) {
-    if (typeof input === "function") {
-        return input;
+function _array_like_to_array3(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 _array_without_holes3(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array3(arr);
+}
+function _define_property3(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _iterable_to_array3(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _non_iterable_spread3() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread3(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys8 = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys8 = ownKeys8.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
     }
-    if (input && typeof input.middleware === "function") {
-        return input.middleware;
+    ownKeys8.forEach(function(key) {
+      _define_property3(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function ownKeys2(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;
+      });
     }
-    throw new Error("".concat(input, " is not a AsyncBrook or { brook: AsyncBrook }"));
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _object_spread_props2(target, source) {
+  source = source != null ? source : {};
+  if (Object.getOwnPropertyDescriptors) {
+    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+  } else {
+    ownKeys2(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _to_consumable_array3(arr) {
+  return _array_without_holes3(arr) || _iterable_to_array3(arr) || _unsupported_iterable_to_array3(arr) || _non_iterable_spread3();
+}
+function _unsupported_iterable_to_array3(o, minLen) {
+  if (!o)
+    return;
+  if (typeof o === "string")
+    return _array_like_to_array3(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor)
+    n = o.constructor.name;
+  if (n === "Map" || n === "Set")
+    return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _array_like_to_array3(o, minLen);
+}
+var ASYNC_WATERFALL_SYMBOL = Symbol.for("MODERN_ASYNC_WATERFALL");
+var getAsyncBrook = function(input) {
+  if (typeof input === "function") {
+    return input;
+  }
+  if (input && typeof input.middleware === "function") {
+    return input.middleware;
+  }
+  throw new Error("".concat(input, " is not a AsyncBrook or { brook: AsyncBrook }"));
 };
 var createAsyncWaterfall = function() {
-    var pipeline = createAsyncPipeline();
-    var use = function() {
-        for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
-            input[_key] = arguments[_key];
-        }
-        var _pipeline;
-        (_pipeline = pipeline).use.apply(_pipeline, _toConsumableArray(input.map(getAsyncBrook).map(mapAsyncBrookToAsyncMiddleware)));
-        return waterfall;
-    };
-    var run = function(input, options) {
-        return pipeline.run(input, _objectSpreadProps(_objectSpread({}, options), {
-            onLast: function(input2) {
-                return input2;
-            }
-        }));
-    };
-    var middleware = function(input) {
-        return pipeline.run(input, {
-            onLast: function(input2) {
-                return input2;
-            }
-        });
-    };
-    var waterfall = _objectSpreadProps(_objectSpread({}, pipeline), _defineProperty({
-        use: use,
-        run: run,
-        middleware: middleware
-    }, ASYNC_WATERFALL_SYMBOL, true));
+  var pipeline = createAsyncPipeline();
+  var use = function() {
+    for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
+      input[_key] = arguments[_key];
+    }
+    var _pipeline;
+    (_pipeline = pipeline).use.apply(_pipeline, _to_consumable_array3(input.map(getAsyncBrook).map(mapAsyncBrookToAsyncMiddleware)));
     return waterfall;
+  };
+  var run = function(input, options) {
+    return pipeline.run(input, _object_spread_props2(_object_spread3({}, options), {
+      onLast: function(input2) {
+        return input2;
+      }
+    }));
+  };
+  var middleware = function(input) {
+    return pipeline.run(input, {
+      onLast: function(input2) {
+        return input2;
+      }
+    });
+  };
+  var waterfall = _object_spread_props2(_object_spread3({}, pipeline), _define_property3({
+    use,
+    run,
+    middleware
+  }, ASYNC_WATERFALL_SYMBOL, true));
+  return waterfall;
 };
 var isAsyncWaterfall = function(input) {
-    return Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WATERFALL_SYMBOL]);
+  return Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WATERFALL_SYMBOL]);
 };
 var mapAsyncBrookToAsyncMiddleware = function(brook) {
-    return function(input, next) {
-        return Promise.resolve(brook(input)).then(function(result) {
-            return next(result);
-        });
-    };
+  return function(input, next) {
+    return Promise.resolve(brook(input)).then(function(result) {
+      return next(result);
+    });
+  };
 };
+
 // src/workflow/sync.ts
+function _array_like_to_array4(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 _array_without_holes4(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array4(arr);
+}
+function _define_property4(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _iterable_to_array4(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _non_iterable_spread4() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread4(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys8 = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys8 = ownKeys8.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+    ownKeys8.forEach(function(key) {
+      _define_property4(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function ownKeys3(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 _object_spread_props3(target, source) {
+  source = source != null ? source : {};
+  if (Object.getOwnPropertyDescriptors) {
+    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+  } else {
+    ownKeys3(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _to_consumable_array4(arr) {
+  return _array_without_holes4(arr) || _iterable_to_array4(arr) || _unsupported_iterable_to_array4(arr) || _non_iterable_spread4();
+}
+function _unsupported_iterable_to_array4(o, minLen) {
+  if (!o)
+    return;
+  if (typeof o === "string")
+    return _array_like_to_array4(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor)
+    n = o.constructor.name;
+  if (n === "Map" || n === "Set")
+    return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _array_like_to_array4(o, minLen);
+}
 var WORKFLOW_SYMBOL = Symbol.for("MODERN_WORKFLOW");
 var createWorkflow = function() {
-    var pipeline = createPipeline();
-    var use = function() {
-        for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
-            input[_key] = arguments[_key];
-        }
-        var _pipeline;
-        (_pipeline = pipeline).use.apply(_pipeline, _toConsumableArray(input.map(mapWorkerToMiddleware)));
-        return workflow;
-    };
-    var run = function(input) {
-        var result = pipeline.run(input, {
-            onLast: function() {
-                return [];
-            }
-        });
-        return result.filter(Boolean);
-    };
-    var workflow = _objectSpreadProps(_objectSpread({}, pipeline), _defineProperty({
-        use: use,
-        run: run
-    }, WORKFLOW_SYMBOL, true));
+  var pipeline = createPipeline();
+  var use = function() {
+    for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
+      input[_key] = arguments[_key];
+    }
+    var _pipeline;
+    (_pipeline = pipeline).use.apply(_pipeline, _to_consumable_array4(input.map(mapWorkerToMiddleware)));
     return workflow;
+  };
+  var run = function(input) {
+    var result = pipeline.run(input, {
+      onLast: function() {
+        return [];
+      }
+    });
+    return result.filter(Boolean);
+  };
+  var workflow = _object_spread_props3(_object_spread4({}, pipeline), _define_property4({
+    use,
+    run
+  }, WORKFLOW_SYMBOL, true));
+  return workflow;
 };
 var isWorkflow = function(input) {
-    return Boolean(input === null || input === void 0 ? void 0 : input[WORKFLOW_SYMBOL]);
+  return Boolean(input === null || input === void 0 ? void 0 : input[WORKFLOW_SYMBOL]);
 };
 var mapWorkerToMiddleware = function(worker) {
-    return function(input, next) {
-        return [
-            worker(input)
-        ].concat(_toConsumableArray(next(input)));
-    };
+  return function(input, next) {
+    return [
+      worker(input)
+    ].concat(_to_consumable_array4(next(input)));
+  };
 };
+
 // src/workflow/parallel.ts
+function _array_like_to_array5(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 _array_without_holes5(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array5(arr);
+}
+function _define_property5(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _iterable_to_array5(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _non_iterable_spread5() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread5(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys8 = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys8 = ownKeys8.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+    ownKeys8.forEach(function(key) {
+      _define_property5(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function ownKeys4(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 _object_spread_props4(target, source) {
+  source = source != null ? source : {};
+  if (Object.getOwnPropertyDescriptors) {
+    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+  } else {
+    ownKeys4(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _to_consumable_array5(arr) {
+  return _array_without_holes5(arr) || _iterable_to_array5(arr) || _unsupported_iterable_to_array5(arr) || _non_iterable_spread5();
+}
+function _unsupported_iterable_to_array5(o, minLen) {
+  if (!o)
+    return;
+  if (typeof o === "string")
+    return _array_like_to_array5(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor)
+    n = o.constructor.name;
+  if (n === "Map" || n === "Set")
+    return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _array_like_to_array5(o, minLen);
+}
 var PARALLEL_WORKFLOW_SYMBOL = Symbol.for("MODERN_PARALLEL_WORKFLOW");
 var isParallelWorkflow = function(input) {
-    return Boolean(input === null || input === void 0 ? void 0 : input[PARALLEL_WORKFLOW_SYMBOL]);
+  return Boolean(input === null || input === void 0 ? void 0 : input[PARALLEL_WORKFLOW_SYMBOL]);
 };
 var createParallelWorkflow = function() {
-    var pipeline = createPipeline();
-    var use = function() {
-        for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
-            input[_key] = arguments[_key];
-        }
-        var _pipeline;
-        (_pipeline = pipeline).use.apply(_pipeline, _toConsumableArray(input.map(mapParallelWorkerToAsyncMiddleware)));
-        return workflow;
-    };
-    var run = function(input) {
-        return Promise.all(pipeline.run(input, {
-            onLast: function() {
-                return [];
-            }
-        })).then(function(result) {
-            return result.filter(Boolean);
-        });
-    };
-    var workflow = _objectSpreadProps(_objectSpread({}, pipeline), _defineProperty({
-        run: run,
-        use: use
-    }, PARALLEL_WORKFLOW_SYMBOL, true));
+  var pipeline = createPipeline();
+  var use = function() {
+    for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
+      input[_key] = arguments[_key];
+    }
+    var _pipeline;
+    (_pipeline = pipeline).use.apply(_pipeline, _to_consumable_array5(input.map(mapParallelWorkerToAsyncMiddleware)));
     return workflow;
+  };
+  var run = function(input) {
+    return Promise.all(pipeline.run(input, {
+      onLast: function() {
+        return [];
+      }
+    })).then(function(result) {
+      return result.filter(Boolean);
+    });
+  };
+  var workflow = _object_spread_props4(_object_spread5({}, pipeline), _define_property5({
+    run,
+    use
+  }, PARALLEL_WORKFLOW_SYMBOL, true));
+  return workflow;
 };
 var mapParallelWorkerToAsyncMiddleware = function(worker) {
-    return function(input, next) {
-        return [
-            worker(input)
-        ].concat(_toConsumableArray(next(input)));
-    };
+  return function(input, next) {
+    return [
+      worker(input)
+    ].concat(_to_consumable_array5(next(input)));
+  };
 };
+
 // src/workflow/async.ts
+function _array_like_to_array6(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 _array_without_holes6(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array6(arr);
+}
+function _define_property6(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _iterable_to_array6(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _non_iterable_spread6() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread6(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys8 = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys8 = ownKeys8.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+    ownKeys8.forEach(function(key) {
+      _define_property6(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function ownKeys5(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 _object_spread_props5(target, source) {
+  source = source != null ? source : {};
+  if (Object.getOwnPropertyDescriptors) {
+    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+  } else {
+    ownKeys5(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _to_consumable_array6(arr) {
+  return _array_without_holes6(arr) || _iterable_to_array6(arr) || _unsupported_iterable_to_array6(arr) || _non_iterable_spread6();
+}
+function _unsupported_iterable_to_array6(o, minLen) {
+  if (!o)
+    return;
+  if (typeof o === "string")
+    return _array_like_to_array6(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor)
+    n = o.constructor.name;
+  if (n === "Map" || n === "Set")
+    return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _array_like_to_array6(o, minLen);
+}
 var ASYNC_WORKFLOW_SYMBOL = Symbol.for("MODERN_ASYNC_WORKFLOW");
 var isAsyncWorkflow = function(input) {
-    return Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WORKFLOW_SYMBOL]);
+  return Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WORKFLOW_SYMBOL]);
 };
 var createAsyncWorkflow = function() {
-    var pipeline = createAsyncPipeline();
-    var use = function() {
-        for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
-            input[_key] = arguments[_key];
-        }
-        var _pipeline;
-        (_pipeline = pipeline).use.apply(_pipeline, _toConsumableArray(input.map(mapAsyncWorkerToAsyncMiddleware)));
-        return workflow;
-    };
-    var run = function(input) {
-        var result = pipeline.run(input, {
-            onLast: function() {
-                return [];
-            }
-        });
-        if (isPromise(result)) {
-            return result.then(function(result2) {
-                return result2.filter(Boolean);
-            });
-        }
-        return result.filter(Boolean);
-    };
-    var workflow = _objectSpreadProps(_objectSpread({}, pipeline), _defineProperty({
-        use: use,
-        run: run
-    }, ASYNC_WORKFLOW_SYMBOL, true));
+  var pipeline = createAsyncPipeline();
+  var use = function() {
+    for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
+      input[_key] = arguments[_key];
+    }
+    var _pipeline;
+    (_pipeline = pipeline).use.apply(_pipeline, _to_consumable_array6(input.map(mapAsyncWorkerToAsyncMiddleware)));
     return workflow;
+  };
+  var run = function(input) {
+    var result = pipeline.run(input, {
+      onLast: function() {
+        return [];
+      }
+    });
+    if (isPromise(result)) {
+      return result.then(function(result2) {
+        return result2.filter(Boolean);
+      });
+    }
+    return result.filter(Boolean);
+  };
+  var workflow = _object_spread_props5(_object_spread6({}, pipeline), _define_property6({
+    use,
+    run
+  }, ASYNC_WORKFLOW_SYMBOL, true));
+  return workflow;
 };
 var mapAsyncWorkerToAsyncMiddleware = function(worker) {
-    return function(input, next) {
-        return Promise.resolve(worker(input)).then(function(result) {
-            return Promise.resolve(next(input)).then(function(nextResult) {
-                return [
-                    result
-                ].concat(_toConsumableArray(nextResult));
-            });
-        });
-    };
-};
-function isPromise(obj) {
-    return obj && typeof obj.then === "function";
-}
-// src/utils/pluginDagSort.ts
-var dagSort = function(plugins) {
-    var _loop = function() {
-        var zep = zeroEndPoints.shift();
-        sortedPoint.push(getPluginByAny(zep));
-        allLines = allLines.filter(function(l) {
-            return l[0] !== getPluginByAny(zep)[key];
-        });
-        var restPoints = plugins.filter(function(item) {
-            return !sortedPoint.find(function(sp) {
-                return sp[key] === item[key];
-            });
-        });
-        zeroEndPoints = restPoints.filter(// eslint-disable-next-line @typescript-eslint/no-loop-func
-        function(item) {
-            return !allLines.find(function(l) {
-                return l[1] === item[key];
-            });
-        });
-    };
-    var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "name", preKey = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "pre", postKey = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "post";
-    var getPluginByAny = function getPluginByAny(q) {
-        var target = plugins.find(function(item) {
-            return typeof q === "string" ? item[key] === q : item[key] === q[key];
-        });
-        if (!target) {
-            throw new Error("plugin ".concat(q, " not existed"));
-        }
-        return target;
-    };
-    var allLines = [];
-    plugins.forEach(function(item) {
-        item[preKey].forEach(function(p) {
-            if (plugins.find(function(ap) {
-                return ap.name === p;
-            })) {
-                allLines.push([
-                    getPluginByAny(p)[key],
-                    getPluginByAny(item)[key]
-                ]);
-            }
-        });
-        item[postKey].forEach(function(pt) {
-            if (plugins.find(function(ap) {
-                return ap.name === pt;
-            })) {
-                allLines.push([
-                    getPluginByAny(item)[key],
-                    getPluginByAny(pt)[key]
-                ]);
-            }
-        });
-    });
-    var zeroEndPoints = plugins.filter(function(item) {
-        return !allLines.find(function(l) {
-            return l[1] === item[key];
-        });
+  return function(input, next) {
+    return Promise.resolve(worker(input)).then(function(result) {
+      return Promise.resolve(next(input)).then(function(nextResult) {
+        return [
+          result
+        ].concat(_to_consumable_array6(nextResult));
+      });
     });
-    var sortedPoint = [];
-    while(zeroEndPoints.length)_loop();
-    if (allLines.length) {
-        var restInRingPoints = {};
-        allLines.forEach(function(l) {
-            restInRingPoints[l[0]] = true;
-            restInRingPoints[l[1]] = true;
-        });
-        throw new Error("plugins dependences has loop: ".concat(Object.keys(restInRingPoints).join(",")));
-    }
-    return sortedPoint;
+  };
 };
+function isPromise(obj) {
+  return obj && typeof obj.then === "function";
+}
+
 // src/manager/shared.ts
+import { pluginDagSort } from "@modern-js/utils/universal/pluginDagSort";
 var checkPlugins = function(plugins) {
-    if (process.env.NODE_ENV !== "production") {
-        plugins.forEach(function(origin) {
-            origin.rivals.forEach(function(rival) {
-                plugins.forEach(function(plugin) {
-                    if (rival === plugin.name) {
-                        throw new Error("".concat(origin.name, " has rival ").concat(plugin.name));
-                    }
-                });
-            });
-            origin.required.forEach(function(required) {
-                if (!plugins.some(function(plugin) {
-                    return plugin.name === required;
-                })) {
-                    throw new Error("The plugin: ".concat(required, " is required when plugin: ").concat(origin.name, " is exist."));
-                }
-            });
+  if (process.env.NODE_ENV !== "production") {
+    plugins.forEach(function(origin) {
+      origin.rivals.forEach(function(rival) {
+        plugins.forEach(function(plugin) {
+          if (rival === plugin.name) {
+            throw new Error("".concat(origin.name, " has rival ").concat(plugin.name));
+          }
         });
-    }
+      });
+      origin.required.forEach(function(required) {
+        if (!plugins.some(function(plugin) {
+          return plugin.name === required;
+        })) {
+          throw new Error("The plugin: ".concat(required, " is required when plugin: ").concat(origin.name, " is exist."));
+        }
+      });
+    });
+  }
 };
 function sortPlugins(input) {
-    return dagSort(input.slice());
+  return pluginDagSort(input.slice());
 }
 var includePlugin = function(plugins, input) {
-    return plugins.some(function(plugin) {
-        return plugin.name === input.name;
-    });
+  return plugins.some(function(plugin) {
+    return plugin.name === input.name;
+  });
 };
 var isObject = function(obj) {
-    return obj !== null && typeof obj === "object";
+  return obj !== null && typeof obj === "object";
 };
 var hasOwnProperty = function(obj, prop) {
-    return obj.hasOwnProperty(prop);
+  return obj.hasOwnProperty(prop);
 };
+
 // src/manager/sync.ts
+function _define_property7(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _object_spread7(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys8 = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys8 = ownKeys8.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+    ownKeys8.forEach(function(key) {
+      _define_property7(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function ownKeys6(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 _object_spread_props6(target, source) {
+  source = source != null ? source : {};
+  if (Object.getOwnPropertyDescriptors) {
+    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+  } else {
+    ownKeys6(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
 var SYNC_PLUGIN_SYMBOL = "SYNC_PLUGIN_SYMBOL";
 var DEFAULT_OPTIONS = {
-    name: "untitled",
-    pre: [],
-    post: [],
-    rivals: [],
-    required: [],
-    usePlugins: [],
-    registerHook: {}
+  name: "untitled",
+  pre: [],
+  post: [],
+  rivals: [],
+  required: [],
+  usePlugins: [],
+  registerHook: {}
 };
 var createManager = function(hooks, api) {
-    var index = 0;
-    var runners;
-    var currentHooks = _objectSpread({}, hooks);
-    var useRunner = function() {
-        return runners;
+  var index = 0;
+  var runners;
+  var currentHooks = _object_spread7({}, hooks);
+  var useRunner = function() {
+    return runners;
+  };
+  var registerHook = function(extraHooks) {
+    currentHooks = _object_spread7({}, extraHooks, currentHooks);
+  };
+  var isPlugin = function(input) {
+    return isObject(input) && hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
+  };
+  var pluginAPI = _object_spread_props6(_object_spread7({}, api), {
+    useHookRunners: useRunner
+  });
+  var clone = function(overrideAPI) {
+    var plugins = [];
+    var addPlugin = function(plugin) {
+      if (!includePlugin(plugins, plugin)) {
+        plugins.push(_object_spread7({}, plugin));
+      }
+    };
+    var usePlugin = function() {
+      for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
+        input[_key] = arguments[_key];
+      }
+      input.forEach(function(plugin) {
+        if (isPlugin(plugin)) {
+          addPlugin(plugin);
+        } else if (typeof plugin === "function") {
+          var options = plugin();
+          addPlugin(createPlugin(options.setup, options));
+        } else if (isObject(plugin)) {
+          addPlugin(createPlugin(plugin.setup, plugin));
+        } else if (process.env.NODE_ENV !== "production") {
+          console.warn("Unknown plugin: ".concat(JSON.stringify(plugin)));
+        }
+      });
+      return manager;
+    };
+    var createPlugin = function() {
+      var setup = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function() {
+      }, options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      var _options_usePlugins;
+      if ((_options_usePlugins = options.usePlugins) === null || _options_usePlugins === void 0 ? void 0 : _options_usePlugins.length) {
+        options.usePlugins.forEach(function(plugin) {
+          usePlugin(createPlugin(plugin.setup, plugin));
+        });
+      }
+      if (options.registerHook) {
+        registerHook(options.registerHook);
+      }
+      return _object_spread_props6(_object_spread7(_object_spread_props6(_object_spread7({}, DEFAULT_OPTIONS), {
+        name: "No.".concat(index++, " plugin")
+      }), options), {
+        SYNC_PLUGIN_SYMBOL,
+        setup
+      });
     };
-    var registerHook = function(extraHooks) {
-        currentHooks = _objectSpread({}, extraHooks, currentHooks);
+    var clear = function() {
+      plugins = [];
     };
-    var isPlugin = function(input) {
-        return isObject(input) && hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
+    var init = function() {
+      var sortedPlugins = sortPlugins(plugins);
+      var mergedPluginAPI = _object_spread7({}, pluginAPI, overrideAPI);
+      checkPlugins(sortedPlugins);
+      var hooksList = sortedPlugins.map(function(plugin) {
+        return plugin.setup(mergedPluginAPI);
+      });
+      runners = generateRunner(hooksList, currentHooks);
+      return runners;
     };
-    var pluginAPI = _objectSpreadProps(_objectSpread({}, api), {
-        useHookRunners: useRunner
-    });
-    var clone = function(overrideAPI) {
-        var plugins = [];
-        var addPlugin = function(plugin) {
-            if (!includePlugin(plugins, plugin)) {
-                plugins.push(_objectSpread({}, plugin));
-            }
-        };
-        var usePlugin = function() {
-            for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
-                input[_key] = arguments[_key];
-            }
-            input.forEach(function(plugin) {
-                if (isPlugin(plugin)) {
-                    addPlugin(plugin);
-                } else if (typeof plugin === "function") {
-                    var options = plugin();
-                    addPlugin(createPlugin(options.setup, options));
-                } else if (isObject(plugin)) {
-                    addPlugin(createPlugin(plugin.setup, plugin));
-                } else if (process.env.NODE_ENV !== "production") {
-                    console.warn("Unknown plugin: ".concat(JSON.stringify(plugin)));
-                }
-            });
-            return manager;
-        };
-        var createPlugin = function() {
-            var setup = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function() {}, options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-            var _options_usePlugins;
-            if ((_options_usePlugins = options.usePlugins) === null || _options_usePlugins === void 0 ? void 0 : _options_usePlugins.length) {
-                options.usePlugins.forEach(function(plugin) {
-                    usePlugin(createPlugin(plugin.setup, plugin));
-                });
-            }
-            if (options.registerHook) {
-                registerHook(options.registerHook);
-            }
-            return _objectSpreadProps(_objectSpread(_objectSpreadProps(_objectSpread({}, DEFAULT_OPTIONS), {
-                name: "No.".concat(index++, " plugin")
-            }), options), {
-                SYNC_PLUGIN_SYMBOL: SYNC_PLUGIN_SYMBOL,
-                setup: setup
-            });
-        };
-        var clear = function() {
-            plugins = [];
-        };
-        var init = function() {
-            var sortedPlugins = sortPlugins(plugins);
-            var mergedPluginAPI = _objectSpread({}, pluginAPI, overrideAPI);
-            checkPlugins(sortedPlugins);
-            var hooksList = sortedPlugins.map(function(plugin) {
-                return plugin.setup(mergedPluginAPI);
-            });
-            runners = generateRunner(hooksList, currentHooks);
-            return runners;
-        };
-        var run = function(cb) {
-            return cb();
-        };
-        var manager = {
-            createPlugin: createPlugin,
-            isPlugin: isPlugin,
-            usePlugin: usePlugin,
-            init: init,
-            clear: clear,
-            run: run,
-            registerHook: registerHook,
-            useRunner: useRunner,
-            clone: clone
-        };
-        return manager;
+    var run = function(cb) {
+      return cb();
     };
-    return clone();
+    var manager = {
+      createPlugin,
+      isPlugin,
+      usePlugin,
+      init,
+      clear,
+      run,
+      registerHook,
+      useRunner,
+      clone
+    };
+    return manager;
+  };
+  return clone();
 };
 var generateRunner = function(hooksList, hooksMap) {
-    var runner = {};
-    var cloneShape = cloneHooksMap(hooksMap);
-    if (hooksMap) {
-        var _loop = function(key) {
-            hooksList.forEach(function(hooks) {
-                if (hooks === null || hooks === void 0 ? void 0 : hooks[key]) {
-                    cloneShape[key].use(hooks[key]);
-                }
-            });
-            runner[key] = function(input, options) {
-                return cloneShape[key].run(input, _objectSpread({}, options));
-            };
-        };
-        for(var key in cloneShape)_loop(key);
-    }
-    return runner;
+  var runner = {};
+  var cloneShape = cloneHooksMap(hooksMap);
+  if (hooksMap) {
+    var _loop = function(key2) {
+      hooksList.forEach(function(hooks) {
+        if (hooks === null || hooks === void 0 ? void 0 : hooks[key2]) {
+          cloneShape[key2].use(hooks[key2]);
+        }
+      });
+      runner[key2] = function(input, options) {
+        return cloneShape[key2].run(input, _object_spread7({}, options));
+      };
+    };
+    for (var key in cloneShape)
+      _loop(key);
+  }
+  return runner;
 };
 var cloneHook = function(hook) {
-    if (isWaterfall(hook)) {
-        return createWaterfall();
-    }
-    if (isAsyncWaterfall(hook)) {
-        return createAsyncWaterfall();
-    }
-    if (isWorkflow(hook)) {
-        return createWorkflow();
-    }
-    if (isAsyncWorkflow(hook)) {
-        return createAsyncWorkflow();
-    }
-    if (isParallelWorkflow(hook)) {
-        return createParallelWorkflow();
-    }
-    if (isPipeline(hook)) {
-        return createPipeline();
-    }
-    throw new Error("Unknown hook: ".concat(hook));
+  if (isWaterfall(hook)) {
+    return createWaterfall();
+  }
+  if (isAsyncWaterfall(hook)) {
+    return createAsyncWaterfall();
+  }
+  if (isWorkflow(hook)) {
+    return createWorkflow();
+  }
+  if (isAsyncWorkflow(hook)) {
+    return createAsyncWorkflow();
+  }
+  if (isParallelWorkflow(hook)) {
+    return createParallelWorkflow();
+  }
+  if (isPipeline(hook)) {
+    return createPipeline();
+  }
+  throw new Error("Unknown hook: ".concat(hook));
 };
 var cloneHooksMap = function(record) {
-    if (!record) {
-        return record;
-    }
-    var result = {};
-    for(var key in record){
-        result[key] = cloneHook(record[key]);
-    }
-    return result;
+  if (!record) {
+    return record;
+  }
+  var result = {};
+  for (var key in record) {
+    result[key] = cloneHook(record[key]);
+  }
+  return result;
 };
+
 // src/manager/async.ts
+function _define_property8(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _object_spread8(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys8 = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys8 = ownKeys8.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+    ownKeys8.forEach(function(key) {
+      _define_property8(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function ownKeys7(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 _object_spread_props7(target, source) {
+  source = source != null ? source : {};
+  if (Object.getOwnPropertyDescriptors) {
+    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+  } else {
+    ownKeys7(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
 var ASYNC_PLUGIN_SYMBOL = "ASYNC_PLUGIN_SYMBOL";
 var createAsyncManager = function(hooks, api) {
-    var index = 0;
-    var runners;
-    var currentHooks = _objectSpread({}, hooks);
-    var useRunner = function() {
-        return runners;
+  var index = 0;
+  var runners;
+  var currentHooks = _object_spread8({}, hooks);
+  var useRunner = function() {
+    return runners;
+  };
+  var registerHook = function(extraHooks) {
+    currentHooks = _object_spread8({}, extraHooks, currentHooks);
+  };
+  var isPlugin = function(input) {
+    return isObject(input) && hasOwnProperty(input, ASYNC_PLUGIN_SYMBOL) && input[ASYNC_PLUGIN_SYMBOL] === ASYNC_PLUGIN_SYMBOL;
+  };
+  var pluginAPI = _object_spread_props7(_object_spread8({}, api), {
+    useHookRunners: useRunner
+  });
+  var clone = function(overrideAPI) {
+    var plugins = [];
+    var addPlugin = function(plugin) {
+      if (!includePlugin(plugins, plugin)) {
+        plugins.push(_object_spread8({}, plugin));
+      }
     };
-    var registerHook = function(extraHooks) {
-        currentHooks = _objectSpread({}, extraHooks, currentHooks);
+    var usePlugin = function() {
+      for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
+        input[_key] = arguments[_key];
+      }
+      input.forEach(function(plugin) {
+        if (isPlugin(plugin)) {
+          addPlugin(plugin);
+        } else if (typeof plugin === "function") {
+          var options = plugin();
+          addPlugin(createPlugin(options.setup, options));
+        } else if (isObject(plugin)) {
+          addPlugin(createPlugin(plugin.setup, plugin));
+        } else if (process.env.NODE_ENV !== "production") {
+          console.warn("Unknown plugin: ".concat(JSON.stringify(plugin)));
+        }
+      });
+      return manager;
+    };
+    var createPlugin = function() {
+      var setup = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function() {
+      }, options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      var _options_usePlugins;
+      if ((_options_usePlugins = options.usePlugins) === null || _options_usePlugins === void 0 ? void 0 : _options_usePlugins.length) {
+        options.usePlugins.forEach(function(plugin) {
+          usePlugin(createPlugin(plugin.setup, plugin));
+        });
+      }
+      if (options.registerHook) {
+        registerHook(options.registerHook);
+      }
+      return _object_spread_props7(_object_spread8(_object_spread_props7(_object_spread8({}, DEFAULT_OPTIONS), {
+        name: "No.".concat(index++, " plugin")
+      }), options), {
+        ASYNC_PLUGIN_SYMBOL,
+        setup
+      });
     };
-    var isPlugin = function(input) {
-        return isObject(input) && hasOwnProperty(input, ASYNC_PLUGIN_SYMBOL) && input[ASYNC_PLUGIN_SYMBOL] === ASYNC_PLUGIN_SYMBOL;
+    var clear = function() {
+      plugins = [];
     };
-    var pluginAPI = _objectSpreadProps(_objectSpread({}, api), {
-        useHookRunners: useRunner
-    });
-    var clone = function(overrideAPI) {
-        var plugins = [];
-        var addPlugin = function(plugin) {
-            if (!includePlugin(plugins, plugin)) {
-                plugins.push(_objectSpread({}, plugin));
-            }
-        };
-        var usePlugin = function() {
-            for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
-                input[_key] = arguments[_key];
-            }
-            input.forEach(function(plugin) {
-                if (isPlugin(plugin)) {
-                    addPlugin(plugin);
-                } else if (typeof plugin === "function") {
-                    var options = plugin();
-                    addPlugin(createPlugin(options.setup, options));
-                } else if (isObject(plugin)) {
-                    addPlugin(createPlugin(plugin.setup, plugin));
-                } else if (process.env.NODE_ENV !== "production") {
-                    console.warn("Unknown plugin: ".concat(JSON.stringify(plugin)));
-                }
-            });
-            return manager;
-        };
-        var createPlugin = function() {
-            var setup = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function() {}, options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-            var _options_usePlugins;
-            if ((_options_usePlugins = options.usePlugins) === null || _options_usePlugins === void 0 ? void 0 : _options_usePlugins.length) {
-                options.usePlugins.forEach(function(plugin) {
-                    usePlugin(createPlugin(plugin.setup, plugin));
-                });
-            }
-            if (options.registerHook) {
-                registerHook(options.registerHook);
-            }
-            return _objectSpreadProps(_objectSpread(_objectSpreadProps(_objectSpread({}, DEFAULT_OPTIONS), {
-                name: "No.".concat(index++, " plugin")
-            }), options), {
-                ASYNC_PLUGIN_SYMBOL: ASYNC_PLUGIN_SYMBOL,
-                setup: setup
-            });
-        };
-        var clear = function() {
-            plugins = [];
-        };
-        var init = function() {
-            var sortedPlugins = sortPlugins(plugins);
-            var mergedPluginAPI = _objectSpread({}, pluginAPI, overrideAPI);
-            checkPlugins(sortedPlugins);
-            return Promise.all(sortedPlugins.map(function(plugin) {
-                return plugin.setup(mergedPluginAPI);
-            })).then(function(hooksList) {
-                runners = generateRunner(hooksList, currentHooks);
-                return runners;
-            });
-        };
-        var run = function(cb) {
-            return cb();
-        };
-        var manager = {
-            createPlugin: createPlugin,
-            isPlugin: isPlugin,
-            usePlugin: usePlugin,
-            init: init,
-            run: run,
-            clear: clear,
-            clone: clone,
-            registerHook: registerHook,
-            useRunner: useRunner
-        };
-        return manager;
+    var init = function() {
+      var sortedPlugins = sortPlugins(plugins);
+      var mergedPluginAPI = _object_spread8({}, pluginAPI, overrideAPI);
+      checkPlugins(sortedPlugins);
+      return Promise.all(sortedPlugins.map(function(plugin) {
+        return plugin.setup(mergedPluginAPI);
+      })).then(function(hooksList) {
+        runners = generateRunner(hooksList, currentHooks);
+        return runners;
+      });
     };
-    return clone();
+    var run = function(cb) {
+      return cb();
+    };
+    var manager = {
+      createPlugin,
+      isPlugin,
+      usePlugin,
+      init,
+      run,
+      clear,
+      clone,
+      registerHook,
+      useRunner
+    };
+    return manager;
+  };
+  return clone();
+};
+export {
+  DEFAULT_OPTIONS,
+  cloneHook,
+  cloneHooksMap,
+  createAsyncManager,
+  createAsyncPipeline,
+  createAsyncWaterfall,
+  createAsyncWorkflow,
+  createContext,
+  createManager,
+  createParallelWorkflow,
+  createPipeline,
+  createWaterfall,
+  createWorkflow,
+  generateRunner,
+  getAsyncBrook,
+  getBrook,
+  isAsyncWaterfall,
+  isAsyncWorkflow,
+  isParallelWorkflow,
+  isPipeline,
+  isWaterfall,
+  isWorkflow
 };
-export { DEFAULT_OPTIONS, cloneHook, cloneHooksMap, createAsyncManager, createAsyncPipeline, createAsyncWaterfall, createAsyncWorkflow, createContext, createManager, createParallelWorkflow, createPipeline, createWaterfall, createWorkflow, generateRunner, getAsyncBrook, getBrook, isAsyncWaterfall, isAsyncWorkflow, isParallelWorkflow, isPipeline, isWaterfall, isWorkflow };