js-build-tools 6.6.0 → 6.8.0

package/dist/partials/cacheFiles.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cacheFiles = void 0;
+var _crypto = require("crypto");
+var _promises = require("fs/promises");
+var _path = _interopRequireDefault(require("path"));
+var _stream = require("stream");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Marks a file sent to the plugin with its cache file and its path, so its result is cached even if the plugin renames it
+const cacheFile = Symbol('cacheFile');
+
+/**
+ * The cache file for a file's contents: a hash of the cache name, the fingerprint and the contents, so the same file
+ * with other plugin settings or plugin versions gets a result of its own.
+ * @private
+ * @param {string} directory
+ * @param {string} name
+ * @param {string} fingerprint
+ * @param {Buffer} contents
+ * @returns {string}
+ */
+const cachePath = (directory, name, fingerprint, contents) => _path.default.join(directory, name, (0, _crypto.createHash)('sha256').update(name).update('\0').update(fingerprint).update('\0').update(contents).digest('hex'));
+
+/**
+ * Write through a temporary file and rename it, so a reader (another build or test worker) never sees a half-written
+ * result.
+ * @private
+ * @param {string} file
+ * @param {Buffer} contents
+ * @returns {Promise<void>}
+ */
+const writeAtomic = async (file, contents) => {
+  await (0, _promises.mkdir)(_path.default.dirname(file), {
+    recursive: true
+  });
+  const temporary = `${file}.${(0, _crypto.randomUUID)()}.tmp`;
+  await (0, _promises.writeFile)(temporary, contents);
+  await (0, _promises.rename)(temporary, file);
+};
+
+/**
+ * Run a gulp plugin only on files it hasn't processed before. A file whose contents (with this cache name and
+ * fingerprint) were processed by an earlier run gets that run's result from the cache instead, and skips the plugin.
+ * Replaces gulp-cache, which kept one cache for every process in the system's temp folder.
+ *
+ * A result is cached when the plugin passes on the file object it was given (as gulp plugins usually do); a plugin
+ * that makes new file objects still works, its results just aren't cached. When the plugin renames a file, the cache
+ * keeps the new name too (next to the result, as `<entry>.path`), so a cached file is renamed the same way. Entries
+ * are never pruned: delete the directory to start over.
+ * @memberOf module:partials
+ * @param {stream.Transform} plugin - The gulp plugin stream to run on uncached files (e.g. imagemin()).
+ * @param {Object} options
+ * @param {string} options.directory - Where cached results are kept (see images.cacheDir).
+ * @param {string} [options.name='default'] - The cache's folder; keeps results of different plugin settings apart.
+ * @param {string} [options.fingerprint=''] - Anything else that changes the plugin's output, such as its version and
+ * options: when it changes, earlier results are no longer used.
+ * @returns {stream.Transform}
+ */
+const cacheFiles = (plugin, {
+  directory,
+  name = 'default',
+  fingerprint = ''
+}) => {
+  const writes = [];
+  const pluginDone = new Promise((resolve, reject) => {
+    plugin.on('end', resolve);
+    plugin.on('error', reject);
+  });
+  // The error also reaches the stream (below); this only stops it from being reported a second time as unhandled
+  pluginDone.catch(() => {});
+  const stream = new _stream.Transform({
+    objectMode: true,
+    transform(file, encoding, callback) {
+      if (!file.isBuffer()) {
+        callback(null, file);
+        return;
+      }
+      const cached = cachePath(directory, name, fingerprint, file.contents);
+      (0, _promises.readFile)(cached).then(async contents => {
+        file.contents = contents;
+        // Written before the result, so it's there whenever the result is
+        const renamed = await (0, _promises.readFile)(`${cached}.path`, 'utf8').catch(() => undefined);
+        if (renamed !== undefined) {
+          file.path = _path.default.join(_path.default.dirname(file.path), renamed);
+        }
+        callback(null, file);
+      }, () => {
+        file[cacheFile] = {
+          cached,
+          from: file.path
+        };
+        plugin.write(file);
+        callback();
+      });
+    },
+    flush(callback) {
+      plugin.end();
+      pluginDone.then(() => Promise.all(writes)).then(() => callback(), callback);
+    }
+  });
+  plugin.on('data', file => {
+    const tag = file[cacheFile];
+    delete file[cacheFile];
+    if (tag && file.isBuffer()) {
+      const {
+        cached,
+        from
+      } = tag;
+      const renamed = file.path === from ? Promise.resolve() : writeAtomic(`${cached}.path`, _path.default.relative(_path.default.dirname(from), file.path));
+      // The cache only saves time: a result that can't be written is processed again next run, not a failed build
+      writes.push(renamed.then(() => writeAtomic(cached, file.contents)).catch(() => {}));
+    }
+    stream.push(file);
+  });
+  plugin.on('error', error => stream.destroy(error));
+  return stream;
+};
+exports.cacheFiles = cacheFiles;

