@markuplint/parser-utils 4.8.10 → 4.8.11

package/lib/parser.js

@@ -23,7 +23,22 @@ import { ignoreFrontMatter } from './ignore-front-matter.js';
 import { ParserError } from './parser-error.js';
 import { sortNodes } from './sort-nodes.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 {
+    /**
+     * 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);
@@ -51,6 +66,10 @@ export class Parser {
         __classPrivateFieldSet(this, _Parser_defaultState, defaultState ?? null, "f");
         this.state = structuredClone(__classPrivateFieldGet(this, _Parser_defaultState, "f"));
     }
+    /**
+     * 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");
     }
@@ -77,22 +96,55 @@ export class Parser {
     get endTag() {
         return __classPrivateFieldGet(this, _Parser_endTagType, "f");
     }
+    /**
+     * 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");
     }
+    /**
+     * 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");
     }
+    /**
+     * 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);
         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
@@ -168,9 +220,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);
     }
+    /**
+     * 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 +247,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 {
@@ -212,15 +289,42 @@ 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);
     }
+    /**
+     * 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,9 +350,25 @@ 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);
     }
+    /**
+     * 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;
@@ -261,6 +381,13 @@ export class Parser {
         nodeList = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_trimText).call(this, 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 +398,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 +418,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 +445,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 and namespace
+     * @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;
@@ -344,6 +497,16 @@ export class Parser {
         }
         return [startTag, ...siblings];
     }
+    /**
+     * 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 conditionalType - The conditional type if this is a conditional block (e.g., "if", "else")
+     * @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 = [], conditionalType = null, originBlockNode) {
         timer.push('visitPsBlock');
         const block = {
@@ -358,6 +521,15 @@ 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 [];
@@ -369,6 +541,13 @@ export class Parser {
         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();
@@ -390,6 +569,16 @@ export class Parser {
             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;
@@ -469,6 +658,15 @@ 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;
@@ -553,6 +751,13 @@ export class Parser {
         }
         return nodes;
     }
+    /**
+     * Updates the position and depth properties of an AST node, recalculating
+     * end offsets, lines, and columns based on the new start values.
+     *
+     * @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,
@@ -592,9 +797,25 @@ export class Parser {
     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);
     }
@@ -613,6 +834,14 @@ export class Parser {
             ...__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);
@@ -623,9 +852,29 @@ export class Parser {
             startCol: 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);
@@ -638,6 +887,14 @@ export class Parser {
             __classPrivateFieldSet(this, _Parser_walkMethodSequentailPrevNode, null, "f");
         }
     }
+    /**
+     * 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;
@@ -659,6 +916,14 @@ export class Parser {
                 : 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) {
@@ -984,9 +1249,6 @@ _Parser_booleanish = new WeakMap(), _Parser_defaultState = new WeakMap(), _Parse
     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) {
         return {

package/lib/script-parser.d.ts

@@ -1,9 +1,30 @@
 import type { CustomParser } from './types.js';
+/**
+ * Tokenizes a JavaScript code string into an array of typed tokens using espree.
+ * Each token contains its type (e.g., Identifier, Punctuator) and raw value.
+ *
+ * @param script - The JavaScript source code to tokenize
+ * @returns An array of tokens with their type and string value
+ */
 export declare function scriptParser(script: string): ScriptTokenType[];
+/**
+ * Attempts to extract the longest valid JavaScript prefix from a script string
+ * that may contain trailing non-JS content (e.g., HTML after an inline expression).
+ * Falls back to wrapping the script as an object literal or spread operator
+ * if the initial parse fails.
+ *
+ * @param script - The potentially mixed script/markup string to parse
+ * @param parse - A custom parse function to validate the script; defaults to espree with JSX support
+ * @returns An object containing the `validScript` prefix and the remaining `leftover` string
+ */
 export declare function safeScriptParser(script: string, parse?: CustomParser): {
     validScript: string;
     leftover: string;
 };
