@modern-js/plugin 1.21.2-beta.1 → 1.21.2

package/dist/js/node/manager/sync.js

@@ -0,0 +1,212 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateRunner = exports.createManager = exports.cloneHooksMap = exports.cloneHook = exports.DEFAULT_OPTIONS = void 0;
+
+var _farrowPipeline = require("../farrow-pipeline");
+
+var _waterfall = require("../waterfall");
+
+var _workflow = require("../workflow");
+
+var _shared = require("./shared");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const SYNC_PLUGIN_SYMBOL = 'SYNC_PLUGIN_SYMBOL';
+const DEFAULT_OPTIONS = {
+  name: 'untitled',
+  pre: [],
+  post: [],
+  rivals: [],
+  required: [],
+  usePlugins: [],
+  registerHook: {}
+};
+exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+
+const createManager = (hooks, api) => {
+  let index = 0;
+  let runners;
+
+  let currentHooks = _objectSpread({}, hooks);
+
+  const useRunner = () => runners;
+
+  const registerHook = extraHooks => {
+    currentHooks = _objectSpread(_objectSpread({}, extraHooks), currentHooks);
+  };
+
+  const isPlugin = input => (0, _shared.isObject)(input) && (0, _shared.hasOwnProperty)(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
+
+  const pluginAPI = _objectSpread(_objectSpread({}, api), {}, {
+    useHookRunners: useRunner
+  });
+
+  const clone = overrideAPI => {
+    let plugins = [];
+
+    const addPlugin = plugin => {
+      if (!(0, _shared.includePlugin)(plugins, plugin)) {
+        plugins.push(_objectSpread({}, plugin));
+      }
+    };
+
+    const usePlugin = (...input) => {
+      input.forEach(plugin => {
+        // already created by createPlugin
+        if (isPlugin(plugin)) {
+          addPlugin(plugin);
+        } // using function to return plugin options
+        else if (typeof plugin === 'function') {
+          const options = plugin();
+          addPlugin(createPlugin(options.setup, options));
+        } // plain plugin object
+        else if ((0, _shared.isObject)(plugin)) {
+          addPlugin(createPlugin(plugin.setup, plugin));
+        } // unknown plugin
+        else {
+          console.warn(`Unknown plugin: ${JSON.stringify(plugin)}`);
+        }
+      });
+      return manager;
+    };
+
+    const createPlugin = ( // eslint-disable-next-line @typescript-eslint/no-empty-function
+    setup = () => {}, options = {}) => {
+      var _options$usePlugins;
+
+      if ((_options$usePlugins = options.usePlugins) !== null && _options$usePlugins !== void 0 && _options$usePlugins.length) {
+        options.usePlugins.forEach(plugin => {
+          usePlugin(createPlugin(plugin.setup, plugin));
+        });
+      }
+
+      if (options.registerHook) {
+        registerHook(options.registerHook);
+      }
+
+      return _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_OPTIONS), {}, {
+        name: `No.${index++} plugin`
+      }, options), {}, {
+        SYNC_PLUGIN_SYMBOL,
+        setup
+      });
+    };
+
+    const clear = () => {
+      plugins = [];
+    };
+
+    const init = () => {
+      const sortedPlugins = (0, _shared.sortPlugins)(plugins);
+
+      const mergedPluginAPI = _objectSpread(_objectSpread({}, pluginAPI), overrideAPI);
+
+      (0, _shared.checkPlugins)(sortedPlugins);
+      const hooksList = sortedPlugins.map(plugin => plugin.setup(mergedPluginAPI));
+      runners = generateRunner(hooksList, currentHooks);
+      return runners;
+    };
+
+    const run = cb => cb();
+
+    const manager = {
+      createPlugin,
+      isPlugin,
+      usePlugin,
+      init,
+      clear,
+      run,
+      registerHook,
+      useRunner,
+      clone
+    };
+    return manager;
+  };
+
+  return clone();
+};
+
+exports.createManager = createManager;
+
+const generateRunner = (hooksList, hooksMap) => {
+  const runner = {};
+  const cloneShape = cloneHooksMap(hooksMap);
+
+  if (hooksMap) {
+    for (const key in cloneShape) {
+      for (const hooks of hooksList) {
+        if (!hooks) {
+          continue;
+        }
+
+        if (hooks[key]) {
+          cloneShape[key].use(hooks[key]);
+        }
+      } // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error
+
+
+      runner[key] = (input, options) => cloneShape[key].run(input, _objectSpread({}, options));
+    }
+  }
+
+  return runner;
+};
+
+exports.generateRunner = generateRunner;
+
+const cloneHook = hook => {
+  if ((0, _waterfall.isWaterfall)(hook)) {
+    return (0, _waterfall.createWaterfall)();
+  }
+
+  if ((0, _waterfall.isAsyncWaterfall)(hook)) {
+    return (0, _waterfall.createAsyncWaterfall)();
+  }
+
+  if ((0, _workflow.isWorkflow)(hook)) {
+    return (0, _workflow.createWorkflow)();
+  }
+
+  if ((0, _workflow.isAsyncWorkflow)(hook)) {
+    return (0, _workflow.createAsyncWorkflow)();
+  }
+
+  if ((0, _workflow.isParallelWorkflow)(hook)) {
+    return (0, _workflow.createParallelWorkflow)();
+  }
+
+  if ((0, _farrowPipeline.isPipeline)(hook)) {
+    return (0, _farrowPipeline.createPipeline)();
+  }
+
+  throw new Error(`Unknown hook: ${hook}`);
+};
+
+exports.cloneHook = cloneHook;
+
+const cloneHooksMap = record => {
+  if (!record) {
+    return record;
+  }
+
+  const result = {};
+
+  for (const key in record) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    result[key] = cloneHook(record[key]);
+  }
+
+  return result;
+};
+
+exports.cloneHooksMap = cloneHooksMap;

