dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/extract/transpile/index.mjs

@@ -14,40 +14,40 @@ const litCoffeeWrap = coffeeWrap(true);
 const svelteWrap = svelteDingus(typeScriptVanillaWrap);
 
 export const EXTENSION2WRAPPER = new Map([
-  [".js", javaScriptWrap],
-  [".cjs", javaScriptWrap],
-  [".mjs", javaScriptWrap],
-  [".jsx", javaScriptWrap],
-  [".ts", typeScriptVanillaWrap],
-  [".tsx", typeScriptTsxWrap],
-  [".d.ts", typeScriptVanillaWrap],
-  [".cts", typeScriptVanillaWrap],
-  [".d.cts", typeScriptVanillaWrap],
-  [".mts", typeScriptESMWrap],
-  [".d.mts", typeScriptESMWrap],
-  [".vue", vueWrap],
-  [".svelte", svelteWrap],
-  [".ls", liveScriptWrap],
-  [".coffee", coffeeVanillaWrap],
-  [".litcoffee", litCoffeeWrap],
-  [".coffee.md", litCoffeeWrap],
-  [".csx", coffeeVanillaWrap],
-  [".cjsx", coffeeVanillaWrap],
+	[".js", javaScriptWrap],
+	[".cjs", javaScriptWrap],
+	[".mjs", javaScriptWrap],
+	[".jsx", javaScriptWrap],
+	[".ts", typeScriptVanillaWrap],
+	[".tsx", typeScriptTsxWrap],
+	[".d.ts", typeScriptVanillaWrap],
+	[".cts", typeScriptVanillaWrap],
+	[".d.cts", typeScriptVanillaWrap],
+	[".mts", typeScriptESMWrap],
+	[".d.mts", typeScriptESMWrap],
+	[".vue", vueWrap],
+	[".svelte", svelteWrap],
+	[".ls", liveScriptWrap],
+	[".coffee", coffeeVanillaWrap],
+	[".litcoffee", litCoffeeWrap],
+	[".coffee.md", litCoffeeWrap],
+	[".csx", coffeeVanillaWrap],
+	[".cjsx", coffeeVanillaWrap],
 ]);
 
-const BABEL_ABLE_EXTENSIONS = [
-  ".js",
-  ".cjs",
-  ".mjs",
-  ".jsx",
-  ".ts",
-  ".cts",
-  ".mts",
-  ".tsx",
-  ".d.ts",
-  ".d.cts",
-  ".d.mts",
-];
+const BABEL_ABLE_EXTENSIONS = new Set([
+	".js",
+	".cjs",
+	".mjs",
+	".jsx",
+	".ts",
+	".cts",
+	".mts",
+	".tsx",
+	".d.ts",
+	".d.cts",
+	".d.mts",
+]);
 
 /**
  * returns the babel wrapper if there's a babelConfig in the transpiler
@@ -65,14 +65,14 @@ const BABEL_ABLE_EXTENSIONS = [
  * @returns {module} the module
  */
 export function getWrapper(pExtension, pTranspilerOptions) {
-  if (
-    Object.keys(pTranspilerOptions?.babelConfig ?? {}).length > 0 &&
-    BABEL_ABLE_EXTENSIONS.includes(pExtension)
-  ) {
-    return babelWrap;
-  }
+	if (
+		Object.keys(pTranspilerOptions?.babelConfig ?? {}).length > 0 &&
+		BABEL_ABLE_EXTENSIONS.has(pExtension)
+	) {
+		return babelWrap;
+	}
 
-  return EXTENSION2WRAPPER.get(pExtension) || javaScriptWrap;
+	return EXTENSION2WRAPPER.get(pExtension) || javaScriptWrap;
 }
 
 /**
@@ -94,14 +94,14 @@ export function getWrapper(pExtension, pTranspilerOptions) {
  *                                transpiler matching pExtension
  */
 export default function transpile(
-  { extension, source, filename },
-  pTranspilerOptions,
+	{ extension, source, filename },
+	pTranspilerOptions,
 ) {
-  const lWrapper = getWrapper(extension, pTranspilerOptions);
+	const lWrapper = getWrapper(extension, pTranspilerOptions);
 
-  if (lWrapper.isAvailable()) {
-    return lWrapper.transpile(source, filename, pTranspilerOptions);
-  } else {
-    return source;
-  }
+	if (lWrapper.isAvailable()) {
+		return lWrapper.transpile(source, filename, pTranspilerOptions);
+	} else {
+		return source;
+	}
 }

