js-build-tools 5.6.0 → 6.0.0

package/dist/images.js

@@ -1,14 +1,14 @@
-'use strict'
+"use strict";
 
-Object.defineProperty(exports, '__esModule', {
+Object.defineProperty(exports, "__esModule", {
   value: true
-})
-exports.images = void 0
-const _imagesFor = require('./partials/imagesFor.js')
+});
+exports.images = void 0;
+var _imagesFor = require("./partials/imagesFor.js");
 /**
  * Move and optimize the images into the browser folder using configured settings.
  * @memberOf module:js-build-tools
  * @return {stream.Stream}
  */
-const images = () => (0, _imagesFor.imagesFor)()
-exports.images = images
+const images = () => (0, _imagesFor.imagesFor)();
+exports.images = images;

package/dist/partials/addToReadme.js

@@ -9,15 +9,26 @@ var _fs = _interopRequireDefault(require("fs"));
 var gulpConfig = _interopRequireWildcard(require("../../gulp.config.js"));
 var _jsdocToMarkdown = _interopRequireDefault(require("jsdoc-to-markdown"));
 var _glob = require("glob");
+var _convertMjsFilesForDocs = require("../utilities/convertMjsFilesForDocs.js");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * Appends all the jsdoc comments to the readme file. Assumes empty or templated file.
  * Configure this with 'readmeSearch', 'readmePath', 'readmeFile', and 'readmeOptions'.
+ *
+ * jsdoc-to-markdown only recognizes `.js` files, even though it parses real ESM syntax just fine once it reads
+ * one - `readme.fromEsm` (empty by default) names `.mjs` files to include anyway, converted on the fly (see
+ * {@link convertMjsFilesForDocs}) and cleaned up again once this has read them, win or lose.
  * @memberOf module:partials
  * @returns {string|Uint8Array}
  */
-const addToReadme = () => _jsdocToMarkdown.default.render({
-  files: (0, _glob.globSync)(gulpConfig.get('readme.from'))
-}).then(readme => _fs.default.appendFileSync(gulpConfig.get('readme.to') + gulpConfig.get('readme.file'), readme, gulpConfig.get('readmeOptions')));
+const addToReadme = () => {
+  const {
+    filePaths: esmFilePaths,
+    cleanUp
+  } = (0, _convertMjsFilesForDocs.convertMjsFilesForDocs)((0, _glob.globSync)(gulpConfig.get('readme.fromEsm') || []));
+  return _jsdocToMarkdown.default.render({
+    files: [...(0, _glob.globSync)(gulpConfig.get('readme.from')), ...esmFilePaths]
+  }).finally(cleanUp).then(readme => _fs.default.appendFileSync(gulpConfig.get('readme.to') + gulpConfig.get('readme.file'), readme, gulpConfig.get('readmeOptions')));
+};
 exports.addToReadme = addToReadme;

package/dist/partials/imagesFor.js

@@ -1,19 +1,19 @@
-"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 _nodePath = _interopRequireDefault(require("node:path"));
-var gulpConfig = _interopRequireWildcard(require("../../gulp.config.js"));
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-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).';
-
+"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 _nodePath = _interopRequireDefault(require("node:path"));
+var gulpConfig = _interopRequireWildcard(require("../../gulp.config.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+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
@@ -22,36 +22,36 @@ const installHint = 'Add it to your project with: npm install --save-dev github:
  * @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;
-};
-
+ */
+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));
-};
+ */
+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));
+};
 exports.imagesFor = imagesFor;

package/dist/partials/loadPeer.js

