@idlizer/arktscgen 2.1.2

package/build/libarkts-copy/src/arkts-api/node-utilities/createScriptFunction.ts

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { AnnotationUsage } from "../../generated/peers/AnnotationUsage"
+import { AstNode } from "../peers/AstNode"
+import { Expression } from "../../generated/peers/Expression"
+import { FunctionSignature } from "../../generated/peers/FunctionSignature"
+import { Identifier } from "../../generated/peers/Identifier"
+import { ScriptFunction } from "../../generated/peers/ScriptFunction"
+import { TSTypeParameterDeclaration } from "../../generated/peers/TSTypeParameterDeclaration"
+import { TypeNode } from "../../generated/peers/TypeNode"
+import { Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums"
+
+export function createScriptFunction(
+    databody: AstNode | undefined,
+    typeParams: TSTypeParameterDeclaration | undefined,
+    params: readonly Expression[],
+    returnTypeAnnotation: TypeNode | undefined,
+    hasReceiver: boolean,
+    datafuncFlags: Es2pandaScriptFunctionFlags,
+    dataflags: Es2pandaModifierFlags,
+    ident: Identifier | undefined,
+    annotations: readonly AnnotationUsage[] | undefined,
+) {
+    const res = ScriptFunction.createScriptFunction(
+        databody,
+        FunctionSignature.createFunctionSignature(
+            typeParams,
+            params,
+            returnTypeAnnotation,
+            hasReceiver,
+        ),
+        datafuncFlags,
+        dataflags
+    )
+    if (ident) {
+        res.setIdent(ident)
+    }
+    if (annotations) {
+        res.setAnnotations(annotations)
+    }
+    return res
+}

package/build/libarkts-copy/src/arkts-api/peers/ArktsObject.ts

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { KNativePointer } from "@koalaui/interop"
+
+export abstract class ArktsObject {
+    protected constructor(peer: KNativePointer) {
+        this.peer = peer
+    }
+
+    readonly peer: KNativePointer
+}
+
+export function isSameNativeObject<T extends ArktsObject | number | string | boolean | undefined>(
+    first: T | readonly T[],
+    second: T | readonly T[]
+): boolean {
+    if (Array.isArray(first) && Array.isArray(second)) {
+        if (first.length !== second.length) {
+            return false
+        }
+        for (let i = 0; i < first.length; i++) {
+            if (!isSameNativeObject(first[i], second[i])) {
+                return false
+            }
+        }
+        return true
+    }
+    if (first instanceof ArktsObject && second instanceof ArktsObject) {
+        return first?.peer === second?.peer
+    }
+    return first === second
+}

package/build/libarkts-copy/src/arkts-api/peers/AstNode.ts

@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { isNullPtr, KInt, KNativePointer as KPtr, KNativePointer, nullptr } from "@koalaui/interop"
+import { global } from "../static/global"
+import { allFlags, nodeType, unpackNodeArray, unpackNonNullableNode, unpackString } from "../utilities/private"
+import { throwError } from "../../utils"
+import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
+import { ArktsObject } from "./ArktsObject"
+import { Es2pandaAstNodeType } from "../../Es2pandaEnums"
+
+export abstract class AstNode extends ArktsObject {
+    protected constructor(peer: KNativePointer) {
+        if (isNullPtr(peer)) {
+            throwError(`attempted to create AstNode from nullptr`)
+        }
+        super(peer)
+        this.updateChildren()
+    }
+
+    public get originalPeer(): KNativePointer {
+        return global.generatedEs2panda._AstNodeOriginalNodeConst(global.context, this.peer)
+    }
+
+    public set originalPeer(peer: KNativePointer) {
+        global.generatedEs2panda._AstNodeSetOriginalNode(global.context, this.peer, peer)
+    }
+
+    public getChildren(): readonly AstNode[] {
+        return unpackNodeArray(global.es2panda._AstNodeChildren(global.context, this.peer))
+    }
+
+    public getSubtree(): readonly AstNode[] {
+        return this.getChildren().reduce(
+            (prev: readonly AstNode[], curr) => {
+                return prev.concat(curr.getSubtree())
+            },
+            [this]
+        )
+    }
+
+    public updateChildren(): void {
+        if (this.peer === nullptr) {
+            throwError('updateChildren called on NULLPTR')
+        }
+        global.es2panda._AstNodeUpdateChildren(global.context, this.peer)
+    }
+
+    public updateModifiers(modifierFlags: KInt | undefined): this {
+        global.generatedEs2panda._AstNodeClearModifier(global.context, this.peer, allFlags)
+        global.generatedEs2panda._AstNodeAddModifier(global.context, this.peer, modifierFlags ?? Es2pandaModifierFlags.MODIFIER_FLAGS_NONE)
+        return this
+    }
+
+    public dump(indentation: number = 0): string {
+        const children = this.getChildren()
+            .map((it) => it.dump(indentation + 1))
+        const msg =
+            `${indentation}_`
+            + ` <mods: ${this.modifiers}>`
+            + this.dumpMessage()
+        return "> " + " ".repeat(4 * indentation) + msg + "\n" + children.join("")
+    }
+
+    protected dumpMessage(): string {
+        return ``
+    }
+
+    public dumpJson(): string {
+        return unpackString(global.generatedEs2panda._AstNodeDumpJSONConst(global.context, this.peer))
+    }
+
+    public dumpSrc(): string {
+        return unpackString(global.generatedEs2panda._AstNodeDumpEtsSrcConst(global.context, this.peer))
+    }
+
+    public dumpModifiers(): string {
+        return unpackString(global.es2panda._AstNodeDumpModifiers(global.context, this.peer))
+    }
+
+    public get parent(): AstNode {
+        const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer)
+        if (parent === nullptr) {
+            throwError(`no parent`)
+        }
+        return unpackNonNullableNode(parent)
+    }
+
+    public set parent(node: AstNode) {
+        global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node.peer)
+    }
+
+    public get modifiers(): KInt {
+        return global.generatedEs2panda._AstNodeModifiers(global.context, this.peer)
+    }
+
+    public set modifiers(flags: KInt | undefined) {
+        global.generatedEs2panda._AstNodeClearModifier(global.context, this.peer, allFlags)
+        global.generatedEs2panda._AstNodeAddModifier(global.context, this.peer, flags ?? Es2pandaModifierFlags.MODIFIER_FLAGS_NONE)
+    }
+}
+
+
+export class UnsupportedNode extends AstNode {
+    constructor(peer: KPtr) {
+        super(peer)
+        console.warn(`Warning: unsupported node ${Es2pandaAstNodeType[nodeType(this)]}`)
+    }
+}

