js-build-tools 2.4.0 → 3.0.1

package/vendor/array-union/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/es.array.unscopables.flat.js");
+require("core-js/modules/esnext.set.add-all.js");
+require("core-js/modules/esnext.set.delete-all.js");
+require("core-js/modules/esnext.set.difference.js");
+require("core-js/modules/esnext.set.every.js");
+require("core-js/modules/esnext.set.filter.js");
+require("core-js/modules/esnext.set.find.js");
+require("core-js/modules/esnext.set.intersection.js");
+require("core-js/modules/esnext.set.is-disjoint-from.js");
+require("core-js/modules/esnext.set.is-subset-of.js");
+require("core-js/modules/esnext.set.is-superset-of.js");
+require("core-js/modules/esnext.set.join.js");
+require("core-js/modules/esnext.set.map.js");
+require("core-js/modules/esnext.set.reduce.js");
+require("core-js/modules/esnext.set.some.js");
+require("core-js/modules/esnext.set.symmetric-difference.js");
+require("core-js/modules/esnext.set.union.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+const arrayUnion = function () {
+  for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+    arguments_[_key] = arguments[_key];
+  }
+  return [...new Set(arguments_.flat())];
+};
+var _default = exports.default = arrayUnion;

package/vendor/easy-transform-stream/index.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformStream;
+require("core-js/modules/web.dom-collections.iterator.js");
+var _nodeStream = require("node:stream");
+function transformStream() {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let transformer = arguments.length > 1 ? arguments[1] : undefined;
+  let flusher = arguments.length > 2 ? arguments[2] : undefined;
+  if (typeof options === 'function') {
+    flusher = transformer;
+    transformer = options;
+  }
+  return new _nodeStream.Transform({
+    ...options,
+    transform(chunk, encoding, callback) {
+      (async () => {
+        try {
+          const value = await transformer(chunk, encoding, this);
+
+          // If the callback throws, we don't want to cause an infinite recursion.
+          try {
+            callback(undefined, value);
+          } catch {}
+        } catch (error) {
+          callback(error);
+        }
+      })();
+    },
+    flush(callback) {
+      if (typeof flusher !== 'function') {
+        callback();
+        return;
+      }
+      (async () => {
+        try {
+          for await (const chunk of flusher(this)) {
+            this.push(chunk);
+          }
+
+          // If the callback throws, we don't want to cause an infinite recursion.
+          try {
+            callback();
+          } catch {}
+        } catch (error) {
+          callback(error);
+        }
+      })();
+    }
+  });
+}