package/src/extract/transpile/javascript-wrap.mjs

@@ -1,12 +1,12 @@
 import { createRequire } from "node:module";
 
 export default {
-  isAvailable: () => true,
+	isAvailable: () => true,
 
-  version: () => {
-    const require = createRequire(import.meta.url);
-    return `acorn@${require("acorn").version}`;
-  },
+	version: () => {
+		const require = createRequire(import.meta.url);
+		return `acorn@${require("acorn").version}`;
+	},
 
-  transpile: (pSource) => pSource,
+	transpile: (pSource) => pSource,
 };

package/src/extract/transpile/livescript-wrap.mjs

@@ -2,16 +2,16 @@ import tryImport from "#utl/try-import.mjs";
 import meta from "#meta.cjs";
 
 const livescript = await tryImport(
-  "livescript",
-  meta.supportedTranspilers.livescript,
+	"livescript",
+	meta.supportedTranspilers.livescript,
 );
 
 /* c8 ignore start */
 export default {
-  isAvailable: () => livescript !== false,
+	isAvailable: () => livescript !== false,
 
-  version: () => `livescript@${livescript.VERSION}`,
+	version: () => `livescript@${livescript.VERSION}`,
 
-  transpile: (pSource) => livescript.compile(pSource),
+	transpile: (pSource) => livescript.compile(pSource),
 };
 /* c8 ignore stop */

package/src/extract/transpile/meta.mjs

@@ -1,7 +1,7 @@
 /* eslint security/detect-object-injection : 0*/
 import {
-  isAvailable as swcIsAvailable,
-  version as swcVersion,
+	isAvailable as swcIsAvailable,
+	version as swcVersion,
 } from "../swc/parse.mjs";
 import tryAvailable from "./try-import-available.mjs";
 import javascriptWrap from "./javascript-wrap.mjs";
