js-build-tools 6.6.0 → 6.8.0

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])) => {
@@ -122,7 +122,15 @@ const jsdocDocsFor = (srcPath = gulpConfig.get('docs.from'), outPath = gulpConfi
       const themeDir = resolveJsdocTheme(theme);
       const indexFile = gulpConfig.get('docs.index');
       const title = gulpConfig.get('docs.title');
+      const basePath = gulpConfig.get('docs.basePath');
       await (0, _removeDirectory.removeDirectory)(outPath);
+      const workDir = _nodeFs.default.mkdtempSync(_nodePath.default.join(_nodeOs.default.tmpdir(), 'jsdocdocs-'));
+      // clean-jsdoc-theme 5.x writes no index.html at all without a front page, so fall back to one with the title
+      let readme = indexFile && _nodeFs.default.existsSync(indexFile) ? _nodePath.default.resolve(indexFile) : '';
+      if (!readme) {
+        readme = _nodePath.default.join(workDir, 'index.md');
+        _nodeFs.default.writeFileSync(readme, `# ${title || 'Documentation'}\n`);
+      }
       const config = {
         ..._jsdocBase.default,
         source: {
@@ -136,21 +144,26 @@ const jsdocDocsFor = (srcPath = gulpConfig.get('docs.from'), outPath = gulpConfi
           // quick-start example, which sets this explicitly, not assumed from jsdoc's own classic defaults.
           recurse: true,
           template: themeDir,
-          // clean-jsdoc-theme's own options for the name in its header and the home page's <title> (otherwise "Home").
+          // clean-jsdoc-theme 4.x's own options for the name in its header and the home page's <title> (otherwise "Home").
           // The header is given as a link: a plain-text title links to the site root ("/"), while every page is in one
           // folder, so index.html is the home page wherever they are served. Both are printed unescaped by the theme.
+          // clean-jsdoc-theme 5.x reads its options from opts itself: the name in its header and <title>, and the path
+          // its root-absolute links start from (4.x reads only theme_opts).
+          ...(title ? {
+            siteName: title
+          } : {}),
+          ...(basePath ? {
+            basePath
+          } : {}),
           ...(title ? {
             theme_opts: {
               title: `<a href="index.html" class="sidebar-title sidebar-title-anchor">${escapeHtml(title)}</a>`,
               homepageTitle: escapeHtml(title)
             }
           } : {}),
-          ...(indexFile && _nodeFs.default.existsSync(indexFile) ? {
-            readme: _nodePath.default.resolve(indexFile)
-          } : {})
+          readme
         }
       };
-      const workDir = _nodeFs.default.mkdtempSync(_nodePath.default.join(_nodeOs.default.tmpdir(), 'jsdocdocs-'));
       try {
         const configPath = _nodePath.default.join(workDir, 'jsdoc.conf.json');
         _nodeFs.default.writeFileSync(configPath, JSON.stringify(config));

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;

package/dist/partials/loadPlaywright.js

@@ -7,13 +7,13 @@ exports.loadPlaywright = exports.launchBrowser = void 0;
 var _loadPeer = require("./loadPeer.js");
 const installHint = 'Install it in your project with: npm install --save-dev playwright';
 
-/**
- * Find Playwright (headless-browser automation) of the project being built, an optional peer dependency only
- * needed by whatever actually drives a real browser - projects which never do 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 Playwright module.
- * @throws {Error} With install instructions when playwright is not installed.
+/**
+ * Find Playwright (headless-browser automation) of the project being built, an optional peer dependency only
+ * needed by whatever actually drives a real browser - projects which never do 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 Playwright module.
+ * @throws {Error} With install instructions when playwright is not installed.
  */
 const loadPlaywright = (projectPath = process.cwd()) => (0, _loadPeer.requirePeer)('playwright', {
   task: 'browser automation',
@@ -21,13 +21,13 @@ const loadPlaywright = (projectPath = process.cwd()) => (0, _loadPeer.requirePee
   projectPath
 });
 
-/**
- * Launch a real headless Chromium browser via Playwright. See {@link loadPlaywright}.
- * @memberOf module:partials
- * @param {Function} [load=loadPlaywright] Which Playwright to launch - swappable in tests.
- * @param {string} [projectPath=process.cwd()] The folder of the project (which has the package.json) being built.
- * @returns {Promise<Browser>} The running Playwright browser - close it yourself (browser.close()) once done with it.
- * @throws {Error} With install instructions when playwright is not installed.
+/**
+ * Launch a real headless Chromium browser via Playwright. See {@link loadPlaywright}.
+ * @memberOf module:partials
+ * @param {Function} [load=loadPlaywright] Which Playwright to launch - swappable in tests.
+ * @param {string} [projectPath=process.cwd()] The folder of the project (which has the package.json) being built.
+ * @returns {Promise<Browser>} The running Playwright browser - close it yourself (browser.close()) once done with it.
+ * @throws {Error} With install instructions when playwright is not installed.
  */
 exports.loadPlaywright = loadPlaywright;
 const launchBrowser = (load = loadPlaywright, projectPath = process.cwd()) => load(projectPath).chromium.launch();

package/dist/partials/minifyFor.js

@@ -1,21 +1,21 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.minifyFor = void 0;
-var _gulp = require("gulp");
-var _gulpUglifyEs = _interopRequireDefault(require("gulp-uglify-es"));
-var _gulpRename = _interopRequireDefault(require("gulp-rename"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const uglify = Object.hasOwn(_gulpUglifyEs.default, 'default') ? _gulpUglifyEs.default.default : _gulpUglifyEs.default;
-
-/**
- * Minify files and rename the output with '.min' extension.
- * @memberOf module:partials
- * @returns {*}
- */
-const minifyFor = (srcSearch, destination) => (0, _gulp.src)(srcSearch).pipe(uglify()).pipe((0, _gulpRename.default)({
-  extname: '.min.js'
-})).pipe((0, _gulp.dest)(destination));
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.minifyFor = void 0;
+var _gulp = require("gulp");
+var _gulpUglifyEs = _interopRequireDefault(require("gulp-uglify-es"));
+var _gulpRename = _interopRequireDefault(require("gulp-rename"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const uglify = Object.hasOwn(_gulpUglifyEs.default, 'default') ? _gulpUglifyEs.default.default : _gulpUglifyEs.default;
+
+/**
+ * Minify files and rename the output with '.min' extension.
+ * @memberOf module:partials
+ * @returns {*}
+ */
+const minifyFor = (srcSearch, destination) => (0, _gulp.src)(srcSearch).pipe(uglify()).pipe((0, _gulpRename.default)({
+  extname: '.min.js'
+})).pipe((0, _gulp.dest)(destination));
 exports.minifyFor = minifyFor;