dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/main/options/assert-validity.mjs

@@ -10,91 +10,91 @@ const MODULE_SYSTEM_LIST_RE = /^(?:(?:cjs|amd|es6|tsd)(?:,|$)){1,4}/gi;
 const VALID_DEPTH_RE = /^\d{1,2}$/g;
 
 function isObject(pObject) {
-  return (
-    typeof pObject === "object" && !Array.isArray(pObject) && pObject !== null
-  );
+	return (
+		typeof pObject === "object" && !Array.isArray(pObject) && pObject !== null
+	);
 }
 function deepMerge(pTarget, pSource) {
-  const lOutput = structuredClone(pTarget);
-
-  for (const lKey in pSource) {
-    if (isObject(pSource[lKey])) {
-      if (lKey in pTarget) {
-        lOutput[lKey] = deepMerge(pTarget[lKey], pSource[lKey]);
-      } else {
-        Object.assign(lOutput, { [lKey]: pSource[lKey] });
-      }
-    } else {
-      Object.assign(lOutput, { [lKey]: pSource[lKey] });
-    }
-  }
-
-  return lOutput;
+	const lOutput = structuredClone(pTarget);
+
+	for (const lKey in pSource) {
+		if (isObject(pSource[lKey])) {
+			if (lKey in pTarget) {
+				lOutput[lKey] = deepMerge(pTarget[lKey], pSource[lKey]);
+			} else {
+				Object.assign(lOutput, { [lKey]: pSource[lKey] });
+			}
+		} else {
+			Object.assign(lOutput, { [lKey]: pSource[lKey] });
+		}
+	}
+
+	return lOutput;
 }
 
 function assertModuleSystemsValid(pModuleSystems) {
-  if (
-    pModuleSystems &&
-    Array.isArray(pModuleSystems) &&
-    !pModuleSystems.every((pModuleSystem) =>
-      pModuleSystem.match(MODULE_SYSTEM_LIST_RE),
-    )
-  ) {
-    throw new Error(
-      `Invalid module system list: '${pModuleSystems.join(", ")}'\n`,
-    );
-  }
+	if (
+		pModuleSystems &&
+		Array.isArray(pModuleSystems) &&
+		!pModuleSystems.every((pModuleSystem) =>
+			pModuleSystem.match(MODULE_SYSTEM_LIST_RE),
+		)
+	) {
+		throw new Error(
+			`Invalid module system list: '${pModuleSystems.join(", ")}'\n`,
+		);
+	}
 }
 
 function assertRegExpSafety(pPattern) {
-  if (pPattern && !safeRegex(pPattern)) {
-    throw new Error(
-      `The pattern '${pPattern}' will probably run very slowly - cowardly refusing to run.\n`,
-    );
-  }
+	if (pPattern && !safeRegex(pPattern)) {
+		throw new Error(
+			`The pattern '${pPattern}' will probably run very slowly - cowardly refusing to run.\n`,
+		);
+	}
 }
 
 function assertOutputTypeValid(pOutputType) {
-  if (
-    pOutputType &&
-    !getAvailableReporters().includes(pOutputType) &&
-    !pOutputType.startsWith("plugin:")
-  ) {
-    throw new Error(`'${pOutputType}' is not a valid output type.\n`);
-  }
+	if (
+		pOutputType &&
+		!getAvailableReporters().includes(pOutputType) &&
+		!pOutputType.startsWith("plugin:")
+	) {
+		throw new Error(`'${pOutputType}' is not a valid output type.\n`);
+	}
 }
 
 function assertMaxDepthValid(pDepth) {
-  if (pDepth && !pDepth.toString().match(VALID_DEPTH_RE)) {
-    throw new Error(
-      `'${pDepth}' is not a valid depth - use an integer between 0 and 99`,
-    );
-  }
+	if (pDepth && !pDepth.toString().match(VALID_DEPTH_RE)) {
+		throw new Error(
+			`'${pDepth}' is not a valid depth - use an integer between 0 and 99`,
+		);
+	}
 }
 
 function assertFocusDepthValid(pFocusDepth) {
-  const lFocusDepth = Number.parseInt(pFocusDepth, 10);
-  const lMaxFocusDepth = 99;
-
-  if (
-    pFocusDepth &&
-    (Number.isNaN(lFocusDepth) ||
-      lFocusDepth < 0 ||
-      lFocusDepth > lMaxFocusDepth)
-  ) {
-    throw new Error(
-      `'${pFocusDepth}' is not a valid focus depth - use an integer between 0 and ${lMaxFocusDepth}`,
-    );
-  }
+	const lFocusDepth = Number.parseInt(pFocusDepth, 10);
+	const lMaxFocusDepth = 99;
+
+	if (
+		pFocusDepth &&
+		(Number.isNaN(lFocusDepth) ||
+			lFocusDepth < 0 ||
+			lFocusDepth > lMaxFocusDepth)
+	) {
+		throw new Error(
+			`'${pFocusDepth}' is not a valid focus depth - use an integer between 0 and ${lMaxFocusDepth}`,
+		);
+	}
 }
 
 function assertPathsSafety(pFilterOption) {
-  if (typeof pFilterOption === "string") {
-    assertRegExpSafety(pFilterOption);
-  }
+	if (typeof pFilterOption === "string") {
+		assertRegExpSafety(pFilterOption);
+	}
 
-  assertRegExpSafety(pFilterOption?.path ?? "");
-  assertRegExpSafety(pFilterOption?.pathNot ?? "");
+	assertRegExpSafety(pFilterOption?.path ?? "");
+	assertRegExpSafety(pFilterOption?.pathNot ?? "");
 }
 
 /**
@@ -103,35 +103,35 @@ function assertPathsSafety(pFilterOption) {
  * @returns {ICruiseOptions}
  */
 export function assertCruiseOptionsValid(pOptions) {
-  let lReturnValue = {};
-
-  if (pOptions) {
-    // necessary because can slip through the cracks when passed as a cli parameter
-    assertModuleSystemsValid(pOptions.moduleSystems);
-
-    // necessary because this safety check can't be done in json schema (a.f.a.i.k.)
-    assertPathsSafety(pOptions.doNotFollow);
-    assertPathsSafety(pOptions.exclude);
-    assertRegExpSafety(pOptions.includeOnly);
-    assertRegExpSafety(pOptions.focus);
-    assertRegExpSafety(pOptions.reaches);
-    assertRegExpSafety(pOptions.highlight);
-    assertRegExpSafety(pOptions.collapse);
-
-    // necessary because not in the config schema
-    assertOutputTypeValid(pOptions.outputType);
-
-    // necessary because not found a way to do this properly in JSON schema
-    assertMaxDepthValid(pOptions.maxDepth);
-
-    assertFocusDepthValid(pOptions.focusDepth);
-
-    if (pOptions?.ruleSet?.options) {
-      lReturnValue = assertCruiseOptionsValid(pOptions.ruleSet.options);
-    }
-    return deepMerge(lReturnValue, pOptions);
-  }
-  return lReturnValue;
+	let lReturnValue = {};
+
+	if (pOptions) {
+		// necessary because can slip through the cracks when passed as a cli parameter
+		assertModuleSystemsValid(pOptions.moduleSystems);
+
+		// necessary because this safety check can't be done in json schema (a.f.a.i.k.)
+		assertPathsSafety(pOptions.doNotFollow);
+		assertPathsSafety(pOptions.exclude);
+		assertRegExpSafety(pOptions.includeOnly);
+		assertRegExpSafety(pOptions.focus);
+		assertRegExpSafety(pOptions.reaches);
+		assertRegExpSafety(pOptions.highlight);
+		assertRegExpSafety(pOptions.collapse);
+
+		// necessary because not in the config schema
+		assertOutputTypeValid(pOptions.outputType);
+
+		// necessary because not found a way to do this properly in JSON schema
+		assertMaxDepthValid(pOptions.maxDepth);
+
+		assertFocusDepthValid(pOptions.focusDepth);
+
+		if (pOptions?.ruleSet?.options) {
+			lReturnValue = assertCruiseOptionsValid(pOptions.ruleSet.options);
+		}
+		return deepMerge(lReturnValue, pOptions);
+	}
+	return lReturnValue;
 }
 
 /**
@@ -140,11 +140,11 @@ export function assertCruiseOptionsValid(pOptions) {
  * @throws {Error}
  */
 export function assertFormatOptionsValid(pFormatOptions) {
-  assertPathsSafety(pFormatOptions.exclude);
-  assertPathsSafety(pFormatOptions.focus);
-  assertPathsSafety(pFormatOptions.reaches);
-  assertPathsSafety(pFormatOptions.includeOnly);
-  assertRegExpSafety(pFormatOptions.collapse);
-  assertOutputTypeValid(pFormatOptions.outputType);
-  assertFocusDepthValid(pFormatOptions.focusDepth);
+	assertPathsSafety(pFormatOptions.exclude);
+	assertPathsSafety(pFormatOptions.focus);
+	assertPathsSafety(pFormatOptions.reaches);
+	assertPathsSafety(pFormatOptions.includeOnly);
+	assertRegExpSafety(pFormatOptions.collapse);
+	assertOutputTypeValid(pFormatOptions.outputType);
+	assertFocusDepthValid(pFormatOptions.focusDepth);
 }