package/build/libarkts-copy/src/arkts-api/peers/Config.ts

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ArktsObject } from "./ArktsObject"
+import { global } from "../static/global"
+import { passStringArray } from "../utilities/private"
+import { KNativePointer } from "@koalaui/interop"
+
+export class Config extends ArktsObject {
+    constructor(peer: KNativePointer) {
+        super(peer)
+        // TODO: wait for getter from api
+        this.path = ``
+    }
+
+    static create(
+        input: readonly string[]
+    ): Config {
+        return new Config(
+            global.es2panda._CreateConfig(input.length, passStringArray(input))
+        )
+    }
+
+    static createDefault(): Config {
+        if (global.configIsInitialized()) {
+            console.warn(`Config already initialized`)
+            return new Config(
+                global.config
+            )
+        }
+        return new Config(
+            global.es2panda._CreateConfig(
+                4,
+                passStringArray(["", "--arktsconfig", "./arktsconfig.json", global.filePath])
+            )
+        )
+    }
+
+    readonly path: string
+}

package/build/libarkts-copy/src/arkts-api/peers/Context.ts

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ArktsObject } from "./ArktsObject"
+import { Program } from "./Program"
+import { global } from "../static/global"
+import { throwError } from "../../utils"
+import { passString } from "../utilities/private"
+import { KNativePointer } from "@koalaui/interop"
+
+export class Context extends ArktsObject {
+    constructor(peer: KNativePointer) {
+        super(peer)
+    }
+
+    static createFromString(
+        source: string
+    ): Context {
+        if (!global.configIsInitialized()) {
+            throwError(`Config not initialized`)
+        }
+        return new Context(
+            global.es2panda._CreateContextFromString(
+                global.config,
+                passString(source),
+                passString(global.filePath)
+            )
+        )
+    }
+
+    get program(): Program {
+        return new Program(global.es2panda._ContextProgram(this.peer));
+    }
+}

package/build/libarkts-copy/src/arkts-api/peers/Program.ts

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ArktsObject } from "./ArktsObject"
+import { global } from "../static/global"
+import { acceptNativeObjectArrayResult, unpackString } from "../utilities/private"
+import { KNativePointer } from "@koalaui/interop"
+import { ETSModule } from "../../generated"
+
+export class Program extends ArktsObject {
+    constructor(peer: KNativePointer) {
+        super(peer)
+    }
+
+    get astNode(): ETSModule {
+        return new ETSModule(global.es2panda._ProgramAst(global.context, this.peer));
+    }
+
+    get externalSources(): ExternalSource[] {
+        return acceptNativeObjectArrayResult<ExternalSource>(
+            global.es2panda._ProgramExternalSources(global.context, this.peer),
+            (instance: KNativePointer) => new ExternalSource(instance)
+        );
+    }
+
+}
+
+export class ExternalSource extends ArktsObject {
+    constructor(peer: KNativePointer) {
+        super(peer)
+    }
+
+    getName(): string {
+        return unpackString(global.es2panda._ExternalSourceName(this.peer));
+    }
+
+    get programs(): Program[] {
+        return acceptNativeObjectArrayResult<Program>(
+            global.es2panda._ExternalSourcePrograms(this.peer),
+            (instance: KNativePointer) => new Program(instance)
+        );
+    }
+}