package/dist/js/node/waterfall/async.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isAsyncWaterfall = exports.getAsyncBrook = exports.createAsyncWaterfall = void 0;
+
+var _farrowPipeline = require("../farrow-pipeline");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const ASYNC_WATERFALL_SYMBOL = Symbol.for('MODERN_ASYNC_WATERFALL');
+
+const getAsyncBrook = input => {
+  if (typeof input === 'function') {
+    return input;
+  } else if (input && typeof input.middleware === 'function') {
+    return input.middleware;
+  }
+
+  throw new Error(`${input} is not a AsyncBrook or { brook: AsyncBrook }`);
+};
+
+exports.getAsyncBrook = getAsyncBrook;
+
+const createAsyncWaterfall = () => {
+  const pipeline = (0, _farrowPipeline.createAsyncPipeline)();
+
+  const use = (...input) => {
+    pipeline.use(...input.map(getAsyncBrook).map(mapAsyncBrookToAsyncMiddleware));
+    return waterfall;
+  };
+
+  const run = (input, options) => pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
+    onLast: input => input
+  }));
+
+  const middleware = input => {
+    return pipeline.run(input, {
+      onLast: input => input
+    });
+  };
+
+  const waterfall = _objectSpread(_objectSpread({}, pipeline), {}, {
+    use,
+    run,
+    middleware,
+    [ASYNC_WATERFALL_SYMBOL]: true
+  });
+
+  return waterfall;
+};
+
+exports.createAsyncWaterfall = createAsyncWaterfall;
+
+const isAsyncWaterfall = input => Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WATERFALL_SYMBOL]);
+
+exports.isAsyncWaterfall = isAsyncWaterfall;
+
+const mapAsyncBrookToAsyncMiddleware = brook => async (input, next) => next(await brook(input));

package/dist/js/node/waterfall/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _sync = require("./sync");
+
+Object.keys(_sync).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _sync[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _sync[key];
+    }
+  });
+});
+
+var _async = require("./async");
+
+Object.keys(_async).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _async[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _async[key];
+    }
+  });
+});

