dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/main/rule-set/normalize.mjs

@@ -1,4 +1,5 @@
 import { normalizeREProperties, normalizeToREAsString } from "../helpers.mjs";
+import { bus } from "#utl/bus.mjs";
 
 /**
  * @import { RuleScopeType } from "../../../types/shared-types.mjs";
@@ -16,9 +17,9 @@ const DEFAULT_RULE = "unnamed";
 const DEFAULT_SCOPE = "module";
 
 function normalizeSeverity(pSeverity) {
-  const lSeverity = pSeverity ?? DEFAULT_SEVERITY;
+	const lSeverity = pSeverity ?? DEFAULT_SEVERITY;
 
-  return VALID_SEVERITIES.test(lSeverity) ? lSeverity : DEFAULT_SEVERITY;
+	return VALID_SEVERITIES.test(lSeverity) ? lSeverity : DEFAULT_SEVERITY;
 }
 /**
  *
@@ -26,7 +27,7 @@ function normalizeSeverity(pSeverity) {
  * @returns {string}
  */
 function normalizeName(pRuleName) {
-  return pRuleName ?? DEFAULT_RULE;
+	return pRuleName ?? DEFAULT_RULE;
 }
 
 /**
@@ -34,7 +35,7 @@ function normalizeName(pRuleName) {
  * @returns {RuleScopeType}
  */
 function normalizeScope(pScope) {
-  return pScope ?? DEFAULT_SCOPE;
+	return pScope ?? DEFAULT_SCOPE;
 }
 
 /**
@@ -42,48 +43,48 @@ function normalizeScope(pScope) {
  * @returns {IStrictMiniDependencyRestriction}
  */
 function normalizeVia(pVia) {
-  let lReturnValue = {};
+	let lReturnValue = {};
 
-  if (typeof pVia === "string" || Array.isArray(pVia)) {
-    lReturnValue.path = pVia;
-  } else {
-    lReturnValue = structuredClone(pVia);
-  }
-  if (lReturnValue?.path) {
-    lReturnValue.path = normalizeToREAsString(lReturnValue.path);
-  }
-  return lReturnValue;
+	if (typeof pVia === "string" || Array.isArray(pVia)) {
+		lReturnValue.path = pVia;
+	} else {
+		lReturnValue = structuredClone(pVia);
+	}
+	if (lReturnValue?.path) {
+		lReturnValue.path = normalizeToREAsString(lReturnValue.path);
+	}
+	return lReturnValue;
 }
 
 // eslint-disable-next-line complexity
 function normalizeVias(pRuleTo) {
-  const lRuleTo = structuredClone(pRuleTo);
+	const lRuleTo = structuredClone(pRuleTo);
 
-  if (lRuleTo?.via) {
-    lRuleTo.via = normalizeVia(lRuleTo.via);
-  }
-  if (lRuleTo?.viaOnly) {
-    lRuleTo.viaOnly = normalizeVia(lRuleTo.viaOnly);
-  }
-  if (lRuleTo?.viaNot) {
-    if (!lRuleTo?.viaOnly?.pathNot) {
-      lRuleTo.viaOnly = {
-        ...lRuleTo.viaOnly,
-        pathNot: normalizeToREAsString(lRuleTo.viaNot),
-      };
-    }
-    delete lRuleTo.viaNot;
-  }
-  if (lRuleTo?.viaSomeNot) {
-    if (!lRuleTo?.via?.pathNot) {
-      lRuleTo.via = {
-        ...lRuleTo.via,
-        pathNot: normalizeToREAsString(lRuleTo.viaSomeNot),
-      };
-    }
-    delete lRuleTo.viaSomeNot;
-  }
-  return lRuleTo;
+	if (lRuleTo?.via) {
+		lRuleTo.via = normalizeVia(lRuleTo.via);
+	}
+	if (lRuleTo?.viaOnly) {
+		lRuleTo.viaOnly = normalizeVia(lRuleTo.viaOnly);
+	}
+	if (lRuleTo?.viaNot) {
+		if (!lRuleTo?.viaOnly?.pathNot) {
+			lRuleTo.viaOnly = {
+				...lRuleTo.viaOnly,
+				pathNot: normalizeToREAsString(lRuleTo.viaNot),
+			};
+		}
+		delete lRuleTo.viaNot;
+	}
+	if (lRuleTo?.viaSomeNot) {
+		if (!lRuleTo?.via?.pathNot) {
+			lRuleTo.via = {
+				...lRuleTo.via,
+				pathNot: normalizeToREAsString(lRuleTo.viaSomeNot),
+			};
+		}
+		delete lRuleTo.viaSomeNot;
+	}
+	return lRuleTo;
 }
 
 /**
@@ -91,16 +92,16 @@ function normalizeVias(pRuleTo) {
  * @returns {IStrictAnyRuleType}
  */
 function normalizeRule(pRule) {
-  const lRuleTo = normalizeVias(pRule.to);
-  return {
-    ...pRule,
-    severity: normalizeSeverity(pRule.severity),
-    name: normalizeName(pRule.name),
-    from: normalizeREProperties(pRule.from),
-    to: normalizeREProperties(lRuleTo),
-    scope: normalizeScope(pRule.scope),
-    ...(pRule.module ? { module: normalizeREProperties(pRule.module) } : {}),
-  };
+	const lRuleTo = normalizeVias(pRule.to);
+	return {
+		...pRule,
+		severity: normalizeSeverity(pRule.severity),
+		name: normalizeName(pRule.name),
+		from: normalizeREProperties(pRule.from),
+		to: normalizeREProperties(lRuleTo),
+		scope: normalizeScope(pRule.scope),
+		...(pRule.module ? { module: normalizeREProperties(pRule.module) } : {}),
+	};
 }
 
 /**
@@ -113,37 +114,38 @@ function normalizeRule(pRule) {
  * @return {IStrictRuleSet}
  */
 export default function normalizeRuleSet(pRuleSet) {
-  const lRuleSet = structuredClone(pRuleSet);
+	bus.info("parse rule set: normalize");
+	const lRuleSet = structuredClone(pRuleSet);
 
-  if (lRuleSet?.allowed) {
-    lRuleSet.allowedSeverity = normalizeSeverity(lRuleSet.allowedSeverity);
-    if (lRuleSet.allowedSeverity === "ignore") {
-      Reflect.deleteProperty(lRuleSet, "allowed");
-      Reflect.deleteProperty(lRuleSet, "allowedSeverity");
-    } else {
-      lRuleSet.allowed = lRuleSet.allowed.map((pRule) => {
-        const lRuleTo = normalizeVias(pRule.to);
-        return {
-          ...pRule,
-          name: "not-in-allowed",
-          from: normalizeREProperties(pRule.from),
-          to: normalizeREProperties(lRuleTo),
-        };
-      });
-    }
-  }
+	if (lRuleSet?.allowed) {
+		lRuleSet.allowedSeverity = normalizeSeverity(lRuleSet.allowedSeverity);
+		if (lRuleSet.allowedSeverity === "ignore") {
+			Reflect.deleteProperty(lRuleSet, "allowed");
+			Reflect.deleteProperty(lRuleSet, "allowedSeverity");
+		} else {
+			lRuleSet.allowed = lRuleSet.allowed.map((pRule) => {
+				const lRuleTo = normalizeVias(pRule.to);
+				return {
+					...pRule,
+					name: "not-in-allowed",
+					from: normalizeREProperties(pRule.from),
+					to: normalizeREProperties(lRuleTo),
+				};
+			});
+		}
+	}
 
-  if (lRuleSet?.forbidden) {
-    lRuleSet.forbidden = lRuleSet.forbidden
-      .map(normalizeRule)
-      .filter((pRule) => pRule.severity !== "ignore");
-  }
+	if (lRuleSet?.forbidden) {
+		lRuleSet.forbidden = lRuleSet.forbidden
+			.map(normalizeRule)
+			.filter((pRule) => pRule.severity !== "ignore");
+	}
 
-  if (lRuleSet?.required) {
-    lRuleSet.required = lRuleSet.required
-      .map(normalizeRule)
-      .filter((pRule) => pRule.severity !== "ignore");
-  }
+	if (lRuleSet?.required) {
+		lRuleSet.required = lRuleSet.required
+			.map(normalizeRule)
+			.filter((pRule) => pRule.severity !== "ignore");
+	}
 
-  return lRuleSet;
+	return lRuleSet;
 }