@@ -1,34 +1,34 @@
-"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.
-const dynamicImport = new Function('specifier', 'return import(specifier)');
-
+"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.
+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}`);
-
+ */
+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
@@ -42,29 +42,29 @@ const notInstalled = (name, {
  * @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;
-  }
-};
-
+ */
+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
@@ -75,25 +75,25 @@ const requirePeer = (name, {
  * @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.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;

package/dist/partials/neostandardLint.js

@@ -0,0 +1,144 @@
+"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').then(({
+  neostandard
+}) => 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>}
+ */
+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`.
+ * @param {Object} options
+ * @param {string} options.cwd
+ * @param {boolean} options.ts
+ * @param {boolean} options.fix
+ * @returns {Promise<import('eslint').ESLint>}
+ */
+const buildEslint = async ({
+  cwd,
+  ts,
+  fix
+}) => {
+  const neostandard = await importNeostandard();
+  return new _eslint.ESLint({
+    cwd,
+    fix,
+    overrideConfigFile: true,
+    baseConfig: neostandard({
+      ts,
+      env: readEnv(cwd)
+    })
+  });
+};
+
+/**
+ * Print a file's lint messages, if it has any.
+ * @memberOf module:partials
+ * @param {import('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 never fail the 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 {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 {import('stream').Transform}
+ */
+const neostandardLint = ({
+  fix = true,
+  ts = false
+} = {}, loadEslint = buildEslint) => {
+  const totals = {
+    errors: 0,
+    warnings: 0
+  };
+  let eslintPromise = null;
+  return _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
+      });
+    }
+    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`);
+    callback();
+  });
+};
+exports.neostandardLint = neostandardLint;

package/dist/partials/tsFor.js

@@ -1,27 +1,27 @@
-"use strict";
-
-require("core-js/modules/esnext.weak-map.delete-all.js");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.tsFor = exports.loadTypescript = void 0;
-var _gulp = require("gulp");
-var _nodePath = _interopRequireDefault(require("node:path"));
-var gulpConfig = _interopRequireWildcard(require("../../gulp.config.js"));
-var _loadPeer = require("./loadPeer.js");
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-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');
-
+"use strict";
+
+require("core-js/modules/esnext.weak-map.delete-all.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tsFor = exports.loadTypescript = void 0;
+var _gulp = require("gulp");
+var _nodePath = _interopRequireDefault(require("node:path"));
+var gulpConfig = _interopRequireWildcard(require("../../gulp.config.js"));
+var _loadPeer = require("./loadPeer.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+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 {import('node:stream').Stream} stream
  * @returns {Promise<void>}
- */
-const installHint = 'Install it in your project with: npm install --save-dev typescript';
-
+ */
+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.
@@ -29,18 +29,18 @@ const installHint = 'Install it in your project with: npm install --save-dev typ
  * @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',
-  installHint,
-  projectPath
-});
-exports.loadTypescript = loadTypescript;
-const streamToPromise = stream => new Promise((resolve, reject) => {
-  stream.on('finish', resolve);
-  stream.on('error', reject);
-});
-
+ */
+const loadTypescript = (projectPath = process.cwd()) => (0, _loadPeer.requirePeer)('typescript', {
+  task: 'typescript',
+  installHint,
+  projectPath
+});
+exports.loadTypescript = loadTypescript;
+const streamToPromise = stream => new Promise((resolve, reject) => {
+  stream.on('finish', resolve);
+  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
@@ -49,13 +49,13 @@ const streamToPromise = stream => new Promise((resolve, reject) => {
  * @memberOf module:partials
  * @param {string} configPath - Path to a tsconfig.json file.
  * @returns {import('typescript').CompilerOptions}
- */
-const readCompilerOptions = (ts, configPath) => {
-  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-  const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, _nodePath.default.dirname(configPath));
-  return parsedConfig.options;
-};
-
+ */
+const readCompilerOptions = (ts, configPath) => {
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+  const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, _nodePath.default.dirname(configPath));
+  return parsedConfig.options;
+};
+
 /**
  * Starting at the source directory, find all the ts files and convert them into the distribution directory.
  * @memberOf module:partials
@@ -68,36 +68,36 @@ const readCompilerOptions = (ts, configPath) => {
  * 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
-}) => tsCompile)) => {
-  if (gulpConfig.get('typescript.enabled') === false) {
-    return () => {};
-  }
-  const ts = loadTypescript();
-  const configPath = gulpConfig.get('typescript.config');
-  // When no tsconfig.json is configured, target/module are pinned explicitly rather than left for TypeScript's
-  // own compiler defaults - those defaults have already shifted once across a TypeScript version bump in this
-  // project's own history (silently changing whether output keeps `const`/`let` or downlevels to `var`), and
-  // pinning them keeps this task's output stable across future TypeScript upgrades too. ES5/CommonJS matches
-  // what the downstream babel/browserify bundling pipeline has always assumed it receives.
-  const compilerOptions = configPath ? readCompilerOptions(ts, configPath) : {
-    declaration: true,
-    target: ts.ScriptTarget.ES5,
-    module: ts.ModuleKind.CommonJS,
-    esModuleInterop: false
-  };
-  // Accepts gulp's own callback-style task convention (an optional `done`, called once finished) rather than
-  // just returning a Promise, since callers may invoke the returned function directly with a callback instead
-  // of relying on gulp's own runner to observe a returned Promise.
-  return done => {
-    const compile = async () => {
-      const tsCompile = await loadTsCompile();
-      const tsResult = (0, _gulp.src)(srcPath).pipe(tsCompile(compilerOptions));
-      await Promise.all([streamToPromise(tsResult.dts.pipe((0, _gulp.dest)(distPath))), streamToPromise(tsResult.js.pipe((0, _gulp.dest)(distPath)))]);
-    };
-    return typeof done === 'function' ? compile().then(() => done(), done) : compile();
-  };
-};
+ */
+const tsFor = (srcPath = gulpConfig.get('typescript.from'), distPath = gulpConfig.get('typescript.to'), loadTsCompile = () => importGulpTsCompile().then(({
+  default: tsCompile
+}) => tsCompile)) => {
+  if (gulpConfig.get('typescript.enabled') === false) {
+    return () => {};
+  }
+  const ts = loadTypescript();
+  const configPath = gulpConfig.get('typescript.config');
+  // When no tsconfig.json is configured, target/module are pinned explicitly rather than left for TypeScript's
+  // own compiler defaults - those defaults have already shifted once across a TypeScript version bump in this
+  // project's own history (silently changing whether output keeps `const`/`let` or downlevels to `var`), and
+  // pinning them keeps this task's output stable across future TypeScript upgrades too. ES5/CommonJS matches
+  // what the downstream babel/browserify bundling pipeline has always assumed it receives.
+  const compilerOptions = configPath ? readCompilerOptions(ts, configPath) : {
+    declaration: true,
+    target: ts.ScriptTarget.ES5,
+    module: ts.ModuleKind.CommonJS,
+    esModuleInterop: false
+  };
+  // Accepts gulp's own callback-style task convention (an optional `done`, called once finished) rather than
+  // just returning a Promise, since callers may invoke the returned function directly with a callback instead
+  // of relying on gulp's own runner to observe a returned Promise.
+  return done => {
+    const compile = async () => {
+      const tsCompile = await loadTsCompile();
+      const tsResult = (0, _gulp.src)(srcPath).pipe(tsCompile(compilerOptions));
+      await Promise.all([streamToPromise(tsResult.dts.pipe((0, _gulp.dest)(distPath))), streamToPromise(tsResult.js.pipe((0, _gulp.dest)(distPath)))]);
+    };
+    return typeof done === 'function' ? compile().then(() => done(), done) : compile();
+  };
+};
 exports.tsFor = tsFor;