@@ -14,90 +14,90 @@ import vueTemplateWrap from "./vue-template-wrap.cjs";
 import meta from "#meta.cjs";
 
 const swcWrap = {
-  isAvailable: () => swcIsAvailable(),
-  version: () => swcVersion(),
+	isAvailable: () => swcIsAvailable(),
+	version: () => swcVersion(),
 };
 const coffeeScriptWrap = coffeeScriptWrapFunction(false);
 const svelteWrap = svelteWrapFunction(javascriptWrap);
 const typescriptWrap = typescriptWrapFunction("esm");
 
 function gotCoffee() {
-  return (
-    tryAvailable("coffeescript", meta.supportedTranspilers.coffeescript) ||
-    tryAvailable("coffee-script", meta.supportedTranspilers["coffee-script"])
-  );
+	return (
+		tryAvailable("coffeescript", meta.supportedTranspilers.coffeescript) ||
+		tryAvailable("coffee-script", meta.supportedTranspilers["coffee-script"])
+	);
 }
 
 const TRANSPILER2AVAILABLE = {
-  babel: tryAvailable("@babel/core", meta.supportedTranspilers.babel),
-  javascript: true,
-  "coffee-script": gotCoffee(),
-  coffeescript: gotCoffee(),
-  livescript: tryAvailable("livescript", meta.supportedTranspilers.livescript),
-  svelte: tryAvailable("svelte/compiler", meta.supportedTranspilers.svelte),
-  swc: tryAvailable("@swc/core", meta.supportedTranspilers.swc),
-  typescript: tryAvailable("typescript", meta.supportedTranspilers.typescript),
-  "vue-template-compiler": tryAvailable(
-    "vue-template-compiler",
-    meta.supportedTranspilers["vue-template-compiler"],
-  ),
-  "@vue/compiler-sfc": tryAvailable(
-    "@vue/compiler-sfc",
-    meta.supportedTranspilers["@vue/compiler-sfc"],
-  ),
+	babel: tryAvailable("@babel/core", meta.supportedTranspilers.babel),
+	javascript: true,
+	"coffee-script": gotCoffee(),
+	coffeescript: gotCoffee(),
+	livescript: tryAvailable("livescript", meta.supportedTranspilers.livescript),
+	svelte: tryAvailable("svelte/compiler", meta.supportedTranspilers.svelte),
+	swc: tryAvailable("@swc/core", meta.supportedTranspilers.swc),
+	typescript: tryAvailable("typescript", meta.supportedTranspilers.typescript),
+	"vue-template-compiler": tryAvailable(
+		"vue-template-compiler",
+		meta.supportedTranspilers["vue-template-compiler"],
+	),
+	"@vue/compiler-sfc": tryAvailable(
+		"@vue/compiler-sfc",
+		meta.supportedTranspilers["@vue/compiler-sfc"],
+	),
 };
 
 const TRANSPILER2WRAPPER = {
-  babel: babelWrap,
-  javascript: javascriptWrap,
-  "coffee-script": coffeeScriptWrap,
-  coffeescript: coffeeScriptWrap,
-  livescript: livescriptWrap,
-  svelte: svelteWrap,
-  swc: swcWrap,
-  typescript: typescriptWrap,
-  "vue-template-compiler": vueTemplateWrap,
-  "@vue/compiler-sfc": vueTemplateWrap,
+	babel: babelWrap,
+	javascript: javascriptWrap,
+	"coffee-script": coffeeScriptWrap,
+	coffeescript: coffeeScriptWrap,
+	livescript: livescriptWrap,
+	svelte: svelteWrap,
+	swc: swcWrap,
+	typescript: typescriptWrap,
+	"vue-template-compiler": vueTemplateWrap,
+	"@vue/compiler-sfc": vueTemplateWrap,
 };
 
 export const EXTENSION2AVAILABLE = new Map([
-  [".js", TRANSPILER2AVAILABLE.javascript],
-  [".cjs", TRANSPILER2AVAILABLE.javascript],
-  [".mjs", TRANSPILER2AVAILABLE.javascript],
-  [".jsx", TRANSPILER2AVAILABLE.javascript],
-  [".ts", TRANSPILER2AVAILABLE.typescript],
-  [".tsx", TRANSPILER2AVAILABLE.typescript],
-  [".d.ts", TRANSPILER2AVAILABLE.typescript],
-  [".cts", TRANSPILER2AVAILABLE.typescript],
-  [".d.cts", TRANSPILER2AVAILABLE.typescript],
-  [".mts", TRANSPILER2AVAILABLE.typescript],
-  [".d.mts", TRANSPILER2AVAILABLE.typescript],
-  [
-    ".vue",
-    TRANSPILER2AVAILABLE["vue-template-compiler"] ||
-      TRANSPILER2AVAILABLE["@vue/compiler-sfc"],
-  ],
-  [".svelte", TRANSPILER2AVAILABLE.svelte],
-  [".ls", TRANSPILER2AVAILABLE.livescript],
-  [".coffee", gotCoffee()],
-  [".litcoffee", gotCoffee()],
-  [".coffee.md", gotCoffee()],
-  [".csx", gotCoffee()],
-  [".cjsx", gotCoffee()],
+	[".js", TRANSPILER2AVAILABLE.javascript],
+	[".cjs", TRANSPILER2AVAILABLE.javascript],
+	[".mjs", TRANSPILER2AVAILABLE.javascript],
+	[".jsx", TRANSPILER2AVAILABLE.javascript],
+	[".ts", TRANSPILER2AVAILABLE.typescript],
+	[".tsx", TRANSPILER2AVAILABLE.typescript],
+	[".d.ts", TRANSPILER2AVAILABLE.typescript],
+	[".cts", TRANSPILER2AVAILABLE.typescript],
+	[".d.cts", TRANSPILER2AVAILABLE.typescript],
+	[".mts", TRANSPILER2AVAILABLE.typescript],
+	[".d.mts", TRANSPILER2AVAILABLE.typescript],
+	[
+		".vue",
+		TRANSPILER2AVAILABLE["vue-template-compiler"] ||
+			TRANSPILER2AVAILABLE["@vue/compiler-sfc"],
+	],
+	[".svelte", TRANSPILER2AVAILABLE.svelte],
+	[".ls", TRANSPILER2AVAILABLE.livescript],
+	[".coffee", gotCoffee()],
+	[".litcoffee", gotCoffee()],
+	[".coffee.md", gotCoffee()],
+	[".csx", gotCoffee()],
+	[".cjsx", gotCoffee()],
 ]);
 
 const EXTENSIONS_PER_PARSER = {
-  swc: [".js", ".cjs", ".mjs", ".jsx", ".ts", ".tsx", ".d.ts"],
-  // tsc: [".js", ".cjs", ".mjs", ".jsx", ".ts", ".tsx", ".d.ts"],
-  // acorn: [".js", ".cjs", ".mjs", ".jsx"],
+	swc: new Set([".js", ".cjs", ".mjs", ".jsx", ".ts", ".tsx", ".d.ts"]),
+	// tsc: [".js", ".cjs", ".mjs", ".jsx", ".ts", ".tsx", ".d.ts"],
+	// acorn: [".js", ".cjs", ".mjs", ".jsx"],
 };
 
 function extensionIsAvailable(pExtension) {
-  return (
-    EXTENSION2AVAILABLE.get(pExtension) ||
-    // should eventually also check whether swc is enabled as a parser?
-    (TRANSPILER2AVAILABLE.swc && EXTENSIONS_PER_PARSER.swc.includes(pExtension))
-  );
+	return (
+		EXTENSION2AVAILABLE.get(pExtension) ||
+		// should eventually also check whether swc is enabled as a parser?
+		(TRANSPILER2AVAILABLE.swc && EXTENSIONS_PER_PARSER.swc.has(pExtension))
+	);
 }
 
 /**
@@ -107,15 +107,15 @@ function extensionIsAvailable(pExtension) {
  * @type {IAvailableExtension[]}
  */
 export const allExtensions = Array.from(EXTENSION2AVAILABLE.keys()).map(
-  (pExtension) => ({
-    extension: pExtension,
-    available: extensionIsAvailable(pExtension),
-  }),
+	(pExtension) => ({
+		extension: pExtension,
+		available: extensionIsAvailable(pExtension),
+	}),
 );
 
 function getCurrentVersion(pTranspiler) {
-  const lTranspiler = TRANSPILER2WRAPPER[pTranspiler];
-  return lTranspiler.isAvailable() ? lTranspiler.version() : "-";
+	const lTranspiler = TRANSPILER2WRAPPER[pTranspiler];
+	return lTranspiler.isAvailable() ? lTranspiler.version() : "-";
 }
 
 /**
@@ -125,7 +125,7 @@ function getCurrentVersion(pTranspiler) {
  * @type {string[]}
  */
 export const scannableExtensions = Array.from(
-  EXTENSION2AVAILABLE.keys(),
+	EXTENSION2AVAILABLE.keys(),
 ).filter(extensionIsAvailable);
 
 /**
@@ -136,12 +136,12 @@ export const scannableExtensions = Array.from(
  * @return {IAvailableTranspiler[]} an array of supported transpilers
  */
 export function getAvailableTranspilers() {
-  return ["javascript"]
-    .concat(Object.keys(meta.supportedTranspilers))
-    .map((pTranspiler) => ({
-      name: pTranspiler,
-      version: meta.supportedTranspilers[pTranspiler] || "*",
-      available: TRANSPILER2AVAILABLE[pTranspiler],
-      currentVersion: getCurrentVersion(pTranspiler),
-    }));
+	return ["javascript"]
+		.concat(Object.keys(meta.supportedTranspilers))
+		.map((pTranspiler) => ({
+			name: pTranspiler,
+			version: meta.supportedTranspilers[pTranspiler] || "*",
+			available: TRANSPILER2AVAILABLE[pTranspiler],
+			currentVersion: getCurrentVersion(pTranspiler),
+		}));
 }

