@reteps/tree-sitter-htmlmustache 0.9.0 → 0.9.2

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

@@ -10,14 +10,21 @@
  * Supported user-facing syntax:
  *   - Tag names (`div`), universal (`*`), classes (`.foo`), ids (`#foo`)
  *   - Attributes: `[attr]`, `[attr=v]`, `[attr^=v]`, `[attr*=v]`, `[attr$=v]`, `[attr~=v]`
- *   - Descendant (space) and child (`>`) combinators
+ *   - Descendant (space), child (`>`), adjacent-sibling (`+`), and
+ *     general-sibling (`~`) combinators. Sibling combinators skip over text /
+ *     whitespace nodes (CSS semantics) and work across HTML and Mustache
+ *     constructs: e.g. `label + input`, `{{foo}} + p`, `h2 ~ {{#items}}`.
  *   - Mustache variables: `{{path}}` and `{{{path}}}` (raw)
  *   - Mustache sections: `{{#name}}` and `{{^name}}` (inverted)
  *   - Mustache comments: `{{!content}}`
  *   - Mustache partials: `{{>name}}`
  *   - Glob wildcard `*` inside the argument: `{{options.*}}`, `{{*.deprecated}}`, `{{*}}`
  *   - `:has(selector)` — element has a matching descendant
- *   - `:not(...)` over any attribute/class/id/:has form
+ *   - `:not(...)` — negation. Accepts attributes/class/id/`:has` (folded into
+ *     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.`.
  *   - `: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
@@ -26,15 +33,19 @@
  *     `pl-answer-panel` is. Cannot combine with tag/class/id/attribute in the
  *     same compound (only with `:has` / `:not(:has(...))`). Inside `:has(...)`,
  *     `:root` refers to the element being checked, not the document.
+ *   - `:is(a, b, ...)` — matches if any alternative matches. Expanded at parse
+ *     time into the Cartesian product of alternatives, so `:is(a, b) :is(c, d)`
+ *     is equivalent to `a c, a d, b c, b d`. Alternatives inside `:is` that
+ *     contain combinators are only allowed when the `:is(...)` stands alone in
+ *     its compound (e.g. `:is(div > span, p)` works; `x:is(div > span, p)`
+ *     does not, since a combinator can't be merged into another compound).
  *   - Comma-separated alternatives
  *
  * Unsupported (parseSelector returns null, rule is skipped):
- *   - Sibling combinators (`+`, `~`)
  *   - `[attr|=v]`, case-insensitive `i` flag
  *   - Mixed HTML + Mustache kinds in one compound (e.g. `img{{foo}}`)
  *   - `{{/end}}` (end tags aren't standalone nodes)
  *   - `{{=<% %>=}}` (delimiter changes aren't grammar-tracked)
- *   - Mustache literals inside `:not(...)` (only attribute/class/id/:has)
  */
 import type { BalanceNode } from './htmlBalanceChecker.js';
 export type AttributeOperator = '=' | '^=' | '*=' | '$=' | '~=';
@@ -49,6 +60,7 @@ export interface DescendantCheck {
     selector: ParsedSelector;
     negated: boolean;
 }
+export type Combinator = 'descendant' | 'child' | 'adjacent-sibling' | 'general-sibling';
 export interface Segment {
     kind: SegmentKind;
     rootOnly: boolean;
@@ -56,7 +68,8 @@ export interface Segment {
     pathRegex?: RegExp;
     attributes: AttributeConstraint[];
     descendantChecks: DescendantCheck[];
-    combinator: 'descendant' | 'child';
+    selfNegations: ParsedSelector[];
+    combinator: Combinator;
 }
 /** A parsed selector is a list of alternatives (from comma-separated parts). */
 export type ParsedSelector = Segment[][];
@@ -70,5 +83,5 @@ export type ParsedSelector = Segment[][];
  */
 export declare function preprocessMustacheLiterals(raw: string): string | null;
 export declare function parseSelector(raw: string): ParsedSelector | null;
-export declare function matchSelector(rootNode: BalanceNode, selector: ParsedSelector): BalanceNode[];
+export declare function matchSelector(rootNode: BalanceNode, selector: ParsedSelector, siblings?: BalanceNode[], indexInSiblings?: number): BalanceNode[];
 //# sourceMappingURL=selectorMatcher.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;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,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,UAAU,EAAE,YAAY,GAAG,OAAO,CAAC;CACpC;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,CAuBhE;AA0eD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,cAAc,GAAG,WAAW,EAAE,CAY5F"}
+{"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"}

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;
       }
     }
@@ -1939,13 +1948,85 @@ function parseSelector(raw) {
   const tops = ast.type === "list" ? ast.list : [ast];
   const alts = [];
   for (const top of tops) {
-    const segments = [];
-    if (!collectSegments(top, "descendant", segments)) return null;
-    if (segments.length === 0) return null;
-    alts.push(segments);
+    const expanded = expandIs(top);
+    if (expanded === null) return null;
+    for (const exp of expanded) {
+      const segments = [];
+      if (!collectSegments(exp, "descendant", segments)) return null;
+      if (segments.length === 0) return null;
+      alts.push(segments);
+    }
   }
   return alts.length > 0 ? alts : null;
 }
+function expandIs(ast) {
+  switch (ast.type) {
+    case "list": {
+      const out = [];
+      for (const alt of ast.list) {
+        const expanded = expandIs(alt);
+        if (expanded === null) return null;
+        out.push(...expanded);
+      }
+      return out;
+    }
+    case "complex": {
+      const lefts = expandIs(ast.left);
+      if (lefts === null) return null;
+      const rights = expandIs(ast.right);
+      if (rights === null) return null;
+      const out = [];
+      for (const l2 of lefts) for (const r2 of rights) {
+        out.push({ ...ast, left: l2, right: r2 });
+      }
+      return out;
+    }
+    case "compound": {
+      if (ast.list.length === 1) {
+        const tok = ast.list[0];
+        if (tok.type === "pseudo-class" && tok.name === "is") {
+          if (!tok.subtree) return null;
+          return expandIs(tok.subtree);
+        }
+      }
+      return expandCompoundWithIs(ast.list);
+    }
+    default:
+      if (ast.type === "pseudo-class" && ast.name === "is") {
+        if (!ast.subtree) return null;
+        return expandIs(ast.subtree);
+      }
+      return [ast];
+  }
+}
+function expandCompoundWithIs(tokens) {
+  let variants = [[]];
+  for (const tok of tokens) {
+    if (tok.type === "pseudo-class" && tok.name === "is") {
+      if (!tok.subtree) return null;
+      const alts = expandIs(tok.subtree);
+      if (alts === null) return null;
+      const next = [];
+      for (const base of variants) {
+        for (const alt of alts) {
+          if (alt.type === "compound") {
+            next.push([...base, ...alt.list]);
+          } else if (alt.type === "complex" || alt.type === "list" || alt.type === "relative") {
+            return null;
+          } else {
+            next.push([...base, alt]);
+          }
+        }
+      }
+      variants = next;
+    } else {
+      variants = variants.map((v) => [...v, tok]);
+    }
+  }
+  return variants.map(
+    (list) => list.length === 1 ? list[0] : { type: "compound", list }
+  );
+}
 function collectSegments(ast, combinator, out) {
   if (ast.type === "complex") {
     const mapped = mapCombinator(ast.combinator);
@@ -1963,6 +2044,8 @@ function mapCombinator(c2) {
   const trimmed = c2.trim();
   if (trimmed === "") return "descendant";
   if (trimmed === ">") return "child";
+  if (trimmed === "+") return "adjacent-sibling";
+  if (trimmed === "~") return "general-sibling";
   return null;
 }
 function segmentFromCompound(ast) {
@@ -1973,6 +2056,7 @@ function segmentFromCompound(ast) {
   let rootOnly = false;
   const attributes = [];
   const descendantChecks = [];
+  const selfNegations = [];
   const forbidChange = (requested) => {
     if (kind === void 0) return false;
     if (kind === requested) return false;
@@ -2026,7 +2110,7 @@ function segmentFromCompound(ast) {
           break;
         }
         if (token.name === "not") {
-          if (!applyNegatedSubtree(token.subtree, attributes, descendantChecks)) return null;
+          if (!applyNegatedSubtree(token.subtree, attributes, descendantChecks, selfNegations)) return null;
           break;
         }
         if (token.name === "root") {
@@ -2048,7 +2132,7 @@ function segmentFromCompound(ast) {
   }
   const isHtml = kind === "html";
   const finalAttrs = isHtml ? attributes : [];
-  return { kind, rootOnly, name, pathRegex, attributes: finalAttrs, descendantChecks, combinator: "descendant" };
+  return { kind, rootOnly, name, pathRegex, attributes: finalAttrs, descendantChecks, selfNegations, combinator: "descendant" };
 }
 function mustacheKindFromMarker(name) {
   switch (name) {
@@ -2113,7 +2197,7 @@ function classConstraint(token, negated) {
 function idConstraint(token, negated) {
   return { name: "id", op: "=", value: token.name, negated };
 }
-function applyNegatedSubtree(subtree, attributes, descendantChecks) {
+function applyNegatedSubtree(subtree, attributes, descendantChecks, selfNegations) {
   if (!subtree) return false;
   if (subtree.type === "attribute") {
     const c2 = attributeConstraint(subtree, true);
@@ -2130,9 +2214,14 @@ function applyNegatedSubtree(subtree, attributes, descendantChecks) {
     return true;
   }
   if (subtree.type === "pseudo-class" && subtree.name === "has") {
-    const sel = subtreeToSelector(subtree.subtree);
-    if (!sel) return false;
-    descendantChecks.push({ selector: sel, negated: true });
+    const sel2 = subtreeToSelector(subtree.subtree);
+    if (!sel2) return false;
+    descendantChecks.push({ selector: sel2, negated: true });
+    return true;
+  }
+  const sel = subtreeToSelector(subtree);
+  if (sel) {
+    selfNegations.push(sel);
     return true;
   }
   return false;
@@ -2232,11 +2321,20 @@ function checkDescendants(node, checks) {
   return true;
 }
 function hasDescendantMatch(node, selector) {
-  for (const child of node.children) {
-    if (matchSelector(child, selector).length > 0) return true;
+  for (let i2 = 0; i2 < node.children.length; i2++) {
+    if (matchSelector(node.children[i2], selector, node.children, i2).length > 0) return true;
   }
   return false;
 }
+function checkSelfNegations(node, negations, rootNode) {
+  for (const sel of negations) {
+    for (const alt of sel) {
+      if (alt.length !== 1) continue;
+      if (nodeMatchesSegment(node, alt[0], rootNode)) return false;
+    }
+  }
+  return true;
+}
 function matchesName(actual, segment) {
   if (segment.name === null) return true;
   if (actual === null) return false;
@@ -2246,51 +2344,73 @@ function matchesName(actual, segment) {
 function nodeMatchesSegment(node, segment, rootNode) {
   if (segment.rootOnly) {
     if (node !== rootNode) return false;
-    return checkDescendants(node, segment.descendantChecks);
-  }
-  switch (segment.kind) {
-    case "html": {
-      if (!HTML_ELEMENT_TYPES.has(node.type)) return false;
-      if (segment.name !== null) {
-        const tagName = getTagName(node)?.toLowerCase();
-        if (tagName !== segment.name) return false;
+    return checkDescendants(node, segment.descendantChecks) && checkSelfNegations(node, segment.selfNegations, rootNode);
+  }
+  const baseMatches = (() => {
+    switch (segment.kind) {
+      case "html": {
+        if (!HTML_ELEMENT_TYPES.has(node.type)) return false;
+        if (segment.name !== null) {
+          const tagName = getTagName(node)?.toLowerCase();
+          if (tagName !== segment.name) return false;
+        }
+        return checkAttributes(node, segment.attributes) && checkDescendants(node, segment.descendantChecks);
       }
-      return checkAttributes(node, segment.attributes) && checkDescendants(node, segment.descendantChecks);
-    }
-    case "section":
-      if (node.type !== "mustache_section") return false;
-      if (!matchesName(getSectionName(node)?.toLowerCase() ?? null, segment)) return false;
-      return checkDescendants(node, segment.descendantChecks);
-    case "inverted":
-      if (node.type !== "mustache_inverted_section") return false;
-      if (!matchesName(getSectionName(node)?.toLowerCase() ?? null, segment)) return false;
-      return checkDescendants(node, segment.descendantChecks);
-    case "variable":
-      if (node.type !== "mustache_interpolation") return false;
-      if (!matchesName(getInterpolationPath(node)?.toLowerCase() ?? null, segment)) return false;
-      return checkDescendants(node, segment.descendantChecks);
-    case "raw":
-      if (node.type !== "mustache_triple") return false;
-      if (!matchesName(getInterpolationPath(node)?.toLowerCase() ?? null, segment)) return false;
-      return checkDescendants(node, segment.descendantChecks);
-    case "comment":
-      if (node.type !== "mustache_comment") return false;
-      if (!matchesName(getCommentContent(node)?.toLowerCase() ?? null, segment)) return false;
-      return checkDescendants(node, segment.descendantChecks);
-    case "partial":
-      if (node.type !== "mustache_partial") return false;
-      if (!matchesName(getPartialName(node)?.toLowerCase() ?? null, segment)) return false;
-      return checkDescendants(node, segment.descendantChecks);
-  }
-}
-function checkAncestors(ancestors, segments, segIdx, childCombinator) {
+      case "section":
+        if (node.type !== "mustache_section") return false;
+        if (!matchesName(getSectionName(node)?.toLowerCase() ?? null, segment)) return false;
+        return checkDescendants(node, segment.descendantChecks);
+      case "inverted":
+        if (node.type !== "mustache_inverted_section") return false;
+        if (!matchesName(getSectionName(node)?.toLowerCase() ?? null, segment)) return false;
+        return checkDescendants(node, segment.descendantChecks);
+      case "variable":
+        if (node.type !== "mustache_interpolation") return false;
+        if (!matchesName(getInterpolationPath(node)?.toLowerCase() ?? null, segment)) return false;
+        return checkDescendants(node, segment.descendantChecks);
+      case "raw":
+        if (node.type !== "mustache_triple") return false;
+        if (!matchesName(getInterpolationPath(node)?.toLowerCase() ?? null, segment)) return false;
+        return checkDescendants(node, segment.descendantChecks);
+      case "comment":
+        if (node.type !== "mustache_comment") return false;
+        if (!matchesName(getCommentContent(node)?.toLowerCase() ?? null, segment)) return false;
+        return checkDescendants(node, segment.descendantChecks);
+      case "partial":
+        if (node.type !== "mustache_partial") return false;
+        if (!matchesName(getPartialName(node)?.toLowerCase() ?? null, segment)) return false;
+        return checkDescendants(node, segment.descendantChecks);
+    }
+  })();
+  if (!baseMatches) return false;
+  return checkSelfNegations(node, segment.selfNegations, rootNode);
+}
+function checkPrefix(cursor, segments, segIdx, stepCombinator, rootNode) {
   if (segIdx < 0) return true;
   const segment = segments[segIdx];
+  if (stepCombinator === "adjacent-sibling" || stepCombinator === "general-sibling") {
+    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 = {
+        ancestors: cursor.ancestors,
+        siblings: cursor.siblings,
+        indexInSiblings: i2
+      };
+      if (checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
+      if (stepCombinator === "adjacent-sibling") return false;
+    }
+    return false;
+  }
   const ancestorKind = ancestorKindForSegment(segment);
   if (ancestorKind === null) return false;
-  if (childCombinator === "child") {
-    for (let a2 = ancestors.length - 1; a2 >= 0; a2--) {
-      const entry = ancestors[a2];
+  if (stepCombinator === "child") {
+    for (let a2 = cursor.ancestors.length - 1; a2 >= 0; a2--) {
+      const entry = cursor.ancestors[a2];
       if (entry.kind !== ancestorKind) {
         if (ancestorKind === "root" && entry.kind === "html") return false;
         continue;
@@ -2298,22 +2418,35 @@ function checkAncestors(ancestors, segments, segIdx, childCombinator) {
       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;
-      return checkAncestors(ancestors.slice(0, a2), segments, segIdx - 1, segment.combinator);
+      if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode)) return false;
+      const newCursor = {
+        ancestors: cursor.ancestors.slice(0, a2),
+        siblings: entry.siblings,
+        indexInSiblings: entry.indexInSiblings
+      };
+      return checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode);
     }
     return false;
   }
-  for (let a2 = ancestors.length - 1; a2 >= 0; a2--) {
-    const entry = ancestors[a2];
+  for (let a2 = cursor.ancestors.length - 1; a2 >= 0; a2--) {
+    const entry = cursor.ancestors[a2];
     if (entry.kind !== ancestorKind) continue;
     if (!matchesName(entry.name, segment)) continue;
     if (segment.kind === "html" && !checkAttributes(entry.node, segment.attributes)) continue;
     if (!checkDescendants(entry.node, segment.descendantChecks)) continue;
-    if (checkAncestors(ancestors.slice(0, a2), segments, segIdx - 1, segment.combinator)) {
-      return true;
-    }
+    if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode)) continue;
+    const newCursor = {
+      ancestors: cursor.ancestors.slice(0, a2),
+      siblings: entry.siblings,
+      indexInSiblings: entry.indexInSiblings
+    };
+    if (checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
   }
   return false;
 }
+function isMatchableNode(node) {
+  return HTML_ELEMENT_TYPES.has(node.type) || node.type === "mustache_section" || node.type === "mustache_inverted_section" || node.type === "mustache_interpolation" || node.type === "mustache_triple" || node.type === "mustache_comment" || node.type === "mustache_partial";
+}
 function ancestorKindForSegment(segment) {
   if (segment.rootOnly) return "root";
   if (segment.kind === "html") return "html";
@@ -2347,12 +2480,13 @@ function getReportNode(node, rootNode) {
   }
   return node;
 }
-function matchAlternative(rootNode, segments) {
+function matchAlternative(rootNode, segments, rootSiblings, rootIndexInSiblings) {
   const results = [];
   const lastSegment = segments[segments.length - 1];
-  function walk(node, ancestors) {
+  function walk(node, ancestors, siblings, indexInSiblings) {
     if (nodeMatchesSegment(node, lastSegment, rootNode)) {
-      if (segments.length === 1 || checkAncestors(ancestors, segments, segments.length - 2, lastSegment.combinator)) {
+      const cursor = { ancestors, siblings, indexInSiblings };
+      if (segments.length === 1 || checkPrefix(cursor, segments, segments.length - 2, lastSegment.combinator, rootNode)) {
         results.push(getReportNode(node, rootNode));
       }
     }
@@ -2361,19 +2495,28 @@ function matchAlternative(rootNode, segments) {
     if (ancestorKind !== null) {
       const name = ancestorKind === "html" ? getTagName(node)?.toLowerCase() : getSectionName(node)?.toLowerCase();
       if (name) {
-        newAncestors = [...ancestors, { kind: ancestorKind, name, node }];
+        newAncestors = [...ancestors, { kind: ancestorKind, name, node, siblings, indexInSiblings }];
       }
     }
-    for (const child of node.children) walk(child, newAncestors);
+    for (let i2 = 0; i2 < node.children.length; i2++) {
+      walk(node.children[i2], newAncestors, node.children, i2);
+    }
   }
-  walk(rootNode, [{ kind: "root", name: "", node: rootNode }]);
+  const rootEntry = {
+    kind: "root",
+    name: "",
+    node: rootNode,
+    siblings: rootSiblings,
+    indexInSiblings: rootIndexInSiblings
+  };
+  walk(rootNode, [rootEntry], rootSiblings, rootIndexInSiblings);
   return results;
 }
-function matchSelector(rootNode, selector) {
+function matchSelector(rootNode, selector, siblings = [], indexInSiblings = 0) {
   const allResults = [];
   const seen = /* @__PURE__ */ new Set();
   for (const alt of selector) {
-    for (const node of matchAlternative(rootNode, alt)) {
+    for (const node of matchAlternative(rootNode, alt, siblings, indexInSiblings)) {
       if (!seen.has(node)) {
         seen.add(node);
         allResults.push(node);
@@ -2535,6 +2678,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 };
@@ -2634,6 +2794,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");
@@ -2649,7 +2810,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)));
@@ -2667,7 +2828,7 @@ function resolveFiles(cliPatterns) {
     }
     files = files.filter((f2) => !excludeSet.has(f2));
   }
-  return { files, config };
+  return { files, config, configDir };
 }
 function applyFixes(source, errors) {
   const replacements = [];
@@ -2714,7 +2875,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);
@@ -2736,12 +2897,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");
@@ -2749,7 +2913,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.0",
+  "version": "0.9.2",
   "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);