package/src/meta.cjs

@@ -1,19 +1,18 @@
 /* generated - don't edit */
-
 module.exports = {
-  version: "17.3.2",
-  engines: {
-    node: "^20.12||^22||>=24",
-  },
-  supportedTranspilers: {
-    babel: ">=7.0.0 <8.0.0",
-    "coffee-script": ">=1.0.0 <2.0.0",
-    coffeescript: ">=1.0.0 <3.0.0",
-    livescript: ">=1.0.0 <2.0.0",
-    svelte: ">=3.0.0 <6.0.0",
-    swc: ">=1.0.0 <2.0.0",
-    typescript: ">=2.0.0 <6.0.0",
-    "vue-template-compiler": ">=2.0.0 <3.0.0",
-    "@vue/compiler-sfc": ">=3.0.0 <4.0.0",
-  },
+	version: "17.3.3-beta-2",
+	engines: {
+		node: "^20.12||^22||>=24",
+	},
+	supportedTranspilers: {
+		babel: ">=7.0.0 <8.0.0",
+		"coffee-script": ">=1.0.0 <2.0.0",
+		coffeescript: ">=1.0.0 <3.0.0",
+		livescript: ">=1.0.0 <2.0.0",
+		svelte: ">=3.0.0 <6.0.0",
+		swc: ">=1.0.0 <2.0.0",
+		typescript: ">=2.0.0 <6.0.0",
+		"vue-template-compiler": ">=2.0.0 <3.0.0",
+		"@vue/compiler-sfc": ">=3.0.0 <4.0.0",
+	},
 };

