@markuplint/parser-utils 4.8.10 → 5.0.0-alpha.0

package/lib/parser.js

@@ -1,17 +1,5 @@
-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 __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 _Parser_instances, _Parser_booleanish, _Parser_defaultState, _Parser_endTagType, _Parser_ignoreTags, _Parser_maskChar, _Parser_tagNameCaseSensitive, _Parser_selfCloseType, _Parser_spaceChars, _Parser_rawTextElements, _Parser_authoredElementName, _Parser_originalRawCode, _Parser_rawCode, _Parser_defaultDepth, _Parser_walkMethodSequentailPrevNode, _Parser_arrayize, _Parser_concatText, _Parser_concatTextNodes, _Parser_convertIntoInvalidNode, _Parser_createOffsetSpaces, _Parser_createRemnantNode, _Parser_exposeRemnantNodes, _Parser_getEndLocation, _Parser_orphanEndTagToBogusMark, _Parser_pairing, _Parser_parseEndTag, _Parser_parseStartTag, _Parser_parseTag, _Parser_removeChild, _Parser_removeDeprecatedNode, _Parser_removeOffsetSpaces, _Parser_reset, _Parser_setRawCode, _Parser_trimText;
+import { randomUUID } from 'node:crypto';
 import { isVoidElement as detectVoidElement } from '@markuplint/ml-spec';
-import { v4 as uuid } from 'uuid';
 import { attrTokenizer } from './attr-tokenizer.js';
 import { defaultSpaces } from './const.js';
 import { domLog, PerformanceTimer } from './debug.js';
@@ -22,37 +10,57 @@ import { ignoreBlock, restoreNode } from './ignore-block.js';
 import { ignoreFrontMatter } from './ignore-front-matter.js';
 import { ParserError } from './parser-error.js';
 import { sortNodes } from './sort-nodes.js';
+import { getNamespace } from './get-namespace.js';
 const timer = new PerformanceTimer();
+/**
+ * Abstract base class for all markuplint parsers. Provides the core parsing pipeline
+ * including tokenization, tree traversal, node flattening, and error handling.
+ * Subclasses must implement `nodeize` to convert language-specific AST nodes
+ * into the markuplint AST format.
+ *
+ * @template Node - The language-specific AST node type produced by the tokenizer
+ * @template State - An optional parser state type that persists across tokenization
+ */
 export class Parser {
+    #booleanish = false;
+    #defaultState;
+    #endTagType = 'omittable';
+    #ignoreTags = [];
+    #maskChar;
+    #tagNameCaseSensitive = false;
+    #selfCloseType = 'html';
+    #spaceChars = defaultSpaces;
+    #rawTextElements = ['style', 'script'];
+    #authoredElementName;
+    #originalRawCode = '';
+    #rawCode = '';
+    #defaultDepth = 0;
+    #walkMethodSequentailPrevNode = null;
+    state;
+    /**
+     * Creates a new Parser instance with the given options and initial state.
+     *
+     * @param options - Configuration options controlling tag handling, whitespace, and quoting behavior
+     * @param defaultState - The initial parser state, cloned and restored after each parse call
+     */
     constructor(options, defaultState) {
-        _Parser_instances.add(this);
-        _Parser_booleanish.set(this, false);
-        _Parser_defaultState.set(this, void 0);
-        _Parser_endTagType.set(this, 'omittable');
-        _Parser_ignoreTags.set(this, []);
-        _Parser_maskChar.set(this, void 0);
-        _Parser_tagNameCaseSensitive.set(this, false);
-        _Parser_selfCloseType.set(this, 'html');
-        _Parser_spaceChars.set(this, defaultSpaces);
-        _Parser_rawTextElements.set(this, ['style', 'script']);
-        _Parser_authoredElementName.set(this, void 0);
-        _Parser_originalRawCode.set(this, '');
-        _Parser_rawCode.set(this, '');
-        _Parser_defaultDepth.set(this, 0);
-        _Parser_walkMethodSequentailPrevNode.set(this, null);
-        __classPrivateFieldSet(this, _Parser_booleanish, options?.booleanish ?? __classPrivateFieldGet(this, _Parser_booleanish, "f"), "f");
-        __classPrivateFieldSet(this, _Parser_endTagType, options?.endTagType ?? __classPrivateFieldGet(this, _Parser_endTagType, "f"), "f");
-        __classPrivateFieldSet(this, _Parser_ignoreTags, options?.ignoreTags ?? __classPrivateFieldGet(this, _Parser_ignoreTags, "f"), "f");
-        __classPrivateFieldSet(this, _Parser_maskChar, options?.maskChar ?? __classPrivateFieldGet(this, _Parser_maskChar, "f"), "f");
-        __classPrivateFieldSet(this, _Parser_tagNameCaseSensitive, options?.tagNameCaseSensitive ?? __classPrivateFieldGet(this, _Parser_tagNameCaseSensitive, "f"), "f");
-        __classPrivateFieldSet(this, _Parser_selfCloseType, options?.selfCloseType ?? __classPrivateFieldGet(this, _Parser_selfCloseType, "f"), "f");
-        __classPrivateFieldSet(this, _Parser_spaceChars, options?.spaceChars ?? __classPrivateFieldGet(this, _Parser_spaceChars, "f"), "f");
-        __classPrivateFieldSet(this, _Parser_rawTextElements, options?.rawTextElements ?? __classPrivateFieldGet(this, _Parser_rawTextElements, "f"), "f");
-        __classPrivateFieldSet(this, _Parser_defaultState, defaultState ?? null, "f");
-        this.state = structuredClone(__classPrivateFieldGet(this, _Parser_defaultState, "f"));
+        this.#booleanish = options?.booleanish ?? this.#booleanish;
+        this.#endTagType = options?.endTagType ?? this.#endTagType;
+        this.#ignoreTags = options?.ignoreTags ?? this.#ignoreTags;
+        this.#maskChar = options?.maskChar ?? this.#maskChar;
+        this.#tagNameCaseSensitive = options?.tagNameCaseSensitive ?? this.#tagNameCaseSensitive;
+        this.#selfCloseType = options?.selfCloseType ?? this.#selfCloseType;
+        this.#spaceChars = options?.spaceChars ?? this.#spaceChars;
+        this.#rawTextElements = options?.rawTextElements ?? this.#rawTextElements;
+        this.#defaultState = defaultState ?? null;
+        this.state = structuredClone(this.#defaultState);
     }
+    /**
+     * The pattern used to distinguish authored (component) element names
+     * from native HTML elements, as specified by the parse options.
+     */
     get authoredElementName() {
-        return __classPrivateFieldGet(this, _Parser_authoredElementName, "f");
+        return this.#authoredElementName;
     }
     /**
      * Detect value as a true if its attribute is booleanish value and omitted.
@@ -65,7 +73,7 @@ export class Parser {
      * In the above, the `aria-hidden` is `true`.
      */
     get booleanish() {
-        return __classPrivateFieldGet(this, _Parser_booleanish, "f");
+        return this.#booleanish;
     }
     /**
      * The end tag omittable type.
@@ -75,50 +83,83 @@ export class Parser {
      * - `"never"`: Never need
      */
     get endTag() {
-        return __classPrivateFieldGet(this, _Parser_endTagType, "f");
+        return this.#endTagType;
     }
+    /**
+     * The current raw source code being parsed, which may have been
+     * preprocessed (e.g., ignore blocks masked, front matter removed).
+     */
     get rawCode() {
-        return __classPrivateFieldGet(this, _Parser_rawCode, "f");
+        return this.#rawCode;
     }
+    /**
+     * Whether tag names should be compared in a case-sensitive manner.
+     * When false (the default), tag name comparisons are case-insensitive (HTML behavior).
+     */
     get tagNameCaseSensitive() {
-        return __classPrivateFieldGet(this, _Parser_tagNameCaseSensitive, "f");
+        return this.#tagNameCaseSensitive;
     }
+    /**
+     * Tokenizes the raw source code into language-specific AST nodes.
+     * Subclasses should override this method to provide actual tokenization logic.
+     *
+     * @param options - Parse options controlling offset, depth, and other parse-time settings
+     * @returns The tokenized result containing the AST node array and fragment flag
+     */
     tokenize(options) {
         return {
             ast: [],
             isFragment: false,
         };
     }
+    /**
+     * Hook called before parsing begins, allowing subclasses to preprocess
+     * the raw source code. The default implementation prepends offset spaces
+     * based on the parse options.
+     *
+     * @param rawCode - The raw source code about to be parsed
+     * @param options - Parse options that may specify offset positioning
+     * @returns The preprocessed source code to be used for tokenization
+     */
     beforeParse(rawCode, options) {
-        const spaces = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_createOffsetSpaces).call(this, options);
+        const spaces = this.#createOffsetSpaces(options);
         return spaces + rawCode;
     }
+    /**
+     * Parses raw source code through the full pipeline: preprocessing, tokenization,
+     * traversal, flattening, ignore-block restoration, and post-processing.
+     * Returns the complete markuplint AST document.
+     *
+     * @param rawCode - The raw source code to parse
+     * @param options - Parse options controlling offsets, depth, front matter, and authored element names
+     * @returns The parsed AST document containing the node list and fragment flag
+     */
     parse(rawCode, options) {
         try {
             // Initialize raw code
-            __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_setRawCode).call(this, rawCode, rawCode);
+            this.#setRawCode(rawCode, rawCode);
             timer.push('beforeParse');
             const beforeParsedCode = this.beforeParse(this.rawCode, options);
             // Override raw code
-            __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_setRawCode).call(this, beforeParsedCode);
-            __classPrivateFieldSet(this, _Parser_authoredElementName, options?.authoredElementName, "f");
+            this.#setRawCode(beforeParsedCode);
+            this.#authoredElementName = options?.authoredElementName;
             let frontMatter = null;
             if (options?.ignoreFrontMatter) {
                 timer.push('ignoreFrontMatter');
                 const fm = ignoreFrontMatter(this.rawCode);
-                __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_setRawCode).call(this, fm.code);
+                this.#setRawCode(fm.code);
                 frontMatter = fm.frontMatter;
             }
             timer.push('ignoreBlock');
