@herb-tools/core 0.8.9 → 0.9.0

package/src/extract-ruby-options.ts

@@ -0,0 +1,11 @@
+export interface ExtractRubyOptions {
+  semicolons?: boolean
+  comments?: boolean
+  preserve_positions?: boolean
+}
+
+export const DEFAULT_EXTRACT_RUBY_OPTIONS: ExtractRubyOptions = {
+  semicolons: true,
+  comments: false,
+  preserve_positions: true,
+}

package/src/herb-backend.ts

@@ -4,9 +4,13 @@ import { ensureString } from "./util.js"
 import { LexResult } from "./lex-result.js"
 import { ParseResult } from "./parse-result.js"
 import { DEFAULT_PARSER_OPTIONS } from "./parser-options.js"
+import { DEFAULT_EXTRACT_RUBY_OPTIONS } from "./extract-ruby-options.js"
+import { deserializePrismParseResult } from "./prism/index.js"
 
 import type { LibHerbBackend, BackendPromise } from "./backend.js"
-import type { ParserOptions } from "./parser-options.js"
+import type { ParseOptions } from "./parser-options.js"
+import type { ExtractRubyOptions } from "./extract-ruby-options.js"
+import type { PrismParseResult } from "./prism/index.js"
 
 /**
  * The main Herb parser interface, providing methods to lex and parse input.
@@ -55,13 +59,8 @@ export abstract class HerbBackend {
    * Lexes a file.
    * @param path - The file path to lex.
    * @returns A `LexResult` instance.
-   * @throws Error if the backend is not loaded.
    */
-  lexFile(path: string): LexResult {
-    this.ensureBackend()
-
-    return LexResult.from(this.backend.lexFile(ensureString(path)))
-  }
+  abstract lexFile(path: string): LexResult
 
   /**
    * Parses the given source string into a `ParseResult`.
@@ -70,7 +69,7 @@ export abstract class HerbBackend {
    * @returns A `ParseResult` instance.
    * @throws Error if the backend is not loaded.
    */