package/src/report/anon/anonymize-path-element.mjs

@@ -2,42 +2,28 @@ import memoize, { memoizeClear } from "memoize";
 import randomString from "./random-string.mjs";
 
 function replace(pElement, pIndex, pWordList) {
-  return pIndex === 0 ? pWordList.shift() || randomString(pElement) : pElement;
+	return pIndex === 0 ? pWordList.shift() || randomString(pElement) : pElement;
 }
 
 const replaceCached = memoize(replace);
 
 function replaceFromWordList(pPathElement, pWordList, pCached) {
-  return pPathElement
-    .split(".")
-    .map((pElement, pIndex) =>
-      pCached
-        ? replaceCached(pElement, pIndex, pWordList)
-        : replace(pElement, pIndex, pWordList),
-    )
-    .join(".");
+	return pPathElement
+		.split(".")
+		.map((pElement, pIndex) =>
+			pCached
+				? replaceCached(pElement, pIndex, pWordList)
+				: replace(pElement, pIndex, pWordList),
+		)
+		.join(".");
 }
 
 /**
- * Replaces the passed pPathElement with words from the word list.
- * - If the word list is empty use a ('smart') random string (see
- *   randomString)
- * - ... but don't replace if the pPathElement matches the whitelist
- * - and only replace up until the first dot in the pattern, so
- *   extensions get
+ * replaces pPathElement with a word from pWordList
  *
- * superSecureThing.ts => abandon.ts
- * superSecureThing.spec.ts => abandon.spec.ts
- * src/index.ts => src/index.ts // 'src' and 'index' are in the whitelist
- * lib/somethingElse.service.js => lib/ability.service.js
+ * note: _mutates_ the wordlist to avoid using the same word > 1x
  *
- * To make sure the same input value gets the same output on
- * consecutive calls, this function saves the (path element, result)
- * pairs in a cache. If you don't want that pass false to the pCached
- * parameter
- *
- * (note: it _removes_ elements from pWordList to prevent duplicates,
- * so if the word list is precious to you - pass a clone)
+ * See ./anonymize-path-element.md for details
  *
  * @param {string} pPathElement the path element to anonymize
  * @param {string[]} pWordList words to pick from
@@ -46,14 +32,14 @@ function replaceFromWordList(pPathElement, pWordList, pCached) {
  * @return {string} the path element, anonymized if it isn't whitelisted
  */
 export function anonymizePathElement(
-  pPathElement,
-  pWordList = [],
-  pWhiteListRE = /^$/g,
-  pCached = true,
+	pPathElement,
+	pWordList = [],
+	pWhiteListRE = /^$/g,
+	pCached = true,
 ) {
-  return pWhiteListRE.test(pPathElement)
-    ? pPathElement
-    : replaceFromWordList(pPathElement, pWordList, pCached);
+	return pWhiteListRE.test(pPathElement)
+		? pPathElement
+		: replaceFromWordList(pPathElement, pWordList, pCached);
 }
 
 /**
@@ -63,5 +49,5 @@ export function anonymizePathElement(
  * @returns {void}
  */
 export function clearCache() {
-  memoizeClear(replaceCached);
+	memoizeClear(replaceCached);
 }