package/dist/partials/clean.js

@@ -11,11 +11,11 @@ var gulpConfig = _interopRequireWildcard(require("../../gulp.config.js"));
 var _removeDirectory = require("./removeDirectory.js");
 var cache;
 function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var r, c, a = Object.defineProperty, n = { __proto__: null, default: e }; if (Object(e) !== e) return n; if (cache || "function" != typeof WeakMap || (cache = new WeakMap()), cache) { if (cache.has(e)) return cache.get(e); cache.set(e, n); } for (c in e) "default" !== c && {}.hasOwnProperty.call(e, c) && ((r = a && Object.getOwnPropertyDescriptor(e, c)) && (r.get || r.set) ? a(n, c, r) : n[c] = e[c]); return n; }
-/**
- * Deletes all the distribution and browser files (used before create a new build).
- * Configure array of directories to remove with 'cleanPaths'.
- * @memberOf module:partials
- * @returns {Promise<string[]> | *}
+/**
+ * Deletes all the distribution and browser files (used before create a new build).
+ * Configure array of directories to remove with 'cleanPaths'.
+ * @memberOf module:partials
+ * @returns {Promise<string[]> | *}
  */
 const clean = () => gulpConfig.get('cleanPaths').reduce((promise, path) => promise.then(() => (0, _removeDirectory.removeDirectory)(path)), Promise.resolve());
 exports.clean = clean;

package/dist/partials/copyFor.js

@@ -5,15 +5,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.copyFor = void 0;
 var _gulp = require("gulp");
