@markuplint/selector 4.7.8 → 5.0.0-alpha.0

package/ARCHITECTURE.ja.md

@@ -4,7 +4,7 @@
 
 `@markuplint/selector` は markuplint のための拡張 [W3C Selectors Level 4](https://www.w3.org/TR/selectors-4/) マッチャーです。2 つの独立したマッチングシステムを提供します:
 
-1. **CSS セレクタマッチング** -- `postcss-selector-parser` を使用して標準 CSS セレクタをパースし、DOM ノードに対して完全な詳細度追跡付きでマッチングします。
+1. **CSS セレクタマッチング** -- `postcss-selector-parser` を使用して標準 CSS セレクタをパースし、要素に対して完全な詳細度追跡付きでマッチングします。
 2. **Regex セレクタマッチング** -- ノード名と属性に対する正規表現パターンでマッチングし、キャプチャグループデータを抽出します。
 
 また、markuplint 固有の拡張擬似クラス（`:aria()`、`:role()`、`:model()`）を定義し、HTML/ARIA 仕様データをセレクタマッチングに統合します。
@@ -14,13 +14,13 @@
 ```
 src/
 ├── index.ts                                — エクスポートエントリーポイント
-├── types.ts                                — 型定義（Specificity, SelectorResult, RegexSelector 等）
+├── types.ts                                — 型定義（SelectorElement, SelectorNode, SelectorAttr, Specificity, SelectorResult 等）
 ├── selector.ts                             — コア Selector/Ruleset/StructuredSelector/SelectorTarget クラス
 ├── create-selector.ts                      — インスタンスキャッシュと拡張擬似クラス登録を持つ Selector ファクトリ
 ├── match-selector.ts                       — CSS/Regex セレクタマッチング公開関数
 ├── compare-specificity.ts                  — 詳細度比較ユーティリティ
 ├── regex-selector-matches.ts               — 正規表現パターンマッチングヘルパー
-├── is.ts                                   — DOM ノード型ガード
+├── is.ts                                   — ノード型ガード（SelectorNode/SelectorElement）
 ├── invalid-selector-error.ts               — 無効セレクタ用カスタムエラークラス
 ├── debug.ts                                — デバッグログ設定（debug パッケージ使用）
 └── extended-selector/
@@ -81,13 +81,13 @@ flowchart TD
 | モジュール                      | 役割                     | 主要エクスポート                                                                                                               |
 | ------------------------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------ |
 | `index.ts`                      | エントリーポイント       | 全公開 API の再エクスポート                                                                                                    |
-| `types.ts`                      | 型定義                   | `Specificity`, `SelectorResult`, `RegexSelector`, `RegexSelectorCombinator`                                                    |
-| `selector.ts`                   | CSS セレクタエンジン     | `Selector` クラス（エントリーポイントからは再エクスポートされない）、`Ruleset`, `StructuredSelector`, `SelectorTarget`（内部） |
+| `types.ts`                      | 型定義                   | `Specificity`, `SelectorResult`, `RegexSelector`, `RegexSelectorCombinator`, `SelectorAttr`, `SelectorNode`, `SelectorElement` |
+| `selector.ts`                   | CSS セレクタエンジン     | `Selector` クラス、`ExtendedPseudoClass` 型、`Ruleset`, `StructuredSelector`, `SelectorTarget`（内部）                         |
 | `create-selector.ts`            | キャッシュ付きファクトリ | `createSelector()`                                                                                                             |
 | `match-selector.ts`             | 統合マッチング           | `matchSelector()`, `SelectorMatches`                                                                                           |
 | `compare-specificity.ts`        | 詳細度比較               | `compareSpecificity()`                                                                                                         |
 | `regex-selector-matches.ts`     | Regex マッチングヘルパー | `regexSelectorMatches()`                                                                                                       |
-| `is.ts`                         | DOM 型ガード             | `isElement()`, `isNonDocumentTypeChildNode()`, `isPureHTMLElement()`                                                           |
+| `is.ts`                         | ノード型ガード           | `isElement()`, `isNonDocumentTypeChildNode()`, `isPureHTMLElement()`                                                           |
 | `invalid-selector-error.ts`     | エラークラス             | `InvalidSelectorError`                                                                                                         |
 | `debug.ts`                      | デバッグログ             | `log`（debug インスタンス）, `enableDebug()`                                                                                   |
 | `aria-pseudo-class.ts`          | `:aria()` ハンドラ       | `ariaPseudoClass()`                                                                                                            |
@@ -102,7 +102,7 @@ flowchart TD
 
 ### `matchSelector(el, selector, scope?, specs?)`
 
-CSS セレクタ文字列または `RegexSelector` オブジェクトの両方を受け付ける統合マッチング関数です。`{ matched: true, selector, specificity, data? }` または `{ matched: false }` を返します。
+CSS セレクタ文字列または `RegexSelector` オブジェクトの両方を受け付ける統合マッチング関数です。`el` および `scope` パラメータは任意の `SelectorNode` を受け取ります。`{ matched: true, selector, specificity, data? }` または `{ matched: false }` を返します。
 
 ### `compareSpecificity(a, b)`
 
@@ -116,6 +116,22 @@ CSS セレクタ文字列または `RegexSelector` オブジェクトの両方
 
 CSS セレクタ文字列がパースできない場合にスローされるカスタムエラーです。
 
+## 純粋データインターフェース
+
+セレクタエンジンは DOM `Element`/`Node` を直接使用せず、純粋なデータインターフェース上で動作します。これにより、マッチングロジックが約200プロパティの DOM API から分離され、移植性（例: Rust/WASM）とプレーンオブジェクトによるテストが可能になります。
+
+| インターフェース  | 継承元         | 用途                                                   |
+| ----------------- | -------------- | ------------------------------------------------------ |
+| `SelectorAttr`    | —              | 最小属性: `name`, `localName`, `value`, `namespaceURI` |
+| `SelectorNode`    | —              | 最小ノード: `nodeType`, `nodeName`, `parentNode`       |
+| `SelectorElement` | `SelectorNode` | エンジンが実際に読み取る約12のプロパティを持つ要素     |
+
+DOM `Element`、JSDOM 要素、`MLElement` はすべて構造的型付けにより `SelectorElement` を満たします — アダプタコードは不要です。
+
+拡張擬似クラス（`:aria()`、`:role()`、`:model()`）は `SelectorElement` を受け取り、完全な DOM API が必要な `@markuplint/ml-spec` 境界で `Element` にキャストします。
+
+`@markuplint/selector` は依存グラフ上 `@markuplint/ml-core` より下位に位置するため、`MLElement` を直接参照できません。`:aria()` 擬似クラスはダックタイピング（`'getAccessibleName' in el`）により、要素がキャッシュ付きアクセシブルネームメソッドを持つかを検出します。これにより、循環依存を導入することなく `MLElement` の要素単位メモ化キャッシュをセレクタから共有できます。
+
 ## コア内部クラス
 
 CSS マッチングシステムは 4 つのクラスの階層で構成されます:
@@ -136,7 +152,7 @@ Selector
 
 ### CSS セレクタマッチング
 
-標準 CSS セレクタは `postcss-selector-parser` により AST にパースされ、DOM ノードに対してマッチングされます:
+標準 CSS セレクタは `postcss-selector-parser` により AST にパースされ、`SelectorNode`/`SelectorElement` インスタンスに対してマッチングされます:
 
 1. `createSelector()` がキャッシュされた `Selector` インスタンスを作成または取得
 2. `Selector.match()` が `Ruleset.match()` に委譲
@@ -161,16 +177,16 @@ Regex セレクタは `RegexSelector` 型を使用してパターンで要素を
 拡張擬似クラスは `ExtendedPseudoClass` 型を通じて登録されます:
 
 ```typescript
-type ExtendedPseudoClass = Record<string, (content: string) => (el: Element) => SelectorResult>;
+type ExtendedPseudoClass = Record<string, (content: string) => (el: SelectorElement) => SelectorResult>;
 ```
 
 3 つの擬似クラスが組み込まれています:
 
-| 擬似クラス                                     | モジュール                      | 説明                                                                   |
-| ---------------------------------------------- | ------------------------------- | ---------------------------------------------------------------------- |
-| `:aria(has name)` / `:aria(has no name)`       | `aria-pseudo-class.ts`          | `getAccname()` を使用してアクセシブルネームの有無で要素をマッチング    |
-| `:role(roleName)` / `:role(roleName\|version)` | `aria-role-pseudo-class.ts`     | `getComputedRole()` を使用して計算された ARIA ロールで要素をマッチング |
-| `:model(category)`                             | `content-model-pseudo-class.ts` | HTML コンテンツモデルカテゴリに属する要素をマッチング                  |
+| 擬似クラス                                     | モジュール                      | 説明                                                                                                                                         |
+| ---------------------------------------------- | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| `:aria(has name)` / `:aria(has no name)`       | `aria-pseudo-class.ts`          | アクセシブルネームの有無で要素をマッチング（`MLElement.getAccessibleName()` のキャッシュを利用、フォールバックとして `getAccname()` を使用） |
+| `:role(roleName)` / `:role(roleName\|version)` | `aria-role-pseudo-class.ts`     | `getComputedRole()` を使用して計算された ARIA ロールで要素をマッチング                                                                       |
+| `:model(category)`                             | `content-model-pseudo-class.ts` | HTML コンテンツモデルカテゴリに属する要素をマッチング                                                                                        |
 
 すべての拡張擬似クラスの詳細度は `[0, 1, 0]` です。
 

package/ARCHITECTURE.md

@@ -4,7 +4,7 @@
 
 `@markuplint/selector` is an extended [W3C Selectors Level 4](https://www.w3.org/TR/selectors-4/) matcher for markuplint. It provides two independent matching systems:
 
-1. **CSS Selector Matching** -- Parses standard CSS selectors via `postcss-selector-parser` and matches them against DOM nodes with full specificity tracking.
+1. **CSS Selector Matching** -- Parses standard CSS selectors via `postcss-selector-parser` and matches them against elements with full specificity tracking.
 2. **Regex Selector Matching** -- Matches elements using regular expression patterns on node names and attributes, with captured group data extraction.
 
 The package also defines markuplint-specific extended pseudo-classes (`:aria()`, `:role()`, `:model()`) that integrate HTML/ARIA specification data into selector matching.
@@ -14,13 +14,13 @@ The package also defines markuplint-specific extended pseudo-classes (`:aria()`,
 ```
 src/
 ├── index.ts                                — Export entry point
-├── types.ts                                — Type definitions (Specificity, SelectorResult, RegexSelector, etc.)
+├── types.ts                                — Type definitions (SelectorElement, SelectorNode, SelectorAttr, Specificity, SelectorResult, etc.)
 ├── selector.ts                             — Core Selector/Ruleset/StructuredSelector/SelectorTarget classes
 ├── create-selector.ts                      — Selector factory with instance caching and extended pseudo-class registration
 ├── match-selector.ts                       — CSS/Regex selector matching public function
 ├── compare-specificity.ts                  — Specificity comparison utility
 ├── regex-selector-matches.ts               — Regex pattern matching helper
-├── is.ts                                   — DOM node type guards
+├── is.ts                                   — Node type guards (SelectorNode/SelectorElement)
 ├── invalid-selector-error.ts               — Custom error class for invalid selectors
 ├── debug.ts                                — Debug log configuration (using debug package)
 └── extended-selector/
@@ -78,21 +78,21 @@ flowchart TD
 
 ## Module Overview
 
-| Module                          | Role                   | Key Exports                                                                                                       |
-| ------------------------------- | ---------------------- | ----------------------------------------------------------------------------------------------------------------- |
-| `index.ts`                      | Entry point            | Re-exports all public API                                                                                         |
-| `types.ts`                      | Type definitions       | `Specificity`, `SelectorResult`, `RegexSelector`, `RegexSelectorCombinator`                                       |
-| `selector.ts`                   | CSS selector engine    | `Selector` class (not re-exported from entry point), `Ruleset`, `StructuredSelector`, `SelectorTarget` (internal) |
-| `create-selector.ts`            | Factory with caching   | `createSelector()`                                                                                                |
-| `match-selector.ts`             | Unified matching       | `matchSelector()`, `SelectorMatches`                                                                              |
-| `compare-specificity.ts`        | Specificity comparison | `compareSpecificity()`                                                                                            |
-| `regex-selector-matches.ts`     | Regex matching helper  | `regexSelectorMatches()`                                                                                          |
-| `is.ts`                         | DOM type guards        | `isElement()`, `isNonDocumentTypeChildNode()`, `isPureHTMLElement()`                                              |
-| `invalid-selector-error.ts`     | Error class            | `InvalidSelectorError`                                                                                            |
-| `debug.ts`                      | Debug logging          | `log` (debug instance), `enableDebug()`                                                                           |
-| `aria-pseudo-class.ts`          | `:aria()` handler      | `ariaPseudoClass()`                                                                                               |
-| `aria-role-pseudo-class.ts`     | `:role()` handler      | `ariaRolePseudoClass()`                                                                                           |
-| `content-model-pseudo-class.ts` | `:model()` handler     | `contentModelPseudoClass()`                                                                                       |
+| Module                          | Role                   | Key Exports                                                                                                                    |
+| ------------------------------- | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| `index.ts`                      | Entry point            | Re-exports all public API                                                                                                      |
+| `types.ts`                      | Type definitions       | `Specificity`, `SelectorResult`, `RegexSelector`, `RegexSelectorCombinator`, `SelectorAttr`, `SelectorNode`, `SelectorElement` |
+| `selector.ts`                   | CSS selector engine    | `Selector` class, `ExtendedPseudoClass` type, `Ruleset`, `StructuredSelector`, `SelectorTarget` (internal)                     |
+| `create-selector.ts`            | Factory with caching   | `createSelector()`                                                                                                             |
+| `match-selector.ts`             | Unified matching       | `matchSelector()`, `SelectorMatches`                                                                                           |
+| `compare-specificity.ts`        | Specificity comparison | `compareSpecificity()`                                                                                                         |
+| `regex-selector-matches.ts`     | Regex matching helper  | `regexSelectorMatches()`                                                                                                       |
+| `is.ts`                         | Node type guards       | `isElement()`, `isNonDocumentTypeChildNode()`, `isPureHTMLElement()`                                                           |
+| `invalid-selector-error.ts`     | Error class            | `InvalidSelectorError`                                                                                                         |
+| `debug.ts`                      | Debug logging          | `log` (debug instance), `enableDebug()`                                                                                        |
+| `aria-pseudo-class.ts`          | `:aria()` handler      | `ariaPseudoClass()`                                                                                                            |
+| `aria-role-pseudo-class.ts`     | `:role()` handler      | `ariaRolePseudoClass()`                                                                                                        |
+| `content-model-pseudo-class.ts` | `:model()` handler     | `contentModelPseudoClass()`                                                                                                    |
 
 ## Public API
 
@@ -102,7 +102,7 @@ Creates a cached `Selector` instance. When `specs` is provided, the extended pse
 
 ### `matchSelector(el, selector, scope?, specs?)`
 
-Unified matching function that accepts either a CSS selector string or a `RegexSelector` object. Returns `{ matched: true, selector, specificity, data? }` or `{ matched: false }`.
+Unified matching function that accepts either a CSS selector string or a `RegexSelector` object. The `el` and `scope` parameters accept any `SelectorNode`. Returns `{ matched: true, selector, specificity, data? }` or `{ matched: false }`.
 
 ### `compareSpecificity(a, b)`
 
@@ -116,6 +116,22 @@ Union type for selector match results: `{ matched: true, selector, specificity,
 
 Custom error thrown when a CSS selector string cannot be parsed.
 
+## Pure Data Interfaces
+
+The selector engine operates on pure data interfaces rather than DOM `Element`/`Node` directly. This decouples the matching logic from the ~200-property DOM API, making it portable (e.g., to Rust/WASM) and testable with plain objects.
+
+| Interface         | Extends        | Purpose                                                         |
+| ----------------- | -------------- | --------------------------------------------------------------- |
+| `SelectorAttr`    | —              | Minimal attribute: `name`, `localName`, `value`, `namespaceURI` |
+| `SelectorNode`    | —              | Minimal node: `nodeType`, `nodeName`, `parentNode`              |
+| `SelectorElement` | `SelectorNode` | Element with the ~12 properties the engine actually reads       |
+
+DOM `Element`, JSDOM elements, and `MLElement` all satisfy `SelectorElement` via structural typing — no adapter code is needed.
+
+Extended pseudo-classes (`:aria()`, `:role()`, `:model()`) receive a `SelectorElement` and cast to `Element` at the `@markuplint/ml-spec` boundary where full DOM APIs are required.
+
+Because `@markuplint/selector` sits below `@markuplint/ml-core` in the dependency graph, it cannot reference `MLElement` directly. The `:aria()` pseudo-class uses duck-typing (`'getAccessibleName' in el`) to detect whether the element provides a cached accessible name method. This allows the selector to share `MLElement`'s per-element memoization cache without introducing a circular dependency.
+
 ## Core Internal Classes
 
 The CSS matching system uses a hierarchy of four classes:
@@ -136,7 +152,7 @@ Selector
 
 ### CSS Selector Matching
 
-Standard CSS selectors are parsed by `postcss-selector-parser` into an AST, then matched against DOM nodes. The matching process:
+Standard CSS selectors are parsed by `postcss-selector-parser` into an AST, then matched against `SelectorNode`/`SelectorElement` instances. The matching process:
 
 1. `createSelector()` creates or retrieves a cached `Selector` instance
 2. `Selector.match()` delegates to `Ruleset.match()`
@@ -161,16 +177,16 @@ See [Selector Matching](docs/matching.md) for detailed algorithm documentation.
 Extended pseudo-classes are registered through the `ExtendedPseudoClass` type:
 
 ```typescript
-type ExtendedPseudoClass = Record<string, (content: string) => (el: Element) => SelectorResult>;
+type ExtendedPseudoClass = Record<string, (content: string) => (el: SelectorElement) => SelectorResult>;
 ```
 
 Three pseudo-classes are built in:
 
-| Pseudo-Class                                   | Module                          | Description                                                       |
-| ---------------------------------------------- | ------------------------------- | ----------------------------------------------------------------- |
-| `:aria(has name)` / `:aria(has no name)`       | `aria-pseudo-class.ts`          | Matches elements by accessible name presence using `getAccname()` |
-| `:role(roleName)` / `:role(roleName\|version)` | `aria-role-pseudo-class.ts`     | Matches elements by computed ARIA role using `getComputedRole()`  |
-| `:model(category)`                             | `content-model-pseudo-class.ts` | Matches elements belonging to an HTML content model category      |
+| Pseudo-Class                                   | Module                          | Description                                                                                                                            |
+| ---------------------------------------------- | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| `:aria(has name)` / `:aria(has no name)`       | `aria-pseudo-class.ts`          | Matches elements by accessible name presence (uses `MLElement.getAccessibleName()` cache when available, falls back to `getAccname()`) |
+| `:role(roleName)` / `:role(roleName\|version)` | `aria-role-pseudo-class.ts`     | Matches elements by computed ARIA role using `getComputedRole()`                                                                       |
+| `:model(category)`                             | `content-model-pseudo-class.ts` | Matches elements belonging to an HTML content model category                                                                           |
 
 All extended pseudo-classes have a specificity of `[0, 1, 0]`.
 

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.0.0-alpha.0](https://github.com/markuplint/markuplint/compare/v4.14.1...v5.0.0-alpha.0) (2026-02-20)
+
+### Bug Fixes
+
+- resolve additional eslint-plugin-unicorn v63 errors ([e58a72c](https://github.com/markuplint/markuplint/commit/e58a72c17c97bbec522f9513b99777fac6904d64))
+- use explicit `export type` for type-only re-exports ([7c77c05](https://github.com/markuplint/markuplint/commit/7c77c05619518c8d18a183132040f5b2cd0ab6ec))
+
+### Performance Improvements
+
+- **selector:** use cached getAccessibleName in :aria() pseudo-class ([42ea466](https://github.com/markuplint/markuplint/commit/42ea4665308e2b90e90856b29be939a6e8022347)), closes [#2179](https://github.com/markuplint/markuplint/issues/2179)
+
 ## [4.7.8](https://github.com/markuplint/markuplint/compare/@markuplint/selector@4.7.7...@markuplint/selector@4.7.8) (2026-02-10)
 
 **Note:** Version bump only for package @markuplint/selector

package/SKILL.md

@@ -40,7 +40,7 @@ Add a new markuplint-specific extended pseudo-class. Follow recipe #1 in `docs/m
 2. Create `src/extended-selector/<name>-pseudo-class.ts`
 3. Implement the handler following the `ExtendedPseudoClass` signature:
    ```typescript
-   (content: string) => (el: Element) => SelectorResult;
+   (content: string) => (el: SelectorElement) => SelectorResult;
    ```
 4. Return specificity `[0, 1, 0]` for consistency with other extended pseudo-classes
 

package/docs/maintenance.ja.md

@@ -41,12 +41,14 @@ yarn workspace @markuplint/selector run vitest run src/selector.spec.ts
 1. `src/extended-selector/custom-pseudo-class.ts` を作成:
 
    ```typescript
-   import type { SelectorResult } from '../types.js';
+   import type { SelectorElement, SelectorResult } from '../types.js';
 
    export function customPseudoClass() {
      return (content: string) =>
-       (el: Element): SelectorResult => {
+       (el: SelectorElement): SelectorResult => {
          // content 文字列をパースして el に対してマッチング
+         // 完全な DOM API（例: @markuplint/ml-spec）が必要な場合は、
+         // その境界で `el as Element` とキャストしてください。
          const matched = /* マッチングロジック */;
          return {
            specificity: [0, 1, 0],
@@ -206,4 +208,4 @@ Regex セレクタに新しいコンビネータを追加するには:
 ### jsdom（開発）
 
 - テストで DOM 環境を作成するための `JSDOM` を提供
-- `jsdom` で作成された要素はセレクタマッチングロジックが使用する標準 DOM API を持つ
+- `jsdom` で作成された要素はセレクタマッチングロジックが使用する `SelectorElement` インターフェースを満たす

package/docs/maintenance.md

@@ -41,12 +41,14 @@ To add a new markuplint-specific pseudo-class (e.g., `:custom()`):
 1. Create `src/extended-selector/custom-pseudo-class.ts`:
 
    ```typescript
-   import type { SelectorResult } from '../types.js';
+   import type { SelectorElement, SelectorResult } from '../types.js';
 
    export function customPseudoClass() {
      return (content: string) =>
-       (el: Element): SelectorResult => {
+       (el: SelectorElement): SelectorResult => {
          // Parse content string and match against el
+         // If you need full DOM APIs (e.g., from @markuplint/ml-spec),
+         // cast with `el as Element` at that boundary.
          const matched = /* your matching logic */;
          return {
            specificity: [0, 1, 0],
@@ -206,4 +208,4 @@ To add a new combinator for regex selectors:
 ### jsdom (dev)
 
 - Provides `JSDOM` for creating DOM environments in tests
-- Elements created via `jsdom` have standard DOM APIs used by the selector matching logic
+- Elements created via `jsdom` satisfy the `SelectorElement` interface used by the selector matching logic

package/docs/matching.ja.md

@@ -9,7 +9,7 @@
 1. **CSS セレクタマッチング** -- `postcss-selector-parser` でパースされる標準 CSS セレクタ
 2. **Regex セレクタマッチング** -- 正規表現を使用したパターンベースのマッチング
 
-両システムとも詳細度情報を返し、統合関数 `matchSelector()` を通じて使用できます。
+両システムとも DOM `Element` ではなく純粋データインターフェース（`SelectorNode`/`SelectorElement`）上で動作し、詳細度情報を返し、統合関数 `matchSelector()` を通じて使用できます。
 
 ## CSS セレクタマッチングフロー
 
@@ -83,7 +83,7 @@ div > .class:not(.other) span
 
 ### 拡張擬似クラス
 
-拡張擬似クラスは `ExtendedPseudoClass` レジストリを通じてディスパッチされます:
+拡張擬似クラスは `ExtendedPseudoClass` レジストリを通じてディスパッチされます。ハンドラは `SelectorElement` を受け取り、`@markuplint/ml-spec` API を呼び出す際に `Element` にキャストします:
 
 #### `:aria(syntax)`
 

package/docs/matching.md

@@ -9,7 +9,7 @@ The package provides two independent matching systems:
 1. **CSS Selector Matching** -- Standard CSS selectors parsed via `postcss-selector-parser`
 2. **Regex Selector Matching** -- Pattern-based matching using regular expressions
 
-Both systems return specificity information and can be used through the unified `matchSelector()` function.
+Both systems operate on pure data interfaces (`SelectorNode`/`SelectorElement`) rather than DOM `Element` directly, return specificity information, and can be used through the unified `matchSelector()` function.
 
 ## CSS Selector Matching Flow
 
@@ -83,7 +83,7 @@ Walks up the ancestor chain and matches if any ancestor matches the inner select
 
 ### Extended Pseudo-Classes
 
-Extended pseudo-classes are dispatched through the `ExtendedPseudoClass` registry:
+Extended pseudo-classes are dispatched through the `ExtendedPseudoClass` registry. Handlers receive a `SelectorElement` and cast to `Element` when calling `@markuplint/ml-spec` APIs:
 
 #### `:aria(syntax)`
 

package/lib/compare-specificity.d.ts

@@ -7,4 +7,4 @@ import type { Specificity } from './types.js';
  * @param b - The second specificity tuple `[id, class, type]`
  * @returns `-1` if `a` is less specific, `1` if `a` is more specific, `0` if equal
  */
-export declare function compareSpecificity(a: Specificity, b: Specificity): 1 | -1 | 0;
+export declare function compareSpecificity(a: Specificity, b: Specificity): 0 | 1 | -1;

package/lib/create-selector.js

@@ -24,7 +24,7 @@ export function createSelector(selector, specs) {
     instance = new Selector(selector, specs
         ? {
             model: contentModelPseudoClass(specs),
-            aria: ariaPseudoClass(),
+            aria: ariaPseudoClass(specs),
             role: ariaRolePseudoClass(specs),
         }
         : undefined);

package/lib/extended-selector/aria-pseudo-class.d.ts

@@ -1,11 +1,28 @@
-import type { SelectorResult } from '../types.js';
+import type { SelectorElement, SelectorResult } from '../types.js';
+import type { MLMLSpec } from '@markuplint/ml-spec';
 /**
  * Creates the `:aria()` extended pseudo-class handler.
  *
- * Matches elements by accessible name presence using `getAccname()`.
+ * Matches elements by accessible name presence.
  * Supports `has name` and `has no name` syntax.
  * Version syntax is parsed but not yet used for filtering.
  *
+ * ## Accessible name resolution strategy
+ *
+ * When the element exposes a `getAccessibleName()` method (i.e. it is an
+ * `MLElement` from `@markuplint/ml-core`), that method is called via
+ * duck-typing so that its per-element memoization cache is shared with
+ * other consumers (`require-accessible-name`, `wai-aria`, etc.).
+ *
+ * The `@markuplint/selector` package cannot depend on `@markuplint/ml-core`
+ * (it sits lower in the dependency graph), so a structural type check
+ * (`'getAccessibleName' in el`) is used instead of an `instanceof` guard.
+ *
+ * For elements that do **not** have the method (e.g. plain DOM `Element`
+ * instances in unit tests), the function falls back to the stateless
+ * `getAccname()` from `@markuplint/ml-spec`.
+ *
+ * @param specs - The ML specification data for role resolution
  * @returns An extended pseudo-class handler function
  */
-export declare function ariaPseudoClass(): (content: string) => (el: Element) => SelectorResult;
+export declare function ariaPseudoClass(specs: MLMLSpec): (content: string) => (el: SelectorElement) => SelectorResult;

package/lib/extended-selector/aria-pseudo-class.js

@@ -2,18 +2,41 @@ import { validateAriaVersion, ARIA_RECOMMENDED_VERSION, getAccname } from '@mark
 /**
  * Creates the `:aria()` extended pseudo-class handler.
  *
- * Matches elements by accessible name presence using `getAccname()`.
+ * Matches elements by accessible name presence.
  * Supports `has name` and `has no name` syntax.
  * Version syntax is parsed but not yet used for filtering.
  *
+ * ## Accessible name resolution strategy
+ *
+ * When the element exposes a `getAccessibleName()` method (i.e. it is an
+ * `MLElement` from `@markuplint/ml-core`), that method is called via
+ * duck-typing so that its per-element memoization cache is shared with
+ * other consumers (`require-accessible-name`, `wai-aria`, etc.).
+ *
+ * The `@markuplint/selector` package cannot depend on `@markuplint/ml-core`
+ * (it sits lower in the dependency graph), so a structural type check
+ * (`'getAccessibleName' in el`) is used instead of an `instanceof` guard.
+ *
+ * For elements that do **not** have the method (e.g. plain DOM `Element`
+ * instances in unit tests), the function falls back to the stateless
+ * `getAccname()` from `@markuplint/ml-spec`.
+ *
+ * @param specs - The ML specification data for role resolution
  * @returns An extended pseudo-class handler function
  */
-export function ariaPseudoClass() {
+export function ariaPseudoClass(specs) {
     return (content) => (
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     el) => {
         const aria = ariaPseudoClassParser(content);
-        const name = getAccname(el);
+        const version = aria.version ?? ARIA_RECOMMENDED_VERSION;
+        // Prefer MLElement.getAccessibleName() (cached) over ml-spec's
+        // stateless getAccname(). The duck-typing check is necessary because
+        // SelectorElement is an interface that does not declare
+        // getAccessibleName — the concrete MLElement adds it at runtime.
+        const name = 'getAccessibleName' in el && typeof el.getAccessibleName === 'function'
+            ? el.getAccessibleName(version)
+            : getAccname(el, specs, version);
         switch (aria.type) {
             case 'hasName': {
                 if (name) {
@@ -48,7 +71,7 @@ export function ariaPseudoClass() {
 }
 function ariaPseudoClassParser(syntax) {
     const [_query, _version] = syntax.split('|');
-    const query = _query?.replace(/\s+/g, '').toLowerCase();
+    const query = _query?.replaceAll(/\s+/g, '').toLowerCase();
     const version = _version ?? ARIA_RECOMMENDED_VERSION;
     if (!validateAriaVersion(version)) {
         throw new SyntaxError(`Unsupported ARIA version: ${version}`);

package/lib/extended-selector/aria-role-pseudo-class.d.ts

@@ -1,4 +1,4 @@
-import type { SelectorResult } from '../types.js';
+import type { SelectorElement, SelectorResult } from '../types.js';
 import type { MLMLSpec } from '@markuplint/ml-spec';
 /**
  * Creates the `:role()` extended pseudo-class handler.
@@ -9,4 +9,4 @@ import type { MLMLSpec } from '@markuplint/ml-spec';
  * @param specs - The HTML/ARIA specification data used for role computation
  * @returns An extended pseudo-class handler function
  */
-export declare function ariaRolePseudoClass(specs: MLMLSpec): (content: string) => (el: Element) => SelectorResult;
+export declare function ariaRolePseudoClass(specs: MLMLSpec): (content: string) => (el: SelectorElement) => SelectorResult;

package/lib/extended-selector/content-model-pseudo-class.d.ts

@@ -1,4 +1,4 @@
-import type { SelectorResult } from '../types.js';
+import type { SelectorElement, SelectorResult } from '../types.js';
 import type { MLMLSpec } from '@markuplint/ml-spec';
 /**
  * Creates the `:model()` extended pseudo-class handler.
@@ -9,4 +9,4 @@ import type { MLMLSpec } from '@markuplint/ml-spec';
  * @param specs - The HTML/ARIA specification data containing content model definitions
  * @returns An extended pseudo-class handler function
  */
-export declare function contentModelPseudoClass(specs: MLMLSpec): (category: string) => (el: Element) => SelectorResult;
+export declare function contentModelPseudoClass(specs: MLMLSpec): (category: string) => (el: SelectorElement) => SelectorResult;

package/lib/index.d.ts

@@ -1,5 +1,8 @@
 export { compareSpecificity } from './compare-specificity.js';
-export { matchSelector, SelectorMatches } from './match-selector.js';
+export { matchSelector } from './match-selector.js';
+export type { SelectorMatches } from './match-selector.js';
 export { createSelector } from './create-selector.js';
+export { Selector } from './selector.js';
+export type { ExtendedPseudoClass } from './selector.js';
 export { InvalidSelectorError } from './invalid-selector-error.js';
-export * from './types.js';
+export type * from './types.js';

package/lib/index.js

@@ -1,5 +1,5 @@
 export { compareSpecificity } from './compare-specificity.js';
 export { matchSelector } from './match-selector.js';
 export { createSelector } from './create-selector.js';
+export { Selector } from './selector.js';
 export { InvalidSelectorError } from './invalid-selector-error.js';
-export * from './types.js';

package/lib/invalid-selector-error.js

@@ -2,13 +2,15 @@
  * Error thrown when a CSS selector string cannot be parsed.
  */
 export class InvalidSelectorError extends Error {
+    name = 'InvalidSelectorError';
+    /** The invalid selector string that caused this error */
+    selector;
     /**
      * @param selector - The invalid selector string
      * @param message - An optional custom error message
      */
     constructor(selector, message) {
         super(message ?? `Invalid selector: "${selector}"`);
-        this.name = 'InvalidSelectorError';
         this.selector = selector;
     }
 }

package/lib/is.d.ts

@@ -1,25 +1,26 @@
+import type { SelectorElement, SelectorNode } from './types.js';
 /**
  * Checks whether the given node is an Element node.
  *
- * @param node - The DOM node to check
+ * @param node - The node to check
  * @returns `true` if the node is an Element
  */
-export declare function isElement(node: Node): node is Element;
+export declare function isElement(node: SelectorNode): node is SelectorElement;
 /**
  * Checks whether the given node is a non-DocumentType child node
  * (i.e., has `previousElementSibling` and `nextElementSibling` properties).
  *
- * @param node - The DOM node to check
+ * @param node - The node to check
  * @returns `true` if the node is an Element or CharacterData
  */
-export declare function isNonDocumentTypeChildNode(node: Node): node is Element | CharacterData;
+export declare function isNonDocumentTypeChildNode(node: SelectorNode): node is SelectorElement;
 /**
  * Checks if the given element is a pure HTML element.
  *
  * If a pure HTML element, `localName` returns lowercase,
  * `nodeName` returns uppercase.
  *
- * @param el The element to check.
- * @returns Returns true if the element is a pure HTML element, otherwise returns false.
+ * @param el - The element to check
+ * @returns `true` if the element is a pure HTML element, `false` otherwise
  */
-export declare function isPureHTMLElement(el: Element): boolean;
+export declare function isPureHTMLElement(el: SelectorElement): boolean;

package/lib/is.js

@@ -1,24 +1,21 @@
+const ELEMENT_NODE = 1;
 /**
  * Checks whether the given node is an Element node.
  *
- * @param node - The DOM node to check
+ * @param node - The node to check
  * @returns `true` if the node is an Element
  */
-export function isElement(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node) {
-    return node.nodeType === node.ELEMENT_NODE;
+export function isElement(node) {
+    return node.nodeType === ELEMENT_NODE;
 }
 /**
  * Checks whether the given node is a non-DocumentType child node
  * (i.e., has `previousElementSibling` and `nextElementSibling` properties).
  *
- * @param node - The DOM node to check
+ * @param node - The node to check
  * @returns `true` if the node is an Element or CharacterData
  */
-export function isNonDocumentTypeChildNode(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node) {
+export function isNonDocumentTypeChildNode(node) {
     return 'previousElementSibling' in node && 'nextElementSibling' in node;
 }
 /**
@@ -27,8 +24,8 @@ node) {
  * If a pure HTML element, `localName` returns lowercase,
  * `nodeName` returns uppercase.
  *
- * @param el The element to check.
- * @returns Returns true if the element is a pure HTML element, otherwise returns false.
+ * @param el - The element to check
+ * @returns `true` if the element is a pure HTML element, `false` otherwise
  */
 export function isPureHTMLElement(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types

package/lib/match-selector.d.ts

@@ -1,4 +1,4 @@
-import type { Specificity, RegexSelector } from './types.js';
+import type { SelectorNode, Specificity, RegexSelector } from './types.js';
 import type { MLMLSpec } from '@markuplint/ml-spec';
 /**
  * The result of matching a selector against a node.
@@ -15,16 +15,16 @@ type SelectorUnmatched = {
     readonly matched: false;
 };
 /**
- * Matches a CSS selector or regex selector against a DOM node.
+ * Matches a CSS selector or regex selector against a node.
  *
  * Supports both standard CSS selectors (as strings) and markuplint's
  * {@link RegexSelector} for pattern-based matching with captured groups.
  *
- * @param el - The DOM node to test
+ * @param el - The node to test
  * @param selector - A CSS selector string, a regex selector object, or `undefined`
  * @param scope - The scope element for `:scope` pseudo-class resolution
  * @param specs - The HTML/ARIA specification data for extended pseudo-classes
  * @returns A match result with specificity and captured data, or `{ matched: false }`
  */
-export declare function matchSelector(el: Node, selector: string | RegexSelector | undefined, scope?: ParentNode | null, specs?: MLMLSpec): SelectorMatches;
+export declare function matchSelector(el: SelectorNode, selector: string | RegexSelector | undefined, scope?: SelectorNode | null, specs?: MLMLSpec): SelectorMatches;
 export {};

package/lib/match-selector.js

@@ -1,35 +1,19 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _SelectorTarget_combinedFrom, _SelectorTarget_selector;
 import { isElement, isNonDocumentTypeChildNode, isPureHTMLElement } from './is.js';
 import { regexSelectorMatches } from './regex-selector-matches.js';
 import { createSelector } from './create-selector.js';
 /**
- * Matches a CSS selector or regex selector against a DOM node.
+ * Matches a CSS selector or regex selector against a node.
  *
  * Supports both standard CSS selectors (as strings) and markuplint's
  * {@link RegexSelector} for pattern-based matching with captured groups.
  *
- * @param el - The DOM node to test
+ * @param el - The node to test
  * @param selector - A CSS selector string, a regex selector object, or `undefined`
  * @param scope - The scope element for `:scope` pseudo-class resolution
  * @param specs - The HTML/ARIA specification data for extended pseudo-classes
  * @returns A match result with specificity and captured data, or `{ matched: false }`
  */
-export function matchSelector(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-el, selector, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-scope, specs) {
+export function matchSelector(el, selector, scope, specs) {
     if (selector == null || selector === '') {
         return {
             matched: false,
@@ -51,9 +35,7 @@ scope, specs) {
     }
     return regexSelect(el, selector);
 }
-function regexSelect(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-el, selector) {
+function regexSelect(el, selector) {
     let edge = new SelectorTarget(selector);
     let edgeSelector = selector.combination;
     while (edgeSelector) {
@@ -65,28 +47,26 @@ el, selector) {
     return edge.match(el);
 }
 class SelectorTarget {
+    #combinedFrom = null;
+    #selector;
     constructor(selector) {
-        _SelectorTarget_combinedFrom.set(this, null);
-        _SelectorTarget_selector.set(this, void 0);
-        __classPrivateFieldSet(this, _SelectorTarget_selector, selector, "f");
+        this.#selector = selector;
     }
     from(target, combinator) {
-        __classPrivateFieldSet(this, _SelectorTarget_combinedFrom, { target, combinator }, "f");
+        this.#combinedFrom = { target, combinator };
     }
-    match(
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    el) {
+    match(el) {
         const unitCheck = this._matchWithoutCombineChecking(el);
         if (!unitCheck.matched) {
             return unitCheck;
         }
-        if (!__classPrivateFieldGet(this, _SelectorTarget_combinedFrom, "f")) {
+        if (!this.#combinedFrom) {
             return unitCheck;
         }
         if (!isNonDocumentTypeChildNode(el)) {
             return unitCheck;
         }
-        const { target, combinator } = __classPrivateFieldGet(this, _SelectorTarget_combinedFrom, "f");
+        const { target, combinator } = this.#combinedFrom;
         switch (combinator) {
             // Descendant combinator
             case ' ': {
@@ -161,20 +141,15 @@ class SelectorTarget {
                 return { matched: false };
             }
             default: {
-                throw new Error(`Unsupported ${__classPrivateFieldGet(this, _SelectorTarget_combinedFrom, "f").combinator} combinator in selector`);
+                throw new Error(`Unsupported ${this.#combinedFrom.combinator} combinator in selector`);
             }
         }
     }
-    _matchWithoutCombineChecking(
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    el) {
-        return uncombinedRegexSelect(el, __classPrivateFieldGet(this, _SelectorTarget_selector, "f"));
+    _matchWithoutCombineChecking(el) {
+        return uncombinedRegexSelect(el, this.#selector);
     }
 }
-_SelectorTarget_combinedFrom = new WeakMap(), _SelectorTarget_selector = new WeakMap();
-function uncombinedRegexSelect(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-el, selector) {
+function uncombinedRegexSelect(el, selector) {
     if (!isElement(el)) {
         return {
             matched: false,
@@ -239,13 +214,13 @@ el, selector) {
     specificity[1] += specifiedAttr.size;
     if (matched) {
         return {
-            matched,
+            matched: true,
             selector: `${tagSelector}${attrSelector}`,
             specificity,
             data,
         };
     }
-    return { matched };
+    return { matched: false };
 }
 function mergeMatches(a, b, sep, close = false) {
     return {

package/lib/selector.d.ts

@@ -1,14 +1,39 @@
-import type { SelectorResult, Specificity } from './types.js';
-type ExtendedPseudoClass = Readonly<Record<string, (content: string) => (el: Element) => SelectorResult>>;
+import type { SelectorElement, SelectorNode, SelectorResult, Specificity } from './types.js';
 /**
- * CSS selector matcher that parses a selector string and matches it against DOM nodes.
+ * Registry of extended pseudo-class handlers keyed by pseudo-class name.
+ *
+ * Each handler is a curried function: given the pseudo-class content string,
+ * it returns a matcher that tests a {@link SelectorElement} and produces
+ * a {@link SelectorResult}.
+ */
+export type ExtendedPseudoClass = Readonly<Record<string, (content: string) => (el: SelectorElement) => SelectorResult>>;
+/**
+ * CSS selector matcher that parses a selector string and matches it against nodes.
  *
  * Use {@link createSelector} to create cached instances with extended pseudo-class support.
  */
 export declare class Selector {
     #private;
+    /**
+     * @param selector - The CSS selector string to parse
+     * @param extended - Extended pseudo-class handlers to register
+     */
     constructor(selector: string, extended?: ExtendedPseudoClass);
-    match(el: Node, scope?: ParentNode | null): Specificity | false;
-    search(el: Node, scope?: ParentNode | null): SelectorResult[];
+    /**
+     * Tests whether the given node matches this selector.
+     *
+     * @param el - The node to test
+     * @param scope - The scope node for `:scope` pseudo-class resolution
+     * @returns The specificity of the first matching selector, or `false` if none matched
+     */
+    match(el: SelectorNode, scope?: SelectorNode | null): Specificity | false;
+    /**
+     * Evaluates all comma-separated selectors against the given node
+     * and returns each result (matched or unmatched).
+     *
+     * @param el - The node to test
+     * @param scope - The scope node for `:scope` pseudo-class resolution
+     * @returns An array of results, one per comma-separated selector alternative
+     */
+    search(el: SelectorNode, scope?: SelectorNode | null): SelectorResult[];
 }
-export {};

package/lib/selector.js

@@ -1,15 +1,3 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Selector_ruleset, _Ruleset_selectorGroup, _StructuredSelector_edge, _StructuredSelector_selector, _SelectorTarget_combinedFrom, _SelectorTarget_extended, _SelectorTarget_isAdded;
 import { resolveNamespace } from '@markuplint/ml-spec';
 import parser from 'postcss-selector-parser';
 import { compareSpecificity } from './compare-specificity.js';
@@ -19,20 +7,27 @@ import { isElement, isNonDocumentTypeChildNode, isPureHTMLElement } from './is.j
 const selLog = coreLog.extend('selector');
 const resLog = coreLog.extend('result');
 /**
- * CSS selector matcher that parses a selector string and matches it against DOM nodes.
+ * CSS selector matcher that parses a selector string and matches it against nodes.
  *
  * Use {@link createSelector} to create cached instances with extended pseudo-class support.
  */
 export class Selector {
+    #ruleset;
+    /**
+     * @param selector - The CSS selector string to parse
+     * @param extended - Extended pseudo-class handlers to register
+     */
     constructor(selector, extended = {}) {
-        _Selector_ruleset.set(this, void 0);
-        __classPrivateFieldSet(this, _Selector_ruleset, Ruleset.parse(selector, extended), "f");
+        this.#ruleset = Ruleset.parse(selector, extended);
     }
-    match(
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    el, 
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    scope) {
+    /**
+     * Tests whether the given node matches this selector.
+     *
+     * @param el - The node to test
+     * @param scope - The scope node for `:scope` pseudo-class resolution
+     * @returns The specificity of the first matching selector, or `false` if none matched
+     */
+    match(el, scope) {
         scope = scope ?? (isElement(el) ? el : null);
         const results = this.search(el, scope);
         for (const result of results) {
@@ -42,16 +37,19 @@ export class Selector {
         }
         return false;
     }
-    search(
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    el, 
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    scope) {
+    /**
+     * Evaluates all comma-separated selectors against the given node
+     * and returns each result (matched or unmatched).
+     *
+     * @param el - The node to test
+     * @param scope - The scope node for `:scope` pseudo-class resolution
+     * @returns An array of results, one per comma-separated selector alternative
+     */
+    search(el, scope) {
         scope = scope ?? (isElement(el) ? el : null);
-        return __classPrivateFieldGet(this, _Selector_ruleset, "f").match(el, scope);
+        return this.#ruleset.match(el, scope);
     }
 }
-_Selector_ruleset = new WeakMap();
 class Ruleset {
     static parse(selector, extended) {
         const selectors = [];
@@ -68,27 +66,24 @@ class Ruleset {
         }
         return new Ruleset(selectors, extended, 0);
     }
+    headCombinator;
+    #selectorGroup = [];
     constructor(selectors, extended, depth) {
-        _Ruleset_selectorGroup.set(this, []);
-        __classPrivateFieldGet(this, _Ruleset_selectorGroup, "f").push(...selectors.map(selector => new StructuredSelector(selector, depth, extended)));
-        const head = __classPrivateFieldGet(this, _Ruleset_selectorGroup, "f")[0];
+        this.#selectorGroup.push(...selectors.map(selector => new StructuredSelector(selector, depth, extended)));
+        const head = this.#selectorGroup[0];
         this.headCombinator = head?.headCombinator ?? null;
         if (this.headCombinator && depth <= 0) {
-            if (__classPrivateFieldGet(this, _Ruleset_selectorGroup, "f")[0]?.selector) {
-                throw new InvalidSelectorError(__classPrivateFieldGet(this, _Ruleset_selectorGroup, "f")[0]?.selector);
+            if (this.#selectorGroup[0]?.selector) {
+                throw new InvalidSelectorError(this.#selectorGroup[0]?.selector);
             }
             throw new Error('Combinated selector depth is not expected');
         }
     }
-    match(
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    el, 
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    scope) {
+    match(el, scope) {
         if (coreLog.enabled) {
             coreLog('<%s> (%s)', isElement(el) ? el.localName : el.nodeName, scope ? (isElement(scope) ? scope.localName : scope.nodeName) : null);
         }
-        return __classPrivateFieldGet(this, _Ruleset_selectorGroup, "f").map(selector => {
+        return this.#selectorGroup.map(selector => {
             if (selLog.enabled) {
                 selLog('"%s"', selector.selector);
             }
@@ -100,16 +95,16 @@ class Ruleset {
         });
     }
 }
-_Ruleset_selectorGroup = new WeakMap();
 class StructuredSelector {
+    #edge;
+    headCombinator;
+    #selector;
     constructor(selector, depth, extended) {
-        _StructuredSelector_edge.set(this, void 0);
-        _StructuredSelector_selector.set(this, void 0);
-        __classPrivateFieldSet(this, _StructuredSelector_selector, selector, "f");
-        __classPrivateFieldSet(this, _StructuredSelector_edge, new SelectorTarget(extended, depth), "f");
+        this.#selector = selector;
+        this.#edge = new SelectorTarget(extended, depth);
         this.headCombinator =
-            __classPrivateFieldGet(this, _StructuredSelector_selector, "f").nodes[0]?.type === 'combinator' ? (__classPrivateFieldGet(this, _StructuredSelector_selector, "f").nodes[0].value ?? null) : null;
-        const nodes = [...__classPrivateFieldGet(this, _StructuredSelector_selector, "f").nodes];
+            this.#selector.nodes[0]?.type === 'combinator' ? (this.#selector.nodes[0].value ?? null) : null;
+        const nodes = [...this.#selector.nodes];
         if (0 < depth && this.headCombinator) {
             nodes.unshift(parser.pseudo({ value: ':scope' }));
         }
@@ -117,8 +112,8 @@ class StructuredSelector {
             switch (node.type) {
                 case 'combinator': {
                     const combinedTarget = new SelectorTarget(extended, depth);
-                    combinedTarget.from(__classPrivateFieldGet(this, _StructuredSelector_edge, "f"), node);
-                    __classPrivateFieldSet(this, _StructuredSelector_edge, combinedTarget, "f");
+                    combinedTarget.from(this.#edge, node);
+                    this.#edge = combinedTarget;
                     break;
                 }
                 case 'root':
@@ -132,38 +127,34 @@ class StructuredSelector {
                     throw new Error(`Unsupported comment in selector: ${selector.toString()}`);
                 }
                 default: {
-                    __classPrivateFieldGet(this, _StructuredSelector_edge, "f").add(node);
+                    this.#edge.add(node);
                 }
             }
         }
     }
     get selector() {
-        return __classPrivateFieldGet(this, _StructuredSelector_selector, "f").nodes.join('');
+        return this.#selector.nodes.join('');
     }
-    match(
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    el, 
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    scope) {
-        return __classPrivateFieldGet(this, _StructuredSelector_edge, "f").match(el, scope, 0);
+    match(el, scope) {
+        return this.#edge.match(el, scope, 0);
     }
 }
-_StructuredSelector_edge = new WeakMap(), _StructuredSelector_selector = new WeakMap();
 class SelectorTarget {
+    attr = [];
+    class = [];
+    #combinedFrom = null;
+    depth;
+    #extended;
+    id = [];
+    #isAdded = false;
+    pseudo = [];
+    tag = null;
     constructor(extended, depth) {
-        this.attr = [];
-        this.class = [];
-        _SelectorTarget_combinedFrom.set(this, null);
-        _SelectorTarget_extended.set(this, void 0);
-        this.id = [];
-        _SelectorTarget_isAdded.set(this, false);
-        this.pseudo = [];
-        this.tag = null;
-        __classPrivateFieldSet(this, _SelectorTarget_extended, extended, "f");
+        this.#extended = extended;
         this.depth = depth;
     }
     add(selector) {
-        __classPrivateFieldSet(this, _SelectorTarget_isAdded, true, "f");
+        this.#isAdded = true;
         switch (selector.type) {
             case 'tag':
             case 'universal': {
@@ -189,17 +180,13 @@ class SelectorTarget {
         }
     }
     from(target, combinator) {
-        __classPrivateFieldSet(this, _SelectorTarget_combinedFrom, { target, combinator }, "f");
+        this.#combinedFrom = { target, combinator };
     }
-    match(
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    el, 
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    scope, count) {
+    match(el, scope, count) {
         const result = this._match(el, scope, count);
         if (selLog.enabled) {
             const nodeName = el.nodeName;
-            const selector = __classPrivateFieldGet(this, _SelectorTarget_combinedFrom, "f")?.target.toString() ?? this.toString();
+            const selector = this.#combinedFrom?.target.toString() ?? this.toString();
             const combinator = result.combinator ? ` ${result.combinator}` : '';
             selLog('The %s element by "%s" => %s (%d)', nodeName, `${selector}${combinator}`, result.matched, count);
             if (selector === ':scope') {
@@ -218,22 +205,18 @@ class SelectorTarget {
             this.pseudo.map(pseudo => pseudo.value).join(''),
         ].join('');
     }
-    _match(
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    el, 
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    scope, count) {
+    _match(el, scope, count) {
         const unitCheck = this._matchWithoutCombineChecking(el, scope);
         if (!unitCheck.matched) {
             return unitCheck;
         }
-        if (!__classPrivateFieldGet(this, _SelectorTarget_combinedFrom, "f")) {
+        if (!this.#combinedFrom) {
             return unitCheck;
         }
         if (!isNonDocumentTypeChildNode(el)) {
             return unitCheck;
         }
-        const { target, combinator } = __classPrivateFieldGet(this, _SelectorTarget_combinedFrom, "f");
+        const { target, combinator } = this.#combinedFrom;
         switch (combinator.value) {
             // Descendant combinator
             case ' ': {
@@ -429,7 +412,7 @@ class SelectorTarget {
                 throw new Error('Unsupported column combinator yet. If you want it, please request it as the issue (https://github.com/markuplint/markuplint/issues/new).');
             }
             default: {
-                throw new Error(`Unsupported ${__classPrivateFieldGet(this, _SelectorTarget_combinedFrom, "f").combinator.value} combinator in selector`);
+                throw new Error(`Unsupported ${this.#combinedFrom.combinator.value} combinator in selector`);
             }
         }
     }
@@ -441,11 +424,7 @@ class SelectorTarget {
      * @param scope
      * @private
      */
-    _matchWithoutCombineChecking(
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    el, 
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    scope) {
+    _matchWithoutCombineChecking(el, scope) {
         const specificity = [0, 0, 0];
         if (!isElement(el)) {
             return {
@@ -477,7 +456,7 @@ class SelectorTarget {
             }
         }
         let matched = true;
-        if (!__classPrivateFieldGet(this, _SelectorTarget_isAdded, "f") && !isScope(el, scope)) {
+        if (!this.#isAdded && !isScope(el, scope)) {
             matched = false;
         }
         if (matched && !this.id.every(id => id.value === el.id)) {
@@ -506,7 +485,7 @@ class SelectorTarget {
         specificity[1] += this.attr.length;
         if (matched) {
             for (const pseudo of this.pseudo) {
-                const pseudoRes = pseudoMatch(pseudo, el, scope, __classPrivateFieldGet(this, _SelectorTarget_extended, "f"), this.depth);
+                const pseudoRes = pseudoMatch(pseudo, el, scope, this.#extended, this.depth);
                 specificity[0] += pseudoRes.specificity[0];
                 specificity[1] += pseudoRes.specificity[1];
                 specificity[2] += pseudoRes.specificity[2];
@@ -522,19 +501,18 @@ class SelectorTarget {
         if (matched) {
             return {
                 specificity,
-                matched,
+                matched: true,
                 nodes: [el],
                 has,
             };
         }
         return {
             specificity,
-            matched,
+            matched: false,
             not,
         };
     }
 }
-_SelectorTarget_combinedFrom = new WeakMap(), _SelectorTarget_extended = new WeakMap(), _SelectorTarget_isAdded = new WeakMap();
 function attrMatch(attr, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el) {
@@ -599,9 +577,7 @@ el) {
 }
 function pseudoMatch(pseudo, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-el, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-scope, extended, depth) {
+el, scope, extended, depth) {
     switch (pseudo.value) {
         //
         /**
@@ -808,9 +784,7 @@ scope, extended, depth) {
 }
 function isScope(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-el, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-scope) {
+el, scope) {
     return el === scope || el.parentNode === null;
 }
 function getDescendants(

package/lib/types.d.ts

@@ -1,3 +1,49 @@
+/**
+ * Minimal attribute representation for selector matching.
+ * Pure data — no methods, no class instances.
+ *
+ * In Rust this maps directly to a struct.
+ */
+export interface SelectorAttr {
+    readonly name: string;
+    readonly localName: string;
+    readonly value: string;
+    readonly namespaceURI: string | null;
+}
+/**
+ * Minimal node representation for selector matching.
+ * Pure data with tree-navigation references.
+ *
+ * In Rust this maps to a trait backed by arena indices.
+ */
+export interface SelectorNode {
+    readonly nodeType: number;
+    readonly nodeName: string;
+    readonly parentNode: SelectorNode | null;
+}
+/**
+ * Minimal element representation for CSS selector matching.
+ * Captures **only** the properties the selector engine actually reads.
+ *
+ * DOM `Element` and `MLElement` both satisfy this interface,
+ * but plain objects can satisfy it too — enabling Rust interop
+ * and unit-testing without a full DOM.
+ *
+ * In Rust this maps to a struct + trait.
+ */
+export interface SelectorElement extends SelectorNode {
+    readonly localName: string;
+    readonly id: string;
+    readonly namespaceURI: string | null;
+    readonly classList: {
+        contains(className: string): boolean;
+    };
+    readonly attributes: Iterable<SelectorAttr>;
+    readonly parentElement: SelectorElement | null;
+    readonly previousElementSibling: SelectorElement | null;
+    readonly nextElementSibling: SelectorElement | null;
+    readonly children: Iterable<SelectorElement>;
+}
 /**
  * A CSS specificity tuple: `[id, class, type]`.
  * Each component counts selectors of the corresponding category.
@@ -15,8 +61,8 @@ export type SelectorMatchedResult = {
     /** The computed specificity of the matched selector */
     readonly specificity: Specificity;
     readonly matched: true;
-    /** The DOM nodes that were matched */
-    readonly nodes: readonly (Element | Text)[];
+    /** The elements that were matched */
+    readonly nodes: readonly SelectorElement[];
     /** Results from `:has()` pseudo-class sub-matches */
     readonly has: readonly SelectorMatchedResult[];
 };

package/package.json

@@ -1,10 +1,13 @@
 {
 	"name": "@markuplint/selector",
-	"version": "4.7.8",
+	"version": "5.0.0-alpha.0",
 	"description": "Extended W3C Selectors matcher",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
+	"engines": {
+		"node": ">=22"
+	},
 	"type": "module",
 	"exports": {
 		".": {
@@ -24,15 +27,15 @@
 		"clean": "tsc --build --clean tsconfig.build.json"
 	},
 	"dependencies": {
-		"@markuplint/ml-spec": "4.10.2",
+		"@markuplint/ml-spec": "5.0.0-alpha.0",
 		"@types/debug": "4.1.12",
 		"debug": "4.4.3",
 		"postcss-selector-parser": "7.1.1",
-		"type-fest": "4.41.0"
+		"type-fest": "5.4.4"
 	},
 	"devDependencies": {
 		"@types/jsdom": "27.0.0",
-		"jsdom": "26.1.0"
+		"jsdom": "28.1.0"
 	},
-	"gitHead": "193ee7c1262bbed95424e38efdf1a8e56ff049f4"
+	"gitHead": "13dcfc84ec83d87360c720e253383b60767e1b56"
 }