package/build/libarkts-copy/src/arkts-api/static/global.ts

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { throwError } from "../../utils"
+import { KNativePointer } from "@koalaui/interop"
+import { initEs2panda, Es2pandaNativeModule, initGeneratedEs2panda } from "../../Es2pandaNativeModule"
+import { Es2pandaNativeModule as GeneratedEs2pandaNativeModule } from "../../generated/Es2pandaNativeModule"
+import { initInterop, InteropNativeModule } from "../../InteropNativeModule"
+import { Context } from "../peers/Context"
+
+export class global {
+    public static filePath: string = "./plugins/input/main.ets"
+    public static filePathFromPackageRoot: string = global.filePath
+
+    private static _config?: KNativePointer
+    public static set config(config: KNativePointer) {
+        global._config = config
+    }
+    public static get config(): KNativePointer {
+        return global._config ?? throwError('Global.config not initialized')
+    }
+    public static configIsInitialized(): boolean {
+        return global._config !== undefined
+    }
+
+    // TODO: rename to contextPeer
+    public static get context(): KNativePointer {
+        return global.compilerContext.peer ?? throwError('Global.context not initialized')
+    }
+
+    // TODO: rename to context when the pointer valued one is eliminated
+    public static compilerContext: Context
+
+    private static _es2panda: Es2pandaNativeModule | undefined = undefined
+    public static get es2panda(): Es2pandaNativeModule {
+        if (this._es2panda === undefined) {
+            this._es2panda = initEs2panda()
+        }
+        return this._es2panda
+    }
+
+    private static _generatedEs2panda: GeneratedEs2pandaNativeModule | undefined = undefined
+    public static get generatedEs2panda(): GeneratedEs2pandaNativeModule {
+        if (this._generatedEs2panda === undefined) {
+            this._generatedEs2panda = initGeneratedEs2panda()
+        }
+        return this._generatedEs2panda
+    }
+
+    private static _interop: InteropNativeModule | undefined = undefined
+    public static get interop(): InteropNativeModule {
+        if (this._interop === undefined) this._interop = initInterop()
+        return this._interop
+    }
+}

package/build/libarkts-copy/src/arkts-api/utilities/nativePtrDecoder.ts

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { int32 } from "@koalaui/common"
+import {
+    Access,
+    ArrayDecoder,
+    CallbackRegistry,
+    NativeStringBase,
+    nullptr,
+    pointer,
+    providePlatformDefinedData,
+    withByteArray
+} from "@koalaui/interop"
+import { global } from "../static/global"
+
+class NativeString extends NativeStringBase {
+    constructor(ptr: pointer) {
+        super(ptr)
+    }
+    protected bytesLength(): int32 {
+        return global.interop._StringLength(this.ptr)
+    }
+    protected getData(data: Uint8Array): void {
+        withByteArray(data, Access.WRITE, (dataPtr: pointer) => {
+            global.interop._StringData(this.ptr, dataPtr, data.length)
+        })
+    }
+    close(): void {
+        global.interop._InvokeFinalizer(this.ptr, global.interop._GetStringFinalizer())
+        this.ptr = nullptr
+    }
+}
+
+providePlatformDefinedData({
+    nativeString(ptr: pointer): NativeStringBase {
+        return new NativeString(ptr)
+    },
+    nativeStringArrayDecoder(): ArrayDecoder<NativeStringBase> {
+        throw new Error("Not yet implemented")
+    },
+    callbackRegistry(): CallbackRegistry | undefined {
+        return undefined
+    }
+})
+
+export class NativePtrDecoder extends ArrayDecoder<pointer> {
+    getArraySize(blob: pointer) {
+        return global.interop._GetPtrVectorSize(blob)
+    }
+    disposeArray(blob: pointer): void {
+        // TODO
+    }
+    getArrayElement(blob: pointer, index: int32): pointer {
+        return global.interop._GetPtrVectorElement(blob, index)
+    }
+}