-/**
- * Copy some files to a different location.
- * @memberOf module:partials
- * @param {string|array} srcPath
- * @param {string} destPath
- * @param {Object} [options]
- * @param {string} [options.base] - Passed through to gulp's own src(pattern, {base}), to preserve srcPath's own
- * subdirectory structure in destPath instead of flattening it.
- * @returns {stream.Stream}
+/**
+ * Copy some files to a different location.
+ * @memberOf module:partials
+ * @param {string|array} srcPath
+ * @param {string} destPath
+ * @param {Object} [options]
+ * @param {string} [options.base] - Passed through to gulp's own src(pattern, {base}), to preserve srcPath's own
+ * subdirectory structure in destPath instead of flattening it.
+ * @returns {stream.Stream}
  */
 // encoding: false copies the bytes untouched - Gulp 5's default utf8 handling corrupts binary files such as fonts.
 const copyFor = (srcPath, destPath, {

package/dist/partials/distFor.js

@@ -13,12 +13,12 @@ var _through = _interopRequireDefault(require("through2"));
 var cache;
 function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var r, c, a = Object.defineProperty, n = { __proto__: null, default: e }; if (Object(e) !== e) return n; if (cache || "function" != typeof WeakMap || (cache = new WeakMap()), cache) { if (cache.has(e)) return cache.get(e); cache.set(e, n); } for (c in e) "default" !== c && {}.hasOwnProperty.call(e, c) && ((r = a && Object.getOwnPropertyDescriptor(e, c)) && (r.get || r.set) ? a(n, c, r) : n[c] = e[c]); return n; }
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-/**
- * Build the distribution for a given source pattern.
- * @memberOf module:partials
- * @param {string|array} [srcPath='src/config/path/dist/for']
- * @param {string} [destPath='dist/config/path']
- * @returns {stream.Stream}
+/**
+ * Build the distribution for a given source pattern.
+ * @memberOf module:partials
+ * @param {string|array} [srcPath='src/config/path/dist/for']
+ * @param {string} [destPath='dist/config/path']
+ * @returns {stream.Stream}
  */
 const distFor = (srcPath = (0, _distForSrc.distForSrc)(), destPath = gulpConfig.get('dist.to')) => (0, _gulp.src)(srcPath).pipe((0, _gulpBabel.default)()).pipe(_through.default.obj(function (file, enc, callback) {
   const regex = /\.mjs(['"]\s*\))/gi;

package/dist/partials/distForSrc.js

@@ -8,11 +8,11 @@ exports.distForSrc = void 0;
 var gulpConfig = _interopRequireWildcard(require("../../gulp.config.js"));
 var cache;
 function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var r, c, a = Object.defineProperty, n = { __proto__: null, default: e }; if (Object(e) !== e) return n; if (cache || "function" != typeof WeakMap || (cache = new WeakMap()), cache) { if (cache.has(e)) return cache.get(e); cache.set(e, n); } for (c in e) "default" !== c && {}.hasOwnProperty.call(e, c) && ((r = a && Object.getOwnPropertyDescriptor(e, c)) && (r.get || r.set) ? a(n, c, r) : n[c] = e[c]); return n; }
-/**
- * Retrieve the correct distFor search path based on TS Config.
- * @memberOf module:partials
- * @param {module:gulpConfig~FlagStringSetting} [useTs='config/for/ts']
- * @returns {string}
+/**
+ * Retrieve the correct distFor search path based on TS Config.
+ * @memberOf module:partials
+ * @param {module:gulpConfig~FlagStringSetting} [useTs='config/for/ts']
+ * @returns {string}
  */
 const distForSrc = (useTs = gulpConfig.get('typescript.enabled')) => useTs ? gulpConfig.get('browser.from') : gulpConfig.get('dist.from');
 exports.distForSrc = distForSrc;

package/dist/partials/distSeries.js

@@ -12,13 +12,13 @@ var _gulp = require("gulp");
 var _tsFor = require("./tsFor.js");
 var cache;
 function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var r, c, a = Object.defineProperty, n = { __proto__: null, default: e }; if (Object(e) !== e) return n; if (cache || "function" != typeof WeakMap || (cache = new WeakMap()), cache) { if (cache.has(e)) return cache.get(e); cache.set(e, n); } for (c in e) "default" !== c && {}.hasOwnProperty.call(e, c) && ((r = a && Object.getOwnPropertyDescriptor(e, c)) && (r.get || r.set) ? a(n, c, r) : n[c] = e[c]); return n; }
-/**
- * When using TypeScript, ensure that we process the ts first then run babel (dist)
- * @memberOf module:partials
- * @param {string} [srcPath='src/config/path/dist/for']
- * @param {string} [distFinalPath='dist/config/path']
- * @param {string} [tsSearch='ts/search/config/path']
- * @returns {function(null=): stream.Stream}
+/**
+ * When using TypeScript, ensure that we process the ts first then run babel (dist)
+ * @memberOf module:partials
+ * @param {string} [srcPath='src/config/path/dist/for']
+ * @param {string} [distFinalPath='dist/config/path']
+ * @param {string} [tsSearch='ts/search/config/path']
+ * @returns {function(null=): stream.Stream}
  */
 const distSeries = (srcPath = (0, _distForSrc.distForSrc)(), distFinalPath = gulpConfig.get('dist.to'), tsSearch = gulpConfig.get('typescript.from')) => {
   const typescript = (0, _tsFor.tsFor)(tsSearch, distFinalPath);

package/dist/partials/imagesFor.js

@@ -1,94 +1,156 @@
-"use strict";
-
-require("core-js/modules/esnext.weak-map.delete-all.js");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.loadImageminPlugins = exports.loadImagemin = exports.imagesFor = exports.imageminPlugins = void 0;
-var _gulpCache = _interopRequireDefault(require("gulp-cache"));
-var _loadPeer = require("./loadPeer.js");
-var _gulp = require("gulp");
-var gulpConfig = _interopRequireWildcard(require("../../gulp.config.js"));
-var cache;
-function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var r, c, a = Object.defineProperty, n = { __proto__: null, default: e }; if (Object(e) !== e) return n; if (cache || "function" != typeof WeakMap || (cache = new WeakMap()), cache) { if (cache.has(e)) return cache.get(e); cache.set(e, n); } for (c in e) "default" !== c && {}.hasOwnProperty.call(e, c) && ((r = a && Object.getOwnPropertyDescriptor(e, c)) && (r.get || r.set) ? a(n, c, r) : n[c] = e[c]); return n; }
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const installHint = 'Add it to your project with: npm install --save-dev github:jheagle/gulp-imagemin#common-js-compatibility ' + '(the CommonJS-compatible fork - upstream gulp-imagemin is ESM-only and cannot be require()d by this package\'s CommonJS build).';
-
-/**
- * Load `gulp-imagemin`, an optional peer dependency: image optimization is off by default and its binary-download
- * dependency chain is heavy, so it is only required once the images task actually runs, and it is resolved from the
- * consuming project's own directory rather than from this package.
- * @memberOf module:partials
- * @param {string} [projectPath=process.cwd()] - The project directory to resolve `gulp-imagemin` from.
- * @returns {Function} The gulp-imagemin plugin factory.
- * @throws {Error} With install instructions when gulp-imagemin is missing or is the ESM-only upstream release.
- */
-const loadImagemin = (projectPath = process.cwd()) => {
-  const loaded = (0, _loadPeer.requirePeer)('gulp-imagemin', {
-    task: 'images',
-    installHint,
-    esmOnlyMessage: `gulp-imagemin could not be loaded because it is ESM-only. ${installHint}`,
-    projectPath
-  });
-  return loaded && (loaded.__esModule || loaded.default) ? loaded.default : loaded;
-};
-
-/**
- * Load the plugins `gulp-imagemin` exports by name (gifsicle, mozjpeg, optipng and svgo), each a promise of a plugin
- * factory, for when they need options of their own (see images.jpegQuality). Resolved like {@link loadImagemin}.
- * @memberOf module:partials
- * @param {string} [projectPath=process.cwd()] - The project directory to resolve `gulp-imagemin` from.
- * @returns {Object<string, Promise<Function>>} The plugin factories, by name.
- */
-exports.loadImagemin = loadImagemin;
-const loadImageminPlugins = (projectPath = process.cwd()) => (0, _loadPeer.requirePeer)('gulp-imagemin', {
-  task: 'images',
-  installHint,
-  esmOnlyMessage: `gulp-imagemin could not be loaded because it is ESM-only. ${installHint}`,
-  projectPath
-});
-
-// The plugins imagemin runs when it isn't given any, in its own order
-exports.loadImageminPlugins = loadImageminPlugins;
-const defaultPluginNames = ['gifsicle', 'mozjpeg', 'optipng', 'svgo'];
-
-/**
- * The plugins imagemin uses by default, with mozjpeg set to the given JPEG quality instead of its own default (75).
- * @memberOf module:partials
- * @param {number} jpegQuality - The mozjpeg quality, 0 to 100.
- * @param {Object<string, Promise<Function>>} [plugins=loadImageminPlugins()] - The plugin factories, by name.
- * @returns {Array<Promise<Function>>} The plugins, in imagemin's default order.
- */
-const imageminPlugins = (jpegQuality, plugins = loadImageminPlugins()) => defaultPluginNames.map(name => Promise.resolve(plugins[name]).then(makePlugin => name === 'mozjpeg' ? makePlugin({
-  quality: jpegQuality
-}) : makePlugin()));
-
-/**
- * Move and optimize images into the browser directory.
- * @memberOf module:partials
- * @param {string|array} [imageSrc=src/images/pattern]
- * @param {string} [imageDest=dest/image/folder]
- * @return {stream.Stream}
- */
-exports.imageminPlugins = imageminPlugins;
-const imagesFor = (imageSrc = gulpConfig.get('images.from'), imageDest = gulpConfig.get('images.to')) => {
-  const imagemin = loadImagemin();
-  const jpegQuality = gulpConfig.get('images.jpegQuality');
-  // Left unset, imagemin runs its default plugins with their own defaults
-  const plugins = jpegQuality ? imageminPlugins(jpegQuality) : undefined;
-  // Gulp 5 reads files as utf8 text unless told otherwise, which corrupts binary images (and makes gulp-cache drop them).
-  return (0, _gulp.src)(imageSrc, {
-    encoding: false
-  }).pipe(
-  // Caching images that ran through imagemin
-  (0, _gulpCache.default)(imagemin(plugins, {
-    interlaced: true,
-    silent: true,
-    verbose: false
-  }),
-  // gulp-cache keys on the file's contents alone, so keep each quality's results apart
-  {
-    name: jpegQuality ? `jpeg-quality-${jpegQuality}` : 'default'
-  })).pipe((0, _gulp.dest)(imageDest));
-};
+"use strict";
+
+require("core-js/modules/esnext.weak-map.delete-all.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadImageminPlugins = exports.loadImagemin = exports.imagesFor = exports.imageminVersions = exports.imageminPlugins = void 0;
+require("core-js/modules/es.json.stringify.js");
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _cacheFiles = require("./cacheFiles.js");
+var _loadPeer = require("./loadPeer.js");
+var _gulp = require("gulp");
+var gulpConfig = _interopRequireWildcard(require("../../gulp.config.js"));
+var cache;
+function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var r, c, a = Object.defineProperty, n = { __proto__: null, default: e }; if (Object(e) !== e) return n; if (cache || "function" != typeof WeakMap || (cache = new WeakMap()), cache) { if (cache.has(e)) return cache.get(e); cache.set(e, n); } for (c in e) "default" !== c && {}.hasOwnProperty.call(e, c) && ((r = a && Object.getOwnPropertyDescriptor(e, c)) && (r.get || r.set) ? a(n, c, r) : n[c] = e[c]); return n; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const installHint = 'Add it to your project with: npm install --save-dev github:jheagle/gulp-imagemin#common-js-compatibility ' + '(the CommonJS-compatible fork - upstream gulp-imagemin is ESM-only and cannot be require()d by this package\'s CommonJS build).';
+
+/**
+ * Load `gulp-imagemin`, an optional peer dependency: image optimization is off by default and its binary-download
+ * dependency chain is heavy, so it is only required once the images task actually runs, and it is resolved from the
+ * consuming project's own directory rather than from this package.
+ * @memberOf module:partials
+ * @param {string} [projectPath=process.cwd()] - The project directory to resolve `gulp-imagemin` from.
+ * @returns {Function} The gulp-imagemin plugin factory.
+ * @throws {Error} With install instructions when gulp-imagemin is missing or is the ESM-only upstream release.
+ */
+const loadImagemin = (projectPath = process.cwd()) => {
+  const loaded = (0, _loadPeer.requirePeer)('gulp-imagemin', {
+    task: 'images',
+    installHint,
+    esmOnlyMessage: `gulp-imagemin could not be loaded because it is ESM-only. ${installHint}`,
+    projectPath
+  });
+  return loaded && (loaded.__esModule || loaded.default) ? loaded.default : loaded;
+};
+
+/**
+ * Load the plugins `gulp-imagemin` exports by name (gifsicle, mozjpeg, optipng and svgo), each a promise of a plugin
+ * factory, for when they need options of their own (see images.jpegQuality). Resolved like {@link loadImagemin}.
+ * @memberOf module:partials
+ * @param {string} [projectPath=process.cwd()] - The project directory to resolve `gulp-imagemin` from.
+ * @returns {Object<string, Promise<Function>>} The plugin factories, by name.
+ */
+exports.loadImagemin = loadImagemin;
+const loadImageminPlugins = (projectPath = process.cwd()) => (0, _loadPeer.requirePeer)('gulp-imagemin', {
+  task: 'images',
+  installHint,
+  esmOnlyMessage: `gulp-imagemin could not be loaded because it is ESM-only. ${installHint}`,
+  projectPath
+});
+
+// The plugins imagemin runs when it isn't given any, in its own order
+exports.loadImageminPlugins = loadImageminPlugins;
+const defaultPluginNames = ['gifsicle', 'mozjpeg', 'optipng', 'svgo'];
+
+/**
+ * The plugins imagemin uses by default, with mozjpeg set to the given JPEG quality instead of its own default (75).
+ * @memberOf module:partials
+ * @param {number} jpegQuality - The mozjpeg quality, 0 to 100.
+ * @param {Object<string, Promise<Function>>} [plugins=loadImageminPlugins()] - The plugin factories, by name.
+ * @returns {Array<Promise<Function>>} The plugins, in imagemin's default order.
+ */
+const imageminPlugins = (jpegQuality, plugins = loadImageminPlugins()) => defaultPluginNames.map(name => Promise.resolve(plugins[name]).then(makePlugin => name === 'mozjpeg' ? makePlugin({
+  quality: jpegQuality
+}) : makePlugin()));
+
+// The packages that decide imagemin's output: the wrapper and imagemin, then each plugin with the engine it runs
+exports.imageminPlugins = imageminPlugins;
+const imageminPackages = [['gulp-imagemin'], ['imagemin'], ['imagemin-gifsicle', 'gifsicle'], ['imagemin-mozjpeg', 'mozjpeg'], ['imagemin-optipng', 'optipng-bin'], ['imagemin-svgo', 'svgo']];
+
+/**
+ * Find an installed package the way Node does, from a directory up through each node_modules folder. Reads the
+ * package.json directly, so it also works for ESM-only packages that don't export it.
+ * @private
+ * @param {string} name
+ * @param {string} fromDirectory
+ * @returns {{directory: string, version: string}|undefined}
+ */
+const findPackage = (name, fromDirectory) => {
+  for (let directory = _path.default.resolve(fromDirectory);; directory = _path.default.dirname(directory)) {
+    const file = _path.default.join(directory, 'node_modules', name, 'package.json');
+    if ((0, _fs.existsSync)(file)) {
+      return {
+        directory: _path.default.dirname(file),
+        version: JSON.parse((0, _fs.readFileSync)(file, 'utf8')).version
+      };
+    }
+    if (directory === _path.default.dirname(directory)) {
+      return undefined;
+    }
+  }
+};
+
+/**
+ * The installed versions of the packages that decide imagemin's output, so the image cache stops using results made
+ * by older versions after an upgrade (see images.cacheDir).
+ * @memberOf module:partials
+ * @param {string} [projectPath=process.cwd()] - The project directory gulp-imagemin is installed in.
+ * @returns {Object<string, string>} Each package's version by name; a package that isn't installed is left out.
+ */
+const imageminVersions = (projectPath = process.cwd()) => {
+  const gulpImagemin = findPackage('gulp-imagemin', projectPath);
+  const versions = {};
+  if (!gulpImagemin) {
+    return versions;
+  }
+  for (const [wrapper, engine] of imageminPackages) {
+    const found = findPackage(wrapper, gulpImagemin.directory);
+    if (found) {
+      versions[wrapper] = found.version;
+      const engineFound = engine && findPackage(engine, found.directory);
+      if (engineFound) {
+        versions[engine] = engineFound.version;
+      }
+    }
+  }
+  return versions;
+};
+
+/**
+ * Move and optimize images into the browser directory.
+ * @memberOf module:partials
+ * @param {string|array} [imageSrc=src/images/pattern]
+ * @param {string} [imageDest=dest/image/folder]
+ * @return {stream.Stream}
+ */
+exports.imageminVersions = imageminVersions;
+const imagesFor = (imageSrc = gulpConfig.get('images.from'), imageDest = gulpConfig.get('images.to')) => {
+  const imagemin = loadImagemin();
+  const jpegQuality = gulpConfig.get('images.jpegQuality');
+  // Left unset, imagemin runs its default plugins with their own defaults
+  const plugins = jpegQuality ? imageminPlugins(jpegQuality) : undefined;
+  const options = {
+    interlaced: true,
+    silent: true,
+    verbose: false
+  };
+  // Gulp 5 reads files as utf8 text unless told otherwise, which corrupts binary images.
+  return (0, _gulp.src)(imageSrc, {
+    encoding: false
+  }).pipe(
+  // Only images imagemin hasn't optimized before go through it; the rest come from the cache
+  (0, _cacheFiles.cacheFiles)(imagemin(plugins, options), {
+    directory: gulpConfig.get('images.cacheDir'),
+    // Each quality gets results of its own
+    name: jpegQuality ? `jpeg-quality-${jpegQuality}` : 'default',
+    // A new imagemin (or plugin, or engine) version, or other options, makes new results
+    fingerprint: JSON.stringify({
+      options,
+      versions: imageminVersions()
+    })
+  })).pipe((0, _gulp.dest)(imageDest));
+};
 exports.imagesFor = imagesFor;