@herb-tools/core 0.1.0

package/dist/herb-core.cjs

@@ -0,0 +1,2759 @@
+'use strict';
+
+class ASTNode {
+    errors;
+    constructor() {
+        this.errors = [];
+    }
+}
+
+const expectedFunctions = [
+    "parse",
+    "lex",
+    "parseFile",
+    "lexFile",
+    "extractRuby",
+    "extractHTML",
+    "version",
+];
+// NOTE: This function should never be called and is only for type checking
+// so we can make sure `expectedFunctions` matches the functions defined
+// in `LibHerbBackendFunctions` and the other way around.
+//
+function _TYPECHECK() {
+    const checkFunctionsExist = true;
+    const checkInterfaceComplete = true;
+    return { checkFunctionsExist, checkInterfaceComplete };
+}
+function isLibHerbBackend(object, libherbpath = "unknown") {
+    for (const expectedFunction of expectedFunctions) {
+        if (object[expectedFunction] === undefined) {
+            throw new Error(`Libherb at "${libherbpath}" doesn't expose function "${expectedFunction}".`);
+        }
+        if (typeof object[expectedFunction] !== "function") {
+            throw new Error(`Libherb at "${libherbpath}" has "${expectedFunction}" but it's not a function.`);
+        }
+    }
+    return true;
+}
+function ensureLibHerbBackend(object, libherbpath = "unknown") {
+    isLibHerbBackend(object, libherbpath);
+    return object;
+}
+
+class Position {
+    line;
+    column;
+    static from(position) {
+        return new Position(position.line, position.column);
+    }
+    constructor(line, column) {
+        this.line = line;
+        this.column = column;
+    }
+    toHash() {
+        return { line: this.line, column: this.column };
+    }
+    toJSON() {
+        return this.toHash();
+    }
+    treeInspect() {
+        return `(${this.line}:${this.column})`;
+    }
+    inspect() {
+        return `#<Herb::Position ${this.treeInspect()}>`;
+    }
+    toString() {
+        return this.inspect();
+    }
+}
+
+class Location {
+    start;
+    end;
+    static from(location) {
+        const start = Position.from(location.start);
+        const end = Position.from(location.end);
+        return new Location(start, end);
+    }
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+    toHash() {
+        return {
+            start: this.start.toHash(),
+            end: this.end.toHash(),
+        };
+    }
+    toJSON() {
+        return this.toHash();
+    }
+    treeInspect() {
+        return `${this.start.treeInspect()}-${this.end.treeInspect()}`;
+    }
+    treeInspectWithLabel() {
+        return `(location: ${this.treeInspect()})`;
+    }
+    inspect() {
+        return `#<Herb::Location ${this.treeInspect()}>`;
+    }
+    toString() {
+        return this.inspect();
+    }
+}
+
+class Range {
+    start;
+    end;
+    static from(range) {
+        return new Range(range[0], range[1]);
+    }
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+    toArray() {
+        return [this.start, this.end];
+    }
+    toJSON() {
+        return this.toArray();
+    }
+    treeInspect() {
+        return `[${this.start}, ${this.end}]`;
+    }
+    inspect() {
+        return `#<Herb::Range ${this.toArray()}>`;
+    }
+    toString() {
+        return this.inspect();
+    }
+}
+
+class Token {
+    value;
+    range;
+    location;
+    type;
+    static from(token) {
+        return new Token(token.value, Range.from(token.range), Location.from(token.location), token.type);
+    }
+    constructor(value, range, location, type) {
+        this.value = value;
+        this.range = range;
+        this.location = location;
+        this.type = type;
+    }
+    toHash() {
+        return {
+            value: this.value,
+            range: this.range?.toArray(),
+            location: this.location?.toHash(),
+            type: this.type,
+        };
+    }
+    toJSON() {
+        return this.toHash();
+    }
+    treeInspect() {
+        return `"${this.value}" ${this.location.treeInspectWithLabel()}`;
+    }
+    valueInspect() {
+        return this.type === "TOKEN_EOF"
+            ? JSON.stringify("<EOF>")
+            : JSON.stringify(this.value);
+    }
+    inspect() {
+        return `#<Herb::Token type="${this.type}" value=${this.valueInspect()} range=${this.range.treeInspect()} start=${this.location.start.treeInspect()} end=${this.location.end.treeInspect()}>`;
+    }
+    toString() {
+        return this.inspect();
+    }
+}
+
+class HerbError {
+    type;
+    message;
+    location;
+    static from(error) {
+        return fromSerializedError(error);
+    }
+    constructor(type, message, location) {
+        this.type = type;
+        this.message = message;
+        this.location = location;
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            message: this.message,
+            location: this.location.toJSON(),
+        };
+    }
+    inspect() {
+        return this.treeInspect(0);
+    }
+}
+
+// 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/errors.ts.erb
+function fromSerializedError(error) {
+    switch (error.type) {
+        case "UNEXPECTED_ERROR": return UnexpectedError.from(error);
+        case "UNEXPECTED_TOKEN_ERROR": return UnexpectedTokenError.from(error);
+        case "MISSING_OPENING_TAG_ERROR": return MissingOpeningTagError.from(error);
+        case "MISSING_CLOSING_TAG_ERROR": return MissingClosingTagError.from(error);
+        case "TAG_NAMES_MISMATCH_ERROR": return TagNamesMismatchError.from(error);
+        case "QUOTES_MISMATCH_ERROR": return QuotesMismatchError.from(error);
+        case "VOID_ELEMENT_CLOSING_TAG_ERROR": return VoidElementClosingTagError.from(error);
+        case "UNCLOSED_ELEMENT_ERROR": return UnclosedElementError.from(error);
+        case "RUBY_PARSE_ERROR": return RubyParseError.from(error);
+        default:
+            throw new Error(`Unknown node type: ${error.type}`);
+    }
+}
+class UnexpectedError extends HerbError {
+    description;
+    expected;
+    found;
+    static from(data) {
+        return new UnexpectedError({
+            type: data.type,
+            message: data.message,
+            location: Location.from(data.location),
+            description: data.description,
+            expected: data.expected,
+            found: data.found,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.message, props.location);
+        this.description = props.description;
+        this.expected = props.expected;
+        this.found = props.found;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "UNEXPECTED_ERROR",
+            description: this.description,
+            expected: this.expected,
+            found: this.found,
+        };
+    }
+    toDiagnostics() {
+        const diagnostics = [
+            {
+                line: this.location.start.line,
+                column: this.location.start.column,
+                endLine: this.location.end.line,
+                endColumn: this.location.end.column,
+                message: this.message,
+                severity: 'error'
+            }
+        ];
+        // no-op for description
+        // no-op for expected
+        // no-op for found
+        return diagnostics;
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ UnexpectedError ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── message: "${this.message}"\n`;
+        output += `├── description: ${JSON.stringify(this.description)}\n`;
+        output += `├── expected: ${JSON.stringify(this.expected)}\n`;
+        output += `└── found: ${JSON.stringify(this.found)}\n`;
+        return output;
+    }
+}
+class UnexpectedTokenError extends HerbError {
+    expected_type;
+    found;
+    static from(data) {
+        return new UnexpectedTokenError({
+            type: data.type,
+            message: data.message,
+            location: Location.from(data.location),
+            expected_type: data.expected_type,
+            found: data.found ? Token.from(data.found) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.message, props.location);
+        this.expected_type = props.expected_type;
+        this.found = props.found;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "UNEXPECTED_TOKEN_ERROR",
+            expected_type: this.expected_type,
+            found: this.found ? this.found.toJSON() : null,
+        };
+    }
+    toDiagnostics() {
+        const diagnostics = [
+            {
+                line: this.location.start.line,
+                column: this.location.start.column,
+                endLine: this.location.end.line,
+                endColumn: this.location.end.column,
+                message: this.message,
+                severity: 'error'
+            }
+        ];
+        // no-op for expected_type
+        if (this.found) {
+            diagnostics.push({
+                line: this.found.location.start.line,
+                column: this.found.location.start.column,
+                endLine: this.found.location.end.line,
+                endColumn: this.found.location.end.column,
+                message: `found "${(this.found.value)}" is here`,
+                severity: 'info'
+            });
+        }
+        return diagnostics;
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ UnexpectedTokenError ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── message: "${this.message}"\n`;
+        output += `├── expected_type: ${JSON.stringify(this.expected_type)}\n`;
+        output += `└── found: ${this.found ? this.found.treeInspect() : "∅"}\n`;
+        return output;
+    }
+}
+class MissingOpeningTagError extends HerbError {
+    closing_tag;
+    static from(data) {
+        return new MissingOpeningTagError({
+            type: data.type,
+            message: data.message,
+            location: Location.from(data.location),
+            closing_tag: data.closing_tag ? Token.from(data.closing_tag) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.message, props.location);
+        this.closing_tag = props.closing_tag;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "MISSING_OPENING_TAG_ERROR",
+            closing_tag: this.closing_tag ? this.closing_tag.toJSON() : null,
+        };
+    }
+    toDiagnostics() {
+        const diagnostics = [
+            {
+                line: this.location.start.line,
+                column: this.location.start.column,
+                endLine: this.location.end.line,
+                endColumn: this.location.end.column,
+                message: this.message,
+                severity: 'error'
+            }
+        ];
+        if (this.closing_tag) {
+            diagnostics.push({
+                line: this.closing_tag.location.start.line,
+                column: this.closing_tag.location.start.column,
+                endLine: this.closing_tag.location.end.line,
+                endColumn: this.closing_tag.location.end.column,
+                message: `closing_tag "${(this.closing_tag.value)}" is here`,
+                severity: 'info'
+            });
+        }
+        return diagnostics;
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ MissingOpeningTagError ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── message: "${this.message}"\n`;
+        output += `└── closing_tag: ${this.closing_tag ? this.closing_tag.treeInspect() : "∅"}\n`;
+        return output;
+    }
+}
+class MissingClosingTagError extends HerbError {
+    opening_tag;
+    static from(data) {
+        return new MissingClosingTagError({
+            type: data.type,
+            message: data.message,
+            location: Location.from(data.location),
+            opening_tag: data.opening_tag ? Token.from(data.opening_tag) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.message, props.location);
+        this.opening_tag = props.opening_tag;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "MISSING_CLOSING_TAG_ERROR",
+            opening_tag: this.opening_tag ? this.opening_tag.toJSON() : null,
+        };
+    }
+    toDiagnostics() {
+        const diagnostics = [
+            {
+                line: this.location.start.line,
+                column: this.location.start.column,
+                endLine: this.location.end.line,
+                endColumn: this.location.end.column,
+                message: this.message,
+                severity: 'error'
+            }
+        ];
+        if (this.opening_tag) {
+            diagnostics.push({
+                line: this.opening_tag.location.start.line,
+                column: this.opening_tag.location.start.column,
+                endLine: this.opening_tag.location.end.line,
+                endColumn: this.opening_tag.location.end.column,
+                message: `opening_tag "${(this.opening_tag.value)}" is here`,
+                severity: 'info'
+            });
+        }
+        return diagnostics;
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ MissingClosingTagError ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── message: "${this.message}"\n`;
+        output += `└── opening_tag: ${this.opening_tag ? this.opening_tag.treeInspect() : "∅"}\n`;
+        return output;
+    }
+}
+class TagNamesMismatchError extends HerbError {
+    opening_tag;
+    closing_tag;
+    static from(data) {
+        return new TagNamesMismatchError({
+            type: data.type,
+            message: data.message,
+            location: Location.from(data.location),
+            opening_tag: data.opening_tag ? Token.from(data.opening_tag) : null,
+            closing_tag: data.closing_tag ? Token.from(data.closing_tag) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.message, props.location);
+        this.opening_tag = props.opening_tag;
+        this.closing_tag = props.closing_tag;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "TAG_NAMES_MISMATCH_ERROR",
+            opening_tag: this.opening_tag ? this.opening_tag.toJSON() : null,
+            closing_tag: this.closing_tag ? this.closing_tag.toJSON() : null,
+        };
+    }
+    toDiagnostics() {
+        const diagnostics = [
+            {
+                line: this.location.start.line,
+                column: this.location.start.column,
+                endLine: this.location.end.line,
+                endColumn: this.location.end.column,
+                message: this.message,
+                severity: 'error'
+            }
+        ];
+        if (this.opening_tag) {
+            diagnostics.push({
+                line: this.opening_tag.location.start.line,
+                column: this.opening_tag.location.start.column,
+                endLine: this.opening_tag.location.end.line,
+                endColumn: this.opening_tag.location.end.column,
+                message: `opening_tag "${(this.opening_tag.value)}" is here`,
+                severity: 'info'
+            });
+        }
+        if (this.closing_tag) {
+            diagnostics.push({
+                line: this.closing_tag.location.start.line,
+                column: this.closing_tag.location.start.column,
+                endLine: this.closing_tag.location.end.line,
+                endColumn: this.closing_tag.location.end.column,
+                message: `closing_tag "${(this.closing_tag.value)}" is here`,
+                severity: 'info'
+            });
+        }
+        return diagnostics;
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ TagNamesMismatchError ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── message: "${this.message}"\n`;
+        output += `├── opening_tag: ${this.opening_tag ? this.opening_tag.treeInspect() : "∅"}\n`;
+        output += `└── closing_tag: ${this.closing_tag ? this.closing_tag.treeInspect() : "∅"}\n`;
+        return output;
+    }
+}
+class QuotesMismatchError extends HerbError {
+    opening_quote;
+    closing_quote;
+    static from(data) {
+        return new QuotesMismatchError({
+            type: data.type,
+            message: data.message,
+            location: Location.from(data.location),
+            opening_quote: data.opening_quote ? Token.from(data.opening_quote) : null,
+            closing_quote: data.closing_quote ? Token.from(data.closing_quote) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.message, props.location);
+        this.opening_quote = props.opening_quote;
+        this.closing_quote = props.closing_quote;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "QUOTES_MISMATCH_ERROR",
+            opening_quote: this.opening_quote ? this.opening_quote.toJSON() : null,
+            closing_quote: this.closing_quote ? this.closing_quote.toJSON() : null,
+        };
+    }
+    toDiagnostics() {
+        const diagnostics = [
+            {
+                line: this.location.start.line,
+                column: this.location.start.column,
+                endLine: this.location.end.line,
+                endColumn: this.location.end.column,
+                message: this.message,
+                severity: 'error'
+            }
+        ];
+        if (this.opening_quote) {
+            diagnostics.push({
+                line: this.opening_quote.location.start.line,
+                column: this.opening_quote.location.start.column,
+                endLine: this.opening_quote.location.end.line,
+                endColumn: this.opening_quote.location.end.column,
+                message: `opening_quote "${(this.opening_quote.value)}" is here`,
+                severity: 'info'
+            });
+        }
+        if (this.closing_quote) {
+            diagnostics.push({
+                line: this.closing_quote.location.start.line,
+                column: this.closing_quote.location.start.column,
+                endLine: this.closing_quote.location.end.line,
+                endColumn: this.closing_quote.location.end.column,
+                message: `closing_quote "${(this.closing_quote.value)}" is here`,
+                severity: 'info'
+            });
+        }
+        return diagnostics;
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ QuotesMismatchError ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── message: "${this.message}"\n`;
+        output += `├── opening_quote: ${this.opening_quote ? this.opening_quote.treeInspect() : "∅"}\n`;
+        output += `└── closing_quote: ${this.closing_quote ? this.closing_quote.treeInspect() : "∅"}\n`;
+        return output;
+    }
+}
+class VoidElementClosingTagError extends HerbError {
+    tag_name;
+    expected;
+    found;
+    static from(data) {
+        return new VoidElementClosingTagError({
+            type: data.type,
+            message: data.message,
+            location: Location.from(data.location),
+            tag_name: data.tag_name ? Token.from(data.tag_name) : null,
+            expected: data.expected,
+            found: data.found,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.message, props.location);
+        this.tag_name = props.tag_name;
+        this.expected = props.expected;
+        this.found = props.found;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "VOID_ELEMENT_CLOSING_TAG_ERROR",
+            tag_name: this.tag_name ? this.tag_name.toJSON() : null,
+            expected: this.expected,
+            found: this.found,
+        };
+    }
+    toDiagnostics() {
+        const diagnostics = [
+            {
+                line: this.location.start.line,
+                column: this.location.start.column,
+                endLine: this.location.end.line,
+                endColumn: this.location.end.column,
+                message: this.message,
+                severity: 'error'
+            }
+        ];
+        if (this.tag_name) {
+            diagnostics.push({
+                line: this.tag_name.location.start.line,
+                column: this.tag_name.location.start.column,
+                endLine: this.tag_name.location.end.line,
+                endColumn: this.tag_name.location.end.column,
+                message: `tag_name "${(this.tag_name.value)}" is here`,
+                severity: 'info'
+            });
+        }
+        // no-op for expected
+        // no-op for found
+        return diagnostics;
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ VoidElementClosingTagError ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── message: "${this.message}"\n`;
+        output += `├── tag_name: ${this.tag_name ? this.tag_name.treeInspect() : "∅"}\n`;
+        output += `├── expected: ${JSON.stringify(this.expected)}\n`;
+        output += `└── found: ${JSON.stringify(this.found)}\n`;
+        return output;
+    }
+}
+class UnclosedElementError extends HerbError {
+    opening_tag;
+    static from(data) {
+        return new UnclosedElementError({
+            type: data.type,
+            message: data.message,
+            location: Location.from(data.location),
+            opening_tag: data.opening_tag ? Token.from(data.opening_tag) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.message, props.location);
+        this.opening_tag = props.opening_tag;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "UNCLOSED_ELEMENT_ERROR",
+            opening_tag: this.opening_tag ? this.opening_tag.toJSON() : null,
+        };
+    }
+    toDiagnostics() {
+        const diagnostics = [
+            {
+                line: this.location.start.line,
+                column: this.location.start.column,
+                endLine: this.location.end.line,
+                endColumn: this.location.end.column,
+                message: this.message,
+                severity: 'error'
+            }
+        ];
+        if (this.opening_tag) {
+            diagnostics.push({
+                line: this.opening_tag.location.start.line,
+                column: this.opening_tag.location.start.column,
+                endLine: this.opening_tag.location.end.line,
+                endColumn: this.opening_tag.location.end.column,
+                message: `opening_tag "${(this.opening_tag.value)}" is here`,
+                severity: 'info'
+            });
+        }
+        return diagnostics;
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ UnclosedElementError ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── message: "${this.message}"\n`;
+        output += `└── opening_tag: ${this.opening_tag ? this.opening_tag.treeInspect() : "∅"}\n`;
+        return output;
+    }
+}
+class RubyParseError extends HerbError {
+    error_message;
+    diagnostic_id;
+    level;
+    static from(data) {
+        return new RubyParseError({
+            type: data.type,
+            message: data.message,
+            location: Location.from(data.location),
+            error_message: data.error_message,
+            diagnostic_id: data.diagnostic_id,
+            level: data.level,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.message, props.location);
+        this.error_message = props.error_message;
+        this.diagnostic_id = props.diagnostic_id;
+        this.level = props.level;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "RUBY_PARSE_ERROR",
+            error_message: this.error_message,
+            diagnostic_id: this.diagnostic_id,
+            level: this.level,
+        };
+    }
+    toDiagnostics() {
+        const diagnostics = [
+            {
+                line: this.location.start.line,
+                column: this.location.start.column,
+                endLine: this.location.end.line,
+                endColumn: this.location.end.column,
+                message: this.message,
+                severity: 'error'
+            }
+        ];
+        // no-op for error_message
+        // no-op for diagnostic_id
+        // no-op for level
+        return diagnostics;
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ RubyParseError ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── message: "${this.message}"\n`;
+        output += `├── error_message: ${JSON.stringify(this.error_message)}\n`;
+        output += `├── diagnostic_id: ${JSON.stringify(this.diagnostic_id)}\n`;
+        output += `└── level: ${JSON.stringify(this.level)}\n`;
+        return output;
+    }
+}
+
+var name = "@herb-tools/core";
+var version = "0.1.0";
+var packageJSON = {
+	name: name,
+	version: version};
+
+function ensureString(object) {
+    if (typeof object === "string") {
+        return object;
+    }
+    throw new TypeError("Argument must be a string");
+}
+function convertToUTF8(string) {
+    const bytes = [];
+    for (let i = 0; i < string.length; i++) {
+        bytes.push(string.charCodeAt(i));
+    }
+    const decoder = new TextDecoder("utf-8");
+    return decoder.decode(new Uint8Array(bytes));
+}
+
+class Result {
+    source;
+    warnings;
+    errors;
+    constructor(source, warnings = [], errors = []) {
+        this.source = source;
+        this.warnings = warnings || [];
+        this.errors = errors || [];
+    }
+    success() {
+        return false;
+    }
+    failed() {
+        return true;
+    }
+}
+
+class TokenList {
+    list;
+    static from(list) {
+        return new TokenList(list.map((token) => Token.from(token)));
+    }
+    constructor(list) {
+        this.list = list;
+    }
+    get length() {
+        return this.list.length;
+    }
+    [Symbol.iterator]() {
+        return this.list[Symbol.iterator]();
+    }
+    at(index) {
+        return this.list.at(index);
+    }
+    forEach(callback) {
+        this.list.forEach(callback);
+    }
+    map(callback) {
+        return this.list.map(callback);
+    }
+    filter(predicate) {
+        return this.list.filter(predicate);
+    }
+    __getobj__() {
+        return this.list;
+    }
+    inspect() {
+        return this.list.map((token) => token.inspect()).join("\n") + "\n";
+    }
+    toString() {
+        return this.inspect();
+    }
+}
+
+/**
+ * Represents the result of a lexical analysis, extending the base `Result` class.
+ * It contains the token list, source code, warnings, and errors.
+ */
+class LexResult extends Result {
+    /** The list of tokens generated from the source code. */
+    value;
+    /**
+     * Creates a `LexResult` instance from a serialized result.
+     * @param result - The serialized lexical result containing tokens, source, warnings, and errors.
+     * @returns A new `LexResult` instance.
+     */
+    static from(result) {
+        return new LexResult(TokenList.from(result.tokens || []), result.source, result.warnings, result.errors);
+    }
+    /**
+     * Constructs a new `LexResult`.
+     * @param value - The list of tokens.
+     * @param source - The source code that was lexed.
+     * @param warnings - An array of warnings encountered during lexing.
+     * @param errors - An array of errors encountered during lexing.
+     */
+    constructor(value, source, warnings = [], errors = []) {
+        super(source, warnings, errors);
+        this.value = value;
+    }
+    /**
+     * Determines if the lexing was successful.
+     * @returns `true` if there are no errors, otherwise `false`.
+     */
+    success() {
+        return this.errors.length === 0;
+    }
+    /**
+     * Determines if the lexing failed.
+     * @returns `true` if there are errors, otherwise `false`.
+     */
+    failed() {
+        return this.errors.length > 0;
+    }
+    /**
+     * Converts the `LexResult` to a JSON representation.
+     * @returns An object containing the token list, source, warnings, and errors.
+     */
+    toJSON() {
+        return {
+            value: this.value,
+            source: this.source,
+            warnings: this.warnings,
+            errors: this.errors,
+        };
+    }
+}
+
+class Node {
+    type;
+    location;
+    errors;
+    static from(node) {
+        return fromSerializedNode(node);
+    }
+    constructor(type, location, errors) {
+        this.type = type;
+        this.location = location;
+        this.errors = errors;
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            location: this.location.toJSON(),
+            errors: this.errors,
+        };
+    }
+    inspect() {
+        return this.treeInspect(0);
+    }
+    inspectArray(array, prefix) {
+        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;
+    }
+    inspectNode(node, prefix, prefix2 = "    ", last = true, trailingNewline = true) {
+        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;
+    }
+}
+
+// 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
+function fromSerializedNode(node) {
+    switch (node.type) {
+        case "AST_DOCUMENT_NODE": return DocumentNode.from(node);
+        case "AST_LITERAL_NODE": return LiteralNode.from(node);
+        case "AST_HTML_OPEN_TAG_NODE": return HTMLOpenTagNode.from(node);
+        case "AST_HTML_CLOSE_TAG_NODE": return HTMLCloseTagNode.from(node);
+        case "AST_HTML_SELF_CLOSE_TAG_NODE": return HTMLSelfCloseTagNode.from(node);
+        case "AST_HTML_ELEMENT_NODE": return HTMLElementNode.from(node);
+        case "AST_HTML_ATTRIBUTE_VALUE_NODE": return HTMLAttributeValueNode.from(node);
+        case "AST_HTML_ATTRIBUTE_NAME_NODE": return HTMLAttributeNameNode.from(node);
+        case "AST_HTML_ATTRIBUTE_NODE": return HTMLAttributeNode.from(node);
+        case "AST_HTML_TEXT_NODE": return HTMLTextNode.from(node);
+        case "AST_HTML_COMMENT_NODE": return HTMLCommentNode.from(node);
+        case "AST_HTML_DOCTYPE_NODE": return HTMLDoctypeNode.from(node);
+        case "AST_WHITESPACE_NODE": return WhitespaceNode.from(node);
+        case "AST_ERB_CONTENT_NODE": return ERBContentNode.from(node);
+        case "AST_ERB_END_NODE": return ERBEndNode.from(node);
+        case "AST_ERB_ELSE_NODE": return ERBElseNode.from(node);
+        case "AST_ERB_IF_NODE": return ERBIfNode.from(node);
+        case "AST_ERB_BLOCK_NODE": return ERBBlockNode.from(node);
+        case "AST_ERB_WHEN_NODE": return ERBWhenNode.from(node);
+        case "AST_ERB_CASE_NODE": return ERBCaseNode.from(node);
+        case "AST_ERB_WHILE_NODE": return ERBWhileNode.from(node);
+        case "AST_ERB_UNTIL_NODE": return ERBUntilNode.from(node);
+        case "AST_ERB_FOR_NODE": return ERBForNode.from(node);
+        case "AST_ERB_RESCUE_NODE": return ERBRescueNode.from(node);
+        case "AST_ERB_ENSURE_NODE": return ERBEnsureNode.from(node);
+        case "AST_ERB_BEGIN_NODE": return ERBBeginNode.from(node);
+        case "AST_ERB_UNLESS_NODE": return ERBUnlessNode.from(node);
+        default:
+            throw new Error(`Unknown node type: ${node.type}`);
+    }
+}
+class DocumentNode extends Node {
+    children;
+    static from(data) {
+        return new DocumentNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            children: (data.children || []).map(node => fromSerializedNode(node)),
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.children = props.children;
+    }
+    childNodes() {
+        return [
+            ...this.children,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.children.map(node => node.recursiveErrors()),
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_DOCUMENT_NODE",
+            children: this.children.map(node => node.toJSON()),
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ DocumentNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `└── children: ${this.inspectArray(this.children, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class LiteralNode extends Node {
+    content;
+    static from(data) {
+        return new LiteralNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            content: data.content,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.content = convertToUTF8(props.content);
+    }
+    childNodes() {
+        return [].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_LITERAL_NODE",
+            content: this.content,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ LiteralNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `└── content: ${this.content ? JSON.stringify(this.content) : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class HTMLOpenTagNode extends Node {
+    tag_opening;
+    tag_name;
+    tag_closing;
+    children;
+    is_void;
+    static from(data) {
+        return new HTMLOpenTagNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            tag_name: data.tag_name ? Token.from(data.tag_name) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            children: (data.children || []).map(node => fromSerializedNode(node)),
+            is_void: data.is_void,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.tag_name = props.tag_name;
+        this.tag_closing = props.tag_closing;
+        this.children = props.children;
+        this.is_void = props.is_void;
+    }
+    childNodes() {
+        return [
+            ...this.children,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.children.map(node => node.recursiveErrors()),
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_HTML_OPEN_TAG_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            tag_name: this.tag_name ? this.tag_name.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            children: this.children.map(node => node.toJSON()),
+            is_void: this.is_void,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ HTMLOpenTagNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── tag_name: ${this.tag_name ? this.tag_name.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `├── children: ${this.inspectArray(this.children, "│   ")}`;
+        output += `└── is_void: ${typeof this.is_void === 'boolean' ? String(this.is_void) : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class HTMLCloseTagNode extends Node {
+    tag_opening;
+    tag_name;
+    tag_closing;
+    static from(data) {
+        return new HTMLCloseTagNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            tag_name: data.tag_name ? Token.from(data.tag_name) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.tag_name = props.tag_name;
+        this.tag_closing = props.tag_closing;
+    }
+    childNodes() {
+        return [].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_HTML_CLOSE_TAG_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            tag_name: this.tag_name ? this.tag_name.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ HTMLCloseTagNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── tag_name: ${this.tag_name ? this.tag_name.treeInspect() : "∅"}\n`;
+        output += `└── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class HTMLSelfCloseTagNode extends Node {
+    tag_opening;
+    tag_name;
+    attributes;
+    tag_closing;
+    is_void;
+    static from(data) {
+        return new HTMLSelfCloseTagNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            tag_name: data.tag_name ? Token.from(data.tag_name) : null,
+            attributes: (data.attributes || []).map(node => fromSerializedNode(node)),
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            is_void: data.is_void,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.tag_name = props.tag_name;
+        this.attributes = props.attributes;
+        this.tag_closing = props.tag_closing;
+        this.is_void = props.is_void;
+    }
+    childNodes() {
+        return [
+            ...this.attributes,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.attributes.map(node => node.recursiveErrors()),
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_HTML_SELF_CLOSE_TAG_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            tag_name: this.tag_name ? this.tag_name.toJSON() : null,
+            attributes: this.attributes.map(node => node.toJSON()),
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            is_void: this.is_void,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ HTMLSelfCloseTagNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── tag_name: ${this.tag_name ? this.tag_name.treeInspect() : "∅"}\n`;
+        output += `├── attributes: ${this.inspectArray(this.attributes, "│   ")}`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `└── is_void: ${typeof this.is_void === 'boolean' ? String(this.is_void) : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class HTMLElementNode extends Node {
+    open_tag;
+    tag_name;
+    body;
+    close_tag;
+    is_void;
+    static from(data) {
+        return new HTMLElementNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            open_tag: data.open_tag ? fromSerializedNode(data.open_tag) : null,
+            tag_name: data.tag_name ? Token.from(data.tag_name) : null,
+            body: (data.body || []).map(node => fromSerializedNode(node)),
+            close_tag: data.close_tag ? fromSerializedNode(data.close_tag) : null,
+            is_void: data.is_void,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.open_tag = props.open_tag;
+        this.tag_name = props.tag_name;
+        this.body = props.body;
+        this.close_tag = props.close_tag;
+        this.is_void = props.is_void;
+    }
+    childNodes() {
+        return [
+            this.open_tag,
+            ...this.body,
+            this.close_tag,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            this.open_tag ? this.open_tag.recursiveErrors() : [],
+            ...this.body.map(node => node.recursiveErrors()),
+            this.close_tag ? this.close_tag.recursiveErrors() : [],
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_HTML_ELEMENT_NODE",
+            open_tag: this.open_tag ? this.open_tag.toJSON() : null,
+            tag_name: this.tag_name ? this.tag_name.toJSON() : null,
+            body: this.body.map(node => node.toJSON()),
+            close_tag: this.close_tag ? this.close_tag.toJSON() : null,
+            is_void: this.is_void,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ HTMLElementNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── open_tag: ${this.inspectNode(this.open_tag, "│   ")}`;
+        output += `├── tag_name: ${this.tag_name ? this.tag_name.treeInspect() : "∅"}\n`;
+        output += `├── body: ${this.inspectArray(this.body, "│   ")}`;
+        output += `├── close_tag: ${this.inspectNode(this.close_tag, "│   ")}`;
+        output += `└── is_void: ${typeof this.is_void === 'boolean' ? String(this.is_void) : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class HTMLAttributeValueNode extends Node {
+    open_quote;
+    children;
+    close_quote;
+    quoted;
+    static from(data) {
+        return new HTMLAttributeValueNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            open_quote: data.open_quote ? Token.from(data.open_quote) : null,
+            children: (data.children || []).map(node => fromSerializedNode(node)),
+            close_quote: data.close_quote ? Token.from(data.close_quote) : null,
+            quoted: data.quoted,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.open_quote = props.open_quote;
+        this.children = props.children;
+        this.close_quote = props.close_quote;
+        this.quoted = props.quoted;
+    }
+    childNodes() {
+        return [
+            ...this.children,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.children.map(node => node.recursiveErrors()),
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_HTML_ATTRIBUTE_VALUE_NODE",
+            open_quote: this.open_quote ? this.open_quote.toJSON() : null,
+            children: this.children.map(node => node.toJSON()),
+            close_quote: this.close_quote ? this.close_quote.toJSON() : null,
+            quoted: this.quoted,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ HTMLAttributeValueNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── open_quote: ${this.open_quote ? this.open_quote.treeInspect() : "∅"}\n`;
+        output += `├── children: ${this.inspectArray(this.children, "│   ")}`;
+        output += `├── close_quote: ${this.close_quote ? this.close_quote.treeInspect() : "∅"}\n`;
+        output += `└── quoted: ${typeof this.quoted === 'boolean' ? String(this.quoted) : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class HTMLAttributeNameNode extends Node {
+    name;
+    static from(data) {
+        return new HTMLAttributeNameNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            name: data.name ? Token.from(data.name) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.name = props.name;
+    }
+    childNodes() {
+        return [].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_HTML_ATTRIBUTE_NAME_NODE",
+            name: this.name ? this.name.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ HTMLAttributeNameNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `└── name: ${this.name ? this.name.treeInspect() : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class HTMLAttributeNode extends Node {
+    name;
+    equals;
+    value;
+    static from(data) {
+        return new HTMLAttributeNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            name: data.name ? fromSerializedNode(data.name) : null,
+            equals: data.equals ? Token.from(data.equals) : null,
+            value: data.value ? fromSerializedNode(data.value) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.name = props.name;
+        this.equals = props.equals;
+        this.value = props.value;
+    }
+    childNodes() {
+        return [
+            this.name,
+            this.value,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            this.name ? this.name.recursiveErrors() : [],
+            this.value ? this.value.recursiveErrors() : [],
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_HTML_ATTRIBUTE_NODE",
+            name: this.name ? this.name.toJSON() : null,
+            equals: this.equals ? this.equals.toJSON() : null,
+            value: this.value ? this.value.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ HTMLAttributeNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── name: ${this.inspectNode(this.name, "│   ")}`;
+        output += `├── equals: ${this.equals ? this.equals.treeInspect() : "∅"}\n`;
+        output += `└── value: ${this.inspectNode(this.value, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class HTMLTextNode extends Node {
+    content;
+    static from(data) {
+        return new HTMLTextNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            content: data.content,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.content = convertToUTF8(props.content);
+    }
+    childNodes() {
+        return [].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_HTML_TEXT_NODE",
+            content: this.content,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ HTMLTextNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `└── content: ${this.content ? JSON.stringify(this.content) : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class HTMLCommentNode extends Node {
+    comment_start;
+    children;
+    comment_end;
+    static from(data) {
+        return new HTMLCommentNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            comment_start: data.comment_start ? Token.from(data.comment_start) : null,
+            children: (data.children || []).map(node => fromSerializedNode(node)),
+            comment_end: data.comment_end ? Token.from(data.comment_end) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.comment_start = props.comment_start;
+        this.children = props.children;
+        this.comment_end = props.comment_end;
+    }
+    childNodes() {
+        return [
+            ...this.children,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.children.map(node => node.recursiveErrors()),
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_HTML_COMMENT_NODE",
+            comment_start: this.comment_start ? this.comment_start.toJSON() : null,
+            children: this.children.map(node => node.toJSON()),
+            comment_end: this.comment_end ? this.comment_end.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ HTMLCommentNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── comment_start: ${this.comment_start ? this.comment_start.treeInspect() : "∅"}\n`;
+        output += `├── children: ${this.inspectArray(this.children, "│   ")}`;
+        output += `└── comment_end: ${this.comment_end ? this.comment_end.treeInspect() : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class HTMLDoctypeNode extends Node {
+    tag_opening;
+    children;
+    tag_closing;
+    static from(data) {
+        return new HTMLDoctypeNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            children: (data.children || []).map(node => fromSerializedNode(node)),
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.children = props.children;
+        this.tag_closing = props.tag_closing;
+    }
+    childNodes() {
+        return [
+            ...this.children,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.children.map(node => node.recursiveErrors()),
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_HTML_DOCTYPE_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            children: this.children.map(node => node.toJSON()),
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ HTMLDoctypeNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── children: ${this.inspectArray(this.children, "│   ")}`;
+        output += `└── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class WhitespaceNode extends Node {
+    value;
+    static from(data) {
+        return new WhitespaceNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            value: data.value ? Token.from(data.value) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.value = props.value;
+    }
+    childNodes() {
+        return [].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_WHITESPACE_NODE",
+            value: this.value ? this.value.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ WhitespaceNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `└── value: ${this.value ? this.value.treeInspect() : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBContentNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    // no-op for analyzed_ruby
+    parsed;
+    valid;
+    static from(data) {
+        return new ERBContentNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            // no-op for analyzed_ruby
+            parsed: data.parsed,
+            valid: data.valid,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        // no-op for analyzed_ruby
+        this.parsed = props.parsed;
+        this.valid = props.valid;
+    }
+    childNodes() {
+        return [].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_CONTENT_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            // no-op for analyzed_ruby
+            parsed: this.parsed,
+            valid: this.valid,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBContentNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        // no-op for analyzed_ruby
+        output += `├── parsed: ${typeof this.parsed === 'boolean' ? String(this.parsed) : "∅"}\n`;
+        output += `└── valid: ${typeof this.valid === 'boolean' ? String(this.valid) : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBEndNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    static from(data) {
+        return new ERBEndNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+    }
+    childNodes() {
+        return [].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_END_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBEndNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `└── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBElseNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    statements;
+    static from(data) {
+        return new ERBElseNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            statements: (data.statements || []).map(node => fromSerializedNode(node)),
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        this.statements = props.statements;
+    }
+    childNodes() {
+        return [
+            ...this.statements,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.statements.map(node => node.recursiveErrors()),
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_ELSE_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            statements: this.statements.map(node => node.toJSON()),
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBElseNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `└── statements: ${this.inspectArray(this.statements, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBIfNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    statements;
+    subsequent;
+    end_node;
+    static from(data) {
+        return new ERBIfNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            statements: (data.statements || []).map(node => fromSerializedNode(node)),
+            subsequent: data.subsequent ? fromSerializedNode(data.subsequent) : null,
+            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        this.statements = props.statements;
+        this.subsequent = props.subsequent;
+        this.end_node = props.end_node;
+    }
+    childNodes() {
+        return [
+            ...this.statements,
+            this.subsequent,
+            this.end_node,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.statements.map(node => node.recursiveErrors()),
+            this.subsequent ? this.subsequent.recursiveErrors() : [],
+            this.end_node ? this.end_node.recursiveErrors() : [],
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_IF_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            statements: this.statements.map(node => node.toJSON()),
+            subsequent: this.subsequent ? this.subsequent.toJSON() : null,
+            end_node: this.end_node ? this.end_node.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBIfNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
+        output += `├── subsequent: ${this.inspectNode(this.subsequent, "│   ")}`;
+        output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBBlockNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    body;
+    end_node;
+    static from(data) {
+        return new ERBBlockNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            body: (data.body || []).map(node => fromSerializedNode(node)),
+            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        this.body = props.body;
+        this.end_node = props.end_node;
+    }
+    childNodes() {
+        return [
+            ...this.body,
+            this.end_node,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.body.map(node => node.recursiveErrors()),
+            this.end_node ? this.end_node.recursiveErrors() : [],
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_BLOCK_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            body: this.body.map(node => node.toJSON()),
+            end_node: this.end_node ? this.end_node.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBBlockNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `├── body: ${this.inspectArray(this.body, "│   ")}`;
+        output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBWhenNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    statements;
+    static from(data) {
+        return new ERBWhenNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            statements: (data.statements || []).map(node => fromSerializedNode(node)),
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        this.statements = props.statements;
+    }
+    childNodes() {
+        return [
+            ...this.statements,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.statements.map(node => node.recursiveErrors()),
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_WHEN_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            statements: this.statements.map(node => node.toJSON()),
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBWhenNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `└── statements: ${this.inspectArray(this.statements, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBCaseNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    children;
+    conditions;
+    else_clause;
+    end_node;
+    static from(data) {
+        return new ERBCaseNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            children: (data.children || []).map(node => fromSerializedNode(node)),
+            conditions: (data.conditions || []).map(node => fromSerializedNode(node)),
+            else_clause: data.else_clause ? fromSerializedNode(data.else_clause) : null,
+            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        this.children = props.children;
+        this.conditions = props.conditions;
+        this.else_clause = props.else_clause;
+        this.end_node = props.end_node;
+    }
+    childNodes() {
+        return [
+            ...this.children,
+            ...this.conditions,
+            this.else_clause,
+            this.end_node,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.children.map(node => node.recursiveErrors()),
+            ...this.conditions.map(node => node.recursiveErrors()),
+            this.else_clause ? this.else_clause.recursiveErrors() : [],
+            this.end_node ? this.end_node.recursiveErrors() : [],
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_CASE_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            children: this.children.map(node => node.toJSON()),
+            conditions: this.conditions.map(node => node.toJSON()),
+            else_clause: this.else_clause ? this.else_clause.toJSON() : null,
+            end_node: this.end_node ? this.end_node.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBCaseNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `├── children: ${this.inspectArray(this.children, "│   ")}`;
+        output += `├── conditions: ${this.inspectArray(this.conditions, "│   ")}`;
+        output += `├── else_clause: ${this.inspectNode(this.else_clause, "│   ")}`;
+        output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBWhileNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    statements;
+    end_node;
+    static from(data) {
+        return new ERBWhileNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            statements: (data.statements || []).map(node => fromSerializedNode(node)),
+            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        this.statements = props.statements;
+        this.end_node = props.end_node;
+    }
+    childNodes() {
+        return [
+            ...this.statements,
+            this.end_node,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.statements.map(node => node.recursiveErrors()),
+            this.end_node ? this.end_node.recursiveErrors() : [],
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_WHILE_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            statements: this.statements.map(node => node.toJSON()),
+            end_node: this.end_node ? this.end_node.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBWhileNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
+        output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBUntilNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    statements;
+    end_node;
+    static from(data) {
+        return new ERBUntilNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            statements: (data.statements || []).map(node => fromSerializedNode(node)),
+            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        this.statements = props.statements;
+        this.end_node = props.end_node;
+    }
+    childNodes() {
+        return [
+            ...this.statements,
+            this.end_node,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.statements.map(node => node.recursiveErrors()),
+            this.end_node ? this.end_node.recursiveErrors() : [],
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_UNTIL_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            statements: this.statements.map(node => node.toJSON()),
+            end_node: this.end_node ? this.end_node.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBUntilNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
+        output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBForNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    statements;
+    end_node;
+    static from(data) {
+        return new ERBForNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            statements: (data.statements || []).map(node => fromSerializedNode(node)),
+            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        this.statements = props.statements;
+        this.end_node = props.end_node;
+    }
+    childNodes() {
+        return [
+            ...this.statements,
+            this.end_node,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.statements.map(node => node.recursiveErrors()),
+            this.end_node ? this.end_node.recursiveErrors() : [],
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_FOR_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            statements: this.statements.map(node => node.toJSON()),
+            end_node: this.end_node ? this.end_node.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBForNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
+        output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBRescueNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    statements;
+    subsequent;
+    static from(data) {
+        return new ERBRescueNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            statements: (data.statements || []).map(node => fromSerializedNode(node)),
+            subsequent: data.subsequent ? fromSerializedNode(data.subsequent) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        this.statements = props.statements;
+        this.subsequent = props.subsequent;
+    }
+    childNodes() {
+        return [
+            ...this.statements,
+            this.subsequent,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.statements.map(node => node.recursiveErrors()),
+            this.subsequent ? this.subsequent.recursiveErrors() : [],
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_RESCUE_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            statements: this.statements.map(node => node.toJSON()),
+            subsequent: this.subsequent ? this.subsequent.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBRescueNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
+        output += `└── subsequent: ${this.inspectNode(this.subsequent, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBEnsureNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    statements;
+    static from(data) {
+        return new ERBEnsureNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            statements: (data.statements || []).map(node => fromSerializedNode(node)),
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        this.statements = props.statements;
+    }
+    childNodes() {
+        return [
+            ...this.statements,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.statements.map(node => node.recursiveErrors()),
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_ENSURE_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            statements: this.statements.map(node => node.toJSON()),
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBEnsureNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `└── statements: ${this.inspectArray(this.statements, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBBeginNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    statements;
+    rescue_clause;
+    else_clause;
+    ensure_clause;
+    end_node;
+    static from(data) {
+        return new ERBBeginNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            statements: (data.statements || []).map(node => fromSerializedNode(node)),
+            rescue_clause: data.rescue_clause ? fromSerializedNode(data.rescue_clause) : null,
+            else_clause: data.else_clause ? fromSerializedNode(data.else_clause) : null,
+            ensure_clause: data.ensure_clause ? fromSerializedNode(data.ensure_clause) : null,
+            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        this.statements = props.statements;
+        this.rescue_clause = props.rescue_clause;
+        this.else_clause = props.else_clause;
+        this.ensure_clause = props.ensure_clause;
+        this.end_node = props.end_node;
+    }
+    childNodes() {
+        return [
+            ...this.statements,
+            this.rescue_clause,
+            this.else_clause,
+            this.ensure_clause,
+            this.end_node,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.statements.map(node => node.recursiveErrors()),
+            this.rescue_clause ? this.rescue_clause.recursiveErrors() : [],
+            this.else_clause ? this.else_clause.recursiveErrors() : [],
+            this.ensure_clause ? this.ensure_clause.recursiveErrors() : [],
+            this.end_node ? this.end_node.recursiveErrors() : [],
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_BEGIN_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            statements: this.statements.map(node => node.toJSON()),
+            rescue_clause: this.rescue_clause ? this.rescue_clause.toJSON() : null,
+            else_clause: this.else_clause ? this.else_clause.toJSON() : null,
+            ensure_clause: this.ensure_clause ? this.ensure_clause.toJSON() : null,
+            end_node: this.end_node ? this.end_node.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBBeginNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
+        output += `├── rescue_clause: ${this.inspectNode(this.rescue_clause, "│   ")}`;
+        output += `├── else_clause: ${this.inspectNode(this.else_clause, "│   ")}`;
+        output += `├── ensure_clause: ${this.inspectNode(this.ensure_clause, "│   ")}`;
+        output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+class ERBUnlessNode extends Node {
+    tag_opening;
+    content;
+    tag_closing;
+    statements;
+    else_clause;
+    end_node;
+    static from(data) {
+        return new ERBUnlessNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            content: data.content ? Token.from(data.content) : null,
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+            statements: (data.statements || []).map(node => fromSerializedNode(node)),
+            else_clause: data.else_clause ? fromSerializedNode(data.else_clause) : null,
+            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.content = props.content;
+        this.tag_closing = props.tag_closing;
+        this.statements = props.statements;
+        this.else_clause = props.else_clause;
+        this.end_node = props.end_node;
+    }
+    childNodes() {
+        return [
+            ...this.statements,
+            this.else_clause,
+            this.end_node,
+        ].filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.statements.map(node => node.recursiveErrors()),
+            this.else_clause ? this.else_clause.recursiveErrors() : [],
+            this.end_node ? this.end_node.recursiveErrors() : [],
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_ERB_UNLESS_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            content: this.content ? this.content.toJSON() : null,
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+            statements: this.statements.map(node => node.toJSON()),
+            else_clause: this.else_clause ? this.else_clause.toJSON() : null,
+            end_node: this.end_node ? this.end_node.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBUnlessNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
+        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
+        output += `├── else_clause: ${this.inspectNode(this.else_clause, "│   ")}`;
+        output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
+        // output += "\n";
+        return output;
+    }
+}
+
+class HerbWarning {
+    message;
+    location;
+    static from(warning) {
+        return new HerbWarning(warning.message, Location.from(warning.location));
+    }
+    constructor(message, location) {
+        this.message = message;
+        this.location = location;
+    }
+}
+
+/**
+ * Represents the result of a parsing operation, extending the base `Result` class.
+ * It contains the parsed document node, source code, warnings, and errors.
+ */
+class ParseResult extends Result {
+    /** The document node generated from the source code. */
+    value;
+    /**
+     * Creates a `ParseResult` instance from a serialized result.
+     * @param result - The serialized parse result containing the value and source.
+     * @returns A new `ParseResult` instance.
+     */
+    static from(result) {
+        return new ParseResult(DocumentNode.from(result.value), result.source, result.warnings.map((warning) => HerbWarning.from(warning)), result.errors.map((error) => HerbError.from(error)));
+    }
+    /**
+     * Constructs a new `ParseResult`.
+     * @param value - The document node.
+     * @param source - The source code that was parsed.
+     * @param warnings - An array of warnings encountered during parsing.
+     * @param errors - An array of errors encountered during parsing.
+     */
+    constructor(value, source, warnings = [], errors = []) {
+        super(source, warnings, errors);
+        this.value = value;
+    }
+    /**
+     * Determines if the parsing failed.
+     * @returns `true` if there are errors, otherwise `false`.
+     */
+    failed() {
+        // TODO: this should probably be recursive as noted in the Ruby version
+        return this.errors.length > 0 || this.value.errors.length > 0;
+    }
+    /**
+     * Determines if the parsing was successful.
+     * @returns `true` if there are no errors, otherwise `false`.
+     */
+    success() {
+        return !this.failed();
+    }
+    /**
+     * Returns a pretty-printed JSON string of the errors.
+     * @returns A string representation of the errors.
+     */
+    prettyErrors() {
+        return JSON.stringify([...this.errors, ...this.value.errors], null, 2);
+    }
+    recursiveErrors() {
+        return [...this.errors, ...this.value.recursiveErrors()];
+    }
+    /**
+     * Returns a pretty-printed string of the parse result.
+     * @returns A string representation of the parse result.
+     */
+    inspect() {
+        return this.value.inspect();
+    }
+    /**
+     * Accepts a visitor to traverse the document node.
+     * @param visitor - The visitor instance.
+     */
+    visit(visitor) {
+        visitor.visit(this.value);
+    }
+}
+
+/**
+ * The main Herb parser interface, providing methods to lex and parse input.
+ */
+class HerbBackend {
+    /** The backend instance handling lexing and parsing. */
+    backend = undefined;
+    backendPromise;
+    /**
+     * Creates a new Herb instance.
+     * @param backendPromise - A promise resolving to a `LibHerbBackend` implementation for lexing and parsing.
+     * @throws Error if no valid backend is provided.
+     */
+    constructor(backendPromise) {
+        if (!backendPromise) {
+            throw new Error("No LibHerb backend provided");
+        }
+        this.backendPromise = backendPromise;
+    }
+    /**
+     * Loads the backend by resolving the backend promise.
+     * @returns A promise containing the resolved `HerbBackend` instance after loading it.
+     */
+    async load() {
+        const backend = await this.backendPromise();
+        this.backend = backend;
+        return this;
+    }
+    /**
+     * Lexes the given source string into a `LexResult`.
+     * @param source - The source code to lex.
+     * @returns A `LexResult` instance.
+     * @throws Error if the backend is not loaded.
+     */
+    lex(source) {
+        this.ensureBackend();
+        return LexResult.from(this.backend.lex(ensureString(source)));
+    }
+    /**
+     * Lexes a file.
+     * @param path - The file path to lex.
+     * @returns A `LexResult` instance.
+     * @throws Error if the backend is not loaded.
+     */
+    lexFile(path) {
+        this.ensureBackend();
+        return LexResult.from(this.backend.lexFile(ensureString(path)));
+    }
+    /**
+     * Parses the given source string into a `ParseResult`.
+     * @param source - The source code to parse.
+     * @returns A `ParseResult` instance.
+     * @throws Error if the backend is not loaded.
+     */
+    parse(source) {
+        this.ensureBackend();
+        return ParseResult.from(this.backend.parse(ensureString(source)));
+    }
+    /**
+     * Parses a file.
+     * @param path - The file path to parse.
+     * @returns A `ParseResult` instance.
+     * @throws Error if the backend is not loaded.
+     */
+    parseFile(path) {
+        this.ensureBackend();
+        return ParseResult.from(this.backend.parseFile(ensureString(path)));
+    }
+    /**
+     * Extracts embedded Ruby code from the given source.
+     * @param source - The source code to extract Ruby from.
+     * @returns The extracted Ruby code as a string.
+     * @throws Error if the backend is not loaded.
+     */
+    extractRuby(source) {
+        this.ensureBackend();
+        return this.backend.extractRuby(ensureString(source));
+    }
+    /**
+     * Extracts HTML from the given source.
+     * @param source - The source code to extract HTML from.
+     * @returns The extracted HTML as a string.
+     * @throws Error if the backend is not loaded.
+     */
+    extractHTML(source) {
+        this.ensureBackend();
+        return this.backend.extractHTML(ensureString(source));
+    }
+    /**
+     * Gets the Herb version information, including the core and backend versions.
+     * @returns A version string containing backend, core, and libherb versions.
+     * @throws Error if the backend is not loaded.
+     */
+    get version() {
+        this.ensureBackend();
+        const backend = this.backendVersion();
+        const core = `${packageJSON.name}@${packageJSON.version}`;
+        const libherb = this.backend.version();
+        return `${backend}, ${core}, ${libherb}`;
+    }
+    /**
+     * Ensures that the backend is loaded.
+     * @throws Error if the backend is not loaded.
+     */
+    ensureBackend() {
+        if (!this.isLoaded) {
+            throw new Error("Herb backend is not loaded. Call `await Herb.load()` first.");
+        }
+    }
+    /**
+     * Checks if the backend is loaded.
+     * @returns True if the backend is loaded, false otherwise.
+     */
+    get isLoaded() {
+        return this.backend !== undefined;
+    }
+}
+
+/**
+ * Represents a visitor that can traverse nodes.
+ */
+class Visitor {
+    /**
+     * Visits a node and performs an action.
+     * @param node - The node to visit.
+     */
+    visit(node) {
+        console.log("Node", node); // TODO: implement
+    }
+}
+
+exports.ASTNode = ASTNode;
+exports.DocumentNode = DocumentNode;
+exports.ERBBeginNode = ERBBeginNode;
+exports.ERBBlockNode = ERBBlockNode;
+exports.ERBCaseNode = ERBCaseNode;
+exports.ERBContentNode = ERBContentNode;
+exports.ERBElseNode = ERBElseNode;
+exports.ERBEndNode = ERBEndNode;
+exports.ERBEnsureNode = ERBEnsureNode;
+exports.ERBForNode = ERBForNode;
+exports.ERBIfNode = ERBIfNode;
+exports.ERBRescueNode = ERBRescueNode;
+exports.ERBUnlessNode = ERBUnlessNode;
+exports.ERBUntilNode = ERBUntilNode;
+exports.ERBWhenNode = ERBWhenNode;
+exports.ERBWhileNode = ERBWhileNode;
+exports.HTMLAttributeNameNode = HTMLAttributeNameNode;
+exports.HTMLAttributeNode = HTMLAttributeNode;
+exports.HTMLAttributeValueNode = HTMLAttributeValueNode;
+exports.HTMLCloseTagNode = HTMLCloseTagNode;
+exports.HTMLCommentNode = HTMLCommentNode;
+exports.HTMLDoctypeNode = HTMLDoctypeNode;
+exports.HTMLElementNode = HTMLElementNode;
+exports.HTMLOpenTagNode = HTMLOpenTagNode;
+exports.HTMLSelfCloseTagNode = HTMLSelfCloseTagNode;
+exports.HTMLTextNode = HTMLTextNode;
+exports.HerbBackend = HerbBackend;
+exports.LexResult = LexResult;
+exports.LiteralNode = LiteralNode;
+exports.Location = Location;
+exports.MissingClosingTagError = MissingClosingTagError;
+exports.MissingOpeningTagError = MissingOpeningTagError;
+exports.ParseResult = ParseResult;
+exports.Position = Position;
+exports.QuotesMismatchError = QuotesMismatchError;
+exports.Range = Range;
+exports.Result = Result;
+exports.RubyParseError = RubyParseError;
+exports.TagNamesMismatchError = TagNamesMismatchError;
+exports.Token = Token;
+exports.TokenList = TokenList;
+exports.UnclosedElementError = UnclosedElementError;
+exports.UnexpectedError = UnexpectedError;
+exports.UnexpectedTokenError = UnexpectedTokenError;
+exports.Visitor = Visitor;
+exports.VoidElementClosingTagError = VoidElementClosingTagError;
+exports.WhitespaceNode = WhitespaceNode;
+exports._TYPECHECK = _TYPECHECK;
+exports.convertToUTF8 = convertToUTF8;
+exports.ensureLibHerbBackend = ensureLibHerbBackend;
+exports.ensureString = ensureString;
+exports.fromSerializedError = fromSerializedError;
+exports.fromSerializedNode = fromSerializedNode;
+exports.isLibHerbBackend = isLibHerbBackend;
+//# sourceMappingURL=herb-core.cjs.map