@herb-tools/core 0.2.0 → 0.3.0

package/dist/types/lex-result.d.ts

@@ -1,10 +1,15 @@
 import { Result } from "./result.js";
-import { TokenList, SerializedTokenList } from "./token-list.js";
+import { TokenList } from "./token-list.js";
+import { HerbError } from "./errors.js";
+import { HerbWarning } from "./warning.js";
+import type { SerializedHerbError } from "./errors.js";
+import type { SerializedHerbWarning } from "./warning.js";
+import type { SerializedTokenList } from "./token-list.js";
 export type SerializedLexResult = {
     tokens: SerializedTokenList;
     source: string;
-    warnings: any[];
-    errors: any[];
+    warnings: SerializedHerbWarning[];
+    errors: SerializedHerbError[];
 };
 /**
  * Represents the result of a lexical analysis, extending the base `Result` class.
@@ -26,17 +31,17 @@ export declare class LexResult extends Result {
      * @param warnings - An array of warnings encountered during lexing.
      * @param errors - An array of errors encountered during lexing.
      */
-    constructor(value: TokenList, source: string, warnings?: any[], errors?: any[]);
+    constructor(value: TokenList, source: string, warnings?: HerbWarning[], errors?: HerbError[]);
     /**
      * Determines if the lexing was successful.
      * @returns `true` if there are no errors, otherwise `false`.
      */
-    success(): boolean;
+    get successful(): boolean;
     /**
      * Determines if the lexing failed.
      * @returns `true` if there are errors, otherwise `false`.
      */
-    failed(): boolean;
+    get failed(): boolean;
     /**
      * Converts the `LexResult` to a JSON representation.
      * @returns An object containing the token list, source, warnings, and errors.
@@ -44,7 +49,7 @@ export declare class LexResult extends Result {
     toJSON(): {
         value: TokenList;
         source: string;
-        warnings: import("./warning.js").HerbWarning[];
-        errors: import("./error.js").HerbError[];
+        warnings: HerbWarning[];
+        errors: HerbError[];
     };
 }

package/dist/types/nodes.d.ts

@@ -1,11 +1,38 @@
-import { Node } from "./node.js";
+import { Location } from "./location.js";
 import { Token, SerializedToken } from "./token.js";
-import { HerbError } from "./error.js";
+import { HerbError } from "./errors.js";
+import type { SerializedLocation } from "./location.js";
+import type { SerializedHerbError } from "./errors.js";
 import type { Visitor } from "./visitor.js";
-import type { SerializedNode, BaseNodeProps } from "./node.js";
-export declare function fromSerializedNode(node: SerializedNode): Node;
 export type SerializedNodeType = string;
+export interface SerializedNode {
+    type: SerializedNodeType;
+    location: SerializedLocation;
+    errors: SerializedHerbError[];
+}
+export interface BaseNodeProps {
+    type: NodeType;
+    location: Location;
+    errors: HerbError[];
+}
 export type NodeType = "AST_DOCUMENT_NODE" | "AST_LITERAL_NODE" | "AST_HTML_OPEN_TAG_NODE" | "AST_HTML_CLOSE_TAG_NODE" | "AST_HTML_SELF_CLOSE_TAG_NODE" | "AST_HTML_ELEMENT_NODE" | "AST_HTML_ATTRIBUTE_VALUE_NODE" | "AST_HTML_ATTRIBUTE_NAME_NODE" | "AST_HTML_ATTRIBUTE_NODE" | "AST_HTML_TEXT_NODE" | "AST_HTML_COMMENT_NODE" | "AST_HTML_DOCTYPE_NODE" | "AST_WHITESPACE_NODE" | "AST_ERB_CONTENT_NODE" | "AST_ERB_END_NODE" | "AST_ERB_ELSE_NODE" | "AST_ERB_IF_NODE" | "AST_ERB_BLOCK_NODE" | "AST_ERB_WHEN_NODE" | "AST_ERB_CASE_NODE" | "AST_ERB_CASE_MATCH_NODE" | "AST_ERB_WHILE_NODE" | "AST_ERB_UNTIL_NODE" | "AST_ERB_FOR_NODE" | "AST_ERB_RESCUE_NODE" | "AST_ERB_ENSURE_NODE" | "AST_ERB_BEGIN_NODE" | "AST_ERB_UNLESS_NODE" | "AST_ERB_YIELD_NODE" | "AST_ERB_IN_NODE";
+export declare abstract class Node implements BaseNodeProps {
+    readonly type: NodeType;
+    readonly location: Location;
+    readonly errors: HerbError[];
+    static from(node: SerializedNode): Node;
+    constructor(type: NodeType, location: Location, errors: HerbError[]);
+    toJSON(): SerializedNode;
+    inspect(): string;
+    get isSingleLine(): boolean;
+    abstract treeInspect(indent?: number): string;
+    abstract recursiveErrors(): HerbError[];
+    abstract accept(visitor: Visitor): void;
+    abstract childNodes(): (Node | null | undefined)[];
+    abstract compactChildNodes(): Node[];
+    protected inspectArray(array: (Node | HerbError)[] | null | undefined, prefix: string): string;
+    protected inspectNode(node: Node | HerbError | undefined | null, prefix: string, prefix2?: string, last?: boolean, trailingNewline?: boolean): string;
+}
 export interface SerializedDocumentNode extends SerializedNode {
     type: "AST_DOCUMENT_NODE";
     children: SerializedNode[];
@@ -822,3 +849,4 @@ export declare class ERBInNode extends Node {
     toJSON(): SerializedERBInNode;
     treeInspect(): string;
 }
+export declare function fromSerializedNode(node: SerializedNode): Node;

package/dist/types/parse-result.d.ts

@@ -1,8 +1,8 @@
 import { Result } from "./result.js";
 import { DocumentNode } from "./nodes.js";
-import { HerbError } from "./error.js";
+import { HerbError } from "./errors.js";
 import { HerbWarning } from "./warning.js";
-import type { SerializedHerbError } from "./error.js";
+import type { SerializedHerbError } from "./errors.js";
 import type { SerializedHerbWarning } from "./warning.js";
 import type { SerializedDocumentNode } from "./nodes.js";
 import type { Visitor } from "./visitor.js";
@@ -37,12 +37,12 @@ export declare class ParseResult extends Result {
      * Determines if the parsing failed.
      * @returns `true` if there are errors, otherwise `false`.
      */