+/**
+ * A token produced by the script tokenizer, representing a single
+ * lexical unit of JavaScript source code.
+ */
 export type ScriptTokenType = {
     type: 'Identifier' | 'Boolean' | 'Numeric' | 'String' | 'Template' | 'Punctuator';
     value: string;

package/lib/script-parser.js

@@ -1,5 +1,12 @@
 // @ts-ignore
 import { tokenize, parse } from 'espree';
+/**
+ * Tokenizes a JavaScript code string into an array of typed tokens using espree.
+ * Each token contains its type (e.g., Identifier, Punctuator) and raw value.
+ *
+ * @param script - The JavaScript source code to tokenize
+ * @returns An array of tokens with their type and string value
+ */
 export function scriptParser(script) {
     const tokens = tokenize(script, {
         ecmaVersion: 'latest',
@@ -10,6 +17,16 @@ export function scriptParser(script) {
         value: token.value,
     }));
 }
+/**
+ * Attempts to extract the longest valid JavaScript prefix from a script string
+ * that may contain trailing non-JS content (e.g., HTML after an inline expression).
+ * Falls back to wrapping the script as an object literal or spread operator
+ * if the initial parse fails.
+ *
+ * @param script - The potentially mixed script/markup string to parse
+ * @param parse - A custom parse function to validate the script; defaults to espree with JSX support
+ * @returns An object containing the `validScript` prefix and the remaining `leftover` string
+ */
 export function safeScriptParser(script, parse = defaultParse) {
     let { validScript, leftover } = safeParse(script, parse);
     // Support for object literal

package/lib/types.d.ts

@@ -1,4 +1,8 @@
 import type { EndTagType, MLASTParentNode, ParserOptions as ConfigParserOptions } from '@markuplint/ml-ast';
+/**
+ * Configuration options for initializing a Parser instance,
+ * controlling how the parser handles tags, attributes, and whitespace.
+ */
 export type ParserOptions = {
     readonly booleanish?: boolean;
     readonly endTagType?: EndTagType;
@@ -9,28 +13,58 @@ export type ParserOptions = {
     readonly spaceChars?: readonly string[];
     readonly rawTextElements?: readonly string[];
 };
+/**
+ * Options passed to a single parse invocation, extending the base config parser options
+ * with offset positioning and depth control for embedded code fragments.
+ */
 export type ParseOptions = ConfigParserOptions & {
     readonly offsetOffset?: number;
     readonly offsetLine?: number;
     readonly offsetColumn?: number;
     readonly depth?: number;
 };
+/**
+ * The result of tokenizing raw source code, containing the AST nodes
+ * and metadata about whether the parsed content is a document fragment.
+ *
+ * @template N - The AST node type produced by the tokenizer
+ * @template State - The parser state type carried through tokenization
+ */
 export type Tokenized<N extends {} = {}, State extends unknown = null> = {
     readonly ast: N[];
     readonly isFragment: boolean;
     readonly state?: State;
 };
+/**
+ * A minimal source token representing a raw string fragment
+ * along with its starting position in the source code.
+ */
 export type Token = {
     readonly raw: string;
     readonly startOffset: number;
     readonly startLine: number;
     readonly startCol: number;
 };
+/**
+ * A token that belongs to a parent node in the AST, extending the base Token
+ * with nesting depth and a reference to the enclosing parent node.
+ */
 export type ChildToken = Token & {
     readonly depth: number;
     readonly parentNode: MLASTParentNode | null;
 };
+/**
+ * Determines how self-closing tags (e.g., `<br />`) are interpreted.
+ *
+ * - `"html"`: Only void elements are treated as self-closing (HTML spec behavior)
+ * - `"xml"`: The self-closing solidus (`/`) determines self-closing behavior
+ * - `"html+xml"`: Either void elements or the self-closing solidus cause self-closing
+ */
 export type SelfCloseType = 'html' | 'xml' | 'html+xml';
+/**
+ * Represents a tagged code block (e.g., template expressions or preprocessor directives)
+ * that was extracted from the source during the ignore-block phase.
+ */
 export type Code = {
     readonly type: string;
     readonly index: number;
@@ -39,22 +73,45 @@ export type Code = {
     readonly endTag: string | null;
     resolved: boolean;
 };
+/**
+ * Defines a pattern for identifying blocks of code that should be masked
+ * (replaced with placeholder characters) before parsing, such as template
+ * language expressions or preprocessor directives.
+ */
 export type IgnoreTag = {
     readonly type: string;
     readonly start: Readonly<RegExp> | string;
     readonly end: Readonly<RegExp> | string;
 };
+/**
+ * The result of masking ignore-tagged code blocks in the source, preserving
+ * the original source alongside the replaced version and a stack of extracted codes.
+ */
 export type IgnoreBlock = {
     readonly source: string;
     readonly replaced: string;
     readonly stack: readonly Code[];
     readonly maskChar: string;
 };
+/**
+ * Defines a pair of quote delimiters and the value type they enclose,
+ * used when parsing attribute values with non-standard quoting
+ * (e.g., JSX expression braces or template literals).
+ */
 export type QuoteSet = {
     readonly start: string;
     readonly end: string;
     readonly type: ValueType;
     readonly parser?: CustomParser;
 };
+/**
+ * A function that attempts to parse a code string, throwing a SyntaxError
+ * if the code is invalid. Used by the safe script parser to determine
+ * the boundary of valid script content.
+ */
 export type CustomParser = (code: string) => void;
+/**
+ * The semantic type of an attribute value, distinguishing between
+ * plain string values and script/expression values.
+ */
 export type ValueType = 'string' | 'script';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/parser-utils",
-	"version": "4.8.10",
+	"version": "4.8.11",
 	"description": "Utility module for markuplint parser plugin",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -28,17 +28,17 @@
 		"clean": "tsc --build --clean tsconfig.build.json"
 	},
 	"dependencies": {
-		"@markuplint/ml-ast": "4.4.10",
-		"@markuplint/ml-spec": "4.10.1",
-		"@markuplint/types": "4.8.1",
-		"@types/uuid": "10.0.0",
+		"@markuplint/ml-ast": "4.4.11",
+		"@markuplint/ml-spec": "4.10.2",
+		"@markuplint/types": "4.8.2",
+		"@types/uuid": "11.0.0",
 		"debug": "4.4.3",
-		"espree": "10.4.0",
+		"espree": "11.1.0",
 		"type-fest": "4.41.0",
 		"uuid": "13.0.0"
 	},
 	"devDependencies": {
-		"@typescript-eslint/typescript-estree": "8.44.0"
+		"@typescript-eslint/typescript-estree": "8.54.0"
 	},
-	"gitHead": "6213ea30269ef404f030e67bbcc7fc7443ec1060"
+	"gitHead": "193ee7c1262bbed95424e38efdf1a8e56ff049f4"
 }