package/src/report/anon/anonymize-path.mjs

@@ -1,8 +1,8 @@
 import { anonymizePathElement } from "./anonymize-path-element.mjs";
 
 export const WHITELIST_RE =
-  // eslint-disable-next-line security/detect-unsafe-regex
-  /^(?:[.]+|~|bin|apps?|cli|src|libs?|configs?|components?|fixtures?|helpers?|i18n|index\.(?:jsx?|[mc]js|d\.ts|tsx?|vue|coffee|ls)|_?_?mocks?_?_?|node_modules|packages?|package\.json|scripts?|services?|sources?|specs?|_?_?tests?_?_?|types?|uti?ls?|tools)$/;
+	// eslint-disable-next-line security/detect-unsafe-regex
+	/^(?:[.]+|~|bin|apps?|cli|src|libs?|configs?|components?|fixtures?|helpers?|i18n|index\.(?:jsx?|[mc]js|d\.ts|tsx?|vue|coffee|ls)|_?_?mocks?_?_?|node_modules|packages?|package\.json|scripts?|services?|sources?|specs?|_?_?tests?_?_?|types?|uti?ls?|tools)$/;
 
 /**
  * Kind of smartly anonymizes paths, by
@@ -22,14 +22,14 @@ export const WHITELIST_RE =
  * @returns {string} - anonymized path
  */
 export function anonymizePath(
-  pPath,
-  pWordList = [],
-  pWhiteListRE = WHITELIST_RE,
+	pPath,
+	pWordList = [],
+	pWhiteListRE = WHITELIST_RE,
 ) {
-  return pPath
-    .split("/")
-    .map((pPathElement) =>
-      anonymizePathElement(pPathElement, pWordList, pWhiteListRE),
-    )
-    .join("/");
+	return pPath
+		.split("/")
+		.map((pPathElement) =>
+			anonymizePathElement(pPathElement, pWordList, pWhiteListRE),
+		)
+		.join("/");
 }

package/src/report/anon/index.mjs