package/src/main/options/defaults.mjs

@@ -1,14 +1,14 @@
 /** @type {import('../../../types/strict-options').IStrictCruiseOptions} */
 export default {
-  validate: false,
-  maxDepth: 0,
-  moduleSystems: ["es6", "cjs", "tsd", "amd"],
-  detectJSDocImports: false,
-  detectProcessBuiltinModuleCalls: false,
-  skipAnalysisNotInRules: false,
-  tsPreCompilationDeps: false,
-  preserveSymlinks: false,
-  combinedDependencies: false,
-  externalModuleResolutionStrategy: "node_modules",
-  exoticRequireStrings: [],
+	validate: false,
+	maxDepth: 0,
+	moduleSystems: ["es6", "cjs", "tsd", "amd"],
+	detectJSDocImports: false,
+	detectProcessBuiltinModuleCalls: false,
+	skipAnalysisNotInRules: false,
+	tsPreCompilationDeps: false,
+	preserveSymlinks: false,
+	combinedDependencies: false,
+	externalModuleResolutionStrategy: "node_modules",
+	exoticRequireStrings: [],
 };

package/src/main/options/normalize.mjs

@@ -15,76 +15,76 @@ const DEFAULT_CACHE_FOLDER = "node_modules/.cache/dependency-cruiser";
 const DEFAULT_CACHE_STRATEGY = "metadata";
 
 function normalizeFilterOption(pFilterOption) {
-  let lReturnValue = pFilterOption || {};
-
-  if (typeof lReturnValue === "string" || Array.isArray(lReturnValue)) {
-    lReturnValue = {
-      path: lReturnValue,
-    };
-  }
-  return normalizeREProperties(lReturnValue, ["path"]);
+	let lReturnValue = pFilterOption || {};
+
+	if (typeof lReturnValue === "string" || Array.isArray(lReturnValue)) {
+		lReturnValue = {
+			path: lReturnValue,
+		};
+	}
+	return normalizeREProperties(lReturnValue, ["path"]);
 }
 
 function normalizeReporterOptions(pReporterOptions) {
-  const lNormalizeableOptions = [
-    "archi.collapsePattern",
-    "archi.filters.includeOnly.path",
-    "archi.filters.focus.path",
-    "archi.filters.exclude.path",
-    "dot.collapsePattern",
-    "dot.filters.includeOnly.path",
-    "dot.filters.focus.path",
-    "dot.filters.exclude.path",
-    "ddot.collapsePattern",
-    "ddot.filters.includeOnly.path",
-    "ddot.filters.focus.path",
-    "ddot.filters.exclude.path",
-  ];
-
-  return normalizeREProperties(pReporterOptions, lNormalizeableOptions);
+	const lNormalizeableOptions = [
+		"archi.collapsePattern",
+		"archi.filters.includeOnly.path",
+		"archi.filters.focus.path",
+		"archi.filters.exclude.path",
+		"dot.collapsePattern",
+		"dot.filters.includeOnly.path",
+		"dot.filters.focus.path",
+		"dot.filters.exclude.path",
+		"ddot.collapsePattern",
+		"ddot.filters.includeOnly.path",
+		"ddot.filters.focus.path",
+		"ddot.filters.exclude.path",
+	];
+
+	return normalizeREProperties(pReporterOptions, lNormalizeableOptions);
 }
 
 function normalizeFilterOptions(pOptions, pFilterOptionKeys) {
-  let lReturnValue = { ...pOptions };
-
-  for (let lFilterOptionKey of pFilterOptionKeys) {
-    if (pOptions[lFilterOptionKey]) {
-      lReturnValue[lFilterOptionKey] = normalizeFilterOption(
-        lReturnValue[lFilterOptionKey],
-      );
-    }
-  }
-  return lReturnValue;
+	let lReturnValue = { ...pOptions };
+
+	for (const lFilterOptionKey of pFilterOptionKeys) {
+		if (pOptions[lFilterOptionKey]) {
+			lReturnValue[lFilterOptionKey] = normalizeFilterOption(
+				lReturnValue[lFilterOptionKey],
+			);
+		}
+	}
+	return lReturnValue;
 }
 
 function normalizeCollapse(pCollapse) {
-  let lReturnValue = pCollapse;
-  const lOneOrMoreNonSlashes = "[^/]+";
-  const lFolderPattern = `${lOneOrMoreNonSlashes}/`;
-  const lFolderBelowNodeModules = `node_modules/${lOneOrMoreNonSlashes}`;
-  const lSingleDigitRe = /^\d$/;
-
-  if (typeof pCollapse === "number" || pCollapse.match(lSingleDigitRe)) {
-    lReturnValue = `${lFolderBelowNodeModules}|^${lFolderPattern.repeat(
-      Number.parseInt(pCollapse, 10),
-    )}`;
-  }
-  return lReturnValue;
+	let lReturnValue = pCollapse;
+	const lOneOrMoreNonSlashes = "[^/]+";
+	const lFolderPattern = `${lOneOrMoreNonSlashes}/`;
+	const lFolderBelowNodeModules = `node_modules/${lOneOrMoreNonSlashes}`;
+	const lSingleDigitRe = /^\d$/;
+
+	if (typeof pCollapse === "number" || pCollapse.match(lSingleDigitRe)) {
+		lReturnValue = `${lFolderBelowNodeModules}|^${lFolderPattern.repeat(
+			Number.parseInt(pCollapse, 10),
+		)}`;
+	}
+	return lReturnValue;
 }
 
 function normalizeFocusDepth(pFormatOptions) {
-  /** @type {IFormatOptions}*/
-  let lFormatOptions = structuredClone(pFormatOptions);
-  if (Object.hasOwn(lFormatOptions, "focusDepth")) {
-    if (lFormatOptions?.focus) {
-      lFormatOptions.focus.depth = Number.parseInt(
-        lFormatOptions.focusDepth,
-        10,
-      );
-    }
-    delete lFormatOptions.focusDepth;
-  }
-  return lFormatOptions;
+	/** @type {IFormatOptions}*/
+	let lFormatOptions = structuredClone(pFormatOptions);
+	if (Object.hasOwn(lFormatOptions, "focusDepth")) {
+		if (lFormatOptions?.focus) {
+			lFormatOptions.focus.depth = Number.parseInt(
+				lFormatOptions.focusDepth,
+				10,
+			);
+		}
+		delete lFormatOptions.focusDepth;
+	}
+	return lFormatOptions;
 }
 
 /**
@@ -93,13 +93,13 @@ function normalizeFocusDepth(pFormatOptions) {
  * @returns {boolean}
  */
 function hasMetricsRule(pRule) {
-  // TODO: philosophy: is a rule with 'folder' in it a metrics rule?
-  //       Or is it a misuse to ensure folder derivations (like cycles) get
-  //       kicked off?
-  return (
-    Object.hasOwn(pRule?.to ?? {}, "moreUnstable") ||
-    (pRule?.scope ?? "module") === "folder"
-  );
+	// TODO: philosophy: is a rule with 'folder' in it a metrics rule?
+	//       Or is it a misuse to ensure folder derivations (like cycles) get
+	//       kicked off?
+	return (
+		Object.hasOwn(pRule?.to ?? {}, "moreUnstable") ||
+		(pRule?.scope ?? "module") === "folder"
+	);
 }
 
 /**
@@ -108,11 +108,11 @@ function hasMetricsRule(pRule) {
  * @returns {boolean}
  */
 function ruleSetHasMetricsRule(pRuleSet) {
-  const lRuleSet = pRuleSet || {};
-  return (
-    (lRuleSet.forbidden || []).some(hasMetricsRule) ||
-    (lRuleSet.allowed || []).some(hasMetricsRule)
-  );
+	const lRuleSet = pRuleSet || {};
+	return (
+		(lRuleSet.forbidden || []).some(hasMetricsRule) ||
+		(lRuleSet.allowed || []).some(hasMetricsRule)
+	);
 }
 
 /**
@@ -121,10 +121,10 @@ function ruleSetHasMetricsRule(pRuleSet) {
  * @returns Boolean
  */
 function reporterShowsMetrics(pOptions) {
-  return (
-    (pOptions.reporterOptions?.[pOptions?.outputType]?.showMetrics ?? false) ===
-    true
-  );
+	return (
+		(pOptions.reporterOptions?.[pOptions?.outputType]?.showMetrics ?? false) ===
+		true
+	);
 }
 
 /**
@@ -134,12 +134,12 @@ function reporterShowsMetrics(pOptions) {
  * @returns Boolean
  */
 function shouldCalculateMetrics(pOptions) {
-  return (
-    pOptions.metrics ||
-    pOptions.outputType === "metrics" ||
-    reporterShowsMetrics(pOptions) ||
-    ruleSetHasMetricsRule(pOptions.ruleSet)
-  );
+	return (
+		pOptions.metrics ||
+		pOptions.outputType === "metrics" ||
+		reporterShowsMetrics(pOptions) ||
+		ruleSetHasMetricsRule(pOptions.ruleSet)
+	);
 }
 
 /**
@@ -147,26 +147,26 @@ function shouldCalculateMetrics(pOptions) {
  * @returns {ICacheOptions}
  */
 function normalizeCacheOptions(pCacheOptions) {
-  let lNormalizedCacheOptions = pCacheOptions;
-
-  if (typeof pCacheOptions === "string") {
-    lNormalizedCacheOptions = {
-      folder: pCacheOptions,
-    };
-  }
-
-  if (pCacheOptions === true) {
-    lNormalizedCacheOptions = {};
-  }
-
-  // TODO: put these values in a central spot as constants
-  //      (folder is already in src/cli/defaults.js but depending on the UI (cli)
-  //       is not OK. We might b.t.w. wanna deduplicate the defaulting)
-  return {
-    folder: DEFAULT_CACHE_FOLDER,
-    strategy: DEFAULT_CACHE_STRATEGY,
-    ...lNormalizedCacheOptions,
-  };
+	let lNormalizedCacheOptions = pCacheOptions;
+
+	if (typeof pCacheOptions === "string") {
+		lNormalizedCacheOptions = {
+			folder: pCacheOptions,
+		};
+	}
+
+	if (pCacheOptions === true) {
+		lNormalizedCacheOptions = {};
+	}
+
+	// TODO: put these values in a central spot as constants
+	//      (folder is already in src/cli/defaults.js but depending on the UI (cli)
+	//       is not OK. We might b.t.w. wanna deduplicate the defaulting)
+	return {
+		folder: DEFAULT_CACHE_FOLDER,
+		strategy: DEFAULT_CACHE_STRATEGY,
+		...lNormalizedCacheOptions,
+	};
 }
 
 /**
@@ -176,54 +176,52 @@ function normalizeCacheOptions(pCacheOptions) {
  * @returns {IStrictCruiseOptions}
  */
 export function normalizeCruiseOptions(pOptions, pFileAndDirectoryArray = []) {
-  /** @type {IStrictCruiseOptions} */
-  let lReturnValue = {
-    baseDir: process.cwd(),
-    ...defaults,
-    ...pOptions,
-    args: pFileAndDirectoryArray.join(" "),
-  };
-
-  // @ts-expect-error the idea of normalizing maxDepth to number is that after
-  // that we're sure it's a number. Should maybe best be solved by
-  // having two types/ interfaces
-  lReturnValue.maxDepth = Number.parseInt(lReturnValue.maxDepth, 10);
-  lReturnValue.moduleSystems = uniq(lReturnValue.moduleSystems);
-  if (Object.hasOwn(lReturnValue, "collapse")) {
-    lReturnValue.collapse = normalizeCollapse(lReturnValue.collapse);
-  }
-  // TODO: further down the execution path code still relies on .doNotFollow
-  //       and .exclude existing. We should treat them the same as the
-  //       other filters (so either make all exist always or only
-  //       when they're actually defined)
-  lReturnValue.doNotFollow = normalizeFilterOption(lReturnValue.doNotFollow);
-  lReturnValue.exclude = normalizeFilterOption(lReturnValue.exclude);
-  lReturnValue.extraExtensionsToScan = lReturnValue.extraExtensionsToScan || [];
-  lReturnValue = normalizeFilterOptions(lReturnValue, [
-    "focus",
-    "includeOnly",
-    "reaches",
-    "highlight",
-  ]);
-
-  lReturnValue.exoticRequireStrings = uniq(lReturnValue.exoticRequireStrings);
-  if (lReturnValue.reporterOptions) {
-    lReturnValue.reporterOptions = normalizeReporterOptions(
-      lReturnValue.reporterOptions,
-    );
-  }
-  lReturnValue.metrics = shouldCalculateMetrics(pOptions);
-  // if (has(pOptions, "ruleSet")) {
-  //   lReturnValue.ruleSet = normalizeRuleSet(pOptions.ruleSet);
-  // }
-  if (lReturnValue.cache) {
-    lReturnValue.cache = normalizeCacheOptions(lReturnValue.cache);
-  }
-  if (lReturnValue.detectJSDocImports) {
-    lReturnValue.parser = "tsc";
-  }
-
-  return normalizeFocusDepth(lReturnValue);
+	/** @type {IStrictCruiseOptions} */
+	let lReturnValue = {
+		baseDir: process.cwd(),
+		...defaults,
+		...pOptions,
+		args: pFileAndDirectoryArray.join(" "),
+	};
+
+	// @ts-expect-error the idea of normalizing maxDepth to number is that after
+	// that we're sure it's a number. Should maybe best be solved by
+	// having two types/ interfaces
+	lReturnValue.maxDepth = Number.parseInt(lReturnValue.maxDepth, 10);
+	lReturnValue.moduleSystems = uniq(lReturnValue.moduleSystems);
+	if (Object.hasOwn(lReturnValue, "collapse")) {
+		lReturnValue.collapse = normalizeCollapse(lReturnValue.collapse);
+	}
+	// TODO: further down the execution path code still relies on .doNotFollow
+	//       and .exclude existing. We should treat them the same as the
+	//       other filters (so either make all exist always or only
+	//       when they're actually defined)
+	lReturnValue.doNotFollow = normalizeFilterOption(lReturnValue.doNotFollow);
+	lReturnValue.exclude = normalizeFilterOption(lReturnValue.exclude);
+	lReturnValue.extraExtensionsToScan = lReturnValue.extraExtensionsToScan || [];
+	lReturnValue = normalizeFilterOptions(lReturnValue, [
+		"focus",
+		"includeOnly",
+		"reaches",
+		"highlight",
+	]);
+
+	lReturnValue.exoticRequireStrings = uniq(lReturnValue.exoticRequireStrings);
+	if (lReturnValue.reporterOptions) {
+		lReturnValue.reporterOptions = normalizeReporterOptions(
+			lReturnValue.reporterOptions,
+		);
+	}
+	lReturnValue.metrics = shouldCalculateMetrics(pOptions);
+
+	if (lReturnValue.cache) {
+		lReturnValue.cache = normalizeCacheOptions(lReturnValue.cache);
+	}
+	if (lReturnValue.detectJSDocImports) {
+		lReturnValue.parser = "tsc";
+	}
+
+	return normalizeFocusDepth(lReturnValue);
 }
 
 /**
@@ -231,19 +229,19 @@ export function normalizeCruiseOptions(pOptions, pFileAndDirectoryArray = []) {
  * @returns {IStrictFormatOptions}
  */
 export function normalizeFormatOptions(pFormatOptions) {
-  let lFormatOptions = structuredClone(pFormatOptions);
+	let lFormatOptions = structuredClone(pFormatOptions);
 
-  if (Object.hasOwn(lFormatOptions, "collapse")) {
-    lFormatOptions.collapse = normalizeCollapse(lFormatOptions.collapse);
-  }
+	if (Object.hasOwn(lFormatOptions, "collapse")) {
+		lFormatOptions.collapse = normalizeCollapse(lFormatOptions.collapse);
+	}
 
-  lFormatOptions = normalizeFilterOptions(lFormatOptions, [
-    "exclude",
-    "focus",
-    "highlight",
-    "includeOnly",
-    "reaches",
-  ]);
+	lFormatOptions = normalizeFilterOptions(lFormatOptions, [
+		"exclude",
+		"focus",
+		"highlight",
+		"includeOnly",
+		"reaches",
+	]);
 
-  return normalizeFocusDepth(lFormatOptions);
+	return normalizeFocusDepth(lFormatOptions);
 }