@boundaries/elements 1.1.2 → 2.0.0-beta.1

package/dist/index.browser.js

@@ -45,8 +45,9 @@ __export(src_exports, {
   isBaseElementSelectorData: () => isBaseElementSelectorData,
   isCapturedValuesSelector: () => isCapturedValuesSelector,
   isCoreDependencyElement: () => isCoreDependencyElement,
+  isDependencyDataSelector: () => isDependencyDataSelector,
+  isDependencyDataSelectorData: () => isDependencyDataSelectorData,
   isDependencyDescription: () => isDependencyDescription,
-  isDependencyElementDescription: () => isDependencyElementDescription,
   isDependencyKind: () => isDependencyKind,
   isDependencyRelationship: () => isDependencyRelationship,
   isDependencyRelationshipDescription: () => isDependencyRelationshipDescription,
@@ -63,12 +64,6 @@ __export(src_exports, {
   isElementsDependencyInfo: () => isElementsDependencyInfo,
   isElementsSelector: () => isElementsSelector,
   isExternalDependencyElement: () => isExternalDependencyElement,
-  isExternalLibrariesSelector: () => isExternalLibrariesSelector,
-  isExternalLibrarySelector: () => isExternalLibrarySelector,
-  isExternalLibrarySelectorOptions: () => isExternalLibrarySelectorOptions,
-  isExternalLibrarySelectorOptionsWithPath: () => isExternalLibrarySelectorOptionsWithPath,
-  isExternalLibrarySelectorOptionsWithSpecifiers: () => isExternalLibrarySelectorOptionsWithSpecifiers,
-  isExternalLibrarySelectorWithOptions: () => isExternalLibrarySelectorWithOptions,
   isIgnoredElement: () => isIgnoredElement,
   isInternalDependency: () => isInternalDependency,
   isKnownLocalElement: () => isKnownLocalElement,
@@ -76,10 +71,54 @@ __export(src_exports, {
   isLocalElement: () => isLocalElement,
   isSimpleElementSelectorByType: () => isSimpleElementSelectorByType,
   isUnknownLocalElement: () => isUnknownLocalElement,
+  normalizeElementSelector: () => normalizeElementSelector,
   normalizeElementsSelector: () => normalizeElementsSelector
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/Support/TypeGuards.ts
+function isString(value) {
+  return typeof value === "string";
+}
+function isUndefined(value) {
+  return value === void 0;
+}
+function isNull(value) {
+  return value === null;
+}
+function isNullish(value) {
+  return isUndefined(value) || isNull(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+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);
+}
+function isEmptyArray(arr) {
+  return arr.length === 0;
+}
+function isStringArray(value) {
+  return isArray(value) && value.every(isString);
+}
+function isObjectWithProperty(value, key) {
+  return isObject(value) && Object.hasOwn(value, key);
+}
+function isObjectWithAnyOfProperties(value, keys) {
+  return isObject(value) && keys.some((key) => key in value);
+}
+
+// src/Support/Paths.ts
+function normalizePath(filePath) {
+  return filePath.replaceAll("\\", "/");
+}
+
 // src/Config/Config.ts
 var Config = class {
   /** The ignore paths */
@@ -90,6 +129,10 @@ var Config = class {
   _legacyTemplates;
   /** Whether the cache is enabled */
   _cache;
+  /** Configuration for categorizing dependencies as external or local */
+  _flagAsExternal;
+  /** Root path of the project */
+  _rootPath;
   /**
    * Creates a new Config instance
    * @param options Configuration options
@@ -99,6 +142,18 @@ var Config = class {
     this._includePaths = options?.includePaths;
     this._legacyTemplates = options?.legacyTemplates ?? true;
     this._cache = options?.cache ?? true;
+    this._flagAsExternal = {
+      unresolvableAlias: options?.flagAsExternal?.unresolvableAlias ?? true,
+      inNodeModules: options?.flagAsExternal?.inNodeModules ?? true,
+      outsideRootPath: options?.flagAsExternal?.outsideRootPath ?? false,
+      customSourcePatterns: options?.flagAsExternal?.customSourcePatterns ?? []
+    };
+    if (options?.rootPath) {
+      const normalizedRoot = normalizePath(options.rootPath);
+      this._rootPath = normalizedRoot.endsWith("/") ? normalizedRoot : `${normalizedRoot}/`;
+    } else {
+      this._rootPath = void 0;
+    }
   }
   /**
    * The normalized configuration options
@@ -108,7 +163,9 @@ var Config = class {
       ignorePaths: this._ignorePaths,
       includePaths: this._includePaths,
       legacyTemplates: this._legacyTemplates,
-      cache: this._cache
+      cache: this._cache,
+      flagAsExternal: this._flagAsExternal,
+      rootPath: this._rootPath
     };
   }
   /**
@@ -118,7 +175,9 @@ var Config = class {
     return {
       ignorePaths: this._ignorePaths,
       includePaths: this._includePaths,
-      cache: this._cache
+      cache: this._cache,
+      flagAsExternal: this._flagAsExternal,
+      rootPath: this._rootPath
     };
   }
   /**
@@ -139,137 +198,8 @@ var Config = class {
 
 // src/Matcher/BaseElementsMatcher.ts
 var import_handlebars = __toESM(require("handlebars"));
-
-// src/Support/TypeGuards.ts
-function isString(value) {
-  return typeof value === "string";
-}
-function isNullish(value) {
-  return value === null || value === void 0;
-}
-function isNull(value) {
-  return value === null;
-}
-function isBoolean(value) {
-  return typeof value === "boolean";
-}
-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);
-}
-function isEmptyArray(arr) {
-  return arr.length === 0;
-}
-function isStringArray(value) {
-  return isArray(value) && value.every(isString);
-}
-function isObjectWithProperty(value, key) {
-  return isObject(value) && Object.hasOwn(value, key);
-}
-function isObjectWithAnyOfProperties(value, keys) {
-  return isObject(value) && keys.some((key) => key in value);
-}
-
-// src/Matcher/MatcherHelpers.ts
-function isCapturedValuesSelector(value) {
-  if (!isObject(value) || isArray(value)) {
-    return false;
-  }
-  return Object.values(value).every(
-    (pattern) => isString(pattern) || isStringArray(pattern)
-  );
-}
-function isSimpleElementSelectorByType(value) {
-  return isString(value);
-}
-function isBaseElementSelectorData(value) {
-  return isObjectWithAnyOfProperties(value, [
-    "path",
-    "elementPath",
-    "internalPath",
-    "type",
-    "category",
-    "captured",
-    "origin",
-    "source",
-    "baseSource",
-    "isIgnored",
-    "isUnknown"
-  ]);
-}
-function isElementSelectorData(value) {
-  return isBaseElementSelectorData(value) || isObjectWithAnyOfProperties(value, [
-    "relationship",
-    "kind",
-    "specifiers",
-    "nodeKind"
-  ]);
-}
-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]) || // 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);
-}
-function isElementsSelector(value) {
-  return isElementSelector(value) || isArray(value) && !isEmptyArray(value) && value.every(isElementSelector);
-}
-function isDependencySelector(value) {
-  return isObjectWithAnyOfProperties(value, ["from", "to"]);
-}
-function isExternalLibrarySelectorOptionsWithPath(value) {
-  return isObjectWithProperty(value, "path") && (isString(value.path) || isStringArray(value.path));
-}
-function isExternalLibrarySelectorOptionsWithSpecifiers(value) {
-  return isObjectWithProperty(value, "specifiers") && isStringArray(value.specifiers);
-}
-function isExternalLibrarySelectorOptions(value) {
-  return isExternalLibrarySelectorOptionsWithPath(value) || isExternalLibrarySelectorOptionsWithSpecifiers(value);
-}
-function isExternalLibrarySelectorWithOptions(value) {
-  return isArray(value) && value.length === 2 && isSimpleElementSelectorByType(value[0]) && isExternalLibrarySelectorOptions(value[1]);
-}
-function isExternalLibrarySelector(value) {
-  return isSimpleElementSelectorByType(value) || isExternalLibrarySelectorWithOptions(value);
-}
-function isExternalLibrariesSelector(value) {
-  return isExternalLibrarySelector(value) || isArray(value) && !isEmptyArray(value) && value.every(isExternalLibrarySelector);
-}
-
-// src/Matcher/BaseElementsMatcher.ts
-var HANDLEBARS_TEMPLATE_REGEX = /{{\s*[^}\s]+(?:\s+[^}\s]+)*\s*}}/;
 var LEGACY_TEMPLATE_REGEX = /\$\{([^}]+)\}/g;
-function normalizeSelector(selector) {
-  if (isSimpleElementSelectorByType(selector)) {
-    return { type: selector };
-  }
-  if (isElementSelectorData(selector)) {
-    return { ...selector };
-  }
-  if (isElementSelectorWithLegacyOptions(selector)) {
-    return {
-      type: selector[0],
-      captured: selector[1] ? { ...selector[1] } : void 0
-    };
-  }
-  throw new Error("Invalid element selector");
-}
-function normalizeElementsSelector(elementsSelector) {
-  if (isArray(elementsSelector)) {
-    if (isElementSelectorWithLegacyOptions(elementsSelector)) {
-      return [normalizeSelector(elementsSelector)];
-    }
-    return elementsSelector.map((sel) => normalizeSelector(sel));
-  }
-  return [normalizeSelector(elementsSelector)];
-}
+var HANDLEBARS_TEMPLATE_REGEX = /{{\s*[^{}\s][^{}]*}}/;
 var BaseElementsMatcher = class {
   /**
    * Option to use legacy templates with ${} syntax.
@@ -294,6 +224,9 @@ var BaseElementsMatcher = class {
    * @returns The converted template.
    */
   _getBackwardsCompatibleTemplate(template) {
+    if (!template) {
+      return template;
+    }
     return template.replaceAll(LEGACY_TEMPLATE_REGEX, "{{ $1 }}");
   }
   /**
@@ -302,6 +235,9 @@ var BaseElementsMatcher = class {
    * @returns True if the template contains Handlebars syntax, false otherwise.
    */
   _isHandlebarsTemplate(template) {
+    if (!template) {
+      return false;
+    }
     return HANDLEBARS_TEMPLATE_REGEX.test(template);
   }
   /**
@@ -333,6 +269,14 @@ var BaseElementsMatcher = class {
     }
     return this._getRenderedTemplate(template, templateData);
   }
+  /**
+   * Cleans a micromatch pattern by removing falsy values from arrays.
+   * @param pattern The micromatch pattern(s) to clean.
+   * @returns The cleaned pattern. If an array is provided, falsy entries are removed and the resulting array may be empty. If null is provided, null is returned unchanged.
+   */
+  cleanMicromatchPattern(pattern) {
+    return isArray(pattern) ? pattern.filter(Boolean) : pattern;
+  }
   /**
    * Returns whether the given value matches the micromatch pattern, converting non-string values to strings.
    * Optimized version with caching for better performance.
@@ -341,9 +285,18 @@ var BaseElementsMatcher = class {
    * @returns Whether the value matches the pattern.
    */
   isMicromatchMatch(value, pattern) {
+    if (isNull(pattern)) {
+      return isNull(value);
+    }
+    if (isNull(value)) {
+      return isArray(pattern) && pattern.some(isNull);
+    }
+    const patternToCheck = this.cleanMicromatchPattern(pattern);
+    if (!patternToCheck?.length) {
+      return false;
+    }
     const elementValueToCheck = !value || !isString(value) ? String(value) : value;
-    const selectorValueToCheck = isArray(pattern) ? pattern.filter(Boolean) : pattern;
-    return this.micromatch.isMatch(elementValueToCheck, selectorValueToCheck);
+    return this.micromatch.isMatch(elementValueToCheck, patternToCheck);
   }
   /**
    * Returns whether the given value matches the micromatch pattern after rendering it as a template.
@@ -353,18 +306,17 @@ var BaseElementsMatcher = class {
    * @returns Whether the value matches the rendered pattern.
    */
   isTemplateMicromatchMatch(pattern, templateData, value) {
-    if (isNullish(value)) {
+    if (isUndefined(value)) {
       return false;
     }
     const patternRendered = this.getRenderedTemplates(pattern, templateData);
-    if (!patternRendered) {
+    if (!isNull(patternRendered) && !patternRendered) {
       return false;
     }
-    const filteredPattern = isArray(patternRendered) ? patternRendered.filter(Boolean) : patternRendered;
     if (isArray(value)) {
-      return value.some((val) => this.isMicromatchMatch(val, filteredPattern));
+      return value.some((val) => this.isMicromatchMatch(val, patternRendered));
     }
-    return this.isMicromatchMatch(value, filteredPattern);
+    return this.isMicromatchMatch(value, patternRendered);
   }
   /**
    * Whether the given element key matches the selector key as booleans.
@@ -408,20 +360,113 @@ var BaseElementsMatcher = class {
     if (!(selectorKey in selector)) {
       return true;
     }
-    if (!selectorValue) {
-      return false;
-    }
-    if (!isObjectWithProperty(element, elementKey)) {
+    if (isUndefined(selectorValue) || !isObjectWithProperty(element, String(elementKey))) {
       return false;
     }
+    const elementValue = element[String(elementKey)];
     return this.isTemplateMicromatchMatch(
       selectorValue,
       templateData,
-      element[elementKey]
+      elementValue
     );
   }
 };
 
+// src/Matcher/MatcherHelpers.ts
+function isCapturedValuesObjectSelector(value) {
+  if (!isObject(value) || isArray(value)) {
+    return false;
+  }
+  return Object.values(value).every(
+    (pattern) => isString(pattern) || isStringArray(pattern)
+  );
+}
+function isCapturedValuesSelector(value) {
+  if (isArray(value)) {
+    return value.every((item) => isCapturedValuesObjectSelector(item));
+  }
+  return isCapturedValuesObjectSelector(value);
+}
+function isSimpleElementSelectorByType(value) {
+  return isString(value);
+}
+function isBaseElementSelectorData(value) {
+  return isObjectWithAnyOfProperties(value, [
+    "path",
+    "elementPath",
+    "internalPath",
+    "type",
+    "category",
+    "captured",
+    "parent",
+    "origin",
+    "source",
+    "module",
+    "isIgnored",
+    "isUnknown"
+  ]);
+}
+function isElementSelectorData(value) {
+  return isBaseElementSelectorData(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]) || // 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);
+}
+function isElementsSelector(value) {
+  return isElementSelector(value) || isArray(value) && !isEmptyArray(value) && value.every(isElementSelector);
+}
+function normalizeElementSelector(selector) {
+  if (isSimpleElementSelectorByType(selector)) {
+    return { type: selector };
+  }
+  if (isElementSelectorData(selector)) {
+    return { ...selector };
+  }
+  if (isElementSelectorWithLegacyOptions(selector)) {
+    return {
+      type: selector[0],
+      captured: selector[1] ? { ...selector[1] } : void 0
+    };
+  }
+  throw new Error("Invalid element selector");
+}
+function normalizeElementsSelector(elementsSelector) {
+  if (isArray(elementsSelector)) {
+    if (isElementSelectorWithLegacyOptions(elementsSelector)) {
+      return [normalizeElementSelector(elementsSelector)];
+    }
+    return elementsSelector.map((sel) => normalizeElementSelector(sel));
+  }
+  return [normalizeElementSelector(elementsSelector)];
+}
+function isDependencySelector(value) {
+  if (!isObjectWithAnyOfProperties(value, ["from", "to", "dependency"])) {
+    return false;
+  }
+  const fromIsValid = !isObjectWithProperty(value, "from") || isElementsSelector(value.from);
+  const toIsValid = !isObjectWithProperty(value, "to") || isElementsSelector(value.to);
+  const dependencyIsValid = !isObjectWithProperty(value, "dependency") || isDependencyDataSelector(value.dependency);
+  return fromIsValid && toIsValid && dependencyIsValid;
+}
+function isDependencyDataSelectorData(value) {
+  return isObjectWithAnyOfProperties(value, [
+    "kind",
+    "relationship",
+    "specifiers",
+    "nodeKind",
+    "source",
+    "module"
+  ]);
+}
+function isDependencyDataSelector(value) {
+  return isDependencyDataSelectorData(value) || isArray(value) && !isEmptyArray(value) && value.every(isDependencyDataSelectorData);
+}
+
 // src/Matcher/DependenciesMatcher.ts
 var DependenciesMatcher = class extends BaseElementsMatcher {
   /**
@@ -444,68 +489,20 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
    * @param selector The dependency selector to normalize.
    * @returns The normalized dependency selector.
    */
-  _normalizeDependencySelector(selector, dependencySelectorsGlobals) {
+  _normalizeDependencySelector(selector) {
     if (!isDependencySelector(selector)) {
       throw new Error("Invalid dependency selector");
     }
-    let normalizedDependencySelectors = selector.to ? normalizeElementsSelector(selector.to) : null;
-    if (normalizedDependencySelectors) {
-      normalizedDependencySelectors = normalizedDependencySelectors.map(
-        (depSelector) => {
-          return {
-            ...dependencySelectorsGlobals,
-            ...depSelector
-          };
-        }
-      );
+    let normalizedDependencySelectors = null;
+    if (selector.dependency && isDependencyDataSelector(selector.dependency)) {
+      normalizedDependencySelectors = isArray(selector.dependency) ? selector.dependency : [selector.dependency];
     }
     return {
       from: selector.from ? normalizeElementsSelector(selector.from) : null,
-      to: normalizedDependencySelectors
+      to: selector.to ? normalizeElementsSelector(selector.to) : null,
+      dependency: normalizedDependencySelectors
     };
   }
-  /**
-   * Converts a DependencyElementSelectorData to a BaseElementSelectorData, by removing dependency-specific properties.
-   * @param selector The dependency element selector data.
-   * @returns The base element selector data.
-   */
-  _convertDependencyElementSelectorDataToBaseElementSelectorData(selector) {
-    const baseSelector = {};
-    if (selector.type) {
-      baseSelector.type = selector.type;
-    }
-    if (selector.category) {
-      baseSelector.category = selector.category;
-    }
-    if (selector.path) {
-      baseSelector.path = selector.path;
-    }
-    if (selector.elementPath) {
-      baseSelector.elementPath = selector.elementPath;
-    }
-    if (selector.internalPath) {
-      baseSelector.internalPath = selector.internalPath;
-    }
-    if (selector.captured) {
-      baseSelector.captured = selector.captured;
-    }
-    if (selector.origin) {
-      baseSelector.origin = selector.origin;
-    }
-    if (selector.baseSource) {
-      baseSelector.baseSource = selector.baseSource;
-    }
-    if (selector.source) {
-      baseSelector.source = selector.source;
-    }
-    if (!isNullish(selector.isIgnored)) {
-      baseSelector.isIgnored = selector.isIgnored;
-    }
-    if (!isNullish(selector.isUnknown)) {
-      baseSelector.isUnknown = selector.isUnknown;
-    }
-    return baseSelector;
-  }
   /**
    * Returns the selectors matching result for the given dependency.
    * @param dependency The dependency description.
@@ -513,56 +510,37 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
    * @param extraTemplateData The extra template data for selector values.
    * @returns The selectors matching result for the given dependency.
    */
-  _getSelectorMatching(dependency, selector, templateData) {
-    const getFromSelectorMatching = () => {
-      for (const fromSelectorData of selector.from) {
-        const fromMatch = this._elementsMatcher.isElementMatch(
-          dependency.from,
-          fromSelectorData,
-          {
-            extraTemplateData: templateData
-          }
-        );
-        const dependencyPropertiesMatch = this._dependencyFromPropertiesMatch(
+  _getSelectorsMatching(dependency, selector, templateData) {
+    const getDependencyMetadataSelectorMatching = () => {
+      for (const dependencySelectorData of selector.dependency) {
+        const dependencyPropertiesMatch = this._dependencyPropertiesMatch(
           dependency,
-          [fromSelectorData],
+          dependencySelectorData,
           templateData
         );
-        if (fromMatch && dependencyPropertiesMatch) {
-          return fromSelectorData;
+        if (dependencyPropertiesMatch) {
+          return dependencySelectorData;
         }
       }
       return null;
     };
-    const getToSelectorMatching = () => {
-      for (const toSelectorData of selector.to) {
-        const toMatch = isBaseElementSelectorData(toSelectorData) ? this._elementsMatcher.isElementMatch(
-          dependency.to,
-          this._convertDependencyElementSelectorDataToBaseElementSelectorData(
-            toSelectorData
-          ),
-          {
-            extraTemplateData: templateData
-          }
-        ) : true;
-        const dependencyPropertiesMatch = this._dependencyToPropertiesMatch(
-          dependency,
-          [toSelectorData],
-          templateData
-        );
-        if (toMatch && dependencyPropertiesMatch) {
-          return toSelectorData;
-        }
+    const fromSelectorMatching = selector.from ? this._elementsMatcher.getSelectorMatching(
+      dependency.from,
+      selector.from,
+      {
+        extraTemplateData: templateData
       }
-      return null;
-    };
-    const fromSelectorMatching = selector.from ? getFromSelectorMatching() : null;
-    const toSelectorMatching = selector.to ? getToSelectorMatching() : null;
+    ) : null;
+    const toSelectorMatching = selector.to ? this._elementsMatcher.getSelectorMatching(dependency.to, selector.to, {
+      extraTemplateData: templateData
+    }) : null;
+    const dependencyMetadataSelectorMatching = selector.dependency ? getDependencyMetadataSelectorMatching() : null;
     return {
       from: fromSelectorMatching,
       to: toSelectorMatching,
+      dependency: dependencyMetadataSelectorMatching,
       isMatch: Boolean(
-        (selector.from ? fromSelectorMatching : true) && (selector.to ? toSelectorMatching : true)
+        (selector.from ? fromSelectorMatching : true) && (selector.to ? toSelectorMatching : true) && (selector.dependency ? dependencyMetadataSelectorMatching : true)
       )
     };
   }
@@ -572,12 +550,29 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
    * @param selector The data of an element selector.
    * @returns Whether the dependency relationship matches the selector.
    */
-  _relationshipMatches(selector, relationship, templateData) {
-    if (!selector.relationship) {
+  _relationshipFromMatches(selector, relationship, templateData) {
+    if (!selector.relationship?.from) {
       return true;
     }
     return this.isTemplateMicromatchMatch(
-      selector.relationship,
+      selector.relationship.from,
+      templateData,
+      relationship
+    );
+  }
+  /**
+   * Determines if the dependency origin relationship matches the selector.
+   * @param selector The dependency selector data.
+   * @param relationship The relationship from origin element to target element.
+   * @param templateData The template data for rendering selector values.
+   * @returns Whether the dependency origin relationship matches.
+   */
+  _relationshipToMatches(selector, relationship, templateData) {
+    if (!selector.relationship?.to) {
+      return true;
+    }
+    return this.isTemplateMicromatchMatch(
+      selector.relationship.to,
       templateData,
       relationship
     );
@@ -630,75 +625,85 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
     );
   }
   /**
-   * Determines if the dependency description matches the selector for 'from'.
+   * Determines if the dependency description matches the selector for 'to'.
    * @param dependency The dependency description.
-   * @param fromSelector The selector for 'from' elements.
+   * @param toSelector The selector for 'to' elements.
    * @param templateData The template data for rendering selector values
-   * @returns Whether the dependency properties match the selector for 'from'.
-   */
-  _dependencyFromPropertiesMatch(dependency, fromSelector, templateData) {
-    return fromSelector.some(
-      (selectorData) => this._relationshipMatches(
-        selectorData,
-        dependency.dependency.relationship.from,
-        templateData
-      )
+   * @returns Whether the dependency properties match the selector for 'to'.
+   */
+  _sourceMatches(selector, source, templateData) {
+    if (!selector.source) {
+      return true;
+    }
+    return this.isTemplateMicromatchMatch(
+      selector.source,
+      templateData,
+      source
     );
   }
   /**
-   * Determines if the dependency description matches the selector for 'to'.
+   * Determines if the selector matches the module
+   * @param selector The dependency selector data
+   * @param module The module to check
+   * @param templateData The template data for rendering selector values
+   * @returns Whether the selector matches the module
+   */
+  _moduleMatches(selector, dependencyModule, templateData) {
+    if (!selector.module) {
+      return true;
+    }
+    return this.isTemplateMicromatchMatch(
+      selector.module,
+      templateData,
+      dependencyModule
+    );
+  }
+  /**
+   * Determines if the dependency description matches the selector for dependency metadata.
    * @param dependency The dependency description.
-   * @param toSelector The selector for 'to' elements.
+   * @param selectorData The selector for dependency metadata.
    * @param templateData The template data for rendering selector values
-   * @returns Whether the dependency properties match the selector for 'to'.
+   * @returns Whether the dependency properties match the selector.
    */
-  _dependencyToPropertiesMatch(dependency, toSelector, templateData) {
+  _dependencyPropertiesMatch(dependency, selectorData, templateData) {
     const dependencyInfo = dependency.dependency;
+    const relationshipFrom = dependencyInfo.relationship.from;
     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;
+    const source = dependencyInfo.source;
+    const dependencyModule = dependencyInfo.module;
+    return this._kindMatches(selectorData, kind, templateData) && this._nodeKindMatches(selectorData, nodeKind, templateData) && this._sourceMatches(selectorData, source, templateData) && this._moduleMatches(selectorData, dependencyModule, templateData) && this._relationshipFromMatches(
+      selectorData,
+      relationshipFrom,
+      templateData
+    ) && this._relationshipToMatches(selectorData, relationshipTo, templateData) && this._specifierMatches(selectorData, specifiers, templateData);
   }
   /**
    * Returns the selectors matching result for the given dependency.
    * @param dependency The dependency to check.
    * @param selector The selector to check against.
-   * @param options Extra options for matching, such as templates data, globals for dependency selectors, etc.
+   * @param options Extra options for matching, such as templates data, etc.
    * @returns The matching result for the dependency against the selector.
    */
-  getSelectorsMatching(dependency, selector, {
-    extraTemplateData = {},
-    dependencySelectorsGlobals = {}
-  } = {}) {
-    const normalizedSelector = this._normalizeDependencySelector(
-      selector,
-      dependencySelectorsGlobals
-    );
+  getSelectorsMatching(dependency, selector, { extraTemplateData = {} } = {}) {
+    const normalizedSelector = this._normalizeDependencySelector(selector);
     const fromExtraData = extraTemplateData.from || {};
     const toExtraData = extraTemplateData.to || {};
     const templateData = {
       ...extraTemplateData,
       from: {
         ...dependency.from,
-        relationship: dependency.dependency.relationship.from,
         ...fromExtraData
       },
       to: {
         ...dependency.to,
-        relationship: dependency.dependency.relationship.to,
-        kind: dependency.dependency.kind,
-        nodeKind: dependency.dependency.nodeKind,
-        specifiers: dependency.dependency.specifiers,
         ...toExtraData
-      }
+      },
+      dependency: dependency.dependency
     };
-    const result = this._getSelectorMatching(
+    const result = this._getSelectorsMatching(
       dependency,
       normalizedSelector,
       templateData
@@ -709,7 +714,7 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
    * Returns whether the given dependency matches the selector.
    * @param dependency The dependency to check.
    * @param selector The selector to check against.
-   * @param options Extra options for matching, such as templates data, globals for dependency selectors, etc.
+   * @param options Extra options for matching, such as templates data, etc.
    * @returns Whether the dependency matches the selector properties.
    */
   isDependencyMatch(dependency, selector, options) {
@@ -724,8 +729,6 @@ var DependenciesMatcher = class extends BaseElementsMatcher {
 
 // src/Matcher/ElementsMatcher.ts
 var ElementsMatcher = class extends BaseElementsMatcher {
-  /** Whether the cache is enabled or not */
-  _cacheIsEnabled;
   /**
    * Creates a new ElementsSelectorMatcher.
    * @param config Configuration options for the matcher.
@@ -838,41 +841,36 @@ var ElementsMatcher = class extends BaseElementsMatcher {
     });
   }
   /**
-   * Whether the given element baseSource matches the selector baseSource
-   * @param element The element to check.
-   * @param selector The selector to check against.
-   * @param templateData The data to use for replace in selector value
-   * @returns Whether the element baseSource matches the selector baseSource.
-   */
-  _isBaseSourceMatch(element, selector, templateData) {
-    return this.isElementKeyMicromatchMatch({
-      element,
-      selector,
-      elementKey: "baseSource",
-      selectorKey: "baseSource",
-      selectorValue: selector.baseSource,
-      templateData
-    });
-  }
-  /**
-   * Whether the given element source matches the selector source
-   * @param element The element to check.
-   * @param selector The selector to check against.
-   * @param templateData The data to use for replace in selector value
-   * @returns Whether the element source matches the selector source.
+   * Checks if a single captured values object matches the element.
+   * @param capturedValues The captured values to check.
+   * @param capturedSelector The captured values selector object to check against
+   * @param templateData The data to use for replace in selector values
+   * @returns True if all captured values in the selector match those in the element, false otherwise.
    */
-  _isSourceMatch(element, selector, templateData) {
-    return this.isElementKeyMicromatchMatch({
-      element,
-      selector,
-      elementKey: "source",
-      selectorKey: "source",
-      selectorValue: selector.source,
-      templateData
-    });
+  _checkCapturedValuesObject(capturedValues, capturedSelector, templateData) {
+    if (!capturedValues) {
+      return false;
+    }
+    for (const [key, pattern] of Object.entries(capturedSelector)) {
+      const elementValue = capturedValues[key];
+      if (!elementValue) {
+        return false;
+      }
+      const renderedPattern = this.getRenderedTemplates(pattern, templateData);
+      const filteredPattern = this.cleanMicromatchPattern(renderedPattern);
+      if (!filteredPattern) {
+        return false;
+      }
+      const isMatch = this.micromatch.isMatch(elementValue, filteredPattern);
+      if (!isMatch) {
+        return false;
+      }
+    }
+    return true;
   }
   /**
    * Determines if the captured values of the element match those in the selector.
+   * When the selector is an array, the element matches if it matches any of the array elements (OR logic).
    * @param element The element to check.
    * @param selector The selector to check against
    * @param templateData The data to use for replace in selector values
@@ -882,23 +880,98 @@ var ElementsMatcher = class extends BaseElementsMatcher {
     if (!selector.captured || isEmptyObject(selector.captured)) {
       return true;
     }
-    if (!element.captured) {
-      return false;
-    }
-    for (const [key, pattern] of Object.entries(selector.captured)) {
-      const elementValue = element.captured?.[key];
-      if (!elementValue) {
+    if (isArray(selector.captured)) {
+      if (selector.captured.length === 0) {
         return false;
       }
-      const renderedPattern = this.getRenderedTemplates(pattern, templateData);
-      if (!renderedPattern) {
-        return false;
-      }
-      const filteredPattern = isArray(renderedPattern) ? renderedPattern.filter(Boolean) : renderedPattern;
-      const isMatch = this.micromatch.isMatch(elementValue, filteredPattern);
-      if (!isMatch) {
+      return selector.captured.some(
+        (capturedSelector) => this._checkCapturedValuesObject(
+          element.captured,
+          capturedSelector,
+          templateData
+        )
+      );
+    }
+    return this._checkCapturedValuesObject(
+      element.captured,
+      selector.captured,
+      templateData
+    );
+  }
+  /**
+   * Determines if the parent captured values match the selector.
+   * @param parentSelector The parent selector to match.
+   * @param parentCaptured The captured values from first parent.
+   * @param templateData The data to use for replace in selector values
+   * @returns True if the captured values match, false otherwise.
+   */
+  _isParentCapturedValuesMatch(parentSelector, parentCaptured, templateData) {
+    if (!parentSelector.captured || isEmptyObject(parentSelector.captured)) {
+      return true;
+    }
+    if (isArray(parentSelector.captured)) {
+      if (parentSelector.captured.length === 0) {
         return false;
       }
+      return parentSelector.captured.some(
+        (capturedSelector) => this._checkCapturedValuesObject(
+          parentCaptured,
+          capturedSelector,
+          templateData
+        )
+      );
+    }
+    return this._checkCapturedValuesObject(
+      parentCaptured,
+      parentSelector.captured,
+      templateData
+    );
+  }
+  /**
+   * Whether the given element first parent matches the selector parent.
+   * @param element The element to check.
+   * @param selector The selector to check against.
+   * @param templateData The data to use for replace in selector values
+   * @returns Whether the first parent matches the selector parent.
+   */
+  _isParentMatch(element, selector, templateData) {
+    if (isUndefined(selector.parent)) {
+      return true;
+    }
+    if (isNull(selector.parent)) {
+      return !element.parents || element.parents.length === 0;
+    }
+    const firstParent = element.parents?.[0];
+    if (!firstParent) {
+      return false;
+    }
+    if (!isUndefined(selector.parent.type) && !this.isTemplateMicromatchMatch(
+      selector.parent.type,
+      templateData,
+      firstParent.type
+    )) {
+      return false;
+    }
+    if (!isUndefined(selector.parent.category) && !this.isTemplateMicromatchMatch(
+      selector.parent.category,
+      templateData,
+      firstParent.category
+    )) {
+      return false;
+    }
+    if (!isUndefined(selector.parent.elementPath) && !this.isTemplateMicromatchMatch(
+      selector.parent.elementPath,
+      templateData,
+      firstParent.elementPath
+    )) {
+      return false;
+    }
+    if (!this._isParentCapturedValuesMatch(
+      selector.parent,
+      firstParent.captured,
+      templateData
+    )) {
+      return false;
     }
     return true;
   }
@@ -943,7 +1016,7 @@ var ElementsMatcher = class extends BaseElementsMatcher {
       ...extraTemplateData
     };
     for (const selectorData of selectorsData) {
-      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)) {
+      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._isCapturedValuesMatch(element, selectorData, templateData) || !this._isParentMatch(element, selectorData, templateData)) {
         continue;
       }
       return selectorData;
@@ -955,7 +1028,7 @@ var ElementsMatcher = class extends BaseElementsMatcher {
    * It omits checks in keys applying only to dependency between elements, such as relationship.
    * @param element The element to check.
    * @param selector The selector to check against.
-   * @param options Extra options for matching, such as templates data, globals for dependency selectors, etc.
+   * @param options Extra options for matching, such as templates data, etc.
    * @returns The selector matching result for the given element, or null if none matches.
    */
   getSelectorMatching(element, selector, { extraTemplateData = {} } = {}) {
@@ -967,7 +1040,7 @@ var ElementsMatcher = class extends BaseElementsMatcher {
    * It omits checks in keys applying only to dependency between elements, such as relationship.
    * @param element The element to check.
    * @param selector The selector to check against.
-   * @param options Extra options for matching, such as templates data, globals for dependency selectors, etc.
+   * @param options Extra options for matching, such as templates data, etc.
    * @returns Whether the element matches the selector properties applying to elements.
    */
   isElementMatch(element, selector, options) {
@@ -1034,20 +1107,17 @@ function isUnknownLocalElement(value) {
 function isKnownLocalElement(value) {
   return isLocalElement(value) && value.isUnknown === false;
 }
-function isDependencyElementDescription(value) {
-  return isBaseElement(value) && isObjectWithProperty(value, "source") && isString(value.source);
-}
-function isElementDescription(value) {
-  return isIgnoredElement(value) || isUnknownLocalElement(value) || isKnownLocalElement(value) || isDependencyElementDescription(value);
-}
 function isLocalDependencyElement(value) {
-  return isDependencyElementDescription(value) && isLocalElement(value);
+  return isLocalElement(value) && value.isIgnored === false;
 }
 function isExternalDependencyElement(value) {
-  return isDependencyElementDescription(value) && value.origin === ELEMENT_ORIGINS_MAP.EXTERNAL && isObjectWithProperty(value, "baseSource") && isString(value.baseSource);
+  return isBaseElement(value) && value.origin === ELEMENT_ORIGINS_MAP.EXTERNAL;
 }
 function isCoreDependencyElement(value) {
-  return isDependencyElementDescription(value) && value.origin === ELEMENT_ORIGINS_MAP.CORE && isObjectWithProperty(value, "baseSource") && isString(value.baseSource);
+  return isBaseElement(value) && value.origin === ELEMENT_ORIGINS_MAP.CORE;
+}
+function isElementDescription(value) {
+  return isIgnoredElement(value) || isUnknownLocalElement(value) || isKnownLocalElement(value) || isExternalDependencyElement(value) || isCoreDependencyElement(value);
 }
 
 // src/Descriptor/DependenciesDescriptor.types.ts
@@ -1104,7 +1174,7 @@ function isDependencyRelationshipDescription(value) {
   return isObjectWithProperty(value, "to") && (isNull(value.to) || isDependencyRelationship(value.to)) && isObjectWithProperty(value, "from") && (isNull(value.from) || isDependencyRelationship(value.from));
 }
 function isElementsDependencyInfo(value) {
-  return isObjectWithProperty(value, "kind") && isDependencyKind(value.kind) && isObjectWithProperty(value, "relationship") && isDependencyRelationshipDescription(value.relationship) && isObjectWithProperty(value, "nodeKind") && (isNull(value.nodeKind) || isString(value.nodeKind));
+  return isObjectWithProperty(value, "source") && isString(value.source) && isObjectWithProperty(value, "module") && (isNullish(value.module) || isString(value.module)) && isObjectWithProperty(value, "kind") && isDependencyKind(value.kind) && isObjectWithProperty(value, "relationship") && isDependencyRelationshipDescription(value.relationship) && isObjectWithProperty(value, "nodeKind") && (isNull(value.nodeKind) || isString(value.nodeKind)) && isObjectWithProperty(value, "specifiers") && (isNull(value.specifiers) || isStringArray(value.specifiers));
 }
 function isDependencyDescription(value) {
   return isObjectWithProperty(value, "to") && isElementDescription(value.to) && isObjectWithProperty(value, "from") && isElementDescription(value.from) && isObjectWithProperty(value, "dependency") && isElementsDependencyInfo(value.dependency);
@@ -1442,17 +1512,20 @@ var DependenciesDescriptor = class {
       return this._dependenciesCache.get(cacheKey);
     }
     const fromElement = this._elementsDescriptor.describeElement(from);
-    const toElement = this._elementsDescriptor.describeDependencyElement(
-      source,
-      to
-    );
+    const toElement = this._elementsDescriptor.describeElement(to, source);
+    const { module: dependencyModule, ...toElementDescription } = toElement;
     const result = {
       from: fromElement,
-      to: toElement,
+      to: toElementDescription,
       dependency: {
+        source,
+        module: dependencyModule || null,
         kind,
         nodeKind: nodeKind || null,
-        relationship: this._dependencyRelationships(fromElement, toElement),
+        relationship: this._dependencyRelationships(
+          fromElement,
+          toElementDescription
+        ),
         specifiers: specifiers || null
       }
     };
@@ -1467,8 +1540,6 @@ var UNKNOWN_ELEMENT = {
   path: null,
   elementPath: null,
   internalPath: null,
-  source: null,
-  baseSource: null,
   parents: null,
   type: null,
   category: null,
@@ -1570,8 +1641,8 @@ var ElementsDescriptor = class {
    */
   _dependencySourceIsCoreModule(dependencySource, baseDependencySource) {
     if (this._mod) {
-      const baseSourceWithoutPrefix = baseDependencySource.startsWith("node:") ? baseDependencySource.slice(5) : baseDependencySource;
-      return this._mod.builtinModules.includes(baseSourceWithoutPrefix);
+      const moduleWithoutPrefix = baseDependencySource.startsWith("node:") ? baseDependencySource.slice(5) : baseDependencySource;
+      return this._mod.builtinModules.includes(moduleWithoutPrefix);
     }
     return (0, import_is_core_module.default)(dependencySource);
   }
@@ -1596,7 +1667,7 @@ var ElementsDescriptor = class {
    * @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")
    */
-  _getExternalOrCoreModuleBaseSource(dependencySource) {
+  _getExternalOrCoreModuleModule(dependencySource) {
     if (this._dependencySourceIsScoped(dependencySource)) {
       const [scope, packageName] = dependencySource.split("/");
       return `${scope}/${packageName}`;
@@ -1605,17 +1676,72 @@ var ElementsDescriptor = class {
     return pkg;
   }
   /**
-   * Determines if an element is external based on its file path and dependency source.
-   * Files inside "node_modules" are considered external.
-   * If the dependency source is not provided, only the file path is considered.
-   * If the dependency source is provided, it must not be a local path (i.e, it should start by "./", "../", or "/").
-   * @param filePath
-   * @param dependencySource
-   * @returns
+   * Determines if a file path is outside the configured root path.
+   * @param filePath The file path to check.
+   * @returns True if the file path is outside the root path, false otherwise.
+   */
+  _isOutsideRootPath(filePath) {
+    if (!this._config.rootPath) {
+      return false;
+    }
+    return !filePath.startsWith(this._config.rootPath);
+  }
+  /**
+   * Converts an absolute file path to a relative path if rootPath is configured.
+   * If rootPath is not configured, returns the path as-is (maintains backward compatibility).
+   * @param filePath The file path to convert (can be absolute or relative)
+   * @returns The relative path if rootPath is configured and path is absolute, otherwise the original path
    */
-  _isExternalDependency(filePath, dependencySource) {
-    return (!filePath || filePath.includes("node_modules")) && // Not having a source, and being in node_modules only could happen if user is analyzing a file directly from there, not as a dependency. Should this be considered external then?
-    (!dependencySource || this._dependencySourceIsExternalOrScoped(dependencySource));
+  _toRelativePath(filePath) {
+    if (!this._config.rootPath || this._isOutsideRootPath(filePath)) {
+      return filePath;
+    }
+    return filePath.replace(this._config.rootPath, "");
+  }
+  /**
+   * Checks if a source string matches any of the provided patterns using micromatch.
+   * @param patterns - Array of micromatch patterns
+   * @param source - The source string to match against patterns
+   * @returns True if the source matches any pattern, false otherwise
+   */
+  _matchesAnyPattern(patterns, source) {
+    if (!source || patterns.length === 0) {
+      return false;
+    }
+    return this._micromatch.isMatch(source, patterns);
+  }
+  /**
+   * Determines if an element is external based on its file path and dependency source.
+   * Uses the flagAsExternal configuration to evaluate multiple conditions with OR logic:
+   * - unresolvableAlias: Files whose path cannot be resolved (filePath is null)
+   * - inNodeModules: Non-relative paths that include "node_modules"
+   * - outsideRootPath: Resolved path is outside the configured root path (only if rootPath is configured)
+   * - customSourcePatterns: Source matches any of the configured patterns
+   * @param filePath The resolved file path (null if unresolved). Can be absolute if rootPath is configured, or relative if rootPath is not configured.
+   * @param isOutsideRootPath Whether the file path is outside the configured root path.
+   * @param dependencySource The import/export source string
+   * @returns True if any of the configured conditions is met, false otherwise
+   */
+  _isExternalDependency(filePath, isOutsideRootPath, dependencySource) {
+    const {
+      unresolvableAlias,
+      inNodeModules,
+      outsideRootPath,
+      customSourcePatterns
+    } = this._config.flagAsExternal;
+    if (outsideRootPath && isOutsideRootPath) {
+      return true;
+    }
+    if (inNodeModules && filePath?.includes("node_modules")) {
+      return true;
+    }
+    if (unresolvableAlias && !filePath && dependencySource && this._dependencySourceIsExternalOrScoped(dependencySource)) {
+      return true;
+    }
+    if (this._matchesAnyPattern(customSourcePatterns, dependencySource)) {
+      return true;
+    }
+    return false;
   }
   /**
    * Determines if a given path is included based on the configuration.
@@ -1683,6 +1809,16 @@ var ElementsDescriptor = class {
     }
     return `${[...allPathSegments].reverse().join("/").split(result)[0]}${result}`;
   }
+  /**
+   * Determines if an element descriptor matches the given parameters in the provided path.
+   * @param options The options for matching the descriptor.
+   * @param options.elementDescriptor The element descriptor to match.
+   * @param options.filePath The file path to match against the descriptor.
+   * @param options.currentPathSegments The current path segments leading to the element.
+   * @param options.lastPathSegmentMatching The last path segment that was matched.
+   * @param options.alreadyMatched Whether the element matched previously.
+   * @returns The result of the match, including whether it matched.
+   */
   _fileDescriptorMatch({
     elementDescriptor,
     filePath,
@@ -1837,11 +1973,12 @@ var ElementsDescriptor = class {
   /**
    * Returns an external or core dependency element given its dependency source and file path.
    * @param dependencySource The source of the dependency.
-   * @param filePath The resolved file path of the dependency, if known.
+   * @param isOutsideRootPath Whether the file path is outside the configured root path.
+   * @param filePath The resolved file path of the dependency, if known. Can be absolute if rootPath is configured.
    * @returns The external or core dependency element, or null if it is a local dependency.
    */
-  _getExternalOrCoreDependencyElement(dependencySource, filePath) {
-    const baseDependencySource = this._getExternalOrCoreModuleBaseSource(dependencySource);
+  _getExternalOrCoreDependencyElement(dependencySource, isOutsideRootPath, filePath) {
+    const baseDependencySource = this._getExternalOrCoreModuleModule(dependencySource);
     const isCore = this._dependencySourceIsCoreModule(
       dependencySource,
       baseDependencySource
@@ -1849,23 +1986,22 @@ var ElementsDescriptor = class {
     if (isCore) {
       const coreElement = {
         ...UNKNOWN_ELEMENT,
-        source: dependencySource,
-        baseSource: baseDependencySource,
+        module: baseDependencySource,
         origin: ELEMENT_ORIGINS_MAP.CORE
       };
       return coreElement;
     }
     const isExternal = this._isExternalDependency(
       filePath || null,
+      isOutsideRootPath,
       dependencySource
     );
     if (isExternal) {
       const externalElement = {
         ...UNKNOWN_ELEMENT,
         path: filePath || null,
-        internalPath: dependencySource.replace(baseDependencySource, ""),
-        source: dependencySource,
-        baseSource: baseDependencySource,
+        internalPath: dependencySource.replace(baseDependencySource, "") || null,
+        module: baseDependencySource,
         origin: ELEMENT_ORIGINS_MAP.EXTERNAL
       };
       return externalElement;
@@ -1877,34 +2013,23 @@ var ElementsDescriptor = class {
     if (this._descriptionsCache.has(cacheKey)) {
       return this._descriptionsCache.get(cacheKey);
     }
-    const externalOrCoreDependencyElement = dependencySource ? this._getExternalOrCoreDependencyElement(dependencySource, filePath) : null;
+    const normalizedFilePath = filePath ? normalizePath(filePath) : filePath;
+    const isOutsideRootPath = normalizedFilePath ? this._isOutsideRootPath(normalizedFilePath) : false;
+    const relativePath = normalizedFilePath && this._config.rootPath ? this._toRelativePath(normalizedFilePath) : normalizedFilePath;
+    const externalOrCoreDependencyElement = dependencySource ? this._getExternalOrCoreDependencyElement(
+      dependencySource,
+      isOutsideRootPath,
+      relativePath
+    ) : 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;
+    const fileDescription = this._describeFile(relativePath);
+    this._descriptionsCache.set(cacheKey, fileDescription);
+    return fileDescription;
   }
-  /**
-   * Describes an element given its file path.
-   * @param filePath The path of the file to describe.
-   * @returns The description of the element.
-   */
-  describeElement(filePath) {
-    return this._describeElement(filePath);
-  }
-  /**
-   * Describes a dependency element given its dependency source and file path.
-   * @param dependencySource The source of the dependency.
-   * @param filePath The path of the file being the dependency, if known.
-   * @returns The description of the dependency element.
-   */
-  describeDependencyElement(dependencySource, filePath) {
+  describeElement(filePath, dependencySource) {
     return this._describeElement(filePath, dependencySource);
   }
 };
@@ -1964,18 +2089,6 @@ var Descriptors = class {
   describeElement(filePath) {
     return this._elementsDescriptor.describeElement(filePath);
   }
-  /**
-   * Describes a dependency element given its dependency source and file path.
-   * @param dependencySource The source of the dependency.
-   * @param filePath The path of the file being the dependency, if known.
-   * @returns The description of the dependency element.
-   */
-  describeDependencyElement(dependencySource, filePath) {
-    return this._elementsDescriptor.describeDependencyElement(
-      dependencySource,
-      filePath
-    );
-  }
   /**
    * Describes elements in a dependency relationship, and provides additional information about the dependency itself.
    * @param options The options for describing the elements and the dependency details.
@@ -2004,6 +2117,22 @@ var Matcher = class {
     this._elementsMatcher = elementsMatcher;
     this._dependenciesMatcher = dependenciesMatcher;
   }
+  /**
+   * Describes an element given its file path.
+   * @param filePath The path of the file to describe.
+   * @returns The description of the element.
+   */
+  describeElement(filePath) {
+    return this._descriptors.describeElement(filePath);
+  }
+  /**
+   * Describes elements in a dependency relationship, and provides additional information about the dependency itself.
+   * @param options The options for describing the elements and the dependency details.
+   * @returns The description of the dependency between the elements.
+   */
+  describeDependency(options) {
+    return this._descriptors.describeDependency(options);
+  }
   /**
    * Determines if an element matches a given selector.
    * @param filePath The file path of the element
@@ -2011,7 +2140,7 @@ var Matcher = class {
    * @param options Extra matcher options
    * @returns True if the element matches the selector, false otherwise
    */
-  _isElementMatch(filePath, selector, options) {
+  isElementMatch(filePath, selector, options) {
     const description = this._descriptors.describeElement(filePath);
     return this._elementsMatcher.isElementMatch(description, selector, options);
   }
@@ -2022,7 +2151,7 @@ var Matcher = class {
    * @param options Extra matcher options
    * @returns True if the dependency matches the selector, false otherwise
    */
-  _isDependencyMatch(dependencyData, selector, options) {
+  isDependencyMatch(dependencyData, selector, options) {
     const description = this._descriptors.describeDependency(dependencyData);
     return this._dependenciesMatcher.isDependencyMatch(
       description,
@@ -2030,20 +2159,6 @@ var Matcher = class {
       options
     );
   }
-  isMatch(descriptorOptions, selector, options) {
-    if (isString(descriptorOptions)) {
-      return this._isElementMatch(
-        descriptorOptions,
-        selector,
-        options
-      );
-    }
-    return this._isDependencyMatch(
-      descriptorOptions,
-      selector,
-      options
-    );
-  }
   /**
    * Determines the selector matching for an element.
    * @param filePath The file path of the element
@@ -2051,7 +2166,7 @@ var Matcher = class {
    * @param options Extra options for matching
    * @returns The matching selector data or null if no match is found
    */
-  _getElementSelectorMatching(filePath, selector, options) {
+  getElementSelectorMatching(filePath, selector, options) {
     const description = this._descriptors.describeElement(filePath);
     return this._elementsMatcher.getSelectorMatching(
       description,
@@ -2066,7 +2181,7 @@ var Matcher = class {
    * @param options Extra options for matching
    * @returns The matching dependency result or null if no match is found
    */
-  _getDependencySelectorMatching(dependencyData, selector, options) {
+  getDependencySelectorMatching(dependencyData, selector, options) {
     const description = this._descriptors.describeDependency(dependencyData);
     return this._dependenciesMatcher.getSelectorsMatching(
       description,
@@ -2074,66 +2189,44 @@ var Matcher = class {
       options
     );
   }
-  getSelectorMatching(descriptorOptions, selector, options) {
-    if (isString(descriptorOptions)) {
-      return this._getElementSelectorMatching(
-        descriptorOptions,
+  /**
+   * Returns the selectors matching result for the given element or dependency description.
+   * @param description The element or dependency  description to check.
+   * @param selector The selector to check against.
+   * @param options Extra options for matching, such as templates data, etc.
+   * @returns The selectors matching result for the given description, and whether it matches or not.
+   */
+  getDependencySelectorMatchingDescription(description, selector, options) {
+    if (isDependencySelector(selector) && isDependencyDescription(description)) {
+      return this._dependenciesMatcher.getSelectorsMatching(
+        description,
         selector,
         options
       );
     }
-    return this._getDependencySelectorMatching(
-      descriptorOptions,
-      selector,
-      options
+    throw new Error(
+      "Invalid arguments: Please provide a valid description and selector"
     );
   }
-  getSelectorMatchingDescription(description, selector, options) {
+  /**
+   * Returns the first element selector matching result for the given element description.
+   * @param description The element description to check.
+   * @param selector The selector to check against.
+   * @param options Extra options for matching, such as templates data, etc.
+   * @returns The first matching selector result for the given description, or null if no match is found.
+   */
+  getElementSelectorMatchingDescription(description, selector, options) {
     if (isElementsSelector(selector) && isElementDescription(description)) {
       return this._elementsMatcher.getSelectorMatching(
         description,
         selector,
         options
       );
-    } else if (isDependencySelector(selector) && isDependencyDescription(description)) {
-      return this._dependenciesMatcher.getSelectorsMatching(
-        description,
-        selector,
-        options
-      );
     }
     throw new Error(
       "Invalid arguments: Please provide a valid description and selector"
     );
   }
-  /**
-   * Describes an element given its file path.
-   * @param filePath The path of the file to describe.
-   * @returns The description of the element.
-   */
-  describeElement(filePath) {
-    return this._descriptors.describeElement(filePath);
-  }
-  /**
-   * Describes a dependency element given its dependency source and file path.
-   * @param dependencySource The source of the dependency.
-   * @param filePath The path of the file being the dependency, if known.
-   * @returns The description of the dependency element.
-   */
-  describeDependencyElement(dependencySource, filePath) {
-    return this._descriptors.describeDependencyElement(
-      dependencySource,
-      filePath
-    );
-  }
-  /**
-   * Describes elements in a dependency relationship, and provides additional information about the dependency itself.
-   * @param options The options for describing the elements and the dependency details.
-   * @returns The description of the dependency between the elements.
-   */
-  describeDependency(options) {
-    return this._descriptors.describeDependency(options);
-  }
   /**
    * Clears all caches.
    */
@@ -2289,7 +2382,7 @@ var MatchersCache = class extends CacheManager {
     config,
     elementDescriptors
   }) {
-    const configHash = `${config.legacyTemplates}|${config.includePaths}|${config.ignorePaths}|${config.cache}`;
+    const configHash = `${config.legacyTemplates}|${config.includePaths}|${config.ignorePaths}|${config.cache}|${config.rootPath}|${config.flagAsExternal.inNodeModules}|${config.flagAsExternal.unresolvableAlias}|${config.flagAsExternal.outsideRootPath}|${config.flagAsExternal.customSourcePatterns.join(",")}`;
     const elementDescriptorsHash = elementDescriptors.map(
       (descriptor) => `${descriptor.type}|${descriptor.category}|${descriptor.pattern}|${descriptor.basePattern}|${descriptor.mode}|${descriptor.capture}|${descriptor.baseCapture}`
     ).join(",");