package/src/extract/transpile/svelte-preprocess.mjs

@@ -9,93 +9,93 @@
  Leaving it be as it's the way svelte currently functions
  */
 function parseAttributes(pString) {
-  const lAttributes = {};
-  pString
-    .split(/\s+/)
-    .filter(Boolean)
-    .forEach((pAttribute) => {
-      const lEqualsSignIndex = pAttribute.indexOf("=");
-      if (lEqualsSignIndex === -1) {
-        lAttributes[pAttribute] = true;
-      } else {
-        lAttributes[pAttribute.slice(0, lEqualsSignIndex)] = "'\"".includes(
-          pAttribute[lEqualsSignIndex + 1],
-        )
-          ? pAttribute.slice(lEqualsSignIndex + 2, -1)
-          : pAttribute.slice(lEqualsSignIndex + 1);
-      }
-    });
-  return lAttributes;
+	const lAttributes = {};
+	pString
+		.split(/\s+/)
+		.filter(Boolean)
+		.forEach((pAttribute) => {
+			const lEqualsSignIndex = pAttribute.indexOf("=");
+			if (lEqualsSignIndex === -1) {
+				lAttributes[pAttribute] = true;
+			} else {
+				lAttributes[pAttribute.slice(0, lEqualsSignIndex)] = "'\"".includes(
+					pAttribute[lEqualsSignIndex + 1],
+				)
+					? pAttribute.slice(lEqualsSignIndex + 2, -1)
+					: pAttribute.slice(lEqualsSignIndex + 1);
+			}
+		});
+	return lAttributes;
 }
 
 function composeTranspilerOptions(pTranspilerOptions) {
-  return {
-    ...pTranspilerOptions,
-    tsConfig: {
-      ...(pTranspilerOptions?.tsConfig ?? {}),
-      options: {
-        ...(pTranspilerOptions?.tsConfig?.options ?? {}),
-        importsNotUsedAsValues: "preserve",
-        jsx: "preserve",
-      },
-    },
-  };
+	return {
+		...pTranspilerOptions,
+		tsConfig: {
+			...(pTranspilerOptions?.tsConfig ?? {}),
+			options: {
+				...(pTranspilerOptions?.tsConfig?.options ?? {}),
+				importsNotUsedAsValues: "preserve",
+				jsx: "preserve",
+			},
+		},
+	};
 }
 
 function getSourceReplacer(pTranspiler, pTranspilerOptions) {
-  return (pMatch, pAttributes, pSource) => {
-    const lAttributes = pAttributes || "";
-    const lParsedAttributes = parseAttributes(lAttributes);
+	return (pMatch, pAttributes, pSource) => {
+		const lAttributes = pAttributes || "";
+		const lParsedAttributes = parseAttributes(lAttributes);
 
-    if (lParsedAttributes.lang === "ts") {
-      return `<script${lAttributes}>${pTranspiler(
-        pSource,
-        "dummy-filename",
-        composeTranspilerOptions(pTranspilerOptions),
-      )}</script>`;
-    } else {
-      return pMatch;
-    }
-  };
+		if (lParsedAttributes.lang === "ts") {
+			return `<script${lAttributes}>${pTranspiler(
+				pSource,
+				"dummy-filename",
+				composeTranspilerOptions(pTranspilerOptions),
+			)}</script>`;
+		} else {
+			return pMatch;
+		}
+	};
 }
 
 function styleReplacer(pMatch, pAttributes) {
-  const lParsedAttributes = parseAttributes(pAttributes || "");
+	const lParsedAttributes = parseAttributes(pAttributes || "");
 
-  if (lParsedAttributes.lang === "css" || !pAttributes) {
-    return pMatch;
-  } else {
-    return "";
-  }
+	if (lParsedAttributes.lang === "css" || !pAttributes) {
+		return pMatch;
+	} else {
+		return "";
+	}
 }
 
 export default function preProcess(
-  pSource,
-  pTranspilerWrapper,
-  pTranspilerOptions,
+	pSource,
+	pTranspilerWrapper,
+	pTranspilerOptions,
 ) {
-  // regexes from
-  // github.com/sveltejs/svelte/blob/67dea941bb1e61f0912ebd2257666b899c1ccefa/src/compiler/preprocess/index.ts#L165
-  // eslint-disable-next-line security/detect-unsafe-regex
-  const lScriptRegex = /<script(\s[^]*?)?(?:>([^]*?)<\/script>|\/>)/gi;
-  // eslint-disable-next-line security/detect-unsafe-regex
-  const lStyleRegex = /<style(\s[^]*?)?(?:>([^]*?)<\/style>|\/>)/gi;
+	// regexes from
+	// github.com/sveltejs/svelte/blob/67dea941bb1e61f0912ebd2257666b899c1ccefa/src/compiler/preprocess/index.ts#L165
+	// eslint-disable-next-line security/detect-unsafe-regex
+	const lScriptRegex = /<script(\s[^]*?)?(?:>([^]*?)<\/script>|\/>)/gi;
+	// eslint-disable-next-line security/detect-unsafe-regex
+	const lStyleRegex = /<style(\s[^]*?)?(?:>([^]*?)<\/style>|\/>)/gi;
 
-  if (pTranspilerWrapper.isAvailable && pTranspilerWrapper.isAvailable()) {
-    return (
-      pSource
-        .replace(
-          lScriptRegex,
-          getSourceReplacer(pTranspilerWrapper.transpile, pTranspilerOptions),
-        )
-        // we don't regard styling in our dependency analysis, so we can remove
-        // styles that (our instance of) svelte doesn't have pre-processors
-        // installed for (e.g. sass/scss/postcss/sss/styl/stylus/...) and that
-        // can potentially get svelte compiler to error out (for an example see
-        // https://github.com/sverweij/dependency-cruiser/issues/713)
-        .replace(lStyleRegex, styleReplacer)
-    );
-  } else {
-    return pSource;
-  }
+	if (pTranspilerWrapper.isAvailable && pTranspilerWrapper.isAvailable()) {
+		return (
+			pSource
+				.replace(
+					lScriptRegex,
+					getSourceReplacer(pTranspilerWrapper.transpile, pTranspilerOptions),
+				)
+				// we don't regard styling in our dependency analysis, so we can remove
+				// styles that (our instance of) svelte doesn't have pre-processors
+				// installed for (e.g. sass/scss/postcss/sss/styl/stylus/...) and that
+				// can potentially get svelte compiler to error out (for an example see
+				// https://github.com/sverweij/dependency-cruiser/issues/713)
+				.replace(lStyleRegex, styleReplacer)
+		);
+	} else {
+		return pSource;
+	}
 }