@@ -3,46 +3,46 @@ import { anonymizePath, WHITELIST_RE } from "./anonymize-path.mjs";
 const EOL = "\n";
 
 function anonymizePathArray(pPathArray, pWordList) {
-  // the coverage ignore is here because the || [] branch isn't taken when running
-  // tests and with the current setup of the anonymize module that's not going
-  // to change. Still want to keep the branch from robustness perspective though.
-  /* c8 ignore next 1 */
-  return (pPathArray || []).map((pPath) => anonymizePath(pPath, pWordList));
+	// coverage ignore: the || [] branch isn't taken when running tests. With the
+	// current setup of the anonymize module that won't change.
+	// We keep the branch for robustness though.
+	/* c8 ignore next 1 */
+	return (pPathArray || []).map((pPath) => anonymizePath(pPath, pWordList));
 }
 
 function anonymizeMiniDependencyArray(
-  pMiniDependencyArray,
-  pWordList,
-  pAttribute = "name",
+	pMiniDependencyArray,
+	pWordList,
+	pAttribute = "name",
 ) {
-  return (pMiniDependencyArray || []).map((pMiniDependency) => ({
-    ...pMiniDependency,
-    [pAttribute]: anonymizePath(pMiniDependency.name, pWordList),
-  }));
+	return (pMiniDependencyArray || []).map((pMiniDependency) => ({
+		...pMiniDependency,
+		[pAttribute]: anonymizePath(pMiniDependency.name, pWordList),
+	}));
 }
 
 function anonymizeDependencies(pDependencies, pWordList) {
-  return pDependencies.map((pDependency) => ({
-    ...pDependency,
-    resolved: anonymizePath(pDependency.resolved, pWordList),
-    module: anonymizePath(pDependency.module, pWordList),
-    cycle: anonymizeMiniDependencyArray(pDependency.cycle, pWordList),
-  }));
+	return pDependencies.map((pDependency) => ({
+		...pDependency,
+		resolved: anonymizePath(pDependency.resolved, pWordList),
+		module: anonymizePath(pDependency.module, pWordList),
+		cycle: anonymizeMiniDependencyArray(pDependency.cycle, pWordList),
+	}));
 }
 
 function anonymizeReachesModule(pWordList) {
-  return (pModule) => ({
-    ...pModule,
-    source: anonymizePath(pModule.source, pWordList),
-    via: anonymizeMiniDependencyArray(pModule.via, pWordList),
-  });
+	return (pModule) => ({
+		...pModule,
+		source: anonymizePath(pModule.source, pWordList),
+		via: anonymizeMiniDependencyArray(pModule.via, pWordList),
+	});
 }
 
 function anonymizeReaches(pReachesArray, pWordList) {
-  return pReachesArray.map((pReaches) => ({
-    ...pReaches,
-    modules: pReaches.modules.map(anonymizeReachesModule(pWordList)),
-  }));
+	return pReachesArray.map((pReaches) => ({
+		...pReaches,
+		modules: pReaches.modules.map(anonymizeReachesModule(pWordList)),
+	}));
 }
 
 /**
@@ -52,24 +52,24 @@ function anonymizeReaches(pReachesArray, pWordList) {
  * @returns {import("../../../types/cruise-result.mjs").IModule[]}
  */
 function anonymizeModules(pModules, pWordList) {
-  return pModules.map((pModule) => {
-    const lReturnValue = {
-      ...pModule,
-      dependencies: anonymizeDependencies(pModule.dependencies, pWordList),
-      source: anonymizePath(pModule.source, pWordList),
-    };
-    if (pModule.dependents) {
-      lReturnValue.dependents = anonymizePathArray(
-        pModule.dependents,
-        pWordList,
-      );
-    }
-    if (pModule.reaches) {
-      lReturnValue.reaches = anonymizeReaches(pModule.reaches, pWordList);
-    }
+	return pModules.map((pModule) => {
+		const lReturnValue = {
+			...pModule,
+			dependencies: anonymizeDependencies(pModule.dependencies, pWordList),
+			source: anonymizePath(pModule.source, pWordList),
+		};
+		if (pModule.dependents) {
+			lReturnValue.dependents = anonymizePathArray(
+				pModule.dependents,
+				pWordList,
+			);
+		}
+		if (pModule.reaches) {
+			lReturnValue.reaches = anonymizeReaches(pModule.reaches, pWordList);
+		}
 
-    return lReturnValue;
-  });
+		return lReturnValue;
+	});
 }
 /**
  *
@@ -78,52 +78,52 @@ function anonymizeModules(pModules, pWordList) {
  * @returns {import("../../../types/cruise-result.mjs").IFolder[]}
  */
 function anonymizeFolders(pFolders, pWordList) {
-  return pFolders.map((pFolder) => {
-    const lReturnValue = {
-      ...pFolder,
-      name: anonymizePath(pFolder.name, pWordList),
-    };
-    if (pFolder.dependencies) {
-      lReturnValue.dependencies = pFolder.dependencies.map((pDependency) => {
-        const lReturnDependencies = {
-          ...pDependency,
-          name: anonymizePath(pDependency.name, pWordList),
-        };
-        if (lReturnDependencies.cycle) {
-          lReturnDependencies.cycle = anonymizeMiniDependencyArray(
-            pDependency.cycle,
-            pWordList,
-          );
-        }
-        return lReturnDependencies;
-      });
-    }
-    if (pFolder.dependents) {
-      lReturnValue.dependents = pFolder.dependents.map((pDependent) => ({
-        ...pDependent,
-        name: anonymizePath(pDependent.name, pWordList),
-      }));
-    }
-    return lReturnValue;
-  });
+	return pFolders.map((pFolder) => {
+		const lReturnValue = {
+			...pFolder,
+			name: anonymizePath(pFolder.name, pWordList),
+		};
+		if (pFolder.dependencies) {
+			lReturnValue.dependencies = pFolder.dependencies.map((pDependency) => {
+				const lReturnDependencies = {
+					...pDependency,
+					name: anonymizePath(pDependency.name, pWordList),
+				};
+				if (lReturnDependencies.cycle) {
+					lReturnDependencies.cycle = anonymizeMiniDependencyArray(
+						pDependency.cycle,
+						pWordList,
+					);
+				}
+				return lReturnDependencies;
+			});
+		}
+		if (pFolder.dependents) {
+			lReturnValue.dependents = pFolder.dependents.map((pDependent) => ({
+				...pDependent,
+				name: anonymizePath(pDependent.name, pWordList),
+			}));
+		}
+		return lReturnValue;
+	});
 }
 
 function anonymizeViolations(pViolations, pWordList) {
-  return pViolations.map((pViolation) => {
-    const lReturnValue = {
-      ...pViolation,
-      from: anonymizePath(pViolation.from, pWordList),
-      to: anonymizePath(pViolation.to, pWordList),
-      cycle: anonymizeMiniDependencyArray(pViolation.cycle, pWordList),
-    };
-    if (pViolation.via) {
-      lReturnValue.via = anonymizeMiniDependencyArray(
-        pViolation.via,
-        pWordList,
-      );
-    }
-    return lReturnValue;
-  });
+	return pViolations.map((pViolation) => {
+		const lReturnValue = {
+			...pViolation,
+			from: anonymizePath(pViolation.from, pWordList),
+			to: anonymizePath(pViolation.to, pWordList),
+			cycle: anonymizeMiniDependencyArray(pViolation.cycle, pWordList),
+		};
+		if (pViolation.via) {
+			lReturnValue.via = anonymizeMiniDependencyArray(
+				pViolation.via,
+				pWordList,
+			);
+		}
+		return lReturnValue;
+	});
 }
 /**
  *
@@ -132,25 +132,25 @@ function anonymizeViolations(pViolations, pWordList) {
  * @returns {import("../../../types/cruise-result.mjs").ICruiseResult}
  */
 function anonymize(pResults, pWordList) {
-  const lResults = structuredClone(pResults);
+	const lResults = structuredClone(pResults);
 
-  lResults.modules = anonymizeModules(lResults.modules, pWordList);
-  if (lResults.folders) {
-    lResults.folders = anonymizeFolders(lResults.folders, pWordList);
-  }
-  lResults.summary.violations = anonymizeViolations(
-    lResults.summary.violations,
-    pWordList,
-  );
+	lResults.modules = anonymizeModules(lResults.modules, pWordList);
+	if (lResults.folders) {
+		lResults.folders = anonymizeFolders(lResults.folders, pWordList);
+	}
+	lResults.summary.violations = anonymizeViolations(
+		lResults.summary.violations,
+		pWordList,
+	);
 
-  return lResults;
+	return lResults;
 }
 
 function sanitizeWordList(pWordList) {
-  return pWordList
-    .map((pString) => pString.replace(/[^a-zA-Z-]/g, "_"))
-    .filter((pString) => pString.match(/^[a-zA-Z-_]+$/g))
-    .filter((pString) => !pString.match(WHITELIST_RE));
+	return pWordList
+		.map((pString) => pString.replace(/[^a-zA-Z-]/g, "_"))
+		.filter((pString) => pString.match(/^[a-zA-Z-_]+$/g))
+		.filter((pString) => !pString.match(WHITELIST_RE));
 }
 
 /**
@@ -176,22 +176,22 @@ function sanitizeWordList(pWordList) {
  *                              exitCode: 0
  */
 export default function reportAnonymous(pResults, pAnonymousReporterOptions) {
-  /** @type {{wordlist?: String[]}} */
-  let lAnonymousReporterOptions = pAnonymousReporterOptions || {};
-  if (!lAnonymousReporterOptions.wordlist) {
-    lAnonymousReporterOptions.wordlist =
-      pResults?.summary?.optionsUsed?.reporterOptions?.anon?.wordlist ?? [];
-  }
-  return {
-    output:
-      JSON.stringify(
-        anonymize(
-          pResults,
-          sanitizeWordList(lAnonymousReporterOptions.wordlist),
-        ),
-        null,
-        "  ",
-      ) + EOL,
-    exitCode: 0,
-  };
+	/** @type {{wordlist?: String[]}} */
+	let lAnonymousReporterOptions = pAnonymousReporterOptions || {};
+	if (!lAnonymousReporterOptions.wordlist) {
+		lAnonymousReporterOptions.wordlist =
+			pResults?.summary?.optionsUsed?.reporterOptions?.anon?.wordlist ?? [];
+	}
+	return {
+		output:
+			JSON.stringify(
+				anonymize(
+					pResults,
+					sanitizeWordList(lAnonymousReporterOptions.wordlist),
+				),
+				null,
+				"  ",
+			) + EOL,
+		exitCode: 0,
+	};
 }