-            const blocks = ignoreBlock(this.rawCode, __classPrivateFieldGet(this, _Parser_ignoreTags, "f"), __classPrivateFieldGet(this, _Parser_maskChar, "f"));
-            __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_setRawCode).call(this, blocks.replaced);
+            const blocks = ignoreBlock(this.rawCode, this.#ignoreTags, this.#maskChar);
+            this.#setRawCode(blocks.replaced);
             timer.push('tokenize');
             const tokenized = this.tokenize(options);
             const ast = tokenized.ast;
             const isFragment = tokenized.isFragment;
-            __classPrivateFieldSet(this, _Parser_defaultDepth, options?.depth ?? __classPrivateFieldGet(this, _Parser_defaultDepth, "f"), "f");
+            this.#defaultDepth = options?.depth ?? this.#defaultDepth;
             timer.push('traverse');
-            const traversed = this.traverse(ast, null, __classPrivateFieldGet(this, _Parser_defaultDepth, "f"));
+            const traversed = this.traverse(ast, null, this.#defaultDepth);
             timer.push('afterTraverse');
             const nodeTree = this.afterTraverse([...traversed.childNodes, ...traversed.siblings]);
             timer.push('flattenNodes');
@@ -157,7 +198,7 @@ export class Parser {
             }
             timer.log();
             domLog(nodeList);
-            __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_reset).call(this);
+            this.#reset();
             return {
                 raw: rawCode,
                 nodeList,
@@ -168,9 +209,25 @@ export class Parser {
             throw this.parseError(error);
         }
     }
+    /**
+     * Hook called after the main parse pipeline completes, allowing subclasses
+     * to perform final transformations on the node list. The default implementation
+     * removes any offset spaces that were prepended during preprocessing.
+     *
+     * @param nodeList - The fully parsed and flattened node list
+     * @param options - The parse options used for this parse invocation
+     * @returns The post-processed node list
+     */
     afterParse(nodeList, options) {
-        return __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_removeOffsetSpaces).call(this, nodeList, options);
+        return this.#removeOffsetSpaces(nodeList, options);
     }
+    /**
+     * Wraps an arbitrary error into a ParserError with source location information.
+     * Extracts line and column numbers from common error formats.
+     *
+     * @param error - The original error to wrap
+     * @returns A ParserError containing the original error's message and location data
+     */
     parseError(error) {
         return new ParserError(error, {
             line: error.line ?? error.lineNumber ?? 0,
@@ -179,6 +236,15 @@ export class Parser {
             stack: error.stack,
         });
     }
+    /**
+     * Recursively traverses language-specific AST nodes by calling `nodeize` on each,
+     * filtering duplicates, and separating child nodes from ancestor-level siblings.
+     *
+     * @param originNodes - The language-specific AST nodes to traverse
+     * @param parentNode - The parent markuplint AST node, or null for top-level nodes
+     * @param depth - The current nesting depth in the tree
+     * @returns An object containing `childNodes` at the current depth and `siblings` that belong to ancestor levels
+     */
     traverse(originNodes, parentNode = null, depth) {
         if (originNodes.length === 0) {
             return {
@@ -195,7 +261,7 @@ export class Parser {
             const filteredNodes = [];
             for (const node of nodes) {
                 // Remove duplicated nodes
-                const id = `${node.startOffset}:${node.endOffset}:${node.nodeName}:${node.type}:${node.raw}`;
+                const id = `${node.offset}:${node.offset + node.raw.length}:${node.nodeName}:${node.type}:${node.raw}`;
                 if (existence.has(id)) {
                     continue;
                 }
@@ -212,15 +278,39 @@ export class Parser {
             siblings,
         };
     }
+    /**
+     * Hook called after traversal completes, used to sort the resulting node tree
+     * by source position. Subclasses may override for custom post-traversal logic.
+     *
+     * @param nodeTree - The unsorted node tree produced by traversal
+     * @returns The node tree sorted by source position
+     */
     afterTraverse(nodeTree) {
-        return Array.prototype.toSorted == null
-            ? // TODO: Use sort instead of toSorted until we end support for Node 18
-                [...nodeTree].sort(sortNodes)
-            : nodeTree.toSorted(sortNodes);
+        return nodeTree.toSorted(sortNodes);
     }
+    /**
+     * Converts a single language-specific AST node into one or more markuplint AST nodes.
+     * Subclasses must override this method to provide actual node conversion logic
+     * using visitor methods like `visitElement`, `visitText`, `visitComment`, etc.
+     *
+     * @param originNode - The language-specific AST node to convert
+     * @param parentNode - The parent markuplint AST node, or null for top-level nodes
+     * @param depth - The current nesting depth in the tree
+     * @returns An array of markuplint AST nodes produced from the origin node
+     */
     nodeize(originNode, parentNode, depth) {
         return [];
     }
+    /**
+     * Post-processes the nodes produced by `nodeize`, separating them into siblings
+     * at the current depth and ancestors that belong to a shallower depth level.
+     * Doctype nodes at depth 0 are promoted to ancestors.
+     *
+     * @param siblings - The nodes produced by `nodeize` for a single origin node
+     * @param parentNode - The parent markuplint AST node, or null for top-level nodes
+     * @param depth - The current nesting depth
+     * @returns An object with `siblings` at the current depth and `ancestors` at shallower depths
+     */
     afterNodeize(siblings, parentNode, depth) {
         const newSiblings = [];
         const ancestors = [];
@@ -246,21 +336,44 @@ export class Parser {
             ancestors,
         };
     }
+    /**
+     * Flattens a hierarchical node tree into a flat, sorted list by walking
+     * the tree depth-first and removing duplicated nodes.
+     *
+     * @param nodeTree - The hierarchical node tree to flatten
+     * @returns A flat array of all nodes in source order
+     */
     flattenNodes(nodeTree) {
-        return __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_arrayize).call(this, nodeTree);
+        return this.#arrayize(nodeTree);
     }
+    /**
+     * Post-processes the flattened node list by exposing remnant whitespace and
+     * invalid nodes between known nodes, converting orphan end tags to bogus markers,
+     * concatenating adjacent text nodes, and trimming overlapping text.
+     *
+     * @param nodeList - The flat node list to post-process
+     * @param options - Controls which post-processing steps are applied
+     * @returns The cleaned-up flat node list
+     */
     afterFlattenNodes(nodeList, options) {
         const exposeInvalidNode = options?.exposeInvalidNode ?? true;
         const exposeWhiteSpace = options?.exposeWhiteSpace ?? true;
         const concatText = options?.concatText ?? true;
-        nodeList = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_exposeRemnantNodes).call(this, nodeList, exposeInvalidNode, exposeWhiteSpace);
-        nodeList = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_orphanEndTagToBogusMark).call(this, nodeList);
+        nodeList = this.#exposeRemnantNodes(nodeList, exposeInvalidNode, exposeWhiteSpace);
+        nodeList = this.#orphanEndTagToBogusMark(nodeList);
         if (concatText) {
-            nodeList = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_concatText).call(this, nodeList);
+            nodeList = this.#concatText(nodeList);
         }
-        nodeList = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_trimText).call(this, nodeList);
+        nodeList = this.#trimText(nodeList);
         return nodeList;
     }