-    failed(): boolean;
+    get failed(): boolean;
     /**
      * Determines if the parsing was successful.
      * @returns `true` if there are no errors, otherwise `false`.
      */
-    success(): boolean;
+    get successful(): boolean;
     /**
      * Returns a pretty-printed JSON string of the errors.
      * @returns A string representation of the errors.

package/dist/types/result.d.ts

@@ -1,10 +1,18 @@
-import { HerbError } from "./error.js";
+import { HerbError } from "./errors.js";
 import { HerbWarning } from "./warning.js";
-export declare class Result {
+export declare abstract class Result {
     readonly source: string;
     readonly warnings: HerbWarning[];
     readonly errors: HerbError[];
     constructor(source: string, warnings?: HerbWarning[], errors?: HerbError[]);
-    success(): boolean;
-    failed(): boolean;
+    /**
+     * Determines if the parsing was successful.
+     * @returns `true` if there are no errors, otherwise `false`.
+     */
+    get successful(): boolean;
+    /**
+     * Determines if the parsing failed.
+     * @returns `true` if there are errors, otherwise `false`.
+     */
+    get failed(): boolean;
 }

package/dist/types/visitor.d.ts

@@ -1,5 +1,4 @@
-import { Node } from "./node";
-import { DocumentNode, LiteralNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, HTMLElementNode, HTMLAttributeValueNode, HTMLAttributeNameNode, HTMLAttributeNode, HTMLTextNode, HTMLCommentNode, HTMLDoctypeNode, WhitespaceNode, ERBContentNode, ERBEndNode, ERBElseNode, ERBIfNode, ERBBlockNode, ERBWhenNode, ERBCaseNode, ERBCaseMatchNode, ERBWhileNode, ERBUntilNode, ERBForNode, ERBRescueNode, ERBEnsureNode, ERBBeginNode, ERBUnlessNode, ERBYieldNode, ERBInNode } from "./nodes.js";
+import { Node, DocumentNode, LiteralNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, HTMLElementNode, HTMLAttributeValueNode, HTMLAttributeNameNode, HTMLAttributeNode, HTMLTextNode, HTMLCommentNode, HTMLDoctypeNode, WhitespaceNode, ERBContentNode, ERBEndNode, ERBElseNode, ERBIfNode, ERBBlockNode, ERBWhenNode, ERBCaseNode, ERBCaseMatchNode, ERBWhileNode, ERBUntilNode, ERBForNode, ERBRescueNode, ERBEnsureNode, ERBBeginNode, ERBUnlessNode, ERBYieldNode, ERBInNode } from "./nodes.js";
 export declare class Visitor {
     visit(node: Node | null | undefined): void;
     visitAll(nodes: (Node | null | undefined)[]): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",

package/src/errors.ts

@@ -3,7 +3,6 @@
 
 import { Location, SerializedLocation } from "./location.js"
 import { Token, SerializedToken } from "./token.js"
-import { HerbError, SerializedHerbError } from "./error.js"
 
 type HerbDiagnostic = {
   line: number
@@ -27,21 +26,40 @@ export type HerbErrorType =
 
 export type SerializedErrorType = string
 
-export function fromSerializedError(error: SerializedHerbError): HerbError {
-  switch (error.type) {
-    case "UNEXPECTED_ERROR": return UnexpectedError.from(error as SerializedUnexpectedError);
-    case "UNEXPECTED_TOKEN_ERROR": return UnexpectedTokenError.from(error as SerializedUnexpectedTokenError);
-    case "MISSING_OPENING_TAG_ERROR": return MissingOpeningTagError.from(error as SerializedMissingOpeningTagError);
-    case "MISSING_CLOSING_TAG_ERROR": return MissingClosingTagError.from(error as SerializedMissingClosingTagError);
-    case "TAG_NAMES_MISMATCH_ERROR": return TagNamesMismatchError.from(error as SerializedTagNamesMismatchError);
-    case "QUOTES_MISMATCH_ERROR": return QuotesMismatchError.from(error as SerializedQuotesMismatchError);
-    case "VOID_ELEMENT_CLOSING_TAG_ERROR": return VoidElementClosingTagError.from(error as SerializedVoidElementClosingTagError);
-    case "UNCLOSED_ELEMENT_ERROR": return UnclosedElementError.from(error as SerializedUnclosedElementError);
-    case "RUBY_PARSE_ERROR": return RubyParseError.from(error as SerializedRubyParseError);
+export interface SerializedHerbError {
+  type: string
+  message: string
+  location: SerializedLocation
+}
 
-    default:
-      throw new Error(`Unknown node type: ${error.type}`);
+export abstract class HerbError {
+  readonly type: string
+  readonly message: string
+  readonly location: Location
+
+  static from(error: SerializedHerbError): HerbError {
+    return fromSerializedError(error)
+  }
+
+  constructor(type: string, message: string, location: Location) {
+    this.type = type
+    this.message = message
+    this.location = location
+  }
+
+  toJSON(): SerializedHerbError {
+    return {
+      type: this.type,
+      message: this.message,
+      location: this.location.toJSON(),
+    }
+  }
+
+  inspect(): string {
+    return this.treeInspect(0)
   }
+
+  abstract treeInspect(indent?: number): string
 }
 
 export interface SerializedUnexpectedError {
@@ -818,3 +836,20 @@ export class RubyParseError extends HerbError {
   }
 }
 
+
+export function fromSerializedError(error: SerializedHerbError): HerbError {
+  switch (error.type) {
+    case "UNEXPECTED_ERROR": return UnexpectedError.from(error as SerializedUnexpectedError);
+    case "UNEXPECTED_TOKEN_ERROR": return UnexpectedTokenError.from(error as SerializedUnexpectedTokenError);
+    case "MISSING_OPENING_TAG_ERROR": return MissingOpeningTagError.from(error as SerializedMissingOpeningTagError);
+    case "MISSING_CLOSING_TAG_ERROR": return MissingClosingTagError.from(error as SerializedMissingClosingTagError);
+    case "TAG_NAMES_MISMATCH_ERROR": return TagNamesMismatchError.from(error as SerializedTagNamesMismatchError);
+    case "QUOTES_MISMATCH_ERROR": return QuotesMismatchError.from(error as SerializedQuotesMismatchError);
+    case "VOID_ELEMENT_CLOSING_TAG_ERROR": return VoidElementClosingTagError.from(error as SerializedVoidElementClosingTagError);
+    case "UNCLOSED_ELEMENT_ERROR": return UnclosedElementError.from(error as SerializedUnclosedElementError);
+    case "RUBY_PARSE_ERROR": return RubyParseError.from(error as SerializedRubyParseError);
+
+    default:
+      throw new Error(`Unknown node type: ${error.type}`);
+  }
+}

package/src/index.ts

@@ -3,7 +3,6 @@ export * from "./errors.js"
 export * from "./herb-backend.js"
 export * from "./lex-result.js"
 export * from "./location.js"
-export * from "./node.js"
 export * from "./nodes.js"
 export * from "./parse-result.js"
 export * from "./position.js"
@@ -13,3 +12,4 @@ export * from "./token-list.js"
 export * from "./token.js"
 export * from "./util.js"
 export * from "./visitor.js"
+export * from "./warning.js"

package/src/lex-result.ts

@@ -1,11 +1,17 @@
 import { Result } from "./result.js"
-import { TokenList, SerializedTokenList } from "./token-list.js"
+import { TokenList } from "./token-list.js"
+import { HerbError } from "./errors.js"
+import { HerbWarning } from "./warning.js"
+
+import type { SerializedHerbError } from "./errors.js"
+import type { SerializedHerbWarning } from "./warning.js"
+import type { SerializedTokenList } from "./token-list.js"
 
 export type SerializedLexResult = {
   tokens: SerializedTokenList
   source: string
-  warnings: any[]
-  errors: any[]
+  warnings: SerializedHerbWarning[]
+  errors: SerializedHerbError[]
 }
 
 /**
@@ -25,8 +31,8 @@ export class LexResult extends Result {
     return new LexResult(
       TokenList.from(result.tokens || []),
       result.source,
-      result.warnings,
-      result.errors,
+      result.warnings.map((warning) => HerbWarning.from(warning)),
+      result.errors.map((error) => HerbError.from(error)),
     )
   }
 
@@ -40,8 +46,8 @@ export class LexResult extends Result {
   constructor(
     value: TokenList,
     source: string,
-    warnings: any[] = [],
-    errors: any[] = [],
+    warnings: HerbWarning[] = [],
+    errors: HerbError[] = [],
   ) {
     super(source, warnings, errors)
     this.value = value
@@ -51,7 +57,7 @@ export class LexResult extends Result {
    * Determines if the lexing was successful.
    * @returns `true` if there are no errors, otherwise `false`.
    */
-  override success(): boolean {
+  get successful(): boolean {
     return this.errors.length === 0
   }
 
@@ -59,7 +65,7 @@ export class LexResult extends Result {
    * Determines if the lexing failed.
    * @returns `true` if there are errors, otherwise `false`.
    */
-  override failed(): boolean {
+  get failed(): boolean {
     return this.errors.length > 0
   }
 

package/src/nodes.ts

@@ -1,53 +1,28 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
 // be modified manually. See /Users/marcoroth/Development/herb-release/templates/javascript/packages/core/src/nodes.ts.erb
 
-import { Node } from "./node.js"
 import { Location } from "./location.js"
 import { Token, SerializedToken } from "./token.js"
-import { HerbError } from "./error.js"
+import { HerbError } from "./errors.js"
 import { convertToUTF8 } from "./util.js"
 
+import type { SerializedLocation } from "./location.js"
+import type { SerializedHerbError } from "./errors.js"
 import type { Visitor } from "./visitor.js"
-import type { SerializedNode, BaseNodeProps } from "./node.js"
 
-export function fromSerializedNode(node: SerializedNode): Node {
-  switch (node.type) {
-    case "AST_DOCUMENT_NODE": return DocumentNode.from(node as SerializedDocumentNode);
-    case "AST_LITERAL_NODE": return LiteralNode.from(node as SerializedLiteralNode);
-    case "AST_HTML_OPEN_TAG_NODE": return HTMLOpenTagNode.from(node as SerializedHTMLOpenTagNode);
-    case "AST_HTML_CLOSE_TAG_NODE": return HTMLCloseTagNode.from(node as SerializedHTMLCloseTagNode);
-    case "AST_HTML_SELF_CLOSE_TAG_NODE": return HTMLSelfCloseTagNode.from(node as SerializedHTMLSelfCloseTagNode);
-    case "AST_HTML_ELEMENT_NODE": return HTMLElementNode.from(node as SerializedHTMLElementNode);
-    case "AST_HTML_ATTRIBUTE_VALUE_NODE": return HTMLAttributeValueNode.from(node as SerializedHTMLAttributeValueNode);
-    case "AST_HTML_ATTRIBUTE_NAME_NODE": return HTMLAttributeNameNode.from(node as SerializedHTMLAttributeNameNode);
-    case "AST_HTML_ATTRIBUTE_NODE": return HTMLAttributeNode.from(node as SerializedHTMLAttributeNode);
-    case "AST_HTML_TEXT_NODE": return HTMLTextNode.from(node as SerializedHTMLTextNode);
-    case "AST_HTML_COMMENT_NODE": return HTMLCommentNode.from(node as SerializedHTMLCommentNode);
-    case "AST_HTML_DOCTYPE_NODE": return HTMLDoctypeNode.from(node as SerializedHTMLDoctypeNode);
-    case "AST_WHITESPACE_NODE": return WhitespaceNode.from(node as SerializedWhitespaceNode);
-    case "AST_ERB_CONTENT_NODE": return ERBContentNode.from(node as SerializedERBContentNode);
-    case "AST_ERB_END_NODE": return ERBEndNode.from(node as SerializedERBEndNode);
-    case "AST_ERB_ELSE_NODE": return ERBElseNode.from(node as SerializedERBElseNode);
-    case "AST_ERB_IF_NODE": return ERBIfNode.from(node as SerializedERBIfNode);
-    case "AST_ERB_BLOCK_NODE": return ERBBlockNode.from(node as SerializedERBBlockNode);
-    case "AST_ERB_WHEN_NODE": return ERBWhenNode.from(node as SerializedERBWhenNode);
-    case "AST_ERB_CASE_NODE": return ERBCaseNode.from(node as SerializedERBCaseNode);
-    case "AST_ERB_CASE_MATCH_NODE": return ERBCaseMatchNode.from(node as SerializedERBCaseMatchNode);
-    case "AST_ERB_WHILE_NODE": return ERBWhileNode.from(node as SerializedERBWhileNode);
-    case "AST_ERB_UNTIL_NODE": return ERBUntilNode.from(node as SerializedERBUntilNode);
-    case "AST_ERB_FOR_NODE": return ERBForNode.from(node as SerializedERBForNode);
-    case "AST_ERB_RESCUE_NODE": return ERBRescueNode.from(node as SerializedERBRescueNode);
-    case "AST_ERB_ENSURE_NODE": return ERBEnsureNode.from(node as SerializedERBEnsureNode);
-    case "AST_ERB_BEGIN_NODE": return ERBBeginNode.from(node as SerializedERBBeginNode);
-    case "AST_ERB_UNLESS_NODE": return ERBUnlessNode.from(node as SerializedERBUnlessNode);
-    case "AST_ERB_YIELD_NODE": return ERBYieldNode.from(node as SerializedERBYieldNode);
-    case "AST_ERB_IN_NODE": return ERBInNode.from(node as SerializedERBInNode);
+export type SerializedNodeType = string
 
-    default:
-      throw new Error(`Unknown node type: ${node.type}`);
-  }
+export interface SerializedNode {
+  type: SerializedNodeType
+  location: SerializedLocation
+  errors: SerializedHerbError[]
+}
+
+export interface BaseNodeProps {
+  type: NodeType
+  location: Location
+  errors: HerbError[]
 }
-export type SerializedNodeType = string
 
 export type NodeType =
   | "AST_DOCUMENT_NODE"
@@ -81,6 +56,103 @@ export type NodeType =
   | "AST_ERB_YIELD_NODE"
   | "AST_ERB_IN_NODE"
 
+export abstract class Node implements BaseNodeProps {
+  readonly type: NodeType
+  readonly location: Location
+  readonly errors: HerbError[]
+
+  static from(node: SerializedNode): Node {
+    return fromSerializedNode(node)
+  }
+
+  constructor(type: NodeType, location: Location, errors: HerbError[]) {
+    this.type = type
+    this.location = location
+    this.errors = errors
+  }
+
+  toJSON(): SerializedNode {
+    return {
+      type: this.type,
+      location: this.location.toJSON(),
+      errors: this.errors,
+    }
+  }
+
+  inspect(): string {
+    return this.treeInspect(0)
+  }
+
+  get isSingleLine(): boolean {
+    return this.location.start.line === this.location.end.line
+  }
+
+  abstract treeInspect(indent?: number): string
+  abstract recursiveErrors(): HerbError[]
+  abstract accept(visitor: Visitor): void
+  abstract childNodes(): (Node | null | undefined)[]
+  abstract compactChildNodes(): Node[]
+
+  protected inspectArray(
+    array: (Node | HerbError)[] | null | undefined,
+    prefix: string,
+  ): string {
+    if (!array) return "∅\n"
+    if (array.length === 0) return "[]\n"
+
+    let output = `(${array.length} item${array.length == 1 ? "" : "s"})\n`
+
+    array.forEach((item, index) => {
+      const isLast = index === array.length - 1
+
+      if (item instanceof Node || item instanceof HerbError) {
+        output += this.inspectNode(
+          item,
+          prefix,
+          isLast ? "    " : "│   ",
+          isLast,
+          false,
+        )
+      } else {
+        const symbol = isLast ? "└── " : "├── "
+        output += `${prefix}${symbol} ${item}\n`
+      }
+    })
+
+    output += `${prefix}\n`
+
+    return output
+  }
+
+  protected inspectNode(
+    node: Node | HerbError | undefined | null,
+    prefix: string,
+    prefix2: string = "    ",
+    last: boolean = true,
+    trailingNewline: boolean = true,
+  ): string {
+    if (!node) return "∅\n"
+
+    let output = trailingNewline ? "\n" : ""
+    output += `${prefix}`
+
+    output += last ? "└── " : "├── "
+    output += node
+      .treeInspect()
+      .trimStart()
+      .split("\n")
+      .map((line, index) =>
+        index == 0 ? line.trimStart() : `${prefix}${prefix2}${line}`,
+      )
+      .join("\n")
+      .trimStart()
+
+    output += `\n`
+
+    return output
+  }
+}
+
 export interface SerializedDocumentNode extends SerializedNode {
   type: "AST_DOCUMENT_NODE";
   children: SerializedNode[];
@@ -2800,3 +2872,41 @@ export class ERBInNode extends Node {
   }
 }
 
+
+export function fromSerializedNode(node: SerializedNode): Node {
+  switch (node.type) {
+    case "AST_DOCUMENT_NODE": return DocumentNode.from(node as SerializedDocumentNode);
+    case "AST_LITERAL_NODE": return LiteralNode.from(node as SerializedLiteralNode);
+    case "AST_HTML_OPEN_TAG_NODE": return HTMLOpenTagNode.from(node as SerializedHTMLOpenTagNode);
+    case "AST_HTML_CLOSE_TAG_NODE": return HTMLCloseTagNode.from(node as SerializedHTMLCloseTagNode);
+    case "AST_HTML_SELF_CLOSE_TAG_NODE": return HTMLSelfCloseTagNode.from(node as SerializedHTMLSelfCloseTagNode);
+    case "AST_HTML_ELEMENT_NODE": return HTMLElementNode.from(node as SerializedHTMLElementNode);
+    case "AST_HTML_ATTRIBUTE_VALUE_NODE": return HTMLAttributeValueNode.from(node as SerializedHTMLAttributeValueNode);
+    case "AST_HTML_ATTRIBUTE_NAME_NODE": return HTMLAttributeNameNode.from(node as SerializedHTMLAttributeNameNode);
+    case "AST_HTML_ATTRIBUTE_NODE": return HTMLAttributeNode.from(node as SerializedHTMLAttributeNode);
+    case "AST_HTML_TEXT_NODE": return HTMLTextNode.from(node as SerializedHTMLTextNode);
+    case "AST_HTML_COMMENT_NODE": return HTMLCommentNode.from(node as SerializedHTMLCommentNode);
+    case "AST_HTML_DOCTYPE_NODE": return HTMLDoctypeNode.from(node as SerializedHTMLDoctypeNode);
+    case "AST_WHITESPACE_NODE": return WhitespaceNode.from(node as SerializedWhitespaceNode);
+    case "AST_ERB_CONTENT_NODE": return ERBContentNode.from(node as SerializedERBContentNode);
+    case "AST_ERB_END_NODE": return ERBEndNode.from(node as SerializedERBEndNode);
+    case "AST_ERB_ELSE_NODE": return ERBElseNode.from(node as SerializedERBElseNode);
+    case "AST_ERB_IF_NODE": return ERBIfNode.from(node as SerializedERBIfNode);
+    case "AST_ERB_BLOCK_NODE": return ERBBlockNode.from(node as SerializedERBBlockNode);
+    case "AST_ERB_WHEN_NODE": return ERBWhenNode.from(node as SerializedERBWhenNode);
+    case "AST_ERB_CASE_NODE": return ERBCaseNode.from(node as SerializedERBCaseNode);
+    case "AST_ERB_CASE_MATCH_NODE": return ERBCaseMatchNode.from(node as SerializedERBCaseMatchNode);
+    case "AST_ERB_WHILE_NODE": return ERBWhileNode.from(node as SerializedERBWhileNode);
+    case "AST_ERB_UNTIL_NODE": return ERBUntilNode.from(node as SerializedERBUntilNode);
+    case "AST_ERB_FOR_NODE": return ERBForNode.from(node as SerializedERBForNode);
+    case "AST_ERB_RESCUE_NODE": return ERBRescueNode.from(node as SerializedERBRescueNode);
+    case "AST_ERB_ENSURE_NODE": return ERBEnsureNode.from(node as SerializedERBEnsureNode);
+    case "AST_ERB_BEGIN_NODE": return ERBBeginNode.from(node as SerializedERBBeginNode);
+    case "AST_ERB_UNLESS_NODE": return ERBUnlessNode.from(node as SerializedERBUnlessNode);
+    case "AST_ERB_YIELD_NODE": return ERBYieldNode.from(node as SerializedERBYieldNode);
+    case "AST_ERB_IN_NODE": return ERBInNode.from(node as SerializedERBInNode);
+
+    default:
+      throw new Error(`Unknown node type: ${node.type}`);
+  }
+}

package/src/parse-result.ts

@@ -1,11 +1,13 @@
 import { Result } from "./result.js"
+
 import { DocumentNode } from "./nodes.js"
-import { HerbError } from "./error.js"
+import { HerbError } from "./errors.js"
 import { HerbWarning } from "./warning.js"
 
-import type { SerializedHerbError } from "./error.js"
+import type { SerializedHerbError } from "./errors.js"
 import type { SerializedHerbWarning } from "./warning.js"
 import type { SerializedDocumentNode } from "./nodes.js"
+
 import type { Visitor } from "./visitor.js"
 
 export type SerializedParseResult = {
@@ -58,7 +60,7 @@ export class ParseResult extends Result {
    * Determines if the parsing failed.
    * @returns `true` if there are errors, otherwise `false`.
    */
-  failed(): boolean {
+  get failed(): boolean {
     // TODO: this should probably be recursive as noted in the Ruby version
     return this.errors.length > 0 || this.value.errors.length > 0
   }
@@ -67,8 +69,8 @@ export class ParseResult extends Result {
    * Determines if the parsing was successful.
    * @returns `true` if there are no errors, otherwise `false`.
    */
-  success(): boolean {
-    return !this.failed()
+  get successful(): boolean {
+    return this.errors.length === 0
   }
 
   /**

package/src/result.ts

@@ -1,7 +1,7 @@
-import { HerbError } from "./error.js"
+import { HerbError } from "./errors.js"
 import { HerbWarning } from "./warning.js"
 
-export class Result {
+export abstract class Result {
   readonly source: string
   readonly warnings: HerbWarning[]
   readonly errors: HerbError[]
@@ -16,11 +16,19 @@ export class Result {
     this.errors = errors || []
   }
 
-  success(): boolean {
-    return false
+  /**
+   * Determines if the parsing was successful.
+   * @returns `true` if there are no errors, otherwise `false`.
+   */
+  get successful(): boolean {
+    return this.errors.length === 0
   }
 
-  failed(): boolean {
-    return true
+  /**
+   * Determines if the parsing failed.
+   * @returns `true` if there are errors, otherwise `false`.
+   */
+  get failed(): boolean {
+    return this.errors.length > 0
   }
 }

package/src/visitor.ts

@@ -1,9 +1,8 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
 // be modified manually. See /Users/marcoroth/Development/herb-release/templates/javascript/packages/core/src/visitor.ts.erb
 
-import { Node } from "./node"
-
 import {
+  Node,
   DocumentNode,
   LiteralNode,
   HTMLOpenTagNode,

package/dist/types/error.d.ts

@@ -1,16 +0,0 @@
-import { Location, SerializedLocation } from "./location.js";
-export interface SerializedHerbError {
-    type: string;
-    message: string;
-    location: SerializedLocation;
-}
-export declare abstract class HerbError {
-    readonly type: string;
-    readonly message: string;
-    readonly location: Location;
-    static from(error: SerializedHerbError): HerbError;
-    constructor(type: string, message: string, location: Location);
-    toJSON(): SerializedHerbError;
-    inspect(): string;
-    abstract treeInspect(indent?: number): string;
-}

package/dist/types/node.d.ts

@@ -1,30 +0,0 @@
-import { Location, SerializedLocation } from "./location.js";
-import { HerbError, SerializedHerbError } from "./error.js";
-import { NodeType, SerializedNodeType } from "./nodes.js";
-import type { Visitor } from "./visitor.js";
-export interface SerializedNode {
-    type: SerializedNodeType;
-    location: SerializedLocation;
-    errors: SerializedHerbError[];
-}
-export interface BaseNodeProps {
-    type: NodeType;
-    location: Location;
-    errors: HerbError[];
-}
-export declare abstract class Node implements BaseNodeProps {
-    readonly type: NodeType;
-    readonly location: Location;
-    readonly errors: HerbError[];
-    static from(node: SerializedNode): Node;
-    constructor(type: NodeType, location: Location, errors: HerbError[]);
-    toJSON(): SerializedNode;
-    inspect(): string;
-    abstract treeInspect(indent?: number): string;
-    abstract recursiveErrors(): HerbError[];
-    abstract accept(visitor: Visitor): void;
-    abstract childNodes(): (Node | null | undefined)[];
-    abstract compactChildNodes(): Node[];
-    protected inspectArray(array: (Node | HerbError)[] | null | undefined, prefix: string): string;
-    protected inspectNode(node: Node | HerbError | undefined | null, prefix: string, prefix2?: string, last?: boolean, trailingNewline?: boolean): string;
-}