@boundaries/elements 1.0.0 → 1.1.1

package/dist/index.browser.js

@@ -33,6 +33,7 @@ __export(src_exports, {
   CacheManager: () => CacheManager,
   DEPENDENCY_KINDS_MAP: () => DEPENDENCY_KINDS_MAP,
   DEPENDENCY_KIND_TYPE: () => DEPENDENCY_KIND_TYPE,
+  DEPENDENCY_KIND_TYPEOF: () => DEPENDENCY_KIND_TYPEOF,
   DEPENDENCY_KIND_VALUE: () => DEPENDENCY_KIND_VALUE,
   DEPENDENCY_RELATIONSHIPS_INVERTED_MAP: () => DEPENDENCY_RELATIONSHIPS_INVERTED_MAP,
   DEPENDENCY_RELATIONSHIPS_MAP: () => DEPENDENCY_RELATIONSHIPS_MAP,
@@ -79,99 +80,6 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/Cache/Cache.ts
-var import_object_hash = __toESM(require("object-hash"));
-var CacheManager = class {
-  /**
-   * Internal cache map
-   */
-  _cache;
-  /**
-   * Creates a new CacheManager instance
-   */
-  constructor() {
-    this._cache = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Generates a hashed key for the given cache key
-   * @param key The cache key to hash
-   * @returns The hashed key as a string
-   */
-  _getHashedKey(key) {
-    return (0, import_object_hash.default)(key);
-  }
-  /**
-   * Retrieves a value from the cache based on the given key
-   * @param key The cache key to retrieve
-   * @returns The cached value or undefined if not found
-   */
-  get(key) {
-    const hashedKey = this._getHashedKey(key);
-    return this._cache.get(hashedKey);
-  }
-  /**
-   * Stores a value in the cache
-   * @param key The cache key to store
-   * @param value The value to cache
-   */
-  set(key, value) {
-    const hashedKey = this._getHashedKey(key);
-    this._cache.set(hashedKey, value);
-  }
-  /**
-   * Restores a value in the cache from a given already hashed key
-   * @param key The hashed key to restore
-   * @param value The value to restore
-   */
-  restore(key, value) {
-    this._cache.set(key, value);
-  }
-  /**
-   * Checks if a value exists in the cache
-   * @param key The cache key to check
-   * @returns True if the value exists, false otherwise
-   */
-  has(key) {
-    const hashedKey = this._getHashedKey(key);
-    return this._cache.has(hashedKey);
-  }
-  /**
-   * Retrieves all cached values
-   * @returns A map of all cached values
-   */
-  getAll() {
-    return this._cache;
-  }
-  /**
-   * Clears the entire cache
-   */
-  clear() {
-    this._cache.clear();
-  }
-  /**
-   * Serializes the  cache to a plain object.
-   * @returns The serialized cache.
-   */
-  serialize() {
-    return Array.from(this.getAll().entries()).reduce(
-      (acc, [key, value]) => {
-        acc[key] = value;
-        return acc;
-      },
-      {}
-    );
-  }
-  /**
-   * Sets the cache from a serialized object.
-   * @param serializedCache The serialized cache.
-   */
-  setFromSerialized(serializedCache) {
-    for (const key in serializedCache) {
-      this.restore(key, serializedCache[key]);
-    }
-  }
-};
-
 // src/Config/Config.ts
 var Config = class {
   /** The ignore paths */
@@ -180,6 +88,8 @@ var Config = class {
   _includePaths;
   /** Whether legacy template support is enabled */
   _legacyTemplates;
+  /** Whether the cache is enabled */
+  _cache;
   /**
    * Creates a new Config instance
    * @param options Configuration options
@@ -188,6 +98,7 @@ var Config = class {
     this._ignorePaths = options?.ignorePaths;
     this._includePaths = options?.includePaths;
     this._legacyTemplates = options?.legacyTemplates ?? true;
+    this._cache = options?.cache ?? true;
   }
   /**
    * The normalized configuration options
@@ -196,14 +107,38 @@ var Config = class {
     return {
       ignorePaths: this._ignorePaths,
       includePaths: this._includePaths,
+      legacyTemplates: this._legacyTemplates,
+      cache: this._cache
+    };
+  }
+  /**
+   * Normalized options for descriptors
+   */
+  get descriptorOptions() {
+    return {
+      ignorePaths: this._ignorePaths,
+      includePaths: this._includePaths,
+      cache: this._cache
+    };
+  }
+  /**
+   * Normalized options for element matchers
+   */
+  get matchersOptions() {
+    return {
       legacyTemplates: this._legacyTemplates
     };
   }
+  /**
+   * Whether caching is enabled
+   */
+  get cache() {
+    return this._cache;
+  }
 };
 
 // src/Matcher/BaseElementsMatcher.ts
 var import_handlebars = __toESM(require("handlebars"));
-var import_micromatch = __toESM(require("micromatch"));
 
 // src/Support/TypeGuards.ts
 function isString(value) {
@@ -221,6 +156,9 @@ function isBoolean(value) {
 function isObject(value) {
   return !isNullish(value) && !isBoolean(value) && !isArray(value) && typeof value === "object";
 }
+function isEmptyObject(obj) {
+  return isObject(obj) && Object.keys(obj).length === 0;
+}
 function isArray(value) {
   return Array.isArray(value);
 }
@@ -273,8 +211,9 @@ function isElementSelectorData(value) {
   ]);
 }
 function isElementSelectorWithLegacyOptions(value) {
-  return isArray(value) && value.length === 2 && isSimpleElementSelectorByType(value[0]) && // NOTE: Arrays of length 2 with captured values selector as second element having a key "type" or "category" will be treated as legacy options instead of two different selectors. We have to live with this limitation for now.
-  isCapturedValuesSelector(value[1]);
+  return isArray(value) && (value.length === 2 && isSimpleElementSelectorByType(value[0]) && // NOTE: Arrays of length 2 with captured values selector as second element having a key "type" or "category" will be treated as legacy options instead of two different selectors. We have to live with this limitation for now.
+  isCapturedValuesSelector(value[1]) || // NOTE: Backwards compatibility: Allow arrays of length 1 with simple element selector. Some users might defined arrays without options.
+  value.length === 1 && isSimpleElementSelectorByType(value[0]));
 }
 function isElementSelector(value) {
   return isSimpleElementSelectorByType(value) || isElementSelectorData(value) || isElementSelectorWithLegacyOptions(value);
@@ -305,6 +244,8 @@ function isExternalLibrariesSelector(value) {
 }
 
 // src/Matcher/BaseElementsMatcher.ts
+var HANDLEBARS_TEMPLATE_REGEX = /{{\s*[^}]+\s*}}/;
+var LEGACY_TEMPLATE_REGEX = /\$\{([^}]+)\}/g;
 function normalizeSelector(selector) {
   if (isSimpleElementSelectorByType(selector)) {
     return { type: selector };
@@ -315,7 +256,7 @@ function normalizeSelector(selector) {
   if (isElementSelectorWithLegacyOptions(selector)) {
     return {
       type: selector[0],
-      captured: { ...selector[1] }
+      captured: selector[1] ? { ...selector[1] } : void 0
     };
   }
   throw new Error("Invalid element selector");
@@ -330,12 +271,21 @@ function normalizeElementsSelector(elementsSelector) {
   return [normalizeSelector(elementsSelector)];
 }
 var BaseElementsMatcher = class {
+  /**
+   * Option to use legacy templates with ${} syntax.
+   */
   _legacyTemplates;
+  /**
+   * Micromatch instance for matching.
+   */
+  micromatch;
   /**
    * Creates a new BaseElementsMatcher.
    * @param config Configuration options for the matcher.
+   * @param globalCache Global cache instance.
    */
-  constructor(config) {
+  constructor(config, micromatch2) {
+    this.micromatch = micromatch2;
     this._legacyTemplates = config.legacyTemplates;
   }
   /**
@@ -344,17 +294,30 @@ var BaseElementsMatcher = class {
    * @returns The converted template.
    */
   _getBackwardsCompatibleTemplate(template) {
-    return template.replaceAll(/\$\{([^}]+)\}/g, "{{ $1 }}");
+    return template.replaceAll(LEGACY_TEMPLATE_REGEX, "{{ $1 }}");
+  }
+  /**
+   * Determines if a template contains Handlebars syntax.
+   * @param template The template to check.
+   * @returns True if the template contains Handlebars syntax, false otherwise.
+   */
+  _isHandlebarsTemplate(template) {
+    return HANDLEBARS_TEMPLATE_REGEX.test(template);
   }
   /**
    * Returns a rendered template using the provided template data.
+   * Optimized version with template caching for better performance.
    * @param template The template to render.
-   * @param extraTemplateData The data to use for replace in the template.
+   * @param templateData The data to use for replace in the template.
    * @returns The rendered template.
    */
   _getRenderedTemplate(template, templateData) {
     const templateToUse = this._legacyTemplates ? this._getBackwardsCompatibleTemplate(template) : template;
-    return import_handlebars.default.compile(templateToUse)(templateData);
+    if (!this._isHandlebarsTemplate(templateToUse)) {
+      return template;
+    }
+    const compiledTemplate = import_handlebars.default.compile(templateToUse);
+    return compiledTemplate(templateData);
   }
   /**
    * Returns rendered templates using the provided template data.
@@ -372,6 +335,7 @@ var BaseElementsMatcher = class {
   }
   /**
    * Returns whether the given value matches the micromatch pattern, converting non-string values to strings.
+   * Optimized version with caching for better performance.
    * @param value The value to check.
    * @param pattern The micromatch pattern to match against.
    * @returns Whether the value matches the pattern.
@@ -379,7 +343,28 @@ var BaseElementsMatcher = class {
   isMicromatchMatch(value, pattern) {
     const elementValueToCheck = !value || !isString(value) ? String(value) : value;
     const selectorValueToCheck = isArray(pattern) ? pattern.filter(Boolean) : pattern;
-    return import_micromatch.default.isMatch(elementValueToCheck, selectorValueToCheck);
+    return this.micromatch.isMatch(elementValueToCheck, selectorValueToCheck);
+  }
+  /**
+   * Returns whether the given value matches the micromatch pattern after rendering it as a template.
+   * @param pattern The micromatch pattern to render and match against.
+   * @param templateData The data to use for rendering the pattern as a template.
+   * @param value The value to check.
+   * @returns Whether the value matches the rendered pattern.
+   */
+  isTemplateMicromatchMatch(pattern, templateData, value) {
+    if (isNullish(value)) {
+      return false;
+    }
+    const patternRendered = this.getRenderedTemplates(pattern, templateData);
+    if (!patternRendered) {
+      return false;
+    }
+    const filteredPattern = isArray(patternRendered) ? patternRendered.filter(Boolean) : patternRendered;
+    if (isArray(value)) {
+      return value.some((val) => this.isMicromatchMatch(val, filteredPattern));
+    }
+    return this.isMicromatchMatch(value, filteredPattern);
   }
   /**
    * Whether the given element key matches the selector key as booleans.
@@ -426,61 +411,34 @@ var BaseElementsMatcher = class {
     if (!selectorValue) {
       return false;
     }
-    const selectorValueRendered = this.getRenderedTemplates(
-      selectorValue,
-      templateData
-    );
-    if (!selectorValueRendered) {
-      return false;
-    }
     if (!isObjectWithProperty(element, elementKey)) {
       return false;
     }
-    if (isNullish(element[elementKey])) {
-      return false;
-    }
-    return this.isMicromatchMatch(element[elementKey], selectorValueRendered);
+    return this.isTemplateMicromatchMatch(
+      selectorValue,
+      templateData,
+      element[elementKey]
+    );
   }
 };
 
 // src/Matcher/DependenciesMatcher.ts
 var DependenciesMatcher = class extends BaseElementsMatcher {
-  /**
-   * Cache to store previously described dependencies.
-   */
-  _cache;
   /**
    * Elements matcher to use for matching elements within dependencies.
    */
   _elementsMatcher;
   /**
    * Creates a new DependenciesMatcher.
+   * @param elementsMatcher Elements matcher to use for matching elements within dependencies.
+   * @param config Configuration options for the matcher.
+   * @param micromatch Micromatch instance for matching.
+   * @param globalCache Global cache instance.
    */
-  constructor(elementsMatcher, config) {
-    super(config);
-    this._cache = new CacheManager();
+  constructor(elementsMatcher, config, micromatch2) {
+    super(config, micromatch2);
     this._elementsMatcher = elementsMatcher;
   }
-  /**
-   * Serializes the cache to a plain object.
-   * @returns The serialized cache.
-   */
-  serializeCache() {
-    return this._cache.serialize();
-  }
-  /**
-   * Sets the cache from a serialized object.
-   * @param serializedCache The serialized cache.
-   */
-  setCacheFromSerialized(serializedCache) {
-    this._cache.setFromSerialized(serializedCache);
-  }
-  /**
-   * Clears the cache.
-   */
-  clearCache() {
-    this._cache.clear();
-  }
   /**
    * Normalizes selector into DependencySelectorNormalized format, containing arrays of selectors data.
    * @param selector The dependency selector to normalize.
@@ -618,17 +576,11 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
     if (!selector.relationship) {
       return true;
     }
-    const renderedPattern = this.getRenderedTemplates(
+    return this.isTemplateMicromatchMatch(
       selector.relationship,
-      templateData
+      templateData,
+      relationship
     );
-    if (!renderedPattern) {
-      return false;
-    }
-    if (!relationship) {
-      return false;
-    }
-    return this.isMicromatchMatch(relationship, renderedPattern);
   }
   /**
    * Determines if the selector matches an specific kind
@@ -641,17 +593,7 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
     if (!selector.kind) {
       return true;
     }
-    const renderedPattern = this.getRenderedTemplates(
-      selector.kind,
-      templateData
-    );
-    if (!renderedPattern) {
-      return false;
-    }
-    if (!kind) {
-      return false;
-    }
-    return this.isMicromatchMatch(kind, renderedPattern);
+    return this.isTemplateMicromatchMatch(selector.kind, templateData, kind);
   }
   /**
    * Determines if the selector matches some of the specifiers
@@ -661,22 +603,13 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
    * @returns Whether the selector matches some of the specifiers
    */
   _specifierMatches(selector, specifiers, templateData) {
-    const specifierPattern = selector.specifiers;
-    if (!specifierPattern) {
+    if (!selector.specifiers) {
       return true;
     }
-    const renderedPattern = this.getRenderedTemplates(
-      specifierPattern,
-      templateData
-    );
-    if (!renderedPattern) {
-      return false;
-    }
-    if (!specifiers) {
-      return false;
-    }
-    return specifiers.some(
-      (specifier) => this.isMicromatchMatch(specifier, renderedPattern)
+    return this.isTemplateMicromatchMatch(
+      selector.specifiers,
+      templateData,
+      specifiers
     );
   }
   /**
@@ -687,21 +620,14 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
    * @returns Whether the selector matches the nodeKind
    */
   _nodeKindMatches(selector, nodeKind, templateData) {
-    const nodeKindPattern = selector.nodeKind;
-    if (!nodeKindPattern) {
+    if (!selector.nodeKind) {
       return true;
     }
-    const renderedPattern = this.getRenderedTemplates(
-      nodeKindPattern,
-      templateData
+    return this.isTemplateMicromatchMatch(
+      selector.nodeKind,
+      templateData,
+      nodeKind
     );
-    if (!renderedPattern) {
-      return false;
-    }
-    if (!nodeKind) {
-      return false;
-    }
-    return this.isMicromatchMatch(nodeKind, renderedPattern);
   }
   /**
    * Determines if the dependency description matches the selector for 'from'.
@@ -727,25 +653,17 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
    * @returns Whether the dependency properties match the selector for 'to'.
    */
   _dependencyToPropertiesMatch(dependency, toSelector, templateData) {
-    return toSelector.some((selectorData) => {
-      return this._relationshipMatches(
-        selectorData,
-        dependency.dependency.relationship.to,
-        templateData
-      ) && this._kindMatches(
-        selectorData,
-        dependency.dependency.kind,
-        templateData
-      ) && this._nodeKindMatches(
-        selectorData,
-        dependency.dependency.nodeKind,
-        templateData
-      ) && this._specifierMatches(
-        selectorData,
-        dependency.dependency.specifiers,
-        templateData
-      );
-    });
+    const dependencyInfo = dependency.dependency;
+    const relationshipTo = dependencyInfo.relationship.to;
+    const kind = dependencyInfo.kind;
+    const nodeKind = dependencyInfo.nodeKind;
+    const specifiers = dependencyInfo.specifiers;
+    for (const selectorData of toSelector) {
+      if (this._kindMatches(selectorData, kind, templateData) && this._nodeKindMatches(selectorData, nodeKind, templateData) && this._relationshipMatches(selectorData, relationshipTo, templateData) && this._specifierMatches(selectorData, specifiers, templateData)) {
+        return true;
+      }
+    }
+    return false;
   }
   /**
    * Returns the selectors matching result for the given dependency.
@@ -758,29 +676,18 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
     extraTemplateData = {},
     dependencySelectorsGlobals = {}
   } = {}) {
-    if (this._cache.has({
-      dependency,
-      selector,
-      extraTemplateData,
-      dependencySelectorsGlobals
-    })) {
-      return this._cache.get({
-        dependency,
-        selector,
-        extraTemplateData,
-        dependencySelectorsGlobals
-      });
-    }
     const normalizedSelector = this._normalizeDependencySelector(
       selector,
       dependencySelectorsGlobals
     );
+    const fromExtraData = extraTemplateData.from || {};
+    const toExtraData = extraTemplateData.to || {};
     const templateData = {
       ...extraTemplateData,
       from: {
         ...dependency.from,
         relationship: dependency.dependency.relationship.from,
-        ...extraTemplateData.from || {}
+        ...fromExtraData
       },
       to: {
         ...dependency.to,
@@ -788,7 +695,7 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
         kind: dependency.dependency.kind,
         nodeKind: dependency.dependency.nodeKind,
         specifiers: dependency.dependency.specifiers,
-        ...extraTemplateData.to || {}
+        ...toExtraData
       }
     };
     const result = this._getSelectorMatching(
@@ -796,15 +703,6 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
       normalizedSelector,
       templateData
     );
-    this._cache.set(
-      {
-        dependency,
-        selector,
-        extraTemplateData,
-        dependencySelectorsGlobals
-      },
-      result
-    );
     return result;
   }
   /**
@@ -825,38 +723,17 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
 };
 
 // src/Matcher/ElementsMatcher.ts
-var import_micromatch2 = __toESM(require("micromatch"));
 var ElementsMatcher = class extends BaseElementsMatcher {
-  /**
-   * Cache to store previously described elements.
-   */
-  _cache;
+  /** Whether the cache is enabled or not */
+  _cacheIsEnabled;
   /**
    * Creates a new ElementsSelectorMatcher.
+   * @param config Configuration options for the matcher.
+   * @param micromatch Micromatch instance for matching.
+   * @param globalCache Global cache instance.
    */
-  constructor(config) {
-    super(config);
-    this._cache = new CacheManager();
-  }
-  /**
-   * Serializes the cache to a plain object.
-   * @returns The serialized cache.
-   */
-  serializeCache() {
-    return this._cache.serialize();
-  }
-  /**
-   * Sets the cache from a serialized object.
-   * @param serializedCache The serialized cache.
-   */
-  setCacheFromSerialized(serializedCache) {
-    this._cache.setFromSerialized(serializedCache);
-  }
-  /**
-   * Clears the cache.
-   */
-  clearCache() {
-    this._cache.clear();
+  constructor(config, micromatch2) {
+    super(config, micromatch2);
   }
   /**
    * Whether the given element type matches the selector type.
@@ -1002,13 +879,13 @@ var ElementsMatcher = class extends BaseElementsMatcher {
    * @returns True if the captured values match, false otherwise.
    */
   _isCapturedValuesMatch(element, selector, templateData) {
-    if (!selector.captured) {
+    if (!selector.captured || isEmptyObject(selector.captured)) {
       return true;
     }
     if (!element.captured) {
       return false;
     }
-    return Object.entries(selector.captured).every(([key, pattern]) => {
+    for (const [key, pattern] of Object.entries(selector.captured)) {
       const elementValue = element.captured?.[key];
       if (!elementValue) {
         return false;
@@ -1018,8 +895,12 @@ var ElementsMatcher = class extends BaseElementsMatcher {
         return false;
       }
       const filteredPattern = isArray(renderedPattern) ? renderedPattern.filter(Boolean) : renderedPattern;
-      return import_micromatch2.default.isMatch(elementValue, filteredPattern);
-    });
+      const isMatch = this.micromatch.isMatch(elementValue, filteredPattern);
+      if (!isMatch) {
+        return false;
+      }
+    }
+    return true;
   }
   /**
    * Determines if the isIgnored property of the element matches that in the selector.
@@ -1056,17 +937,16 @@ var ElementsMatcher = class extends BaseElementsMatcher {
    * @param extraTemplateData Extra template data to use for matching.
    * @returns The selector matching result for the given element, or null if none matches.
    */
-  _getSelectorMatching(element, selector, extraTemplateData) {
-    const selectorsData = normalizeElementsSelector(selector);
+  _getSelectorMatching(element, selectorsData, extraTemplateData) {
     const templateData = {
       element,
       ...extraTemplateData
     };
     for (const selectorData of selectorsData) {
-      const isMatch = this._isTypeMatch(element, selectorData, templateData) && this._isCategoryMatch(element, selectorData, templateData) && this._isCapturedValuesMatch(element, selectorData, templateData) && this._isPathMatch(element, selectorData, templateData) && this._isElementPathMatch(element, selectorData, templateData) && this._isInternalPathMatch(element, selectorData, templateData) && this._isOriginMatch(element, selectorData, templateData) && this._isSourceMatch(element, selectorData, templateData) && this._isBaseSourceMatch(element, selectorData, templateData) && this._isIgnoredMatch(element, selectorData) && this._isUnknownMatch(element, selectorData);
-      if (isMatch) {
-        return selectorData;
+      if (!this._isTypeMatch(element, selectorData, templateData) || !this._isCategoryMatch(element, selectorData, templateData) || !this._isOriginMatch(element, selectorData, templateData) || !this._isIgnoredMatch(element, selectorData) || !this._isUnknownMatch(element, selectorData) || !this._isPathMatch(element, selectorData, templateData) || !this._isElementPathMatch(element, selectorData, templateData) || !this._isInternalPathMatch(element, selectorData, templateData) || !this._isSourceMatch(element, selectorData, templateData) || !this._isBaseSourceMatch(element, selectorData, templateData) || !this._isCapturedValuesMatch(element, selectorData, templateData)) {
+        continue;
       }
+      return selectorData;
     }
     return null;
   }
@@ -1079,31 +959,8 @@ var ElementsMatcher = class extends BaseElementsMatcher {
    * @returns The selector matching result for the given element, or null if none matches.
    */
   getSelectorMatching(element, selector, { extraTemplateData = {} } = {}) {
-    if (this._cache.has({
-      element,
-      selector,
-      extraTemplateData
-    })) {
-      return this._cache.get({
-        element,
-        selector,
-        extraTemplateData
-      });
-    }
-    const result = this._getSelectorMatching(
-      element,
-      selector,
-      extraTemplateData
-    );
-    this._cache.set(
-      {
-        element,
-        selector,
-        extraTemplateData
-      },
-      result
-    );
-    return result;
+    const selectorsData = normalizeElementsSelector(selector);
+    return this._getSelectorMatching(element, selectorsData, extraTemplateData);
   }
   /**
    * Returns whether the given element matches the selector.
@@ -1196,11 +1053,14 @@ function isCoreDependencyElement(value) {
 // src/Descriptor/DependenciesDescriptor.types.ts
 var DEPENDENCY_KIND_TYPE = "type";
 var DEPENDENCY_KIND_VALUE = "value";
+var DEPENDENCY_KIND_TYPEOF = "typeof";
 var DEPENDENCY_KINDS_MAP = {
   /** Type import, e.g., `import type { X } from 'module'` */
   TYPE: DEPENDENCY_KIND_TYPE,
   /** Value import, e.g., `import { X } from 'module'` */
-  VALUE: DEPENDENCY_KIND_VALUE
+  VALUE: DEPENDENCY_KIND_VALUE,
+  /** typeof import, e.g. `type ModuleType = typeof import("./my_module");` */
+  TYPE_OF: DEPENDENCY_KIND_TYPEOF
 };
 var DEPENDENCY_RELATIONSHIPS_MAP = {
   /** The dependency is internal to the element */
@@ -1253,22 +1113,173 @@ function isInternalDependency(dependency) {
   return dependency.dependency.relationship.to === DEPENDENCY_RELATIONSHIPS_MAP.INTERNAL;
 }
 
+// src/Cache/Cache.ts
+var CacheManager = class {
+  /**
+   * Internal cache map
+   */
+  _cache;
+  /**
+   * Creates a new CacheManager instance
+   */
+  constructor() {
+    this._cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Generates a string key from the given cache key. Has to be implemented for non-string keys.
+   * @param key The cache key to generate from
+   * @returns The generated string key
+   */
+  generateKey(key) {
+    if (isString(key)) {
+      return key;
+    }
+    const errorMessage = "Cache key generation for non-string keys is not implemented because it causes performance issues: " + JSON.stringify(key);
+    throw new Error(errorMessage);
+  }
+  /**
+   * Generates a hashed key for the given cache key
+   * @param key The cache key to hash
+   * @returns The hashed key as a string
+   */
+  getKey(key) {
+    return this.generateKey(key);
+  }
+  /**
+   * Retrieves a value from the cache based on the given hashed key
+   * @param hashedKey The hashed key to retrieve
+   * @returns The cached value or undefined if not found
+   */
+  get(hashedKey) {
+    return this._cache.get(hashedKey);
+  }
+  /**
+   * Stores a value in the cache with a given hashed key
+   * @param hashedKey The hashed key to store
+   * @param value The value to cache
+   */
+  set(hashedKey, value) {
+    this._cache.set(hashedKey, value);
+  }
+  /**
+   * Checks if a value exists in the cache based on the given hashed key
+   * @param hashedKey The hashed key to check
+   * @returns True if the value exists, false otherwise
+   */
+  has(hashedKey) {
+    return this._cache.has(hashedKey);
+  }
+  /**
+   * Retrieves all cached values
+   * @returns A map of all cached values
+   */
+  getAll() {
+    return this._cache;
+  }
+  /**
+   * Clears the entire cache
+   */
+  clear() {
+    this._cache.clear();
+  }
+  /**
+   * Serializes the  cache to a plain object.
+   * @returns The serialized cache.
+   */
+  serialize() {
+    return Array.from(this.getAll().entries()).reduce(
+      (acc, [key, value]) => {
+        acc[key] = value;
+        return acc;
+      },
+      {}
+    );
+  }
+  /**
+   * Sets the cache from a serialized object.
+   * @param serializedCache The serialized cache.
+   */
+  setFromSerialized(serializedCache) {
+    for (const key in serializedCache) {
+      this.set(key, serializedCache[key]);
+    }
+  }
+};
+
+// src/Cache/CacheDisabled.ts
+var CacheManagerDisabled = class extends CacheManager {
+  /**
+   * Generates a fake cache key as caching is disabled
+   * @param key The cache key to hash
+   * @returns An empty string
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getKey(_key) {
+    return "";
+  }
+  /**
+   * Does nothing as caching is disabled
+   * @param hashedKey The hashed key to retrieve
+   * @returns Undefined as caching is disabled
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  get(_hashedKey) {
+    return void 0;
+  }
+  /**
+   * Does nothing as caching is disabled
+   * @param hashedKey The hashed key to store
+   * @param value The value to cache
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  set(_hashedKey, _value) {
+    return;
+  }
+  /**
+   * Does nothing as caching is disabled
+   * @param hashedKey The hashed key to check
+   * @returns False as caching is disabled
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  has(_hashedKey) {
+    return false;
+  }
+};
+
+// src/Descriptor/DependenciesDescriptionsCache.ts
+var DependenciesDescriptionsCache = class extends CacheManager {
+  /** Generates a unique key for the given dependency description options.
+   * @param options The options to generate the key from.
+   * @returns The generated key.
+   */
+  generateKey(options) {
+    return `${options.from}|${options.to}|${options.source}|${options.kind}|${options.nodeKind}|${options.specifiers ? options.specifiers.join(",") : ""}`;
+  }
+};
+
 // src/Descriptor/DependenciesDescriptor.ts
 var DependenciesDescriptor = class {
   /**
    * Cache to store previously described dependencies.
    */
-  _dependenciesCache = new CacheManager();
+  _dependenciesCache;
   /**
    * Elements descriptor instance.
    */
   _elementsDescriptor;
+  /**
+   * Configuration options.
+   */
+  _config;
   /**
    * Creates a new DependenciesDescriptor instance.
    * @param elementsDescriptor The elements descriptor instance.
+   * @param config The configuration options.
    */
-  constructor(elementsDescriptor) {
+  constructor(elementsDescriptor, config) {
     this._elementsDescriptor = elementsDescriptor;
+    this._config = config;
+    this._dependenciesCache = this._config.cache ? new DependenciesDescriptionsCache() : new CacheManagerDisabled();
   }
   /**
    * Serializes the elements cache to a plain object.
@@ -1419,22 +1430,16 @@ var DependenciesDescriptor = class {
     nodeKind,
     specifiers
   }) {
-    if (this._dependenciesCache.has({
+    const cacheKey = this._dependenciesCache.getKey({
       from,
       to,
       source,
       kind,
       nodeKind,
       specifiers
-    })) {
-      return this._dependenciesCache.get({
-        from,
-        to,
-        source,
-        kind,
-        nodeKind,
-        specifiers
-      });
+    });
+    if (this._dependenciesCache.has(cacheKey)) {
+      return this._dependenciesCache.get(cacheKey);
     }
     const fromElement = this._elementsDescriptor.describeElement(from);
     const toElement = this._elementsDescriptor.describeDependencyElement(
@@ -1451,25 +1456,14 @@ var DependenciesDescriptor = class {
         specifiers: specifiers || null
       }
     };
-    this._dependenciesCache.set(
-      {
-        from,
-        to,
-        source,
-        kind,
-        nodeKind,
-        specifiers
-      },
-      result
-    );
+    this._dependenciesCache.set(cacheKey, result);
     return result;
   }
 };
 
 // src/Descriptor/ElementsDescriptor.ts
 var import_is_core_module = __toESM(require("is-core-module"));
-var import_micromatch3 = __toESM(require("micromatch"));
-var UNKNOWN_LOCAL_ELEMENT = {
+var UNKNOWN_ELEMENT = {
   path: null,
   elementPath: null,
   internalPath: null,
@@ -1483,16 +1477,18 @@ var UNKNOWN_LOCAL_ELEMENT = {
   isIgnored: false,
   isUnknown: true
 };
+var SCOPED_PACKAGE_REGEX = /^@[^/]*\/?[^/]+/;
+var EXTERNAL_PATH_REGEX = /^\w/;
 var ElementsDescriptor = class {
   _mod = null;
   /**
    * Cache to store previously described elements.
    */
-  _elementsCache = new CacheManager();
+  _descriptionsCache;
   /**
    * Cache to store previously described files.
    */
-  _filesCache = new CacheManager();
+  _filesCache;
   /**
    * Configuration instance for this descriptor.
    */
@@ -1501,15 +1497,22 @@ var ElementsDescriptor = class {
    * Element descriptors used by this descriptor.
    */
   _elementDescriptors;
+  /** Micromatch instance for path matching */
+  _micromatch;
   /**
    * The configuration options for this descriptor.
    * @param elementDescriptors The element descriptors.
    * @param configOptions The configuration options.
+   * @param globalCache The global cache for various caching needs.
+   * @param micromatch The micromatch instance for path matching.
    */
-  constructor(elementDescriptors, configOptions) {
+  constructor(elementDescriptors, configOptions, micromatch2) {
+    this._micromatch = micromatch2;
     this._elementDescriptors = elementDescriptors;
     this._validateDescriptors(elementDescriptors);
-    this._config = new Config(configOptions);
+    this._config = configOptions;
+    this._filesCache = this._config.cache ? new CacheManager() : new CacheManagerDisabled();
+    this._descriptionsCache = this._config.cache ? new CacheManager() : new CacheManagerDisabled();
     this._loadModuleInNode();
   }
   /**
@@ -1517,20 +1520,24 @@ var ElementsDescriptor = class {
    * @returns The serialized elements cache.
    */
   serializeCache() {
-    return this._elementsCache.serialize();
+    return {
+      descriptions: this._descriptionsCache.serialize(),
+      files: this._filesCache.serialize()
+    };
   }
   /**
    * Sets the elements cache from a serialized object.
    * @param serializedCache The serialized elements cache.
    */
   setCacheFromSerialized(serializedCache) {
-    this._elementsCache.setFromSerialized(serializedCache);
+    this._descriptionsCache.setFromSerialized(serializedCache.descriptions);
+    this._filesCache.setFromSerialized(serializedCache.files);
   }
   /**
    * Clears the elements cache.
    */
   clearCache() {
-    this._elementsCache.clear();
+    this._descriptionsCache.clear();
     this._filesCache.clear();
   }
   /**
@@ -1574,7 +1581,7 @@ var ElementsDescriptor = class {
    * @returns True if the dependency source is scoped, false otherwise.
    */
   _dependencySourceIsScoped(dependencySource) {
-    return /^@[^/]*\/?[^/]+/.test(dependencySource);
+    return SCOPED_PACKAGE_REGEX.test(dependencySource);
   }
   /**
    * Determines if a dependency source is external or an alias.
@@ -1582,14 +1589,14 @@ var ElementsDescriptor = class {
    * @returns True if the dependency source is external or an alias, false otherwise.
    */
   _dependencySourceIsExternalOrScoped(dependencySource) {
-    return /^\w/.test(dependencySource) || this._dependencySourceIsScoped(dependencySource);
+    return EXTERNAL_PATH_REGEX.test(dependencySource) || this._dependencySourceIsScoped(dependencySource);
   }
   /**
    * Gets the base source of an external module.
    * @param dependencySource The source of the dependency to check.
    * @returns The base source of the external module. (e.g., for "@scope/package/submodule", it returns "@scope/package")
    */
-  _getExternalModuleBaseSource(dependencySource) {
+  _getExternalOrCoreModuleBaseSource(dependencySource) {
     if (this._dependencySourceIsScoped(dependencySource)) {
       const [scope, packageName] = dependencySource.split("/");
       return `${scope}/${packageName}`;
@@ -1612,27 +1619,31 @@ var ElementsDescriptor = class {
   }
   /**
    * Determines if a given path is included based on the configuration.
+   * Uses caching for better performance on repeated calls.
    * @param elementPath The element path to check.
+   * @param includeExternal Whether to include external files.
    * @returns True if the path is included, false otherwise.
    */
-  _pathIsIncluded(elementPath, includeExternal) {
-    const isExternal = includeExternal ? import_micromatch3.default.isMatch(elementPath, "**/node_modules/**") : false;
-    if (this._config.options.includePaths && this._config.options.ignorePaths) {
-      const isIncluded = import_micromatch3.default.isMatch(
+  _pathIsIncluded(elementPath) {
+    let result;
+    if (this._config.includePaths && this._config.ignorePaths) {
+      const isIncluded = this._micromatch.isMatch(
         elementPath,
-        this._config.options.includePaths
+        this._config.includePaths
       );
-      const isIgnored = import_micromatch3.default.isMatch(
+      const isIgnored = this._micromatch.isMatch(
         elementPath,
-        this._config.options.ignorePaths
+        this._config.ignorePaths
       );
-      return (isIncluded || isExternal) && !isIgnored;
-    } else if (this._config.options.includePaths) {
-      return import_micromatch3.default.isMatch(elementPath, this._config.options.includePaths) || isExternal;
-    } else if (this._config.options.ignorePaths) {
-      return !import_micromatch3.default.isMatch(elementPath, this._config.options.ignorePaths);
+      result = isIncluded && !isIgnored;
+    } else if (this._config.includePaths) {
+      result = this._micromatch.isMatch(elementPath, this._config.includePaths);
+    } else if (this._config.ignorePaths) {
+      result = !this._micromatch.isMatch(elementPath, this._config.ignorePaths);
+    } else {
+      result = true;
     }
-    return true;
+    return result;
   }
   /**
    * Gets captured values from the captured array and capture configuration.
@@ -1659,16 +1670,15 @@ var ElementsDescriptor = class {
    * @returns The element path.
    */
   _getElementPath(pathPattern, pathSegments, allPathSegments) {
-    const elementPathRegexp = import_micromatch3.default.makeRe(pathPattern);
+    const elementPathRegexp = this._micromatch.makeRe(pathPattern);
     const testedSegments = [];
     let result;
     for (const pathSegment of pathSegments) {
-      if (!result) {
-        testedSegments.push(pathSegment);
-        const joinedSegments = testedSegments.join("/");
-        if (elementPathRegexp.test(joinedSegments)) {
-          result = joinedSegments;
-        }
+      testedSegments.push(pathSegment);
+      const joinedSegments = testedSegments.join("/");
+      if (elementPathRegexp.test(joinedSegments)) {
+        result = joinedSegments;
+        break;
       }
     }
     return `${[...allPathSegments].reverse().join("/").split(result)[0]}${result}`;
@@ -1685,20 +1695,18 @@ var ElementsDescriptor = class {
     for (const pattern of patterns) {
       const useFullPathMatch = mode === ELEMENT_DESCRIPTOR_MODES_MAP.FULL && !alreadyMatched;
       const effectivePattern = mode === ELEMENT_DESCRIPTOR_MODES_MAP.FOLDER && !alreadyMatched ? `${pattern}/**/*` : pattern;
+      const targetPath = useFullPathMatch ? filePath : currentPathSegments.join("/");
       let baseCapture = null;
       let hasCapture = true;
       if (elementDescriptor.basePattern) {
         const baseTarget = filePath.split("/").slice(0, filePath.split("/").length - lastPathSegmentMatching).join("/");
-        baseCapture = import_micromatch3.default.capture(
+        baseCapture = this._micromatch.capture(
           [elementDescriptor.basePattern, "**", effectivePattern].join("/"),
           baseTarget
         );
         hasCapture = baseCapture !== null;
       }
-      const capture = import_micromatch3.default.capture(
-        effectivePattern,
-        useFullPathMatch ? filePath : currentPathSegments.join("/")
-      );
+      const capture = this._micromatch.capture(effectivePattern, targetPath);
       if (capture && hasCapture) {
         return {
           matched: true,
@@ -1712,22 +1720,19 @@ var ElementsDescriptor = class {
     return { matched: false };
   }
   /**
-   * Retrieves the description of an element given its path.
-   * It does not identify external files. Files not matching any element are considered unknown.
-   * If a file in node_modules does a match, it is considered local as well.
-   * @param includeExternal Whether to include external files (inside node_modules) in the matching process.
+   * Retrieves the description of a local file given its path.
    * @param elementPath The path of the element to describe.
    * @returns The description of the element.
    */
-  _getFileDescription(includeExternal, filePath) {
+  _getFileDescription(filePath) {
     if (!filePath) {
       return {
-        ...UNKNOWN_LOCAL_ELEMENT
+        ...UNKNOWN_ELEMENT
       };
     }
-    if (!this._pathIsIncluded(filePath, includeExternal)) {
+    if (!this._pathIsIncluded(filePath)) {
       return {
-        ...UNKNOWN_LOCAL_ELEMENT,
+        ...UNKNOWN_ELEMENT,
         path: filePath,
         isIgnored: true,
         origin: null
@@ -1783,13 +1788,14 @@ var ElementsDescriptor = class {
     for (let i = 0; i < pathSegments.length; i++) {
       const segment = pathSegments[i];
       state.pathSegmentsAccumulator.unshift(segment);
+      const alreadyHasMainElement = Boolean(elementResult.type) || Boolean(elementResult.category);
       for (const elementDescriptor of this._elementDescriptors) {
         const match = this._fileDescriptorMatch({
           elementDescriptor,
           filePath,
           currentPathSegments: state.pathSegmentsAccumulator,
           lastPathSegmentMatching: state.lastPathSegmentMatching,
-          alreadyMatched: Boolean(elementResult.type) || Boolean(elementResult.category)
+          alreadyMatched: alreadyHasMainElement
         });
         if (match.matched) {
           processElementMatch(
@@ -1807,7 +1813,7 @@ var ElementsDescriptor = class {
     const result = { ...elementResult, parents };
     if (!isKnownLocalElement(result)) {
       return {
-        ...UNKNOWN_LOCAL_ELEMENT,
+        ...UNKNOWN_ELEMENT,
         path: filePath
       };
     }
@@ -1819,35 +1825,30 @@ var ElementsDescriptor = class {
    * @param filePath The path of the file to describe.
    * @returns The description of the element.
    */
-  _describeFile(includeExternal, filePath) {
-    if (this._filesCache.has(String(filePath))) {
-      return this._filesCache.get(String(filePath));
+  _describeFile(filePath) {
+    const cacheKey = this._filesCache.getKey(String(filePath));
+    if (this._filesCache.has(cacheKey)) {
+      return this._filesCache.get(cacheKey);
     }
-    const description = this._getFileDescription(includeExternal, filePath);
-    this._filesCache.set(String(filePath), description);
+    const description = this._getFileDescription(filePath);
+    this._filesCache.set(cacheKey, description);
     return description;
   }
   /**
-   * Describes a dependency element given the file element and dependency source, by completing the file description.
-   * @param element The file element to complete the description for.
+   * Returns an external or core dependency element given its dependency source and file path.
    * @param dependencySource The source of the dependency.
-   * @returns The description of the dependency element.
+   * @param filePath The resolved file path of the dependency, if known.
+   * @returns The external or core dependency element, or null if it is a local dependency.
    */
-  _describeDependencyElement(element, dependencySource) {
-    if (isIgnoredElement(element)) {
-      return {
-        ...element,
-        source: dependencySource
-      };
-    }
-    const baseDependencySource = this._getExternalModuleBaseSource(dependencySource);
+  _getExternalOrCoreDependencyElement(dependencySource, filePath) {
+    const baseDependencySource = this._getExternalOrCoreModuleBaseSource(dependencySource);
     const isCore = this._dependencySourceIsCoreModule(
       dependencySource,
       baseDependencySource
     );
     if (isCore) {
       const coreElement = {
-        ...element,
+        ...UNKNOWN_ELEMENT,
         source: dependencySource,
         baseSource: baseDependencySource,
         origin: ELEMENT_ORIGINS_MAP.CORE
@@ -1855,44 +1856,38 @@ var ElementsDescriptor = class {
       return coreElement;
     }
     const isExternal = this._isExternalDependency(
-      element.path,
+      filePath || null,
       dependencySource
     );
-    if (!isExternal) {
-      const localElement = {
-        ...element,
-        source: dependencySource
+    if (isExternal) {
+      const externalElement = {
+        ...UNKNOWN_ELEMENT,
+        path: filePath || null,
+        internalPath: dependencySource.replace(baseDependencySource, ""),
+        source: dependencySource,
+        baseSource: baseDependencySource,
+        origin: ELEMENT_ORIGINS_MAP.EXTERNAL
       };
-      return localElement;
-    }
-    const externalElement = {
-      ...element,
-      internalPath: dependencySource.replace(baseDependencySource, ""),
-      source: dependencySource,
-      baseSource: baseDependencySource,
-      origin: ELEMENT_ORIGINS_MAP.EXTERNAL
-    };
-    return externalElement;
+      return externalElement;
+    }
+    return null;
   }
   _describeElement(filePath, dependencySource) {
-    if (this._elementsCache.has({
-      dependencySource,
-      filePath: String(filePath)
-    })) {
-      return this._elementsCache.get({
-        dependencySource,
-        filePath: String(filePath)
-      });
-    }
-    const fileDescription = this._describeFile(!!dependencySource, filePath);
-    const elementResult = dependencySource ? this._describeDependencyElement(fileDescription, dependencySource) : fileDescription;
-    this._elementsCache.set(
-      {
-        dependencySource,
-        filePath: String(filePath)
-      },
-      elementResult
-    );
+    const cacheKey = `${String(dependencySource)}::${String(filePath)}`;
+    if (this._descriptionsCache.has(cacheKey)) {
+      return this._descriptionsCache.get(cacheKey);
+    }
+    const externalOrCoreDependencyElement = dependencySource ? this._getExternalOrCoreDependencyElement(dependencySource, filePath) : null;
+    if (externalOrCoreDependencyElement) {
+      this._descriptionsCache.set(cacheKey, externalOrCoreDependencyElement);
+      return externalOrCoreDependencyElement;
+    }
+    const fileDescription = this._describeFile(filePath);
+    const elementResult = dependencySource ? {
+      ...fileDescription,
+      source: dependencySource
+    } : fileDescription;
+    this._descriptionsCache.set(cacheKey, elementResult);
     return elementResult;
   }
   /**
@@ -1921,14 +1916,17 @@ var Descriptors = class {
   /** Creates a new DescriptorsManager instance
    * @param elementDescriptors The element descriptors.
    * @param configOptions The configuration options.
+   * @param micromatch The Micromatch instance.
    */
-  constructor(elementDescriptors, configOptions) {
+  constructor(elementDescriptors, config, micromatch2) {
     this._elementsDescriptor = new ElementsDescriptor(
       elementDescriptors,
-      configOptions
+      config,
+      micromatch2
     );
     this._dependenciesDescriptor = new DependenciesDescriptor(
-      this._elementsDescriptor
+      this._elementsDescriptor,
+      config
     );
   }
   /**
@@ -1996,15 +1994,15 @@ var Matcher = class {
   /**
    * Constructor for the Matcher class.
    * @param descriptors Element descriptors to use for matching.
+   * @param elementsMatcher Elements matcher instance.
+   * @param dependenciesMatcher Dependencies matcher instance.
    * @param config Configuration options.
+   * @param globalCache Global cache instance.
    */
-  constructor(descriptors, config) {
-    this._descriptors = new Descriptors(descriptors, config);
-    this._elementsMatcher = new ElementsMatcher(config);
-    this._dependenciesMatcher = new DependenciesMatcher(
-      this._elementsMatcher,
-      config
-    );
+  constructor(descriptors, elementsMatcher, dependenciesMatcher, config, micromatch2) {
+    this._descriptors = new Descriptors(descriptors, config, micromatch2);
+    this._elementsMatcher = elementsMatcher;
+    this._dependenciesMatcher = dependenciesMatcher;
   }
   /**
    * Determines if an element matches a given selector.
@@ -2068,7 +2066,7 @@ var Matcher = class {
    * @param options Extra options for matching
    * @returns The matching dependency result or null if no match is found
    */
-  _isDependencySelectorMatching(dependencyData, selector, options) {
+  _getDependencySelectorMatching(dependencyData, selector, options) {
     const description = this._descriptors.describeDependency(dependencyData);
     return this._dependenciesMatcher.getSelectorsMatching(
       description,
@@ -2084,7 +2082,7 @@ var Matcher = class {
         options
       );
     }
-    return this._isDependencySelectorMatching(
+    return this._getDependencySelectorMatching(
       descriptorOptions,
       selector,
       options
@@ -2141,32 +2139,161 @@ var Matcher = class {
    */
   clearCache() {
     this._descriptors.clearCache();
-    this._elementsMatcher.clearCache();
-    this._dependenciesMatcher.clearCache();
   }
   /**
-   * Serializes the descriptors and elements matchers cache to a plain object.
+   * Serializes the descriptors matchers cache to a plain object.
    * @returns The serialized cache
    */
   serializeCache() {
     return {
-      descriptors: this._descriptors.serializeCache(),
-      elementsMatcher: this._elementsMatcher.serializeCache(),
-      dependenciesMatcher: this._dependenciesMatcher.serializeCache()
+      descriptors: this._descriptors.serializeCache()
     };
   }
   /**
-   * Sets the descriptors and elements matchers cache from a serialized object.
+   * Sets the descriptors matchers cache from a serialized object.
    * @param serializedCache The serialized cache
    */
   setCacheFromSerialized(serializedCache) {
     this._descriptors.setCacheFromSerialized(serializedCache.descriptors);
-    this._elementsMatcher.setCacheFromSerialized(
-      serializedCache.elementsMatcher
-    );
-    this._dependenciesMatcher.setCacheFromSerialized(
-      serializedCache.dependenciesMatcher
+  }
+};
+
+// src/Matcher/Micromatch.ts
+var import_micromatch = __toESM(require("micromatch"));
+var MatchingResultsCache = class extends CacheManager {
+  /**
+   * Generates a unique cache key based on the value and pattern
+   * @param param0 The cache key components
+   * @returns The generated cache key
+   */
+  generateKey({ value, pattern }) {
+    return `${value}::${isArray(pattern) ? pattern.join("|") : pattern}`;
+  }
+};
+var CapturedValueCache = class extends CacheManager {
+  /**
+   * Generates a unique cache key based on the pattern and target
+   * @param param0 The cache key components
+   * @returns The generated cache key
+   */
+  generateKey({ pattern, target }) {
+    return `${pattern}|${target}`;
+  }
+};
+var Micromatch = class {
+  /**
+   * Cache for micromatch matching results
+   */
+  _matchingResultsCache;
+  /**
+   * Cache for micromatch captures
+   */
+  _capturesCache = new CacheManagerDisabled();
+  /**
+   * Cache for micromatch makeRe results
+   */
+  _makeReCache = new CacheManagerDisabled();
+  /**
+   * Creates an instance of Micromatch class.
+   * @param cache Whether to use caching or not.
+   */
+  constructor(cache) {
+    this._matchingResultsCache = cache ? new MatchingResultsCache() : new CacheManagerDisabled();
+    this._capturesCache = cache ? new CapturedValueCache() : new CacheManagerDisabled();
+    this._makeReCache = cache ? new CacheManager() : new CacheManagerDisabled();
+  }
+  /**
+   * Clears all caches.
+   */
+  clearCache() {
+    this._matchingResultsCache.clear();
+    this._capturesCache.clear();
+    this._makeReCache.clear();
+  }
+  /**
+   * Serializes the current cache state.
+   * @returns The serialized cache data.
+   */
+  serializeCache() {
+    return {
+      matchingResults: this._matchingResultsCache.serialize(),
+      captures: this._capturesCache.serialize()
+    };
+  }
+  /**
+   * Restores the cache state from serialized data.
+   * @param serializedCache The serialized cache data.
+   */
+  setFromSerialized(serializedCache) {
+    this._matchingResultsCache.setFromSerialized(
+      serializedCache.matchingResults
     );
+    this._capturesCache.setFromSerialized(serializedCache.captures);
+  }
+  /**
+   * Optimized micromatch match with caching.
+   * @param value The value to match.
+   * @param pattern The pattern to match against.
+   * @returns True if the value matches the pattern, false otherwise.
+   */
+  isMatch(value, pattern) {
+    const cacheKey = this._matchingResultsCache.getKey({
+      value,
+      pattern
+    });
+    if (this._matchingResultsCache.has(cacheKey)) {
+      return this._matchingResultsCache.get(cacheKey);
+    }
+    const isMatch = import_micromatch.default.isMatch(value, pattern);
+    this._matchingResultsCache.set(cacheKey, isMatch);
+    return isMatch;
+  }
+  /**
+   * Optimized micromatch capture with caching.
+   * @param pattern The pattern to match against.
+   * @param target The target string to test.
+   * @returns Captured groups or null if no match.
+   */
+  capture(pattern, target) {
+    const cacheKey = this._capturesCache.getKey({ pattern, target });
+    if (this._capturesCache.has(cacheKey)) {
+      return this._capturesCache.get(cacheKey);
+    }
+    const result = import_micromatch.default.capture(pattern, target);
+    this._capturesCache.set(cacheKey, result);
+    return result;
+  }
+  /**
+   * Optimized micromatch makeRe with caching.
+   * @param pattern The pattern to convert to RegExp.
+   * @returns The RegExp instance.
+   */
+  makeRe(pattern) {
+    if (this._makeReCache.has(pattern)) {
+      return this._makeReCache.get(pattern);
+    }
+    const regexp = import_micromatch.default.makeRe(pattern);
+    this._makeReCache.set(pattern, regexp);
+    return regexp;
+  }
+};
+
+// src/MatchersCache.ts
+var MatchersCache = class extends CacheManager {
+  /**
+   * Generates a unique key based on the configuration options and element descriptors
+   * @param params The configuration and element descriptors
+   * @returns A unique string key
+   */
+  generateKey({
+    config,
+    elementDescriptors
+  }) {
+    const configHash = `${config.legacyTemplates}|${config.includePaths}|${config.ignorePaths}|${config.cache}`;
+    const elementDescriptorsHash = elementDescriptors.map(
+      (descriptor) => `${descriptor.type}|${descriptor.category}|${descriptor.pattern}|${descriptor.basePattern}|${descriptor.mode}|${descriptor.capture}|${descriptor.baseCapture}`
+    ).join(",");
+    return `${configHash}|:|${elementDescriptorsHash}`;
   }
 };
 
@@ -2175,11 +2302,10 @@ var Elements = class {
   /** The global configuration options for Elements. Can be overridden when getting a descriptor */
   _globalConfigOptions;
   /** Cache manager for Matcher instances, unique for each different configuration */
-  _matchersCache = new CacheManager();
-  /** Matcher for element selectors */
-  _elementsMatcher;
-  /** Matcher for dependency selectors */
-  _dependenciesMatcher;
+  _matchersCache = new MatchersCache();
+  /** Micromatch instances for pattern matching */
+  _micromatchWithCache = new Micromatch(true);
+  _micromatchWithoutCache = new Micromatch(false);
   /**
    * Creates a new Elements instance
    * @param configOptions The global configuration options for Elements. Can be overridden when getting a descriptor.
@@ -2187,11 +2313,6 @@ var Elements = class {
   constructor(configOptions) {
     const globalConfig = new Config(configOptions);
     this._globalConfigOptions = globalConfig.options;
-    this._elementsMatcher = new ElementsMatcher(this._globalConfigOptions);
-    this._dependenciesMatcher = new DependenciesMatcher(
-      this._elementsMatcher,
-      this._globalConfigOptions
-    );
   }
   /**
    * Returns a serialized representation of the current state of the cache.
@@ -2201,20 +2322,20 @@ var Elements = class {
     const matchersCache = Array.from(
       this._matchersCache.getAll().entries()
     ).reduce(
-      (acc, [key, descriptorCache]) => {
+      (acc, [key, cache]) => {
         acc[key] = {
-          config: descriptorCache.config,
-          elementDescriptors: descriptorCache.elementDescriptors,
-          cache: descriptorCache.matcher.serializeCache()
+          config: cache.config,
+          elementDescriptors: cache.elementDescriptors,
+          cache: cache.matcher.serializeCache()
         };
         return acc;
       },
       {}
     );
+    const micromatchCache = this._micromatchWithCache.serializeCache();
     return {
       matchers: matchersCache,
-      elementsMatcher: this._elementsMatcher.serializeCache(),
-      dependenciesMatcher: this._dependenciesMatcher.serializeCache()
+      micromatch: micromatchCache
     };
   }
   /**
@@ -2222,54 +2343,70 @@ var Elements = class {
    * @param serializedCache The serialized cache to set.
    */
   setCacheFromSerialized(serializedCache) {
+    this._micromatchWithCache.setFromSerialized(serializedCache.micromatch);
     for (const key in serializedCache.matchers) {
       const matcher = this.getMatcher(
         serializedCache.matchers[key].elementDescriptors,
         serializedCache.matchers[key].config
       );
       matcher.setCacheFromSerialized(serializedCache.matchers[key].cache);
-      this._matchersCache.restore(key, {
+      this._matchersCache.set(key, {
         config: serializedCache.matchers[key].config,
         elementDescriptors: serializedCache.matchers[key].elementDescriptors,
         matcher
       });
     }
-    this._elementsMatcher.setCacheFromSerialized(
-      serializedCache.elementsMatcher
-    );
-    this._dependenciesMatcher.setCacheFromSerialized(
-      serializedCache.dependenciesMatcher
-    );
   }
   /**
    * Clears cache
    */
   clearCache() {
-    this._elementsMatcher.clearCache();
-    this._dependenciesMatcher.clearCache();
     for (const { matcher } of this._matchersCache.getAll().values()) {
       matcher.clearCache();
     }
     this._matchersCache.clear();
+    this._micromatchWithCache.clearCache();
   }
   /**
    * Gets a Matcher instance for the given configuration options.
    * It uses caching to return the same instance for the same configuration options. If no options are provided, the global configuration options are used.
    * @param elementDescriptors The element descriptors to use.
-   * @param configOptions Optional configuration options to override the global ones.
+   * @param config Optional configuration options to override the global ones.
    * @returns A matcher instance, unique for each different configuration.
    */
-  getMatcher(elementDescriptors, configOptions) {
-    const optionsToUse = configOptions || this._globalConfigOptions;
+  getMatcher(elementDescriptors, config) {
+    const optionsToUse = config || this._globalConfigOptions;
     const configInstance = new Config(optionsToUse);
-    const normalizedOptions = configInstance.options;
-    const cacheKey = { config: normalizedOptions, elementDescriptors };
+    const cacheIsEnabled = configInstance.cache;
+    const configOptionsNormalized = configInstance.options;
+    const descriptorNormalizedOptions = configInstance.descriptorOptions;
+    const matchersNormalizedOptions = configInstance.matchersOptions;
+    const cacheKey = this._matchersCache.getKey({
+      config: configOptionsNormalized,
+      elementDescriptors
+    });
     if (this._matchersCache.has(cacheKey)) {
       return this._matchersCache.get(cacheKey).matcher;
     }
-    const matcher = new Matcher(elementDescriptors, normalizedOptions);
+    const micromatch2 = cacheIsEnabled ? this._micromatchWithCache : this._micromatchWithoutCache;
+    const elementsMatcher = new ElementsMatcher(
+      matchersNormalizedOptions,
+      micromatch2
+    );
+    const dependenciesMatcher = new DependenciesMatcher(
+      elementsMatcher,
+      matchersNormalizedOptions,
+      micromatch2
+    );
+    const matcher = new Matcher(
+      elementDescriptors,
+      elementsMatcher,
+      dependenciesMatcher,
+      descriptorNormalizedOptions,
+      micromatch2
+    );
     this._matchersCache.set(cacheKey, {
-      config: normalizedOptions,
+      config: configOptionsNormalized,
       elementDescriptors,
       matcher
     });