package/dist/js/node/waterfall/sync.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isWaterfall = exports.getBrook = exports.createWaterfall = void 0;
+
+var _farrowPipeline = require("../farrow-pipeline");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const WATERFALL_SYMBOL = Symbol.for('MODERN_WATERFALL');
+
+const getBrook = input => {
+  if (typeof input === 'function') {
+    return input;
+  } else if (input && typeof input.middleware === 'function') {
+    return input.middleware;
+  }
+
+  throw new Error(`${input} is not a Brook or { brook: Brook }`);
+};
+
+exports.getBrook = getBrook;
+
+const createWaterfall = () => {
+  const pipeline = (0, _farrowPipeline.createPipeline)();
+
+  const use = (...brooks) => {
+    pipeline.use(...brooks.map(getBrook).map(mapBrookToMiddleware));
+    return waterfall;
+  };
+
+  const run = (input, options) => pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
+    onLast: input => input
+  }));
+
+  const middleware = input => {
+    return pipeline.run(input, {
+      onLast: input => input
+    });
+  };
+
+  const waterfall = _objectSpread(_objectSpread({}, pipeline), {}, {
+    use,
+    run,
+    middleware,
+    [WATERFALL_SYMBOL]: true
+  });
+
+  return waterfall;
+};
+
+exports.createWaterfall = createWaterfall;
+
+const isWaterfall = input => Boolean(input === null || input === void 0 ? void 0 : input[WATERFALL_SYMBOL]);
+
+exports.isWaterfall = isWaterfall;
+
+const mapBrookToMiddleware = brook => (input, next) => next(brook(input));

package/dist/js/node/workflow/async.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isAsyncWorkflow = exports.createAsyncWorkflow = void 0;
+
+var _farrowPipeline = require("../farrow-pipeline");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const ASYNC_WORKFLOW_SYMBOL = Symbol.for('MODERN_ASYNC_WORKFLOW');
+
+const isAsyncWorkflow = input => Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WORKFLOW_SYMBOL]);
+
+exports.isAsyncWorkflow = isAsyncWorkflow;
+
+const createAsyncWorkflow = () => {
+  const pipeline = (0, _farrowPipeline.createAsyncPipeline)();
+
+  const use = (...input) => {
+    pipeline.use(...input.map(mapAsyncWorkerToAsyncMiddleware));
+    return workflow;
+  };
+
+  const run = async input => {
+    const result = pipeline.run(input, {
+      onLast: () => []
+    });
+
+    if (isPromise(result)) {
+      return result.then(result => result.filter(Boolean));
+    } else {
+      return result.filter(Boolean);
+    }
+  };
+
+  const workflow = _objectSpread(_objectSpread({}, pipeline), {}, {
+    use,
+    run,
+    [ASYNC_WORKFLOW_SYMBOL]: true
+  });
+
+  return workflow;
+};
+
+exports.createAsyncWorkflow = createAsyncWorkflow;
+
+const mapAsyncWorkerToAsyncMiddleware = worker => async (input, next) => [await worker(input), ...(await next(input))];
+
+function isPromise(obj) {
+  return Boolean(obj) && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
+}

package/dist/js/node/workflow/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _sync = require("./sync");
+
+Object.keys(_sync).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _sync[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _sync[key];
+    }
+  });
+});
+
+var _parallel = require("./parallel");
+
+Object.keys(_parallel).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _parallel[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _parallel[key];
+    }
+  });
+});
+
+var _async = require("./async");
+
+Object.keys(_async).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _async[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _async[key];
+    }
+  });
+});

