@idlizer/arktscgen 2.1.9-arktscgen-9 → 2.1.10-arktscgen-2

package/build/libarkts-copy/src/generated/peers/ChainExpression.ts

@@ -38,17 +38,16 @@ import { Expression } from "./Expression"
 import { VReg } from "./VReg"
 
 export class ChainExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 12)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createChainExpression(expression?: Expression): ChainExpression {
-        const result: ChainExpression = new ChainExpression(global.generatedEs2panda._CreateChainExpression(global.context, passNode(expression)))
+        const result: ChainExpression = new ChainExpression(global.generatedEs2panda._CreateChainExpression(global.context, passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateChainExpression(original?: ChainExpression, expression?: Expression): ChainExpression {
-        const result: ChainExpression = new ChainExpression(global.generatedEs2panda._UpdateChainExpression(global.context, passNode(original), passNode(expression)))
+        const result: ChainExpression = new ChainExpression(global.generatedEs2panda._UpdateChainExpression(global.context, passNode(original), passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -66,5 +65,5 @@ export function isChainExpression(node: object | undefined): node is ChainExpres
     return node instanceof ChainExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION, (peer: KNativePointer) => new ChainExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION, (peer: KNativePointer) => new ChainExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/CharLiteral.ts

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 
 export class CharLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 13)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createCharLiteral(): CharLiteral {
-        const result: CharLiteral = new CharLiteral(global.generatedEs2panda._CreateCharLiteral(global.context))
+        const result: CharLiteral = new CharLiteral(global.generatedEs2panda._CreateCharLiteral(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateCharLiteral(original?: CharLiteral): CharLiteral {
-        const result: CharLiteral = new CharLiteral(global.generatedEs2panda._UpdateCharLiteral(global.context, passNode(original)))
+        const result: CharLiteral = new CharLiteral(global.generatedEs2panda._UpdateCharLiteral(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isCharLiteral(node: object | undefined): node is CharLiteral {
     return node instanceof CharLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL, (peer: KNativePointer) => new CharLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL, (peer: KNativePointer) => new CharLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL))
 }

package/build/libarkts-copy/src/generated/peers/ClassDeclaration.ts

@@ -39,12 +39,11 @@ import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 
 export class ClassDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 15)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createClassDeclaration(def?: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration {
-        const result: ClassDeclaration = new ClassDeclaration(global.generatedEs2panda._CreateClassDeclaration(global.context, passNode(def)))
+        const result: ClassDeclaration = new ClassDeclaration(global.generatedEs2panda._CreateClassDeclaration(global.context, passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION)
         if (modifierFlags)
         {
             result.modifierFlags = modifierFlags
@@ -53,7 +52,7 @@ export class ClassDeclaration extends Statement {
         return result
     }
     static updateClassDeclaration(original?: ClassDeclaration, def?: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration {
-        const result: ClassDeclaration = new ClassDeclaration(global.generatedEs2panda._UpdateClassDeclaration(global.context, passNode(original), passNode(def)))
+        const result: ClassDeclaration = new ClassDeclaration(global.generatedEs2panda._UpdateClassDeclaration(global.context, passNode(original), passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION)
         if (modifierFlags)
         {
             result.modifierFlags = modifierFlags
@@ -96,5 +95,5 @@ export function isClassDeclaration(node: object | undefined): node is ClassDecla
     return node instanceof ClassDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, (peer: KNativePointer) => new ClassDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, (peer: KNativePointer) => new ClassDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION))
 }

package/build/libarkts-copy/src/generated/peers/ClassDefinition.ts

@@ -45,14 +45,14 @@ import { TSEnumDeclaration } from "./TSEnumDeclaration"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 import { TypedAstNode } from "./TypedAstNode"
+import { extension_ClassDefinitionSetBody } from "./../../reexport-for-generated"
 
 export class ClassDefinition extends TypedAstNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 14)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createClassDefinition(ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition {
-        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._CreateClassDefinition(global.context, passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags))
+        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._CreateClassDefinition(global.context, passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -61,7 +61,7 @@ export class ClassDefinition extends TypedAstNode {
         return result
     }
     static updateClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition {
-        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition(global.context, passNode(original), passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags))
+        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition(global.context, passNode(original), passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -70,7 +70,7 @@ export class ClassDefinition extends TypedAstNode {
         return result
     }
     static update1ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition {
-        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition1(global.context, passNode(original), passNode(ident), passNodeArray(body), body.length, modifiers, flags))
+        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition1(global.context, passNode(original), passNode(ident), passNodeArray(body), body.length, modifiers, flags), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -79,7 +79,7 @@ export class ClassDefinition extends TypedAstNode {
         return result
     }
     static update2ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition {
-        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition2(global.context, passNode(original), passNode(ident), modifiers, flags))
+        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition2(global.context, passNode(original), passNode(ident), modifiers, flags), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -348,11 +348,12 @@ export class ClassDefinition extends TypedAstNode {
         global.generatedEs2panda._ClassDefinitionAddAnnotations(global.context, this.peer, passNode(annotations))
         return this
     }
+    setBody = extension_ClassDefinitionSetBody
     protected readonly brandClassDefinition: undefined
 }
 export function isClassDefinition(node: object | undefined): node is ClassDefinition {
     return node instanceof ClassDefinition
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, (peer: KNativePointer) => new ClassDefinition(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, (peer: KNativePointer) => new ClassDefinition(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION))
 }

package/build/libarkts-copy/src/generated/peers/ClassElement.ts

@@ -33,14 +33,15 @@ import {
 } from "../../reexport-for-generated"
 
 import { Decorator } from "./Decorator"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { Identifier } from "./Identifier"
 import { TSEnumMember } from "./TSEnumMember"
 import { TypedStatement } from "./TypedStatement"
 
 export class ClassElement extends TypedStatement {
-    constructor(pointer: KNativePointer) {
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     get id(): Identifier | undefined {
         return unpackNode(global.generatedEs2panda._ClassElementId(global.context, this.peer))

package/build/libarkts-copy/src/generated/peers/ClassExpression.ts

@@ -37,17 +37,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class ClassExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 16)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createClassExpression(def?: ClassDefinition): ClassExpression {
-        const result: ClassExpression = new ClassExpression(global.generatedEs2panda._CreateClassExpression(global.context, passNode(def)))
+        const result: ClassExpression = new ClassExpression(global.generatedEs2panda._CreateClassExpression(global.context, passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateClassExpression(original?: ClassExpression, def?: ClassDefinition): ClassExpression {
-        const result: ClassExpression = new ClassExpression(global.generatedEs2panda._UpdateClassExpression(global.context, passNode(original), passNode(def)))
+        const result: ClassExpression = new ClassExpression(global.generatedEs2panda._UpdateClassExpression(global.context, passNode(original), passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +59,5 @@ export function isClassExpression(node: object | undefined): node is ClassExpres
     return node instanceof ClassExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION, (peer: KNativePointer) => new ClassExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION, (peer: KNativePointer) => new ClassExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/ClassProperty.ts

@@ -40,12 +40,11 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class ClassProperty extends ClassElement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 17)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createClassProperty(key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, annotations?: readonly AnnotationUsage[]): ClassProperty {
-        const result: ClassProperty = new ClassProperty(global.generatedEs2panda._CreateClassProperty(global.context, passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed))
+        const result: ClassProperty = new ClassProperty(global.generatedEs2panda._CreateClassProperty(global.context, passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -54,7 +53,7 @@ export class ClassProperty extends ClassElement {
         return result
     }
     static updateClassProperty(original: ClassProperty | undefined, key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, annotations?: readonly AnnotationUsage[]): ClassProperty {
-        const result: ClassProperty = new ClassProperty(global.generatedEs2panda._UpdateClassProperty(global.context, passNode(original), passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed))
+        const result: ClassProperty = new ClassProperty(global.generatedEs2panda._UpdateClassProperty(global.context, passNode(original), passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -82,8 +81,16 @@ export class ClassProperty extends ClassElement {
         return global.generatedEs2panda._ClassPropertyNeedInitInStaticBlockConst(global.context, this.peer)
     }
     /** @deprecated */
-    setInitInStaticBlock(needInitInStaticBlock: boolean): this {
-        global.generatedEs2panda._ClassPropertySetInitInStaticBlock(global.context, this.peer, needInitInStaticBlock)
+    setNeedInitInStaticBlock(): this {
+        global.generatedEs2panda._ClassPropertySetNeedInitInStaticBlock(global.context, this.peer)
+        return this
+    }
+    get isImmediateInit(): boolean {
+        return global.generatedEs2panda._ClassPropertyIsImmediateInitConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setIsImmediateInit(): this {
+        global.generatedEs2panda._ClassPropertySetIsImmediateInit(global.context, this.peer)
         return this
     }
     /** @deprecated */
@@ -128,5 +135,5 @@ export function isClassProperty(node: object | undefined): node is ClassProperty
     return node instanceof ClassProperty
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, (peer: KNativePointer) => new ClassProperty(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, (peer: KNativePointer) => new ClassProperty(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY))
 }

package/build/libarkts-copy/src/generated/peers/ClassStaticBlock.ts

@@ -38,17 +38,16 @@ import { Expression } from "./Expression"
 import { ScriptFunction } from "./ScriptFunction"
 
 export class ClassStaticBlock extends ClassElement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 18)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createClassStaticBlock(value?: Expression): ClassStaticBlock {
-        const result: ClassStaticBlock = new ClassStaticBlock(global.generatedEs2panda._CreateClassStaticBlock(global.context, passNode(value)))
+        const result: ClassStaticBlock = new ClassStaticBlock(global.generatedEs2panda._CreateClassStaticBlock(global.context, passNode(value)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK)
         result.setChildrenParentPtr()
         return result
     }
     static updateClassStaticBlock(original?: ClassStaticBlock, value?: Expression): ClassStaticBlock {
-        const result: ClassStaticBlock = new ClassStaticBlock(global.generatedEs2panda._UpdateClassStaticBlock(global.context, passNode(original), passNode(value)))
+        const result: ClassStaticBlock = new ClassStaticBlock(global.generatedEs2panda._UpdateClassStaticBlock(global.context, passNode(original), passNode(value)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK)
         result.setChildrenParentPtr()
         return result
     }
@@ -64,5 +63,5 @@ export function isClassStaticBlock(node: object | undefined): node is ClassStati
     return node instanceof ClassStaticBlock
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, (peer: KNativePointer) => new ClassStaticBlock(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, (peer: KNativePointer) => new ClassStaticBlock(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK))
 }

package/build/libarkts-copy/src/generated/peers/ConditionalExpression.ts

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class ConditionalExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 19)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createConditionalExpression(test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression {
-        const result: ConditionalExpression = new ConditionalExpression(global.generatedEs2panda._CreateConditionalExpression(global.context, passNode(test), passNode(consequent), passNode(alternate)))
+        const result: ConditionalExpression = new ConditionalExpression(global.generatedEs2panda._CreateConditionalExpression(global.context, passNode(test), passNode(consequent), passNode(alternate)), Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateConditionalExpression(original?: ConditionalExpression, test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression {
-        const result: ConditionalExpression = new ConditionalExpression(global.generatedEs2panda._UpdateConditionalExpression(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate)))
+        const result: ConditionalExpression = new ConditionalExpression(global.generatedEs2panda._UpdateConditionalExpression(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate)), Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -80,5 +79,5 @@ export function isConditionalExpression(node: object | undefined): node is Condi
     return node instanceof ConditionalExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION, (peer: KNativePointer) => new ConditionalExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION, (peer: KNativePointer) => new ConditionalExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/ContinueStatement.ts

@@ -37,22 +37,21 @@ import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 
 export class ContinueStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 20)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1ContinueStatement(ident?: Identifier): ContinueStatement {
-        const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._CreateContinueStatement1(global.context, passNode(ident)))
+        const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._CreateContinueStatement1(global.context, passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateContinueStatement(original?: ContinueStatement): ContinueStatement {
-        const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement(global.context, passNode(original)))
+        const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static update1ContinueStatement(original?: ContinueStatement, ident?: Identifier): ContinueStatement {
-        const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement1(global.context, passNode(original), passNode(ident)))
+        const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement1(global.context, passNode(original), passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -76,5 +75,5 @@ export function isContinueStatement(node: object | undefined): node is ContinueS
     return node instanceof ContinueStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT, (peer: KNativePointer) => new ContinueStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT, (peer: KNativePointer) => new ContinueStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT))
 }

package/build/libarkts-copy/src/generated/peers/DebuggerStatement.ts

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 
 export class DebuggerStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 21)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createDebuggerStatement(): DebuggerStatement {
-        const result: DebuggerStatement = new DebuggerStatement(global.generatedEs2panda._CreateDebuggerStatement(global.context))
+        const result: DebuggerStatement = new DebuggerStatement(global.generatedEs2panda._CreateDebuggerStatement(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateDebuggerStatement(original?: DebuggerStatement): DebuggerStatement {
-        const result: DebuggerStatement = new DebuggerStatement(global.generatedEs2panda._UpdateDebuggerStatement(global.context, passNode(original)))
+        const result: DebuggerStatement = new DebuggerStatement(global.generatedEs2panda._UpdateDebuggerStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isDebuggerStatement(node: object | undefined): node is DebuggerS
     return node instanceof DebuggerStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT, (peer: KNativePointer) => new DebuggerStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT, (peer: KNativePointer) => new DebuggerStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT))
 }

package/build/libarkts-copy/src/generated/peers/Decorator.ts

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 
 export class Decorator extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 22)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createDecorator(expr?: Expression): Decorator {
-        const result: Decorator = new Decorator(global.generatedEs2panda._CreateDecorator(global.context, passNode(expr)))
+        const result: Decorator = new Decorator(global.generatedEs2panda._CreateDecorator(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR)
         result.setChildrenParentPtr()
         return result
     }
     static updateDecorator(original?: Decorator, expr?: Expression): Decorator {
-        const result: Decorator = new Decorator(global.generatedEs2panda._UpdateDecorator(global.context, passNode(original), passNode(expr)))
+        const result: Decorator = new Decorator(global.generatedEs2panda._UpdateDecorator(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +59,5 @@ export function isDecorator(node: object | undefined): node is Decorator {
     return node instanceof Decorator
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR, (peer: KNativePointer) => new Decorator(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR, (peer: KNativePointer) => new Decorator(peer, Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR))
 }

package/build/libarkts-copy/src/generated/peers/DirectEvalExpression.ts

@@ -38,17 +38,16 @@ import { Expression } from "./Expression"
 import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 
 export class DirectEvalExpression extends CallExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 23)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createDirectEvalExpression(callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression {
-        const result: DirectEvalExpression = new DirectEvalExpression(global.generatedEs2panda._CreateDirectEvalExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, parserStatus))
+        const result: DirectEvalExpression = new DirectEvalExpression(global.generatedEs2panda._CreateDirectEvalExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, parserStatus), Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateDirectEvalExpression(original: DirectEvalExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression {
-        const result: DirectEvalExpression = new DirectEvalExpression(global.generatedEs2panda._UpdateDirectEvalExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, parserStatus))
+        const result: DirectEvalExpression = new DirectEvalExpression(global.generatedEs2panda._UpdateDirectEvalExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, parserStatus), Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -58,5 +57,5 @@ export function isDirectEvalExpression(node: object | undefined): node is Direct
     return node instanceof DirectEvalExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL, (peer: KNativePointer) => new DirectEvalExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL, (peer: KNativePointer) => new DirectEvalExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL))
 }

package/build/libarkts-copy/src/generated/peers/DoWhileStatement.ts

@@ -38,17 +38,16 @@ import { LoopStatement } from "./LoopStatement"
 import { Statement } from "./Statement"
 
 export class DoWhileStatement extends LoopStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 24)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createDoWhileStatement(body?: Statement, test?: Expression): DoWhileStatement {
-        const result: DoWhileStatement = new DoWhileStatement(global.generatedEs2panda._CreateDoWhileStatement(global.context, passNode(body), passNode(test)))
+        const result: DoWhileStatement = new DoWhileStatement(global.generatedEs2panda._CreateDoWhileStatement(global.context, passNode(body), passNode(test)), Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateDoWhileStatement(original?: DoWhileStatement, body?: Statement, test?: Expression): DoWhileStatement {
-        const result: DoWhileStatement = new DoWhileStatement(global.generatedEs2panda._UpdateDoWhileStatement(global.context, passNode(original), passNode(body), passNode(test)))
+        const result: DoWhileStatement = new DoWhileStatement(global.generatedEs2panda._UpdateDoWhileStatement(global.context, passNode(original), passNode(body), passNode(test)), Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -64,5 +63,5 @@ export function isDoWhileStatement(node: object | undefined): node is DoWhileSta
     return node instanceof DoWhileStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT, (peer: KNativePointer) => new DoWhileStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT, (peer: KNativePointer) => new DoWhileStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT))
 }

package/build/libarkts-copy/src/generated/peers/ETSClassLiteral.ts

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class ETSClassLiteral extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 73)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSClassLiteral(expr?: TypeNode): ETSClassLiteral {
-        const result: ETSClassLiteral = new ETSClassLiteral(global.generatedEs2panda._CreateETSClassLiteral(global.context, passNode(expr)))
+        const result: ETSClassLiteral = new ETSClassLiteral(global.generatedEs2panda._CreateETSClassLiteral(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSClassLiteral(original?: ETSClassLiteral, expr?: TypeNode): ETSClassLiteral {
-        const result: ETSClassLiteral = new ETSClassLiteral(global.generatedEs2panda._UpdateETSClassLiteral(global.context, passNode(original), passNode(expr)))
+        const result: ETSClassLiteral = new ETSClassLiteral(global.generatedEs2panda._UpdateETSClassLiteral(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +59,5 @@ export function isETSClassLiteral(node: object | undefined): node is ETSClassLit
     return node instanceof ETSClassLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL, (peer: KNativePointer) => new ETSClassLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL, (peer: KNativePointer) => new ETSClassLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL))
 }

package/build/libarkts-copy/src/generated/peers/ETSFunctionType.ts

@@ -42,12 +42,11 @@ import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 
 export class ETSFunctionType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 69)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSFunctionType(signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags, annotations?: readonly AnnotationUsage[]): ETSFunctionType {
-        const result: ETSFunctionType = new ETSFunctionType(global.generatedEs2panda._CreateETSFunctionType(global.context, passNode(signature), funcFlags))
+        const result: ETSFunctionType = new ETSFunctionType(global.generatedEs2panda._CreateETSFunctionType(global.context, passNode(signature), funcFlags), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -56,7 +55,7 @@ export class ETSFunctionType extends TypeNode {
         return result
     }
     static updateETSFunctionType(original: ETSFunctionType | undefined, signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags, annotations?: readonly AnnotationUsage[]): ETSFunctionType {
-        const result: ETSFunctionType = new ETSFunctionType(global.generatedEs2panda._UpdateETSFunctionType(global.context, passNode(original), passNode(signature), funcFlags))
+        const result: ETSFunctionType = new ETSFunctionType(global.generatedEs2panda._UpdateETSFunctionType(global.context, passNode(original), passNode(signature), funcFlags), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -93,5 +92,5 @@ export function isETSFunctionType(node: object | undefined): node is ETSFunction
     return node instanceof ETSFunctionType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, (peer: KNativePointer) => new ETSFunctionType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, (peer: KNativePointer) => new ETSFunctionType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/ETSImportDeclaration.ts

@@ -40,17 +40,16 @@ import { ImportDeclaration } from "./ImportDeclaration"
 import { StringLiteral } from "./StringLiteral"
 
 export class ETSImportDeclaration extends ImportDeclaration {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 81)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSImportDeclaration(importPath: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ETSImportDeclaration {
-        const result: ETSImportDeclaration = new ETSImportDeclaration(global.generatedEs2panda._CreateETSImportDeclaration(global.context, passNode(importPath), passNodeArray(specifiers), specifiers.length, importKinds))
+        const result: ETSImportDeclaration = new ETSImportDeclaration(global.generatedEs2panda._CreateETSImportDeclaration(global.context, passNode(importPath), passNodeArray(specifiers), specifiers.length, importKinds), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSImportDeclaration(original: ETSImportDeclaration | undefined, importPath: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ETSImportDeclaration {
-        const result: ETSImportDeclaration = new ETSImportDeclaration(global.generatedEs2panda._UpdateETSImportDeclaration(global.context, passNode(original), passNode(importPath), passNodeArray(specifiers), specifiers.length, importKinds))
+        const result: ETSImportDeclaration = new ETSImportDeclaration(global.generatedEs2panda._UpdateETSImportDeclaration(global.context, passNode(original), passNode(importPath), passNodeArray(specifiers), specifiers.length, importKinds), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -88,5 +87,5 @@ export function isETSImportDeclaration(node: object | undefined): node is ETSImp
     return node instanceof ETSImportDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, (peer: KNativePointer) => new ETSImportDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, (peer: KNativePointer) => new ETSImportDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION))
 }

package/build/libarkts-copy/src/generated/peers/ETSIntrinsicNode.ts

@@ -37,27 +37,26 @@ import { Es2pandaIntrinsicNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class ETSIntrinsicNode extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 68)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create2ETSIntrinsicNode(type: Es2pandaIntrinsicNodeType, _arguments: readonly Expression[]): ETSIntrinsicNode {
-        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._CreateETSIntrinsicNode2(global.context, type, passNodeArray(_arguments), _arguments.length))
+        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._CreateETSIntrinsicNode2(global.context, type, passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSIntrinsicNode(original?: ETSIntrinsicNode): ETSIntrinsicNode {
-        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode(global.context, passNode(original)))
+        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static update1ETSIntrinsicNode(original?: ETSIntrinsicNode, other?: ETSIntrinsicNode): ETSIntrinsicNode {
-        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode1(global.context, passNode(original), passNode(other)))
+        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static update2ETSIntrinsicNode(original: ETSIntrinsicNode | undefined, type: Es2pandaIntrinsicNodeType, _arguments: readonly Expression[]): ETSIntrinsicNode {
-        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode2(global.context, passNode(original), type, passNodeArray(_arguments), _arguments.length))
+        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode2(global.context, passNode(original), type, passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -73,5 +72,5 @@ export function isETSIntrinsicNode(node: object | undefined): node is ETSIntrins
     return node instanceof ETSIntrinsicNode
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE, (peer: KNativePointer) => new ETSIntrinsicNode(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE, (peer: KNativePointer) => new ETSIntrinsicNode(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE))
 }