package/vendor/globby/gitignore.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isGitIgnoredSync = exports.isGitIgnored = void 0;
+require("core-js/modules/esnext.async-iterator.filter.js");
+require("core-js/modules/esnext.async-iterator.map.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _nodeProcess = _interopRequireDefault(require("node:process"));
+var _nodeFs = _interopRequireDefault(require("node:fs"));
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _fastGlob = _interopRequireDefault(require("fast-glob"));
+var _index = _interopRequireDefault(require("../ignore/index.js"));
+var _index2 = _interopRequireDefault(require("./node_modules/slash/index.js"));
+var _toPath = _interopRequireDefault(require("./to-path.js"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const DEFAULT_IGNORE = ['**/node_modules/**', '**/flow-typed/**', '**/coverage/**', '**/.git'];
+const mapGitIgnorePatternTo = base => ignore => {
+  if (ignore.startsWith('!')) {
+    return '!' + _nodePath.default.posix.join(base, ignore.slice(1));
+  }
+  return _nodePath.default.posix.join(base, ignore);
+};
+const parseGitIgnore = (content, options) => {
+  const base = (0, _index2.default)(_nodePath.default.relative(options.cwd, _nodePath.default.dirname(options.fileName)));
+  return content.split(/\r?\n/).filter(Boolean).filter(line => !line.startsWith('#')).map(mapGitIgnorePatternTo(base));
+};
+const reduceIgnore = files => {
+  const ignores = (0, _index.default)();
+  for (const file of files) {
+    ignores.add(parseGitIgnore(file.content, {
+      cwd: file.cwd,
+      fileName: file.filePath
+    }));
+  }
+  return ignores;
+};
+const ensureAbsolutePathForCwd = (cwd, p) => {
+  cwd = (0, _index2.default)(cwd);
+  if (_nodePath.default.isAbsolute(p)) {
+    if ((0, _index2.default)(p).startsWith(cwd)) {
+      return p;
+    }
+    throw new Error("Path ".concat(p, " is not in cwd ").concat(cwd));
+  }
+  return _nodePath.default.join(cwd, p);
+};
+const getIsIgnoredPredicate = (ignores, cwd) => p => ignores.ignores((0, _index2.default)(_nodePath.default.relative(cwd, ensureAbsolutePathForCwd(cwd, (0, _toPath.default)(p.path || p)))));
+const getFile = async (file, cwd) => {
+  const filePath = _nodePath.default.join(cwd, file);
+  const content = await _nodeFs.default.promises.readFile(filePath, 'utf8');
+  return {
+    cwd,
+    filePath,
+    content
+  };
+};
+const getFileSync = (file, cwd) => {
+  const filePath = _nodePath.default.join(cwd, file);
+  const content = _nodeFs.default.readFileSync(filePath, 'utf8');
+  return {
+    cwd,
+    filePath,
+    content
+  };
+};
+const normalizeOptions = function () {
+  let {
+    ignore = [],
+    cwd = (0, _index2.default)(_nodeProcess.default.cwd())
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return {
+    ignore: [...DEFAULT_IGNORE, ...ignore],
+    cwd: (0, _toPath.default)(cwd)
+  };
+};
+const isGitIgnored = async options => {
+  options = normalizeOptions(options);
+  const paths = await (0, _fastGlob.default)('**/.gitignore', options);
+  const files = await Promise.all(paths.map(file => getFile(file, options.cwd)));
+  const ignores = reduceIgnore(files);
+  return getIsIgnoredPredicate(ignores, options.cwd);
+};
+exports.isGitIgnored = isGitIgnored;
+const isGitIgnoredSync = options => {
+  options = normalizeOptions(options);
+  const paths = _fastGlob.default.sync('**/.gitignore', options);
+  const files = paths.map(file => getFileSync(file, options.cwd));
+  const ignores = reduceIgnore(files);
+  return getIsIgnoredPredicate(ignores, options.cwd);
+};
+exports.isGitIgnoredSync = isGitIgnoredSync;

package/vendor/globby/index.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDynamicPattern = exports.globbySync = exports.globbyStream = exports.globby = exports.generateGlobTasks = void 0;
+Object.defineProperty(exports, "isGitIgnored", {
+  enumerable: true,
+  get: function () {
+    return _gitignore.isGitIgnored;
+  }
+});
+Object.defineProperty(exports, "isGitIgnoredSync", {
+  enumerable: true,
+  get: function () {
+    return _gitignore.isGitIgnoredSync;
+  }
+});
+require("core-js/modules/es.array.unscopables.flat.js");
+require("core-js/modules/esnext.async-iterator.every.js");
+require("core-js/modules/esnext.async-iterator.filter.js");
+require("core-js/modules/esnext.async-iterator.map.js");
+require("core-js/modules/esnext.async-iterator.some.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.every.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/esnext.iterator.some.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _nodeFs = _interopRequireDefault(require("node:fs"));
+var _index = _interopRequireDefault(require("../array-union/index.js"));
+var _merge = _interopRequireDefault(require("merge2"));
+var _fastGlob = _interopRequireDefault(require("fast-glob"));
+var _dirGlob = _interopRequireDefault(require("dir-glob"));
+var _toPath = _interopRequireDefault(require("./to-path.js"));
+var _gitignore = require("./gitignore.js");
+var _streamUtils = require("./stream-utils.js");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const DEFAULT_FILTER = () => false;
+const isNegative = pattern => pattern[0] === '!';
+const assertPatternsInput = patterns => {
+  if (!patterns.every(pattern => typeof pattern === 'string')) {
+    throw new TypeError('Patterns must be a string or an array of strings');
+  }
+};
+const checkCwdOption = options => {
+  if (!options.cwd) {
+    return;
+  }
+  let stat;
+  try {
+    stat = _nodeFs.default.statSync(options.cwd);
+  } catch {
+    return;
+  }
+  if (!stat.isDirectory()) {
+    throw new Error('The `cwd` option must be a path to a directory');
+  }
+};
+const getPathString = p => p.stats instanceof _nodeFs.default.Stats ? p.path : p;
+const generateGlobTasks = function (patterns) {
+  let taskOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  patterns = (0, _index.default)([patterns].flat());
+  assertPatternsInput(patterns);
+  const globTasks = [];
+  taskOptions = {
+    ignore: [],
+    expandDirectories: true,
+    ...taskOptions,
+    cwd: (0, _toPath.default)(taskOptions.cwd)
+  };
+  checkCwdOption(taskOptions);
+  for (const [index, pattern] of patterns.entries()) {
+    if (isNegative(pattern)) {
+      continue;
+    }
+    const ignore = patterns.slice(index).filter(pattern => isNegative(pattern)).map(pattern => pattern.slice(1));
+    const options = {
+      ...taskOptions,
+      ignore: [...taskOptions.ignore, ...ignore]
+    };
+    globTasks.push({
+      pattern,
+      options
+    });
+  }
+  return globTasks;
+};
+exports.generateGlobTasks = generateGlobTasks;
+const globDirectories = (task, fn) => {
+  let options = {};
+  if (task.options.cwd) {
+    options.cwd = task.options.cwd;
+  }
+  if (Array.isArray(task.options.expandDirectories)) {
+    options = {
+      ...options,
+      files: task.options.expandDirectories
+    };
+  } else if (typeof task.options.expandDirectories === 'object') {
+    options = {
+      ...options,
+      ...task.options.expandDirectories
+    };
+  }
+  return fn(task.pattern, options);
+};
+const getPattern = (task, fn) => task.options.expandDirectories ? globDirectories(task, fn) : [task.pattern];
+const getFilterSync = options => options && options.gitignore ? (0, _gitignore.isGitIgnoredSync)({
+  cwd: options.cwd,
+  ignore: options.ignore
+}) : DEFAULT_FILTER;
+const globToTask = task => async glob => {
+  const {
+    options
+  } = task;
+  if (options.ignore && Array.isArray(options.ignore) && options.expandDirectories) {
+    options.ignore = await (0, _dirGlob.default)(options.ignore);
+  }
+  return {
+    pattern: glob,
+    options
+  };
+};
+const globToTaskSync = task => glob => {
+  const {
+    options
+  } = task;
+  if (options.ignore && Array.isArray(options.ignore) && options.expandDirectories) {
+    options.ignore = _dirGlob.default.sync(options.ignore);
+  }
+  return {
+    pattern: glob,
+    options
+  };
+};
+const globby = async (patterns, options) => {
+  const globTasks = generateGlobTasks(patterns, options);
+  const getFilter = async () => options && options.gitignore ? (0, _gitignore.isGitIgnored)({
+    cwd: options.cwd,
+    ignore: options.ignore
+  }) : DEFAULT_FILTER;
+  const getTasks = async () => {
+    const tasks = await Promise.all(globTasks.map(async task => {
+      const globs = await getPattern(task, _dirGlob.default);
+      return Promise.all(globs.map(globToTask(task)));
+    }));
+    return (0, _index.default)(...tasks);
+  };
+  const [filter, tasks] = await Promise.all([getFilter(), getTasks()]);
+  const paths = await Promise.all(tasks.map(task => (0, _fastGlob.default)(task.pattern, task.options)));
+  return (0, _index.default)(...paths).filter(path_ => !filter(getPathString(path_)));
+};
+exports.globby = globby;
+const globbySync = (patterns, options) => {
+  const globTasks = generateGlobTasks(patterns, options);
+  const tasks = [];
+  for (const task of globTasks) {
+    const newTask = getPattern(task, _dirGlob.default.sync).map(globToTaskSync(task));
+    tasks.push(...newTask);
+  }
+  const filter = getFilterSync(options);
+  let matches = [];
+  for (const task of tasks) {
+    matches = (0, _index.default)(matches, _fastGlob.default.sync(task.pattern, task.options));
+  }
+  return matches.filter(path_ => !filter(path_));
+};
+exports.globbySync = globbySync;
+const globbyStream = (patterns, options) => {
+  const globTasks = generateGlobTasks(patterns, options);
+  const tasks = [];
+  for (const task of globTasks) {
+    const newTask = getPattern(task, _dirGlob.default.sync).map(globToTaskSync(task));
+    tasks.push(...newTask);
+  }
+  const filter = getFilterSync(options);
+  const filterStream = new _streamUtils.FilterStream(p => !filter(p));
+  const uniqueStream = new _streamUtils.UniqueStream();
+  return (0, _merge.default)(tasks.map(task => _fastGlob.default.stream(task.pattern, task.options))).pipe(filterStream).pipe(uniqueStream);
+};
+exports.globbyStream = globbyStream;
+const isDynamicPattern = function (patterns) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  options = {
+    ...options,
+    cwd: (0, _toPath.default)(options.cwd)
+  };
+  return [patterns].flat().some(pattern => _fastGlob.default.isDynamicPattern(pattern, options));
+};
+exports.isDynamicPattern = isDynamicPattern;

package/vendor/globby/node_modules/slash/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = slash;
+require("core-js/modules/es.string.replace.js");
+function slash(path) {
+  const isExtendedLengthPath = /^\\\\\?\\/.test(path);
+  const hasNonAscii = /[^\u0000-\u0080]+/.test(path); // eslint-disable-line no-control-regex
+
+  if (isExtendedLengthPath || hasNonAscii) {
+    return path;
+  }
+  return path.replace(/\\/g, '/');
+}

package/vendor/globby/stream-utils.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UniqueStream = exports.FilterStream = void 0;
+require("core-js/modules/esnext.set.add-all.js");
+require("core-js/modules/esnext.set.delete-all.js");
+require("core-js/modules/esnext.set.difference.js");
+require("core-js/modules/esnext.set.every.js");
+require("core-js/modules/esnext.set.filter.js");
+require("core-js/modules/esnext.set.find.js");
+require("core-js/modules/esnext.set.intersection.js");
+require("core-js/modules/esnext.set.is-disjoint-from.js");
+require("core-js/modules/esnext.set.is-subset-of.js");
+require("core-js/modules/esnext.set.is-superset-of.js");
+require("core-js/modules/esnext.set.join.js");
+require("core-js/modules/esnext.set.map.js");
+require("core-js/modules/esnext.set.reduce.js");
+require("core-js/modules/esnext.set.some.js");
+require("core-js/modules/esnext.set.symmetric-difference.js");
+require("core-js/modules/esnext.set.union.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _nodeStream = require("node:stream");
+class ObjectTransform extends _nodeStream.Transform {
+  constructor() {
+    super({
+      objectMode: true
+    });
+  }
+}
+class FilterStream extends ObjectTransform {
+  constructor(filter) {
+    super();
+    this._filter = filter;
+  }
+  _transform(data, encoding, callback) {
+    if (this._filter(data)) {
+      this.push(data);
+    }
+    callback();
+  }
+}
+exports.FilterStream = FilterStream;
+class UniqueStream extends ObjectTransform {
+  constructor() {
+    super();
+    this._pushed = new Set();
+  }
+  _transform(data, encoding, callback) {
+    if (!this._pushed.has(data)) {
+      this.push(data);
+      this._pushed.add(data);
+    }
+    callback();
+  }
+}
+exports.UniqueStream = UniqueStream;

package/vendor/globby/to-path.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/web.url.js");
+require("core-js/modules/web.url-search-params.js");
+var _nodeUrl = require("node:url");
+const toPath = urlOrPath => {
+  if (!urlOrPath) {
+    return urlOrPath;
+  }
+  if (urlOrPath instanceof URL) {
+    urlOrPath = urlOrPath.href;
+  }
+  return urlOrPath.startsWith('file://') ? (0, _nodeUrl.fileURLToPath)(urlOrPath) : urlOrPath;
+};
+var _default = exports.default = toPath;

package/vendor/gulp-imagemin/index.js

@@ -0,0 +1,128 @@
+async function exportGulpImagemin () {
+  "use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = gulpImagemin;
+exports.svgo = exports.optipng = exports.mozjpeg = exports.gifsicle = void 0;
+require("core-js/modules/es.array.unscopables.flat-map.js");
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/esnext.set.add-all.js");
+require("core-js/modules/esnext.set.delete-all.js");
+require("core-js/modules/esnext.set.difference.js");
+require("core-js/modules/esnext.set.every.js");
+require("core-js/modules/esnext.set.filter.js");
+require("core-js/modules/esnext.set.find.js");
+require("core-js/modules/esnext.set.intersection.js");
+require("core-js/modules/esnext.set.is-disjoint-from.js");
+require("core-js/modules/esnext.set.is-subset-of.js");
+require("core-js/modules/esnext.set.is-superset-of.js");
+require("core-js/modules/esnext.set.join.js");
+require("core-js/modules/esnext.set.map.js");
+require("core-js/modules/esnext.set.reduce.js");
+require("core-js/modules/esnext.set.some.js");
+require("core-js/modules/esnext.set.symmetric-difference.js");
+require("core-js/modules/esnext.set.union.js");
+require("core-js/modules/esnext.weak-map.delete-all.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _nodeProcess = _interopRequireDefault(require("node:process"));
+var _index = _interopRequireDefault(require("../pretty-bytes/index.js"));
+var _index2 = _interopRequireDefault(require("./node_modules/chalk/source/index.js"));
+var _index3 = _interopRequireDefault(require("../imagemin/index.js"));
+var _index4 = _interopRequireDefault(require("../plur/index.js"));
+var _index5 = require("../gulp-plugin-extras/index.js");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const PLUGIN_NAME = 'gulp-imagemin';
+const defaultPlugins = ['gifsicle', 'mozjpeg', 'optipng', 'svgo'];
+const loadPlugin = async function (pluginName) {
+  try {
+    const {
+      default: plugin
+    } = await (specifier => new Promise(r => r(specifier)).then(s => _interopRequireWildcard(require(s))))("../imagemin-".concat(pluginName, "/index.js"));
+    for (var _len = arguments.length, arguments_ = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      arguments_[_key - 1] = arguments[_key];
+    }
+    return plugin(...arguments_);
+  } catch (error) {
+    console.log('er', error);
+    console.log("".concat(PLUGIN_NAME, ": Could not load default plugin `").concat(pluginName, "`"));
+  }
+};
+const exposePlugin = async plugin => function () {
+  for (var _len2 = arguments.length, arguments_ = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    arguments_[_key2] = arguments[_key2];
+  }
+  return loadPlugin(plugin, ...arguments_);
+};
+const getDefaultPlugins = async () => Promise.all(defaultPlugins.flatMap(plugin => loadPlugin(plugin)));
+function gulpImagemin(plugins, options) {
+  if (typeof plugins === 'object' && !Array.isArray(plugins)) {
+    options = plugins;
+    plugins = undefined;
+  }
+  options = {
+    // TODO: Remove this when Gulp gets a real logger with levels
+    silent: _nodeProcess.default.argv.includes('--silent'),
+    verbose: _nodeProcess.default.argv.includes('--verbose'),
+    ...options
+  };
+  const validExtensions = new Set(['.jpg', '.jpeg', '.png', '.gif', '.svg']);
+  let totalBytes = 0;
+  let totalSavedBytes = 0;
+  let totalFiles = 0;
+  return (0, _index5.gulpPlugin)('gulp-imagemin', async file => {
+    var _plugins;
+    if (!validExtensions.has(_nodePath.default.extname(file.path).toLowerCase())) {
+      if (options.verbose) {
+        console.log("".concat(PLUGIN_NAME, ": Skipping unsupported image ").concat(_index2.default.blue(file.relative)));
+      }
+      return file;
+    }
+    if (Array.isArray(plugins)) {
+      plugins = await Promise.all(plugins);
+    }
+    const localPlugins = (_plugins = plugins) !== null && _plugins !== void 0 ? _plugins : await getDefaultPlugins();
+    const data = await _index3.default.buffer(file.contents, {
+      plugins: localPlugins
+    });
+    const originalSize = file.contents.length;
+    const optimizedSize = data.length;
+    const saved = originalSize - optimizedSize;
+    const percent = originalSize > 0 ? saved / originalSize * 100 : 0;
+    const savedMessage = "saved ".concat((0, _index.default)(saved), " - ").concat(percent.toFixed(1).replace(/\.0$/, ''), "%");
+    const message = saved > 0 ? savedMessage : 'already optimized';
+    if (saved > 0) {
+      totalBytes += originalSize;
+      totalSavedBytes += saved;
+      totalFiles++;
+    }
+    if (options.verbose) {
+      console.log("".concat(PLUGIN_NAME, ":"), _index2.default.green('✔ ') + file.relative + _index2.default.gray(" (".concat(message, ")")));
+    }
+    file.contents = data;
+    return file;
+  }, {
+    async *onFinish() {
+      // eslint-disable-line require-yield
+      if (!options.silent) {
+        const percent = totalBytes > 0 ? totalSavedBytes / totalBytes * 100 : 0;
+        let message = "Minified ".concat(totalFiles, " ").concat((0, _index4.default)('image', totalFiles));
+        if (totalFiles > 0) {
+          message += _index2.default.gray(" (saved ".concat((0, _index.default)(totalSavedBytes), " - ").concat(percent.toFixed(1).replace(/\.0$/, ''), "%)"));
+        }
+        console.log("".concat(PLUGIN_NAME, ":"), message);
+      }
+    }
+  });
+}
+const gifsicle = exports.gifsicle = await exposePlugin('gifsicle');
+const mozjpeg = exports.mozjpeg = await exposePlugin('mozjpeg');
+const optipng = exports.optipng = await exposePlugin('optipng');
+const svgo = exports.svgo = await exposePlugin('svgo');
+}
+
+exportGulpImagemin()