package/dist/js/node/workflow/parallel.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isParallelWorkflow = exports.createParallelWorkflow = void 0;
+
+var _farrowPipeline = require("../farrow-pipeline");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const PARALLEL_WORKFLOW_SYMBOL = Symbol.for('MODERN_PARALLEL_WORKFLOW');
+
+const isParallelWorkflow = input => Boolean(input === null || input === void 0 ? void 0 : input[PARALLEL_WORKFLOW_SYMBOL]);
+
+exports.isParallelWorkflow = isParallelWorkflow;
+
+const createParallelWorkflow = () => {
+  const pipeline = (0, _farrowPipeline.createPipeline)();
+
+  const use = (...input) => {
+    pipeline.use(...input.map(mapParallelWorkerToAsyncMiddleware));
+    return workflow;
+  };
+
+  const run = async input => Promise.all(pipeline.run(input, {
+    onLast: () => []
+  })).then(result => result.filter(Boolean));
+
+  const workflow = _objectSpread(_objectSpread({}, pipeline), {}, {
+    run,
+    use,
+    [PARALLEL_WORKFLOW_SYMBOL]: true
+  });
+
+  return workflow;
+};
+
+exports.createParallelWorkflow = createParallelWorkflow;
+
+const mapParallelWorkerToAsyncMiddleware = worker => (input, next) => [worker(input), ...next(input)];

package/dist/js/node/workflow/sync.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isWorkflow = exports.createWorkflow = void 0;
+
+var _farrowPipeline = require("../farrow-pipeline");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const WORKFLOW_SYMBOL = Symbol.for('MODERN_WORKFLOW');
+
+const createWorkflow = () => {
+  const pipeline = (0, _farrowPipeline.createPipeline)();
+
+  const use = (...input) => {
+    pipeline.use(...input.map(mapWorkerToMiddleware));
+    return workflow;
+  };
+
+  const run = input => {
+    const result = pipeline.run(input, {
+      onLast: () => []
+    });
+    return result.filter(Boolean);
+  };
+
+  const workflow = _objectSpread(_objectSpread({}, pipeline), {}, {
+    use,
+    run,
+    [WORKFLOW_SYMBOL]: true
+  });
+
+  return workflow;
+};
+
+exports.createWorkflow = createWorkflow;
+
+const isWorkflow = input => Boolean(input === null || input === void 0 ? void 0 : input[WORKFLOW_SYMBOL]);
+
+exports.isWorkflow = isWorkflow;
+
+const mapWorkerToMiddleware = worker => (input, next) => [worker(input), ...next(input)];

package/dist/js/treeshaking/farrow-pipeline/context.js

@@ -0,0 +1,42 @@
+/**
+ * modified from https://github.com/farrow-js/farrow/tree/master/packages/farrow-pipeline
+ * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
+ */
+export var createContext = function createContext(value) {
+  var currentValue;
+
+  var create = function create(value) {
+    currentValue = value;
+
+    var use = function use() {
+      return {
+        get value() {
+          return currentValue;
+        },
+
+        set value(v) {
+          currentValue = v;
+        }
+
+      };
+    };
+
+    var get = function get() {
+      return currentValue;
+    };
+
+    var set = function set(v) {
+      currentValue = v;
+    };
+
+    var Context = {
+      create: create,
+      use: use,
+      get: get,
+      set: set
+    };
+    return Context;
+  };
+
+  return create(value);
+};

package/dist/js/treeshaking/farrow-pipeline/counter.js

@@ -0,0 +1,23 @@
+/**
+ * modified from https://github.com/farrow-js/farrow/tree/master/packages/farrow-pipeline
+ * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
+ */
+export var createCounter = function createCounter(callback) {
+  var dispatch = function dispatch(index, input) {
+    var next = function next() {
+      var nextInput = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : input;
+      return dispatch(index + 1, nextInput);
+    };
+
+    return callback(index, input, next);
+  };
+
+  var start = function start(input) {
+    return dispatch(0, input);
+  };
+
+  return {
+    start: start,
+    dispatch: dispatch
+  };
+};

package/dist/js/treeshaking/farrow-pipeline/index.js

@@ -0,0 +1,5 @@
+/**
+ * modified from https://github.com/farrow-js/farrow/tree/master/packages/farrow-pipeline
+ * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
+ */
+export * from "./pipeline";