dependency-cruiser 17.3.3-beta-2 → 17.3.3-beta-4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dependency-cruiser",
-	"version": "17.3.3-beta-2",
+	"version": "17.3.3-beta-4",
 	"description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
 	"keywords": [
 		"static analysis",

package/src/cache/find-content-changes.mjs

@@ -98,7 +98,10 @@ export default function findContentChanges(
 	);
 
 	bus.debug("cache: - get (new - cached)");
-	lDiffCachedVsNew.forEach(({ name }) => lFileSet.delete(name));
+	// eslint-disable-next-line budapestian/local-variable-pattern
+	for (const { name } of lDiffCachedVsNew) {
+		lFileSet.delete(name);
+	}
 
 	const lDiffNewVsCached = [];
 	for (const lFileName of lFileSet) {

package/src/cli/init-config/build-config.mjs

@@ -45,8 +45,8 @@ function buildNotToTestRule(pInitOptions) {
       }
     },`;
 	return pInitOptions.hasTestsOutsideSource
-		? lNotToTestRule.replace(
-				/{{testLocationRE}}/g,
+		? lNotToTestRule.replaceAll(
+				"{{testLocationRE}}",
 				folderNameArrayToRE(pInitOptions?.testLocation ?? []),
 			)
 		: "";
@@ -211,12 +211,12 @@ function buildBuiltInModulesAttribute(pInitOptions) {
  */
 export default function buildConfig(pInitOptions) {
 	return configTemplate
-		.replace(
-			/{{sourceLocationRE}}/g,
+		.replaceAll(
+			"{{sourceLocationRE}}",
 			folderNameArrayToRE(pInitOptions.sourceLocation),
 		)
-		.replace(
-			/{{resolutionExtensionsAsString}}/g,
+		.replaceAll(
+			"{{resolutionExtensionsAsString}}",
 			extensionsToString(pInitOptions.resolutionExtensions),
 		)
 		.replace("{{notToTestRule}}", buildNotToTestRule(pInitOptions))

package/src/cli/init-config/utl.mjs

@@ -5,7 +5,7 @@
  */
 export function folderNameArrayToRE(pArrayOfStrings) {
 	const lFoldersInARE = pArrayOfStrings
-		.map((pName) => pName.replace(/\\/g, "\\\\").replace(/\./g, "\\."))
+		.map((pName) => pName.replaceAll("\\", "\\\\").replaceAll(".", "\\."))
 		.join("|");
 
 	return `^(${lFoldersInARE})`;

package/src/enrich/derive/reachable.mjs

@@ -4,7 +4,7 @@ import {
 	matchToModulePathNot,
 } from "#validate/matchers.mjs";
 import IndexedModuleGraph from "#graph-utl/indexed-module-graph.mjs";
-import { extractGroups } from "#utl/regex-util.mjs";
+import { getCachedRegExp, extractGroups } from "#utl/regex-util.mjs";
 
 function isReachableRule(pRule) {
 	return Object.hasOwn(pRule?.to ?? {}, "reachable");
@@ -18,15 +18,25 @@ function getReachableRules(pRuleSet) {
 }
 
 function isModuleInRuleFrom(pRule) {
+	const lRuleFrom = pRule.from ?? pRule.module;
+	if (!lRuleFrom) {
+		return () => false;
+	}
+	const lRuleFromPathRE = lRuleFrom.path
+		? getCachedRegExp(lRuleFrom.path)
+		: null;
+	const lRuleFromPathNotRE = lRuleFrom.pathNot
+		? getCachedRegExp(lRuleFrom.pathNot)
+		: null;
+
 	return (pModule) => {
-		const lRuleFrom = pRule.from ?? pRule.module;
-		if (lRuleFrom) {
-			return (
-				(!lRuleFrom.path || pModule.source.match(lRuleFrom.path)) &&
-				(!lRuleFrom.pathNot || !pModule.source.match(lRuleFrom.pathNot))
-			);
+		if (lRuleFromPathRE && !lRuleFromPathRE.test(pModule.source)) {
+			return false;
+		}
+		if (lRuleFromPathNotRE && lRuleFromPathNotRE.test(pModule.source)) {
+			return false;
 		}
-		return false;
+		return true;
 	};
 }
 
@@ -118,12 +128,11 @@ function shouldAddReachable(pRule, pModuleTo, pGraph) {
 }
 
 function addReachesToModule(pModule, pGraph, pIndexedGraph, pReachableRule) {
-	const lToModules = pGraph.filter((pToModule) =>
-		isModuleInRuleTo(pReachableRule, pToModule, pModule),
-	);
-
-	for (const lToModule of lToModules) {
-		if (pModule.source !== lToModule.source) {
+	for (const lToModule of pGraph) {
+		if (
+			pModule.source !== lToModule.source &&
+			isModuleInRuleTo(pReachableRule, lToModule, pModule)
+		) {
 			const lPath = pIndexedGraph.getPath(pModule.source, lToModule.source);
 
 			if (lPath.length > 0) {

package/src/extract/resolve/index.mjs

@@ -146,7 +146,7 @@ function resolveWithRetry(
 		lReturnValue.couldNotResolve &&
 		canBeResolvedToTsVariant(lStrippedModuleName)
 	) {
-		const lModuleWithoutExtension = lStrippedModuleName.replace(
+		const lModuleWithoutExtension = lStrippedModuleName.replaceAll(
 			/\.(js|jsx|cjs|mjs)$/g,
 			"",
 		);
@@ -225,9 +225,8 @@ export default function resolve(
 		// enhanced-resolve inserts a NULL character in front of any `#` character.
 		// This wonky replace corrects that so the filename again corresponds
 		// with a real file on disk
-		const lResolvedEHRCorrected = lResolvedDependency.resolved.replace(
-			// eslint-disable-next-line no-control-regex
-			/\u0000#/g,
+		const lResolvedEHRCorrected = lResolvedDependency.resolved.replaceAll(
+			"\u0000#",
 			"#",
 		);
 		const lResolvedYarnVirtual = resolveYarnVirtual(

package/src/extract/resolve/module-classifiers.mjs

@@ -3,9 +3,9 @@ import { isAbsolute, resolve as path_resolve } from "node:path";
 import { join as posix_join } from "node:path/posix";
 import picomatch from "picomatch";
 import getExtension from "#utl/get-extension.mjs";
+import { getCachedRegExp } from "#utl/regex-util.mjs";
 
 /**
- * @import { IResolveOptions } from "../../../types/resolve-options.mjs"
  * @import { ITranspileOptions } from "../../../types/dependency-cruiser.mjs"
  */
 
@@ -108,10 +108,8 @@ function isSubpathImport(pModuleName, pManifest) {
 			// replacement only.
 			// Quoting https://nodejs.org/api/packages.html#subpath-imports :
 			// > "* maps expose nested subpaths as it is a string replacement syntax only"
-			const lMatchREasString = pImportLHS.replace(/\*/g, ".+");
-			// eslint-disable-next-line security/detect-non-literal-regexp
-			const lMatchRE = new RegExp(`^${lMatchREasString}$`);
-			return lMatchRE.test(pModuleName);
+			const lMatchREasString = pImportLHS.replaceAll("*", ".+");
+			return getCachedRegExp(`^${lMatchREasString}$`).test(pModuleName);
 		})
 	);
 }
