js-build-tools 6.6.0 → 6.8.0

package/dist/partials/neostandardLint.js

@@ -1,176 +1,176 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.neostandardLint = void 0;
-require("core-js/modules/esnext.iterator.constructor.js");
-require("core-js/modules/esnext.iterator.for-each.js");
-var _nodeFs = _interopRequireDefault(require("node:fs"));
-var _nodePath = _interopRequireDefault(require("node:path"));
-var _through = _interopRequireDefault(require("through2"));
-var _eslint = require("eslint");
-var _loadPeer = require("./loadPeer.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// neostandard (js-build-tools' chosen style - a maintained, TypeScript-aware successor to `standard`, see
-// https://github.com/neostandard/neostandard) ships ESM-only, see importModule for how it is imported.
-const importNeostandard = () => (0, _loadPeer.importModule)('neostandard');
-
-/**
- * Read the `env` a project already declared for Standard (the `standard` field in its package.json), so a project
- * migrating from `standard` keeps its globals (jest, browser, ...) without touching package.json.
- * @param {string} cwd
- * @returns {Array<string>}
- * @private
- */
-const readEnv = cwd => {
-  try {
-    return JSON.parse(_nodeFs.default.readFileSync(_nodePath.default.join(cwd, 'package.json'), 'utf8')).standard?.env ?? [];
-  } catch {
-    return [];
-  }
-};
-
-/**
- * Build an ESLint instance configured with neostandard, honoring the project's own package.json `standard.env`,
- * plus an optional layer of rule overrides (see gulp.config.mjs's `lint.rules`) for a rule that is wrong for this
- * project specifically rather than something to fix in its code - for example a test fixture whose content
- * neostandard mistakes for a real syntax problem. Scoped to the same files neostandard itself lints (its own
- * `defaultFilePatterns.all`), per neostandard's own guidance: an unscoped rule-tweak layer would otherwise apply
- * to every lintable file, including ones from an unrelated plugin this project never defined.
- * @param {Object} options
- * @param {string} options.cwd
- * @param {boolean} options.ts
- * @param {boolean} options.fix
- * @param {Object<string, *>} [options.rules={}]
- * @returns {Promise<ESLint>} eslint's ESLint instance
- * @private
- */
-const buildEslint = async ({
-  cwd,
-  ts,
-  fix,
-  rules = {}
-}) => {
-  const {
-    neostandard,
-    defaultFilePatterns
-  } = await importNeostandard();
-  const baseConfig = neostandard({
-    ts,
-    env: readEnv(cwd)
-  });
-  if (Object.keys(rules).length) {
-    baseConfig.push({
-      files: defaultFilePatterns.all,
-      rules
-    });
-  }
-  return new _eslint.ESLint({
-    cwd,
-    fix,
-    overrideConfigFile: true,
-    baseConfig
-  });
-};
-
-/**
- * Print a file's lint messages, if it has any.
- * @memberOf module:partials
- * @param {Vinyl} file
- * @param {{messages: Array<{line: number, column: number, message: string}>, errorCount: number, warningCount: number}} result
- * @returns {undefined}
- */
-const printFileReport = (file, result) => {
-  if (!result.messages.length) {
-    return;
-  }
-  console.log(_nodePath.default.relative(file.cwd, file.path));
-  result.messages.forEach(({
-    line,
-    column,
-    message
-  }) => console.log(`line ${line}:${column}\t${message}`));
-  console.log(`✖ ${result.errorCount} error\t⚠ ${result.warningCount} warning\n`);
-};
-
-/**
- * Lint every file streaming through with neostandard and, unless `fix` is false, apply the automatic fixes to the
- * file's contents so a following `dest()` writes the fixed version. Remaining problems are printed along with a
- * summary once the stream ends; they only fail the stream when `failOnError` is set (the standalone `lint` task),
- * never during `build`.
- *
- * One ESLint instance is built from the first file's own cwd and reused for the rest of the stream, since every
- * file in a given lint pass shares the same project (and so the same config).
- * @memberOf module:partials
- * @param {Object} [options={}]
- * @param {boolean} [options.fix=true] - Apply neostandard's automatic fixes to the file contents.
- * @param {boolean} [options.ts=false] - Lint `.ts` files too, with type-aware rules (see neostandard's `ts` option).
- * @param {Object<string, *>} [options.rules={}] - ESLint rule overrides layered on top of neostandard's own rules
- * (see gulp.config.mjs's `lint.rules`).
- * @param {boolean} [options.failOnError=false] - Emit an error once the stream ends if any lint errors remain after
- * fixing, so a command-line run exits non-zero.
- * @param {function(Object): Promise<{lintText: Function}>} [loadEslint] - Resolves an ESLint-shaped linter. Real
- * callers should never need to pass this - it exists so tests can supply a stand-in, since this project's
- * CommonJS-transform-based Jest setup cannot execute a real dynamic import() of neostandard (ESM-only).
- * @returns {stream.Transform} With a `totals` property ({errors, warnings}), complete once the stream ends.
- */
-const neostandardLint = ({
-  fix = true,
-  ts = false,
-  rules = {},
-  failOnError = false
-} = {}, loadEslint = buildEslint) => {
-  const totals = {
-    errors: 0,
-    warnings: 0
-  };
-  let eslintPromise = null;
-  const linter = _through.default.obj(function (file, enc, callback) {
-    if (file.isNull()) {
-      callback(null, file);
-      return;
-    }
-    if (file.isStream()) {
-      callback(new Error('neostandardLint: streaming file contents are not supported.'));
-      return;
-    }
-    if (!eslintPromise) {
-      eslintPromise = loadEslint({
-        cwd: file.cwd,
-        ts,
-        fix,
-        rules
-      });
-    }
-    eslintPromise.then(eslint => eslint.lintText(file.contents.toString(), {
-      filePath: file.path
-    })).then(results => {
-      // No result at all means the file is ignored by the project's ESLint configuration.
-      const [result] = results;
-      if (result) {
-        if (typeof result.output === 'string') {
-          file.contents = Buffer.from(result.output);
-        }
-        totals.errors += result.errorCount;
-        totals.warnings += result.warningCount;
-        printFileReport(file, result);
-      }
-      callback(null, file);
-    }, callback);
-  }, function (callback) {
-    console.log('neostandard linter results');
-    console.log('======================================');
-    console.log(`✖ Errors total: ${totals.errors}`);
-    console.log(`⚠ Warnings total: ${totals.warnings}\n`);
-    if (failOnError && totals.errors) {
-      callback(new Error(`neostandard found ${totals.errors} lint error(s) that could not be fixed automatically.`));
-      return;
-    }
-    callback();
-  });
-  // Read by lintSource, which can only fail once the fixed files have been written, after this stream has ended.
-  linter.totals = totals;
-  return linter;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.neostandardLint = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+var _nodeFs = _interopRequireDefault(require("node:fs"));
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _through = _interopRequireDefault(require("through2"));
+var _eslint = require("eslint");
+var _loadPeer = require("./loadPeer.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// neostandard (js-build-tools' chosen style - a maintained, TypeScript-aware successor to `standard`, see
+// https://github.com/neostandard/neostandard) ships ESM-only, see importModule for how it is imported.
+const importNeostandard = () => (0, _loadPeer.importModule)('neostandard');
+
+/**
+ * Read the `env` a project already declared for Standard (the `standard` field in its package.json), so a project
+ * migrating from `standard` keeps its globals (jest, browser, ...) without touching package.json.
+ * @param {string} cwd
+ * @returns {Array<string>}
+ * @private
+ */
+const readEnv = cwd => {
+  try {
+    return JSON.parse(_nodeFs.default.readFileSync(_nodePath.default.join(cwd, 'package.json'), 'utf8')).standard?.env ?? [];
+  } catch {
+    return [];
+  }
+};
+
+/**
+ * Build an ESLint instance configured with neostandard, honoring the project's own package.json `standard.env`,
+ * plus an optional layer of rule overrides (see gulp.config.mjs's `lint.rules`) for a rule that is wrong for this
+ * project specifically rather than something to fix in its code - for example a test fixture whose content
+ * neostandard mistakes for a real syntax problem. Scoped to the same files neostandard itself lints (its own
+ * `defaultFilePatterns.all`), per neostandard's own guidance: an unscoped rule-tweak layer would otherwise apply
+ * to every lintable file, including ones from an unrelated plugin this project never defined.
+ * @param {Object} options
+ * @param {string} options.cwd
+ * @param {boolean} options.ts
+ * @param {boolean} options.fix
+ * @param {Object<string, *>} [options.rules={}]
+ * @returns {Promise<ESLint>} eslint's ESLint instance
+ * @private
+ */
+const buildEslint = async ({
+  cwd,
+  ts,
+  fix,
+  rules = {}
+}) => {
+  const {
+    neostandard,
+    defaultFilePatterns
+  } = await importNeostandard();
+  const baseConfig = neostandard({
+    ts,
+    env: readEnv(cwd)
+  });
+  if (Object.keys(rules).length) {
+    baseConfig.push({
+      files: defaultFilePatterns.all,
+      rules
+    });
+  }
+  return new _eslint.ESLint({
+    cwd,
+    fix,
+    overrideConfigFile: true,
+    baseConfig
+  });
+};
+
+/**
+ * Print a file's lint messages, if it has any.
+ * @memberOf module:partials
+ * @param {Vinyl} file
+ * @param {{messages: Array<{line: number, column: number, message: string}>, errorCount: number, warningCount: number}} result
+ * @returns {undefined}
+ */
+const printFileReport = (file, result) => {
+  if (!result.messages.length) {
+    return;
+  }
+  console.log(_nodePath.default.relative(file.cwd, file.path));
+  result.messages.forEach(({
+    line,
+    column,
+    message
+  }) => console.log(`line ${line}:${column}\t${message}`));
+  console.log(`✖ ${result.errorCount} error\t⚠ ${result.warningCount} warning\n`);
+};
+
+/**
+ * Lint every file streaming through with neostandard and, unless `fix` is false, apply the automatic fixes to the
+ * file's contents so a following `dest()` writes the fixed version. Remaining problems are printed along with a
+ * summary once the stream ends; they only fail the stream when `failOnError` is set (the standalone `lint` task),
+ * never during `build`.
+ *
+ * One ESLint instance is built from the first file's own cwd and reused for the rest of the stream, since every
+ * file in a given lint pass shares the same project (and so the same config).
+ * @memberOf module:partials
+ * @param {Object} [options={}]
+ * @param {boolean} [options.fix=true] - Apply neostandard's automatic fixes to the file contents.
+ * @param {boolean} [options.ts=false] - Lint `.ts` files too, with type-aware rules (see neostandard's `ts` option).
+ * @param {Object<string, *>} [options.rules={}] - ESLint rule overrides layered on top of neostandard's own rules
+ * (see gulp.config.mjs's `lint.rules`).
+ * @param {boolean} [options.failOnError=false] - Emit an error once the stream ends if any lint errors remain after
+ * fixing, so a command-line run exits non-zero.
+ * @param {function(Object): Promise<{lintText: Function}>} [loadEslint] - Resolves an ESLint-shaped linter. Real
+ * callers should never need to pass this - it exists so tests can supply a stand-in, since this project's
+ * CommonJS-transform-based Jest setup cannot execute a real dynamic import() of neostandard (ESM-only).
+ * @returns {stream.Transform} With a `totals` property ({errors, warnings}), complete once the stream ends.
+ */
+const neostandardLint = ({
+  fix = true,
+  ts = false,
+  rules = {},
+  failOnError = false
+} = {}, loadEslint = buildEslint) => {
+  const totals = {
+    errors: 0,
+    warnings: 0
+  };
+  let eslintPromise = null;
+  const linter = _through.default.obj(function (file, enc, callback) {
+    if (file.isNull()) {
+      callback(null, file);
+      return;
+    }
+    if (file.isStream()) {
+      callback(new Error('neostandardLint: streaming file contents are not supported.'));
+      return;
+    }
+    if (!eslintPromise) {
+      eslintPromise = loadEslint({
+        cwd: file.cwd,
+        ts,
+        fix,
+        rules
+      });
+    }
+    eslintPromise.then(eslint => eslint.lintText(file.contents.toString(), {
+      filePath: file.path
+    })).then(results => {
+      // No result at all means the file is ignored by the project's ESLint configuration.
+      const [result] = results;
+      if (result) {
+        if (typeof result.output === 'string') {
+          file.contents = Buffer.from(result.output);
+        }
+        totals.errors += result.errorCount;
+        totals.warnings += result.warningCount;
+        printFileReport(file, result);
+      }
+      callback(null, file);
+    }, callback);
+  }, function (callback) {
+    console.log('neostandard linter results');
+    console.log('======================================');
+    console.log(`✖ Errors total: ${totals.errors}`);
+    console.log(`⚠ Warnings total: ${totals.warnings}\n`);
+    if (failOnError && totals.errors) {
+      callback(new Error(`neostandard found ${totals.errors} lint error(s) that could not be fixed automatically.`));
+      return;
+    }
+    callback();
+  });
+  // Read by lintSource, which can only fail once the fixed files have been written, after this stream has ended.
+  linter.totals = totals;
+  return linter;
+};
 exports.neostandardLint = neostandardLint;

package/dist/partials/readmeTemplate.js

@@ -11,10 +11,10 @@ var _gulpRename = _interopRequireDefault(require("gulp-rename"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 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; }
-/**
- * Copy a readme template into the README.md file.
- * @memberOf module:partials
- * @returns {*}
+/**
+ * Copy a readme template into the README.md file.
+ * @memberOf module:partials
+ * @returns {*}
  */
 const readmeTemplate = () => (0, _gulp.src)(gulpConfig.get('readme.template')).pipe((0, _gulpRename.default)(gulpConfig.get('readme.file'))).pipe((0, _gulp.dest)(gulpConfig.get('readme.to')));
 exports.readmeTemplate = readmeTemplate;

package/dist/partials/removeDirectory.js

@@ -9,17 +9,17 @@ var _promises2 = require("node:timers/promises");
 const attempts = 4;
 const exists = dirPath => (0, _promises.access)(dirPath).then(() => true, () => false);
 
-/**
- * Delete a directory and everything in it, resolving only once it is really gone.
- *
- * A single rm can leave a directory behind - most often when something is still writing into it (a build task, a
- * watcher, a dev server) or has it briefly locked (EBUSY/EPERM/ENOTEMPTY) - which silently leaves stale output for
- * the next build. So: Node's own retry-with-back-off handles the transient errors, then the directory is checked and
- * removed again if it was recreated, and a clear error is raised rather than carrying on with stale output.
- * @memberOf module:partials
- * @param {string} dirPath
- * @returns {Promise<string>} Resolves with dirPath once the directory no longer exists (or already didn't).
- * @throws {Error} If the directory still exists after several attempts.
+/**
+ * Delete a directory and everything in it, resolving only once it is really gone.
+ *
+ * A single rm can leave a directory behind - most often when something is still writing into it (a build task, a
+ * watcher, a dev server) or has it briefly locked (EBUSY/EPERM/ENOTEMPTY) - which silently leaves stale output for
+ * the next build. So: Node's own retry-with-back-off handles the transient errors, then the directory is checked and
+ * removed again if it was recreated, and a clear error is raised rather than carrying on with stale output.
+ * @memberOf module:partials
+ * @param {string} dirPath
+ * @returns {Promise<string>} Resolves with dirPath once the directory no longer exists (or already didn't).
+ * @throws {Error} If the directory still exists after several attempts.
  */
 const removeDirectory = async dirPath => {
   for (let attempt = 1; attempt <= attempts; attempt++) {

package/dist/partials/resolveDocsMethod.js

@@ -8,12 +8,12 @@ exports.resolveDocsMethod = 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; }
-/**
- * Pick which engine generates the HTML documentation: docs.method picks it explicitly; left unset (false, the
- * default), it's inferred from typescript.enabled - every existing TypeScript project's config, which never
- * sets method, keeps producing TypeDoc output exactly as it always has.
- * @memberOf module:partials
- * @returns {'typedoc'|'jsdoc'}
+/**
+ * Pick which engine generates the HTML documentation: docs.method picks it explicitly; left unset (false, the
+ * default), it's inferred from typescript.enabled - every existing TypeScript project's config, which never
+ * sets method, keeps producing TypeDoc output exactly as it always has.
+ * @memberOf module:partials
+ * @returns {'typedoc'|'jsdoc'}
  */
 const resolveDocsMethod = () => gulpConfig.get('docs.method') || (gulpConfig.get('typescript.enabled') ? 'typedoc' : 'jsdoc');
 exports.resolveDocsMethod = resolveDocsMethod;

package/dist/partials/runOnChange.js

@@ -12,42 +12,42 @@ var _gulp = require("gulp");
 var _testQuick = require("../testQuick.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; }
-/**
- * Run this function when the watched files are modified.
- * 1. Find the sub-folders within src path
- * 2. Maintain the folders, but use distPath for base
- * 3. Remove base folder and return dist path with correct sub-folders
- * @example
- * // Configured paths
- * distPath = 'dist'
- * srcPath = 'functions'
- *
- * // Path parameter
- * path = 'functions/some/path/file.js'
- *
- * // Generated regex using configured srcPath
- * pathRegex = '/^functions(.*\/).+\.js$/i'
- *
- * // Replace value using the configured distPath
- * replacePath = 'dist$1'
- *
- * // The resulting replaced path for the destination folder
- * distPathResult = 'dist/some/path/'
- * @memberOf module:partials
- * @param {string} path
- * @returns {stream.Stream}
+/**
+ * Run this function when the watched files are modified.
+ * 1. Find the sub-folders within src path
+ * 2. Maintain the folders, but use distPath for base
+ * 3. Remove base folder and return dist path with correct sub-folders
+ * @example
+ * // Configured paths
+ * distPath = 'dist'
+ * srcPath = 'functions'
+ *
+ * // Path parameter
+ * path = 'functions/some/path/file.js'
+ *
+ * // Generated regex using configured srcPath
+ * pathRegex = '/^functions(.*\/).+\.js$/i'
+ *
+ * // Replace value using the configured distPath
+ * replacePath = 'dist$1'
+ *
+ * // The resulting replaced path for the destination folder
+ * distPathResult = 'dist/some/path/'
+ * @memberOf module:partials
+ * @param {string} path
+ * @returns {stream.Stream}
  */
 const runOnChange = path => {
   const useTs = gulpConfig.get('typescript.enabled');
   const distPath = gulpConfig.get('dist.to');
   const srcPath = gulpConfig.get('srcPath');
-  /**
-   * 1. The original path comes in from src and is a .ts
-   * 2. Discover the outgoing dist path where that file should go
-   * 3. Use the path and dist in tsFor
-   * 4. Take the original path, convert to full file path in dist
-   * 5. Use the dist path found previously in #2
-   * 6. Use the full dist path and the dist outgoing path in distFor
+  /**
+   * 1. The original path comes in from src and is a .ts
+   * 2. Discover the outgoing dist path where that file should go
+   * 3. Use the path and dist in tsFor
+   * 4. Take the original path, convert to full file path in dist
+   * 5. Use the dist path found previously in #2
+   * 6. Use the full dist path and the dist outgoing path in distFor
    */
   const pathRegex = new RegExp(`^${srcPath}(.*\\/)(.+)\\.(js|ts)$`, 'i');
   const distPathResult = path.replace(pathRegex, `${distPath}$1`);

package/dist/partials/sassFor.js

@@ -18,12 +18,12 @@ 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; }
 const runSass = (0, _gulpSass.default)(sass);
 
-/**
- * Build the CSS for a given source pattern.
- * @memberOf module:partials
- * @param {string|array} [srcSearch='src/config/path/sass/for']
- * @param {string} [cssPath='css/config/path']
- * @returns {stream.Stream}
+/**
+ * Build the CSS for a given source pattern.
+ * @memberOf module:partials
+ * @param {string|array} [srcSearch='src/config/path/sass/for']
+ * @param {string} [cssPath='css/config/path']
+ * @returns {stream.Stream}
  */
 const sassFor = (srcSearch = gulpConfig.get('sass.from'), cssPath = gulpConfig.get('sass.to')) => (0, _gulp.src)(srcSearch).pipe(runSass().on('error', runSass.logError)) // Passes it through a gulp-sass, log errors to console
 .pipe((0, _gulp.dest)(cssPath))

package/dist/partials/serveStatic.js

@@ -26,15 +26,15 @@ const contentTypes = {
   '.woff2': 'font/woff2'
 };
 
-/**
- * Serve a directory's real files over plain HTTP, for anything that needs a page loaded from a real URL rather
- * than a bare file:// path - most commonly, a page using root-relative asset paths (/browser/...), which a
- * file:// load resolves against the filesystem root instead of the page's own directory.
- * @memberOf module:partials
- * @param {string} rootDir - The directory to serve.
- * @param {number} [port=0] - The port to listen on; 0 picks any free port.
- * @returns {Promise<{server: http.Server, url: string}>} The running server, and its base URL - close the
- * server yourself (server.close()) once done with it.
+/**
+ * Serve a directory's real files over plain HTTP, for anything that needs a page loaded from a real URL rather
+ * than a bare file:// path - most commonly, a page using root-relative asset paths (/browser/...), which a
+ * file:// load resolves against the filesystem root instead of the page's own directory.
+ * @memberOf module:partials
+ * @param {string} rootDir - The directory to serve.
+ * @param {number} [port=0] - The port to listen on; 0 picks any free port.
+ * @returns {Promise<{server: http.Server, url: string}>} The running server, and its base URL - close the
+ * server yourself (server.close()) once done with it.
  */
 const serveStatic = (rootDir, port = 0) => new Promise((resolve, reject) => {
   const server = _nodeHttp.default.createServer((req, res) => {

package/dist/partials/tsFor.js

@@ -15,21 +15,21 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 // gulp-ts-compile ships ESM-only (no CJS build - see its own package.json), see importModule for how it is imported.
 const importGulpTsCompile = () => (0, _loadPeer.importModule)('gulp-ts-compile');
 
-/**
- * Wrap a stream in a promise that resolves once it finishes writing.
- * @memberOf module:partials
- * @param {stream.Stream} stream
- * @returns {Promise<void>}
+/**
+ * Wrap a stream in a promise that resolves once it finishes writing.
+ * @memberOf module:partials
+ * @param {stream.Stream} stream
+ * @returns {Promise<void>}
  */
 const installHint = 'Install it in your project with: npm install --save-dev typescript';
 
-/**
- * Load the project's own copy of TypeScript (an optional peer dependency, only needed when the typescript task is
- * enabled) from the project being built, so projects which do not use TypeScript never need it installed.
- * @memberOf module:partials
- * @param {string} [projectPath=process.cwd()] The folder of the project (which has the package.json) being built.
- * @returns {Object} The TypeScript compiler API module.
- * @throws {Error} With install instructions when typescript is not installed.
+/**
+ * Load the project's own copy of TypeScript (an optional peer dependency, only needed when the typescript task is
+ * enabled) from the project being built, so projects which do not use TypeScript never need it installed.
+ * @memberOf module:partials
+ * @param {string} [projectPath=process.cwd()] The folder of the project (which has the package.json) being built.
+ * @returns {Object} The TypeScript compiler API module.
+ * @throws {Error} With install instructions when typescript is not installed.
  */
 const loadTypescript = (projectPath = process.cwd()) => (0, _loadPeer.requirePeer)('typescript', {
   task: 'typescript',
@@ -42,14 +42,14 @@ const streamToPromise = stream => new Promise((resolve, reject) => {
   stream.on('error', reject);
 });
 
-/**
- * Read a tsconfig.json file into real typescript.CompilerOptions values, using only TypeScript's stable, current,
- * public config-reading API (the same one `tsc --project` itself uses internally) - never
- * `ts.convertCompilerOptionsFromJson`, which is exactly the kind of internal/legacy surface that broke
- * gulp-typescript when a removed API call started throwing under TypeScript 7.
- * @memberOf module:partials
- * @param {string} configPath - Path to a tsconfig.json file.
- * @returns {ts.CompilerOptions} TypeScript's compiler options
+/**
+ * Read a tsconfig.json file into real typescript.CompilerOptions values, using only TypeScript's stable, current,
+ * public config-reading API (the same one `tsc --project` itself uses internally) - never
+ * `ts.convertCompilerOptionsFromJson`, which is exactly the kind of internal/legacy surface that broke
+ * gulp-typescript when a removed API call started throwing under TypeScript 7.
+ * @memberOf module:partials
+ * @param {string} configPath - Path to a tsconfig.json file.
+ * @returns {ts.CompilerOptions} TypeScript's compiler options
  */
 const readCompilerOptions = (ts, configPath) => {
   const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
@@ -57,18 +57,18 @@ const readCompilerOptions = (ts, configPath) => {
   return parsedConfig.options;
 };
 
-/**
- * Starting at the source directory, find all the ts files and convert them into the distribution directory.
- * @memberOf module:partials
- * @param {string|array} [srcPath='']
- * @param {string} [distPath='']
- * @param {function(): Promise<Function>} [loadTsCompile] - Resolves the `gulp-ts-compile` default export. Real
- * callers should never need to pass this - it exists so tests can inject a stand-in compiler, sidestepping the
- * genuine dynamic `import()` above that this project's current CommonJS-transform-based Jest setup cannot
- * execute without a broader (and riskier) migration to Jest's native ESM support. gulp-ts-compile's own test
- * suite already covers real TypeScript-compile correctness - this function's own tests only need to verify its
- * config resolution and stream wiring.
- * @returns {Function}
+/**
+ * Starting at the source directory, find all the ts files and convert them into the distribution directory.
+ * @memberOf module:partials
+ * @param {string|array} [srcPath='']
+ * @param {string} [distPath='']
+ * @param {function(): Promise<Function>} [loadTsCompile] - Resolves the `gulp-ts-compile` default export. Real
+ * callers should never need to pass this - it exists so tests can inject a stand-in compiler, sidestepping the
+ * genuine dynamic `import()` above that this project's current CommonJS-transform-based Jest setup cannot
+ * execute without a broader (and riskier) migration to Jest's native ESM support. gulp-ts-compile's own test
+ * suite already covers real TypeScript-compile correctness - this function's own tests only need to verify its
+ * config resolution and stream wiring.
+ * @returns {Function}
  */
 const tsFor = (srcPath = gulpConfig.get('typescript.from'), distPath = gulpConfig.get('typescript.to'), loadTsCompile = () => importGulpTsCompile().then(({
   default: tsCompile