@modern-js/plugin 2.12.0 → 2.13.0

package/dist/esm/index.js

@@ -1,4 +1,743 @@
-export * from "./farrow-pipeline";
-export * from "./waterfall";
-export * from "./workflow";
-export * from "./manager";
+// 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;
+        },
+        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
+    };
+};
+// src/farrow-pipeline/index.ts
+var isPipeline = function(input) {
+    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"));
+};
+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);
+    return pipeline;
+};
+var createAsyncPipeline = function() {
+    var pipeline = createPipeline();
+    return _objectSpread({}, pipeline);
+};
+// src/waterfall/sync.ts
+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 }"));
+};
+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));
+    return waterfall;
+};
+var isWaterfall = function(input) {
+    return Boolean(input === null || input === void 0 ? void 0 : input[WATERFALL_SYMBOL]);
+};
+var mapBrookToMiddleware = function(brook) {
+    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;
+    }
+    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));
+    return waterfall;
+};
+var isAsyncWaterfall = function(input) {
+    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);
+        });
+    };
+};
+// src/workflow/sync.ts
+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));
+    return workflow;
+};
+var isWorkflow = function(input) {
+    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)));
+    };
+};
+// src/workflow/parallel.ts
+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]);
+};
+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));
+    return workflow;
+};
+var mapParallelWorkerToAsyncMiddleware = function(worker) {
+    return function(input, next) {
+        return [
+            worker(input)
+        ].concat(_toConsumableArray(next(input)));
+    };
+};
+// src/workflow/async.ts
+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]);
+};
+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));
+    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];
+        });
+    });
+    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;
+};
+// src/manager/shared.ts
+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."));
+                }
+            });
+        });
+    }
+};
+function sortPlugins(input) {
+    return dagSort(input.slice());
+}
+var includePlugin = function(plugins, input) {
+    return plugins.some(function(plugin) {
+        return plugin.name === input.name;
+    });
+};
+var isObject = function(obj) {
+    return obj !== null && typeof obj === "object";
+};
+var hasOwnProperty = function(obj, prop) {
+    return obj.hasOwnProperty(prop);
+};
+// src/manager/sync.ts
+var SYNC_PLUGIN_SYMBOL = "SYNC_PLUGIN_SYMBOL";
+var DEFAULT_OPTIONS = {
+    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 registerHook = function(extraHooks) {
+        currentHooks = _objectSpread({}, extraHooks, currentHooks);
+    };
+    var isPlugin = function(input) {
+        return isObject(input) && hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
+    };
+    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;
+    };
+    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 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));
+};
+var cloneHooksMap = function(record) {
+    if (!record) {
+        return record;
+    }
+    var result = {};
+    for(var key in record){
+        result[key] = cloneHook(record[key]);
+    }
+    return result;
+};
+// src/manager/async.ts
+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 registerHook = function(extraHooks) {
+        currentHooks = _objectSpread({}, extraHooks, currentHooks);
+    };
+    var isPlugin = function(input) {
+        return isObject(input) && hasOwnProperty(input, ASYNC_PLUGIN_SYMBOL) && input[ASYNC_PLUGIN_SYMBOL] === ASYNC_PLUGIN_SYMBOL;
+    };
+    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;
+    };
+    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 };