@herb-tools/core 0.8.9 → 0.9.0

package/dist/types/ast-utils.d.ts

@@ -1,5 +1,6 @@
-import { Node, ERBNode, ERBContentNode, HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLAttributeNameNode, HTMLCommentNode } from "./nodes.js";
-import type { Location } from "./location.js";
+import { Node, LiteralNode, ERBNode, ERBContentNode, HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLAttributeNode, HTMLAttributeNameNode, HTMLAttributeValueNode, HTMLCommentNode, WhitespaceNode } from "./nodes.js";
+import { Location } from "./location.js";
+import { Token } from "./token.js";
 import type { Position } from "./position.js";
 export type ERBOutputNode = ERBNode & {
     tag_opening: {
@@ -80,13 +81,149 @@ export declare function getStaticAttributeName(attributeNameNode: HTMLAttributeN
  */
 export declare function getCombinedAttributeName(attributeNameNode: HTMLAttributeNameNode): string;
 /**
- * Gets the tag name of an HTML element node
+ * Gets the tag name of an HTML element, open tag, or close tag node.
+ * Returns null if the node is null/undefined.
  */
 export declare function getTagName(node: HTMLElementNode | HTMLOpenTagNode | HTMLCloseTagNode): string;
+export declare function getTagName(node: HTMLElementNode | HTMLOpenTagNode | HTMLCloseTagNode | null | undefined): string | null;
+/**
+ * Gets the lowercased tag name of an HTML element, open tag, or close tag node.
+ * Similar to `Element.localName` in the DOM API.
+ * Returns null if the node is null/undefined.
+ */
+export declare function getTagLocalName(node: HTMLElementNode | HTMLOpenTagNode | HTMLCloseTagNode): string;
+export declare function getTagLocalName(node: HTMLElementNode | HTMLOpenTagNode | HTMLCloseTagNode | null | undefined): string | null;
 /**
  * Check if a node is a comment (HTML comment or ERB comment)
  */
 export declare function isCommentNode(node: Node): node is HTMLCommentNode | ERBCommentNode;
+/**
+ * Gets the open tag node from an HTMLElementNode, handling both regular and conditional open tags.
+ * For conditional open tags, returns null.
+ * If given an HTMLOpenTagNode directly, returns it as-is.
+ */
+export declare function getOpenTag(node: HTMLElementNode | HTMLOpenTagNode | null | undefined): HTMLOpenTagNode | null;
+/**
+ * Gets attributes from an HTMLElementNode or HTMLOpenTagNode
+ */
+export declare function getAttributes(node: HTMLElementNode | HTMLOpenTagNode | null | undefined): HTMLAttributeNode[];
+/**
+ * Gets the attribute name from an HTMLAttributeNode (lowercased)
+ * Returns null if the attribute name contains dynamic content (ERB)
+ */
+export declare function getAttributeName(attributeNode: HTMLAttributeNode, lowercase?: boolean): string | null;
+/**
+ * Checks if an attribute value contains only static content (no ERB).
+ * Accepts an HTMLAttributeNode directly, or an element/open tag + attribute name.
+ * Returns false for null/undefined input.
+ */
+export declare function hasStaticAttributeValue(attributeNode: HTMLAttributeNode | null | undefined): boolean;
+export declare function hasStaticAttributeValue(node: HTMLElementNode | HTMLOpenTagNode | null | undefined, attributeName: string): boolean;
+/**
+ * Gets the static string value of an attribute (returns null if it contains ERB).
+ * Accepts an HTMLAttributeNode directly, or an element/open tag + attribute name.
+ * Returns null for null/undefined input.
+ */
+export declare function getStaticAttributeValue(attributeNode: HTMLAttributeNode | null | undefined): string | null;
+export declare function getStaticAttributeValue(node: HTMLElementNode | HTMLOpenTagNode | null | undefined, attributeName: string): string | null;
+/**
+ * Attributes whose values are space-separated token lists.
+ */
+export declare const TOKEN_LIST_ATTRIBUTES: Set<string>;
+/**
+ * Splits a space-separated attribute value into individual tokens.
+ * Accepts a string, or an element/open tag + attribute name to look up.
+ * Returns an empty array for null/undefined/empty input.
+ */
+export declare function getTokenList(value: string | null | undefined): string[];
+export declare function getTokenList(node: HTMLElementNode | HTMLOpenTagNode | null | undefined, attributeName: string): string[];
+/**
+ * Finds an attribute by name in a list of attribute nodes
+ */
+export declare function findAttributeByName(attributes: Node[], attributeName: string): HTMLAttributeNode | null;
+/**
+ * Gets a specific attribute from an HTMLElementNode or HTMLOpenTagNode by name
+ */
+export declare function getAttribute(node: HTMLElementNode | HTMLOpenTagNode | null | undefined, attributeName: string): HTMLAttributeNode | null;
+/**
+ * Checks if an element or open tag has a specific attribute
+ */
+export declare function hasAttribute(node: HTMLElementNode | HTMLOpenTagNode | null | undefined, attributeName: string): boolean;
+/**
+ * Checks if an attribute has a dynamic (ERB-containing) name.
+ * Accepts an HTMLAttributeNode (wraps the core HTMLAttributeNameNode-level check).
+ */
+export declare function hasDynamicAttributeNameOnAttribute(attributeNode: HTMLAttributeNode): boolean;
+/**
+ * Gets the combined string representation of an attribute name (including ERB syntax).
+ * Accepts an HTMLAttributeNode (wraps the core HTMLAttributeNameNode-level check).
+ */
+export declare function getCombinedAttributeNameString(attributeNode: HTMLAttributeNode): string;
+/**
+ * Checks if an attribute value contains dynamic content (ERB)
+ */
+export declare function hasDynamicAttributeValue(attributeNode: HTMLAttributeNode): boolean;
+/**
+ * Gets the value nodes array from an attribute for dynamic inspection
+ */
+export declare function getAttributeValueNodes(attributeNode: HTMLAttributeNode): Node[];
+/**
+ * Checks if an attribute value contains any static content (for validation purposes)
+ */
+export declare function hasStaticAttributeValueContent(attributeNode: HTMLAttributeNode): boolean;
+/**
+ * Gets the static content of an attribute value (all literal parts combined).
+ * Unlike getStaticAttributeValue, this extracts only the static portions from mixed content.
+ * Returns the concatenated literal content, or null if no literal nodes exist.
+ */
+export declare function getStaticAttributeValueContent(attributeNode: HTMLAttributeNode): string | null;
+/**
+ * Gets the combined attribute value including both static text and ERB tag syntax.
+ * For ERB nodes, includes the full tag syntax (e.g., "<%= foo %>").
+ * Returns null if the attribute has no value.
+ */
+export declare function getAttributeValue(attributeNode: HTMLAttributeNode): string | null;
+/**
+ * Checks if an attribute has a value node
+ */
+export declare function hasAttributeValue(attributeNode: HTMLAttributeNode): boolean;
+/**
+ * Gets the quote type used for an attribute value
+ */
+export declare function getAttributeValueQuoteType(node: HTMLAttributeNode | HTMLAttributeValueNode): "single" | "double" | "none" | null;
+/**
+ * Checks if an attribute value is quoted
+ */
+export declare function isAttributeValueQuoted(attributeNode: HTMLAttributeNode): boolean;
+/**
+ * Iterates over all attributes of an element or open tag node
+ */
+export declare function forEachAttribute(node: HTMLElementNode | HTMLOpenTagNode, callback: (attributeNode: HTMLAttributeNode) => void): void;
+/**
+ * Checks if a node is a whitespace-only literal or text node (no visible content)
+ */
+export declare function isPureWhitespaceNode(node: Node): boolean;
+/**
+ * Splits literal nodes at whitespace boundaries into separate nodes.
+ * Non-literal nodes are passed through unchanged.
+ *
+ * For example, a literal `"bg-blue-500 text-white"` becomes two literals:
+ * `"bg-blue-500"` and `" "` and `"text-white"`.
+ */
+export declare function splitLiteralsAtWhitespace(nodes: Node[]): Node[];
+/**
+ * Groups split nodes into "class groups" where each group represents a single
+ * class name (possibly spanning multiple nodes when ERB is interpolated).
+ *
+ * For example, `text-<%= color %>-500 bg-blue-500` produces two groups:
+ *   - [`text-`, ERB, `-500`] (interpolated class)
+ *   - [`bg-blue-500`] (static class)
+ *
+ * The key heuristic: a hyphen at a node boundary means the nodes are part of
+ * the same class name (e.g., `bg-` + ERB + `-500`), while whitespace means
+ * a new class name starts.
+ */
+export declare function groupNodesByClass(nodes: Node[]): Node[][];
 /**
  * Compares two positions to determine if they are equal
  * Returns true if pos1 and pos2 are at the same location
@@ -136,3 +273,48 @@ export declare function getNodesBeforePosition<T extends Node>(nodes: T[], posit
  * @param inclusive - If true, includes nodes that start exactly at the position (default: true, matching typical boundary behavior)
  */
 export declare function getNodesAfterPosition<T extends Node>(nodes: T[], position: Position, inclusive?: boolean): T[];
+/**
+ * Checks if two attributes are structurally equivalent (same name and value),
+ * ignoring positional data like location and range.
+ */
+export declare function isEquivalentAttribute(first: HTMLAttributeNode, second: HTMLAttributeNode): boolean;
+/**
+ * Checks if two open tags are structurally equivalent (same tag name and attributes),
+ * ignoring positional data like location and range.
+ */
+export declare function isEquivalentOpenTag(first: HTMLOpenTagNode, second: HTMLOpenTagNode): boolean;
+/**
+ * Checks if two elements have structurally equivalent open tags (same tag name and attributes),
+ * ignoring positional data like location and range. Does not compare body or close tag.
+ */
+export declare function isEquivalentElement(first: HTMLElementNode, second: HTMLElementNode): boolean;
+/**
+ * Finds the array containing a target node in the AST, along with its index.
+ * Traverses child arrays and linked node properties (e.g., `subsequent`, `else_clause`).
+ *
+ * Useful for autofix operations that need to splice nodes in/out of their parent array.
+ *
+ * @param root - The root node to search from
+ * @param target - The node to find
+ * @returns The containing array and the target's index, or null if not found
+ */
+export declare function findParentArray(root: Node, target: Node): {
+    array: Node[];
+    index: number;
+} | null;
+/**
+ * Removes a node from an array, also removing an adjacent preceding
+ * whitespace-only literal if present.
+ */
+export declare function removeNodeFromArray(array: Node[], node: Node): void;
+/**
+ * Replaces an element in an array with its body (children), effectively unwrapping it.
+ */
+export declare function replaceNodeWithBody(array: Node[], element: HTMLElementNode): void;
+/**
+ * Creates a synthetic LiteralNode with the given content and zero location.
+ * Useful for inserting whitespace or newlines during AST mutations.
+ */
+export declare function createLiteral(content: string): LiteralNode;
+export declare function createSyntheticToken(value: string, type?: string): Token;
+export declare function createWhitespaceNode(): WhitespaceNode;

package/dist/types/backend.d.ts

@@ -1,17 +1,17 @@
 import type { SerializedParseResult } from "./parse-result.js";
 import type { SerializedLexResult } from "./lex-result.js";
-import type { ParserOptions } from "./parser-options.js";
+import type { ParseOptions } from "./parser-options.js";
+import type { ExtractRubyOptions } from "./extract-ruby-options.js";
 interface LibHerbBackendFunctions {
     lex: (source: string) => SerializedLexResult;
-    lexFile: (path: string) => SerializedLexResult;
-    parse: (source: string, options?: ParserOptions) => SerializedParseResult;
-    parseFile: (path: string) => SerializedParseResult;
-    extractRuby: (source: string) => string;
+    parse: (source: string, options?: ParseOptions) => SerializedParseResult;
+    extractRuby: (source: string, options?: ExtractRubyOptions) => string;
     extractHTML: (source: string) => string;
+    parseRuby: (source: string) => Uint8Array | null;
     version: () => string;
 }
 export type BackendPromise = () => Promise<LibHerbBackend>;
-declare const expectedFunctions: readonly ["parse", "lex", "parseFile", "lexFile", "extractRuby", "extractHTML", "version"];
+declare const expectedFunctions: readonly ["parse", "lex", "extractRuby", "extractHTML", "parseRuby", "version"];
 type LibHerbBackendFunctionName = (typeof expectedFunctions)[number];
 export declare function _TYPECHECK(): {
     checkFunctionsExist: true;

package/dist/types/errors.d.ts

@@ -1,7 +1,8 @@
 import { Location, SerializedLocation } from "./location.js";
+import { Position, SerializedPosition } from "./position.js";
 import { Token, SerializedToken } from "./token.js";
 import { Diagnostic, MonacoDiagnostic } from "./diagnostic.js";
-export type HerbErrorType = "UNEXPECTED_ERROR" | "UNEXPECTED_TOKEN_ERROR" | "MISSING_OPENING_TAG_ERROR" | "MISSING_CLOSING_TAG_ERROR" | "TAG_NAMES_MISMATCH_ERROR" | "QUOTES_MISMATCH_ERROR" | "VOID_ELEMENT_CLOSING_TAG_ERROR" | "UNCLOSED_ELEMENT_ERROR" | "RUBY_PARSE_ERROR" | "ERB_CONTROL_FLOW_SCOPE_ERROR" | "MISSINGERB_END_TAG_ERROR" | "ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR";
+export type HerbErrorType = "UNEXPECTED_ERROR" | "UNEXPECTED_TOKEN_ERROR" | "MISSING_OPENING_TAG_ERROR" | "MISSING_CLOSING_TAG_ERROR" | "TAG_NAMES_MISMATCH_ERROR" | "VOID_ELEMENT_CLOSING_TAG_ERROR" | "UNCLOSED_ELEMENT_ERROR" | "RUBY_PARSE_ERROR" | "ERB_CONTROL_FLOW_SCOPE_ERROR" | "MISSING_ERB_END_TAG_ERROR" | "ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR" | "ERB_CASE_WITH_CONDITIONS_ERROR" | "CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR" | "CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR" | "INVALID_COMMENT_CLOSING_TAG_ERROR" | "OMITTED_CLOSING_TAG_ERROR" | "UNCLOSED_OPEN_TAG_ERROR" | "UNCLOSED_CLOSE_TAG_ERROR" | "UNCLOSED_QUOTE_ERROR" | "MISSING_ATTRIBUTE_VALUE_ERROR" | "UNCLOSED_ERB_TAG_ERROR" | "STRAY_ERB_CLOSING_TAG_ERROR" | "NESTED_ERB_TAG_ERROR";
 export type SerializedErrorType = string;
 export interface SerializedHerbError {
     type: string;
@@ -133,29 +134,6 @@ export declare class TagNamesMismatchError extends HerbError {
     toMonacoDiagnostic(): MonacoDiagnostic;
     treeInspect(): string;
 }
-export interface SerializedQuotesMismatchError {
-    type: "QUOTES_MISMATCH_ERROR";
-    message: string;
-    location: SerializedLocation;
-    opening_quote: SerializedToken | null;
-    closing_quote: SerializedToken | null;
-}
-export interface QuotesMismatchErrorProps {
-    type: string;
-    message: string;
-    location: Location;
-    opening_quote: Token | null;
-    closing_quote: Token | null;
-}
-export declare class QuotesMismatchError extends HerbError {
-    readonly opening_quote: Token | null;
-    readonly closing_quote: Token | null;
-    static from(data: SerializedQuotesMismatchError): QuotesMismatchError;
-    constructor(props: QuotesMismatchErrorProps);
-    toJSON(): SerializedQuotesMismatchError;
-    toMonacoDiagnostic(): MonacoDiagnostic;
-    treeInspect(): string;
-}
 export interface SerializedVoidElementClosingTagError {
     type: "VOID_ELEMENT_CLOSING_TAG_ERROR";
     message: string;
@@ -249,7 +227,7 @@ export declare class ERBControlFlowScopeError extends HerbError {
     treeInspect(): string;
 }
 export interface SerializedMissingERBEndTagError {
-    type: "MISSINGERB_END_TAG_ERROR";
+    type: "MISSING_ERB_END_TAG_ERROR";
     message: string;
     location: SerializedLocation;
     keyword: string;
@@ -285,4 +263,268 @@ export declare class ERBMultipleBlocksInTagError extends HerbError {
     toMonacoDiagnostic(): MonacoDiagnostic;
     treeInspect(): string;
 }
+export interface SerializedERBCaseWithConditionsError {
+    type: "ERB_CASE_WITH_CONDITIONS_ERROR";
+    message: string;
+    location: SerializedLocation;
+}
+export interface ERBCaseWithConditionsErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+}
+export declare class ERBCaseWithConditionsError extends HerbError {
+    static from(data: SerializedERBCaseWithConditionsError): ERBCaseWithConditionsError;
+    constructor(props: ERBCaseWithConditionsErrorProps);
+    toJSON(): SerializedERBCaseWithConditionsError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedConditionalElementMultipleTagsError {
+    type: "CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR";
+    message: string;
+    location: SerializedLocation;
+    line: any;
+    column: any;
+}
+export interface ConditionalElementMultipleTagsErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    line: any;
+    column: any;
+}
+export declare class ConditionalElementMultipleTagsError extends HerbError {
+    readonly line: any;
+    readonly column: any;
+    static from(data: SerializedConditionalElementMultipleTagsError): ConditionalElementMultipleTagsError;
+    constructor(props: ConditionalElementMultipleTagsErrorProps);
+    toJSON(): SerializedConditionalElementMultipleTagsError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedConditionalElementConditionMismatchError {
+    type: "CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR";
+    message: string;
+    location: SerializedLocation;
+    tag_name: string;
+    open_condition: string;
+    open_line: any;
+    open_column: any;
+    close_condition: string;
+    close_line: any;
+    close_column: any;
+}
+export interface ConditionalElementConditionMismatchErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    tag_name: string;
+    open_condition: string;
+    open_line: any;
+    open_column: any;
+    close_condition: string;
+    close_line: any;
+    close_column: any;
+}
+export declare class ConditionalElementConditionMismatchError extends HerbError {
+    readonly tag_name: string;
+    readonly open_condition: string;
+    readonly open_line: any;
+    readonly open_column: any;
+    readonly close_condition: string;
+    readonly close_line: any;
+    readonly close_column: any;
+    static from(data: SerializedConditionalElementConditionMismatchError): ConditionalElementConditionMismatchError;
+    constructor(props: ConditionalElementConditionMismatchErrorProps);
+    toJSON(): SerializedConditionalElementConditionMismatchError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedInvalidCommentClosingTagError {
+    type: "INVALID_COMMENT_CLOSING_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    closing_tag: SerializedToken | null;
+}
+export interface InvalidCommentClosingTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    closing_tag: Token | null;
+}
+export declare class InvalidCommentClosingTagError extends HerbError {
+    readonly closing_tag: Token | null;
+    static from(data: SerializedInvalidCommentClosingTagError): InvalidCommentClosingTagError;
+    constructor(props: InvalidCommentClosingTagErrorProps);
+    toJSON(): SerializedInvalidCommentClosingTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedOmittedClosingTagError {
+    type: "OMITTED_CLOSING_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    opening_tag: SerializedToken | null;
+    insertion_point: SerializedPosition;
+}
+export interface OmittedClosingTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    opening_tag: Token | null;
+    insertion_point: Position;
+}
+export declare class OmittedClosingTagError extends HerbError {
+    readonly opening_tag: Token | null;
+    readonly insertion_point: Position;
+    static from(data: SerializedOmittedClosingTagError): OmittedClosingTagError;
+    constructor(props: OmittedClosingTagErrorProps);
+    toJSON(): SerializedOmittedClosingTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedUnclosedOpenTagError {
+    type: "UNCLOSED_OPEN_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    tag_name: SerializedToken | null;
+}
+export interface UnclosedOpenTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    tag_name: Token | null;
+}
+export declare class UnclosedOpenTagError extends HerbError {
+    readonly tag_name: Token | null;
+    static from(data: SerializedUnclosedOpenTagError): UnclosedOpenTagError;
+    constructor(props: UnclosedOpenTagErrorProps);
+    toJSON(): SerializedUnclosedOpenTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedUnclosedCloseTagError {
+    type: "UNCLOSED_CLOSE_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    tag_name: SerializedToken | null;
+}
+export interface UnclosedCloseTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    tag_name: Token | null;
+}
+export declare class UnclosedCloseTagError extends HerbError {
+    readonly tag_name: Token | null;
+    static from(data: SerializedUnclosedCloseTagError): UnclosedCloseTagError;
+    constructor(props: UnclosedCloseTagErrorProps);
+    toJSON(): SerializedUnclosedCloseTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedUnclosedQuoteError {
+    type: "UNCLOSED_QUOTE_ERROR";
+    message: string;
+    location: SerializedLocation;
+    opening_quote: SerializedToken | null;
+}
+export interface UnclosedQuoteErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    opening_quote: Token | null;
+}
+export declare class UnclosedQuoteError extends HerbError {
+    readonly opening_quote: Token | null;
+    static from(data: SerializedUnclosedQuoteError): UnclosedQuoteError;
+    constructor(props: UnclosedQuoteErrorProps);
+    toJSON(): SerializedUnclosedQuoteError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedMissingAttributeValueError {
+    type: "MISSING_ATTRIBUTE_VALUE_ERROR";
+    message: string;
+    location: SerializedLocation;
+    attribute_name: string;
+}
+export interface MissingAttributeValueErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    attribute_name: string;
+}
+export declare class MissingAttributeValueError extends HerbError {
+    readonly attribute_name: string;
+    static from(data: SerializedMissingAttributeValueError): MissingAttributeValueError;
+    constructor(props: MissingAttributeValueErrorProps);
+    toJSON(): SerializedMissingAttributeValueError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedUnclosedERBTagError {
+    type: "UNCLOSED_ERB_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    opening_tag: SerializedToken | null;
+}
+export interface UnclosedERBTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    opening_tag: Token | null;
+}
+export declare class UnclosedERBTagError extends HerbError {
+    readonly opening_tag: Token | null;
+    static from(data: SerializedUnclosedERBTagError): UnclosedERBTagError;
+    constructor(props: UnclosedERBTagErrorProps);
+    toJSON(): SerializedUnclosedERBTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedStrayERBClosingTagError {
+    type: "STRAY_ERB_CLOSING_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+}
+export interface StrayERBClosingTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+}
+export declare class StrayERBClosingTagError extends HerbError {
+    static from(data: SerializedStrayERBClosingTagError): StrayERBClosingTagError;
+    constructor(props: StrayERBClosingTagErrorProps);
+    toJSON(): SerializedStrayERBClosingTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedNestedERBTagError {
+    type: "NESTED_ERB_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    opening_tag: SerializedToken | null;
+    nested_tag_line: any;
+    nested_tag_column: any;
+}
+export interface NestedERBTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    opening_tag: Token | null;
+    nested_tag_line: any;
+    nested_tag_column: any;
+}
+export declare class NestedERBTagError extends HerbError {
+    readonly opening_tag: Token | null;
+    readonly nested_tag_line: any;
+    readonly nested_tag_column: any;
+    static from(data: SerializedNestedERBTagError): NestedERBTagError;
+    constructor(props: NestedERBTagErrorProps);
+    toJSON(): SerializedNestedERBTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
 export declare function fromSerializedError(error: SerializedHerbError): HerbError;

package/dist/types/extract-ruby-options.d.ts

@@ -0,0 +1,6 @@
+export interface ExtractRubyOptions {
+    semicolons?: boolean;
+    comments?: boolean;
+    preserve_positions?: boolean;
+}
+export declare const DEFAULT_EXTRACT_RUBY_OPTIONS: ExtractRubyOptions;

package/dist/types/herb-backend.d.ts

@@ -1,7 +1,9 @@
 import { LexResult } from "./lex-result.js";
 import { ParseResult } from "./parse-result.js";
 import type { LibHerbBackend, BackendPromise } from "./backend.js";
-import type { ParserOptions } from "./parser-options.js";
+import type { ParseOptions } from "./parser-options.js";
+import type { ExtractRubyOptions } from "./extract-ruby-options.js";
+import type { PrismParseResult } from "./prism/index.js";
 /**
  * The main Herb parser interface, providing methods to lex and parse input.
  */
@@ -31,9 +33,8 @@ export declare abstract class HerbBackend {
      * Lexes a file.
      * @param path - The file path to lex.
      * @returns A `LexResult` instance.
-     * @throws Error if the backend is not loaded.
      */
-    lexFile(path: string): LexResult;
+    abstract lexFile(path: string): LexResult;
     /**
      * Parses the given source string into a `ParseResult`.
      * @param source - The source code to parse.
@@ -41,21 +42,28 @@ export declare abstract class HerbBackend {
      * @returns A `ParseResult` instance.
      * @throws Error if the backend is not loaded.
      */
-    parse(source: string, options?: ParserOptions): ParseResult;
+    parse(source: string, options?: ParseOptions): ParseResult;
     /**
      * Parses a file.
      * @param path - The file path to parse.
      * @returns A `ParseResult` instance.
-     * @throws Error if the backend is not loaded.
      */
-    parseFile(path: string): ParseResult;
+    abstract parseFile(path: string): ParseResult;
     /**
      * Extracts embedded Ruby code from the given source.
      * @param source - The source code to extract Ruby from.
+     * @param options - Optional extraction options.
      * @returns The extracted Ruby code as a string.
      * @throws Error if the backend is not loaded.
      */
-    extractRuby(source: string): string;
+    extractRuby(source: string, options?: ExtractRubyOptions): string;
+    /**
+     * Parses a Ruby source string using Prism via the libherb backend.
+     * @param source - The Ruby source code to parse.
+     * @returns A Prism ParseResult containing the AST.
+     * @throws Error if the backend is not loaded.
+     */
+    parseRuby(source: string): PrismParseResult;
     /**
      * Extracts HTML from the given source.
      * @param source - The source code to extract HTML from.

package/dist/types/index.d.ts

@@ -3,6 +3,7 @@ export * from "./backend.js";
 export * from "./diagnostic.js";
 export * from "./didyoumean.js";
 export * from "./errors.js";
+export * from "./extract-ruby-options.js";
 export * from "./herb-backend.js";
 export * from "./levenshtein.js";
 export * from "./lex-result.js";
@@ -19,3 +20,4 @@ export * from "./token.js";
 export * from "./util.js";
 export * from "./visitor.js";
 export * from "./warning.js";
+export * from "./prism";