package/src/extract/transpile/svelte-wrap.mjs

@@ -3,29 +3,29 @@ import tryImport from "#utl/try-import.mjs";
 import meta from "#meta.cjs";
 
 const { compile, VERSION } = await tryImport(
-  "svelte/compiler",
-  meta.supportedTranspilers.svelte,
+	"svelte/compiler",
+	meta.supportedTranspilers.svelte,
 );
 
 function getTranspiler(pTranspilerWrapper) {
-  return (pSource, _pFileName, pTranspilerOptions) => {
-    const lPreProcessedSource = preProcess(
-      pSource,
-      pTranspilerWrapper,
-      pTranspilerOptions,
-    );
-    // in svelte 5 one must provide the second argument
-    // lest it throws because it's accessing a property
-    // in it. In svelte 4 (which also takes compiler
-    // options there) this isn't necessary.
-    return compile(lPreProcessedSource, {}).js.code;
-  };
+	return (pSource, _pFileName, pTranspilerOptions) => {
+		const lPreProcessedSource = preProcess(
+			pSource,
+			pTranspilerWrapper,
+			pTranspilerOptions,
+		);
+		// in svelte 5 one must provide the second argument
+		// lest it throws because it's accessing a property
+		// in it. In svelte 4 (which also takes compiler
+		// options there) this isn't necessary.
+		return compile(lPreProcessedSource, {}).js.code;
+	};
 }
 
 export default function svelteWrap(pTranspilerWrapper) {
-  return {
-    isAvailable: () => Boolean(compile),
-    version: () => `svelte/compiler@${VERSION}`,
-    transpile: getTranspiler(pTranspilerWrapper),
-  };
+	return {
+		isAvailable: () => Boolean(compile),
+		version: () => `svelte/compiler@${VERSION}`,
+		transpile: getTranspiler(pTranspilerWrapper),
+	};
 }