package/build/libarkts-copy/src/arkts-api/utilities/private.ts

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { global } from "../static/global"
+import { isNumber, throwError } from "../../utils"
+import {
+    KInt,
+    KNativePointer as KPtr,
+    KNativePointer,
+    nullptr,
+    withString,
+    withStringArray,
+    withStringResult
+} from "@koalaui/interop"
+import { NativePtrDecoder } from "./nativePtrDecoder"
+import { Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums"
+import { classByPeer } from "../class-by-peer"
+import type { AstNode } from "../peers/AstNode"
+import { ArktsObject } from "../peers/ArktsObject"
+import { Es2pandaAstNodeType } from "../../Es2pandaEnums"
+
+export const arrayOfNullptr = new BigUint64Array([nullptr])
+
+export const allFlags =
+    Object.values(Es2pandaModifierFlags)
+        .filter(isNumber)
+        .reduce(
+            (prev, next) => prev | next,
+            0
+
+        )
+
+export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): void {
+    if (peer === nullptr) {
+        throwError(`invalid peer`)
+    }
+    const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer)
+    if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION) {
+        // TODO: Struct is a child class of Class
+        return
+    }
+    if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION) {
+        // TODO: ETSImportDeclaration is a child of a ImportDeclaration
+        return
+    }
+    if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT) {
+        // TODO: ETSModule is a child of a BlockStatement
+        return
+    }
+    if (peerType !== expectedKind) {
+        throwError(`expected: ${Es2pandaAstNodeType[expectedKind]}, got: ${Es2pandaAstNodeType[peerType]}`)
+    }
+}
+
+export function acceptNativeObjectArrayResult<T extends ArktsObject>(arrayObject: KNativePointer, factory: (instance: KNativePointer) => T): T[] {
+    return new NativePtrDecoder().decode(arrayObject).map(factory);
+}
+
+export function unpackNonNullableNode<T extends AstNode>(peer: KNativePointer): T {
+    if (peer === nullptr) {
+        throwError('peer is NULLPTR (maybe you should use unpackNode)')
+    }
+    return classByPeer(peer) as T
+}
+
+export function unpackNode<T extends AstNode>(peer: KNativePointer): T | undefined {
+    if (peer === nullptr) {
+        return undefined
+    }
+    return classByPeer(peer) as T
+}
+
+export function passNode(node: ArktsObject | undefined): KNativePointer {
+    return node?.peer ?? nullptr
+}
+
+// meaning unpackNonNullableNodeArray
+export function unpackNodeArray<T extends AstNode>(nodesPtr: KNativePointer): T[] {
+    if (nodesPtr === nullptr) {
+        throwError('nodesPtr is NULLPTR (maybe you should use unpackNodeArray)')
+    }
+    return new NativePtrDecoder()
+        .decode(nodesPtr)
+        .map((peer: KNativePointer) => unpackNonNullableNode(peer))
+}
+
+export function passNodeArray(nodes: readonly AstNode[] | undefined): BigUint64Array {
+    return new BigUint64Array(
+        nodes?.map(node => BigInt(node.peer)) ?? []
+    )
+}
+
+export function unpackNonNullableObject<T extends ArktsObject>(type: { new (peer: KNativePointer): T }, peer: KNativePointer): T {
+    if (peer === nullptr) {
+        throwError('peer is NULLPTR (maybe you should use unpackObject)')
+    }
+    return new type(peer)
+}
+
+export function unpackObject<T extends ArktsObject>(type: { new (peer: KNativePointer): T }, peer: KNativePointer): T | undefined {
+    if (peer === nullptr) {
+        return undefined
+    }
+    return new type(peer)
+}
+
+export function unpackString(peer: KNativePointer): string {
+    return withStringResult(peer) ?? throwError(`failed to unpack (peer shouldn't be NULLPTR)`)
+}
+
+export function passString(str: string | undefined): string {
+    if (str === undefined) {
+        return ""
+    }
+    return withString(str, (it: string) => it)
+}
+
+export function passStringArray(strings: readonly string[]): string[] {
+    return withStringArray(strings, (it: string[]) => it)
+}
+
+export function passNodeWithNewModifiers<T extends AstNode>(node: T, modifiers: KInt): T {
+    return (unpackNonNullableNode(node.peer) as T).updateModifiers(modifiers)
+}
+
+export function scriptFunctionHasBody(peer: KNativePointer): boolean {
+    const flags = global.generatedEs2panda._ScriptFunctionFlagsConst(global.context, peer)
+    return (flags & Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_EXTERNAL) === 0
+        && (flags & Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_EXTERNAL_OVERLOAD) === 0
+}
+
+export function updateNodeByNode<T extends ArktsObject>(node: T, original: T): T {
+    if (original.peer === nullptr) {
+        throwError('update called on NULLPTR')
+    }
+    global.generatedEs2panda._AstNodeSetOriginalNode(global.context, node.peer, original.peer)
+    global.generatedEs2panda._AstNodeSetParent(global.context, node.peer, global.generatedEs2panda._AstNodeParent(global.context, original.peer))
+    global.es2panda._AstNodeUpdateChildren(global.context, node.peer)
+    return node
+}
+
+export function nodeType(node: AstNode): Es2pandaAstNodeType {
+    return global.generatedEs2panda._AstNodeTypeConst(global.context, passNode(node))
+}