-  parse(source: string, options?: ParserOptions): ParseResult {
+  parse(source: string, options?: ParseOptions): ParseResult {
     this.ensureBackend()
 
     const mergedOptions = { ...DEFAULT_PARSER_OPTIONS, ...options }
@@ -82,24 +81,40 @@ export abstract class HerbBackend {
    * Parses a file.
    * @param path - The file path to parse.
    * @returns A `ParseResult` instance.
+   */
+  abstract parseFile(path: string): ParseResult
+
+  /**
+   * Extracts embedded Ruby code from the given source.
+   * @param source - The source code to extract Ruby from.
+   * @param options - Optional extraction options.
+   * @returns The extracted Ruby code as a string.
    * @throws Error if the backend is not loaded.
    */
-  parseFile(path: string): ParseResult {
+  extractRuby(source: string, options?: ExtractRubyOptions): string {
     this.ensureBackend()
 
-    return ParseResult.from(this.backend.parseFile(ensureString(path)))
+    const mergedOptions = { ...DEFAULT_EXTRACT_RUBY_OPTIONS, ...options }
+
+    return this.backend.extractRuby(ensureString(source), mergedOptions)
   }
 
   /**
-   * 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.
+   * Parses a Ruby source string using Prism via the libherb backend.
+   * @param source - The Ruby source code to parse.
+   * @returns A Prism ParseResult containing the AST.
    * @throws Error if the backend is not loaded.
    */
-  extractRuby(source: string): string {
+  parseRuby(source: string): PrismParseResult {
     this.ensureBackend()
 
-    return this.backend.extractRuby(ensureString(source))
+    const bytes = this.backend.parseRuby(ensureString(source))
+
+    if (!bytes) {
+      throw new Error("Failed to parse Ruby source")
+    }
+
+    return deserializePrismParseResult(bytes, source)
   }
 
   /**

package/src/index.ts

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

package/src/node-type-guards.ts

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.9/templates/javascript/packages/core/src/node-type-guards.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/javascript/packages/core/src/node-type-guards.ts.erb
 
 import type { Node, NodeType, ERBNode } from "./nodes.js"
 
@@ -10,11 +10,18 @@ import {
   DocumentNode,
   LiteralNode,
   HTMLOpenTagNode,
+  HTMLConditionalOpenTagNode,
   HTMLCloseTagNode,
+  HTMLOmittedCloseTagNode,
+  HTMLVirtualCloseTagNode,
   HTMLElementNode,
+  HTMLConditionalElementNode,
   HTMLAttributeValueNode,
   HTMLAttributeNameNode,
   HTMLAttributeNode,
+  RubyLiteralNode,
+  RubyHTMLAttributesSplatNode,
+  ERBOpenTagNode,
   HTMLTextNode,
   HTMLCommentNode,
   HTMLDoctypeNode,
@@ -50,217 +57,342 @@ import {
 /**
  * Checks if a node is a DocumentNode
  */
-export function isDocumentNode(node: Node): node is DocumentNode {
+export function isDocumentNode(node: Node | null | undefined): node is DocumentNode {
+  if (!node) return false
+
   return node instanceof DocumentNode || node.type === "AST_DOCUMENT_NODE" || (node.constructor as any).type === "AST_DOCUMENT_NODE"
 }
 
 /**
  * Checks if a node is a LiteralNode
  */
-export function isLiteralNode(node: Node): node is LiteralNode {
+export function isLiteralNode(node: Node | null | undefined): node is LiteralNode {
+  if (!node) return false
+
   return node instanceof LiteralNode || node.type === "AST_LITERAL_NODE" || (node.constructor as any).type === "AST_LITERAL_NODE"
 }
 
 /**
  * Checks if a node is a HTMLOpenTagNode
  */
-export function isHTMLOpenTagNode(node: Node): node is HTMLOpenTagNode {
+export function isHTMLOpenTagNode(node: Node | null | undefined): node is HTMLOpenTagNode {
+  if (!node) return false
+
   return node instanceof HTMLOpenTagNode || node.type === "AST_HTML_OPEN_TAG_NODE" || (node.constructor as any).type === "AST_HTML_OPEN_TAG_NODE"
 }
 
+/**
+ * Checks if a node is a HTMLConditionalOpenTagNode
+ */
+export function isHTMLConditionalOpenTagNode(node: Node | null | undefined): node is HTMLConditionalOpenTagNode {
+  if (!node) return false
+
+  return node instanceof HTMLConditionalOpenTagNode || node.type === "AST_HTML_CONDITIONAL_OPEN_TAG_NODE" || (node.constructor as any).type === "AST_HTML_CONDITIONAL_OPEN_TAG_NODE"
+}
+
 /**
  * Checks if a node is a HTMLCloseTagNode
  */
-export function isHTMLCloseTagNode(node: Node): node is HTMLCloseTagNode {
+export function isHTMLCloseTagNode(node: Node | null | undefined): node is HTMLCloseTagNode {
+  if (!node) return false
+
   return node instanceof HTMLCloseTagNode || node.type === "AST_HTML_CLOSE_TAG_NODE" || (node.constructor as any).type === "AST_HTML_CLOSE_TAG_NODE"
 }
 
+/**
+ * Checks if a node is a HTMLOmittedCloseTagNode
+ */
+export function isHTMLOmittedCloseTagNode(node: Node | null | undefined): node is HTMLOmittedCloseTagNode {
+  if (!node) return false
+
+  return node instanceof HTMLOmittedCloseTagNode || node.type === "AST_HTML_OMITTED_CLOSE_TAG_NODE" || (node.constructor as any).type === "AST_HTML_OMITTED_CLOSE_TAG_NODE"
+}
+
+/**
+ * Checks if a node is a HTMLVirtualCloseTagNode
+ */
+export function isHTMLVirtualCloseTagNode(node: Node | null | undefined): node is HTMLVirtualCloseTagNode {
+  if (!node) return false
+
+  return node instanceof HTMLVirtualCloseTagNode || node.type === "AST_HTML_VIRTUAL_CLOSE_TAG_NODE" || (node.constructor as any).type === "AST_HTML_VIRTUAL_CLOSE_TAG_NODE"
+}
+
 /**
  * Checks if a node is a HTMLElementNode
  */
-export function isHTMLElementNode(node: Node): node is HTMLElementNode {
+export function isHTMLElementNode(node: Node | null | undefined): node is HTMLElementNode {
+  if (!node) return false
+
   return node instanceof HTMLElementNode || node.type === "AST_HTML_ELEMENT_NODE" || (node.constructor as any).type === "AST_HTML_ELEMENT_NODE"
 }
 
+/**
+ * Checks if a node is a HTMLConditionalElementNode
+ */
+export function isHTMLConditionalElementNode(node: Node | null | undefined): node is HTMLConditionalElementNode {
+  if (!node) return false
+
+  return node instanceof HTMLConditionalElementNode || node.type === "AST_HTML_CONDITIONAL_ELEMENT_NODE" || (node.constructor as any).type === "AST_HTML_CONDITIONAL_ELEMENT_NODE"
+}
+
 /**
  * Checks if a node is a HTMLAttributeValueNode
  */
-export function isHTMLAttributeValueNode(node: Node): node is HTMLAttributeValueNode {
+export function isHTMLAttributeValueNode(node: Node | null | undefined): node is HTMLAttributeValueNode {
+  if (!node) return false
+
   return node instanceof HTMLAttributeValueNode || node.type === "AST_HTML_ATTRIBUTE_VALUE_NODE" || (node.constructor as any).type === "AST_HTML_ATTRIBUTE_VALUE_NODE"
 }
 
 /**
  * Checks if a node is a HTMLAttributeNameNode
  */
-export function isHTMLAttributeNameNode(node: Node): node is HTMLAttributeNameNode {
+export function isHTMLAttributeNameNode(node: Node | null | undefined): node is HTMLAttributeNameNode {
+  if (!node) return false
+
   return node instanceof HTMLAttributeNameNode || node.type === "AST_HTML_ATTRIBUTE_NAME_NODE" || (node.constructor as any).type === "AST_HTML_ATTRIBUTE_NAME_NODE"
 }
 
 /**
  * Checks if a node is a HTMLAttributeNode
  */
-export function isHTMLAttributeNode(node: Node): node is HTMLAttributeNode {
+export function isHTMLAttributeNode(node: Node | null | undefined): node is HTMLAttributeNode {
+  if (!node) return false
+
   return node instanceof HTMLAttributeNode || node.type === "AST_HTML_ATTRIBUTE_NODE" || (node.constructor as any).type === "AST_HTML_ATTRIBUTE_NODE"
 }
 
+/**
+ * Checks if a node is a RubyLiteralNode
+ */
+export function isRubyLiteralNode(node: Node | null | undefined): node is RubyLiteralNode {
+  if (!node) return false
+
+  return node instanceof RubyLiteralNode || node.type === "AST_RUBY_LITERAL_NODE" || (node.constructor as any).type === "AST_RUBY_LITERAL_NODE"
+}
+
+/**
+ * Checks if a node is a RubyHTMLAttributesSplatNode
+ */
+export function isRubyHTMLAttributesSplatNode(node: Node | null | undefined): node is RubyHTMLAttributesSplatNode {
+  if (!node) return false
+
+  return node instanceof RubyHTMLAttributesSplatNode || node.type === "AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE" || (node.constructor as any).type === "AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE"
+}
+
+/**
+ * Checks if a node is a ERBOpenTagNode
+ */
+export function isERBOpenTagNode(node: Node | null | undefined): node is ERBOpenTagNode {
+  if (!node) return false
+
+  return node instanceof ERBOpenTagNode || node.type === "AST_ERB_OPEN_TAG_NODE" || (node.constructor as any).type === "AST_ERB_OPEN_TAG_NODE"
+}
+
 /**
  * Checks if a node is a HTMLTextNode
  */
-export function isHTMLTextNode(node: Node): node is HTMLTextNode {
+export function isHTMLTextNode(node: Node | null | undefined): node is HTMLTextNode {
+  if (!node) return false
+
   return node instanceof HTMLTextNode || node.type === "AST_HTML_TEXT_NODE" || (node.constructor as any).type === "AST_HTML_TEXT_NODE"
 }
 
 /**
  * Checks if a node is a HTMLCommentNode
  */
-export function isHTMLCommentNode(node: Node): node is HTMLCommentNode {
+export function isHTMLCommentNode(node: Node | null | undefined): node is HTMLCommentNode {
+  if (!node) return false
+
   return node instanceof HTMLCommentNode || node.type === "AST_HTML_COMMENT_NODE" || (node.constructor as any).type === "AST_HTML_COMMENT_NODE"
 }
 
 /**
  * Checks if a node is a HTMLDoctypeNode
  */
-export function isHTMLDoctypeNode(node: Node): node is HTMLDoctypeNode {
+export function isHTMLDoctypeNode(node: Node | null | undefined): node is HTMLDoctypeNode {
+  if (!node) return false
+
   return node instanceof HTMLDoctypeNode || node.type === "AST_HTML_DOCTYPE_NODE" || (node.constructor as any).type === "AST_HTML_DOCTYPE_NODE"
 }
 
 /**
  * Checks if a node is a XMLDeclarationNode
  */
-export function isXMLDeclarationNode(node: Node): node is XMLDeclarationNode {
+export function isXMLDeclarationNode(node: Node | null | undefined): node is XMLDeclarationNode {
+  if (!node) return false
+
   return node instanceof XMLDeclarationNode || node.type === "AST_XML_DECLARATION_NODE" || (node.constructor as any).type === "AST_XML_DECLARATION_NODE"
 }
 
 /**
  * Checks if a node is a CDATANode
  */
-export function isCDATANode(node: Node): node is CDATANode {
+export function isCDATANode(node: Node | null | undefined): node is CDATANode {
+  if (!node) return false
+
   return node instanceof CDATANode || node.type === "AST_CDATA_NODE" || (node.constructor as any).type === "AST_CDATA_NODE"
 }
 
 /**
  * Checks if a node is a WhitespaceNode
  */
-export function isWhitespaceNode(node: Node): node is WhitespaceNode {
+export function isWhitespaceNode(node: Node | null | undefined): node is WhitespaceNode {
+  if (!node) return false
+
   return node instanceof WhitespaceNode || node.type === "AST_WHITESPACE_NODE" || (node.constructor as any).type === "AST_WHITESPACE_NODE"
 }
 
 /**
  * Checks if a node is a ERBContentNode
  */
-export function isERBContentNode(node: Node): node is ERBContentNode {
+export function isERBContentNode(node: Node | null | undefined): node is ERBContentNode {
+  if (!node) return false
+
   return node instanceof ERBContentNode || node.type === "AST_ERB_CONTENT_NODE" || (node.constructor as any).type === "AST_ERB_CONTENT_NODE"
 }
 
 /**
  * Checks if a node is a ERBEndNode
  */
-export function isERBEndNode(node: Node): node is ERBEndNode {
+export function isERBEndNode(node: Node | null | undefined): node is ERBEndNode {
+  if (!node) return false
+
   return node instanceof ERBEndNode || node.type === "AST_ERB_END_NODE" || (node.constructor as any).type === "AST_ERB_END_NODE"
 }
 
 /**
  * Checks if a node is a ERBElseNode
  */
-export function isERBElseNode(node: Node): node is ERBElseNode {
+export function isERBElseNode(node: Node | null | undefined): node is ERBElseNode {
+  if (!node) return false
+
   return node instanceof ERBElseNode || node.type === "AST_ERB_ELSE_NODE" || (node.constructor as any).type === "AST_ERB_ELSE_NODE"
 }
 
 /**
  * Checks if a node is a ERBIfNode
  */
-export function isERBIfNode(node: Node): node is ERBIfNode {
+export function isERBIfNode(node: Node | null | undefined): node is ERBIfNode {
+  if (!node) return false
+
   return node instanceof ERBIfNode || node.type === "AST_ERB_IF_NODE" || (node.constructor as any).type === "AST_ERB_IF_NODE"
 }
 
 /**
  * Checks if a node is a ERBBlockNode
  */
-export function isERBBlockNode(node: Node): node is ERBBlockNode {
+export function isERBBlockNode(node: Node | null | undefined): node is ERBBlockNode {
+  if (!node) return false
+
   return node instanceof ERBBlockNode || node.type === "AST_ERB_BLOCK_NODE" || (node.constructor as any).type === "AST_ERB_BLOCK_NODE"
 }
 
 /**
  * Checks if a node is a ERBWhenNode
  */
-export function isERBWhenNode(node: Node): node is ERBWhenNode {
+export function isERBWhenNode(node: Node | null | undefined): node is ERBWhenNode {
+  if (!node) return false
+
   return node instanceof ERBWhenNode || node.type === "AST_ERB_WHEN_NODE" || (node.constructor as any).type === "AST_ERB_WHEN_NODE"
 }
 
 /**
  * Checks if a node is a ERBCaseNode
  */
-export function isERBCaseNode(node: Node): node is ERBCaseNode {
+export function isERBCaseNode(node: Node | null | undefined): node is ERBCaseNode {
+  if (!node) return false
+
   return node instanceof ERBCaseNode || node.type === "AST_ERB_CASE_NODE" || (node.constructor as any).type === "AST_ERB_CASE_NODE"
 }
 
 /**
  * Checks if a node is a ERBCaseMatchNode
  */
-export function isERBCaseMatchNode(node: Node): node is ERBCaseMatchNode {
+export function isERBCaseMatchNode(node: Node | null | undefined): node is ERBCaseMatchNode {
+  if (!node) return false
+
   return node instanceof ERBCaseMatchNode || node.type === "AST_ERB_CASE_MATCH_NODE" || (node.constructor as any).type === "AST_ERB_CASE_MATCH_NODE"
 }
 
 /**
  * Checks if a node is a ERBWhileNode
  */
-export function isERBWhileNode(node: Node): node is ERBWhileNode {
+export function isERBWhileNode(node: Node | null | undefined): node is ERBWhileNode {
+  if (!node) return false
+
   return node instanceof ERBWhileNode || node.type === "AST_ERB_WHILE_NODE" || (node.constructor as any).type === "AST_ERB_WHILE_NODE"
 }
 
 /**
  * Checks if a node is a ERBUntilNode
  */
-export function isERBUntilNode(node: Node): node is ERBUntilNode {
+export function isERBUntilNode(node: Node | null | undefined): node is ERBUntilNode {
+  if (!node) return false
+
   return node instanceof ERBUntilNode || node.type === "AST_ERB_UNTIL_NODE" || (node.constructor as any).type === "AST_ERB_UNTIL_NODE"
 }
 
 /**
  * Checks if a node is a ERBForNode
  */
-export function isERBForNode(node: Node): node is ERBForNode {
+export function isERBForNode(node: Node | null | undefined): node is ERBForNode {
+  if (!node) return false
+
   return node instanceof ERBForNode || node.type === "AST_ERB_FOR_NODE" || (node.constructor as any).type === "AST_ERB_FOR_NODE"
 }
 
 /**
  * Checks if a node is a ERBRescueNode
  */
-export function isERBRescueNode(node: Node): node is ERBRescueNode {
+export function isERBRescueNode(node: Node | null | undefined): node is ERBRescueNode {
+  if (!node) return false
+
   return node instanceof ERBRescueNode || node.type === "AST_ERB_RESCUE_NODE" || (node.constructor as any).type === "AST_ERB_RESCUE_NODE"
 }
 
 /**
  * Checks if a node is a ERBEnsureNode
  */
-export function isERBEnsureNode(node: Node): node is ERBEnsureNode {
+export function isERBEnsureNode(node: Node | null | undefined): node is ERBEnsureNode {
+  if (!node) return false
+
   return node instanceof ERBEnsureNode || node.type === "AST_ERB_ENSURE_NODE" || (node.constructor as any).type === "AST_ERB_ENSURE_NODE"
 }
 
 /**
  * Checks if a node is a ERBBeginNode
  */
-export function isERBBeginNode(node: Node): node is ERBBeginNode {
+export function isERBBeginNode(node: Node | null | undefined): node is ERBBeginNode {
+  if (!node) return false
+
   return node instanceof ERBBeginNode || node.type === "AST_ERB_BEGIN_NODE" || (node.constructor as any).type === "AST_ERB_BEGIN_NODE"
 }
 
 /**
  * Checks if a node is a ERBUnlessNode
  */
-export function isERBUnlessNode(node: Node): node is ERBUnlessNode {
+export function isERBUnlessNode(node: Node | null | undefined): node is ERBUnlessNode {
+  if (!node) return false
+
   return node instanceof ERBUnlessNode || node.type === "AST_ERB_UNLESS_NODE" || (node.constructor as any).type === "AST_ERB_UNLESS_NODE"
 }
 
 /**
  * Checks if a node is a ERBYieldNode
  */
-export function isERBYieldNode(node: Node): node is ERBYieldNode {
+export function isERBYieldNode(node: Node | null | undefined): node is ERBYieldNode {
+  if (!node) return false
+
   return node instanceof ERBYieldNode || node.type === "AST_ERB_YIELD_NODE" || (node.constructor as any).type === "AST_ERB_YIELD_NODE"
 }
 
 /**
  * Checks if a node is a ERBInNode
  */
-export function isERBInNode(node: Node): node is ERBInNode {
+export function isERBInNode(node: Node | null | undefined): node is ERBInNode {
+  if (!node) return false
+
   return node instanceof ERBInNode || node.type === "AST_ERB_IN_NODE" || (node.constructor as any).type === "AST_ERB_IN_NODE"
 }
 
@@ -273,8 +405,12 @@ export function isERBInNode(node: Node): node is ERBInNode {
  */
 export function isHTMLNode(node: Node): boolean {
   return isHTMLOpenTagNode(node) ||
+         isHTMLConditionalOpenTagNode(node) ||
          isHTMLCloseTagNode(node) ||
+         isHTMLOmittedCloseTagNode(node) ||
+         isHTMLVirtualCloseTagNode(node) ||
          isHTMLElementNode(node) ||
+         isHTMLConditionalElementNode(node) ||
          isHTMLAttributeValueNode(node) ||
          isHTMLAttributeNameNode(node) ||
          isHTMLAttributeNode(node) ||
@@ -287,7 +423,8 @@ export function isHTMLNode(node: Node): boolean {
  * Checks if a node is any ERB node type
  */
 export function isERBNode(node: Node): node is ERBNode {
-  return isERBContentNode(node) ||
+  return isERBOpenTagNode(node) ||
+         isERBContentNode(node) ||
          isERBEndNode(node) ||
          isERBElseNode(node) ||
          isERBIfNode(node) ||
@@ -320,11 +457,18 @@ export const NODE_TYPE_GUARDS = new Map<new (...args: any[]) => Node, (node: Nod
   [DocumentNode, isDocumentNode],
   [LiteralNode, isLiteralNode],
   [HTMLOpenTagNode, isHTMLOpenTagNode],
+  [HTMLConditionalOpenTagNode, isHTMLConditionalOpenTagNode],
   [HTMLCloseTagNode, isHTMLCloseTagNode],
+  [HTMLOmittedCloseTagNode, isHTMLOmittedCloseTagNode],
+  [HTMLVirtualCloseTagNode, isHTMLVirtualCloseTagNode],
   [HTMLElementNode, isHTMLElementNode],
+  [HTMLConditionalElementNode, isHTMLConditionalElementNode],
   [HTMLAttributeValueNode, isHTMLAttributeValueNode],
   [HTMLAttributeNameNode, isHTMLAttributeNameNode],
   [HTMLAttributeNode, isHTMLAttributeNode],
+  [RubyLiteralNode, isRubyLiteralNode],
+  [RubyHTMLAttributesSplatNode, isRubyHTMLAttributesSplatNode],
+  [ERBOpenTagNode, isERBOpenTagNode],
   [HTMLTextNode, isHTMLTextNode],
   [HTMLCommentNode, isHTMLCommentNode],
   [HTMLDoctypeNode, isHTMLDoctypeNode],
@@ -364,11 +508,18 @@ export const AST_TYPE_GUARDS = new Map<NodeType, (node: Node) => boolean>([
   ["AST_DOCUMENT_NODE", isDocumentNode],
   ["AST_LITERAL_NODE", isLiteralNode],
   ["AST_HTML_OPEN_TAG_NODE", isHTMLOpenTagNode],
+  ["AST_HTML_CONDITIONAL_OPEN_TAG_NODE", isHTMLConditionalOpenTagNode],
   ["AST_HTML_CLOSE_TAG_NODE", isHTMLCloseTagNode],
+  ["AST_HTML_OMITTED_CLOSE_TAG_NODE", isHTMLOmittedCloseTagNode],
+  ["AST_HTML_VIRTUAL_CLOSE_TAG_NODE", isHTMLVirtualCloseTagNode],
   ["AST_HTML_ELEMENT_NODE", isHTMLElementNode],
+  ["AST_HTML_CONDITIONAL_ELEMENT_NODE", isHTMLConditionalElementNode],
   ["AST_HTML_ATTRIBUTE_VALUE_NODE", isHTMLAttributeValueNode],
   ["AST_HTML_ATTRIBUTE_NAME_NODE", isHTMLAttributeNameNode],
   ["AST_HTML_ATTRIBUTE_NODE", isHTMLAttributeNode],
+  ["AST_RUBY_LITERAL_NODE", isRubyLiteralNode],
+  ["AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE", isRubyHTMLAttributesSplatNode],
+  ["AST_ERB_OPEN_TAG_NODE", isERBOpenTagNode],
   ["AST_HTML_TEXT_NODE", isHTMLTextNode],
   ["AST_HTML_COMMENT_NODE", isHTMLCommentNode],
   ["AST_HTML_DOCTYPE_NODE", isHTMLDoctypeNode],
@@ -398,11 +549,18 @@ type NodeTypeToClass = {
   "AST_DOCUMENT_NODE": DocumentNode;
   "AST_LITERAL_NODE": LiteralNode;
   "AST_HTML_OPEN_TAG_NODE": HTMLOpenTagNode;
+  "AST_HTML_CONDITIONAL_OPEN_TAG_NODE": HTMLConditionalOpenTagNode;
   "AST_HTML_CLOSE_TAG_NODE": HTMLCloseTagNode;
+  "AST_HTML_OMITTED_CLOSE_TAG_NODE": HTMLOmittedCloseTagNode;
+  "AST_HTML_VIRTUAL_CLOSE_TAG_NODE": HTMLVirtualCloseTagNode;
   "AST_HTML_ELEMENT_NODE": HTMLElementNode;
+  "AST_HTML_CONDITIONAL_ELEMENT_NODE": HTMLConditionalElementNode;
   "AST_HTML_ATTRIBUTE_VALUE_NODE": HTMLAttributeValueNode;
   "AST_HTML_ATTRIBUTE_NAME_NODE": HTMLAttributeNameNode;
   "AST_HTML_ATTRIBUTE_NODE": HTMLAttributeNode;
+  "AST_RUBY_LITERAL_NODE": RubyLiteralNode;
+  "AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE": RubyHTMLAttributesSplatNode;
+  "AST_ERB_OPEN_TAG_NODE": ERBOpenTagNode;
   "AST_HTML_TEXT_NODE": HTMLTextNode;
   "AST_HTML_COMMENT_NODE": HTMLCommentNode;
   "AST_HTML_DOCTYPE_NODE": HTMLDoctypeNode;
@@ -680,6 +838,13 @@ export function filterHTMLOpenTagNodes(nodes: Node[]): HTMLOpenTagNode[] {
   return nodes.filter(isHTMLOpenTagNode) as HTMLOpenTagNode[]
 }
 
+/**
+ * Filters an array of nodes to only include HTMLConditionalOpenTagNode nodes
+ */
+export function filterHTMLConditionalOpenTagNodes(nodes: Node[]): HTMLConditionalOpenTagNode[] {
+  return nodes.filter(isHTMLConditionalOpenTagNode) as HTMLConditionalOpenTagNode[]
+}
+
 /**
  * Filters an array of nodes to only include HTMLCloseTagNode nodes
  */
@@ -687,6 +852,20 @@ export function filterHTMLCloseTagNodes(nodes: Node[]): HTMLCloseTagNode[] {
   return nodes.filter(isHTMLCloseTagNode) as HTMLCloseTagNode[]
 }
 
+/**
+ * Filters an array of nodes to only include HTMLOmittedCloseTagNode nodes
+ */
+export function filterHTMLOmittedCloseTagNodes(nodes: Node[]): HTMLOmittedCloseTagNode[] {
+  return nodes.filter(isHTMLOmittedCloseTagNode) as HTMLOmittedCloseTagNode[]
+}
+
+/**
+ * Filters an array of nodes to only include HTMLVirtualCloseTagNode nodes
+ */
+export function filterHTMLVirtualCloseTagNodes(nodes: Node[]): HTMLVirtualCloseTagNode[] {
+  return nodes.filter(isHTMLVirtualCloseTagNode) as HTMLVirtualCloseTagNode[]
+}
+
 /**
  * Filters an array of nodes to only include HTMLElementNode nodes
  */
@@ -694,6 +873,13 @@ export function filterHTMLElementNodes(nodes: Node[]): HTMLElementNode[] {
   return nodes.filter(isHTMLElementNode) as HTMLElementNode[]
 }
 
+/**
+ * Filters an array of nodes to only include HTMLConditionalElementNode nodes
+ */
+export function filterHTMLConditionalElementNodes(nodes: Node[]): HTMLConditionalElementNode[] {
+  return nodes.filter(isHTMLConditionalElementNode) as HTMLConditionalElementNode[]
+}
+
 /**
  * Filters an array of nodes to only include HTMLAttributeValueNode nodes
  */
@@ -715,6 +901,27 @@ export function filterHTMLAttributeNodes(nodes: Node[]): HTMLAttributeNode[] {
   return nodes.filter(isHTMLAttributeNode) as HTMLAttributeNode[]
 }
 
+/**
+ * Filters an array of nodes to only include RubyLiteralNode nodes
+ */
+export function filterRubyLiteralNodes(nodes: Node[]): RubyLiteralNode[] {
+  return nodes.filter(isRubyLiteralNode) as RubyLiteralNode[]
+}
+
+/**
+ * Filters an array of nodes to only include RubyHTMLAttributesSplatNode nodes
+ */
+export function filterRubyHTMLAttributesSplatNodes(nodes: Node[]): RubyHTMLAttributesSplatNode[] {
+  return nodes.filter(isRubyHTMLAttributesSplatNode) as RubyHTMLAttributesSplatNode[]
+}
+
+/**
+ * Filters an array of nodes to only include ERBOpenTagNode nodes
+ */
+export function filterERBOpenTagNodes(nodes: Node[]): ERBOpenTagNode[] {
+  return nodes.filter(isERBOpenTagNode) as ERBOpenTagNode[]
+}
+
 /**
  * Filters an array of nodes to only include HTMLTextNode nodes
  */