@reteps/tree-sitter-htmlmustache 0.9.1 → 0.9.3

package/browser/out/core/configSchema.d.ts

@@ -34,6 +34,14 @@ export interface CustomRule {
     selector: string;
     message: string;
     severity?: RuleSeverity;
+    /**
+     * Optional glob patterns (relative to the config file) restricting which
+     * files this rule applies to. Applied as an additional filter on top of the
+     * top-level `include`/`exclude` — a rule only fires for files that both
+     * the top-level settings include AND the per-rule settings include.
+     */
+    include?: string[];
+    exclude?: string[];
 }
 export interface NoBreakDelimiter {
     start: string;

package/browser/out/core/configSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configSchema.d.ts","sourceRoot":"","sources":["../../../src/core/configSchema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAA2B,MAAM,qBAAqB,CAAC;AAWxF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,SAAS,GAAG,KAAK,CAAC;AAEvD,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpD;AAED,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG;IAAE,QAAQ,EAAE,YAAY,CAAA;CAAE,CAAC;AAClE,MAAM,MAAM,oBAAoB,CAAC,QAAQ,IAAI,YAAY,GAAG,CAAC;IAAE,QAAQ,EAAE,YAAY,CAAA;CAAE,GAAG,QAAQ,CAAC,CAAC;AAEpG,MAAM,WAAW,WAAW;IAC1B,uBAAuB,CAAC,EAAE,SAAS,CAAC;IACpC,0BAA0B,CAAC,EAAE,SAAS,CAAC;IACvC,4BAA4B,CAAC,EAAE,SAAS,CAAC;IACzC,sBAAsB,CAAC,EAAE,SAAS,CAAC;IACnC,mBAAmB,CAAC,EAAE,SAAS,CAAC;IAChC,iBAAiB,CAAC,EAAE,SAAS,CAAC;IAC9B,sBAAsB,CAAC,EAAE,SAAS,CAAC;IACnC,oBAAoB,CAAC,EAAE,SAAS,CAAC;IACjC,qBAAqB,CAAC,EAAE,oBAAoB,CAAC,4BAA4B,CAAC,CAAC;CAC5E;AAuCD,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,YAAY,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAC;IACvC,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CA2ChD;AAiCD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,kBAAkB,CAwF/D"}
+{"version":3,"file":"configSchema.d.ts","sourceRoot":"","sources":["../../../src/core/configSchema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAA2B,MAAM,qBAAqB,CAAC;AAWxF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,SAAS,GAAG,KAAK,CAAC;AAEvD,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpD;AAED,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG;IAAE,QAAQ,EAAE,YAAY,CAAA;CAAE,CAAC;AAClE,MAAM,MAAM,oBAAoB,CAAC,QAAQ,IAAI,YAAY,GAAG,CAAC;IAAE,QAAQ,EAAE,YAAY,CAAA;CAAE,GAAG,QAAQ,CAAC,CAAC;AAEpG,MAAM,WAAW,WAAW;IAC1B,uBAAuB,CAAC,EAAE,SAAS,CAAC;IACpC,0BAA0B,CAAC,EAAE,SAAS,CAAC;IACvC,4BAA4B,CAAC,EAAE,SAAS,CAAC;IACzC,sBAAsB,CAAC,EAAE,SAAS,CAAC;IACnC,mBAAmB,CAAC,EAAE,SAAS,CAAC;IAChC,iBAAiB,CAAC,EAAE,SAAS,CAAC;IAC9B,sBAAsB,CAAC,EAAE,SAAS,CAAC;IACnC,oBAAoB,CAAC,EAAE,SAAS,CAAC;IACjC,qBAAqB,CAAC,EAAE,oBAAoB,CAAC,4BAA4B,CAAC,CAAC;CAC5E;AAuCD,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAC;IACvC,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CA2ChD;AAiCD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,kBAAkB,CAgG/D"}

package/browser/out/core/customRuleFilter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Filter custom lint rules by per-rule `include` / `exclude` glob patterns.
+ *
+ * Patterns are matched against a path relative to the config file's directory.
+ * Path separators are normalized to forward slashes so cross-platform patterns
+ * like `questions/**` work regardless of host OS.
+ *
+ * Uses Node's `path.matchesGlob` (available since Node 22.5), so this module
+ * is Node-only — the browser entrypoint does not import it.
+ */
+import type { CustomRule } from './configSchema.js';
+export declare function ruleMatchesPath(rule: CustomRule, relPath: string): boolean;
+export declare function filterCustomRulesForPath(rules: CustomRule[] | undefined, relPath: string): CustomRule[] | undefined;
+//# sourceMappingURL=customRuleFilter.d.ts.map

package/browser/out/core/customRuleFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customRuleFilter.d.ts","sourceRoot":"","sources":["../../../src/core/customRuleFilter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAS1E;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,UAAU,EAAE,GAAG,SAAS,EAC/B,OAAO,EAAE,MAAM,GACd,UAAU,EAAE,GAAG,SAAS,CAG1B"}

package/browser/out/core/selectorMatcher.d.ts

@@ -24,7 +24,11 @@
  *     the outer compound), plus any other selector (including Mustache
  *     literals and type selectors) as a whole-selector check against the
  *     node itself. Example: `{{*}}:not({{internal.*}})` matches any
- *     interpolation whose path does not start with `internal.`.
+ *     interpolation whose path does not start with `internal.`. Multi-segment
+ *     selectors with combinators are supported and tested against the node's
+ *     ancestor/sibling context, matching `Element.matches` semantics — e.g.
+ *     `img:not(pl-overlay img)` matches any `img` that is not a descendant of
+ *     `pl-overlay`, and `td:not(thead td)` matches `td`s outside a `thead`.
  *   - `:root` — the tree-sitter fragment root (the whole document). Unlike
  *     browser CSS where `:root` matches `<html>`, this matches the parse-tree
  *     root so it works on partials/fragments too. Useful as a document-scoped

package/browser/out/core/selectorMatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selectorMatcher.d.ts","sourceRoot":"","sources":["../../../src/core/selectorMatcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAY3D,MAAM,MAAM,iBAAiB,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAEhE,MAAM,MAAM,WAAW,GACnB,MAAM,GACN,SAAS,GACT,UAAU,GACV,UAAU,GACV,KAAK,GACL,SAAS,GACT,SAAS,CAAC;AAEd,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,iBAAiB,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,cAAc,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG,OAAO,GAAG,kBAAkB,GAAG,iBAAiB,CAAC;AAEzF,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,aAAa,EAAE,cAAc,EAAE,CAAC;IAChC,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,gFAAgF;AAChF,MAAM,MAAM,cAAc,GAAG,OAAO,EAAE,EAAE,CAAC;AAQzC;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAuFrE;AAID,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CA2BhE;AA2pBD,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,WAAW,EACrB,QAAQ,EAAE,cAAc,EACxB,QAAQ,GAAE,WAAW,EAAO,EAC5B,eAAe,SAAI,GAClB,WAAW,EAAE,CAYf"}
+{"version":3,"file":"selectorMatcher.d.ts","sourceRoot":"","sources":["../../../src/core/selectorMatcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAY3D,MAAM,MAAM,iBAAiB,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAEhE,MAAM,MAAM,WAAW,GACnB,MAAM,GACN,SAAS,GACT,UAAU,GACV,UAAU,GACV,KAAK,GACL,SAAS,GACT,SAAS,CAAC;AAEd,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,iBAAiB,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,cAAc,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG,OAAO,GAAG,kBAAkB,GAAG,iBAAiB,CAAC;AAEzF,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,aAAa,EAAE,cAAc,EAAE,CAAC;IAChC,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,gFAAgF;AAChF,MAAM,MAAM,cAAc,GAAG,OAAO,EAAE,EAAE,CAAC;AAQzC;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAuFrE;AAID,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CA2BhE;AA2qBD,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,WAAW,EACrB,QAAQ,EAAE,cAAc,EACxB,QAAQ,GAAE,WAAW,EAAO,EAC5B,eAAe,SAAI,GAClB,WAAW,EAAE,CAYf"}

package/cli/out/main.js

@@ -784,6 +784,14 @@ function validateConfig(raw) {
       if (typeof e2.severity === "string" && VALID_RULE_SEVERITIES.has(e2.severity)) {
         rule.severity = e2.severity;
       }
+      if (Array.isArray(e2.include)) {
+        const items = e2.include.filter((s2) => typeof s2 === "string" && s2.length > 0);
+        if (items.length > 0) rule.include = items;
+      }
+      if (Array.isArray(e2.exclude)) {
+        const items = e2.exclude.filter((s2) => typeof s2 === "string" && s2.length > 0);
+        if (items.length > 0) rule.exclude = items;
+      }
       rules.push(rule);
     }
     if (rules.length > 0) config.customRules = rules;
@@ -815,7 +823,8 @@ function loadConfigFileForPath(filePath) {
   try {
     const text2 = fs.readFileSync(configPath, "utf-8");
     const raw = parseJsonc(text2);
-    return validateConfig(raw);
+    const config = validateConfig(raw);
+    return { config, configDir: path2.dirname(configPath) };
   } catch {
     return null;
   }
@@ -1916,9 +1925,9 @@ function preprocessMustacheLiterals(raw) {
       case "=":
         return null;
       default: {
-        const path5 = body.trim();
-        if (path5.length === 0) return null;
-        out += `:m-variable(${path5})`;
+        const path6 = body.trim();
+        if (path6.length === 0) return null;
+        out += `:m-variable(${path6})`;
         break;
       }
     }
@@ -2317,11 +2326,16 @@ function hasDescendantMatch(node, selector) {
   }
   return false;
 }
-function checkSelfNegations(node, negations, rootNode) {
+function checkSelfNegations(node, negations, rootNode, cursor) {
   for (const sel of negations) {
     for (const alt of sel) {
-      if (alt.length !== 1) continue;
-      if (nodeMatchesSegment(node, alt[0], rootNode)) return false;
+      if (alt.length === 0) continue;
+      const lastSegment = alt[alt.length - 1];
+      if (!nodeMatchesSegment(node, lastSegment, rootNode, cursor)) continue;
+      if (alt.length === 1) return false;
+      if (checkPrefix(cursor, alt, alt.length - 2, lastSegment.combinator, rootNode)) {
+        return false;
+      }
     }
   }
   return true;
@@ -2332,10 +2346,10 @@ function matchesName(actual, segment) {
   if (segment.pathRegex) return segment.pathRegex.test(actual);
   return actual === segment.name;
 }
-function nodeMatchesSegment(node, segment, rootNode) {
+function nodeMatchesSegment(node, segment, rootNode, cursor) {
   if (segment.rootOnly) {
     if (node !== rootNode) return false;
-    return checkDescendants(node, segment.descendantChecks) && checkSelfNegations(node, segment.selfNegations, rootNode);
+    return checkDescendants(node, segment.descendantChecks) && checkSelfNegations(node, segment.selfNegations, rootNode, cursor);
   }
   const baseMatches = (() => {
     switch (segment.kind) {
@@ -2374,7 +2388,7 @@ function nodeMatchesSegment(node, segment, rootNode) {
     }
   })();
   if (!baseMatches) return false;
-  return checkSelfNegations(node, segment.selfNegations, rootNode);
+  return checkSelfNegations(node, segment.selfNegations, rootNode, cursor);
 }
 function checkPrefix(cursor, segments, segIdx, stepCombinator, rootNode) {
   if (segIdx < 0) return true;
@@ -2383,16 +2397,16 @@ function checkPrefix(cursor, segments, segIdx, stepCombinator, rootNode) {
     for (let i2 = cursor.indexInSiblings - 1; i2 >= 0; i2--) {
       const sib = cursor.siblings[i2];
       if (!isMatchableNode(sib)) continue;
-      if (!nodeMatchesSegment(sib, segment, rootNode)) {
-        if (stepCombinator === "adjacent-sibling") return false;
-        continue;
-      }
-      const newCursor = {
+      const sibCursor = {
         ancestors: cursor.ancestors,
         siblings: cursor.siblings,
         indexInSiblings: i2
       };
-      if (checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
+      if (!nodeMatchesSegment(sib, segment, rootNode, sibCursor)) {
+        if (stepCombinator === "adjacent-sibling") return false;
+        continue;
+      }
+      if (checkPrefix(sibCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
       if (stepCombinator === "adjacent-sibling") return false;
     }
     return false;
@@ -2409,13 +2423,13 @@ function checkPrefix(cursor, segments, segIdx, stepCombinator, rootNode) {
       if (!matchesName(entry.name, segment)) return false;
       if (segment.kind === "html" && !checkAttributes(entry.node, segment.attributes)) return false;
       if (!checkDescendants(entry.node, segment.descendantChecks)) return false;
-      if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode)) return false;
-      const newCursor = {
+      const ancestorCursor = {
         ancestors: cursor.ancestors.slice(0, a2),
         siblings: entry.siblings,
         indexInSiblings: entry.indexInSiblings
       };
-      return checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode);
+      if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode, ancestorCursor)) return false;
+      return checkPrefix(ancestorCursor, segments, segIdx - 1, segment.combinator, rootNode);
     }
     return false;
   }
@@ -2425,13 +2439,13 @@ function checkPrefix(cursor, segments, segIdx, stepCombinator, rootNode) {
     if (!matchesName(entry.name, segment)) continue;
     if (segment.kind === "html" && !checkAttributes(entry.node, segment.attributes)) continue;
     if (!checkDescendants(entry.node, segment.descendantChecks)) continue;
-    if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode)) continue;
-    const newCursor = {
+    const ancestorCursor = {
       ancestors: cursor.ancestors.slice(0, a2),
       siblings: entry.siblings,
       indexInSiblings: entry.indexInSiblings
     };
-    if (checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
+    if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode, ancestorCursor)) continue;
+    if (checkPrefix(ancestorCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
   }
   return false;
 }
@@ -2475,8 +2489,8 @@ function matchAlternative(rootNode, segments, rootSiblings, rootIndexInSiblings)
   const results = [];
   const lastSegment = segments[segments.length - 1];
   function walk(node, ancestors, siblings, indexInSiblings) {
-    if (nodeMatchesSegment(node, lastSegment, rootNode)) {
-      const cursor = { ancestors, siblings, indexInSiblings };
+    const cursor = { ancestors, siblings, indexInSiblings };
+    if (nodeMatchesSegment(node, lastSegment, rootNode, cursor)) {
       if (segments.length === 1 || checkPrefix(cursor, segments, segments.length - 2, lastSegment.combinator, rootNode)) {
         results.push(getReportNode(node, rootNode));
       }
@@ -2669,6 +2683,23 @@ function collectErrors(tree, rules, customTagNames, customRules) {
   );
 }
 
+// src/core/customRuleFilter.ts
+var path3 = __toESM(require("node:path"));
+function ruleMatchesPath(rule, relPath) {
+  const normalized = relPath.split(path3.sep).join("/");
+  if (rule.exclude && rule.exclude.some((p2) => path3.matchesGlob(normalized, p2))) {
+    return false;
+  }
+  if (rule.include && rule.include.length > 0) {
+    return rule.include.some((p2) => path3.matchesGlob(normalized, p2));
+  }
+  return true;
+}
+function filterCustomRulesForPath(rules, relPath) {
+  if (!rules) return rules;
+  return rules.filter((r2) => ruleMatchesPath(r2, relPath));
+}
+
 // src/core/diagnostic.ts
 function toFix(r2) {
   return { range: [r2.startIndex, r2.endIndex], newText: r2.newText };
@@ -2768,6 +2799,7 @@ var DEFAULT_EXCLUDE_SEGMENTS = ["/node_modules/", "/.git/"];
 function resolveFiles(cliPatterns) {
   const configPath = findConfigFile(process.cwd());
   let config = null;
+  const configDir = configPath ? import_node_path.default.dirname(configPath) : null;
   if (configPath) {
     try {
       const text2 = import_node_fs.default.readFileSync(configPath, "utf-8");
@@ -2783,7 +2815,7 @@ function resolveFiles(cliPatterns) {
   } else if (config?.include && config.include.length > 0) {
     patterns = config.include;
   } else {
-    return { files: [], config };
+    return { files: [], config, configDir };
   }
   let files = expandGlobs(patterns);
   files = files.filter((f2) => !DEFAULT_EXCLUDE_SEGMENTS.some((seg) => f2.includes(seg)));
@@ -2801,7 +2833,7 @@ function resolveFiles(cliPatterns) {
     }
     files = files.filter((f2) => !excludeSet.has(f2));
   }
-  return { files, config };
+  return { files, config, configDir };
 }
 function applyFixes(source, errors) {
   const replacements = [];
@@ -2848,7 +2880,7 @@ async function run(args) {
   }
   const fixMode = args.includes("--fix");
   const patterns = args.filter((a2) => a2 !== "--fix");
-  const { files, config } = resolveFiles(patterns);
+  const { files, config, configDir } = resolveFiles(patterns);
   if (files.length === 0) {
     if (patterns.length === 0 && (!config?.include || config.include.length === 0)) {
       console.log(USAGE);
@@ -2870,12 +2902,15 @@ async function run(args) {
   const rules = config?.rules;
   const customTagNames = config?.customTags?.map((t2) => t2.name);
   const customRules = config?.customRules;
+  const ruleFilterBase = configDir ?? cwd;
   for (const file of files) {
     const displayPath = import_node_path.default.relative(cwd, file) || file;
+    const ruleFilterPath = import_node_path.default.relative(ruleFilterBase, file) || displayPath;
+    const applicableCustomRules = filterCustomRulesForPath(customRules, ruleFilterPath);
     let source = import_node_fs.default.readFileSync(file, "utf-8");
     if (fixMode) {
       const tree2 = parseDocument(source);
-      const errors2 = collectErrors2(tree2, displayPath, rules, customTagNames, customRules);
+      const errors2 = collectErrors2(tree2, displayPath, rules, customTagNames, applicableCustomRules);
       const fixed = applyFixes(source, errors2);
       if (fixed !== source) {
         import_node_fs.default.writeFileSync(file, fixed, "utf-8");
@@ -2883,7 +2918,7 @@ async function run(args) {
       }
     }
     const tree = parseDocument(source);
-    const errors = collectErrors2(tree, displayPath, rules, customTagNames, customRules);
+    const errors = collectErrors2(tree, displayPath, rules, customTagNames, applicableCustomRules);
     const fileErrors = errors.filter((e2) => e2.severity !== "warning");
     const fileWarnings = errors.filter((e2) => e2.severity === "warning");
     if (errors.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reteps/tree-sitter-htmlmustache",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "HTML with Mustache/Handlebars template syntax grammar for tree-sitter",
   "repository": {
     "type": "git",

package/src/browser/browser.test.ts

@@ -107,6 +107,20 @@ describe('lint', () => {
     expect(d.some((x) => x.ruleName === 'no-script')).toBe(true);
   });
 
+  it('rejects per-rule include/exclude at the type level', () => {
+    linter.lint('<script>x</script>', {
+      customRules: [{
+        id: 'no-script',
+        selector: 'script',
+        message: 'Bare <script> is disallowed',
+        // @ts-expect-error include is stripped from the browser CustomRule type
+        include: ['questions/**'],
+        // @ts-expect-error exclude is stripped from the browser CustomRule type
+        exclude: ['**/legacy/**'],
+      }],
+    });
+  });
+
   it('honors <!-- htmlmustache-disable ruleName --> directives', () => {
     const src = '<!-- htmlmustache-disable duplicateAttributes -->\n<p id="a" id="b"></p>';
     const d = linter.lint(src, DEFAULT_CONFIG);

package/src/browser/index.ts

@@ -28,8 +28,17 @@ import type {
 } from '../core/configSchema.js';
 import type { CustomCodeTagConfig } from '../core/customCodeTags.js';
 
-export type Config = Omit<HtmlMustacheConfig, 'include' | 'exclude'>;
-export type CustomRule = CustomRuleType;
+/**
+ * `include`/`exclude` on custom rules are stripped from the browser surface:
+ * the browser API has no filesystem path to match against, so those fields
+ * would silently do nothing. Users who share a `.htmlmustache.jsonc` config
+ * between the CLI and a web playground should strip them before passing, or
+ * let TypeScript catch the mismatch.
+ */
+export type CustomRule = Omit<CustomRuleType, 'include' | 'exclude'>;
+export type Config =
+  Omit<HtmlMustacheConfig, 'include' | 'exclude' | 'customRules'>
+  & { customRules?: CustomRule[] };
 export type CustomTag = CustomCodeTagConfig;
 export type { RulesConfig, RuleSeverity, PrettierLike, Diagnostic };
 

package/src/core/configSchema.ts

@@ -79,6 +79,14 @@ export interface CustomRule {
   selector: string;
   message: string;
   severity?: RuleSeverity;
+  /**
+   * Optional glob patterns (relative to the config file) restricting which
+   * files this rule applies to. Applied as an additional filter on top of the
+   * top-level `include`/`exclude` — a rule only fires for files that both
+   * the top-level settings include AND the per-rule settings include.
+   */
+  include?: string[];
+  exclude?: string[];
 }
 
 export interface NoBreakDelimiter {
@@ -264,6 +272,14 @@ export function validateConfig(raw: unknown): HtmlMustacheConfig {
       if (typeof e.severity === 'string' && VALID_RULE_SEVERITIES.has(e.severity)) {
         rule.severity = e.severity as RuleSeverity;
       }
+      if (Array.isArray(e.include)) {
+        const items = e.include.filter((s: unknown) => typeof s === 'string' && s.length > 0);
+        if (items.length > 0) rule.include = items as string[];
+      }
+      if (Array.isArray(e.exclude)) {
+        const items = e.exclude.filter((s: unknown) => typeof s === 'string' && s.length > 0);
+        if (items.length > 0) rule.exclude = items as string[];
+      }
       rules.push(rule);
     }
     if (rules.length > 0) config.customRules = rules;

package/src/core/customRuleFilter.ts

@@ -0,0 +1,32 @@
+/**
+ * Filter custom lint rules by per-rule `include` / `exclude` glob patterns.
+ *
+ * Patterns are matched against a path relative to the config file's directory.
+ * Path separators are normalized to forward slashes so cross-platform patterns
+ * like `questions/**` work regardless of host OS.
+ *
+ * Uses Node's `path.matchesGlob` (available since Node 22.5), so this module
+ * is Node-only — the browser entrypoint does not import it.
+ */
+
+import * as path from 'node:path';
+import type { CustomRule } from './configSchema.js';
+
+export function ruleMatchesPath(rule: CustomRule, relPath: string): boolean {
+  const normalized = relPath.split(path.sep).join('/');
+  if (rule.exclude && rule.exclude.some(p => path.matchesGlob(normalized, p))) {
+    return false;
+  }
+  if (rule.include && rule.include.length > 0) {
+    return rule.include.some(p => path.matchesGlob(normalized, p));
+  }
+  return true;
+}
+
+export function filterCustomRulesForPath(
+  rules: CustomRule[] | undefined,
+  relPath: string,
+): CustomRule[] | undefined {
+  if (!rules) return rules;
+  return rules.filter(r => ruleMatchesPath(r, relPath));
+}

package/src/core/selectorMatcher.ts

@@ -24,7 +24,11 @@
  *     the outer compound), plus any other selector (including Mustache
  *     literals and type selectors) as a whole-selector check against the
  *     node itself. Example: `{{*}}:not({{internal.*}})` matches any
- *     interpolation whose path does not start with `internal.`.
+ *     interpolation whose path does not start with `internal.`. Multi-segment
+ *     selectors with combinators are supported and tested against the node's
+ *     ancestor/sibling context, matching `Element.matches` semantics — e.g.
+ *     `img:not(pl-overlay img)` matches any `img` that is not a descendant of
+ *     `pl-overlay`, and `td:not(thead td)` matches `td`s outside a `thead`.
  *   - `:root` — the tree-sitter fragment root (the whole document). Unlike
  *     browser CSS where `:root` matches `<html>`, this matches the parse-tree
  *     root so it works on partials/fragments too. Useful as a document-scoped
@@ -651,14 +655,25 @@ function hasDescendantMatch(node: BalanceNode, selector: ParsedSelector): boolea
   return false;
 }
 
-function checkSelfNegations(node: BalanceNode, negations: ParsedSelector[], rootNode: BalanceNode): boolean {
+function checkSelfNegations(
+  node: BalanceNode,
+  negations: ParsedSelector[],
+  rootNode: BalanceNode,
+  cursor: Cursor,
+): boolean {
   for (const sel of negations) {
     for (const alt of sel) {
-      // A selfNegation selector is a single-segment check against the node itself.
-      // Multi-segment alternatives (e.g. `:not(a b)`) aren't sensibly testable
-      // against a single node, so they're treated as never matching => pass.
-      if (alt.length !== 1) continue;
-      if (nodeMatchesSegment(node, alt[0], rootNode)) return false;
+      if (alt.length === 0) continue;
+      const lastSegment = alt[alt.length - 1];
+      if (!nodeMatchesSegment(node, lastSegment, rootNode, cursor)) continue;
+      if (alt.length === 1) return false;
+      // Multi-segment negation (e.g. `:not(ancestor descendant)`): the last
+      // segment matched the node itself; walk back through the remaining
+      // segments against the node's ancestor/sibling cursor. If the chain
+      // also matches, the negation fires.
+      if (checkPrefix(cursor, alt, alt.length - 2, lastSegment.combinator, rootNode)) {
+        return false;
+      }
     }
   }
   return true;
@@ -671,11 +686,16 @@ function matchesName(actual: string | null, segment: Segment): boolean {
   return actual === segment.name;
 }
 
-function nodeMatchesSegment(node: BalanceNode, segment: Segment, rootNode: BalanceNode): boolean {
+function nodeMatchesSegment(
+  node: BalanceNode,
+  segment: Segment,
+  rootNode: BalanceNode,
+  cursor: Cursor,
+): boolean {
   if (segment.rootOnly) {
     if (node !== rootNode) return false;
     return checkDescendants(node, segment.descendantChecks)
-        && checkSelfNegations(node, segment.selfNegations, rootNode);
+        && checkSelfNegations(node, segment.selfNegations, rootNode, cursor);
   }
   const baseMatches = (() => {
     switch (segment.kind) {
@@ -714,7 +734,7 @@ function nodeMatchesSegment(node: BalanceNode, segment: Segment, rootNode: Balan
     }
   })();
   if (!baseMatches) return false;
-  return checkSelfNegations(node, segment.selfNegations, rootNode);
+  return checkSelfNegations(node, segment.selfNegations, rootNode, cursor);
 }
 
 interface Cursor {
@@ -738,16 +758,16 @@ function checkPrefix(
     for (let i = cursor.indexInSiblings - 1; i >= 0; i--) {
       const sib = cursor.siblings[i];
       if (!isMatchableNode(sib)) continue;
-      if (!nodeMatchesSegment(sib, segment, rootNode)) {
-        if (stepCombinator === 'adjacent-sibling') return false;
-        continue;
-      }
-      const newCursor: Cursor = {
+      const sibCursor: Cursor = {
         ancestors: cursor.ancestors,
         siblings: cursor.siblings,
         indexInSiblings: i,
       };
-      if (checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
+      if (!nodeMatchesSegment(sib, segment, rootNode, sibCursor)) {
+        if (stepCombinator === 'adjacent-sibling') return false;
+        continue;
+      }
+      if (checkPrefix(sibCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
       if (stepCombinator === 'adjacent-sibling') return false;
     }
     return false;
@@ -770,13 +790,13 @@ function checkPrefix(
       if (!matchesName(entry.name, segment)) return false;
       if (segment.kind === 'html' && !checkAttributes(entry.node, segment.attributes)) return false;
       if (!checkDescendants(entry.node, segment.descendantChecks)) return false;
-      if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode)) return false;
-      const newCursor: Cursor = {
+      const ancestorCursor: Cursor = {
         ancestors: cursor.ancestors.slice(0, a),
         siblings: entry.siblings,
         indexInSiblings: entry.indexInSiblings,
       };
-      return checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode);
+      if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode, ancestorCursor)) return false;
+      return checkPrefix(ancestorCursor, segments, segIdx - 1, segment.combinator, rootNode);
     }
     return false;
   }
@@ -787,13 +807,13 @@ function checkPrefix(
     if (!matchesName(entry.name, segment)) continue;
     if (segment.kind === 'html' && !checkAttributes(entry.node, segment.attributes)) continue;
     if (!checkDescendants(entry.node, segment.descendantChecks)) continue;
-    if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode)) continue;
-    const newCursor: Cursor = {
+    const ancestorCursor: Cursor = {
       ancestors: cursor.ancestors.slice(0, a),
       siblings: entry.siblings,
       indexInSiblings: entry.indexInSiblings,
     };
-    if (checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
+    if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode, ancestorCursor)) continue;
+    if (checkPrefix(ancestorCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
   }
   return false;
 }
@@ -862,8 +882,8 @@ function matchAlternative(
     siblings: BalanceNode[],
     indexInSiblings: number,
   ) {
-    if (nodeMatchesSegment(node, lastSegment, rootNode)) {
-      const cursor: Cursor = { ancestors, siblings, indexInSiblings };
+    const cursor: Cursor = { ancestors, siblings, indexInSiblings };
+    if (nodeMatchesSegment(node, lastSegment, rootNode, cursor)) {
       if (
         segments.length === 1 ||
         checkPrefix(cursor, segments, segments.length - 2, lastSegment.combinator, rootNode)