+    /**
+     * Creates an AST doctype node from a token containing the doctype
+     * name, public ID, and system ID.
+     *
+     * @param token - The child token with doctype-specific properties
+     * @returns An array containing the single doctype AST node
+     */
     visitDoctype(token) {
         timer.push('visitDoctype');
         const node = {
@@ -271,6 +384,14 @@ export class Parser {
         };
         return [node];
     }
+    /**
+     * Creates an AST comment node from a token. Automatically detects whether
+     * the comment is a bogus comment (not starting with `<!--`).
+     *
+     * @param token - The child token containing the comment's raw text and position
+     * @param options - Optional settings to override the bogus detection
+     * @returns An array containing the single comment AST node
+     */
     visitComment(token, options) {
         timer.push('visitComment');
         const isBogus = options?.isBogus ?? !token.raw.startsWith('<!--');
@@ -283,6 +404,14 @@ export class Parser {
         };
         return [node];
     }
+    /**
+     * Creates AST text node(s) from a token. Optionally re-parses the text content
+     * to discover embedded HTML tags within it.
+     *
+     * @param token - The child token containing the text content and position
+     * @param options - Controls whether to search for embedded tags and how to handle invalid ones
+     * @returns An array of AST nodes; a single text node or multiple tag/text nodes if tags were found
+     */
     visitText(token, options) {
         timer.push('visitText');
         const node = {
@@ -302,6 +431,16 @@ export class Parser {
         }
         return [node];
     }
+    /**
+     * Creates AST element node(s) from a token, including the start tag, optional end tag,
+     * and recursively traversed child nodes. Handles ghost elements (empty raw),
+     * self-closing tags, and nameless fragments (e.g., JSX `<>`).
+     *
+     * @param token - The child token with the element's node name; namespace is auto-detected from tag name and parent node
+     * @param childNodes - The language-specific child AST nodes to traverse
+     * @param options - Controls end tag creation, fragment handling, and property overrides
+     * @returns An array of AST nodes including the start tag, optional end tag, and any sibling nodes
+     */
     visitElement(token, childNodes = [], options) {
         timer.push('visitElement');
         const createEndTagToken = options?.createEndTagToken;
@@ -316,20 +455,21 @@ export class Parser {
                 elementType: 'html',
                 attributes: [],
                 childNodes: [],
+                blockBehavior: null,
                 parentNode: token.parentNode,
                 pairNode: null,
                 tagCloseChar: '',
                 tagOpenChar: '',
                 isGhost: true,
                 isFragment: false,
+                namespace: getNamespace(null, token.parentNode),
                 ...overwriteProps,
             };
             const siblings = this.visitChildren(childNodes, startTag);
             return [startTag, ...siblings];
         }
         const startTag = {
-            ...__classPrivateFieldGet(this, _Parser_instances, "m", _Parser_parseStartTag).call(this, token, {
-                namespace: token.namespace,
+            ...this.#parseStartTag(token, {
                 ...overwriteProps,
             }, namelessFragment),
         };
@@ -337,20 +477,30 @@ export class Parser {
         if (createEndTagToken) {
             const endTagToken = createEndTagToken(startTag);
             if (endTagToken) {
-                const endTag = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_parseEndTag).call(this, endTagToken, namelessFragment);
-                __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_pairing).call(this, startTag, endTag);
+                const endTag = this.#parseEndTag(endTagToken, namelessFragment);
+                this.#pairing(startTag, endTag);
                 return [startTag, endTag, ...siblings];
             }
         }
         return [startTag, ...siblings];
     }
