@herb-tools/core 0.8.10 → 0.9.1

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.10/templates/javascript/packages/core/src/node-type-guards.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.1/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,
@@ -36,6 +43,8 @@ import {
   ERBEnsureNode,
   ERBBeginNode,
   ERBUnlessNode,
+  RubyRenderLocalNode,
+  ERBRenderNode,
   ERBYieldNode,
   ERBInNode,
 } from "./nodes.js"
@@ -50,217 +59,360 @@ 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 RubyRenderLocalNode
+ */
+export function isRubyRenderLocalNode(node: Node | null | undefined): node is RubyRenderLocalNode {
+  if (!node) return false
+
+  return node instanceof RubyRenderLocalNode || node.type === "AST_RUBY_RENDER_LOCAL_NODE" || (node.constructor as any).type === "AST_RUBY_RENDER_LOCAL_NODE"
+}
+
+/**
+ * Checks if a node is a ERBRenderNode
+ */
+export function isERBRenderNode(node: Node | null | undefined): node is ERBRenderNode {
+  if (!node) return false
+
+  return node instanceof ERBRenderNode || node.type === "AST_ERB_RENDER_NODE" || (node.constructor as any).type === "AST_ERB_RENDER_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 +425,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 +443,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) ||
@@ -302,6 +459,7 @@ export function isERBNode(node: Node): node is ERBNode {
          isERBEnsureNode(node) ||
          isERBBeginNode(node) ||
          isERBUnlessNode(node) ||
+         isERBRenderNode(node) ||
          isERBYieldNode(node) ||
          isERBInNode(node)
 }
@@ -320,11 +478,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],
@@ -346,6 +511,8 @@ export const NODE_TYPE_GUARDS = new Map<new (...args: any[]) => Node, (node: Nod
   [ERBEnsureNode, isERBEnsureNode],
   [ERBBeginNode, isERBBeginNode],
   [ERBUnlessNode, isERBUnlessNode],
+  [RubyRenderLocalNode, isRubyRenderLocalNode],
+  [ERBRenderNode, isERBRenderNode],
   [ERBYieldNode, isERBYieldNode],
   [ERBInNode, isERBInNode],
 ])
@@ -364,11 +531,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],
@@ -390,6 +564,8 @@ export const AST_TYPE_GUARDS = new Map<NodeType, (node: Node) => boolean>([
   ["AST_ERB_ENSURE_NODE", isERBEnsureNode],
   ["AST_ERB_BEGIN_NODE", isERBBeginNode],
   ["AST_ERB_UNLESS_NODE", isERBUnlessNode],
+  ["AST_RUBY_RENDER_LOCAL_NODE", isRubyRenderLocalNode],
+  ["AST_ERB_RENDER_NODE", isERBRenderNode],
   ["AST_ERB_YIELD_NODE", isERBYieldNode],
   ["AST_ERB_IN_NODE", isERBInNode],
 ])
@@ -398,11 +574,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;
@@ -424,6 +607,8 @@ type NodeTypeToClass = {
   "AST_ERB_ENSURE_NODE": ERBEnsureNode;
   "AST_ERB_BEGIN_NODE": ERBBeginNode;
   "AST_ERB_UNLESS_NODE": ERBUnlessNode;
+  "AST_RUBY_RENDER_LOCAL_NODE": RubyRenderLocalNode;
+  "AST_ERB_RENDER_NODE": ERBRenderNode;
   "AST_ERB_YIELD_NODE": ERBYieldNode;
   "AST_ERB_IN_NODE": ERBInNode;
 }
@@ -680,6 +865,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 +879,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 +900,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 +928,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
  */
@@ -862,6 +1096,20 @@ export function filterERBUnlessNodes(nodes: Node[]): ERBUnlessNode[] {
   return nodes.filter(isERBUnlessNode) as ERBUnlessNode[]
 }
 
+/**
+ * Filters an array of nodes to only include RubyRenderLocalNode nodes
+ */
+export function filterRubyRenderLocalNodes(nodes: Node[]): RubyRenderLocalNode[] {
+  return nodes.filter(isRubyRenderLocalNode) as RubyRenderLocalNode[]
+}
+
+/**
+ * Filters an array of nodes to only include ERBRenderNode nodes
+ */
+export function filterERBRenderNodes(nodes: Node[]): ERBRenderNode[] {
+  return nodes.filter(isERBRenderNode) as ERBRenderNode[]
+}
+
 /**
  * Filters an array of nodes to only include ERBYieldNode nodes
  */