@@ -226,11 +224,9 @@ function matchesTSConfigPaths(pModuleName, pPaths) {
 	//
 	// TODO: 'any string' - does this include the empty string as well? Checks seem
 	// to indicate it doesn't, so we use `.+` instead of `.*`
-	return Object.keys(pPaths).some((pPathLHS) => {
-		// eslint-disable-next-line security/detect-non-literal-regexp
-		const lMatchRE = new RegExp(`^${pPathLHS.replace(/\*/g, ".+")}$`);
-		return lMatchRE.test(pModuleName);
-	});
+	return Object.keys(pPaths).some((pPathLHS) =>
+		getCachedRegExp(`^${pPathLHS.replaceAll("*", ".+")}$`).test(pModuleName),
+	);
 }
 
 function stripExtension(pModulePath) {

package/src/extract/tsc/extract-typescript-deps.mjs

@@ -560,7 +560,6 @@ export default function extractTypeScriptDependencies(
 	pDetectJSDocImports,
 	pDetectProcessBuiltinModuleCalls,
 ) {
-	// console.dir(pTypeScriptAST, { depth: 100 });
 	return typescript
 		? extractImports(pTypeScriptAST)
 				.concat(extractExports(pTypeScriptAST))

package/src/graph-utl/consolidate-to-pattern.mjs

@@ -1,9 +1,12 @@
 import consolidateModules from "./consolidate-modules.mjs";
 import consolidateModuleDependencies from "./consolidate-module-dependencies.mjs";
+import { getCachedRegExp } from "#utl/regex-util.mjs";
 
 function squashDependencyToPattern(pCollapsePattern) {
 	return (pDependency) => {
-		const lCollapseMatch = pDependency.resolved.match(pCollapsePattern);
+		const lCollapseMatch = getCachedRegExp(pCollapsePattern).exec(
+			pDependency.resolved,
+		);
 
 		return {
 			...pDependency,
@@ -27,7 +30,9 @@ function determineConsolidatedness(pConsolidated, pCollapseMatch, pSource) {
 
 function squashModuleToPattern(pCollapsePattern) {
 	return (pModule) => {
-		const lCollapseMatch = pModule.source.match(pCollapsePattern);
+		const lCollapseMatch = getCachedRegExp(pCollapsePattern).exec(
+			pModule.source,
+		);
 
 		return {
 			...pModule,

package/src/graph-utl/indexed-module-graph.mjs

@@ -164,25 +164,19 @@ export default class IndexedModuleGraph {
 		if (!lFromNode) {
 			return [];
 		}
+		for (const lDependency of lFromNode.dependencies) {
+			if (!pVisited.has(lDependency.name)) {
+				if (lDependency.name === pTo) {
+					return [this.#geldEdge(lDependency)];
+				}
+				let lCandidatePath = this.getPath(lDependency.name, pTo, pVisited);
 
-		const lDirectUnvisitedDependencies = lFromNode.dependencies
-			.filter((pDependency) => !pVisited.has(pDependency.name))
-			.map(this.#geldEdge);
-		const lFoundDependency = lDirectUnvisitedDependencies.find(
-			(pDependency) => pDependency.name === pTo,
-		);
-
-		if (lFoundDependency) {
-			return [lFoundDependency];
-		}
-
-		for (const lNewFrom of lDirectUnvisitedDependencies) {
-			let lCandidatePath = this.getPath(lNewFrom.name, pTo, pVisited);
-
-			if (lCandidatePath.length > 0) {
-				return [lNewFrom].concat(lCandidatePath);
+				if (lCandidatePath.length > 0) {
+					return [this.#geldEdge(lDependency)].concat(lCandidatePath);
+				}
 			}
 		}
+
 		return [];
 	}
 

package/src/graph-utl/match-facade.mjs

@@ -1,5 +1,7 @@
+import { getCachedRegExp } from "#utl/regex-util.mjs";
+
 export function filenameMatchesPattern(pFullPathToFile, pPattern) {
-	return RegExp(pPattern, "g").test(pFullPathToFile);
+	return getCachedRegExp(pPattern).test(pFullPathToFile);
 }
 
 export function moduleMatchesFilter(pModule, pFilter) {

package/src/main/cruise.mjs

@@ -3,6 +3,7 @@ import { assertCruiseOptionsValid } from "./options/assert-validity.mjs";
 import { normalizeCruiseOptions } from "./options/normalize.mjs";
 import reportWrap from "./report-wrap.mjs";
 import { bus } from "#utl/bus.mjs";
+import { clearRegExpCache } from "#utl/regex-util.mjs";
 
 const TOTAL_STEPS = 10;
 
@@ -104,5 +105,10 @@ export default async function cruise(
 	}
 
 	bus.summary("report", c(9));
-	return await reportWrap(lCruiseResult, lCruiseOptions);
+	const lResult = await reportWrap(lCruiseResult, lCruiseOptions);
+
+	bus.debug("clear regex cache");
+	clearRegExpCache();
+
+	return lResult;
 }

package/src/main/options/normalize.mjs

@@ -64,7 +64,7 @@ function normalizeCollapse(pCollapse) {
 	const lFolderBelowNodeModules = `node_modules/${lOneOrMoreNonSlashes}`;
 	const lSingleDigitRe = /^\d$/;
 
-	if (typeof pCollapse === "number" || pCollapse.match(lSingleDigitRe)) {
+	if (typeof pCollapse === "number" || lSingleDigitRe.test(pCollapse)) {
 		lReturnValue = `${lFolderBelowNodeModules}|^${lFolderPattern.repeat(
 			Number.parseInt(pCollapse, 10),
 		)}`;

package/src/meta.cjs

@@ -1,6 +1,6 @@
 /* generated - don't edit */
 module.exports = {
-	version: "17.3.3-beta-2",
+	version: "17.3.3-beta-4",
 	engines: {
 		node: "^20.12||^22||>=24",
 	},

package/src/report/anon/index.mjs

@@ -1,3 +1,4 @@
+import { clearCache } from "./anonymize-path-element.mjs";
 import { anonymizePath, WHITELIST_RE } from "./anonymize-path.mjs";
 
 const EOL = "\n";
@@ -148,9 +149,11 @@ function anonymize(pResults, pWordList) {
 
 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));
+		.map((pString) => pString.replaceAll(/[^a-zA-Z-]/g, "_"))
+		.filter(
+			(pString) =>
+				/^[a-zA-Z-_]+$/g.test(pString) && !WHITELIST_RE.test(pString),
+		);
 }
 
 /**
@@ -182,7 +185,7 @@ export default function reportAnonymous(pResults, pAnonymousReporterOptions) {
 		lAnonymousReporterOptions.wordlist =
 			pResults?.summary?.optionsUsed?.reporterOptions?.anon?.wordlist ?? [];
 	}
-	return {
+	const lReturnValue = {
 		output:
 			JSON.stringify(
 				anonymize(
@@ -194,4 +197,6 @@ export default function reportAnonymous(pResults, pAnonymousReporterOptions) {
 			) + EOL,
 		exitCode: 0,
 	};
+	clearCache();
+	return lReturnValue;
 }

package/src/report/dot-webpage/svg-in-html-snippets/script.cjs

@@ -270,7 +270,7 @@ function skewLineABit(lDrawingInstructions) {
 	// Even this value is so small that it is not visible to the
 	// human eye (tested with the two I have at my disposal).
 	var lIncrement = 0.001;
-	var lNewLastValue = parseFloat(lLastValue) + lIncrement;
+	var lNewLastValue = Number.parseFloat(lLastValue) + lIncrement;
 
 	return lDrawingInstructions.replace(lLastValue, lNewLastValue);
 }

package/src/report/mermaid.mjs

@@ -106,10 +106,10 @@ function focusHighlights(pModules, pNamesHashMap) {
 
 const hashToReadableNodeName = (pNode) =>
 	pNode
-		.replace(ACORN_DUMMY_VALUE, "__unknown__")
-		.replace(/^\.$|^\.\//g, "__currentPath__")
-		.replace(/^\.{2}$|^\.{2}\//g, "__prevPath__")
-		.replace(/[[\]/.@~-]/g, "_");
+		.replaceAll(ACORN_DUMMY_VALUE, "__unknown__")
+		.replaceAll(/^\.$|^\.\//g, "__currentPath__")
+		.replaceAll(/^\.{2}$|^\.{2}\//g, "__prevPath__")
+		.replaceAll(/[[\]/.@~-]/g, "_");
 
 /**
  * @param {import("../../types/cruise-result").IModule[]} pModules

package/src/report/plugins.mjs

@@ -43,7 +43,7 @@ async function getPluginReporter(pOutputType) {
 
 export function getExternalPluginReporter(pOutputType) {
 	const lPluginPatternRE = /^plugin:(?<pluginName>.+)$/;
-	const lPluginMatch = (pOutputType || "").match(lPluginPatternRE);
+	const lPluginMatch = lPluginPatternRE.exec(pOutputType || "");
 
 	if (lPluginMatch?.groups) {
 		return getPluginReporter(lPluginMatch.groups.pluginName);

package/src/report/teamcity.mjs

@@ -19,18 +19,18 @@ function escape(pMessageString) {
 	return (
 		pMessageString
 			.toString()
-			.replace(/\|/g, "||")
-			.replace(/\n/g, "|n")
-			.replace(/\r/g, "|r")
-			.replace(/\[/g, "|[")
-			.replace(/\]/g, "|]")
+			.replaceAll("|", "||")
+			.replaceAll("\n", "|n")
+			.replaceAll("\r", "|r")
+			.replaceAll("[", "|[")
+			.replaceAll("]", "|]")
 			// next line
-			.replace(/\u0085/g, "|x")
+			.replaceAll("\u0085", "|x")
 			// line separator
-			.replace(/\u2028/g, "|l")
+			.replaceAll("\u2028", "|l")
 			// paragraph separator
-			.replace(/\u2029/g, "|p")
-			.replace(/'/g, "|'")
+			.replaceAll("\u2029", "|p")
+			.replaceAll("'", "|'")
 	);
 }
 

package/src/report/utl/index.mjs

@@ -48,7 +48,7 @@ function smartURIConcat(pPrefix, pSource) {
 function deriveExternalPackageName(pSource) {
 	const lRE =
 		/node_modules\/(?<packageName>[^@][^/]+)|(?<atPackageName>@[^/]+\/[^/]+)/;
-	const lMatch = pSource.match(lRE);
+	const lMatch = lRE.exec(pSource);
 	if (lMatch) {
 		return lMatch.groups.packageName || lMatch.groups.atPackageName;
 	}
@@ -72,7 +72,7 @@ function deriveCorePackageName(pSource) {
  */
 export function getURLForModule(pModule, pPrefix, pSuffix) {
 	// TODO: derive the URLs from configuration
-	if (pModule.dependencyTypes?.some((pType) => pType === "core")) {
+	if (pModule.dependencyTypes?.includes("core")) {
 		const lPackageName = deriveCorePackageName(pModule.source);
 		// Check if it's a Bun core module (starts with bun:)
 		if (lPackageName.startsWith("bun:")) {

package/src/utl/get-extension.mjs

@@ -16,7 +16,7 @@ const EXTENSION_RE = /(?<extension>(?:(?:\.d\.(?:[cm])?ts)|\.coffee\.md)$)/;
  * @return {string}          extension
  */
 export default function getExtension(pFileName) {
-	const lMatchResult = pFileName.match(EXTENSION_RE);
+	const lMatchResult = EXTENSION_RE.exec(pFileName);
 
 	return lMatchResult?.groups?.extension ?? extname(pFileName);
 }

package/src/utl/regex-util.mjs

@@ -1,3 +1,25 @@
+/* eslint-disable security/detect-non-literal-regexp */
+const REGEXP_CACHE = new Map();
+
+/**
+ * Returns a cached RegExp instance for the given pattern.
+ *
+ * See ./regex-cache.md for design considerations
+ *
+ * @param {string} pPattern
+ * @returns {RegExp}
+ */
+export function getCachedRegExp(pPattern) {
+	if (!REGEXP_CACHE.has(pPattern)) {
+		REGEXP_CACHE.set(pPattern, new RegExp(pPattern));
+	}
+	return REGEXP_CACHE.get(pPattern);
+}
+
+export function clearRegExpCache() {
+	REGEXP_CACHE.clear();
+}
+
 /**
  * If there is at least one group expression in the given pRulePath
  * return the first matched one.
@@ -19,7 +41,7 @@ export function extractGroups(pFromRestriction, pActualPath) {
 		// except before it enters here it has already been 'normalized' to a string
 		// so it can be safely passed to match. The right solution here (TODO)
 		// is to create a separate type for NormalizedFromRestriction
-		let lMatchResult = pActualPath.match(pFromRestriction.path);
+		let lMatchResult = getCachedRegExp(pFromRestriction.path).exec(pActualPath);
 
 		if (lMatchResult && lMatchResult.length > 1) {
 			lReturnValue = lMatchResult.filter(
@@ -49,8 +71,7 @@ export function extractGroups(pFromRestriction, pActualPath) {
 export function replaceGroupPlaceholders(pString, pExtractedGroups) {
 	return pExtractedGroups.reduce(
 		(pAll, pThis, pIndex) =>
-			// eslint-disable-next-line security/detect-non-literal-regexp
-			pAll.replace(new RegExp(`\\$${pIndex}`, "g"), pThis),
+			pAll.replaceAll(new RegExp(`\\$${pIndex}`, "g"), pThis),
 		pString,
 	);
 }

package/src/utl/wrap-and-indent.mjs

@@ -1,9 +1,7 @@
 const DEFAULT_INDENT = 4;
 
 function indentString(pString, pCount) {
-	const lRegex = /^(?!\s*$)/gm;
-
-	return pString.replace(lRegex, " ".repeat(pCount));
+	return pString.replaceAll(/^(?!\s*$)/gm, " ".repeat(pCount));
 }
 
 /**

package/src/validate/match-folder-dependency-rule.mjs

@@ -1,28 +1,39 @@
 import { isModuleOnlyRule, isFolderScope } from "./rule-classifiers.mjs";
 import { propertyEquals, matchesToIsMoreUnstable } from "./matchers.mjs";
-import { extractGroups, replaceGroupPlaceholders } from "#utl/regex-util.mjs";
+import {
+	getCachedRegExp,
+	extractGroups,
+	replaceGroupPlaceholders,
+} from "#utl/regex-util.mjs";
 
 function fromFolderPath(pRule, pFromFolder) {
-	return Boolean(!pRule.from.path || pFromFolder.name.match(pRule.from.path));
+	return (
+		!pRule.from.path || getCachedRegExp(pRule.from.path).test(pFromFolder.name)
+	);
 }
 
 function fromFolderPathNot(pRule, pFromFolder) {
-	return Boolean(
-		!pRule.from.pathNot || !pFromFolder.name.match(pRule.from.pathNot),
+	return (
+		!pRule.from.pathNot ||
+		!getCachedRegExp(pRule.from.pathNot).test(pFromFolder.name)
 	);
 }
 
 function toFolderPath(pRule, pToFolder, pGroups) {
-	return Boolean(
+	return (
 		!pRule.to.path ||
-		pToFolder.name.match(replaceGroupPlaceholders(pRule.to.path, pGroups)),
+		getCachedRegExp(replaceGroupPlaceholders(pRule.to.path, pGroups)).test(
+			pToFolder.name,
+		)
 	);
 }
 
 function toFolderPathNot(pRule, pToFolder, pGroups) {
-	return Boolean(
+	return (
 		!pRule.to.pathNot ||
-		!pToFolder.name.match(replaceGroupPlaceholders(pRule.to.pathNot, pGroups)),
+		!getCachedRegExp(replaceGroupPlaceholders(pRule.to.pathNot, pGroups)).test(
+			pToFolder.name,
+		)
 	);
 }
 

package/src/validate/match-module-rule-helpers.mjs

@@ -6,7 +6,7 @@ import {
 	matchesModulePath,
 	matchesModulePathNot,
 } from "./matchers.mjs";
-import { extractGroups } from "#utl/regex-util.mjs";
+import { getCachedRegExp, extractGroups } from "#utl/regex-util.mjs";
 
 /**
  * @import { IModule } from "../../types/cruise-result.mjs";
@@ -98,8 +98,9 @@ export function matchesReachesRule(pRule, pModule) {
 function dependentsCountsMatch(pRule, pDependents) {
 	const lMatchingDependentsCount = pDependents.filter(
 		(pDependent) =>
-			Boolean(!pRule.from.path || pDependent.match(pRule.from.path)) &&
-			Boolean(!pRule.from.pathNot || !pDependent.match(pRule.from.pathNot)),
+			(!pRule.from.path || getCachedRegExp(pRule.from.path).test(pDependent)) &&
+			(!pRule.from.pathNot ||
+				!getCachedRegExp(pRule.from.pathNot).test(pDependent)),
 	).length;
 	return (
 		(!pRule.module.numberOfDependentsLessThan ||

package/src/validate/matchers.mjs

@@ -1,6 +1,6 @@
 /* eslint-disable security/detect-object-injection */
 import { dirname, resolve, sep } from "node:path/posix";
-import { replaceGroupPlaceholders } from "#utl/regex-util.mjs";
+import { getCachedRegExp, replaceGroupPlaceholders } from "#utl/regex-util.mjs";
 import { intersects } from "#utl/array-util.mjs";
 
 // by their nature some dependency types always occur alongside other
@@ -29,10 +29,10 @@ export function propertyEquals(pRule, pDependency, pProperty) {
 }
 
 export function propertyMatches(pRule, pDependency, pRuleProperty, pProperty) {
-	return Boolean(
+	return (
 		!pRule.to[pRuleProperty] ||
 		(pDependency[pProperty] &&
-			pDependency[pProperty].match(pRule.to[pRuleProperty])),
+			getCachedRegExp(pRule.to[pRuleProperty]).test(pDependency[pProperty]))
 	);
 }
 
@@ -42,37 +42,46 @@ export function propertyMatchesNot(
 	pRuleProperty,
 	pProperty,
 ) {
-	return Boolean(
+	return (
 		!pRule.to[pRuleProperty] ||
 		(pDependency[pProperty] &&
-			!pDependency[pProperty].match(pRule.to[pRuleProperty])),
+			!getCachedRegExp(pRule.to[pRuleProperty]).test(pDependency[pProperty]))
 	);
 }
 
 export function matchesFromPath(pRule, pModule) {
-	return Boolean(!pRule.from.path || pModule.source.match(pRule.from.path));
+	return (
+		!pRule.from.path || getCachedRegExp(pRule.from.path).test(pModule.source)
+	);
 }
 
 export function matchesFromPathNot(pRule, pModule) {
-	return Boolean(
-		!pRule.from.pathNot || !pModule.source.match(pRule.from.pathNot),
+	return (
+		!pRule.from.pathNot ||
+		!getCachedRegExp(pRule.from.pathNot).test(pModule.source)
 	);
 }
 
 export function matchesModulePath(pRule, pModule) {
-	return Boolean(!pRule.module.path || pModule.source.match(pRule.module.path));
+	return (
+		!pRule.module.path ||
+		getCachedRegExp(pRule.module.path).test(pModule.source)
+	);
 }
 
 export function matchesModulePathNot(pRule, pModule) {
-	return Boolean(
-		!pRule.module.pathNot || !pModule.source.match(pRule.module.pathNot),
+	return (
+		!pRule.module.pathNot ||
+		!getCachedRegExp(pRule.module.pathNot).test(pModule.source)
 	);
 }
 
 function _matchesToPath(pRule, pString, pGroups = []) {
-	return Boolean(
+	return (
 		!pRule.to.path ||
-		pString.match(replaceGroupPlaceholders(pRule.to.path, pGroups)),
+		getCachedRegExp(replaceGroupPlaceholders(pRule.to.path, pGroups)).test(
+			pString,
+		)
 	);
 }
 
@@ -87,7 +96,9 @@ export function matchToModulePath(pRule, pModule, pGroups) {
 function _matchesToPathNot(pRule, pString, pGroups = []) {
 	return (
 		!pRule.to.pathNot ||
-		!pString.match(replaceGroupPlaceholders(pRule.to.pathNot, pGroups))
+		!getCachedRegExp(replaceGroupPlaceholders(pRule.to.pathNot, pGroups)).test(
+			pString,
+		)
 	);
 }
 
@@ -100,16 +111,16 @@ export function matchToModulePathNot(pRule, pModule, pGroups) {
 }
 
 export function matchesToDependencyTypes(pRule, pDependency) {
-	return Boolean(
+	return (
 		!pRule.to.dependencyTypes ||
-		intersects(pDependency.dependencyTypes, pRule.to.dependencyTypes),
+		intersects(pDependency.dependencyTypes, pRule.to.dependencyTypes)
 	);
 }
 
 export function matchesToDependencyTypesNot(pRule, pDependency) {
-	return Boolean(
+	return (
 		!pRule.to.dependencyTypesNot ||
-		!intersects(pDependency.dependencyTypes, pRule.to.dependencyTypesNot),
+		!intersects(pDependency.dependencyTypes, pRule.to.dependencyTypesNot)
 	);
 }
 
@@ -118,12 +129,16 @@ export function matchesToVia(pRule, pDependency, pGroups) {
 	if (pRule.to.via && pDependency.cycle) {
 		if (pRule.to.via.path) {
 			lReturnValue = pDependency.cycle.some(({ name }) =>
-				name.match(replaceGroupPlaceholders(pRule.to.via.path, pGroups)),
+				getCachedRegExp(
+					replaceGroupPlaceholders(pRule.to.via.path, pGroups),
+				).test(name),
 			);
 		}
 		if (pRule.to.via.pathNot) {
 			lReturnValue = !pDependency.cycle.every(({ name }) =>
-				name.match(replaceGroupPlaceholders(pRule.to.via.pathNot, pGroups)),
+				getCachedRegExp(
+					replaceGroupPlaceholders(pRule.to.via.pathNot, pGroups),
+				).test(name),
 			);
 		}
 		if (pRule.to.via.dependencyTypes) {
@@ -149,12 +164,16 @@ export function matchesToViaOnly(pRule, pDependency, pGroups) {
 	if (pRule.to.viaOnly && pDependency.cycle) {
 		if (pRule.to.viaOnly.path) {
 			lReturnValue = pDependency.cycle.every(({ name }) =>
-				name.match(replaceGroupPlaceholders(pRule.to.viaOnly.path, pGroups)),
+				getCachedRegExp(
+					replaceGroupPlaceholders(pRule.to.viaOnly.path, pGroups),
+				).test(name),
 			);
 		}
 		if (pRule.to.viaOnly.pathNot) {
 			lReturnValue = !pDependency.cycle.some(({ name }) =>
-				name.match(replaceGroupPlaceholders(pRule.to.viaOnly.pathNot, pGroups)),
+				getCachedRegExp(
+					replaceGroupPlaceholders(pRule.to.viaOnly.pathNot, pGroups),
+				).test(name),
 			);
 		}
 		if (pRule.to.viaOnly.dependencyTypes) {