lint-suite 2.0.2 → 2.1.1

package/stylelint.js

@@ -1,938 +1,13 @@
 // packages/lint-suite/src/stylelint.ts
+import { fileURLToPath } from "node:url";
+import noUnusedClasses from "@lint-suite/stylelint-no-unused-classes";
 import stylelintScss from "stylelint-scss";
 import bemPattern from "stylelint-selector-bem-pattern";
-
-// packages/lint-suite/src/lib/rules/no-unused-classes/no-unused-classes.ts
-import stylelint from "stylelint";
-
-// packages/lint-suite/src/lib/rules/no-unused-classes/styles/stylesheet-components.ts
-import { existsSync, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
-import { dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
-
-// packages/lint-suite/src/lib/rules/no-unused-classes/styles/linked-templates.ts
-import { readdirSync } from "node:fs";
-import { dirname as dirname2, join as join2, resolve } from "node:path";
-
-// packages/lint-suite/src/lib/rules/file-cache.ts
-import {
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  statSync,
-  writeFileSync
-} from "node:fs";
-import { dirname, join } from "node:path";
-var CACHE_FORMAT_VERSION = 1;
-var caches = /* @__PURE__ */ new Set();
-var isFlushRegistered = false;
-var cacheDirectory = () => {
-  const { LINT_SUITE_CACHE, LINT_SUITE_CACHE_DIR } = process.env;
-  const isDisabled = LINT_SUITE_CACHE === "0";
-  if (isDisabled) return null;
-  if (LINT_SUITE_CACHE_DIR) return LINT_SUITE_CACHE_DIR;
-  return join(process.cwd(), "node_modules", ".cache", "lint-suite");
+var resolveConfig = (specifier) => {
+  const url = import.meta.resolve(specifier);
+  return fileURLToPath(url);
 };
-var cacheFile = (name) => {
-  const directory = cacheDirectory();
-  if (directory === null) return null;
-  return join(directory, `${name}.v${CACHE_FORMAT_VERSION}.json`);
-};
-var isCachedFile = (value) => {
-  const isObject = typeof value === "object" && value !== null;
-  if (!isObject) return false;
-  const hasVersion = "version" in value && typeof value.version === "string";
-  return hasVersion && "value" in value;
-};
-var storedEntries = (text) => {
-  const entries = /* @__PURE__ */ new Map();
-  const parsed = JSON.parse(text);
-  const isRecord = typeof parsed === "object" && parsed !== null;
-  if (!isRecord) return entries;
-  for (const [path, entry] of Object.entries(parsed)) {
-    if (isCachedFile(entry)) entries.set(path, entry);
-  }
-  return entries;
-};
-var load = (cache2) => {
-  cache2.loaded = true;
-  const file = cacheFile(cache2.name);
-  if (file === null) return;
-  try {
-    const stored = storedEntries(readFileSync(file, "utf8"));
-    for (const [path, entry] of stored) cache2.entries.set(path, entry);
-  } catch {
-    return;
-  }
-};
-var write = (cache2) => {
-  const file = cacheFile(cache2.name);
-  if (file === null) return;
-  try {
-    mkdirSync(dirname(file), { recursive: true });
-    const temporary = `${file}.${process.pid}.tmp`;
-    const stored = Object.fromEntries(cache2.entries);
-    writeFileSync(temporary, JSON.stringify(stored));
-    renameSync(temporary, file);
-  } catch {
-    return;
-  }
-};
-var flushFileCaches = () => {
-  for (const cache2 of caches) {
-    if (!cache2.dirty) continue;
-    write(cache2);
-    cache2.dirty = false;
-  }
-};
-var registerFlush = () => {
-  if (isFlushRegistered) return;
-  isFlushRegistered = true;
-  process.once("exit", flushFileCaches);
-};
-var createFileCache = (name) => {
-  const cache2 = {
-    name,
-    entries: /* @__PURE__ */ new Map(),
-    loaded: false,
-    dirty: false
-  };
-  caches.add(cache2);
-  registerFlush();
-  return cache2;
-};
-var readCached = (cache2, path, parse) => {
-  if (!cache2.loaded) load(cache2);
-  try {
-    const stats = statSync(path, { bigint: true });
-    const version = `${stats.mtimeNs}:${stats.size}`;
-    const cached = cache2.entries.get(path);
-    if (cached?.version === version) return cached.value;
-    const value = parse(readFileSync(path, "utf8"), path);
-    const fresh = { value, version };
-    cache2.entries.set(path, fresh);
-    cache2.dirty = true;
-    return value;
-  } catch {
-    return null;
-  }
-};
-
-// packages/lint-suite/src/lib/rules/utils/template-links.util.ts
-var LINK_TAG = /<link\b[^>]*>/giu;
-var STYLESHEET_REL = /\brel\s*=\s*["']stylesheet["']/iu;
-var HREF = /\bhref\s*=\s*["']([^"']*)["']/iu;
-var UNRESOLVABLE = /^(?:\/|[^:/?#]+:)/u;
-var hrefOf = (tag) => {
-  const isStylesheet = STYLESHEET_REL.test(tag);
-  if (!isStylesheet) return null;
-  const href = HREF.exec(tag)?.[1] ?? "";
-  const isUnresolvable = UNRESOLVABLE.test(href);
-  const isLocal = href.length > 0 && !isUnresolvable;
-  return isLocal ? href : null;
-};
-var linkedStylesheetHrefs = (template) => {
-  const tags = template.match(LINK_TAG) ?? [];
-  return tags.map(hrefOf).filter((href) => href !== null);
-};
-
-// packages/lint-suite/src/lib/rules/no-unused-classes/styles/linked-templates.ts
-var TEMPLATE_EXTENSION = /\.html$/iu;
-var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
-var links = createFileCache("template-links");
-var linkIndex = null;
-var templateLinks = (templatePath) => {
-  return readCached(links, templatePath, linkedStylesheetHrefs) ?? [];
-};
-var isWalkable = (name) => {
-  const isDotfile = name.startsWith(".");
-  if (isDotfile) return false;
-  return !SKIPPED_DIRECTORIES.has(name);
-};
-var walkTemplates = (root) => {
-  const found = [];
-  const pending = [root];
-  while (pending.length > 0) {
-    const directory = pending.pop();
-    if (directory === void 0) break;
-    for (const entry of readdirSync(directory, { withFileTypes: true })) {
-      const path = join2(directory, entry.name);
-      const isDirectory = entry.isDirectory();
-      if (isDirectory) {
-        const canWalk = isWalkable(entry.name);
-        if (canWalk) pending.push(path);
-        continue;
-      }
-      const isTemplate = TEMPLATE_EXTENSION.test(entry.name);
-      if (isTemplate) found.push(path);
-    }
-  }
-  return found;
-};
-var templatesUnder = (root) => {
-  try {
-    return walkTemplates(root);
-  } catch {
-    return [];
-  }
-};
-var templatesByStylesheet = (root) => {
-  const byStylesheet = /* @__PURE__ */ new Map();
-  for (const template of templatesUnder(root)) {
-    const directory = dirname2(template);
-    for (const href of templateLinks(template)) {
-      const stylesheet = resolve(directory, href);
-      const linked = byStylesheet.get(stylesheet) ?? [];
-      linked.push(template);
-      byStylesheet.set(stylesheet, linked);
-    }
-  }
-  return byStylesheet;
-};
-var currentLinkIndex = () => {
-  const now = performance.now();
-  const cached = linkIndex;
-  const isFresh = cached !== null && now - cached.builtAt < cached.buildDuration * 100;
-  if (isFresh) return cached;
-  const templates2 = templatesByStylesheet(process.cwd());
-  const fresh = {
-    builtAt: now,
-    buildDuration: performance.now() - now,
-    templates: templates2
-  };
-  linkIndex = fresh;
-  return fresh;
-};
-var linkedTemplates = (stylesheetPath) => {
-  return currentLinkIndex().templates.get(stylesheetPath) ?? [];
-};
-
-// packages/lint-suite/src/lib/rules/component-metadata.ts
-import {
-  ScriptTarget,
-  canHaveDecorators,
-  createSourceFile,
-  forEachChild,
-  getDecorators,
-  isArrayLiteralExpression,
-  isCallExpression,
-  isIdentifier,
-  isObjectLiteralExpression,
-  isPropertyAssignment,
-  isStringLiteralLike
-} from "typescript";
-var COMPONENT_MARKER = "@Component";
-var cache = createFileCache("component-metadata");
-var componentArgument = (decorator) => {
-  const { expression } = decorator;
-  if (!isCallExpression(expression)) return null;
-  if (!isIdentifier(expression.expression)) return null;
-  const isComponent = expression.expression.text === "Component";
-  if (!isComponent) return null;
-  const [argument] = expression.arguments;
-  if (argument === void 0) return null;
-  if (!isObjectLiteralExpression(argument)) return null;
-  return argument;
-};
-var decoratedMetadata = (node) => {
-  if (!canHaveDecorators(node)) return null;
-  const decorators = getDecorators(node) ?? [];
-  for (const decorator of decorators) {
-    const metadata = componentArgument(decorator);
-    if (metadata !== null) return metadata;
-  }
-  return null;
-};
-var literalText = (node) => {
-  if (!isStringLiteralLike(node)) return null;
-  return node.text;
-};
-var literalTexts = (node) => {
-  const single = literalText(node);
-  if (single !== null) return [single];
-  if (!isArrayLiteralExpression(node)) return [];
-  const texts = [];
-  for (const element of node.elements) {
-    const text = literalText(element);
-    if (text !== null) texts.push(text);
-  }
-  return texts;
-};
-var metadataValue = (metadata, name) => {
-  for (const property of metadata.properties) {
-    if (!isPropertyAssignment(property)) continue;
-    if (!isIdentifier(property.name)) continue;
-    const isMatch = property.name.text === name;
-    if (isMatch) return property.initializer;
-  }
-  return null;
-};
-var metadataTexts = (metadata, name) => {
-  const value = metadataValue(metadata, name);
-  if (value === null) return [];
-  return literalTexts(value);
-};
-var toDescriptor = (metadata) => {
-  const [templateUrl] = metadataTexts(metadata, "templateUrl");
-  const [template] = metadataTexts(metadata, "template");
-  const styleUrl = metadataTexts(metadata, "styleUrl");
-  const listedStyleUrls = metadataTexts(metadata, "styleUrls");
-  const styleUrls = [...styleUrl, ...listedStyleUrls];
-  const styles = metadataTexts(metadata, "styles");
-  const descriptor = {
-    templateUrl: templateUrl ?? null,
-    template: template ?? null,
-    styleUrls,
-    styles
-  };
-  return descriptor;
-};
-var parseComponentMetadata = (text, path) => {
-  const found = [];
-  const hasComponent = text.includes(COMPONENT_MARKER);
-  if (!hasComponent) return found;
-  const visit = (node) => {
-    const metadata = decoratedMetadata(node);
-    if (metadata !== null) found.push(toDescriptor(metadata));
-    forEachChild(node, visit);
-  };
-  const source = createSourceFile(path, text, ScriptTarget.Latest, true);
-  forEachChild(source, visit);
-  return found;
-};
-var componentMetadata = (path) => {
-  return readCached(cache, path, parseComponentMetadata) ?? [];
-};
-
-// packages/lint-suite/src/lib/rules/no-unused-classes/styles/stylesheet-components.ts
-var MODULE_EXTENSION = /\.ts$/iu;
-var STYLE_EXTENSION = /\.(?:scss|sass|css)$/iu;
-var UNKNOWN_TEMPLATE = { kind: "unknown" };
-var listings = /* @__PURE__ */ new Map();
-var directoryListing = (directory) => {
-  const stats = statSync2(directory, { bigint: true });
-  const version = `${stats.mtimeNs}`;
-  const cached = listings.get(directory);
-  if (cached?.version === version) return cached.files;
-  const files = readdirSync2(directory);
-  const fresh = { files, version };
-  listings.set(directory, fresh);
-  return files;
-};
-var declaredStylesheets = (descriptor, directory) => {
-  const resolveUrl = (url) => resolve2(directory, url);
-  return descriptor.styleUrls.map(resolveUrl);
-};
-var fileTemplate = (descriptor, directory) => {
-  if (descriptor.templateUrl === null) return null;
-  const path = resolve2(directory, descriptor.templateUrl);
-  const isPresent = existsSync(path);
-  if (!isPresent) return null;
-  const source = { kind: "file", path };
-  return source;
-};
-var inlineTemplate = (descriptor, componentPath) => {
-  if (descriptor.template === null) return null;
-  const source = {
-    kind: "inline",
-    source: descriptor.template,
-    path: componentPath
-  };
-  return source;
-};
-var componentTemplate = (descriptor, componentPath) => {
-  const directory = dirname3(componentPath);
-  const file = fileTemplate(descriptor, directory);
-  if (file !== null) return file;
-  const inline = inlineTemplate(descriptor, componentPath);
-  return inline ?? UNKNOWN_TEMPLATE;
-};
-var matchedTemplates = (componentPath, stylesheetPath) => {
-  const directory = dirname3(componentPath);
-  const sources = [];
-  for (const descriptor of componentMetadata(componentPath)) {
-    const declared = declaredStylesheets(descriptor, directory);
-    const isMatch = declared.includes(stylesheetPath);
-    if (!isMatch) continue;
-    sources.push(componentTemplate(descriptor, componentPath));
-  }
-  return sources;
-};
-var directoryFiles = (directory, extension) => {
-  try {
-    return directoryListing(directory).filter((file) => extension.test(file));
-  } catch {
-    return [];
-  }
-};
-var fallbackTemplates = (stylesheetPath) => {
-  const sibling = stylesheetPath.replace(STYLE_EXTENSION, ".html");
-  const paths = /* @__PURE__ */ new Set();
-  const hasSibling = existsSync(sibling);
-  if (hasSibling) paths.add(sibling);
-  for (const path of linkedTemplates(stylesheetPath)) paths.add(path);
-  const toSource = (path) => {
-    const source = { kind: "file", path };
-    return source;
-  };
-  const pathList = [...paths];
-  return pathList.map(toSource);
-};
-var stylesheetTemplates = (stylesheetPath) => {
-  const resolved = resolve2(stylesheetPath);
-  const directory = dirname3(resolved);
-  const sources = [];
-  for (const file of directoryFiles(directory, MODULE_EXTENSION)) {
-    const componentPath = join3(directory, file);
-    const matched = matchedTemplates(componentPath, resolved);
-    sources.push(...matched);
-  }
-  if (sources.length > 0) return sources;
-  return fallbackTemplates(resolved);
-};
-
-// packages/lint-suite/src/lib/rules/no-unused-classes/template/template-usage.ts
-import {
-  ASTWithSource,
-  TmplAstRecursiveVisitor,
-  parseTemplate,
-  tmplAstVisitAll
-} from "@angular/compiler";
-
-// packages/lint-suite/src/lib/rules/selector-classes.ts
-import selectorParser from "postcss-selector-parser";
-var INTERPOLATION_TOKEN = "zzinterpzz";
-var PARENT_TOKEN = "zzparentzz";
-var UNKNOWN_PARENT_SELECTOR = `.${PARENT_TOKEN}`;
-var UNKNOWN_PARTS = new RegExp(
-  `${INTERPOLATION_TOKEN}|${PARENT_TOKEN}`,
-  "gu"
-);
-var INTERPOLATION = /#\{[^}]*\}/gu;
-var DEEP_COMBINATORS = /* @__PURE__ */ new Set(["/deep/", ">>>"]);
-var HOST_PSEUDOS = /* @__PURE__ */ new Set([":host", ":host-context"]);
-var NG_DEEP_PSEUDO = "::ng-deep";
-var REGEXP_META = /[.*+?^${}()|[\]\\]/gu;
-var escapeRegExp = (part) => {
-  return part.replaceAll(REGEXP_META, "\\$&");
-};
-var classNamePattern = (value) => {
-  const literals = value.split(UNKNOWN_PARTS).map(escapeRegExp);
-  const joined = literals.join(".*");
-  return `^${joined}$`;
-};
-var withoutParent = (selector) => {
-  return selector.replaceAll("&", UNKNOWN_PARENT_SELECTOR);
-};
-var withParent = (selector, parent) => {
-  const hasNesting = selector.includes("&");
-  if (hasNesting) return selector.replaceAll("&", parent);
-  return `${parent} ${selector}`;
-};
-var resolveSelectors = (selectors, parents) => {
-  const hasParents = parents.length > 0;
-  if (!hasParents) return selectors.map(withoutParent);
-  const resolved = [];
-  for (const parent of parents) {
-    for (const selector of selectors) {
-      resolved.push(withParent(selector, parent));
-    }
-  }
-  return resolved;
-};
-var isBoundaryNode = (node) => {
-  if (node.type === "combinator") return DEEP_COMBINATORS.has(node.value);
-  if (node.type !== "pseudo") return false;
-  return node.value === NG_DEEP_PSEUDO;
-};
-var addTemplateClass = (value, names) => {
-  const hasInterpolation = value.includes(INTERPOLATION_TOKEN);
-  const hasUnknownParent = value.includes(PARENT_TOKEN);
-  const isDynamic = hasInterpolation || hasUnknownParent;
-  if (isDynamic) return;
-  names.push(value);
-};
-var collectTemplateClasses = (nodes, names) => {
-  for (const node of nodes) {
-    const isBoundary = isBoundaryNode(node);
-    if (isBoundary) return true;
-    if (node.type === "class") {
-      addTemplateClass(node.value, names);
-      continue;
-    }
-    if (node.type !== "pseudo") continue;
-    const isHost = HOST_PSEUDOS.has(node.value);
-    if (isHost) continue;
-    for (const argument of node.nodes) {
-      const isStopped = collectTemplateClasses(argument.nodes, names);
-      if (isStopped) return true;
-    }
-  }
-  return false;
-};
-var selectorTemplateClasses = (selector) => {
-  const names = [];
-  const normalized = selector.replaceAll(INTERPOLATION, INTERPOLATION_TOKEN);
-  try {
-    const root = selectorParser().astSync(normalized);
-    for (const each of root.nodes) collectTemplateClasses(each.nodes, names);
-  } catch {
-    return [];
-  }
-  const uniqueNames = new Set(names);
-  return [...uniqueNames];
-};
-var classMatcher = (exact, patterns) => {
-  const matches = (name) => {
-    const isExact = exact.has(name);
-    if (isExact) return true;
-    return patterns.some((pattern) => pattern.test(name));
-  };
-  return matches;
-};
-
-// packages/lint-suite/src/lib/rules/utils/class-expression-literals.util.ts
-import {
-  Conditional,
-  Interpolation,
-  Lexer,
-  LiteralArray,
-  LiteralMap,
-  LiteralPrimitive,
-  ParseLocation,
-  ParseSourceFile,
-  ParseSourceSpan,
-  Parser
-} from "@angular/compiler";
-var WHITESPACE = /\s+/u;
-var EXPRESSION_FILE = "class-expression";
-var INTERPOLATION_TOKEN2 = "zzinterpzz";
-var parser = new Parser(new Lexer());
-var spanOf = (source) => {
-  const file = new ParseSourceFile(source, EXPRESSION_FILE);
-  const start = new ParseLocation(file, 0, 0, 0);
-  const span = new ParseSourceSpan(start, start.moveBy(source.length));
-  return span;
-};
-var astOf = (parsed) => {
-  const hasErrors = parsed.errors.length > 0;
-  if (hasErrors) return null;
-  return parsed.ast;
-};
-var parseClassExpression = (source) => {
-  try {
-    const span = spanOf(source);
-    const interpolation = parser.parseInterpolation(source, span, 0, null);
-    if (interpolation) return astOf(interpolation);
-    const binding = parser.parseBinding(source, span, 0);
-    return astOf(binding);
-  } catch {
-    return null;
-  }
-};
-var addNames = (value, names) => {
-  for (const token of value.split(WHITESPACE)) {
-    if (token) names.push(token);
-  }
-};
-var addPrimitive = (ast, names) => {
-  if (typeof ast.value === "string") addNames(ast.value, names);
-};
-var addMapKeys = (ast, names) => {
-  for (const key of ast.keys) {
-    if (key.kind !== "spread") addNames(key.key, names);
-  }
-};
-var addInterpolation = (ast, names) => {
-  for (const text of ast.strings) addNames(text, names);
-};
-var collect = (ast, names) => {
-  if (ast instanceof LiteralPrimitive) {
-    addPrimitive(ast, names);
-    return;
-  }
-  if (ast instanceof LiteralMap) {
-    addMapKeys(ast, names);
-    return;
-  }
-  if (ast instanceof Interpolation) {
-    addInterpolation(ast, names);
-    return;
-  }
-  if (ast instanceof LiteralArray) {
-    for (const expression of ast.expressions) collect(expression, names);
-    return;
-  }
-  if (ast instanceof Conditional) {
-    collect(ast.trueExp, names);
-    collect(ast.falseExp, names);
-  }
-};
-var classExpressionLiterals = (source) => {
-  const ast = parseClassExpression(source);
-  if (ast === null) return [];
-  const names = [];
-  collect(ast, names);
-  const uniqueNames = new Set(names);
-  return [...uniqueNames];
-};
-var isSpreadKey = (key) => key.kind === "spread";
-var isDynamicAst = (ast) => {
-  if (ast instanceof LiteralPrimitive) return false;
-  if (ast instanceof LiteralMap) return ast.keys.some(isSpreadKey);
-  if (ast instanceof LiteralArray) return ast.expressions.some(isDynamicAst);
-  if (ast instanceof Conditional) {
-    const isTrueDynamic = isDynamicAst(ast.trueExp);
-    const isFalseDynamic = isDynamicAst(ast.falseExp);
-    return isTrueDynamic || isFalseDynamic;
-  }
-  return true;
-};
-var isNamedToken = (token) => token !== INTERPOLATION_TOKEN2;
-var isPatternToken = (token) => {
-  return token.includes(INTERPOLATION_TOKEN2);
-};
-var isPlainToken = (token) => !isPatternToken(token);
-var interpolationUsage = (ast) => {
-  const joined = ast.strings.join(INTERPOLATION_TOKEN2);
-  const tokens = joined.split(WHITESPACE).filter(Boolean);
-  const named = tokens.filter(isNamedToken);
-  const patterns = named.filter(isPatternToken).map(classNamePattern);
-  const names = named.filter(isPlainToken);
-  const uniqueNames = new Set(names);
-  const uniquePatterns = new Set(patterns);
-  const usage = {
-    names: [...uniqueNames],
-    patterns: [...uniquePatterns],
-    isDynamic: named.length < tokens.length
-  };
-  return usage;
-};
-var UNKNOWN_USAGE = {
-  names: [],
-  patterns: [],
-  isDynamic: true
-};
-var classExpressionUsage = (source) => {
-  const ast = parseClassExpression(source);
-  if (ast === null) return UNKNOWN_USAGE;
-  if (ast instanceof Interpolation) return interpolationUsage(ast);
-  const names = [];
-  collect(ast, names);
-  const isDynamic = isDynamicAst(ast);
-  const uniqueNames = new Set(names);
-  const usage = {
-    names: [...uniqueNames],
-    patterns: [],
-    isDynamic
-  };
-  return usage;
-};
-
-// packages/lint-suite/src/lib/rules/utils/template-classes.util.ts
-import { ParseSourceSpan as ParseSourceSpan2 } from "@angular/compiler";
-var CLASS_ATTRIBUTES = [
-  "class",
-  "routerLinkActive",
-  "animate.enter",
-  "animate.leave"
-];
-var CLASS_BINDING_PREFIX = "class.";
-var TOKEN = /\S+/gu;
-var expressionSource = (value) => {
-  if (!("source" in value)) return null;
-  const { source } = value;
-  if (typeof source !== "string") return null;
-  return source;
-};
-var staticClasses = (attribute) => {
-  const classes = [];
-  const valueSpan = attribute.valueSpan ?? attribute.sourceSpan;
-  for (const token of attribute.value.matchAll(TOKEN)) {
-    const start = valueSpan.start.moveBy(token.index);
-    const end = valueSpan.start.moveBy(token.index + token[0].length);
-    const span = new ParseSourceSpan2(start, end);
-    const templateClass = { name: token[0], span };
-    classes.push(templateClass);
-  }
-  return classes;
-};
-var boundClassName = (input) => {
-  const { details } = input.keySpan;
-  if (details === null) return null;
-  const isClassBinding = details.startsWith(CLASS_BINDING_PREFIX);
-  if (!isClassBinding) return null;
-  return input.name;
-};
-var isClassExpression = (input) => {
-  const isClassName = CLASS_ATTRIBUTES.includes(input.name);
-  if (!isClassName) return false;
-  const { details } = input.keySpan;
-  if (details === null) return true;
-  return details === input.name;
-};
-var expressionClasses = (input) => {
-  const source = expressionSource(input.value);
-  if (source === null) return [];
-  const names = classExpressionLiterals(source);
-  const templateClassOf = (name) => {
-    const templateClass = { name, span: input.sourceSpan };
-    return templateClass;
-  };
-  return names.map(templateClassOf);
-};
-var inputClasses = (input) => {
-  const bound = boundClassName(input);
-  if (bound !== null) {
-    const templateClass = { name: bound, span: input.keySpan };
-    return [templateClass];
-  }
-  const isExpression = isClassExpression(input);
-  if (!isExpression) return [];
-  return expressionClasses(input);
-};
-var templateClasses = (node) => {
-  const classes = [];
-  for (const attribute of node.attributes) {
-    const isClassName = CLASS_ATTRIBUTES.includes(attribute.name);
-    if (isClassName) {
-      const found = staticClasses(attribute);
-      classes.push(...found);
-    }
-  }
-  for (const input of node.inputs) {
-    const found = inputClasses(input);
-    classes.push(...found);
-  }
-  return classes;
-};
-
-// packages/lint-suite/src/lib/rules/utils/to-regexp.util.ts
-var toRegExp = (pattern) => new RegExp(pattern, "u");
-
-// packages/lint-suite/src/lib/rules/no-unused-classes/template/template-usage.ts
-var NG_CLASS_ATTRIBUTE = "ngClass";
-var matchesNone = () => false;
-var UNKNOWN_USAGE2 = {
-  has: matchesNone,
-  isDynamic: true,
-  size: 0
-};
-var templates = createFileCache("template-usage");
-var expressionSource2 = (value) => {
-  const isWithSource = value instanceof ASTWithSource;
-  if (!isWithSource) return null;
-  return value.source;
-};
-var isClassInput = (input) => {
-  const isNgClass = input.name === NG_CLASS_ATTRIBUTE;
-  if (isNgClass) return true;
-  return isClassExpression(input);
-};
-var ClassUsageVisitor = class extends TmplAstRecursiveVisitor {
-  names = /* @__PURE__ */ new Set();
-  patterns = /* @__PURE__ */ new Set();
-  isDynamic = false;
-  visitElement(element) {
-    this.collect(element);
-    super.visitElement(element);
-  }
-  visitTemplate(template) {
-    this.collect(template);
-    super.visitTemplate(template);
-  }
-  visitComponent(component) {
-    this.collect(component);
-    super.visitComponent(component);
-  }
-  collect(node) {
-    for (const { name } of templateClasses(node)) this.names.add(name);
-    for (const input of node.inputs) this.collectInput(input);
-  }
-  collectInput(input) {
-    const isClass = isClassInput(input);
-    if (!isClass) return;
-    const source = expressionSource2(input.value);
-    if (source === null) {
-      this.isDynamic = true;
-      return;
-    }
-    const usage = classExpressionUsage(source);
-    for (const name of usage.names) this.names.add(name);
-    for (const pattern of usage.patterns) this.patterns.add(pattern);
-    if (usage.isDynamic) this.isDynamic = true;
-  }
-};
-var parseUsage = (text, path) => {
-  const parsed = parseTemplate(text, path);
-  if (parsed.errors !== null) return null;
-  const visitor = new ClassUsageVisitor();
-  tmplAstVisitAll(visitor, parsed.nodes);
-  const names = [...visitor.names];
-  const patterns = [...visitor.patterns];
-  const entry = { names, patterns, isDynamic: visitor.isDynamic };
-  return entry;
-};
-var sourceUsage = (source) => {
-  if (source.kind === "unknown") return null;
-  if (source.kind === "inline") return parseUsage(source.source, source.path);
-  return readCached(templates, source.path, parseUsage) ?? null;
-};
-var templateUsage = (sources) => {
-  const names = /* @__PURE__ */ new Set();
-  const patterns = /* @__PURE__ */ new Set();
-  for (const source of sources) {
-    const entry = sourceUsage(source);
-    if (entry === null) return UNKNOWN_USAGE2;
-    if (entry.isDynamic) return UNKNOWN_USAGE2;
-    for (const name of entry.names) names.add(name);
-    for (const pattern of entry.patterns) patterns.add(pattern);
-  }
-  const patternList = [...patterns];
-  const compiled = patternList.map(toRegExp);
-  const has = classMatcher(names, compiled);
-  const size = names.size;
-  const usage = { has, isDynamic: false, size };
-  return usage;
-};
-
-// packages/lint-suite/src/lib/rules/utils/resolved-rules.util.ts
-var walkContainer = (container, parents, visit) => {
-  for (const node of container.nodes ?? []) {
-    if (node.type === "rule") {
-      const resolved = resolveSelectors(node.selectors, parents);
-      visit(node, resolved, parents);
-      walkContainer(node, resolved, visit);
-      continue;
-    }
-    if (node.type !== "atrule") continue;
-    walkContainer(node, parents, visit);
-  }
-};
-var walkResolvedRules = (root, visit) => {
-  walkContainer(root, [], visit);
-};
-
-// packages/lint-suite/src/lib/rules/no-unused-classes/no-unused-classes.ts
-var { createPlugin, utils } = stylelint;
-var DEFAULT_IGNORE_PATTERNS = ["^(js|qa|mat|cdk|mdc)-"];
-var ruleName = "lint-suite/no-unused-classes";
-var rejected = (name) => {
-  return `Unexpected class ".${name}" not used by any template of this stylesheet`;
-};
-var messages = utils.ruleMessages(ruleName, { rejected });
-var meta = {
-  url: "https://github.com/F0rty-Tw0/lint-suite#no-unused-classes"
-};
-var isString = (value) => typeof value === "string";
-var validate = (result, primary, secondary) => {
-  const primaryOptions = { actual: primary, possible: [true] };
-  const possible = { ignoreClassPatterns: [isString] };
-  const secondaryOptions = { actual: secondary, possible, optional: true };
-  return utils.validateOptions(
-    result,
-    ruleName,
-    primaryOptions,
-    secondaryOptions
-  );
-};
-var addNames2 = (selector, names) => {
-  for (const name of selectorTemplateClasses(selector)) names.add(name);
-};
-var extendedClasses = (root) => {
-  const names = /* @__PURE__ */ new Set();
-  const collect2 = (atRule) => addNames2(atRule.params, names);
-  root.walkAtRules("extend", collect2);
-  return names;
-};
-var isEmittingRule = (rule) => {
-  const isEmittingNode = (node) => {
-    return node.type === "decl" || node.type === "atrule";
-  };
-  const children = rule.nodes;
-  return children.some(isEmittingNode);
-};
-var emittedClasses = (root) => {
-  const names = /* @__PURE__ */ new Set();
-  const visit = (rule, resolved) => {
-    const isEmitting = isEmittingRule(rule);
-    if (!isEmitting) return;
-    for (const selector of resolved) addNames2(selector, names);
-  };
-  walkResolvedRules(root, visit);
-  return names;
-};
-var ruleClasses = (resolved, parents) => {
-  const inherited = /* @__PURE__ */ new Set();
-  for (const parent of parents) addNames2(parent, inherited);
-  const own = /* @__PURE__ */ new Set();
-  for (const selector of resolved) {
-    for (const name of selectorTemplateClasses(selector)) {
-      const isInherited = inherited.has(name);
-      if (isInherited) continue;
-      own.add(name);
-    }
-  }
-  return [...own];
-};
-var reportUnused = (context, rule, name) => {
-  const isEmitted = context.emitted.has(name);
-  if (!isEmitted) return;
-  const matchesIgnored = (pattern) => pattern.test(name);
-  const isIgnored = context.ignored.some(matchesIgnored);
-  if (isIgnored) return;
-  const isUsed = context.isUsed(name);
-  if (isUsed) return;
-  const isExtended = context.extended.has(name);
-  if (isExtended) return;
-  const message = messages.rejected(name);
-  const word = `.${name}`;
-  const problem = {
-    ruleName,
-    result: context.result,
-    node: rule,
-    message,
-    word
-  };
-  utils.report(problem);
-};
-var noUnusedClasses = (primary, secondary) => {
-  const walk = (root, result) => {
-    const isValid = validate(result, primary, secondary);
-    if (!isValid) return;
-    const file = root.source?.input.file;
-    if (file === void 0) return;
-    const templates2 = stylesheetTemplates(file);
-    if (templates2.length === 0) return;
-    const usage = templateUsage(templates2);
-    if (usage.isDynamic) return;
-    const patterns = secondary?.ignoreClassPatterns ?? DEFAULT_IGNORE_PATTERNS;
-    const ignored = patterns.map(toRegExp);
-    const extended = extendedClasses(root);
-    const emitted = emittedClasses(root);
-    const context = {
-      result,
-      ignored,
-      extended,
-      emitted,
-      isUsed: usage.has
-    };
-    const visit = (rule, resolved, parents) => {
-      for (const name of ruleClasses(resolved, parents)) {
-        reportUnused(context, rule, name);
-      }
-    };
-    walkResolvedRules(root, visit);
-  };
-  return walk;
-};
-noUnusedClasses.ruleName = ruleName;
-noUnusedClasses.messages = messages;
-noUnusedClasses.meta = meta;
-var plugin = createPlugin(ruleName, noUnusedClasses);
-var no_unused_classes_default = plugin;
-
-// packages/lint-suite/src/stylelint.ts
-var stylelint2 = {
+var stylelint = {
   // Stylelint resolves config for cwd when picking a formatter; without a
   // top-level `rules` an overrides-only config fails with "No rules found".
   rules: {},
@@ -940,11 +15,11 @@ var stylelint2 = {
     {
       files: ["**/*.scss", "**/*.css"],
       extends: [
-        "stylelint-config-standard",
-        "stylelint-config-standard-scss",
-        "stylelint-config-recess-order"
+        resolveConfig("stylelint-config-standard"),
+        resolveConfig("stylelint-config-standard-scss"),
+        resolveConfig("stylelint-config-recess-order")
       ],
-      plugins: [...stylelintScss, bemPattern, no_unused_classes_default],
+      plugins: [...stylelintScss, bemPattern, noUnusedClasses],
       rules: {
         "selector-class-pattern": "^(?:(?:o|c|u|t|s|is|has|_|js|qa)-)?[a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)*(?:__[a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)*)?(?:--[a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)*)?(?:\\[.+\\])?$",
         "plugin/selector-bem-pattern": {
@@ -962,6 +37,5 @@ var stylelint2 = {
   ]
 };
 export {
-  stylelint2 as stylelint
+  stylelint
 };
-//# sourceMappingURL=stylelint.js.map