js-build-tools 6.5.0 → 6.7.0

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,57 +1,94 @@
-"use strict";
-
-require("core-js/modules/esnext.weak-map.delete-all.js");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.loadImagemin = exports.imagesFor = 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;
-};
-
-/**
- * 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.loadImagemin = loadImagemin;
-const imagesFor = (imageSrc = gulpConfig.get('images.from'), imageDest = gulpConfig.get('images.to')) => {
-  const imagemin = loadImagemin();
-  // 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({
-    interlaced: true,
-    silent: true,
-    verbose: false
-  }))).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.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));
+};
 exports.imagesFor = imagesFor;

package/dist/partials/jsdocDocsFor.js

@@ -31,23 +31,23 @@ const escapeHtml = text => String(text).replace(/&/g, '&amp;').replace(/</g, '&l
 const jsdocInstallHint = 'Install it in your project with: npm install --save-dev jsdoc';
 const themeInstallHint = name => `Install it in your project with: npm install --save-dev ${name}`;
 
-/**
- * Resolve the installed directory of an optional peer dependency, from the project being built rather than from
- * this package. Deliberately not requirePeer/importPeer's own `require(name + '/package.json')` approach - that
- * breaks for any package whose own package.json restricts its exports map and does not expose that subpath
- * (clean-jsdoc-theme does; confirmed live, not assumed - resolving its own package.json throws
- * ERR_PACKAGE_PATH_NOT_EXPORTED in plain Node, and a differently-shaped MODULE_NOT_FOUND under Jest's own
- * resolver, which still is not "not installed" either way). Walking Node's own real module-lookup directories
- * (require.resolve.paths) and checking each on disk sidesteps the exports map entirely - this only ever reads
- * whether `<dir>/<name>/package.json` exists, never asks the module system to resolve a restricted subpath.
- * @memberOf module:partials
- * @param {string} name - The package name.
- * @param {Object} options
- * @param {string} options.task
- * @param {string} options.installHint
- * @param {string} [options.projectPath=process.cwd()]
- * @returns {string}
- * @throws {Error} With install instructions when the package is not installed.
+/**
+ * Resolve the installed directory of an optional peer dependency, from the project being built rather than from
+ * this package. Deliberately not requirePeer/importPeer's own `require(name + '/package.json')` approach - that
+ * breaks for any package whose own package.json restricts its exports map and does not expose that subpath
+ * (clean-jsdoc-theme does; confirmed live, not assumed - resolving its own package.json throws
+ * ERR_PACKAGE_PATH_NOT_EXPORTED in plain Node, and a differently-shaped MODULE_NOT_FOUND under Jest's own
+ * resolver, which still is not "not installed" either way). Walking Node's own real module-lookup directories
+ * (require.resolve.paths) and checking each on disk sidesteps the exports map entirely - this only ever reads
+ * whether `<dir>/<name>/package.json` exists, never asks the module system to resolve a restricted subpath.
+ * @memberOf module:partials
+ * @param {string} name - The package name.
+ * @param {Object} options
+ * @param {string} options.task
+ * @param {string} options.installHint
+ * @param {string} [options.projectPath=process.cwd()]
+ * @returns {string}
+ * @throws {Error} With install instructions when the package is not installed.
  */
 const resolvePeerDir = (name, {
   task,
@@ -62,15 +62,15 @@ const resolvePeerDir = (name, {
   return found;
 };
 
-/**
- * Resolve jsdoc's own CLI entry point. jsdoc has no stable programmatic Node API for generating HTML docs (unlike
- * TypeDoc's Application.bootstrap()/convert()/generateDocs()) - gulp-jsdoc3, the established gulp wrapper, is
- * stale, and its own README admits jsdoc does not support piped input in the first place, a real anti-pattern for
- * this project's own gulp-stream conventions. Running its real CLI via child_process is the portable way in -
- * confirmed via `npm view jsdoc bin`, which reports "jsdoc.js" at the package root.
- * @memberOf module:partials
- * @param {string} [projectPath=process.cwd()]
- * @returns {string}
+/**
+ * Resolve jsdoc's own CLI entry point. jsdoc has no stable programmatic Node API for generating HTML docs (unlike
+ * TypeDoc's Application.bootstrap()/convert()/generateDocs()) - gulp-jsdoc3, the established gulp wrapper, is
+ * stale, and its own README admits jsdoc does not support piped input in the first place, a real anti-pattern for
+ * this project's own gulp-stream conventions. Running its real CLI via child_process is the portable way in -
+ * confirmed via `npm view jsdoc bin`, which reports "jsdoc.js" at the package root.
+ * @memberOf module:partials
+ * @param {string} [projectPath=process.cwd()]
+ * @returns {string}
  */
 const resolveJsdocBin = (projectPath = process.cwd()) => _nodePath.default.join(resolvePeerDir('jsdoc', {
   task: 'docs',
@@ -78,14 +78,14 @@ const resolveJsdocBin = (projectPath = process.cwd()) => _nodePath.default.join(
   projectPath
 }), 'jsdoc.js');
 
-/**
- * Resolve a jsdoc theme package's own template directory, for jsdoc's own opts.template config key: the folder
- * holding its publish.js. That is the package root for a classic jsdoc template (clean-jsdoc-theme 4.x included),
- * but `dist` for a bundled one (clean-jsdoc-theme 5.x).
- * @memberOf module:partials
- * @param {string} name
- * @param {string} [projectPath=process.cwd()]
- * @returns {string}
+/**
+ * Resolve a jsdoc theme package's own template directory, for jsdoc's own opts.template config key: the folder
+ * holding its publish.js. That is the package root for a classic jsdoc template (clean-jsdoc-theme 4.x included),
+ * but `dist` for a bundled one (clean-jsdoc-theme 5.x).
+ * @memberOf module:partials
+ * @param {string} name
+ * @param {string} [projectPath=process.cwd()]
+ * @returns {string}
  */
 exports.resolveJsdocBin = resolveJsdocBin;
 const resolveJsdocTheme = (name, projectPath = process.cwd()) => {
@@ -98,18 +98,18 @@ const resolveJsdocTheme = (name, projectPath = process.cwd()) => {
   return _nodeFs.default.existsSync(_nodePath.default.join(distDir, 'publish.js')) ? distDir : packageDir;
 };
 
-/**
- * Generate the HTML documentation of a plain-JavaScript project with jsdoc, using jsdoc.base.js's own shared
- * config (plugins, includePattern/excludePattern) as the starting point rather than a parallel one - the same
- * base a project's own .jsdoc.conf.js has always been able to extend, just with source.include and the output
- * options generated here instead of hand-maintained per project. Configure this with 'docs.from', 'docs.to',
- * 'docs.index', 'docs.theme' and 'docs.title'.
- * @memberOf module:partials
- * @param {string|Array<string>} [srcPath=gulpConfig.get('docs.from')] - The directory (or directories and files) holding
- * the JS source.
- * @param {string} [outPath=gulpConfig.get('docs.to')] - The directory the documentation is generated into (cleared first).
- * @param {function(string, Array<string>): Promise<Object>} [runJsdoc] - Runs the jsdoc CLI, tests can inject a stand-in.
- * @returns {Function} A gulp task, it accepts an optional callback and returns a promise.
+/**
+ * Generate the HTML documentation of a plain-JavaScript project with jsdoc, using jsdoc.base.js's own shared
+ * config (plugins, includePattern/excludePattern) as the starting point rather than a parallel one - the same
+ * base a project's own .jsdoc.conf.js has always been able to extend, just with source.include and the output
+ * options generated here instead of hand-maintained per project. Configure this with 'docs.from', 'docs.to',
+ * 'docs.index', 'docs.theme' and 'docs.title'.
+ * @memberOf module:partials
+ * @param {string|Array<string>} [srcPath=gulpConfig.get('docs.from')] - The directory (or directories and files) holding
+ * the JS source.
+ * @param {string} [outPath=gulpConfig.get('docs.to')] - The directory the documentation is generated into (cleared first).
+ * @param {function(string, Array<string>): Promise<Object>} [runJsdoc] - Runs the jsdoc CLI, tests can inject a stand-in.
+ * @returns {Function} A gulp task, it accepts an optional callback and returns a promise.
  */
 exports.resolveJsdocTheme = resolveJsdocTheme;
 const jsdocDocsFor = (srcPath = gulpConfig.get('docs.from'), outPath = gulpConfig.get('docs.to'), runJsdoc = (bin, args) => execFileAsync(process.execPath, [bin, ...args])) => {

package/dist/partials/lintSource.js

@@ -1,52 +1,52 @@
-"use strict";
-
-require("core-js/modules/esnext.weak-map.delete-all.js");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.lintSource = void 0;
-var gulpConfig = _interopRequireWildcard(require("../../gulp.config.js"));
-var _gulp = require("gulp");
-var _neostandardLint = require("./neostandardLint.js");
-var _nodeStream = require("node:stream");
-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; }
-/**
- * Lint the project's source (srcPath: .js, .mjs and .cjs, plus .ts when typescript.enabled) with neostandard and
- * write the automatic fixes back in place. Shared by the sourceLint (build) and lint (standalone) tasks.
- * @memberOf module:partials
- * @param {Object} [options={}]
- * @param {boolean} [options.failOnError=false] - Fail once linting finishes if any errors could not be fixed.
- * @returns {stream.Stream}
- */
-const lintSource = ({
-  failOnError = false
-} = {}) => {
-  const srcPath = gulpConfig.get('srcPath');
-  const ts = gulpConfig.get('typescript.enabled');
-  const patterns = [`${srcPath}/**/*.{js,mjs,cjs}`];
-  if (ts) {
-    patterns.push(`${srcPath}/**/*.ts`);
-  }
-  const linter = (0, _neostandardLint.neostandardLint)({
-    fix: true,
-    ts,
-    rules: gulpConfig.get('lint.rules')
-  });
-  // Fail only once dest() has written every fixed file: gulp exits as soon as a task fails, so failing from the
-  // linter itself (before dest() finished) could leave a file that dest() had opened, but not yet written, empty.
-  // dest() passes each file on only after writing it, so this last step's flush runs after the final write. Files
-  // are consumed here rather than passed on, so nothing downstream has to read them.
-  const written = new _nodeStream.Transform({
-    objectMode: true,
-    transform: (file, enc, callback) => callback(),
-    flush: callback => failOnError && linter.totals.errors ? callback(new Error(`neostandard found ${linter.totals.errors} lint error(s) that could not be fixed automatically.`)) : callback()
-  });
-  const saved = (0, _gulp.src)(patterns).pipe(linter).pipe((0, _gulp.dest)(srcPath));
-  saved.pipe(written);
-  // pipe() does not forward errors, and gulp only watches the returned stream, so pass any failure along.
-  linter.on('error', error => written.destroy(error));
-  saved.on('error', error => written.destroy(error));
-  return written;
-};
+"use strict";
+
+require("core-js/modules/esnext.weak-map.delete-all.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lintSource = void 0;
+var gulpConfig = _interopRequireWildcard(require("../../gulp.config.js"));
+var _gulp = require("gulp");
+var _neostandardLint = require("./neostandardLint.js");
+var _nodeStream = require("node:stream");
+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; }
+/**
+ * Lint the project's source (srcPath: .js, .mjs and .cjs, plus .ts when typescript.enabled) with neostandard and
+ * write the automatic fixes back in place. Shared by the sourceLint (build) and lint (standalone) tasks.
+ * @memberOf module:partials
+ * @param {Object} [options={}]
+ * @param {boolean} [options.failOnError=false] - Fail once linting finishes if any errors could not be fixed.
+ * @returns {stream.Stream}
+ */
+const lintSource = ({
+  failOnError = false
+} = {}) => {
+  const srcPath = gulpConfig.get('srcPath');
+  const ts = gulpConfig.get('typescript.enabled');
+  const patterns = [`${srcPath}/**/*.{js,mjs,cjs}`];
+  if (ts) {
+    patterns.push(`${srcPath}/**/*.ts`);
+  }
+  const linter = (0, _neostandardLint.neostandardLint)({
+    fix: true,
+    ts,
+    rules: gulpConfig.get('lint.rules')
+  });
+  // Fail only once dest() has written every fixed file: gulp exits as soon as a task fails, so failing from the
+  // linter itself (before dest() finished) could leave a file that dest() had opened, but not yet written, empty.
+  // dest() passes each file on only after writing it, so this last step's flush runs after the final write. Files
+  // are consumed here rather than passed on, so nothing downstream has to read them.
+  const written = new _nodeStream.Transform({
+    objectMode: true,
+    transform: (file, enc, callback) => callback(),
+    flush: callback => failOnError && linter.totals.errors ? callback(new Error(`neostandard found ${linter.totals.errors} lint error(s) that could not be fixed automatically.`)) : callback()
+  });
+  const saved = (0, _gulp.src)(patterns).pipe(linter).pipe((0, _gulp.dest)(srcPath));
+  saved.pipe(written);
+  // pipe() does not forward errors, and gulp only watches the returned stream, so pass any failure along.
+  linter.on('error', error => written.destroy(error));
+  saved.on('error', error => written.destroy(error));
+  return written;
+};
 exports.lintSource = lintSource;

package/dist/partials/loadPeer.js

@@ -1,100 +1,100 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.requirePeer = exports.importPeer = exports.importModule = void 0;
-require("core-js/modules/es.array.includes.js");
-var _nodeModule = require("node:module");
-var _nodePath = _interopRequireDefault(require("node:path"));
-var _nodeUrl = require("node:url");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// Several dependencies ship ESM-only (standard, gulp-ts-compile, typedoc), but this package also publishes a CommonJS
-// build (dist/*.js) whose babel transform would turn even a dynamic import() into a require() that cannot load an ES
-// module. Hiding the import() inside a Function constructor keeps it a genuine dynamic import that works from either
-// build, because babel cannot see (and so cannot rewrite) an import expression which only exists as a runtime string.
-// eslint-disable-next-line no-new-func -- deliberate, see above
-const dynamicImport = new Function('specifier', 'return import(specifier)');
-
-/**
- * Import an ES module (or any module) with a real dynamic import(), whichever build (ESM or CommonJS) this runs from.
- * @memberOf module:partials
- * @param {string} specifier - The package name, or the URL of a file.
- * @returns {Promise<Object>} The module namespace.
- */
-const importModule = specifier => dynamicImport(specifier);
-exports.importModule = importModule;
-const isMissing = (error, name) => error.code === 'MODULE_NOT_FOUND' && error.message.includes(`'${name}'`);
-const notInstalled = (name, {
-  task,
-  installHint
-}) => new Error(`The ${task} task needs the optional peer dependency ${name}, which is not installed. ${installHint}`);
-
-/**
- * Load an optional peer dependency (one which is only needed once a task runs, so projects which never use that task
- * do not have to install it) with require(), from the project being built rather than from this package. When it is
- * missing the error explains how to install it.
- * @memberOf module:partials
- * @param {string} name - The package name.
- * @param {Object} options
- * @param {string} options.task - The task which needs the package, for the error message.
- * @param {string} options.installHint - How to install it, for the error message.
- * @param {string} [options.esmOnlyMessage] - The error message when the package turns out to be ESM-only (it cannot be require()d).
- * @param {string} [options.projectPath=process.cwd()] - The folder of the project (which has the package.json) being built.
- * @returns {*} Whatever the package exports.
- * @throws {Error} With install instructions when the package is not installed.
- */
-const requirePeer = (name, {
-  task,
-  installHint,
-  esmOnlyMessage,
-  projectPath = process.cwd()
-}) => {
-  try {
-    return (0, _nodeModule.createRequire)(_nodePath.default.join(projectPath, 'package.json'))(name);
-  } catch (error) {
-    if (isMissing(error, name)) {
-      throw notInstalled(name, {
-        task,
-        installHint
-      });
-    }
-    if (error.code === 'ERR_REQUIRE_ESM' && esmOnlyMessage) {
-      throw new Error(esmOnlyMessage);
-    }
-    throw error;
-  }
-};
-
-/**
- * Import an optional peer dependency which ships ESM-only, from the project being built. See {@link requirePeer}.
- * @memberOf module:partials
- * @param {string} name - The package name.
- * @param {Object} options
- * @param {string} options.task - The task which needs the package, for the error message.
- * @param {string} options.installHint - How to install it, for the error message.
- * @param {string} [options.projectPath=process.cwd()] - The folder of the project (which has the package.json) being built.
- * @returns {Promise<Object>} The module namespace.
- * @throws {Error} With install instructions when the package is not installed.
- */
-exports.requirePeer = requirePeer;
-const importPeer = async (name, {
-  task,
-  installHint,
-  projectPath = process.cwd()
-}) => {
-  let resolved;
-  try {
-    resolved = (0, _nodeModule.createRequire)(_nodePath.default.join(projectPath, 'package.json')).resolve(name);
-  } catch (error) {
-    if (isMissing(error, name)) {
-      throw notInstalled(name, {
-        task,
-        installHint
-      });
-    }
-    throw error;
-  }
-  return importModule((0, _nodeUrl.pathToFileURL)(resolved).href);
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requirePeer = exports.importPeer = exports.importModule = void 0;
+require("core-js/modules/es.array.includes.js");
+var _nodeModule = require("node:module");
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _nodeUrl = require("node:url");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Several dependencies ship ESM-only (standard, gulp-ts-compile, typedoc), but this package also publishes a CommonJS
+// build (dist/*.js) whose babel transform would turn even a dynamic import() into a require() that cannot load an ES
+// module. Hiding the import() inside a Function constructor keeps it a genuine dynamic import that works from either
+// build, because babel cannot see (and so cannot rewrite) an import expression which only exists as a runtime string.
+// eslint-disable-next-line no-new-func -- deliberate, see above
+const dynamicImport = new Function('specifier', 'return import(specifier)');
+
+/**
+ * Import an ES module (or any module) with a real dynamic import(), whichever build (ESM or CommonJS) this runs from.
+ * @memberOf module:partials
+ * @param {string} specifier - The package name, or the URL of a file.
+ * @returns {Promise<Object>} The module namespace.
+ */
+const importModule = specifier => dynamicImport(specifier);
+exports.importModule = importModule;
+const isMissing = (error, name) => error.code === 'MODULE_NOT_FOUND' && error.message.includes(`'${name}'`);
+const notInstalled = (name, {
+  task,
+  installHint
+}) => new Error(`The ${task} task needs the optional peer dependency ${name}, which is not installed. ${installHint}`);
+
+/**
+ * Load an optional peer dependency (one which is only needed once a task runs, so projects which never use that task
+ * do not have to install it) with require(), from the project being built rather than from this package. When it is
+ * missing the error explains how to install it.
+ * @memberOf module:partials
+ * @param {string} name - The package name.
+ * @param {Object} options
+ * @param {string} options.task - The task which needs the package, for the error message.
+ * @param {string} options.installHint - How to install it, for the error message.
+ * @param {string} [options.esmOnlyMessage] - The error message when the package turns out to be ESM-only (it cannot be require()d).
+ * @param {string} [options.projectPath=process.cwd()] - The folder of the project (which has the package.json) being built.
+ * @returns {*} Whatever the package exports.
+ * @throws {Error} With install instructions when the package is not installed.
+ */
+const requirePeer = (name, {
+  task,
+  installHint,
+  esmOnlyMessage,
+  projectPath = process.cwd()
+}) => {
+  try {
+    return (0, _nodeModule.createRequire)(_nodePath.default.join(projectPath, 'package.json'))(name);
+  } catch (error) {
+    if (isMissing(error, name)) {
+      throw notInstalled(name, {
+        task,
+        installHint
+      });
+    }
+    if (error.code === 'ERR_REQUIRE_ESM' && esmOnlyMessage) {
+      throw new Error(esmOnlyMessage);
+    }
+    throw error;
+  }
+};
+
+/**
+ * Import an optional peer dependency which ships ESM-only, from the project being built. See {@link requirePeer}.
+ * @memberOf module:partials
+ * @param {string} name - The package name.
+ * @param {Object} options
+ * @param {string} options.task - The task which needs the package, for the error message.
+ * @param {string} options.installHint - How to install it, for the error message.
+ * @param {string} [options.projectPath=process.cwd()] - The folder of the project (which has the package.json) being built.
+ * @returns {Promise<Object>} The module namespace.
+ * @throws {Error} With install instructions when the package is not installed.
+ */
+exports.requirePeer = requirePeer;
+const importPeer = async (name, {
+  task,
+  installHint,
+  projectPath = process.cwd()
+}) => {
+  let resolved;
+  try {
+    resolved = (0, _nodeModule.createRequire)(_nodePath.default.join(projectPath, 'package.json')).resolve(name);
+  } catch (error) {
+    if (isMissing(error, name)) {
+      throw notInstalled(name, {
+        task,
+        installHint
+      });
+    }
+    throw error;
+  }
+  return importModule((0, _nodeUrl.pathToFileURL)(resolved).href);
+};
 exports.importPeer = importPeer;