package/src/extract/transpile/try-import-available.mjs

@@ -9,37 +9,36 @@ const SCOPED_PACKAGE_RE = "@[^/]+(?:/[^/]+)";
 const ROOT_MODULE_RE = new RegExp(`^(${SCOPED_PACKAGE_RE}|${PACKAGE_RE})`, "g");
 
 function extractRootModuleName(pModuleName) {
-  return (pModuleName.match(ROOT_MODULE_RE) || []).shift();
+	return (pModuleName.match(ROOT_MODULE_RE) || []).shift();
 }
 
 function getVersion(pModuleName) {
-  // of course we'd love to use something like an import with an import assertion
-  // (yo, you're import-ing 'json'!), but that's _experimental_, printing scary
-  // messages to stderr so: ¯\_(ツ)_/¯
-  // eslint-disable-next-line import/no-dynamic-require, security/detect-non-literal-require
-  const lManifest = require(
-    path.join(extractRootModuleName(pModuleName), "package.json"),
-  );
-  return lManifest.version;
+	// of course we'd love to use something like an import with an import assertion
+	// As that's _experimental_ we have to use _require_ in stead.
+	// eslint-disable-next-line import/no-dynamic-require, security/detect-non-literal-require
+	const lManifest = require(
+		path.join(extractRootModuleName(pModuleName), "package.json"),
+	);
+	return lManifest.version;
 }
 
 export default function tryImportAvailable(pModuleName, pSemanticVersion) {
-  try {
-    if (pSemanticVersion) {
-      const lVersion = getVersion(pModuleName);
-      const lCoerced = coerce(lVersion);
-      if (
-        lVersion &&
-        lCoerced &&
-        !satisfies(lCoerced.version, pSemanticVersion)
-      ) {
-        return false;
-      }
-    }
-    // of course we'd love to use something like import.meta.resolve, but
-    // that's _experimental_, so ¯\_(ツ)_/¯
-    return Boolean(require.resolve(pModuleName));
-  } catch (pError) {
-    return false;
-  }
+	try {
+		if (pSemanticVersion) {
+			const lVersion = getVersion(pModuleName);
+			const lCoerced = coerce(lVersion);
+			if (
+				lVersion &&
+				lCoerced &&
+				!satisfies(lCoerced.version, pSemanticVersion)
+			) {
+				return false;
+			}
+		}
+		// of course we'd love to use something like import.meta.resolve, but
+		// that's _experimental_, so ¯\_(ツ)_/¯
+		return Boolean(require.resolve(pModuleName));
+	} catch (pError) {
+		return false;
+	}
 }