-    visitPsBlock(token, childNodes = [], conditionalType = null, originBlockNode) {
+    /**
+     * Creates an AST preprocessor-specific block node (e.g., for template directives
+     * like `{#if}`, `{#each}`, or front matter). Recursively traverses child nodes.
+     *
+     * @param token - The child token with the block's node name and fragment flag
+     * @param childNodes - The language-specific child AST nodes to traverse
+     * @param blockBehavior - The block behavior if this is a control-flow block (e.g., "if", "each")
+     * @param originBlockNode - The original language-specific block node for reference
+     * @returns An array of AST nodes including the block node and any sibling nodes
+     */
+    visitPsBlock(token, childNodes = [], blockBehavior = null, originBlockNode) {
         timer.push('visitPsBlock');
         const block = {
             ...token,
             ...this.createToken(token),
             type: 'psblock',
-            conditionalType,
+            blockBehavior,
             nodeName: `#ps:${token.nodeName}`,
             childNodes: [],
             isBogus: false,
@@ -358,17 +508,33 @@ export class Parser {
         const siblings = this.visitChildren(childNodes, block);
         return [block, ...siblings];
     }
+    /**
+     * Traverses a list of child nodes under the given parent, appending the resulting
+     * child AST nodes to the parent and returning any sibling nodes that belong
+     * to ancestor levels. Skips traversal for raw text elements (e.g., `<script>`, `<style>`).
+     *
+     * @param children - The language-specific child AST nodes to traverse
+     * @param parentNode - The parent markuplint AST node to which children will be appended
+     * @returns An array of sibling nodes that belong to ancestor depth levels
+     */
     visitChildren(children, parentNode) {
         if (children.length === 0) {
             return [];
         }
-        if (parentNode && __classPrivateFieldGet(this, _Parser_rawTextElements, "f").includes(parentNode.nodeName.toLowerCase())) {
+        if (parentNode && this.#rawTextElements.includes(parentNode.nodeName.toLowerCase())) {
             return [];
         }
         const traversed = this.traverse(children, parentNode, parentNode ? parentNode.depth + 1 : 0);
         this.appendChild(parentNode, ...traversed.childNodes);
         return traversed.siblings;
     }
+    /**
+     * Attempts to parse a token as a JSX spread attribute (e.g., `{...props}`).
+     * Returns null if the token does not match the spread attribute pattern.
+     *
+     * @param token - The token to inspect for spread attribute syntax
+     * @returns A spread attribute AST node, or null if the token is not a spread attribute
+     */
     visitSpreadAttr(token) {
         timer.push('visitSpreadAttr');
         const raw = token.raw.trim();
@@ -382,14 +548,23 @@ export class Parser {
         if (!raw.endsWith('}')) {
             return null;
         }
-        const node = this.createToken(raw, token.startOffset, token.startLine, token.startCol);
+        const node = this.createToken(raw, token.offset, token.line, token.col);
         return {
             ...node,
-            ...__classPrivateFieldGet(this, _Parser_instances, "m", _Parser_getEndLocation).call(this, node),
             type: 'spread',
             nodeName: '#spread',
         };
     }
+    /**
+     * Parses a token into a fully structured attribute AST node, breaking it down
+     * into its constituent parts: spaces, name, equal sign, quotes, and value.
+     * Also detects spread attributes. If there is leftover text after the attribute,
+     * it is returned in the `__rightText` property for further processing.
+     *
+     * @param token - The token containing the raw attribute text and position
+     * @param options - Controls quoting behavior, value types, and the initial parser state
+     * @returns The parsed attribute AST node with an optional `__rightText` for remaining unparsed content
+     */
     visitAttr(token, options) {
         timer.push('visitAttr');
         const raw = token.raw;
@@ -397,9 +572,9 @@ export class Parser {
         const startState = options?.startState ?? AttrState.BeforeName;
         const noQuoteValueType = options?.noQuoteValueType;
         const endOfUnquotedValueChars = options?.endOfUnquotedValueChars;
-        let startOffset = token.startOffset;
-        let startLine = token.startLine;
-        let startCol = token.startCol;
+        let curOffset = token.offset;
+        let curLine = token.line;
+        let curCol = token.col;
         let tokens;
         try {
             tokens = attrTokenizer(raw, quoteSet, startState, noQuoteValueType, endOfUnquotedValueChars);
@@ -410,42 +585,28 @@ export class Parser {
             }
             throw error;
         }
-        const spacesBeforeName = this.createToken(tokens.spacesBeforeAttrName, startOffset, startLine, startCol);
-        startLine = spacesBeforeName.endLine;
-        startCol = spacesBeforeName.endCol;
-        startOffset = spacesBeforeName.endOffset;
-        const name = this.createToken(tokens.attrName, startOffset, startLine, startCol);
-        startLine = name.endLine;
-        startCol = name.endCol;
-        startOffset = name.endOffset;
-        const spacesBeforeEqual = this.createToken(tokens.spacesBeforeEqual, startOffset, startLine, startCol);
-        startLine = spacesBeforeEqual.endLine;
-        startCol = spacesBeforeEqual.endCol;
-        startOffset = spacesBeforeEqual.endOffset;
-        const equal = this.createToken(tokens.equal, startOffset, startLine, startCol);
-        startLine = equal.endLine;
-        startCol = equal.endCol;
-        startOffset = equal.endOffset;
-        const spacesAfterEqual = this.createToken(tokens.spacesAfterEqual, startOffset, startLine, startCol);
-        startLine = spacesAfterEqual.endLine;
-        startCol = spacesAfterEqual.endCol;
-        startOffset = spacesAfterEqual.endOffset;
-        const startQuote = this.createToken(tokens.quoteStart, startOffset, startLine, startCol);
-        startLine = startQuote.endLine;
-        startCol = startQuote.endCol;
-        startOffset = startQuote.endOffset;
-        const value = this.createToken(tokens.attrValue, startOffset, startLine, startCol);
-        startLine = value.endLine;
-        startCol = value.endCol;
-        startOffset = value.endOffset;
-        const endQuote = this.createToken(tokens.quoteEnd, startOffset, startLine, startCol);
+        const spacesBeforeName = this.createToken(tokens.spacesBeforeAttrName, curOffset, curLine, curCol);
+        ({ offset: curOffset, line: curLine, col: curCol } = this.#getEndLocation(spacesBeforeName));
+        const name = this.createToken(tokens.attrName, curOffset, curLine, curCol);
+        ({ offset: curOffset, line: curLine, col: curCol } = this.#getEndLocation(name));
+        const spacesBeforeEqual = this.createToken(tokens.spacesBeforeEqual, curOffset, curLine, curCol);
+        ({ offset: curOffset, line: curLine, col: curCol } = this.#getEndLocation(spacesBeforeEqual));
+        const equal = this.createToken(tokens.equal, curOffset, curLine, curCol);
+        ({ offset: curOffset, line: curLine, col: curCol } = this.#getEndLocation(equal));
+        const spacesAfterEqual = this.createToken(tokens.spacesAfterEqual, curOffset, curLine, curCol);
+        ({ offset: curOffset, line: curLine, col: curCol } = this.#getEndLocation(spacesAfterEqual));
+        const startQuote = this.createToken(tokens.quoteStart, curOffset, curLine, curCol);
+        ({ offset: curOffset, line: curLine, col: curCol } = this.#getEndLocation(startQuote));
+        const value = this.createToken(tokens.attrValue, curOffset, curLine, curCol);
+        ({ offset: curOffset, line: curLine, col: curCol } = this.#getEndLocation(value));
+        const endQuote = this.createToken(tokens.quoteEnd, curOffset, curLine, curCol);
         const attrToken = this.createToken(tokens.attrName +
             tokens.spacesBeforeEqual +
             tokens.equal +
             tokens.spacesAfterEqual +
             tokens.quoteStart +
             tokens.attrValue +
-            tokens.quoteEnd, name.startOffset, name.startLine, name.startCol);
+            tokens.quoteEnd, name.offset, name.line, name.col);
         const htmlAttr = {
             ...attrToken,
             type: 'attr',
@@ -469,25 +630,34 @@ export class Parser {
         }
         return spread ?? htmlAttr;
     }
+    /**
+     * Re-parses a text token to discover embedded HTML/XML tags within it,
+     * splitting the content into a sequence of tag and text AST nodes.
+     * Handles self-closing detection, depth tracking, and void element recognition.
+     *
+     * @param token - The child token containing the code fragment to re-parse
+     * @param options - Controls whether nameless fragments (JSX `<>`) are recognized
+     * @returns An array of tag and text AST nodes discovered in the code fragment
+     */
     parseCodeFragment(token, options) {
         const nodes = [];
         let raw = token.raw;
-        let startOffset = token.startOffset;
-        let startLine = token.startLine;
-        let startCol = token.startCol;
+        let curOffset = token.offset;
+        let curLine = token.line;
+        let curCol = token.col;
         let depth = token.depth;
         const depthStack = new Map();
         while (raw) {
-            const parsed = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_parseTag).call(this, {
+            const parsed = this.#parseTag({
                 raw,
-                startOffset,
-                startLine,
-                startCol,
+                offset: curOffset,
+                line: curLine,
+                col: curCol,
                 depth,
-                parentNode: null,
+                parentNode: token.parentNode,
             }, true, true, options?.namelessFragment ?? false);
             if (parsed.__left) {
-                const token = this.createToken(parsed.__left, startOffset, startLine, startCol);
+                const token = this.createToken(parsed.__left, curOffset, curLine, curCol);
                 const textNode = {
                     ...token,
                     type: 'text',
@@ -502,12 +672,10 @@ export class Parser {
                 continue;
             }
             const tag = parsed.token;
-            startLine = tag.endLine;
-            startCol = tag.endCol;
-            startOffset = tag.endOffset;
-            let isSelfClose = tag.type === 'starttag' && tag.selfClosingSolidus?.raw === '/';
+            ({ offset: curOffset, line: curLine, col: curCol } = this.#getEndLocation(tag));
+            let isSelfClose = tag.type === 'starttag' && tag.tagCloseChar.startsWith('/');
             const isVoidElement = detectVoidElement({ localName: tag.nodeName.toLowerCase() });
-            switch (__classPrivateFieldGet(this, _Parser_selfCloseType, "f")) {
+            switch (this.#selfCloseType) {
                 case 'html': {
                     isSelfClose = isVoidElement;
                     break;
@@ -532,7 +700,7 @@ export class Parser {
                         depthStack.delete(tag.nodeName);
                     }
                     else {
-                        depth = Math.max(depth - 1, __classPrivateFieldGet(this, _Parser_defaultDepth, "f"));
+                        depth = Math.max(depth - 1, this.#defaultDepth);
                     }
                     this.updateLocation(tag, {
                         depth,
@@ -553,91 +721,131 @@ export class Parser {
         }
         return nodes;
     }
+    /**
+     * Updates the position and depth properties of an AST node.
+     *
+     * @param node - The AST node whose location should be updated
+     * @param props - The new position and depth values to apply (only provided values are changed)
+     */
     updateLocation(node, props) {
         Object.assign(node, {
-            startOffset: props.startOffset ?? node.startOffset,
-            startLine: props.startLine ?? node.startLine,
-            startCol: props.startCol ?? node.startCol,
-            endOffset: props.startOffset == null ? node.endOffset : props.startOffset + node.raw.length,
-            endLine: props.startLine == null ? node.endLine : getEndLine(node.raw, props.startLine),
-            endCol: props.startCol == null ? node.endCol : getEndCol(node.raw, props.startCol),
+            offset: props.offset ?? node.offset,
+            line: props.line ?? node.line,
+            col: props.col ?? node.col,
             depth: props.depth ?? node.depth,
         });
     }
     /**
      * Set new raw code to target node.
      *
-     * Replace the raw code and update the start/end offset/line/column.
-     *
      * @param node target node
      * @param raw new raw code
      */
     updateRaw(node, raw) {
-        const startOffset = node.startOffset;
-        const startLine = node.startLine;
-        const startCol = node.startCol;
-        const endOffset = startOffset + raw.length;
-        const endLine = getEndLine(raw, startLine);
-        const endCol = getEndCol(raw, startCol);
         Object.assign(node, {
             raw,
-            startOffset,
-            endOffset,
-            startLine,
-            endLine,
-            startCol,
-            endCol,
         });
     }
     updateElement(el, props) {
         Object.assign(el, props);
     }
+    /**
+     * Updates metadata properties on an HTML attribute AST node, such as marking
+     * it as a directive, dynamic value, or setting its potential name/value
+     * for preprocessor-specific attribute transformations.
+     *
+     * @param attr - The HTML attribute AST node to update
+     * @param props - The metadata properties to overwrite on the attribute
+     */
     updateAttr(attr, props) {
         Object.assign(attr, props);
     }
+    /**
+     * Determines the element type (e.g., "html", "web-component", "authored") for a
+     * given tag name, using the parser's authored element name distinguishing pattern.
+     *
+     * @param nodeName - The tag name to classify
+     * @param defaultPattern - A fallback pattern if no authored element name pattern is set
+     * @returns The element type classification
+     */
     detectElementType(nodeName, defaultPattern) {
-        return detectElementType(nodeName, __classPrivateFieldGet(this, _Parser_authoredElementName, "f"), defaultPattern);
+        return detectElementType(nodeName, this.#authoredElementName, defaultPattern);
     }
-    createToken(token, startOffset, startLine, startCol) {
+    createToken(token, offset, line, col) {
         const props = typeof token === 'string'
             ? {
                 raw: token,
-                startOffset: startOffset ?? 0,
-                startLine: startLine ?? 1,
-                startCol: startCol ?? 1,
+                offset: offset ?? 0,
+                line: line ?? 1,
+                col: col ?? 1,
             }
             : token;
         return {
-            uuid: uuid().slice(0, 8),
+            uuid: randomUUID().slice(0, 8),
             ...props,
-            ...__classPrivateFieldGet(this, _Parser_instances, "m", _Parser_getEndLocation).call(this, props),
         };
     }
+    /**
+     * Extracts a Token from the current raw code at the given byte offset range,
+     * computing the line and column from the source position.
+     *
+     * @param start - The starting byte offset (inclusive) in the raw code
+     * @param end - The ending byte offset (exclusive) in the raw code; if omitted, slices to the end
+     * @returns A Token containing the sliced raw content and its start position
+     */
     sliceFragment(start, end) {
         const raw = this.rawCode.slice(start, end);
-        const { line, column } = getPosition(this.rawCode, start);
+        const { line: l, column } = getPosition(this.rawCode, start);
         return {
             raw,
-            startOffset: start,
-            startLine: line,
-            startCol: column,
+            offset: start,
+            line: l,
+            col: column,
         };
     }
+    /**
+     * Calculates start and end byte offsets from line/column positions
+     * within the current raw source code.
+     *
+     * @param startLine - The starting line number (1-based)
+     * @param startCol - The starting column number (1-based)
+     * @param endLine - The ending line number (1-based)
+     * @param endCol - The ending column number (1-based)
+     * @returns The computed start and end byte offsets
+     */
     getOffsetsFromCode(startLine, startCol, endLine, endCol) {
         return getOffsetsFromCode(this.rawCode, startLine, startCol, endLine, endCol);
     }
+    /**
+     * Walks through a node list depth-first, invoking the walker callback for each node.
+     * The walker receives the current node, the sequentially previous node, and the depth.
+     * Automatically recurses into child nodes of parent elements and preprocessor blocks.
+     *
+     * @template Node - The specific AST node type being walked
+     * @param nodeList - The list of nodes to walk
+     * @param walker - The callback invoked for each node during the walk
+     * @param depth - The current depth (starts at 0 for top-level calls)
+     */
     walk(nodeList, walker, depth = 0) {
         for (const node of nodeList) {
-            walker(node, __classPrivateFieldGet(this, _Parser_walkMethodSequentailPrevNode, "f"), depth);
-            __classPrivateFieldSet(this, _Parser_walkMethodSequentailPrevNode, node, "f");
+            walker(node, this.#walkMethodSequentailPrevNode, depth);
+            this.#walkMethodSequentailPrevNode = node;
             if ('childNodes' in node && node.childNodes.length > 0) {
                 this.walk(node.childNodes, walker, depth + 1);
             }
         }
         if (depth === 0) {
-            __classPrivateFieldSet(this, _Parser_walkMethodSequentailPrevNode, null, "f");
+            this.#walkMethodSequentailPrevNode = null;
         }
     }
+    /**
+     * Appends child nodes to a parent node, updating parent references and
+     * maintaining sorted order by source position. If a child already exists
+     * in the parent (by UUID), it is replaced in place rather than duplicated.
+     *
+     * @param parentNode - The parent node to append children to, or null (no-op)
+     * @param childNodes - The child nodes to append
+     */
     appendChild(parentNode, ...childNodes) {
         if (!parentNode || childNodes.length === 0) {
             return;
@@ -653,468 +861,472 @@ export class Parser {
             newChildNodes.splice(currentIndex, 1, appendingChild);
         }
         Object.assign(parentNode, {
-            childNodes: Array.prototype.toSorted == null
-                ? // TODO: Use sort instead of toSorted until we end support for Node 18
-                    [...newChildNodes].sort(sortNodes)
-                : newChildNodes.toSorted(sortNodes),
+            childNodes: newChildNodes.toSorted(sortNodes),
         });
     }
+    /**
+     * Replaces a child node within a parent's child list with one or more replacement nodes.
+     * If the old child is not found in the parent, the operation is a no-op.
+     *
+     * @param parentNode - The parent node containing the child to replace
+     * @param oldChildNode - The existing child node to be replaced
+     * @param replacementChildNodes - The replacement nodes to insert at the old child's position
+     */
     replaceChild(parentNode, oldChildNode, ...replacementChildNodes) {
         const index = parentNode.childNodes.findIndex(childNode => childNode.uuid === oldChildNode.uuid);
         if (index === -1) {
             return;
         }
-        if (Array.prototype.toSpliced == null) {
-            const newChildNodes = [...parentNode.childNodes];
-            // TODO: Use splice instead of toSpliced until we end support for Node 18
-            newChildNodes.splice(index, 1, ...replacementChildNodes);
-            Object.assign(parentNode, { childNodes: newChildNodes });
-            return;
-        }
         const newChildNodes = parentNode.childNodes.toSpliced(index, 1, ...replacementChildNodes);
         Object.assign(parentNode, { childNodes: newChildNodes });
     }
-}
-_Parser_booleanish = new WeakMap(), _Parser_defaultState = new WeakMap(), _Parser_endTagType = new WeakMap(), _Parser_ignoreTags = new WeakMap(), _Parser_maskChar = new WeakMap(), _Parser_tagNameCaseSensitive = new WeakMap(), _Parser_selfCloseType = new WeakMap(), _Parser_spaceChars = new WeakMap(), _Parser_rawTextElements = new WeakMap(), _Parser_authoredElementName = new WeakMap(), _Parser_originalRawCode = new WeakMap(), _Parser_rawCode = new WeakMap(), _Parser_defaultDepth = new WeakMap(), _Parser_walkMethodSequentailPrevNode = new WeakMap(), _Parser_instances = new WeakSet(), _Parser_arrayize = function _Parser_arrayize(nodeTree) {
-    let nodeList = [];
-    this.walk(nodeTree, node => {
-        nodeList.push(node);
-    });
-    nodeList = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_removeDeprecatedNode).call(this, nodeList);
-    return nodeList;
-}, _Parser_concatText = function _Parser_concatText(nodeList) {
-    const newNodeList = [];
-    for (const node of nodeList) {
-        const prevNode = newNodeList.at(-1) ?? null;
-        if (prevNode?.type === 'text' &&
-            prevNode?.nodeName === '#text' &&
-            node.type === 'text' &&
-            node.nodeName === '#text' &&
-            prevNode?.endOffset === node.startOffset) {
-            const newNode = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_concatTextNodes).call(this, prevNode, node);
-            newNodeList.pop();
-            newNodeList.push(newNode);
-            continue;
-        }
-        newNodeList.push(node);
-    }
-    return newNodeList;
-}, _Parser_concatTextNodes = function _Parser_concatTextNodes(...nodes) {
-    if (nodes.length === 0) {
-        throw new Error('Empty node list');
-    }
-    const firstNode = nodes.at(0);
-    const lastNode = nodes.at(-1);
-    if (firstNode.uuid === lastNode.uuid) {
-        return firstNode;
-    }
-    const textNode = {
-        ...firstNode,
-        uuid: uuid().slice(0, 8),
-        raw: nodes.map(n => n.raw).join(''),
-        endOffset: lastNode.endOffset,
-        endLine: lastNode.endLine,
-        endCol: lastNode.endCol,
-    };
-    for (const node of nodes) {
-        __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_removeChild).call(this, node.parentNode, node);
+    #arrayize(nodeTree) {
+        let nodeList = [];
+        this.walk(nodeTree, node => {
+            nodeList.push(node);
+        });
+        nodeList = this.#removeDeprecatedNode(nodeList);
+        return nodeList;
     }
-    this.appendChild(textNode.parentNode, textNode);
-    return textNode;
-}, _Parser_convertIntoInvalidNode = function _Parser_convertIntoInvalidNode(node) {
-    if (node.type === 'invalid') {
-        return node;
+    #concatText(nodeList) {
+        const newNodeList = [];
+        for (const node of nodeList) {
+            const prevNode = newNodeList.at(-1) ?? null;
+            if (prevNode?.type === 'text' &&
+                prevNode?.nodeName === '#text' &&
+                node.type === 'text' &&
+                node.nodeName === '#text' &&
+                prevNode.offset + prevNode.raw.length === node.offset) {
+                const newNode = this.#concatTextNodes(prevNode, node);
+                newNodeList.pop();
+                newNodeList.push(newNode);
+                continue;
+            }
+            newNodeList.push(node);
+        }
+        return newNodeList;
     }
-    return {
-        ...node,
-        type: 'invalid',
-        nodeName: '#invalid',
-        isBogus: true,
-        kind: node.type,
-    };
-}, _Parser_createOffsetSpaces = function _Parser_createOffsetSpaces(options) {
-    const offsetOffset = Math.max(options?.offsetOffset ?? 0, 0);
-    const offsetLine = Math.max((options?.offsetLine ?? 0) - 1, 0);
-    const offsetColumn = Math.max((options?.offsetColumn ?? 0) - 1, 0);
-    const offsetSpaces = ' '.repeat(offsetOffset - offsetLine - offsetColumn);
-    const offsetLines = '\n'.repeat(offsetLine);
-    const offsetColumns = ' '.repeat(offsetColumn);
-    return offsetSpaces + offsetLines + offsetColumns;
-}, _Parser_createRemnantNode = function _Parser_createRemnantNode(start, end, depth, parentNode, exposeInvalidNode, exposeWhitespace) {
-    const codeFragment = this.sliceFragment(start, end);
-    if (codeFragment.raw) {
-        const remnantNodes = this.visitText({
-            ...codeFragment,
-            depth: depth,
-            parentNode: parentNode,
-        }, { researchTags: true }).filter((node) => 'parentNode' in node);
-        if (remnantNodes.length > 1) {
-            this.appendChild(parentNode, ...remnantNodes);
-            return remnantNodes;
+    #concatTextNodes(...nodes) {
+        if (nodes.length === 0) {
+            throw new Error('Empty node list');
         }
-        const remnantNode = remnantNodes[0];
-        if (!remnantNode) {
-            return null;
+        const firstNode = nodes.at(0);
+        const lastNode = nodes.at(-1);
+        if (firstNode.uuid === lastNode.uuid) {
+            return firstNode;
         }
-        if (exposeInvalidNode && remnantNode.raw.trim() !== '') {
-            const invalidNode = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_convertIntoInvalidNode).call(this, remnantNode);
-            this.appendChild(parentNode, invalidNode);
-            return [remnantNode];
+        const textNode = {
+            ...firstNode,
+            uuid: randomUUID().slice(0, 8),
+            raw: nodes.map(n => n.raw).join(''),
+        };
+        for (const node of nodes) {
+            this.#removeChild(node.parentNode, node);
         }
-        if (exposeWhitespace && remnantNode.type === 'text' && remnantNode.raw.trim() === '') {
-            this.appendChild(parentNode, remnantNode);
-            return [remnantNode];
+        this.appendChild(textNode.parentNode, textNode);
+        return textNode;
+    }
+    #convertIntoInvalidNode(node) {
+        if (node.type === 'invalid') {
+            return node;
         }
+        return {
+            ...node,
+            type: 'invalid',
+            nodeName: '#invalid',
+            isBogus: true,
+            kind: node.type,
+        };
     }
-    return null;
-}, _Parser_exposeRemnantNodes = function _Parser_exposeRemnantNodes(nodeList, invalidNode, whitespace) {
-    if (!invalidNode && !whitespace) {
-        return nodeList;
+    #createOffsetSpaces(options) {
+        const offsetOffset = Math.max(options?.offsetOffset ?? 0, 0);
+        const offsetLine = Math.max((options?.offsetLine ?? 0) - 1, 0);
+        const offsetColumn = Math.max((options?.offsetColumn ?? 0) - 1, 0);
+        const offsetSpaces = ' '.repeat(offsetOffset - offsetLine - offsetColumn);
+        const offsetLines = '\n'.repeat(offsetLine);
+        const offsetColumns = ' '.repeat(offsetColumn);
+        return offsetSpaces + offsetLines + offsetColumns;
     }
-    const newNodeList = [];
-    for (const [i, node] of nodeList.entries()) {
-        const sequentailPrevNode = nodeList[i - 1] ?? null;
-        if (!__classPrivateFieldGet(this, _Parser_rawTextElements, "f").includes(node.nodeName.toLowerCase())) {
-            const endOffset = sequentailPrevNode?.endOffset ?? 0;
-            const remnantNodes = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_createRemnantNode).call(this, endOffset, node.startOffset, node.depth, node.parentNode, invalidNode, whitespace);
-            if (remnantNodes) {
-                newNodeList.push(...remnantNodes);
+    #createRemnantNode(start, end, depth, parentNode, exposeInvalidNode, exposeWhitespace) {
+        const codeFragment = this.sliceFragment(start, end);
+        if (codeFragment.raw) {
+            const remnantNodes = this.visitText({
+                ...codeFragment,
+                depth: depth,
+                parentNode: parentNode,
+            }, { researchTags: true }).filter((node) => 'parentNode' in node);
+            if (remnantNodes.length > 1) {
+                this.appendChild(parentNode, ...remnantNodes);
+                return remnantNodes;
+            }
+            const remnantNode = remnantNodes[0];
+            if (!remnantNode) {
+                return null;
+            }
+            if (exposeInvalidNode && remnantNode.raw.trim() !== '') {
+                const invalidNode = this.#convertIntoInvalidNode(remnantNode);
+                this.appendChild(parentNode, invalidNode);
+                return [remnantNode];
+            }
+            if (exposeWhitespace && remnantNode.type === 'text' && remnantNode.raw.trim() === '') {
+                this.appendChild(parentNode, remnantNode);
+                return [remnantNode];
             }
         }
-        newNodeList.push(node);
+        return null;
     }
-    const lastNode = newNodeList.at(-1);
-    if (!lastNode) {
+    #exposeRemnantNodes(nodeList, invalidNode, whitespace) {
+        if (!invalidNode && !whitespace) {
+            return nodeList;
+        }
+        const newNodeList = [];
+        for (const [i, node] of nodeList.entries()) {
+            const sequentailPrevNode = nodeList[i - 1] ?? null;
+            if (!this.#rawTextElements.includes(node.nodeName.toLowerCase())) {
+                const prevEndOffset = sequentailPrevNode
+                    ? sequentailPrevNode.offset + sequentailPrevNode.raw.length
+                    : 0;
+                const remnantNodes = this.#createRemnantNode(prevEndOffset, node.offset, node.depth, node.parentNode, invalidNode, whitespace);
+                if (remnantNodes) {
+                    newNodeList.push(...remnantNodes);
+                }
+            }
+            newNodeList.push(node);
+        }
+        const lastNode = newNodeList.at(-1);
+        if (!lastNode) {
+            return newNodeList;
+        }
+        const remnantNodes = this.#createRemnantNode(lastNode.offset + lastNode.raw.length, undefined, lastNode.depth, lastNode.parentNode, invalidNode, whitespace);
+        if (!remnantNodes) {
+            return newNodeList;
+        }
+        newNodeList.push(...remnantNodes);
         return newNodeList;
     }
-    const remnantNodes = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_createRemnantNode).call(this, lastNode.endOffset, undefined, lastNode.depth, lastNode.parentNode, invalidNode, whitespace);
-    if (!remnantNodes) {
-        return newNodeList;
+    #getEndLocation(token) {
+        return {
+            offset: token.offset + token.raw.length,
+            line: getEndLine(token.raw, token.line),
+            col: getEndCol(token.raw, token.col),
+        };
     }
-    newNodeList.push(...remnantNodes);
-    return newNodeList;
-}, _Parser_getEndLocation = function _Parser_getEndLocation(token) {
-    const endOffset = token.startOffset + token.raw.length;
-    return {
-        endOffset,
-        endLine: getEndLine(token.raw, token.startLine),
-        endCol: getEndCol(token.raw, token.startCol),
-    };
-}, _Parser_orphanEndTagToBogusMark = function _Parser_orphanEndTagToBogusMark(nodeList) {
-    const newNodeList = [];
-    for (let node of nodeList) {
-        if (node.type === 'endtag') {
-            const endTagUUID = node.uuid;
-            const openTag = newNodeList.findLast((n) => n.type === 'starttag' && !n.isGhost ? n.pairNode?.uuid === endTagUUID : false);
-            if (!openTag) {
-                node = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_convertIntoInvalidNode).call(this, node);
+    #orphanEndTagToBogusMark(nodeList) {
+        const newNodeList = [];
+        for (let node of nodeList) {
+            if (node.type === 'endtag') {
+                const endTagUUID = node.uuid;
+                const openTag = newNodeList.findLast((n) => n.type === 'starttag' && !n.isGhost ? n.pairNode?.uuid === endTagUUID : false);
+                if (!openTag) {
+                    node = this.#convertIntoInvalidNode(node);
+                }
             }
+            newNodeList.push(node);
         }
-        newNodeList.push(node);
+        return newNodeList;
     }
-    return newNodeList;
-}, _Parser_pairing = function _Parser_pairing(startTag, endTag) {
-    Object.assign(startTag, { pairNode: endTag });
-    Object.assign(endTag, { pairNode: startTag });
-    this.appendChild(startTag.parentNode, endTag);
-}, _Parser_parseEndTag = function _Parser_parseEndTag(token, namelessFragment) {
-    const parsed = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_parseTag).call(this, token, true, false, namelessFragment);
-    if (!parsed.token || parsed.token.type !== 'endtag') {
-        throw new ParserError("Expected end tag but it's not end tag", token);
+    #pairing(startTag, endTag) {
+        Object.assign(startTag, { pairNode: endTag });
+        Object.assign(endTag, { pairNode: startTag });
+        this.appendChild(startTag.parentNode, endTag);
     }
-    return parsed.token;
-}, _Parser_parseStartTag = function _Parser_parseStartTag(token, overwriteProps, namelessFragment) {
-    const parsed = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_parseTag).call(this, token, true, false, namelessFragment);
-    if (!parsed.token || parsed.token.type !== 'starttag') {
-        throw new ParserError("Expected start tag but it's not start tag", token);
+    #parseEndTag(token, namelessFragment) {
+        const parsed = this.#parseTag(token, true, false, namelessFragment);
+        if (!parsed.token || parsed.token.type !== 'endtag') {
+            throw new ParserError("Expected end tag but it's not end tag", token);
+        }
+        return parsed.token;
     }
-    const startTag = {
-        ...parsed.token,
-        ...overwriteProps,
-    };
-    this.appendChild(token.parentNode, startTag);
-    return startTag;
-}, _Parser_parseTag = function _Parser_parseTag(token, praseAttr, failSafe, namelessFragment) {
-    const raw = token.raw;
-    const depth = token.depth;
-    const initialOffset = token.startOffset;
-    const initialLine = token.startLine;
-    const initialCol = token.startCol;
-    let offset = initialOffset;
-    let line = initialLine;
-    let col = initialCol;
-    let tagStartOffset = offset;
-    let tagStartLine = line;
-    let tagStartCol = col;
-    let state = TagState.BeforeOpenTag;
-    let beforeOpenTagChars = '';
-    let tagName = '';
-    let afterAttrsSpaceChars = '';
-    let selfClosingSolidusChar = '';
-    let isOpenTag = true;
-    const attrs = [];
-    const chars = [...raw];
-    while (chars.length > 0) {
-        if (state === TagState.AfterOpenTag) {
-            break;
+    #parseStartTag(token, overwriteProps, namelessFragment) {
+        const parsed = this.#parseTag(token, true, false, namelessFragment);
+        if (!parsed.token || parsed.token.type !== 'starttag') {
+            throw new ParserError("Expected start tag but it's not start tag", token);
         }
-        const char = chars.shift();
-        stateSwitch: switch (state) {
-            case TagState.BeforeOpenTag: {
-                if (char === '<') {
-                    const beforeOpenTag = this.createToken(beforeOpenTagChars, offset, line, col);
-                    line = beforeOpenTag.endLine;
-                    col = beforeOpenTag.endCol;
-                    offset = beforeOpenTag.endOffset;
-                    tagStartOffset = offset;
-                    tagStartLine = line;
-                    tagStartCol = col;
-                    // Add `<` length
-                    col += 1;
-                    offset += 1;
-                    state = TagState.FirstCharOfTagName;
-                    break;
-                }
-                beforeOpenTagChars += char;
-                break;
-            }
-            case TagState.FirstCharOfTagName: {
-                if (/[a-z]/i.test(char)) {
-                    tagName += char;
-                    state = TagState.TagName;
-                    break;
-                }
-                if (char === '/') {
-                    isOpenTag = false;
-                    break;
-                }
-                if (namelessFragment && char === '>') {
-                    state = TagState.AfterOpenTag;
-                    break;
-                }
-                chars.unshift(char);
-                state = TagState.AfterOpenTag;
+        const startTag = {
+            ...parsed.token,
+            ...overwriteProps,
+        };
+        this.appendChild(token.parentNode, startTag);
+        return startTag;
+    }
+    #parseTag(token, praseAttr, failSafe, namelessFragment) {
+        const raw = token.raw;
+        const depth = token.depth;
+        const initialOffset = token.offset;
+        const initialLine = token.line;
+        const initialCol = token.col;
+        let offset = initialOffset;
+        let line = initialLine;
+        let col = initialCol;
+        let tagStartOffset = offset;
+        let tagStartLine = line;
+        let tagStartCol = col;
+        let state = TagState.BeforeOpenTag;
+        let beforeOpenTagChars = '';
+        let tagName = '';
+        let selfClosingSolidusChar = '';
+        let isOpenTag = true;
+        const attrs = [];
+        const chars = [...raw];
+        while (chars.length > 0) {
+            if (state === TagState.AfterOpenTag) {
                 break;
             }
-            case TagState.TagName: {
-                if (__classPrivateFieldGet(this, _Parser_spaceChars, "f").includes(char)) {
-                    chars.unshift(char);
-                    if (!isOpenTag) {
-                        // Add `/` of `</`(close tag) length
-                        offset += 1;
+            const char = chars.shift();
+            stateSwitch: switch (state) {
+                case TagState.BeforeOpenTag: {
+                    if (char === '<') {
+                        const beforeOpenTag = this.createToken(beforeOpenTagChars, offset, line, col);
+                        ({ offset, line, col } = this.#getEndLocation(beforeOpenTag));
+                        tagStartOffset = offset;
+                        tagStartLine = line;
+                        tagStartCol = col;
+                        // Add `<` length
                         col += 1;
+                        offset += 1;
+                        state = TagState.FirstCharOfTagName;
+                        break;
                     }
-                    offset += tagName.length;
-                    col += tagName.length;
-                    state = TagState.Attrs;
+                    beforeOpenTagChars += char;
                     break;
                 }
-                if (char === '/') {
+                case TagState.FirstCharOfTagName: {
+                    if (/[a-z]/i.test(char)) {
+                        tagName += char;
+                        state = TagState.TagName;
+                        break;
+                    }
+                    if (char === '/') {
+                        isOpenTag = false;
+                        break;
+                    }
+                    if (namelessFragment && char === '>') {
+                        state = TagState.AfterOpenTag;
+                        break;
+                    }
                     chars.unshift(char);
-                    state = TagState.AfterAttrs;
-                    break;
-                }
-                if (char === '>') {
                     state = TagState.AfterOpenTag;
                     break;
                 }
-                tagName += char;
-                break;
-            }
-            case TagState.Attrs: {
-                if (!praseAttr) {
-                    state = TagState.AfterAttrs;
-                    break stateSwitch;
-                }
-                let leftover = char + chars.join('');
-                while (leftover.trim()) {
-                    if (leftover.trim().startsWith('/') || leftover.trim().startsWith('>')) {
-                        chars.length = 0;
-                        chars.push(...leftover);
+                case TagState.TagName: {
+                    if (this.#spaceChars.includes(char)) {
+                        chars.unshift(char);
+                        if (!isOpenTag) {
+                            // Add `/` of `</`(close tag) length
+                            offset += 1;
+                            col += 1;
+                        }
+                        offset += tagName.length;
+                        col += tagName.length;
+                        state = TagState.Attrs;
+                        break;
+                    }
+                    if (char === '/') {
+                        chars.unshift(char);
                         state = TagState.AfterAttrs;
-                        break stateSwitch;
+                        break;
                     }
-                    const attr = this.visitAttr({
-                        raw: leftover,
-                        startOffset: offset,
-                        startLine: line,
-                        startCol: col,
-                    });
-                    line = attr.endLine;
-                    col = attr.endCol;
-                    offset = attr.endOffset;
-                    if (leftover === attr.__rightText) {
-                        throw new SyntaxError(`Invalid attribute syntax: ${leftover}`);
+                    if (char === '>') {
+                        state = TagState.AfterOpenTag;
+                        break;
                     }
-                    leftover = attr.__rightText == null ? '' : `${attr.__rightText}`;
-                    delete attr.__rightText;
-                    attrs.push(attr);
-                }
-                break;
-            }
-            case TagState.AfterAttrs: {
-                if (char === '>') {
-                    state = TagState.AfterOpenTag;
-                    break;
-                }
-                if (__classPrivateFieldGet(this, _Parser_spaceChars, "f").includes(char)) {
-                    afterAttrsSpaceChars += char;
+                    tagName += char;
                     break;
                 }
-                if (char === '/') {
-                    selfClosingSolidusChar = char;
+                case TagState.Attrs: {
+                    if (!praseAttr) {
+                        state = TagState.AfterAttrs;
+                        break stateSwitch;
+                    }
+                    let leftover = char + chars.join('');
+                    while (leftover.trim()) {
+                        if (leftover.trim().startsWith('/') || leftover.trim().startsWith('>')) {
+                            chars.length = 0;
+                            chars.push(...leftover);
+                            state = TagState.AfterAttrs;
+                            break stateSwitch;
+                        }
+                        const attr = this.visitAttr({
+                            raw: leftover,
+                            offset,
+                            line,
+                            col,
+                        });
+                        ({ offset, line, col } = this.#getEndLocation(attr));
+                        if (leftover === attr.__rightText) {
+                            throw new SyntaxError(`Invalid attribute syntax: ${leftover}`);
+                        }
+                        leftover = attr.__rightText == null ? '' : `${attr.__rightText}`;
+                        delete attr.__rightText;
+                        attrs.push(attr);
+                    }
                     break;
                 }
-                if (!praseAttr) {
-                    break;
+                case TagState.AfterAttrs: {
+                    if (char === '>') {
+                        state = TagState.AfterOpenTag;
+                        break;
+                    }
+                    if (this.#spaceChars.includes(char)) {
+                        break;
+                    }
+                    if (char === '/') {
+                        selfClosingSolidusChar = char;
+                        break;
+                    }
+                    if (!praseAttr) {
+                        break;
+                    }
+                    throw new SyntaxError(`Invalid tag syntax: "${raw}"`);
                 }
-                throw new SyntaxError(`Invalid tag syntax: "${raw}"`);
             }
         }
-    }
-    const leftover = chars.join('');
-    if (!failSafe && !leftover && state === TagState.TagName) {
-        throw new SyntaxError(`Invalid tag syntax: "${raw}"`);
-    }
-    if (!failSafe && !namelessFragment && tagName === '') {
-        throw new SyntaxError(`No tag name: "${raw}"`);
-    }
-    const endSpace = this.createToken(afterAttrsSpaceChars, offset, line, col);
-    line = endSpace.endLine;
-    col = endSpace.endCol;
-    offset = endSpace.endOffset;
-    const selfClosingSolidus = this.createToken(selfClosingSolidusChar, offset, line, col);
-    line = selfClosingSolidus.endLine;
-    col = selfClosingSolidus.endCol;
-    offset = selfClosingSolidus.endOffset;
-    const rawCodeFragment = raw.slice(beforeOpenTagChars.length, raw.length - leftover.length);
-    if (!rawCodeFragment) {
+        const leftover = chars.join('');
+        if (!failSafe && !leftover && state === TagState.TagName) {
+            throw new SyntaxError(`Invalid tag syntax: "${raw}"`);
+        }
+        if (!failSafe && !namelessFragment && tagName === '') {
+            throw new SyntaxError(`No tag name: "${raw}"`);
+        }
+        const rawCodeFragment = raw.slice(beforeOpenTagChars.length, raw.length - leftover.length);
+        if (!rawCodeFragment) {
+            return {
+                __left: beforeOpenTagChars,
+                __right: leftover,
+            };
+        }
+        const tagToken = this.createToken(rawCodeFragment, tagStartOffset, tagStartLine, tagStartCol);
+        const isFragment = tagName === '';
+        const commons = {
+            depth,
+            nodeName: isFragment ? '#jsx-fragment' : tagName,
+            parentNode: null,
+        };
+        const tag = isOpenTag
+            ? {
+                ...tagToken,
+                ...commons,
+                type: 'starttag',
+                elementType: this.detectElementType(tagName),
+                namespace: 'namespace' in token
+                    ? token.namespace
+                    : getNamespace(tagName, token.parentNode),
+                attributes: attrs,
+                childNodes: [],
+                pairNode: null,
+                tagOpenChar: '<',
+                tagCloseChar: selfClosingSolidusChar + '>',
+                blockBehavior: null,
+                isGhost: false,
+                isFragment,
+            }
+            : {
+                ...tagToken,
+                ...commons,
+                type: 'endtag',
+                pairNode: {},
+                tagOpenChar: '</',
+                tagCloseChar: '>',
+            };
         return {
+            token: tag,
             __left: beforeOpenTagChars,
             __right: leftover,
         };
     }
-    const tagToken = this.createToken(rawCodeFragment, tagStartOffset, tagStartLine, tagStartCol);
-    const isFragment = tagName === '';
-    const commons = {
-        depth,
-        nodeName: isFragment ? '#jsx-fragment' : tagName,
-        parentNode: null,
-    };
-    const tag = isOpenTag
-        ? {
-            ...tagToken,
-            ...commons,
-            type: 'starttag',
-            elementType: this.detectElementType(tagName),
-            namespace: '',
-            attributes: attrs,
-            childNodes: [],
-            pairNode: null,
-            tagOpenChar: '<',
-            tagCloseChar: selfClosingSolidusChar + '>',
-            selfClosingSolidus,
-            isGhost: false,
-            isFragment,
+    #removeChild(parentNode, ...childNodes) {
+        if (!parentNode || childNodes.length === 0) {
+            return;
         }
-        : {
-            ...tagToken,
-            ...commons,
-            type: 'endtag',
-            pairNode: {},
-            tagOpenChar: '</',
-            tagCloseChar: '>',
-        };
-    return {
-        token: tag,
-        __left: beforeOpenTagChars,
-        __right: leftover,
-    };
-}, _Parser_removeChild = function _Parser_removeChild(parentNode, ...childNodes) {
-    if (!parentNode || childNodes.length === 0) {
-        return;
+        const newChildNodes = parentNode.childNodes.filter(n => !childNodes.includes(n));
+        Object.assign(parentNode, { childNodes: newChildNodes });
     }
-    const newChildNodes = parentNode.childNodes.filter(n => !childNodes.includes(n));
-    Object.assign(parentNode, { childNodes: newChildNodes });
-}, _Parser_removeDeprecatedNode = function _Parser_removeDeprecatedNode(nodeOrders) {
     /**
-     * sorting
-     */
-    const sorted = Array.prototype.toSorted == null
-        ? // TODO: Use sort instead of toSorted until we end support for Node 18
-            [...nodeOrders].sort(sortNodes)
-        : nodeOrders.toSorted(sortNodes);
-    /**
-     * remove duplicated node
+     *
+     * @disruptive
+     * @param nodeOrders [Disruptive change]
      */
-    const stack = {};
-    const removeIndexes = [];
-    for (const [i, node] of sorted.entries()) {
-        const id = `${node.startOffset}::${node.nodeName}`;
-        if (stack[id] != null) {
-            removeIndexes.push(i);
+    #removeDeprecatedNode(nodeOrders) {
+        /**
+         * sorting
+         */
+        const sorted = nodeOrders.toSorted(sortNodes);
+        /**
+         * remove duplicated node
+         */
+        const stack = {};
+        const removeIndexes = [];
+        for (const [i, node] of sorted.entries()) {
+            const id = `${node.offset}::${node.nodeName}`;
+            if (stack[id] != null) {
+                removeIndexes.push(i);
+            }
+            stack[id] = i;
         }
-        stack[id] = i;
-    }
-    let r = sorted.length;
-    while (r-- > 0) {
-        if (removeIndexes.includes(r)) {
-            sorted.splice(r, 1);
+        let r = sorted.length;
+        while (r-- > 0) {
+            if (removeIndexes.includes(r)) {
+                sorted.splice(r, 1);
+            }
         }
+        return sorted;
     }
-    return sorted;
-}, _Parser_removeOffsetSpaces = function _Parser_removeOffsetSpaces(nodeList, options) {
-    const offsetOffset = options?.offsetOffset ?? 0;
-    const offsetLine = options?.offsetLine ?? 1;
-    const offsetColumn = options?.offsetColumn ?? 1;
-    if (offsetOffset === 0) {
+    #removeOffsetSpaces(nodeList, options) {
+        const offsetOffset = options?.offsetOffset ?? 0;
+        const offsetLine = options?.offsetLine ?? 1;
+        const offsetColumn = options?.offsetColumn ?? 1;
+        if (offsetOffset === 0) {
+            return nodeList;
+        }
+        const firstNode = nodeList.at(0);
+        if (!firstNode || firstNode.type !== 'text') {
+            return nodeList;
+        }
+        const raw = firstNode.raw.slice(offsetOffset);
+        if (!raw) {
+            return nodeList.toSpliced(0, 1);
+        }
+        this.updateRaw(firstNode, raw);
+        this.updateLocation(firstNode, {
+            offset: offsetOffset,
+            line: offsetLine,
+            col: offsetColumn,
+        });
         return nodeList;
     }
-    const firstNode = nodeList.at(0);
-    if (!firstNode || firstNode.type !== 'text') {
-        return nodeList;
+    #reset() {
+        // Reset state
+        this.state = structuredClone(this.#defaultState);
+        this.#defaultDepth = 0;
     }
-    const raw = firstNode.raw.slice(offsetOffset);
-    if (!raw) {
-        if (Array.prototype.toSpliced == null) {
-            const newNodeList = [...nodeList];
-            // TODO: Use splice instead of toSpliced until we end support for Node 18
-            newNodeList.splice(0, 1);
-            return newNodeList;
-        }
-        return nodeList.toSpliced(0, 1);
+    #setRawCode(rawCode, originalRawCode) {
+        this.#rawCode = rawCode;
+        this.#originalRawCode = originalRawCode ?? this.#originalRawCode;
     }
-    this.updateRaw(firstNode, raw);
-    this.updateLocation(firstNode, {
-        startOffset: offsetOffset,
-        startLine: offsetLine,
-        startCol: offsetColumn,
-    });
-    return nodeList;
-}, _Parser_reset = function _Parser_reset() {
-    // Reset state
-    this.state = structuredClone(__classPrivateFieldGet(this, _Parser_defaultState, "f"));
-    __classPrivateFieldSet(this, _Parser_defaultDepth, 0, "f");
-}, _Parser_setRawCode = function _Parser_setRawCode(rawCode, originalRawCode) {
-    __classPrivateFieldSet(this, _Parser_rawCode, rawCode, "f");
-    __classPrivateFieldSet(this, _Parser_originalRawCode, originalRawCode ?? __classPrivateFieldGet(this, _Parser_originalRawCode, "f"), "f");
-}, _Parser_trimText = function _Parser_trimText(nodeList) {
-    const newNodeList = [];
-    let prevNode = null;
-    for (const node of nodeList) {
-        if (prevNode?.type === 'text' &&
-            // Empty node
-            node.startOffset !== node.endOffset) {
-            const prevNodeEndOffset = prevNode.endOffset;
-            const nodeStartOffset = node.startOffset;
-            if (prevNodeEndOffset > nodeStartOffset) {
-                const prevNodeRaw = prevNode.raw;
-                const prevNodeTrimmedRaw = prevNodeRaw.slice(0, nodeStartOffset - prevNode.startOffset);
-                this.updateRaw(prevNode, prevNodeTrimmedRaw);
+    /**
+     * Trim overlapping sections of text nodes for proper node separation
+     *
+     * @param nodeList
+     * @returns
+     */
+    #trimText(nodeList) {
+        const newNodeList = [];
+        let prevNode = null;
+        for (const node of nodeList) {
+            if (prevNode?.type === 'text' &&
+                // Empty node
+                node.raw.length > 0) {
+                const prevNodeEndOffset = prevNode.offset + prevNode.raw.length;
+                const nodeStartOffset = node.offset;
+                if (prevNodeEndOffset > nodeStartOffset) {
+                    const prevNodeRaw = prevNode.raw;
+                    const prevNodeTrimmedRaw = prevNodeRaw.slice(0, nodeStartOffset - prevNode.offset);
+                    this.updateRaw(prevNode, prevNodeTrimmedRaw);
+                }
             }
+            newNodeList.push(node);
+            prevNode = node;
         }
-        newNodeList.push(node);
-        prevNode = node;
+        return newNodeList;
     }
-    return newNodeList;
-};
+}