From 38b54047df94556eec5db012a80fb04e40ba3102 Mon Sep 17 00:00:00 2001 From: Korobeinikov Evgeny Date: Tue, 18 Feb 2025 14:16:18 +0000 Subject: [PATCH 01/20] !1 release-1.5.4 * release-1.5.4 --- VERSION | 2 +- arkoala/arkui-common/package.json | 8 ++++---- arkoala/arkui/package.json | 8 ++++---- arkoala/ets-plugin/package.json | 2 +- incremental/build-common/package.json | 7 +++++-- incremental/common/package.json | 4 ++-- incremental/compat/package.json | 2 +- incremental/compiler-plugin/package.json | 4 ++-- incremental/harness/package.json | 6 +++--- incremental/runtime/package.json | 8 ++++---- interop/package.json | 4 ++-- 11 files changed, 29 insertions(+), 26 deletions(-) diff --git a/VERSION b/VERSION index 1d5e9e0ba..63ebd3fe3 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.5.3 \ No newline at end of file +1.5.4 \ No newline at end of file diff --git a/arkoala/arkui-common/package.json b/arkoala/arkui-common/package.json index eaf72b00b..a47ed8a21 100644 --- a/arkoala/arkui-common/package.json +++ b/arkoala/arkui-common/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/arkui-common", - "version": "1.5.3+devel", + "version": "1.5.4+devel", "description": "", "main": "build/lib/src/index.js", "exports": { @@ -53,9 +53,9 @@ }, "keywords": [], "dependencies": { - "@koalaui/common": "1.5.3+devel", - "@koalaui/compat": "1.5.3+devel", - "@koalaui/runtime": "1.5.3+devel", + "@koalaui/common": "1.5.4+devel", + "@koalaui/compat": "1.5.4+devel", + "@koalaui/runtime": "1.5.4+devel", "@koalaui/ets-tsc": "4.9.5-r4", "@koalaui/fast-arktsc": "next" } diff --git a/arkoala/arkui/package.json b/arkoala/arkui/package.json index d7f5d0a20..784d1062d 100644 --- a/arkoala/arkui/package.json +++ b/arkoala/arkui/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/arkoala-arkui", - "version": "1.5.3+devel", + "version": "1.5.4+devel", "description": "", "main": "build/lib/src/index.js", "exports": { @@ -45,10 +45,10 @@ }, "keywords": [], "dependencies": { - "@koalaui/common": "1.5.3+devel", - "@koalaui/runtime": "1.5.3+devel", + "@koalaui/common": "1.5.4+devel", + "@koalaui/runtime": "1.5.4+devel", "@koalaui/arkoala": "1.4.1+devel", - "@koalaui/arkui-common": "1.5.3+devel", + "@koalaui/arkui-common": "1.5.4+devel", "@koalaui/ets-tsc": "4.9.5-r4", "media-query-parser": "^2.0.2", "commander": "10.0.1" diff --git a/arkoala/ets-plugin/package.json b/arkoala/ets-plugin/package.json index 167262437..229020c03 100644 --- a/arkoala/ets-plugin/package.json +++ b/arkoala/ets-plugin/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/ets-plugin", - "version": "1.5.3+devel", + "version": "1.5.4+devel", "description": "", "main": "build/lib/src/index.js", "types": "build/lib/src/index.d.ts", diff --git a/incremental/build-common/package.json b/incremental/build-common/package.json index 4fbd620d6..ae04b44d0 100644 --- a/incremental/build-common/package.json +++ b/incremental/build-common/package.json @@ -1,8 +1,11 @@ { "name": "@koalaui/build-common", - "version": "1.5.3+devel", + "version": "1.5.4+devel", "description": "", "files": [ "tsconfig.json" - ] + ], + "scripts": { + "compile": "" + } } \ No newline at end of file diff --git a/incremental/common/package.json b/incremental/common/package.json index 5eb5658c8..fed0d1e32 100644 --- a/incremental/common/package.json +++ b/incremental/common/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/common", - "version": "1.5.3+devel", + "version": "1.5.4+devel", "description": "", "main": "build/lib/src/index.js", "types": "./index.d.ts", @@ -43,7 +43,7 @@ }, "keywords": [], "dependencies": { - "@koalaui/compat": "1.5.3+devel" + "@koalaui/compat": "1.5.4+devel" }, "devDependencies": { "@ohos/hypium": "1.0.6", diff --git a/incremental/compat/package.json b/incremental/compat/package.json index 62ad8d61d..97ea035f5 100644 --- a/incremental/compat/package.json +++ b/incremental/compat/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/compat", - "version": "1.5.3+devel", + "version": "1.5.4+devel", "description": "", "main": "build/src/index.js", "types": "build/src/index.d.ts", diff --git a/incremental/compiler-plugin/package.json b/incremental/compiler-plugin/package.json index 8f29b81db..dccd66d64 100644 --- a/incremental/compiler-plugin/package.json +++ b/incremental/compiler-plugin/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/compiler-plugin", - "version": "1.5.3+devel", + "version": "1.5.4+devel", "description": "", "main": "build/lib/src/index.js", "types": "build/lib/src/index.d.ts", @@ -10,7 +10,7 @@ ], "keywords": [], "dependencies": { - "@koalaui/common": "1.5.3+devel" + "@koalaui/common": "1.5.4+devel" }, "devDependencies": { "@types/chai": "^4.3.1", diff --git a/incremental/harness/package.json b/incremental/harness/package.json index 257c87491..fe784704c 100644 --- a/incremental/harness/package.json +++ b/incremental/harness/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/harness", - "version": "1.5.3+devel", + "version": "1.5.4+devel", "description": "A harness library compatible with OHOS and ArkTS", "main": "build/src/index.js", "types": "build/src/index.d.ts", @@ -35,8 +35,8 @@ }, "keywords": [], "dependencies": { - "@koalaui/common": "1.5.3+devel", - "@koalaui/compat": "1.5.3+devel" + "@koalaui/common": "1.5.4+devel", + "@koalaui/compat": "1.5.4+devel" }, "devDependencies": { "@ohos/hypium": "1.0.6", diff --git a/incremental/runtime/package.json b/incremental/runtime/package.json index e20c6e8fd..aa8066c4c 100644 --- a/incremental/runtime/package.json +++ b/incremental/runtime/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/runtime", - "version": "1.5.3+devel", + "version": "1.5.4+devel", "description": "", "main": "./build/lib/src/index.js", "types": "./build/lib/src/index.d.ts", @@ -41,9 +41,9 @@ }, "keywords": [], "dependencies": { - "@koalaui/common": "1.5.3+devel", - "@koalaui/compat": "1.5.3+devel", - "@koalaui/harness": "1.5.3+devel" + "@koalaui/common": "1.5.4+devel", + "@koalaui/compat": "1.5.4+devel", + "@koalaui/harness": "1.5.4+devel" }, "devDependencies": { "@types/chai": "^4.3.1", diff --git a/interop/package.json b/interop/package.json index 511ad48a3..cc1f72473 100644 --- a/interop/package.json +++ b/interop/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/interop", - "version": "1.5.3+devel", + "version": "1.5.4+devel", "description": "", "workspaces": [ "../incremental/build-common", @@ -57,7 +57,7 @@ "keywords": [], "dependencies": { "@types/node": "^18.0.0", - "@koalaui/common": "1.5.3+devel" + "@koalaui/common": "1.5.4+devel" }, "devDependencies": { "@ohos/hypium": "1.0.6", -- Gitee From 469990480f04780d57831c6af1f91176f43bc4bc Mon Sep 17 00:00:00 2001 From: Roman Sedaikin Date: Tue, 18 Feb 2025 14:29:02 +0000 Subject: [PATCH 02/20] !2 EtsHarness log assertion. --- arkoala-arkts/arkui/src/Application.ts | 3 +- .../arkui/src/peers/ArkTestComponentPeer.ts | 2 +- .../ets-harness/src/EtsHarnessApplication.ts | 12 ++++++-- .../ets-harness/src/ets/pages/case1.ets | 1 - .../ets-harness/src/ets/pages/case2.ets | 1 - arkoala-arkts/ets-harness/src/loader.ts | 17 +++++++---- arkoala-arkts/ets-harness/src/test_entry.ts | 30 +++++++++++-------- arkoala-arkts/loader/src/loader.ts | 2 +- interop/src/cpp/common-interop.cc | 11 ++++--- interop/src/cpp/vmloader.cc | 21 ++++++++----- 10 files changed, 62 insertions(+), 38 deletions(-) diff --git a/arkoala-arkts/arkui/src/Application.ts b/arkoala-arkts/arkui/src/Application.ts index a60c065a0..afa0423cd 100644 --- a/arkoala-arkts/arkui/src/Application.ts +++ b/arkoala-arkts/arkui/src/Application.ts @@ -306,7 +306,7 @@ export class Application { } // TODO: make [emitEvent] suitable to get string argument - emitEvent(type: int32, target: int32, arg0: int32, arg1: int32) { + emitEvent(type: int32, target: int32, arg0: int32, arg1: int32): string { const node = PeerNode.findPeerByNativeId(target) if (node != undefined) { try { @@ -332,6 +332,7 @@ export class Application { InteropNativeModule._NativeLog("emitEvent error: " + errorInfo(error as Object)) } } + return "0" } static createApplication(appUrl: string, params: string, useNativeLog: boolean): Application { diff --git a/arkoala-arkts/arkui/src/peers/ArkTestComponentPeer.ts b/arkoala-arkts/arkui/src/peers/ArkTestComponentPeer.ts index 431e97dff..3a7ba1c6c 100644 --- a/arkoala-arkts/arkui/src/peers/ArkTestComponentPeer.ts +++ b/arkoala-arkts/arkui/src/peers/ArkTestComponentPeer.ts @@ -43,7 +43,7 @@ export class ArkTestComponentPeer extends ArkCommonMethodPeer { this.onChangeCallback = callback } logAttribute(message: string): void { - InteropNativeModule._AppendGroupedLog(1, message) + InteropNativeModule._AppendGroupedLog(0, message + "\n") } } export interface ArkTestComponentAttributes extends ArkCommonMethodAttributes { diff --git a/arkoala-arkts/ets-harness/src/EtsHarnessApplication.ts b/arkoala-arkts/ets-harness/src/EtsHarnessApplication.ts index 38bf4ba7c..83016e900 100644 --- a/arkoala-arkts/ets-harness/src/EtsHarnessApplication.ts +++ b/arkoala-arkts/ets-harness/src/EtsHarnessApplication.ts @@ -113,8 +113,9 @@ export class EtsHarnessApplication { return true } - emitEvent(type: int32, target: int32, arg0: int32, arg1: int32) { + emitEvent(type: int32, target: int32, arg0: int32, arg1: int32): string { const node = PeerNode.findPeerByNativeId(target) + let result = "0" switch (type) { case 1: { if (node != undefined) { @@ -124,11 +125,15 @@ export class EtsHarnessApplication { break } case 2: { - UserView.startNativeLog(1) + UserView.startNativeLog(0) break; } case 3: { - UserView.stopNativeLog(1) + UserView.stopNativeLog(0) + break; + } + case 4: { + result = UserView.getNativeLog(0) break; } default: { @@ -136,6 +141,7 @@ export class EtsHarnessApplication { break; } } + return result } updateStates(manager: StateManager, root: ComputableState ) { diff --git a/arkoala-arkts/ets-harness/src/ets/pages/case1.ets b/arkoala-arkts/ets-harness/src/ets/pages/case1.ets index 8594a5214..98f08cc78 100644 --- a/arkoala-arkts/ets-harness/src/ets/pages/case1.ets +++ b/arkoala-arkts/ets-harness/src/ets/pages/case1.ets @@ -5,7 +5,6 @@ struct Case1 { build() { TestComponent({ id: 42 }).onChange(() => { this.x++ - console.log("Case1 - value:" + this.x) }) .log("Case1 - value:" + this.x) } diff --git a/arkoala-arkts/ets-harness/src/ets/pages/case2.ets b/arkoala-arkts/ets-harness/src/ets/pages/case2.ets index 30529d8ff..392f423b7 100644 --- a/arkoala-arkts/ets-harness/src/ets/pages/case2.ets +++ b/arkoala-arkts/ets-harness/src/ets/pages/case2.ets @@ -5,7 +5,6 @@ struct Case2 { build() { TestComponent({ id: 42 }).onChange(() => { this.x-- - console.log("Case2 - value:" + this.x) }) .log("Case2 - value:" + this.x) } diff --git a/arkoala-arkts/ets-harness/src/loader.ts b/arkoala-arkts/ets-harness/src/loader.ts index 586a48ad7..4fabe956a 100644 --- a/arkoala-arkts/ets-harness/src/loader.ts +++ b/arkoala-arkts/ets-harness/src/loader.ts @@ -26,7 +26,7 @@ export interface LoaderOps { } export interface NativeControl extends LoaderOps { - _EmitEvent(type: int32, target: int32, arg0: int32, arg1: int32): void + _EmitEvent(type: int32, target: int32, arg0: int32, arg1: int32): string _RestartWith(page: string): void } @@ -46,20 +46,27 @@ export function nativeModule(): NativeControl { return theModule } +export enum TaskType { + OnChange = 1, + StartLog = 2, + StopLog = 3, + GetLog = 4, +} + export class AppControl { getLog(): string { - return "" + return nativeModule()._EmitEvent(TaskType.GetLog, -1, 0, 0) } - emitTask(type: int32, target: int32, arg1: int32, arg2: int32): AppControl { + emitTask(type: int32, target: int32, arg1: int32 = 0, arg2: int32 = 0): AppControl { nativeModule()._EmitEvent(type, target, arg1, arg2) return this } start(): AppControl { - nativeModule()._EmitEvent(2, -1, 0, 0) + nativeModule()._EmitEvent(TaskType.StartLog, -1, 0, 0) return this } stop(): AppControl { - nativeModule()._EmitEvent(3, -1, 0, 0) + nativeModule()._EmitEvent(TaskType.StopLog, -1, 0, 0) return this } nextFrame(): AppControl { diff --git a/arkoala-arkts/ets-harness/src/test_entry.ts b/arkoala-arkts/ets-harness/src/test_entry.ts index ec112fe5e..47cd0f156 100644 --- a/arkoala-arkts/ets-harness/src/test_entry.ts +++ b/arkoala-arkts/ets-harness/src/test_entry.ts @@ -1,33 +1,37 @@ import { Assert } from "@koalaui/harness" -import { AppControl } from "./loader" +import { AppControl, TaskType } from "./loader" export function entry(control: AppControl) { suite("Case1", () => { test("StateChange:Increment", () => { + const expected = "Case1 - value:1\nCase1 - value:2\nCase1 - value:3\n" + const componentId = 42 // id from Case1.TestComponent // onChange - control + const actual = control .loadPage("Case1") .start() - .emitTask(1, 42, 0, 0).nextFrame() - .emitTask(1, 42, 0, 0).nextFrame() - .emitTask(1, 42, 0, 0).nextFrame() + .emitTask(TaskType.OnChange, componentId).nextFrame() + .emitTask(TaskType.OnChange, componentId).nextFrame() + .emitTask(TaskType.OnChange, componentId).nextFrame() .stop() - let x = 3 - Assert.equal(x, 3, "StateChange test is failed!\n expected: " + 3 + "\ncurrent: " + x) + .getLog() + Assert.equal(expected, actual, "StateChange: Case1 test is failed!") }) }) suite("Case2", () => { test("StateChange:Decrement", () => { + const expected = "Case2 - value:-1\nCase2 - value:-2\nCase2 - value:-3\n" + const componentId = 42 // id from Case2.TestComponent // onChange - control + const actual = control .loadPage("Case2") .start() - .emitTask(1, 42, 0, 0).nextFrame() - .emitTask(1, 42, 0, 0).nextFrame() - .emitTask(1, 42, 0, 0).nextFrame() + .emitTask(TaskType.OnChange, componentId).nextFrame() + .emitTask(TaskType.OnChange, componentId).nextFrame() + .emitTask(TaskType.OnChange, componentId).nextFrame() .stop() - let x = -3 - Assert.equal(x, -3, "StateChange test is failed!\n expected: " + (-3) + "\ncurrent: " + x) + .getLog() + Assert.equal(expected, actual, "StateChange: Case2 test is failed!") }) }) } diff --git a/arkoala-arkts/loader/src/loader.ts b/arkoala-arkts/loader/src/loader.ts index 8936e229e..f66b0a977 100644 --- a/arkoala-arkts/loader/src/loader.ts +++ b/arkoala-arkts/loader/src/loader.ts @@ -46,7 +46,7 @@ export interface NativeControl extends LoaderOps { _SetVsyncCallback(pipeline: KPointer): void _VSyncAwait(pipeline: KPointer): Promise _UnblockVsyncWait(pipeline: KPointer): void - _EmitEvent(type: int32, target: int32, arg0: int32, arg1: int32): void + _EmitEvent(type: int32, target: int32, arg0: int32, arg1: int32): string } function callCallback(id: int32, args: KUint8ArrayPtr, length: int32): int32 { diff --git a/interop/src/cpp/common-interop.cc b/interop/src/cpp/common-interop.cc index c522cc84a..cd3146017 100644 --- a/interop/src/cpp/common-interop.cc +++ b/interop/src/cpp/common-interop.cc @@ -259,7 +259,7 @@ struct ForeignVMContext { typedef KInt (*LoadVirtualMachine_t)(KInt vmKind, const char* classPath, const char* libraryPath, const struct ForeignVMContext* foreignVM); typedef KNativePointer (*StartApplication_t)(const char* appUrl, const char* appParams); typedef KBoolean (*RunApplication_t)(const KInt arg0, const KInt arg1); -typedef void (*EmitEvent_t)(const KInt type, const KInt target, const KInt arg0, const KInt arg1); +typedef const char* (*EmitEvent_t)(const KInt type, const KInt target, const KInt arg0, const KInt arg1); typedef void (*RestartWith_t)(const char* page); void* getImpl(const char* path, const char* name) { @@ -310,12 +310,15 @@ KBoolean impl_RunApplication(const KInt arg0, const KInt arg1) { } KOALA_INTEROP_2(RunApplication, KBoolean, KInt, KInt) -void impl_EmitEvent(const KInt type, const KInt target, const KInt arg0, const KInt arg1) { +KStringPtr impl_EmitEvent(const KInt type, const KInt target, const KInt arg0, const KInt arg1) { static EmitEvent_t impl = nullptr; if (!impl) impl = reinterpret_cast(getImpl(nullptr, "EmitEvent")); - impl(type, target, arg0, arg1); + const char* out = impl(type, target, arg0, arg1); + auto size = std::string(out).size(); + KStringPtr result(out, size, true); + return result; } -KOALA_INTEROP_V4(EmitEvent, KInt, KInt, KInt, KInt) +KOALA_INTEROP_4(EmitEvent,KStringPtr, KInt, KInt, KInt, KInt) void impl_RestartWith(const KStringPtr& page) { static RestartWith_t impl = nullptr; diff --git a/interop/src/cpp/vmloader.cc b/interop/src/cpp/vmloader.cc index d409a8780..e7eda0d42 100644 --- a/interop/src/cpp/vmloader.cc +++ b/interop/src/cpp/vmloader.cc @@ -310,7 +310,7 @@ const AppInfo javaAppInfo = { "enter", "(IIJ)Z", "emitEvent", - "(IIII)V", + "(IIII)Ljava/lang/String;", }; #endif @@ -324,7 +324,7 @@ const AppInfo pandaAppInfo = { "enter", "IIJ:Z", "emitEvent", - "IIII:V", + "IIII:Lstd/core/String;", }; const AppInfo harnessAppInfo = { "@koalaui/ets-harness/src/EtsHarnessApplication/EtsHarnessApplication", @@ -335,7 +335,7 @@ const AppInfo harnessAppInfo = { "enter", "II:Z", "emitEvent", - "IIII:V", + "IIII:Lstd/core/String;", "restartWith", "Lstd/core/String;:V" }; @@ -509,15 +509,15 @@ extern "C" DLL_EXPORT KBoolean RunApplication(const KInt arg0, const KInt arg1) return 1; } -extern "C" DLL_EXPORT void EmitEvent(const KInt type, const KInt target, const KInt arg0, const KInt arg1) { +extern "C" DLL_EXPORT const char* EmitEvent(const KInt type, const KInt target, const KInt arg0, const KInt arg1) { #ifdef KOALA_JNI if (g_vmEntry.vmKind == JAVA_VM_KIND) { JNIEnv* jEnv = (JNIEnv*)(g_vmEntry.env); if (!g_vmEntry.emitEvent) { LOGE("Cannot find emitEvent method"); - return; + return "-1"; } - jEnv->CallVoidMethod( + auto rv = (jstring)jEnv->CallObjectMethod( (jobject)(g_vmEntry.app), (jmethodID)(g_vmEntry.emitEvent), (jint)type, @@ -529,6 +529,8 @@ extern "C" DLL_EXPORT void EmitEvent(const KInt type, const KInt target, const K jEnv->ExceptionDescribe(); jEnv->ExceptionClear(); } + const char *result = jEnv->GetStringUTFChars(rv, 0); + return result; } #endif #ifdef KOALA_ETS_NAPI @@ -536,9 +538,9 @@ extern "C" DLL_EXPORT void EmitEvent(const KInt type, const KInt target, const K EtsEnv* etsEnv = (EtsEnv*)(g_vmEntry.env); if (!g_vmEntry.emitEvent) { LOGE("Cannot find emitEvent method"); - return; + return "-1"; } - etsEnv->CallVoidMethod( + auto rv = (ets_string)etsEnv->CallObjectMethod( (ets_object)(g_vmEntry.app), (ets_method)(g_vmEntry.emitEvent), (ets_int)type, @@ -551,8 +553,11 @@ extern "C" DLL_EXPORT void EmitEvent(const KInt type, const KInt target, const K etsEnv->ErrorDescribe(); etsEnv->ErrorClear(); } + const char *result = etsEnv->GetStringUTFChars(rv, 0); + return result; } #endif + return "-1"; } extern "C" DLL_EXPORT void RestartWith(const char* page) { -- Gitee From 2605710849691dada76faa1cb2e8b31d75e4866f Mon Sep 17 00:00:00 2001 From: Nikolay Igotti Date: Tue, 18 Feb 2025 15:15:13 +0000 Subject: [PATCH 03/20] !3 Fix ANI * Fix Java and ANI typos --- interop/src/cpp/ani/convertors-ani.h | 10 +++++----- interop/src/cpp/common-interop.cc | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/interop/src/cpp/ani/convertors-ani.h b/interop/src/cpp/ani/convertors-ani.h index 6ca8e43d9..c6aaaf46c 100644 --- a/interop/src/cpp/ani/convertors-ani.h +++ b/interop/src/cpp/ani/convertors-ani.h @@ -1367,11 +1367,11 @@ void getKoalaEtsNapiCallbackDispatcher(ani_class* clazz, ani_method* method); #else #define KOALA_INTEROP_CALL_VOID(venv, id, length, args) -#define KOALA_INTEROP_CALL_INT(venv, id, length, args) -#define KOALA_INTEROP_CALL_VOID_INTS32(venv, id, argc, args) -#define KOALA_INTEROP_CALL_INT_INTS32(venv, id, argc, args) -#define KOALA_INTEROP_THROW(vmContext, object, ...) -#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) +#define KOALA_INTEROP_CALL_INT(venv, id, length, args) { return 0; } +#define KOALA_INTEROP_CALL_VOID_INTS32(venv, id, argc, args) { return; } +#define KOALA_INTEROP_CALL_INT_INTS32(venv, id, argc, args) { return 0; } +#define KOALA_INTEROP_THROW(vmContext, object, ...) { return __VA_ARGS__; } +#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) { return __VA_ARGS__; } #endif #endif // KOALA_ETS_NAPI diff --git a/interop/src/cpp/common-interop.cc b/interop/src/cpp/common-interop.cc index cd3146017..f7f5b74a6 100644 --- a/interop/src/cpp/common-interop.cc +++ b/interop/src/cpp/common-interop.cc @@ -310,7 +310,7 @@ KBoolean impl_RunApplication(const KInt arg0, const KInt arg1) { } KOALA_INTEROP_2(RunApplication, KBoolean, KInt, KInt) -KStringPtr impl_EmitEvent(const KInt type, const KInt target, const KInt arg0, const KInt arg1) { +KStringPtr impl_EmitEvent(KVMContext vmContext, KInt type, KInt target, KInt arg0, KInt arg1) { static EmitEvent_t impl = nullptr; if (!impl) impl = reinterpret_cast(getImpl(nullptr, "EmitEvent")); const char* out = impl(type, target, arg0, arg1); @@ -318,7 +318,7 @@ KStringPtr impl_EmitEvent(const KInt type, const KInt target, const KInt arg0, c KStringPtr result(out, size, true); return result; } -KOALA_INTEROP_4(EmitEvent,KStringPtr, KInt, KInt, KInt, KInt) +KOALA_INTEROP_CTX_4(EmitEvent, KStringPtr, KInt, KInt, KInt, KInt) void impl_RestartWith(const KStringPtr& page) { static RestartWith_t impl = nullptr; -- Gitee From c9d8a7335bf2d2367dfc4e3b724ae34efb4a0e73 Mon Sep 17 00:00:00 2001 From: Korobeinikov Evgeny Date: Tue, 18 Feb 2025 15:49:58 +0000 Subject: [PATCH 04/20] !4 release-1.5.5 * release-1.5.5 --- VERSION | 2 +- arkoala/arkui-common/package.json | 8 ++++---- arkoala/arkui/package.json | 8 ++++---- arkoala/ets-plugin/package.json | 2 +- incremental/build-common/package.json | 2 +- incremental/common/package.json | 4 ++-- incremental/compat/package.json | 2 +- incremental/compiler-plugin/package.json | 4 ++-- incremental/harness/package.json | 6 +++--- incremental/runtime/package.json | 8 ++++---- interop/package.json | 4 ++-- 11 files changed, 25 insertions(+), 25 deletions(-) diff --git a/VERSION b/VERSION index 63ebd3fe3..5ebba4f08 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.5.4 \ No newline at end of file +1.5.5 \ No newline at end of file diff --git a/arkoala/arkui-common/package.json b/arkoala/arkui-common/package.json index a47ed8a21..f67bcb9d5 100644 --- a/arkoala/arkui-common/package.json +++ b/arkoala/arkui-common/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/arkui-common", - "version": "1.5.4+devel", + "version": "1.5.5+devel", "description": "", "main": "build/lib/src/index.js", "exports": { @@ -53,9 +53,9 @@ }, "keywords": [], "dependencies": { - "@koalaui/common": "1.5.4+devel", - "@koalaui/compat": "1.5.4+devel", - "@koalaui/runtime": "1.5.4+devel", + "@koalaui/common": "1.5.5+devel", + "@koalaui/compat": "1.5.5+devel", + "@koalaui/runtime": "1.5.5+devel", "@koalaui/ets-tsc": "4.9.5-r4", "@koalaui/fast-arktsc": "next" } diff --git a/arkoala/arkui/package.json b/arkoala/arkui/package.json index 784d1062d..55c80acfa 100644 --- a/arkoala/arkui/package.json +++ b/arkoala/arkui/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/arkoala-arkui", - "version": "1.5.4+devel", + "version": "1.5.5+devel", "description": "", "main": "build/lib/src/index.js", "exports": { @@ -45,10 +45,10 @@ }, "keywords": [], "dependencies": { - "@koalaui/common": "1.5.4+devel", - "@koalaui/runtime": "1.5.4+devel", + "@koalaui/common": "1.5.5+devel", + "@koalaui/runtime": "1.5.5+devel", "@koalaui/arkoala": "1.4.1+devel", - "@koalaui/arkui-common": "1.5.4+devel", + "@koalaui/arkui-common": "1.5.5+devel", "@koalaui/ets-tsc": "4.9.5-r4", "media-query-parser": "^2.0.2", "commander": "10.0.1" diff --git a/arkoala/ets-plugin/package.json b/arkoala/ets-plugin/package.json index 229020c03..aa39e9813 100644 --- a/arkoala/ets-plugin/package.json +++ b/arkoala/ets-plugin/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/ets-plugin", - "version": "1.5.4+devel", + "version": "1.5.5+devel", "description": "", "main": "build/lib/src/index.js", "types": "build/lib/src/index.d.ts", diff --git a/incremental/build-common/package.json b/incremental/build-common/package.json index ae04b44d0..6c39c39b5 100644 --- a/incremental/build-common/package.json +++ b/incremental/build-common/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/build-common", - "version": "1.5.4+devel", + "version": "1.5.5+devel", "description": "", "files": [ "tsconfig.json" diff --git a/incremental/common/package.json b/incremental/common/package.json index fed0d1e32..5a948a90b 100644 --- a/incremental/common/package.json +++ b/incremental/common/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/common", - "version": "1.5.4+devel", + "version": "1.5.5+devel", "description": "", "main": "build/lib/src/index.js", "types": "./index.d.ts", @@ -43,7 +43,7 @@ }, "keywords": [], "dependencies": { - "@koalaui/compat": "1.5.4+devel" + "@koalaui/compat": "1.5.5+devel" }, "devDependencies": { "@ohos/hypium": "1.0.6", diff --git a/incremental/compat/package.json b/incremental/compat/package.json index 97ea035f5..81a3dea9b 100644 --- a/incremental/compat/package.json +++ b/incremental/compat/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/compat", - "version": "1.5.4+devel", + "version": "1.5.5+devel", "description": "", "main": "build/src/index.js", "types": "build/src/index.d.ts", diff --git a/incremental/compiler-plugin/package.json b/incremental/compiler-plugin/package.json index dccd66d64..a81d998ee 100644 --- a/incremental/compiler-plugin/package.json +++ b/incremental/compiler-plugin/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/compiler-plugin", - "version": "1.5.4+devel", + "version": "1.5.5+devel", "description": "", "main": "build/lib/src/index.js", "types": "build/lib/src/index.d.ts", @@ -10,7 +10,7 @@ ], "keywords": [], "dependencies": { - "@koalaui/common": "1.5.4+devel" + "@koalaui/common": "1.5.5+devel" }, "devDependencies": { "@types/chai": "^4.3.1", diff --git a/incremental/harness/package.json b/incremental/harness/package.json index fe784704c..399333031 100644 --- a/incremental/harness/package.json +++ b/incremental/harness/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/harness", - "version": "1.5.4+devel", + "version": "1.5.5+devel", "description": "A harness library compatible with OHOS and ArkTS", "main": "build/src/index.js", "types": "build/src/index.d.ts", @@ -35,8 +35,8 @@ }, "keywords": [], "dependencies": { - "@koalaui/common": "1.5.4+devel", - "@koalaui/compat": "1.5.4+devel" + "@koalaui/common": "1.5.5+devel", + "@koalaui/compat": "1.5.5+devel" }, "devDependencies": { "@ohos/hypium": "1.0.6", diff --git a/incremental/runtime/package.json b/incremental/runtime/package.json index aa8066c4c..a0f665056 100644 --- a/incremental/runtime/package.json +++ b/incremental/runtime/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/runtime", - "version": "1.5.4+devel", + "version": "1.5.5+devel", "description": "", "main": "./build/lib/src/index.js", "types": "./build/lib/src/index.d.ts", @@ -41,9 +41,9 @@ }, "keywords": [], "dependencies": { - "@koalaui/common": "1.5.4+devel", - "@koalaui/compat": "1.5.4+devel", - "@koalaui/harness": "1.5.4+devel" + "@koalaui/common": "1.5.5+devel", + "@koalaui/compat": "1.5.5+devel", + "@koalaui/harness": "1.5.5+devel" }, "devDependencies": { "@types/chai": "^4.3.1", diff --git a/interop/package.json b/interop/package.json index cc1f72473..7f0af0df8 100644 --- a/interop/package.json +++ b/interop/package.json @@ -1,6 +1,6 @@ { "name": "@koalaui/interop", - "version": "1.5.4+devel", + "version": "1.5.5+devel", "description": "", "workspaces": [ "../incremental/build-common", @@ -57,7 +57,7 @@ "keywords": [], "dependencies": { "@types/node": "^18.0.0", - "@koalaui/common": "1.5.4+devel" + "@koalaui/common": "1.5.5+devel" }, "devDependencies": { "@ohos/hypium": "1.0.6", -- Gitee From 9ba76b51b1d6186df14906625e9afee6fd870fd9 Mon Sep 17 00:00:00 2001 From: Alexander Gorshenev Date: Tue, 18 Feb 2025 22:24:23 +0000 Subject: [PATCH 05/20] !6 After Checker: Builder Lambda Transformation + Struct Transformation The commit author is shijiakai2@huawei.com --- arkoala-arkts/arkui/src/sts/arkui.sts | 2 +- arkoala-arkts/libarkts/native/src/bridges.cc | 9 + .../libarkts/plugins/input/library.sts | 2 + arkoala-arkts/libarkts/plugins/input/main.sts | 2 +- .../libarkts/plugins/src/arkts-utils.ts | 28 +++ .../plugins/src/builder-lambda-transformer.ts | 185 ++++++++++++------ .../plugins/src/checked-stage-plugin.ts | 10 +- .../plugins/src/component-transformer.ts | 5 +- .../plugins/src/struct-transformer.ts | 178 +++++++++++++++++ arkoala-arkts/libarkts/plugins/tsconfig.json | 2 + .../libarkts/src/Es2pandaNativeModule.ts | 40 ++++ .../src/arkts-api/factory/nodeFactory.ts | 21 ++ .../src/arkts-api/factory/nodeTests.ts | 21 ++ arkoala-arkts/libarkts/src/arkts-api/types.ts | 148 +++++++++++++- .../src/arkts-api/utilities/public.ts | 3 +- .../libarkts/src/arkts-api/visitor.ts | 47 +++++ arkoala-arkts/trivial/user/src/sts/hello.sts | 2 +- 17 files changed, 630 insertions(+), 75 deletions(-) create mode 100644 arkoala-arkts/libarkts/plugins/src/arkts-utils.ts create mode 100644 arkoala-arkts/libarkts/plugins/src/struct-transformer.ts diff --git a/arkoala-arkts/arkui/src/sts/arkui.sts b/arkoala-arkts/arkui/src/sts/arkui.sts index 69aa97ece..2998691be 100644 --- a/arkoala-arkts/arkui/src/sts/arkui.sts +++ b/arkoala-arkts/arkui/src/sts/arkui.sts @@ -31,7 +31,7 @@ export abstract class StructBase { if (builder !== undefined) builder(instance) instance.build() } - abstract build() + build() {} } export enum Color { diff --git a/arkoala-arkts/libarkts/native/src/bridges.cc b/arkoala-arkts/libarkts/native/src/bridges.cc index 4250b7908..1ee0b055d 100644 --- a/arkoala-arkts/libarkts/native/src/bridges.cc +++ b/arkoala-arkts/libarkts/native/src/bridges.cc @@ -50,6 +50,15 @@ KNativePointer impl_AnnotationAllowedAnnotations(KNativePointer contextPtr, KNat } KOALA_INTEROP_3(AnnotationAllowedAnnotations, KNativePointer, KNativePointer, KNativePointer, KNativePointer) +KNativePointer impl_AnnotationAllowedAnnotationsConst(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + std::size_t params_len = 0; + auto annotations = GetImpl()->AnnotationAllowedAnnotationsConst(context, node, ¶ms_len); + return new std::vector(annotations, annotations + params_len); +} +KOALA_INTEROP_3(AnnotationAllowedAnnotationsConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + KNativePointer impl_AstNodeVariableConst(KNativePointer contextPtr, KNativePointer nodePtr) { auto context = reinterpret_cast(contextPtr); auto node = reinterpret_cast(nodePtr); diff --git a/arkoala-arkts/libarkts/plugins/input/library.sts b/arkoala-arkts/libarkts/plugins/input/library.sts index 9d7a1f0e1..84aa6aac1 100644 --- a/arkoala-arkts/libarkts/plugins/input/library.sts +++ b/arkoala-arkts/libarkts/plugins/input/library.sts @@ -1 +1,3 @@ export @interface Component {} + +export @interface memo {} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/plugins/input/main.sts b/arkoala-arkts/libarkts/plugins/input/main.sts index bff61711a..0a64cf195 100644 --- a/arkoala-arkts/libarkts/plugins/input/main.sts +++ b/arkoala-arkts/libarkts/plugins/input/main.sts @@ -1,4 +1,4 @@ -import { Component } from "./library" +import { Component, memo } from "./library" @interface BuilderLambda { value: string diff --git a/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts b/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts new file mode 100644 index 000000000..549790fd7 --- /dev/null +++ b/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts @@ -0,0 +1,28 @@ +import * as arkts from "@koalaui/libarkts" + +export function annotation(name: string): arkts.AnnotationUsageIr { + const ident: arkts.Identifier = arkts.factory.createIdentifier(name).setAnnotationUsage(); + const annotation: arkts.AnnotationUsageIr = arkts.factory.createAnnotationUsageIr(ident); + + annotation.modifiers = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_ANNOTATION_USAGE; + ident.parent = annotation; + + return annotation; +} + +export function mangle(value: string): string { + return `__${value}`; +} + +export function backingField(originalName: string): string { + return mangle(`backing_${originalName}`); +} + +export function filterDefined(value: (T | undefined)[]): T[] { + return value.filter((it: T | undefined): it is T => it != undefined); +} + +export function collect(...value: (ReadonlyArray | T | undefined)[]): T[] { + const empty: (T | undefined)[] = [] + return filterDefined(empty.concat(...value)) +} diff --git a/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts b/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts index 6be93bccd..e65728dba 100644 --- a/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts +++ b/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts @@ -31,7 +31,7 @@ function getLambdaArg(lambdaBody: arkts.AstNode, typeName: string|undefined): ar arkts.factory.createIdentifier( builderLambdaInstanceName, // TODO: it should be the return type of the function annotated with the @BuilderLambda - typeName ? arkts.factory.createTypeReference( + typeName ? arkts.factory.createTypeReferenceFromId( arkts.factory.createIdentifier( typeName ) @@ -45,7 +45,7 @@ function getLambdaArg(lambdaBody: arkts.AstNode, typeName: string|undefined): ar param ], // TODO: it should be the return type of the function annotated with the @BuilderLambda - typeName ? arkts.factory.createTypeReference( + typeName ? arkts.factory.createTypeReferenceFromId( arkts.factory.createIdentifier( typeName ) @@ -190,75 +190,142 @@ function builderLambdaReplace(leaf: arkts.CallExpression): arkts.Identifier|arkt return undefined } -export class BuilderLambdaTransformer extends AbstractVisitor { - visitor(beforeChildren: arkts.AstNode): arkts.AstNode { - const node = this.visitEachChild(beforeChildren) +function builderLambdaBodyRewrite(node: arkts.AstNode): arkts.AstNode { + if (!arkts.isArrowFunctionExpression(node)) return node; - if (!arkts.isCallExpression(node)) { - return node - } + const scriptFunc: arkts.ScriptFunction = node.scriptFunction; + if (!scriptFunc || !scriptFunc.body) return node; - if (true - && arkts.isMemberExpression(node.parent) - && arkts.isIdentifier(node.parent.property) - && arkts.isCallExpression(node.parent.parent) + const body: arkts.BlockStatement = scriptFunc.body; + const statements: arkts.AstNode[] = body.statements.map((statement: arkts.AstNode) => { + if ( + arkts.isExpressionStatement(statement) + && statement.expression + && arkts.isCallExpression(statement.expression) ) { - return node + return transformBuilderLambda(statement.expression); } + return statement; + }); + const updateBody = arkts.factory.updateBlock(body, statements); + + const signature: arkts.FunctionSignature = arkts.FunctionSignature.create(undefined, [], undefined); + const updateFunc: arkts.ScriptFunction = arkts.factory.updateScriptFunction( + scriptFunc, + updateBody, + signature, // TODO: Cannot get signature from original ScriptFunction node + scriptFunc.scriptFunctionFlags, + scriptFunc.modifiers, + false, + undefined + ); - let instanceCalls: arkts.CallExpression[] = [] - let leaf: arkts.CallExpression = node + return arkts.factory.updateArrowFunction(node, updateFunc); +} - while (true - && arkts.isMemberExpression(leaf.expression) - && arkts.isIdentifier(leaf.expression.property) - && arkts.isCallExpression(leaf.expression.object) - ) { - instanceCalls.push( - arkts.factory.createCallExpression( - leaf.expression.property, - undefined, - leaf.arguments - ) - ) - leaf = leaf.expression.object - } +function transformBuilderLambda(node: arkts.CallExpression): arkts.AstNode { + let instanceCalls: arkts.CallExpression[] = [] + let leaf: arkts.CallExpression = node - const replace = builderLambdaReplace(leaf) - if (replace === undefined) { - return node - } - - instanceCalls = instanceCalls.reverse() - let lambdaBody: arkts.Identifier | arkts.CallExpression = arkts.factory.createIdentifier(builderLambdaInstanceName) - instanceCalls.forEach((call)=> { - if (!arkts.isIdentifier(call.expression)) { - throw new Error('call expression should be identifier') - } - lambdaBody = arkts.factory.createCallExpression( - arkts.factory.createMemberExpression( - lambdaBody, - call.expression, - arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, - false, - false - ), + while (true + && arkts.isMemberExpression(leaf.expression) + && arkts.isIdentifier(leaf.expression.property) + && arkts.isCallExpression(leaf.expression.object) + ) { + instanceCalls.push( + arkts.factory.createCallExpression( + leaf.expression.property, undefined, - call.arguments + leaf.arguments ) - }) + ) + leaf = leaf.expression.object + } - const typeName = builderLambdaTypeName(leaf) - const lambdaArg = getLambdaArg(lambdaBody, typeName) + const replace = builderLambdaReplace(leaf) + if (replace === undefined) { + return node + } - return arkts.factory.updateCallExpression( - node, - replace, + instanceCalls = instanceCalls.reverse() + let lambdaBody: arkts.Identifier | arkts.CallExpression = arkts.factory.createIdentifier(builderLambdaInstanceName) + instanceCalls.forEach((call)=> { + if (!arkts.isIdentifier(call.expression)) { + throw new Error('call expression should be identifier') + } + lambdaBody = arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + lambdaBody, + call.expression, + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), undefined, - [ - lambdaArg, - ...leaf.arguments - ] + call.arguments ) + }) + + const typeName = builderLambdaTypeName(leaf) + const lambdaArg = getLambdaArg(lambdaBody, typeName) + + let args: arkts.AstNode[] = leaf.arguments.length < 3 + ? leaf.arguments as arkts.AstNode[] + : [ + ...leaf.arguments.slice(0, 2), + builderLambdaBodyRewrite(leaf.arguments.at(2)!), + ...leaf.arguments.slice(3) // Currently, this is never reached since the maximum length of arguments is 3 + ]; + + return arkts.factory.updateCallExpression( + node, + replace, + undefined, + [ + lambdaArg, + ...args + ] + ) +} + +function isBuilderLambda(node: arkts.AstNode): boolean { + const builderLambda: arkts.AstNode | undefined = _getDeclForBuilderLambda(node); + return !!builderLambda; +} + +// TODO: temporary solution for get declaration of a builder lambda +function _getDeclForBuilderLambda(node: arkts.AstNode): arkts.AstNode | undefined { + if (!node || !arkts.isCallExpression(node)) return undefined; + + if (node.expression && arkts.isMemberExpression(node.expression)) { + const _node: arkts.MemberExpression = node.expression; + if (_node.property && arkts.isIdentifier(_node.property) && _node.property.name === "$_instantiate") { + return node; + } + if (_node.object && arkts.isCallExpression(_node.object)) { + return _getDeclForBuilderLambda(_node.object); + } + } + + return undefined; +} + +export class BuilderLambdaTransformer extends AbstractVisitor { + visitEachChild(node: arkts.AstNode): arkts.AstNode { + if (arkts.isCallExpression(node) && isBuilderLambda(node)) { + return node; + } + + return super.visitEachChild(node); + } + + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren) + + if (arkts.isCallExpression(node) && isBuilderLambda(node)) { + return transformBuilderLambda(node); + } + + return node; } } diff --git a/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts b/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts index ec0578ffd..c7b9f1463 100644 --- a/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts +++ b/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts @@ -2,6 +2,7 @@ import * as ts from "@koalaui/libarkts" import { PrintVisitor } from './print-visitor' import { BuilderLambdaTransformer } from './builder-lambda-transformer' import { ComponentTransformer } from './component-transformer' +import { StructTransformer } from './struct-transformer' export interface TransformerOptions { trace?: boolean, @@ -11,6 +12,13 @@ export default function exampleTransformer( userPluginOptions?: TransformerOptions ) { return (node: ts.EtsScript) => { - return new BuilderLambdaTransformer().visitor(node) + const builderLambdaTransformer = new BuilderLambdaTransformer(); + const structTransformer = new StructTransformer(); + + let script: ts.EtsScript = node; + script = builderLambdaTransformer.visitor(script) as ts.EtsScript; + script = structTransformer.visitor(script) as ts.EtsScript; + + return script; } } diff --git a/arkoala-arkts/libarkts/plugins/src/component-transformer.ts b/arkoala-arkts/libarkts/plugins/src/component-transformer.ts index eb9dea774..10b2a6d0e 100644 --- a/arkoala-arkts/libarkts/plugins/src/component-transformer.ts +++ b/arkoala-arkts/libarkts/plugins/src/component-transformer.ts @@ -71,6 +71,7 @@ export class ComponentTransformer extends AbstractVisitor { processComponent(node: arkts.ClassDeclaration | arkts.StructDeclaration): arkts.ClassDeclaration { const className = node.definition.name.name + arkts.GlobalInfo.getInfoInstance().add(className); this.context.componentNames.push(className) const newDefinition = arkts.factory.updateClassDefinition( @@ -85,10 +86,10 @@ export class ComponentTransformer extends AbstractVisitor { arkts.factory.createIdentifier('StructBase'), arkts.factory.createTSTypeParameterInstantiation( [ - arkts.factory.createTypeReference( + arkts.factory.createTypeReferenceFromId( arkts.factory.createIdentifier(className) ), - arkts.factory.createTypeReference( + arkts.factory.createTypeReferenceFromId( arkts.factory.createIdentifier(`__Options_${className}`) ), ] diff --git a/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts b/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts new file mode 100644 index 000000000..0959ea80a --- /dev/null +++ b/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts @@ -0,0 +1,178 @@ +import * as arkts from "@koalaui/libarkts" +import { AbstractVisitor } from "./AbstractVisitor"; +import { annotation } from "./arkts-utils"; + +function isCustomComponentClass(node: arkts.ClassDeclaration): boolean { + const structCollection: Set = arkts.GlobalInfo.getInfoInstance().getStructCollection(); + if (structCollection.has(node.definition.name.name)) { + return true; + } + return false; +} + +function isKnownMethodDefinition(method: arkts.MethodDefinition, name: string): boolean { + if (!method || !arkts.isMethodDefinition(method)) return false; + + // For now, we only considered matched method name. + const isNameMatched: boolean = method.name?.name === name; + return isNameMatched; +} + +function createStyleArgInBuildMethod(className: string): arkts.ETSParameterExpression { + const styleLambdaParams: arkts.ETSParameterExpression = arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier( + 'instance', + arkts.factory.createIdentifier(className), + ), + undefined + ); + + const styleLambda: arkts.ETSFunctionType = arkts.factory.createFunctionType( + arkts.FunctionSignature.create( + undefined, + [ + styleLambdaParams + ], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID) + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW + ); + + const optionalStyleLambda: arkts.ETSUnionType = arkts.factory.createUnionType([ + styleLambda, + arkts.factory.createUndefinedLiteral() + ]); + + const styleParam: arkts.Identifier = arkts.factory.createIdentifier( + 'style', + optionalStyleLambda + ); + + const param = arkts.factory.createParameterDeclaration(styleParam, undefined); + param.annotations = [annotation("memo")]; + + return param; +} + +function createContentArgInBuildMethod(): arkts.ETSParameterExpression { + const contentLambda: arkts.ETSFunctionType = arkts.factory.createFunctionType( + arkts.FunctionSignature.create( + undefined, + [], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID) + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW + ); + + const contentParam: arkts.Identifier = arkts.factory.createIdentifier( + 'content', + contentLambda + ); + + const param = arkts.factory.createParameterDeclaration(contentParam, undefined); + param.annotations = [annotation("memo")]; + + return param; +} + +function createInitializerArgInBuildMethod(className: string): arkts.ETSParameterExpression { + return arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier( + 'initializers', + arkts.factory.createTypeReferenceFromId( + arkts.factory.createIdentifier(`__Options_${className}`) + ) + ).setOptional(true), + undefined + ); +} + +function prepareArgsInBuildMethod(className: string): arkts.ETSParameterExpression[] { + return [ + createStyleArgInBuildMethod(className), + createContentArgInBuildMethod(), + createInitializerArgInBuildMethod(className) + ]; +} + +function transformBuildMethod( + method: arkts.MethodDefinition, + className: string +): arkts.MethodDefinition { + const updateKey: arkts.Identifier = arkts.factory.createIdentifier( + '_build' + ); + + const scriptFunction: arkts.ScriptFunction = method.scriptFunction; + + const params: arkts.ETSParameterExpression[] = prepareArgsInBuildMethod(className); + + const signature: arkts.FunctionSignature = arkts.FunctionSignature.create( + undefined, + params, + undefined + ); + const updateScriptFunction = arkts.factory.createScriptFunction( + scriptFunction.body, + signature, + scriptFunction.scriptFunctionFlags, + scriptFunction.modifiers, + false, + undefined + ); + + updateScriptFunction.annotations = [annotation("memo")]; + + // TODO: Currently, just return method itself. Remove this once createMethodDefinition is ready. + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + updateKey, + arkts.factory.createFunctionExpression(updateScriptFunction), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PROTECTED, + false + ); +} + +function tranformClassMembers(node: arkts.ClassDeclaration): arkts.ClassDeclaration { + const definition: arkts.ClassDefinition = node.definition; + const className: string = node.definition.name.name; + + const updateMembers: arkts.AstNode[] = definition.members.map((member: arkts.AstNode) => { + if (arkts.isMethodDefinition(member) && isKnownMethodDefinition(member, "constructor")) { + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_CONSTRUCTOR, + member.name, + arkts.factory.createFunctionExpression(member.scriptFunction), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR, + false + ); + } + if (arkts.isMethodDefinition(member) && isKnownMethodDefinition(member, "build")) { + return transformBuildMethod(member, className); + } + + return member; + }); + + const updateClassDef: arkts.ClassDefinition = arkts.factory.updateClassDefinition( + definition, + definition.name, + updateMembers, + definition.modifiers, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + definition.typeParamsDecl, + definition.superClass + ); + + return arkts.factory.updateClassDeclaration(node, updateClassDef); +} + +export class StructTransformer extends AbstractVisitor { + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren); + if (arkts.isClassDeclaration(node) && isCustomComponentClass(node)) { + return tranformClassMembers(node); + } + return node; + } +} diff --git a/arkoala-arkts/libarkts/plugins/tsconfig.json b/arkoala-arkts/libarkts/plugins/tsconfig.json index d0ce6f222..a460c9048 100644 --- a/arkoala-arkts/libarkts/plugins/tsconfig.json +++ b/arkoala-arkts/libarkts/plugins/tsconfig.json @@ -14,5 +14,7 @@ "./src/print-visitor.ts", "./src/builder-lambda-transformer.ts", "./src/component-transformer.ts", + "./src/struct-transformer.ts", + "./src/arkts-utils.ts", ] } diff --git a/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts b/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts index e62809f69..f3fe48606 100644 --- a/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts +++ b/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts @@ -53,6 +53,9 @@ export class Es2pandaNativeModule { _AnnotationAllowedAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { throw new Error("Not implemented") } + _AnnotationAllowedAnnotationsConst(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error("Not implemented") + } _AstNodeRebind(context: KPtr, node: KPtr): void { throw new Error("Not implemented") } @@ -164,6 +167,9 @@ export class Es2pandaNativeModule { _ScriptFunctionBody(context: KPtr, node: KPtr): KPtr { throw new Error("Not implemented") } + _ScriptFunctionAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error("Not implemented") + } _ScriptFunctionSetIdent(context: KPtr, ast: KPtr, id: KPtr): KPtr { throw new Error("Not implemented") } @@ -176,6 +182,9 @@ export class Es2pandaNativeModule { _ScriptFunctionSetScope(context: KPtr, ast: KPtr, scope: KPtr): KPtr { throw new Error("Not implemented") } + _ScriptFunctionSetAnnotations(context: KPtr, ast: KPtr, annotations: KPtrArray, annotationsLen: KInt): KPtr { + throw new Error("Not implemented") + } _ScriptFunctionDeclareConst(context: KPtr, node: KPtr): KBoolean { throw new Error("Not implemented") } @@ -191,6 +200,12 @@ export class Es2pandaNativeModule { _ScriptFunctionAddFlag(context: KPtr, node: KPtr, flags: KInt): void { throw new Error("Not implemented") } + _ClassPropertyAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error("Not implemented") + } + _ClassPropertySetAnnotations(context: KPtr, ast: KPtr, annotations: KPtrArray, annotationsLen: KInt): KPtr { + throw new Error("Not implemented") + } _UpdateBlockStatement(context: KPtr, original: KPtr, statementList: KPtrArray, statementListLen: KInt): KPtr { throw new Error("Not implemented") } @@ -392,6 +407,12 @@ export class Es2pandaNativeModule { _ETSParameterExpressionIdent(context: KPtr, node: KPtr): KPtr { throw new Error("Not implemented") } + _ETSParameterExpressionAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error("Not implemented") + } + _ETSParameterExpressionSetAnnotations(context: KPtr, ast: KPtr, annotations: KPtrArray, annotationsLen: KInt): KPtr { + throw new Error("Not implemented") + } _CreateTSTypeParameterDeclaration(context: KPtr, params: KPtrArray, paramsLen: KInt, requiredParams: KInt): KPtr { throw new Error("Not implemented") } @@ -551,6 +572,25 @@ export class Es2pandaNativeModule { _DeclarationFromIdentifier(context: KPtr, identifier: KPtr): KPtr { throw new Error("Not implemented") } + _IsTSInterfaceDeclaration(ast: KNativePointer): KBoolean { + throw new Error("Not implemented") + } + + _IsAnnotationDeclaration(ast: KNativePointer): KBoolean { + throw new Error("Not implemented") + } + + _IsAnnotationUsage(ast: KNativePointer): KBoolean { + throw new Error("Not implemented") + } + + _IsClassProperty(ast: KNativePointer): KBoolean { + throw new Error("Not implemented") + } + + _CreateAnnotationUsageIr(context: KPtr, ast: KPtr): KPtr { + throw new Error("Not implemented") + } } export function initEs2panda(): Es2pandaNativeModule { diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts index ff36ada6f..778cb68cd 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts @@ -15,12 +15,14 @@ import { updateNodeByNode } from "../utilities/private" import { + AnnotationUsageIr, ArrowFunctionExpression, BinaryExpression, BlockStatement, CallExpression, ClassDeclaration, ClassDefinition, + ClassProperty, ETSFunctionType, EtsImportDeclaration, ETSParameterExpression, @@ -46,6 +48,7 @@ import { TSTypeParameter, TSTypeParameterDeclaration, TSTypeParameterInstantiation, + UndefinedLiteral, VariableDeclaration, VariableDeclarator } from "../types" @@ -238,6 +241,12 @@ export const factory = { get updateClassDefinition() { return compose(ClassDefinition.create) }, + get createClassProperty() { + return ClassProperty.create + }, + get updateClassProperty() { + return compose(ClassProperty.create) + }, get createFunctionType() { return ETSFunctionType.create }, @@ -274,4 +283,16 @@ export const factory = { get updateInterfaceDeclaration() { return compose(TSInterfaceDeclaration.create) }, + get createUndefinedLiteral() { + return UndefinedLiteral.create + }, + get updateUndefinedLiteral() { + return compose(UndefinedLiteral.create) + }, + get createAnnotationUsageIr() { + return AnnotationUsageIr.create + }, + get updateAnnotationUsageIr() { + return compose(UndefinedLiteral.create) + }, } diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts index 07750fe2f..70089c669 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts @@ -1,4 +1,7 @@ +import { global } from "../static/global" import { + AnnotationDeclaration, + AnnotationUsageIr, ArrowFunctionExpression, BlockStatement, CallExpression, @@ -14,11 +17,29 @@ import { ScriptFunction, StringLiteral, StructDeclaration, + TSInterfaceDeclaration, VariableDeclaration, + ClassProperty } from "../types" import { MemberExpression } from "../to-be-generated/MemberExpression" import { AstNode } from "../peers/AstNode" +export function isClassProperty(node: AstNode): node is ClassProperty { + return global.es2panda._IsClassProperty(node.peer); +} + +export function isAnnotationUsage(node: AstNode): node is AnnotationUsageIr { + return global.es2panda._IsAnnotationUsage(node.peer); +} + +export function isAnnotationDeclaration(node: AstNode): node is AnnotationDeclaration { + return global.es2panda._IsAnnotationDeclaration(node.peer); +} + +export function isTSInterfaceDeclaration(node: AstNode): node is TSInterfaceDeclaration { + return global.es2panda._IsTSInterfaceDeclaration(node.peer); +} + export function isIdentifier(node: AstNode): node is Identifier { return node instanceof Identifier } diff --git a/arkoala-arkts/libarkts/src/arkts-api/types.ts b/arkoala-arkts/libarkts/src/arkts-api/types.ts index 10b6b5197..a3168d27b 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/types.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/types.ts @@ -19,6 +19,7 @@ import { KBoolean, KInt, KNativePointer as KPtr, nullptr } from "@koalaui/intero import { Es2pandaClassDefinitionModifiers, Es2pandaContextState, + Es2pandaExpressionParseFlags, Es2pandaIdentifierFlags, Es2pandaImportKinds, Es2pandaMethodDefinitionKind, @@ -298,6 +299,7 @@ export class ETSTypeReferencePart extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART) super(peer) + this.typeName = unpackNonNullableNode(global.generatedEs2panda._ETSTypeReferencePartName(global.context, this.peer)); } // TODO: support type params and prev @@ -317,7 +319,7 @@ export class ETSTypeReferencePart extends AstNode { ) } - // readonly typeName: Identifier + readonly typeName: Identifier } export class TSUnionType extends AstNode { @@ -396,9 +398,18 @@ export class Identifier extends AstNode { static create( name: string, - typeAnnotation?: AstNode + typeAnnotation?: AstNode, + isAnnotation?: boolean ): Identifier { - if (typeAnnotation === undefined) { + if (isAnnotation) { + return new Identifier( + global.es2panda._ETSParserCreateExpression( + global.context, + passString(name), + Es2pandaExpressionParseFlags.EXPRESSION_PARSE_FLAGS_ACCEPT_COMMA + ) + ) + } else if (typeAnnotation === undefined) { return new Identifier( global.es2panda._CreateIdentifier1(global.context, passString(name)) ) @@ -409,6 +420,16 @@ export class Identifier extends AstNode { } } + setOptional(optional: boolean): Identifier { + global.generatedEs2panda._IdentifierSetOptional(global.context, this.peer, optional) + return this + } + + setAnnotationUsage(): Identifier { + global.generatedEs2panda._IdentifierSetAnnotationUsage(global.context, this.peer); + return this; + } + protected override dumpMessage(): string { return ` ` } @@ -554,6 +575,12 @@ export class ScriptFunction extends AstNode { return new ScriptFunction(peer) } + setIdent(id: Identifier): ScriptFunction { + assertValidPeer(id.peer, Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER); + global.generatedEs2panda._ScriptFunctionSetIdent(global.context, this.peer, id.peer); + return this; + } + protected override dumpMessage(): string { const scriptFunctionFlags = global.generatedEs2panda._ScriptFunctionFlagsConst(global.context, this.peer) return ` ` @@ -596,6 +623,23 @@ export class ScriptFunction extends AstNode { // readonly signature: FunctionSignature readonly scriptFunctionFlags: KInt readonly ident?: Identifier + + get annotations(): AnnotationUsageIr[] { + return unpackNodeArray(global.es2panda._ScriptFunctionAnnotations( + global.context, + this.peer, + nullptr + )) as AnnotationUsageIr[]; + } + + set annotations(newAnnotations: AnnotationUsageIr[]) { + global.es2panda._ScriptFunctionSetAnnotations( + global.context, + this.peer, + passNodeArray(newAnnotations), + newAnnotations.length + ); + } } export class ArrowFunctionExpression extends AstNode { @@ -721,6 +765,23 @@ export class ETSParameterExpression extends AstNode { ) ) } + + get annotations(): AnnotationUsageIr[] { + return unpackNodeArray(global.es2panda._ETSParameterExpressionAnnotations( + global.context, + this.peer, + nullptr + )) as AnnotationUsageIr[]; + } + + set annotations(newAnnotations: AnnotationUsageIr[]) { + global.es2panda._ETSParameterExpressionSetAnnotations( + global.context, + this.peer, + passNodeArray(newAnnotations), + newAnnotations.length + ); + } } export class TSTypeParameterDeclaration extends AstNode { @@ -933,10 +994,20 @@ export class ClassStaticBlock extends AstNode { } export class MethodDefinition extends AstNode { - constructor(peer: KPtr) { + constructor(peer: KPtr, key?: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION) super(peer) + this.kind = global.generatedEs2panda._MethodDefinitionKindConst(global.context, this.peer); this.scriptFunction = unpackNonNullableNode(global.generatedEs2panda._MethodDefinitionFunction(global.context, this.peer)) + assertValidPeer(this.scriptFunction.peer, Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION); + + // Somehow the scriptFunction cannot attach method's key to its ident after checker + if (key) { + assertValidPeer(key, Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER); + const _name = unpackNonNullableNode(key); + this.scriptFunction = this.scriptFunction.setIdent(_name as Identifier); + } + this.name = unpackNonNullableNode(global.generatedEs2panda._ScriptFunctionId(global.context, this.scriptFunction.peer)) this.kind = global.generatedEs2panda._MethodDefinitionKindConst(global.context, this.peer) } @@ -956,13 +1027,19 @@ export class MethodDefinition extends AstNode { passNode(value), modifiers, isComputed - ) + ), + key.peer ) } + // TODO: does not work + isConstructor(): boolean { + return global.generatedEs2panda._MethodDefinitionIsConstructorConst(global.context, this.peer); + } + + readonly kind: Es2pandaMethodDefinitionKind; readonly scriptFunction: ScriptFunction readonly name: Identifier - readonly kind: Es2pandaMethodDefinitionKind } export class ClassElement extends AstNode { @@ -980,6 +1057,7 @@ export class ClassProperty extends ClassElement { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY) super(peer) + this.typeAnnotation = unpackNonNullableNode(global.generatedEs2panda._ClassPropertyTypeAnnotationConst(global.context, this.peer)); } static create( @@ -1000,6 +1078,25 @@ export class ClassProperty extends ClassElement { ) ) } + + get annotations(): AnnotationUsageIr[] { + return unpackNodeArray(global.es2panda._ScriptFunctionAnnotations( + global.context, + this.peer, + nullptr + )) as AnnotationUsageIr[]; + } + + set annotations(newAnnotations: AnnotationUsageIr[]) { + global.es2panda._ScriptFunctionSetAnnotations( + global.context, + this.peer, + passNodeArray(newAnnotations), + newAnnotations.length + ); + } + + readonly typeAnnotation: ETSTypeReference; } export class VariableDeclaration extends AstNode { @@ -1067,6 +1164,7 @@ export class SuperExpression extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION) super(peer) + this.id = unpackNonNullableNode(global.generatedEs2panda._TSInterfaceDeclarationId(global.context, this.peer)); } static create( @@ -1077,6 +1175,8 @@ export class SuperExpression extends AstNode { ) ) } + + readonly id?: Identifier; } export class ImportSource extends ArktsObject { @@ -1165,8 +1265,16 @@ export class AnnotationUsageIr extends AstNode { this.properties = unpackNodeArray(global.generatedEs2panda._AnnotationUsageIrPropertiesConst(global.context, this.peer)) } - // TODO: - // static create + static create( + annoIdent: AstNode + ): AnnotationUsageIr { + return new AnnotationUsageIr( + global.es2panda._CreateAnnotationUsageIr( + global.context, + passNode(annoIdent) + ) + ); + } readonly expr: AstNode readonly properties: readonly ClassProperty[] @@ -1225,4 +1333,28 @@ export class UndefinedLiteral extends AstNode { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL) super(peer) } + + static create(): UndefinedLiteral { + return new UndefinedLiteral( + global.generatedEs2panda._CreateUndefinedLiteral(global.context) + ) + } +} + +export class AnnotationDeclaration extends AstNode { + constructor(peer: KPtr) { + assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION); + super(peer) + } + + static create( + expr: AstNode + ): AnnotationDeclaration { + return new AnnotationDeclaration ( + global.generatedEs2panda._CreateAnnotationDeclaration( + global.context, + passNode(expr) + ) + ) + } } diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts index dbea933f3..7231cc0f5 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts @@ -16,12 +16,11 @@ import { global } from "../static/global" import { throwError } from "../../utils" import { KNativePointer, nullptr, withStringResult } from "@koalaui/interop" -import { AnnotationUsageIr, MethodDefinition } from "../types" import { passNode, unpackNodeArray, unpackNonNullableNode } from "./private" import { isClassDefinition, isFunctionDeclaration, isScriptFunction } from "../factory/nodeTests" import { Es2pandaContextState } from "../../generated/Es2pandaEnums" import { AstNode } from "../peers/AstNode" -import { Identifier } from "../types" +import { AnnotationUsageIr } from "../types" export function proceedToState(state: Es2pandaContextState): void { if (state <= global.es2panda._ContextState(global.context)) { diff --git a/arkoala-arkts/libarkts/src/arkts-api/visitor.ts b/arkoala-arkts/libarkts/src/arkts-api/visitor.ts index f114ccef7..622448e38 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/visitor.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/visitor.ts @@ -38,6 +38,53 @@ import { MemberExpression } from "./to-be-generated/MemberExpression" type Visitor = (node: AstNode) => AstNode +export interface DoubleNode { + originNode: AstNode; + translatedNode: AstNode; +} + +export class StructInfo { + stateVariables: Set = new Set(); +} + +export class GlobalInfo { + private _structCollection: Set; + private static instance: GlobalInfo; + private _structMap: Map; + + private constructor() { + this._structCollection = new Set(); + this._structMap = new Map(); + } + + public static getInfoInstance(): GlobalInfo { + if (!this.instance) { + this.instance = new GlobalInfo(); + } + return this.instance; + } + + public add(str: string): void { + this._structCollection.add(str); + } + + public getStructCollection(): Set { + return this._structCollection; + } + + public getStructInfo(structName: string): StructInfo { + const structInfo = this._structMap.get(structName); + if (!structInfo) { + return new StructInfo(); + } + return structInfo; + } + + public setStructInfo(structName: string, info: StructInfo): void { + this._structMap.set(structName, info); + } +} + // TODO: rethink (remove as) function nodeVisitor(node: T, visitor: Visitor): T { if (node === undefined) { diff --git a/arkoala-arkts/trivial/user/src/sts/hello.sts b/arkoala-arkts/trivial/user/src/sts/hello.sts index 41c42c50e..1923eb273 100644 --- a/arkoala-arkts/trivial/user/src/sts/hello.sts +++ b/arkoala-arkts/trivial/user/src/sts/hello.sts @@ -1,7 +1,7 @@ import { Text } from "@ohos.arkui" import { Column, ColumnOptions } from "@ohos.arkui" import { Button } from "@ohos.arkui" -import { Component, State, Entry } from "@ohos.arkui" +import { Component, State, Entry, memo } from "@ohos.arkui" import { Color } from "@ohos.arkui" @Entry -- Gitee From 2aa6dab87237c0b026dac3dc304844f8cecb26cc Mon Sep 17 00:00:00 2001 From: Alexander Gorshenev Date: Wed, 19 Feb 2025 01:41:14 +0000 Subject: [PATCH 06/20] !9 Struct runs again --- arkoala-arkts/arkui/src/sts/arkui.sts | 12 +++++++++--- .../libarkts/plugins/src/struct-transformer.ts | 17 +++++++++++------ 2 files changed, 20 insertions(+), 9 deletions(-) diff --git a/arkoala-arkts/arkui/src/sts/arkui.sts b/arkoala-arkts/arkui/src/sts/arkui.sts index 2998691be..58a5b1b1a 100644 --- a/arkoala-arkts/arkui/src/sts/arkui.sts +++ b/arkoala-arkts/arkui/src/sts/arkui.sts @@ -29,9 +29,15 @@ export abstract class StructBase { console.log("Struct instantiate redirected") const instance = factory() if (builder !== undefined) builder(instance) - instance.build() + instance._build(builder, content, options) + } + build() { + throw new Error("The struct build() should never be executed directly") + } + + protected _build(style: ((instance: T)=>T)|undefined, content: (() => void)|undefined, options: OptionsT|undefined) { + throw new Error("The struct _build() must have a valid override") } - build() {} } export enum Color { @@ -141,7 +147,7 @@ export class Text extends CommonMethod { style(instance) //content() } - + fontColor(value: Color): this { console.log("\.fontColor(", Color[value], ")") return this diff --git a/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts b/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts index 0959ea80a..1243e1c91 100644 --- a/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts +++ b/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts @@ -13,7 +13,7 @@ function isCustomComponentClass(node: arkts.ClassDeclaration): boolean { function isKnownMethodDefinition(method: arkts.MethodDefinition, name: string): boolean { if (!method || !arkts.isMethodDefinition(method)) return false; - // For now, we only considered matched method name. + // For now, we only considered matched method name. const isNameMatched: boolean = method.name?.name === name; return isNameMatched; } @@ -64,9 +64,14 @@ function createContentArgInBuildMethod(): arkts.ETSParameterExpression { arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW ); + const optionalContentLambda: arkts.ETSUnionType = arkts.factory.createUnionType([ + contentLambda, + arkts.factory.createUndefinedLiteral() + ]); + const contentParam: arkts.Identifier = arkts.factory.createIdentifier( 'content', - contentLambda + optionalContentLambda ); const param = arkts.factory.createParameterDeclaration(contentParam, undefined); @@ -82,7 +87,7 @@ function createInitializerArgInBuildMethod(className: string): arkts.ETSParamete arkts.factory.createTypeReferenceFromId( arkts.factory.createIdentifier(`__Options_${className}`) ) - ).setOptional(true), + ).setOptional(true), undefined ); } @@ -108,8 +113,8 @@ function transformBuildMethod( const params: arkts.ETSParameterExpression[] = prepareArgsInBuildMethod(className); const signature: arkts.FunctionSignature = arkts.FunctionSignature.create( - undefined, - params, + undefined, + params, undefined ); const updateScriptFunction = arkts.factory.createScriptFunction( @@ -146,7 +151,7 @@ function tranformClassMembers(node: arkts.ClassDeclaration): arkts.ClassDeclarat arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR, false ); - } + } if (arkts.isMethodDefinition(member) && isKnownMethodDefinition(member, "build")) { return transformBuildMethod(member, className); } -- Gitee From 30f61cb361c9218cd7d954de105de1dd905fd71c Mon Sep 17 00:00:00 2001 From: Nikolay Igotti Date: Wed, 19 Feb 2025 09:57:48 +0000 Subject: [PATCH 07/20] !5 Perf measurement harness --- arkoala-arkts/arkui/src/ArkComponentRoot.ts | 2 -- arkoala-arkts/arkui/src/ArkStructBase.ts | 3 --- arkoala-arkts/package.json | 3 ++- .../user/src/ets/pages/homePage/main.ets | 21 +++++++++++++++++++ incremental/tools/fast-arktsc/src/main.ts | 9 ++++---- 5 files changed, 28 insertions(+), 10 deletions(-) diff --git a/arkoala-arkts/arkui/src/ArkComponentRoot.ts b/arkoala-arkts/arkui/src/ArkComponentRoot.ts index 3af4b9281..27ddb6c47 100644 --- a/arkoala-arkts/arkui/src/ArkComponentRoot.ts +++ b/arkoala-arkts/arkui/src/ArkComponentRoot.ts @@ -43,12 +43,10 @@ export function ArkComponentRoot( }) } ) - console.log("Going to attach") NodeAttach( () => ArkComponentRootPeer.create(), (node: PeerNode) => { content() - console.log("TODO: ArkComponentRoot routing") // const state = CurrentRouterTransitionState() // if (state) { // RunEffect(state.visibility, visibility => { diff --git a/arkoala-arkts/arkui/src/ArkStructBase.ts b/arkoala-arkts/arkui/src/ArkStructBase.ts index 5c40d5e86..ce99fe7ee 100644 --- a/arkoala-arkts/arkui/src/ArkStructBase.ts +++ b/arkoala-arkts/arkui/src/ArkStructBase.ts @@ -18,7 +18,6 @@ export abstract class ArkStructBase extends ArkCustomComponentImpl arg1?: () => void, arg2?: T_Options ): void { - console.log("_instantiate()") const receiver = remember(() => { const instance = factory(); instance.__initializeStruct(arg1, arg2); @@ -43,8 +42,6 @@ export abstract class ArkStructBase extends ArkCustomComponentImpl content?: () => void, initializers?: T_Options ): void { - console.log("_buildWrapper()") - ArkComponentRoot(this, () => { this.__updateStruct(initializers) this.__build(attributes, content, initializers) diff --git a/arkoala-arkts/package.json b/arkoala-arkts/package.json index ee2066012..bcae4f45d 100644 --- a/arkoala-arkts/package.json +++ b/arkoala-arkts/package.json @@ -65,12 +65,13 @@ "build:arkoala": "npm run panda:sdk:check-install && npm run build:arkoala:components && npm run link:arkoala", "build:arkoala:inc": "npm run build:arkoala:components:inc && npm run link:arkoala", "link:arkoala": "mkdir -p build && ../incremental/tools/panda/arkts/arklink --output build/arkoala.abc -- ./arkui/build/arkui-no-common.abc ../arkoala/arkui-common/build/arkui-common.abc ../incremental/runtime/build/incremental.abc ../interop/build/interop.abc", - "aot:host:arkoala": "npm run link:arkoala && npm run -C ../incremental/tools/fast-arktsc compile && node ../incremental/tools/fast-arktsc --only-aot build/arkoala.abc", + "aot:host:arkoala": "npm run link:arkoala && npm run -C ../incremental/tools/fast-arktsc compile && npm run aot:host:stdlib && node ../incremental/tools/fast-arktsc --only-aot build/arkoala.abc", "aot:arm32:arkoala": "npm run link:arkoala && npm run -C ../incremental/tools/fast-arktsc compile && node ../incremental/tools/fast-arktsc --only-aot build/arkoala.abc --aot-target arm", "aot:arm64:arkoala": "npm run link:arkoala && npm run -C ../incremental/tools/fast-arktsc compile && node ../incremental/tools/fast-arktsc --only-aot build/arkoala.abc --aot-target arm64", "build:user": "npm run build:user --prefix trivial/user && mkdir -p ./build && cp -r trivial/user/build/user.abc ./build/", "build:navigation": "npm run build:user --prefix navigation/user && mkdir -p ./build && cp -r navigation/user/build/user.abc ./build/navigation.abc", "build:shopping": "npm run build:user --prefix shopping/user && mkdir -p ./build && cp -r shopping/user/build/user.abc ./build/shopping.abc", + "aot:host:stdlib": "node ../incremental/tools/fast-arktsc --only-aot ../incremental/tools/panda/node_modules/@panda/sdk/ets/etsstdlib.abc", "aot:host:shopping": "npm run build:shopping && npm run -C ../incremental/tools/fast-arktsc compile && npm run aot:host:arkoala && node ../incremental/tools/fast-arktsc --only-aot build/shopping.abc --aot-libs ./build/arkoala.abc", "aot:arm32:shopping": "npm run build:shopping && npm run -C ../incremental/tools/fast-arktsc compile && npm run aot:host:arkoala && node ../incremental/tools/fast-arktsc --only-aot build/shopping.abc --aot-libs ./build/arkoala.abc --aot-target arm", "aot:arm64:shopping": "npm run build:shopping && npm run -C ../incremental/tools/fast-arktsc compile && npm run aot:host:arkoala && node ../incremental/tools/fast-arktsc --only-aot build/shopping.abc --aot-libs ./build/arkoala.abc --aot-target arm64", diff --git a/arkoala-arkts/shopping/user/src/ets/pages/homePage/main.ets b/arkoala-arkts/shopping/user/src/ets/pages/homePage/main.ets index 4ddc9ed53..a57b795dd 100644 --- a/arkoala-arkts/shopping/user/src/ets/pages/homePage/main.ets +++ b/arkoala-arkts/shopping/user/src/ets/pages/homePage/main.ets @@ -31,7 +31,28 @@ export struct MainPage { @Prop num: number @Prop ratio: number @Consume('pathInfos') pathInfos: NavPathStack + + isPerf: boolean = false + build() { + if (this.isPerf) { + const count = 100 + let perfData = new Array(count) + for (let i = 0; i < count; i++) perfData[i] = i + let now = Date.now() + console.log(`Measuring...`) + ForEach(perfData, (item: number, index: number) => { + this.buildReal() + }, (item: number, index: number) => String(item)) + let passed = Date.now() - now + console.log(`Passed ${passed}ms, ${passed / count}ms per iteration`) + } else { + this.buildReal() + } + } + + @Builder + buildReal() { Column() { Flex({ justifyContent: FlexAlign.SpaceAround, alignItems: ItemAlign.Center }) { Column() { diff --git a/incremental/tools/fast-arktsc/src/main.ts b/incremental/tools/fast-arktsc/src/main.ts index 2e8bc7cf3..b9b066a0b 100644 --- a/incremental/tools/fast-arktsc/src/main.ts +++ b/incremental/tools/fast-arktsc/src/main.ts @@ -177,7 +177,7 @@ function mainAot(abc: string) { let sdk = options.sdk ?? path.resolve(path.join(__dirname, '..', '..', 'panda', 'node_modules', '@panda', 'sdk')) let aot = path.join(sdk, archDir(), 'bin', 'ark_aot') let stdlib = path.resolve(path.join(sdk, "ets", "etsstdlib.abc")) - const aotLibs = [stdlib] + const aotLibs = abc.indexOf("etsstdlib") == -1 ? [stdlib] : [] if (options.aotLibs) aotLibs.push(... options.aotLibs.split(",")) let args: string[] = [] if (process.platform == "darwin") { @@ -185,15 +185,16 @@ function mainAot(abc: string) { args.push(aot) aot = "echo" } - let result = abc.replace('.abc', '.an') + let dir = options.outputDir ?? path.dirname(abc) + let result = path.join(dir, path.basename(abc).replace('.abc', '.an')) args.push(... options.aotTarget ? [`--compiler-cross-arch=${options.aotTarget}`] : []) args.push(... [ `--load-runtimes=ets`, - `--boot-panda-files=${aotLibs.join(':')}:${abc}`, + `--boot-panda-files=${aotLibs.map(it => path.resolve(it)).concat(abc).join(':')}`, `--paoc-panda-files=${abc}`, `--paoc-output=${result}` ]) - console.log(`AOT compile ${abc}...`) + console.log(`AOT compile ${abc} to ${result}...`) const child = child_process.spawn(aot, args) child.stdout.on('data', (data) => { process.stdout.write(data); -- Gitee From a5973a42406af5e652752127bbea6ee1d5d32aa2 Mon Sep 17 00:00:00 2001 From: Korobeinikov Evgeny Date: Wed, 19 Feb 2025 09:58:57 +0000 Subject: [PATCH 08/20] !11 Trivial demo with dollar functions * Test dollar r and rawfile --- .../src/main/resources/base/element/color.json | 4 ++++ .../main/resources/base/element/string.json | 4 ++++ .../entry/src/main/resources/rawfile/koala.png | Bin 0 -> 112716 bytes .../entry/src/main/resources/rawfile/phone.png | Bin 49101 -> 0 bytes arkoala-arkts/trivial/user/src/ets/page1.ets | 2 +- 5 files changed, 9 insertions(+), 1 deletion(-) create mode 100644 arkoala-arkts/trivial/application/entry/src/main/resources/rawfile/koala.png delete mode 100644 arkoala-arkts/trivial/trivial/entry/src/main/resources/rawfile/phone.png diff --git a/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/color.json b/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/color.json index 3c712962d..c813809cb 100644 --- a/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/color.json +++ b/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/color.json @@ -3,6 +3,10 @@ { "name": "start_window_background", "value": "#FFFFFF" + }, + { + "name": "my_color", + "value": "#114bbf" } ] } \ No newline at end of file diff --git a/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/string.json b/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/string.json index f94595515..d1c869602 100644 --- a/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/string.json +++ b/arkoala-arkts/trivial/application/entry/src/main/resources/base/element/string.json @@ -11,6 +11,10 @@ { "name": "EntryAbility_label", "value": "label" + }, + { + "name": "my_text", + "value": "some_text" } ] } \ No newline at end of file diff --git a/arkoala-arkts/trivial/application/entry/src/main/resources/rawfile/koala.png b/arkoala-arkts/trivial/application/entry/src/main/resources/rawfile/koala.png new file mode 100644 index 0000000000000000000000000000000000000000..04c21efeca88b0eea5f17e89fb4a8e1c7bb30892 GIT binary patch literal 112716 zcmeGDWmg+-*ggsecPsAD{tC3Tc#+^>btkw6KW_Gp`jg0vnb?mm$m;elF1!!qMcjhg zmG$mq#-b&tlD+LR_)jRrSkNbZo$ispt2D3L{AEhiOi%MFQ2(^)kgwjbN+WgH$*eqo zJ$^=!M&^~YK~A2`y&U(5@mu6nX6*2zQ#vd`J)FPeK7%a33)?jm&IHx=9H$s!Vn{8l zEi@#Ko_f#BuQhs#ITbZs2|ixjhO0x4-JDVh`S;mC0AsoO#(W#uWS71KLO@FNMYs0o zOHs2C&Q0R1a;fAIb>?p?cZI{eV&z6Q~K^0R{Rs7dFs9Vr~CpeI=E zirNGZy!gs?=q0%0PIo~8Tc^V_d{ zbXI8$+D5Q`xX3Oc{O?mh&^Aj(b;%f8o=#=e_3t|snc#q^}$6nmzc`?~KxA){(Ub=s2? zzaWL<|9fO?)zvqbb!ry`ORRi`Z7(xkDOmUN^QHUol_K=8aMy z{Xbu359B|>iR0jty(5R=-@*yi#&K(Te8{6=wxg28s}*X=E14(8sk3wSi@tTwjQjw~ zz<4&FLa0Fb-I6Z-WE2K1aD-lNsxws~cC|G<8I8d!7nO83O&?zTEdKKI)x?4HDQ~Iw z|UYjcq{(}L7?SEFzac>cUEd2PCy(5)JfGCW4u_SncU0*T^ z3)$$lDG5W(ttzUxfo|Tb*4!nD3TVGda!_nJlU?w=`R#_U)T``qQ`|Y{Y8lPq(~d#NNVi`f=R%4L%DpYzI4V zM)u9scr@5Q%k6km^uR~Pdf_MRdOTz1t{r5c-%MqZ$#Wh#@yG`NJC`Sh)B_;ut_{lk zkE!OWCX+t1g{qDR+BIkl;FjzigJ+?h9|k;s4&)Q<4Du$#W-~ieP-Dp1h%-OlBV?Ho z;*1cEae5ftJ*qh%wQ?Di9#L!EQoF#Jikc|@C(0bSAFN2*(8%xh_~?d~wv)5v3h(wpV9fY#$~eN|$A``I8IG1Ko=Xhl`B9%9ww>2R3?kvc zbY*hHrz$m|zilNR9^Mb5QtkBg^gRAIe%cGZNm@bZDmVE9a9BWn5kwyg*nbv%m!6_*W?Z6n(*~P_A zaU~$<0nfI9kal+8e$T>ze1H9+Aco&E=THN3e#~}&)%hV!xtRo@8ryN5bl_F5fMhUD~BGQ;O3MRQ$}aO z{f{a{du$`syXp5^TkR%bFk0Jv`;q_s2;&$U^*9Hbmy;s&d+#eZK6v@oX%X{rnwj-PF;r?6JiarJ; zidhK+4gty{db(sn2z{D^?%zo+paT)4b=bSj+G8(RwJR}U4ye9II1q}30EZ4u73!{IFn5Uq(W^sSkOvuBF+~TpY4(bXp}M-ym**TLd9mExp;SRkpo5%cDTB5%n}5JD`Dj}rDD?jaHAaG5-=xv9wjg?J{5 z=!18Qm?(X=0w2o}Q&CKX6S2E=0ZX$6ZJsCl{BN%*7WNX*#&o6eDtd=jA{87esbRFGHjDqKa6@Zqz-E{dJF%L%4=lpGuD;UC-Xjrcqm#~68|=y zO?yX*zSKp^8zZ}GBTDNRY#9))onL^{UwFDK6P64<)$pnYe12P|gGUd0)yCh9$4b|{ z`AUKhctqZow!Nsq$RI8oeuS1M0hQE}f*H-(dRe&D~jnIL1d`+|l`>p}~EAWmXm%L~gES?UG}T2`kECv2C>! z3rjzU3#Y8d$AczTMURS&i#z;vS%f2f)pFEt%oD59no?sj#svV*Otg`?$-}ZnUn3NjX> zcwnq{5%HANN34r~;&9kdD2pbhIgVw>@i;=qv|yl*2y=XoXCU6KQ74Vw2VKn`!I?j@ z@!=9goZlcm)Gp*>agMtml9WvZ3(%Zo<*-5=URU|vJcS9^#s1klx0`LR{wENNN40op zi{2@N68s~J7KYTJg6xhQ%0bq!;P5QgIeFbGA3vE1|BF@H^b;KSd0OYe5H~qT0gu5Q zkb8nYRn?M|3bZ8`W+YpXZerlRdh9D0{X%&?Ya^OJzzlsmK7bb>B($>*DKuY^D6Q9( zq}i7)W4I*>V4<&m9biv|G8ih#MC%uP8X6-;C^_o+f!-eg$Z94sDFXDoNG=>>0HgzN z&wxE>7y;l-GGEBweuID-ed1b-hyq)Z{-zJkM&H`r z21K7k6w=wT5xr+<=a!!%TKzsD{6z`9=Glhy!!?^eV6H6k7GOc5jHZu0jk0qEU@CBB zab~P>sUo!(@8N$9&t+!lYjYB3kh?RlJC*O$b2mUMd+{DdW#P*sq$?`f;py)B+=SlI zg@}2f*=i(%;E4D`J6H|*Wpb*Godcr2*2r0SIyy0?bF{noR{`M+ZiorT8cS5$SF-J$ zHGSp)ezxU~7s!4lVG%n2_6#bmYqp5v8;jkAkpQcu;K}SL3e2&|lACev@kl_q<6tsu z?7i~H4iCdtj9bl=fF@p4+Edr&`N98-C&0wlZnHLvBk?Fi=6#Zpt-aA ziZ!xF|I&t=@QLY+$ndYdkkCIWy?8|oR>AdXYa*u4w8(!^lJ0$UxDk}wsSIndiDDzT z$|JnR@2&`Hg|B`eo?45J90ped(Xi9nZ}`U5T9a#0nZmx&3@WCDJ*_7z({Kg(5Zm`%~OQ?{JgO8q^rU)cTUAYf-2{o9y+ zH;K(xCI(#+FYMN;wE8sjoISx@6RfHQ6+J9%Y3}2{np}=FLgY!ym_IxRcHQ6fnGv;5 z2n)8;Ly?3(czJ+r)QszY$CxEb=$D!okO0_R@9NL6>79y8jF&0ov*Hi8r#;V}>t1^~ zPdo7!u-H{2`@7KPuI0U^MoZY);MNQl0+H{ZRqgfTS3v_yG}uZh&eB3!>L|l2dUQx_ zTfLIyV7P@Jk7HJtoqo)7rU!#DRz!Xw)aSD4#%mO*{}NOYI1muct4?2ibbvApny{fU z^vFmju!~0J*1Tz>w=n4DrTCh#Jt1A|3t48h^5xn-m|(-K+YQS)%hjmc9XobO1KjOQ z6eQH*%*!6prB43{BN`l#@|-(s-|WQspR`c(iBZ;m(3pQIm>L;&Gv(Ykl8%cuIj!|e zM`J_HYlBLfp6RbgnnBJX$Na}BQ2QWz*WP@TrN{ua06p^bD`w!~6!lr+<^`L_=%^`6 zI3*LO@IeRn3lOv?BVOaTr9nZgGQofPVINZ1S(1EYTPGshlseMrf|oJ6P=;|P(aW;Y zh$L8bXyby#7E$&bV4!2vD#R-Ns+fq>`+X9qo2!#B+3x)<(oMg>DBVPtifG4#GLIxi zP^lx77!pO05lSk?3U&V2%KxP!x#Mh>H`vc2vHw$3=nvT_OrwyKfiY*M0b0jb945He zZ7*e!&p%QV%MiYbW@RbMKXO;Axq7pV&N<+pBK66__9u?5RmE=Kfac+Rj9GA^9J^J} z6>bg-z?~}TqlGMS7L}$IJ&+&$g$SMv#h^Tmwnd_iY<&zCW@XOC!QI(vx0>=T-48Kw8u<)#-@RIu> z)Ov5%Z-5OokI!NWKP%M51E1Y)Vst8NO5Vat!ahK_vDk z^mB4(>~;RR%BF1|BSu4Y0~eU$SI`e&<9vtz6@I0P% zY!%o)G!?n=s}&aMiaUdO-T;P>b$FN1&{7k}An*w3i5PA|W62oSw$yr7&$A2;E@9=T zeDIG%9cs4!QHR?`!v83dHq)8W#-0u(O5JMg)g_HA4$X4k7?Ut6Uk28$E3<(bUY!YxMBK0D;Kz- z?#~{iC5vUEYW9^gy%5h&-*2?;wb(@rrpZ6k&XHYIh<~!gXZP$wK zXU3f_K4@VMl!xd$tb2QVy#P0iyK4*bj?moHFYaxIHml(eZ-){LSC;d+PU3fL@kj{N z&`Lo5ByRJZFZLlAoqi}QoiE+bDV-m~(Ec}))Gc`0(0*!*sJKUdaEFjap$zx!BoZmR zYx7;1e#JbHEdGdA({bj4+yh5ezK#HUTR{aqg6q z^UJa_uH2UfvCFVUq8TQxi)AUs| zL*cJ5j$LLw_34rmTC2t(>|}a4qqqsF>ETW%|JMY-9~f3DecU{sY_CZjTE8G+p#0od z@Bf^ayjDZ4lkc5Lcle2iS|Y+IXsP^K@VHhwRe!u_Qm(0~Y4BQ=yTqjAqYSLKOXKA9 z*kR6cv?F4^jLGusjrbShuoX#cGd5KqUBUl4QBq__OTokI0puQizN#5>%9S}U$kL(5 z3IT$G5cQBOv_X;f>s*=k;HDKeP-DZ zy^w7r|HLe?Wjs1Qdo+NbCQT0|nFy!FxYNUjpcX;C<%0#4cN$G8AiU#GbXvBly=3D{ zU4^m`?V0W)3wgyGfm=cj;X*bx75cS~YF%hQIGOAkFytZpG?QC^G)0Nxy#4?thy;;= zRvV93DF^Di)nq~x7~uGW$FrFau=ei3d9pPLJ_BWgJwJ+0v*d?@MH;t z>eB2z5lU{{P0;rNFk{=XE#G2DPXvs4fo#|U7mj*KYe75Zm_@(RwgIj^{<+V-#;t-S-#m1t;V(K^-<$^49Q-Vd<+j@vT7rrGeBQ1R4NQRQZXr&yBak7(Km2Jqqg|Om7XGYu^Y3}LjDRSl&dShFWCIk zM^Zq!3ZZtK#|0cv08UvF$yrqOddHV|2u2}# zO?F>Wcj{g{N2cr250fyk_mn?#XJifl3DDr9Sab?p-Q(gIo5)>Sam}w}y?DUnt!Fgz z{&iQ{a{blPnU!kvAtl{?f&X0Jv^RD5lJS0x(H6V5xcRZDp;P;nWl{gPCXHRdp#B-E zbE0s1CVYh!@cGq}`h)0uB!~-_^H6-hSl8n%snpiz% zdo>bjW|%W*OsDDy^dj0-Z^t*l=tSocPA%?x?5P=d#dnnE6vW zL&*|4-?BtnOQd>d(O3Rx*VyMY-^&6(Q6#afIzKPy(!k6fqDwXVjH!LWn%c?c%-D+4okORrHwIWs65b}<$Ho}1{ zm7`;n9`0h;uX`vsVMRg_Nf|9(ppaLy`g@(c_)((83h`&SmCrH0bbK$05xZU6n<*ta zUY7N0WWd~WYqh7hJx-%xzn{_$BaMuVPbPWrq9H=H1a@9SLXO<=dFuj?*FbH!UYd^C z5T{jNY77M;J?z0g<~(g4Ih`(6J6L<9#Qfq`u;a>w8oN3*8|B7N$p%DnLvBV$QzR0r z&y<|#Gxji18^U>n-6?L1JilDO*Qu0b`5yB$4D9uP&jLi2IGJD`rOQn&I@I3C>%eZ3 z7f)GLGF0m|!W&;}tVjcaqHteSyFQgT-WV*qQ?DU2)XH~48~-&#{+d2mRqJ-=oASSk%2&v zA&PPDm7%!5nE0de)|m4LIyS5BzQ{^4J|D#0@>OVYI(6vU$9a6Y zcaOhqpCZ{Fhr6h9J0NF*Bk@h=V1Gm~3!TemsIeLA?Vopw?$%0J^x}V07XR7=r{RXq zOXrA6%+t1wDoP+V>>n^;L&hE5J%VTLDDEpOv$Is_p;h|X(12T&`wbPgrY3LKXG5l& zHD7Ew8!#3dBIq4adYqnrO6eh9>GB@?Y{XaOiDwd{ou>@zJWd18K35RAr(6%%3oxV@ zK8HoAvxyaId8h6e+)%IWn}L?pW;zy`--?`N2f39GGHlUEbfL3E1PAb~0GLFsfGLR(#$ZA2wA@D^`s)R7Clx9@3-Z}b2j&^>;9r9M*ELie>zzIa|oMD z!B;83;`*`sX7~9J372GLK8y~ALz(x2!PrWjE;ph3<#O*-h7BF?OWlMBS``p&E56W# zMc7eI~Pxf)Ge)U2SF5mMJ;cj1`fk`Ys2WbT#E=yKU>Dg)NHzRE+O}Ec?U$Zzi z2C{`U7UF{f^_}~|u8eeZ{vzX8hjNtEh-^d8l6(J4N}=2j-mh3N42s!>wi2*WVwi#^ z$p>GN8Y&TnTjS_m`qf3E>wEQ`KWi-QRO+>>Gb;ULd}-G?)KgX;snE>L*}nG5q~sLj ze+dfCygw^QC^+;Z_B|Vu*Bm@EemLqRBI)K4TCml0MC(U^O~r0A)4FDb*@Mi8Gi5`` zFeE#lxn71>{J5pb8xh(rEa0;f|ABaw0Er$Uqdz9QoVD7>Fn@J36D(;J51`LRusSU_ z3CRilI`Yy_5|m$-UxPDxv=}R2>JC?qcy_40`|c@4F2_;N(vsGT1;&& z{Qw2(s;td-Wr1kwFyUn>uj|R%+kRXjShUwFPc25rvEgf8Kg)sqRJ-qg`7WKcfv0wTA^jAia?-@sQet{7Z*a7g z>0B_n%<#+k{bn&1#fS^yL6R4RM}{?m5aqg*%#7u8-O=wg=(In|kJDWFaTcu;owy?# zbq>X74$LLb-~RMRGx0}B$uvDj4Om>2ZS`;X;=1U4zB{!u;(ve2&}JasY@m-7r_CjR zg2Hd9;j|no>{n}4>PzYEN7S)WAcW?;F9c;Qek&FT5+Z>)v&~mCV5@1(*d?~GJr8AQ ziol^$WA`K;S3aoM`GQheBOc^-Pt~bmWQwd(!nNs@7HGh_qH|mER9jl-!Nzc7bbr*Y z%IENbC+#{_ZJUu4i#2!6c-oe`$C%Mhiq4g`3@cFJyxjb6JcvABth#O%S~A0J*;GAk zJ$*P`blx}xKKE;1S~@CoZNQn=3}!fK9HxcTHgrAnC^?wZZawr={dnE#lWCHaP!of(2J ze=p2tks!MJ<&7J72a&RH?v+|^JJW$8&z-p%J^J~=aqV@cZ!6; z$FmUaB`WRR#{622lb51dJ5|59rb(@1UEoy-G(Gh4!KI^>4>YA=OY!kxRXxafWh<+@ zq}F}&!DHgR-Wf)btETEE5#c51uhMBdQai6USEAu<(U70!&q}xXjo3%SpEKmk)PJpB zp8~F%o$#;4jSsNx$>?DWZZ&>TMc?3`ZFyfSLe^(E>JSWGda0c{d%=n&8hV00c$^-} zdv;V}xhLM$(#TTMFgXv*26ekZ!7Nhj2{|^3aVpVU<89D zE%;2va@Rz^r>?_R8)HW^#B;E?$J=maijT;Fd5LUv0&*?{fLv7b97C;dWfrqWT%VF`c$Y-(Mlo z=S;z+*XW1F1mNb<>mU7*;7TO8g2&@*r(h-aU`an6nqj14Tb0UwP7_M^sfdc5&J;Vy zi&dMBgh(0%#+Zy%CCso4!au~8bZ_aMS%^S>(2YeaeR0w)`WAo`)8J$QTvyx*dy9p z{1_iDYkNFD4?kr!CBcsl;A5e*(MEWD3~rknQ%Q{}YVB+2v2NSddPhfxZxr(bwuCb8 zZ*d9MJ51nhvTw?CmM0LlD@dvD_(HO+5R=FNR-rA-!p1sFlEq?Wcer*3_^&!FqRpsH z#W&FPCjTApxtEPMatI`T>sZy))DU$TaE!}P_Q`RqVPckux!;V!gPRgy^n9J!v$H!d zh42?qopdex+*ha@>`ExlaMY;g{ot7_m$J<{!XjX?#(3MwUFU9=J7q#&gqyA-GZ$AB z+TP`i_Qx$&VeMK6<|pXoT2}jD>w7mh))}V40;&;kTFoBvF}aTYmcimm`Uq=IIn0a$ zy9xI8*IZtam)uCv3d4xr(&W7YQoXS!b|d7)s;O6ajyNEpwMV!o6%T&P99js8Oqt6> z873kb_6r%YMSw9jE!Gx4mKswEZ^2$$3_nfv$Z4(G`$x%%y*ccAYJM7^tTbDYg)O?b zV@z}bQ&meIV&-ZOmCW#wlN%d@Ls~^HrDEL2F1bbz=;@s|nyE*4t8&akUaZ!%nUVY- zm}%1?tjb9ND1w8zP@JxF^4!E?6xgunfOMk>a;+@v1T{>O=H2opFc^Uoh~?E7A}g;)%e)&8S9+YX{W&!o|&M+}Cg( zRgS!oX~xXcbk$`3wX}>_C;ugz89H}CIGHH7J?svhu@=j>yajnZ*1k49J>By+Qk#?2 zlfOobivwv{J5wKYE;5~xs~y9K6lhCgkSf!X#Zm+t%bWrvDLHt z)pyTmqO(;CMtBW-k_?>~W`e)({GM-g`4%TP&Z1r2mP6B7`IZEU&ytC?`zXI*|J2(_GdY+F`iX1Hpq${%YqA*1KC#aer$Z#*v0 zXso`LO<%4iy$ulTqo*{Fw0S6Ru+B|zCrM!M`@6ZfO&ilVkjy@{Pt<@E>>2hSuMfQu z?J5$TvOTx7w2GmiOaijA7li>%*3R|^yJT{O0$tNPozcq~yy^0xgZZMk2@4ViVHS*q zMLGQk@o(EyuLzZr;N4|kN#fb~4QK?{S$32OLaATnlCx z>1tFK99-3FJ^72$9xLV-o;577Dk=r@1qB2WM#1xEeTW9)esjZ0CvPph_(zLbb2La1 z8P^GL596*GI6AE^7z|0wg)|5Xq;3-xapHr@wC-T{#3kMZr?erZ4}{E!1-@mvQ%u#3 zsGY>U74kO=P#4~GATR0a(2C&<@Zh^>QGS#7Bd`W$7!Z26BE$x=`{esj9uucmFy}tQ z13^Pa)UAM{>;C@!v+?n9x;ALXlz8C`YfCJ5Po`-Tx6*YrE^CCrryzdOk=hq&BP1Y) z+8|`NbUmtTK^oj`9M8Zspw2m3EoMw6mm8Xv#yHIR=Il5JXBjv#G12)~3r{xk0TzMx z1I{*lbp>_PB)8D~o|GT>Z46h+RG2SaH_&(3ONvQIUL#M< zWX!}TBD!E-5MCfCqb*i3`eJUh<2kQZyHEre#_Ju8WGC=qN}SM2$#WtdM9UJvIH@|& z1!1~Oj?d1Gdopir+A@u8hzP_Gm>AW^@?G|x6wUPU1-+Cyf`6owB&W{jnzuYI8E_XahJR1Lue=8lfa0gG#el)#-BbG5mw+vhTZGL@CQV}pbH z#KT?~=6}O9G$z#SY;9)?XL9t4Iojws>SatEC_K(}?~Jw#RqPfxTMapdQ~!$I9pFX^ zDEfT5;?Nf|EOWdu)S}iDuOwI2EZ{NS*)_EbH;#?1NroK3ar;DbwAawS8l>Ud#agm8)Ovf9cI_shn_J!VKLe{Pja$hk z%Gp1ZWIG@ z(?cJNED_kS)nQ?Z@Ed6)HC_V9>M=Y%!EI_Lv_`tYM4t@*ruR|l)a)-`V5-(~DDyki)gPyxUgb34OcezW#9E9XD9Hvc$~s9+;6f{)H8^X$*3 zua7PogL-wcH`D5azMl(lhoXS+8@?GMs!J4OtX}aiYun%CLnEBwGmE!SFYU6&YPLuy zQ0v~8j7wWKeMDPRGUfSFMlqcjHmLow5qmSIh1$GpYAOSx-vK!Z=Xn;`1{ELt1l=PWUnS!hIHoEwTzjo!-Lp&xK-tQBA&9)q3nH|c|sVLDr z)#KxFckN=4qU**Vpc-@fFEz`(7{Sx1T(RJ~5&^H>6B-f{72fcZW8H)5<< z22r3C*msVP*1b`}pdA8c|AAGDQeP_QyC5GI1TuZZa4#Pqjr3r5X))4Tg^*)^IZ+EV zSmDIl3YEU+4uJN=KA`kanwVBNV1WnE(<1g#C8i_v7cwUtvpCq&Y-Y_I&4 z54YwV)Zj>)b<;61gt&mXYyKe3@aS^5c^PM(1{t9IrfS(C>YpvlN{#0->|oxG@mCP) zPCDygVm$pesaMg^hkh2P0RxKG!R-b@_l&$Cy2!a}Znh@kye1g1$KhgJ&3jNh8T|57 zcs?6#^%OC$$(CE)TE$^;I<*jw2p3{q+RUf!B&b{r9rvp^xw_`Gu$XpsaR{*k?sp_TsfgW3IEon)K$8`L% z-a)OG;?~fyKI)EK^oO1#V@$T0wuJz9j862qDZO`6A<}#(+Zk9PBg3eDlv`^tBX|;- zJwHyKboFg4`oax0&Q&Hde$CG1_~>7DTo_|dpQgBr zem$mB>X=7%8+YQgQPv*gptrZdjn~{+2NSl%_r@q2ptzyetKrjy6cQXf6FwPm zH3pUd)}ud!mK~sS(gLQ}jK{Vebz`iPEe$@AHE%E02OBL6l77rv7plP)5@hID5W3PQz>KUHiV!6SOyD<2L2-)>R@SWqT;wNukZ< zOFd;wTFvC83DpdyLLL2Sm010nuxJENfKkG<`|#hl1xX>NC4f^{ZZ0;jm%K2xow$UK z@Ru48(6DaH@EiZo3wCwa;u6n4?>W48P4*9)dZEpTUw^iroF4Fg<4c=Jxps)53r~BeQ$QV7D2k>qD0CqC?G)Kib@AmvlYf zI6GfH5cV+p8~vJUiB(wg3y9f$-j&he6CGd>tIcS~TqiZ@aWU+^jYjX{mI*ayAlwAU z^5RpU$nJ)??*6voPfhopYabErogBf6LaVa5y*eAT=M&~7%@)c1k|ztvh_)myQC_gV ztt0HPoNW;7=rix1Lhc;?`p{Aa`oW`MwQZUcg_m#G+PJ%0mu2uL)nQGVbo!Ju^;ej} z1(*tT^Sa!3lpgh{Ur2@CU1*wa*fu1h0|3Lez=|>t^%R8r1e{B^U30HC2mf6s9v90Z zpDD{|X1PX6)bDZYdNuOyrE8hT$9jf|h=z_xstmd3Qs{355o6JF{)E$?t~q0QoRfz# z+$PeU#>XEdg@rW|5%Ciew)mbSB=M(#5K3RI+V1CEwM#(5FTKi0orf}4%Rg=B>H*oe z;2#3UZ=XtJQ1brBHW7FfUPpZ8A8iynrBn-giTlS{+6{QL93qx|Y97tL)yAc71fBs; zr~5EoHF3<}G3plZIrNuRir7Ket`mlD=OBv@Q{|XN?fE(Hd7qG$NH!)$qpnT?&QjS| zYRgZ(e|9G{#!kjRR5euu#d!oB>%Q?1eL0#++CeR_cSOb_sE|7Q&$$-~Epz_J_~&#F(L4 zgH}!ChAS+LI#H$v_6BCE?T4k-8ii%{>ixi3N%>YbAsCF0*f&cZ5ig|Od#e@ZiZM)2 zcF)|uA=H1yoY;8NJvR2&AId=2;&r}1*3&aa^7a=6?&fcqv$K?(SaJcULi|nBS_N;B61Kiz+u_qf9TdVg3-TZl0~T=gZt-$ zWpCs{yA*9&G}>sgbJPu`d2bR0C2>UyHj{BoVv;u30+`*_%%Gm2r@LN_%Hh`4SG%=w zdGmfwZX3d9sd6=wa+pHMnWPqDp)8yUzKCvaP7pwBrQf=2e^rO>PFf|4_Zns6 zbu%IS&QImzl^k(Pb2GVvqvKbFRko^TG?Rk7DfF&hE)F7)92*h9)vl4f&TTV^iBHd{ z>5xs8fw#8K(5ffJt}D}*A`9(i)~OZ@SE-KjMt_zzh|V%Im#?3=rv|=a1vh@ z0|E_2)_eE$vhK}q!E~C+bGP5edFg??;&8svZVAU}LOkXE|3Y6TkvSenLq!gj1a=8X zzH{_ObIKJB1RVd+TuWAgX=0U4;P0QQfcmkBC!^j(FG?PkvK7(sAW|CLu|)RV?Y&tT?xac7NZ(o$Z|+_7NO<4F^_jQF;bx|LbeXx}(pBEiB9FhEd#u)V*a zm@)lPj?*6#riA2Px6$vLw8k1_9R^G70K@IzeD}^o^!+=$UwGUBn;Xggcw7&^7ZCS3 zOJYcs0A!Jqam!-ImFv3~jSiNc)VQW$p3Uf*-|CkQmH4U(M;asC?w|6g2r|LUnBAAp z0#u$}Zjw`P109amKBkKos}&{n*N#51fea5uxJ-IEm)$S99ifYE-_m+<1Zs1h_|sROs-4Yv|LmOyiu%htvptN#DIv6)KG3B9)~TYyh|=I?~FYb z5DyaG_Xl&8R#h>`ow2cRsaHx^Zg-Wh#rn1Vce;Q3sr;_?tl_w_WFz8GSAHV5LS{hT zzt@IM&@mv*f1VR-FG-3j0pjEVr_|pL4wk;u|M>BPmdYoJdt*qvc-k&=^7oX_EPvQA zuh0hi@#MFQbgOzr@m$^v6iioxjKV)!nSeIb0qe2Pxlvmu{(x${W@j`xKc7EMg(7XO|J>&}OeHa4)3)|v%Gq+QBSg87MXixE2B8DrSTmQZ+c-IT(3S8Kox2>vZpcpcxKM@)%QO@4o zQnzvsYEktdt&xTvM|B3;h5J#C8Yd#|Wrfk`-|F%$?I}rJ* z=b=?fSFB_HR9qY=c%?0YyzUGm65wL73=pS%Z;TRks2B%|eW%@>yZY$)DAT=*+$9A& zy;IaTtNygT(|!z3Qndjs5G@lKjA7i(2Hq0zmwf#aCegr?U%w;?4zB*ox|RN;bl*#r zbo=6u;hpqnXS7nBvw$v%4Y$WehIt3+QKIdKtI?#Cag+a0PWjSb2iw<`Ok)jx8KChM zHTTiW$E;$-s`#$Coy*owH2s?2?Zj@kM1^HGv)l*Z}4czkTR#DY>g^7 z*xyo4?eP4kubZ9p;IJRAfZ>7p>%_bE<3YuRzthuyRO)32rZftERh?b)@)WD(^FH*3 z@zc9+T3gY$dP>P57eCNTU>)u|6W|;I>k3RVCRdIzIR45r{4!tegiD81v>u#eJ-CBi zuS>(ie2o3>&SzqYQ34}SEX~-&k0k4ZT@*6_t8*x@^9t+$;w}fF3%l8+b&U*$2`Fg&OJa@n2t=sU&WqN2*FNQ=_ zm%!sdL#}^#W)kz?b-Gk%wC-%ZJk_^o6WLq;tqB#Cv74z`hcPsc# z99Yu3>J_RbxE%xpB`tZmvmR8$VF^3y!xbTpQKSXjut;nTV}1Qdtty-)1I6_8A?6Y3 zdN+J;ri3(7gU#LqcAdX_pV4+J;tctli^emt5{gcySK{ZB+)v^o_aJOLxW<(8a zN20`^g{wee*}9^(xp~Q&GzOU_P?|#@#k;bwL<$=y$4_E*nRguL*K^2JW`37*a5m`;Se@&p&g{-2Zwa%q%FP6O+tJtxzHvsVF4goPf)brV$d(E!gucb^)-gm zQ!;5+@>tY(R| zkuyV9{t~n|G#s8gaH!|5z;%RyCQ|sJg2f1C zY1d~j?Iae}W-fVz?$WHr=1%nlI#n`n~74c%4a4v#?qia)BqRTmrobq*FLybm_lndg4?T8$pNsi4r$n zuD=zs_a5ja{20yuTDjyCOx=lS)C-vyc$`=qengSFeY;aay~?C46Bf1)5>;7pP>IQA zl55T4mZ+}=>C_BZ|H3$nckV-hp)cwPi0R4J0gHwGU_C?IJws_@8=n>bNE&U#O>E9X zU4`ouT?U=c@%h+lm8pE5_4@)2@MLGQyEju8c1?BrIMT$b4vf(gtmfmUBn5I6&B}(W zvdJbj{W#!@@Z`ptq7_X+;kPNC&R)bQM>*Q1M)Jaq3jt>i+(LALjcmCtlJ&WUFE?q> zH*#dV5K>Fzk#z1mUXf%j6_7jS+JfwT8=Xdm2#)lO!?-**qOUHFvn%n79!MqIF>$wwF!)CTs0v7wx_IjK}b8FAoQdt z2Fw^#{iUj=CwXP4PLhFY*#=l{*9K=FdcThhei~aVuEGq)oGx=TeS_?sn5gu}-@eJ! zYrY8EUMyxV#cArY-?OQ8m3jF_l|i5TdFPur{hk;&-Dy)NtLbww@d*W$0{x`k$cdD_ zRMxd41#ML!AOTwVsv|2~m)8tVHKU0)} z>^#y2lH^EKUZ@MJN$<|M?;>IS&c;g#Ml>)*|0$uDuKXg_NDJb_-l+SFX-BwYcHDuY zl_SXaGPJY^Tv}a#FC*LoO^flq@R_IZl~9(7z*%*MpgMsOs9k^G`6EwctM1oj-9uhZ z5R$BOoZ!BVTdX75RHw8uk<0lh03<)pMr7iUYA3v{ZR|<5@_%d!*Z@V17o<5lxm9e8 zm#>Cy6jtwEW}#lHQS`DUXeV<&WUeMYya;86ARk}fX=+oq!FIw*j>K6ZgB~^}e#m{U z$?45LFi-JM&^O2)1^vU5pff+VL&)=KGcIT=0VRF{*#@A$8f=*vENrD_ zh)Rkq$Z=0JZKgn4vH1T*)py53;s5d53Xx>*Pg%)I8E2DJW=Y6d$tWD|jLudenb~m; zDatsR=j<|$Gp@)!`_4M^&OYOJeSeSNAHP5DZ;yL>-|PK)J=e?o_L@%QHHtVOh}@Gh zBrDB<$_y27rwW<67R-VcVq}nJ`@Plk4Q|1x%8TN*?m&X*a+d!dn~_6a9n-)Aj^F-k zCRx)2JnC=tCBT6{?0eDlmw;}moIfnxNomI6%lpFfDZ`IFDn?%jAsl4=e{Cc+tl>+x z`~ikE3bHwHhgfEMfdx-x=jMcKoAj?{1N~avqtpJpicq=QB$oW2G}2p8D!uF*S82{_ zhtftN@2UJ`X@VK&s*v-RWOE;% zTCI%LRmpVbh%u&g^c@Gm?h5*rqlrzJdrbHXV1V4NmWU?;cF-wmjyr_-_wU?fBnTwFLk+BAC+8*9d)C97FgG{Hh#g?Fhd0^aT?1=mP+e~7#sdX+q%pi6 zt@%Ze9TmKC)g3m9Tk@gxy3GIJ;QBWstYr9@ub+#qDAFbAR)L@>ZhM7~ zn5nZK)O4OiI#SO>Qtn8GPE8O43FBb??j-AZuXQ(@rt?vW=Cw}$Jla>1k5^Z6W{mFhD?x5Jt^1N=w z<3v?=uB9qL0vlQS-}2Q0?)$l0eyWbwO_2P9^=t2C$ISLmBs{K9Yb-)ug~i`8i!|J$ zNz=5#{$NN)qYw7k?P&^M<>?V|s0I;ykG7eMKAIoq-B){a2X#f`wpI-kl)kb7*T=^p*93&SOEP(Qz{t{{W z`jMc?vd-D`Y9ydtZ%@oV+I&+@eU8-zB19#+P7W*Vkn`CJ7tk;_+melH9|xZP;jr`? zZvcLwX)^)+BPFP_h8_A*12Jgjb9a%+FQh%{9J}*vM@(D3e@5{!XnRA|Ol@o`3hpyA zoym6nv$@wc{9UD|w_3PjW=y+#(K8cj=N=#Kb*CHnt}IA{X2*LzJ6>stNVL)S)|s50 z&2ss(Q+-OVld``4!QuQ?U8iq5SBVDm&Z>coZ5v^NFyGv+&dVm^W9@Brjvx&W$@~rk z;Cp|3JPfU^S}r=_jL!p4*2R`5S+JWcini;}_eY@G+9*v%R3?nqrH?z?y%5LXmt{F< zq5W`v`=8cj&Z>Qub=&Rd#eW=*fb`s3DoJsv(@@kRgrEILv;LCe6ksUDfW71G%(7r2 zPq(CkSm0@sul;%cy_OwxT@IhI88J0kI}^8%B3nM#IQ#e9{3md?`*vhzchGvc>@Z+Z z?BYvnO6UITZVA=>-slSAlrlQW6G)R@vee|Fe}f~XtkL@^4Y;S5(Z|#@ZV%ln>{w(w z>Vs=P+>x1wTaGt!f4QS;?VA$4e^r1*ueqJScCLs4e=?Fnxvt?I(=&_wrdRgrAE^*?~kATx`6)F4Znlw8zm;NzFgptCS z^M?=my)X7V|VT!PuK~HWw{=Y9b5~5sHtbCeY#Lk)1e;Y=RT~V1!CWP z=qm@^-=nG7#d^5Vx=9i$^;2Y{GT*LhuvQi5sFM1mE{v2}&(7&#dSBMvKxc{yuM#tp zAw#NJ*9OgwJdoNm@!SnOED7Ux8h9qR4XIHUx~00(=|o+`aS9+|s$IxeD|VK4QTa-D z7i(Di6e}yl*U9I(JqasmH>^X8Kcxkd1XqOM-ZzilvqR}7AN+mom2=$}7E>dIfUOf) zC5GScm)F3j5s5{Kd*(FKWJSF` zo^ttcBc6-vlF~3Bs)>E-v;J#g$h0`NIE(v60M1oMTM&Ur=I4k42beWpb?30f&ZqUX z-b_fQhK8sjENqY+D2;xttK;#%CS61R*oUZ(+MV0e1@R1a6_p&SR@uitt)dSWISE(> z3Y(v1Li*=3(>z;Sss97VcDdR3{d5=YT8$-^04wz)8m)=VH@-#SuiHYRKVNUB=nFa+X(SjKrCUUy-hi`QP;sT^1hKF;WFPr6w;@u)E88u=_v6(m!@-~m?<|qAuv;#p6E)WX}Mh2C`?BP_6SLx z;U7X6gawwP`kYHk6M$eP-_F`u6wA`5?{7F8y-I3S|S-wbEC+MhYyOhR!dP@rrscO;|FUzIf ze-jhq)$M?W%618o#J_|iekx^r?E}njq_SF_aI6LnO)3lpu-ofsBmTP`yzuiaGxBoN z*(&}8*(fnC?wqyYfcBPmp@CI=Wp7aUgt2OYCUe!ZZ;fPiN=6^Wm7} z8v_h%Sjt?%Z|)9FZ)Dt7bKc5Q*M~oQo)K2Gchd|(-Pnt!AsOF## z{lGmVd|=)b;t$vx~<5NqTf_&hGXlg(2?tvY( zN3$+BHhHVGd0iq$1wXSQv!f<9t1o-|wbe0uG;+!3Mro6St03@zerB5vp_*zJw?F~M zR>P#Dc=zXY4O(hTl#r0#;N^v9SEB{KI<>@oLNtu)FuByVxvm&8z0z8(NoovnedDjM zdZ#KEz@hhdCe{hcti^ix-35LI@A+yUBB}@}weJp9Me}kr)i0S+o1J*QZWYF0CD6sIP=XEwJE8WiWW%_br|F6mv(9QvLO25c zpDEB#c=>_ayd|H3*&G!{s3 z4N;XHoM_h^7}$VO&T*}M7MpZI2V1t$)Csq5*1y*^?Y^@XA7-)M7XPlK08SUogD0Ho z##D23QaEv>Yc~`3{|oF_oy+!Vh6-yedCSCjI=l&Wt(^_cOOd;U9dLk0ZNiM@u|`3| z!wX3)emLf$KL@y-z6$z(`u-<|Bglb ztZ@U=f7=q&7a`J;c1-IR(?Y32#_sngvzXUoK+=nwP$tZu`MgL9prt;L_%=HF=sc;e zH{yND%2pwLT}%>wLh3a{ZJ{x3BcSJw5zfCSZR?^3uSOX4l9-9|8nfRwLECfZOK9e+ zOhg(*NPk@4{KoVbB{lBw>)+jXrQZFfAoKo4Gh&KttY$zPS(*A&-(`#wR+-XfQM!WE z+}!Qk+Ii|7@yRjJ3l%P-Vq;AiANq9by5bcdY2tf|(-iX5dpbWf3B>^$Aonx5yi3*# zqHW%ycKRZ31KMpMVG$Fc4~4*DDQVFU5`Pp6`EVrD`5c`Pv!tUM4<8>CAef?_m+WQFq`=3?HG{S4Ax#sYCua)>|6NvfcgIH8_rd&QaR)6g z1TB!N>hpH_lA*-&&%^4c+?WOH*>K8+LAtdddW$pN(|Nr%-zNdZJ`2cJPS3h|-RxhY zoh=ngK;8T2TmDE_q>Ex-|6KXCC4qo->y^oJ>1BQ^(EX8hjtOr{hv9wt6cl<(M~C7P zie~T`IoNq7CS`BeCsn@7#``R=p(d$eN}Tt5O`1tp-rj3tfog<0Uh;n5#cw!tI`qMn zo@VrN>7Xreo3B7q9S+Yo7>J9zsPy!NCsVVDRjlMk02tGI$45mfO$lEc!k67guRhF^ zAgnrXNA2+b&W=bVGWT0XVE_w;b7296nx0pm-7~?9@Ex_=WkmL=BQ@qqF9{Z|e)TtUzi24)=3)F%O@V zJ0qfoj*T#e+C7@IrEQ}t(nnqDClfy!(P3mi3K`26zzPIC)689Pq#F+TrltcY3^mY* zn89JwX15<&b$3sf6)f@HU{B}D?)`EDL||4J0!9yl{ECmX|6-mcnRdiK+qF8G7od>P z1OtzFr$4`5dV~W5IKVyb#qM+Ov4#htn(wK!u7MIf^yN!V_M>-vE(rZm*EZC+#F#MH z^Ek3<5#W?-K|S-bdul21Eot_qMxihi#3os_h5>pX8lBDt)5 zGgV5}(TXbKggSdPsgG)keoTe@-COM9lw;|1ZOM|VXvYzK#1U-evCJoylAo7H>+25!JJ5NO(usQjM>nH(QMqq>hJ z25>gEzH<;teIMa`fMEN=B53zt)x3v$-fFF~ydH4B0;Y?2i(zhsIf-} z@4n~$$P2gb;xULIjYJk72IUy$=?_~!eX2BkoVap!dhnTNr0m;UQc+XhXNF|$ z*K+BJHqPAG?Q34pA0v$<7ikmsrWwY;PVgl>2JL0%8Z{j_*t#FgUx;HIPbyvZA3Qz6 zi@xBFE{cCDHwhmQN1C5xVilTvZpms0k>7T_y}%W3m`p?9*qNM}{1A9~H0e`&S6?vK z@VuJcr<&D7e|hHVclHsl8$Fs=JH4w@F@M%b=Q}Eb-}+>SqBOoQ@++DT_lC+Pp(Jk4 zsJP9HIed#Oq^&yQ#JCAxKI@vF-u_>o%MujPL7=Hok$IN+KpZ`Pvf)?@|nSYP;)>DQVKo_2+D4w0sS20XZt_kRm=F*LZ zr8UY}0|Q1YejtRDy*4|;6=H>?vp>&Pm9sJy_eKWP8Nw1#`tg~^h zWmBS_>5zBSmO+s`8Ct>$AbwB8R+&yZs~wX-6mAxo6~2Yb02}2oZ^Ey_?=PSvln`1{|WJa z8L*eO`u)48ij?Ge?X!wd8k*}_R2B`p`+$|T`<=sp1Xg{nTV*1DI1)%~j(5mvwGYh- zt1@Zz1AI(-Gc(SQ49Du#gZBuux11Er_4jE;sxtTto!5`Ui(l`ATdCo%X12cnihX*y z^h^Y|!!dI%mgAUWoX=fh0B7`3wdngj(p)6Zq8f+}xbPzi6@KhaPrfZB`kGQ-2J>AozFCwB8zu zfTD2>9vu(HrUNhG(oXQqM>J-r1UyiIf8_MV-!rZ*Rg5yyuB3y1XMd!oOpWS5Yv(zi?85FZbP z=9TNJGh%d6SaD<|RP$%9kg-D|I(4i^B9?WkA>#b3qAMcez?yYM<=fLD^Bcra@e;gc6S0@`(KD@ zv5$=1VhQMbxmv>`>DL5dt|^~w6P+%Mn+8pH54p>k9IA*5frJ0(lu;`5>b#rAv2=KG zb`+r4A+Ltrp;3b4_s++}$qjn%*}#Ciye3(vTD9LBNtdF%$Ncn#ed{7TjxVQ-Vr3`= zveS=w{&M@4)n99i_xbLEps@=YWR-klX|V;yTS;qV&cD$JzoHeke><272^&?6*jX_A zo0zxTz$w97(&c?Uut9i;vF@2L8Fo!%Sw7s_R~R{Ma@g?ZKLsRU5T=RVsfm>2>$_`egpB#X$)H_sB_lJf?Saw(G3ExxZOL z=?mHzMj=OoM~a?A8_BClw(`m!g>1F(wlK$r21H8++VO0vdm~Y!^07FU4W);8eRa${#&URSQJ7{8RSXx&;H#7LRE9Cd0`1N}N zkY*J79LxGfyF#*_lbJH&fYP#ZXH+iYt?f7!R20(s+36FzlMR{AwnL|ubmql^kEkS8 ztlH9oo^7*ZGi2>a*$Hk-JqyQqEJC;R(xLu$AXMsB-Vtt`oIo?Ev#?X~`u^KP^B=b- z$!3+5WFs`XZG3w2__T%^3`RdhVOUagIKLbHL-b;aP$fNAPe2w<$P#hm$7XgJmrDtZ zVp~r0D0rmf|7iiJU|M7$PL@-OY8v}Wr!74e1>AwHX3Jh4%Of2kVV3d*LX`l?K+oyc zFv@9HSJ%0UlKN3caK%}ee>SL79#!iecJAdo=ZDt3WOt|gjo^I64Sy|KGL0A#u;4ac zex1RO@w0(XsC8TJRK;qlykky&rm(QMdeY(aeV=_k;$94&LO6NUv}%_hp6H}SqC5wx zqwoy)aA^fFwnm)zd7<-1L9(!Fp<`YNN3;Fl>&CVdJfs!dIIZbe(-`yXwFkfvqKJ$I ztQNArepa#Wq}94n%~N*ait_AbCuB@HdJq+0S7-+ZY&;0Lqdz&)3CiBEi&VqeHjB7? zs?8vrexy%#?0v zkQsb$yzQ&-HCJ--!082}9 zDq~ms>g~<2)c)Pt`X63wS0CzH-fnwUjWvA=N8;;Vv>jWl!tXHnSeb0!b6#a2T4ol~Bz7b%x|HMHJ-#VWd;XbX{; zeS3VIy7%hp1pj+sFBj%!ws{Z59Tm`h2}||nwt z=zf#u_uE=`HJB$Je2Kex^acJxi0nT?M`T+Dqx;qT#ts;AMyfslN&VT701#BsT30?c zrHp^3#^sOqVjsb0C+wPcd8=e(9VWJA-gmorc=fb&TK$ypb7rP;I})#yS?QT(Y^Lx+ zKk0~uHJd|GyCiv)98iK2GDbvLBdv!e#-<@t>WxDFvwPct|57F1{97~eQ=ee`oUyw= zmtR^{7|eyK`@Of$;3Jt{M6aO~A91ibO&L5nIZ38{8}a@DTKn6R()g7pRxXM`j&Pn* zP+)u7)>Fl?xe=Uvf!!?VUE6;yT6eXy%=7@my&Pxq3R)0tQY7hst+p)u^HK^C^U~j- zz`ksxXk^4H^3c>|eV@kSOnX$aByQR*EpGa+4T;Ueb2Ia(iK9n33Am6=tWk9@E9Ce_ z`2L0RBQV>Bsv7H_#kcqD`oiQ#!=E@M*YMMWLB;hDg%;@=Ou=h%4#xm%Yzo*hmZ z{o$cfsDz;>jd;vW`5#Yf46A{sD#BjO%}p?O;+DV*_xh<{^YM{DSS7c3bJ!e`w&vJr58T04C<@^gM(0j>ijT^dc2lHPLGh=Q^Z7*=Cr zSulGNLtgTz)s$St%~uX=gr7k-sG>h$*gu{;oS)2HO;;rCG$RO{4WQvYm0Yw^BL=g2 zrd?~X$rakV(@>QbxpP!kSGP4VAa^p+d3O;KITzNvbXOohz#}Hw69iq5XEp9$q7usH zc^ij8cLs54_n3O>e0PD;yzi|kbhPoZn{tu=fQ5_rwI-&eecLfV z0fwbJCEh7*Z}=_Ir)m)_mg8 zq%vX0M!Hq26;SL-(v{L`=Tu+sL(Vck^HGUl-M#IOA4dE7Z;V`}i7D*pmV?avFE|-{1Q<`rEA8@z>z!6vxI%kY*}8Q+R`-W?@v#9t~RQu`z}Y@k>v4GZlyCua8D@8uRei&~HkQ(6%rbLMd&{IRrVkAnod@&`NSy|TBKDa~wK(|dSG4Yt=)ySGa zdnkYblQtM81S-Ytz?2byX+I;osK7x}bDSUJj5|G8%D3-QwL#^#`x-{m7tMe6GVC%u zdgFPORyC2k4N83K&)NrXIS~0ZDyn%|oJchw_71r>(!--k&(XP&z)ji41w9wEeNtZI zx95uH!hnci+pm3ZkP0o$k1qmN)jQ|BWk28zB^UIAK}&(E z+3uo^j{rzZxc0aujlvLGe0@zhjQTDxzt##pG~FGsZcA2CRryhT#3LETRSfbK9F?_I znbb$&5mkhxeYL!fN9K9H)7;qbr%rh>-vq^17ZlzJ=paPyeLaZQ%qFs{-rzPF}|5pYw3F2tUu|vralqupOsel1Z1{me1KWo#`Q)p@>WC z5wD)LN^Xn%1NI+KWq)m77||sIEHG-aZ2?fPVc{|tW^ZC_Raq{&*Z@kmG%o4pXmnxk z_NbJj-80~c7buX&LVHIhGL(_uJdU{cuF_p&^4_-w{%W{x<+U$3-|h_hC4Wrf@7+$l zpi?s~WI_j=4s~eHVQ2nE+-2E;K4^qBT_=OM_{W5J8#VQo`V#9LTC}St%KU@Zdc6zR zR()hra^;c!e|If{Z0)?~H-f8T=uze1C5s_4xZ8eYkZI);Q@Uo#kGj#Tw?e%qEH}cM zq^3-N*KK8+g?mhc)YgjBRtlXENun&{FM}s|(jlAlp@IceYGCQ>+d$HU`bF4MxuAs^ z<@pi%+c3z;Cet`Ut|V^OK{G;9@@)s+<)>@T^}l&!JY@f8+AD=>ZCicn14;VQg5j9t z+xicU+eq(Q3EXH{3xuDD%!;OxNr`gi^d+Gi272luF+$I6YmFjFv+XkH5&7C-$AWjI zh13d~MWf{si<|KBXwC0A_kLzJIcHUJH#7f}N&QDH{|b+scfMEulSy5cwto4c0M{xs zd9y%hQ_XAZ2H^fHO(=<7I^WjDp|z^I`DCJhcm3Ss_S!5x!%#o5;&5_fxn%C?ZvI}? zMCQauomp+d=*X|pz2AY}Y|sTK^!)d@8hLhJ`dX%O$rR#TDx=>9FvAYyU;x&-!k!8l zymJ40sa~E9xcB9Ms&^&tiiYnBzpIFNU)Ph>DL_~X#zRYR?Bl(Bqp21Mnt~O3dnc9| z5^om7em_Y0{A7n@g(bdsbeC2Y@)u69&vzZcf*(S~vM9+c_%)%c{_btd2E&E`j%=bC z3fwpH_$4)Z#IY4f<+wxN`z<9GowjJ19EYV0i#J5M|C+Q^1tzB4|7mku<63A-ax+sTX*LKf+ZZ+^|mjI>)%p>3~K*>g5i;KV!xVmX;8~E`6?D5US3H30PL&oRf<5 zN@7$M_97&p^Snm*&80#uX+(nh6Hmaa3yT^Ns`Y(~ap$kLj(TTbd^pUfRVQeMIfiX^UE?y^edErF911Ox;HiH>cA_zVKa5= zryZ*^mKN2e&PyXAs_^NzDTgz5#^rAOn9%-bvJQQ^d&k(t)|V!zX&H{ZI4wxo(;zP+ zXtj&>W5eY0CKWf*>Y-RI1WB3{0)(fck|nAq#lpP*s_bMqu?d z1Yk7jcOWDFqSKef=C9YNH3EzeDA5d~NeTFExva_l2>Y&B*4>=8A+y_e)^I-Q!a{IY z!OlVr#3uRV>~uwA_DHQUaR*;3Bp^A;B@bnpmjUwXqn>q3Z~B%D2K&7anVdJn%Cq&8 zot)_^ureI9Ti4B@pL-vCh~+x&_o78$Wq(eVSd~!x@nQn- zo27+;+f`}R)E8efr!T`ujB123s)QE~KN96iWQwlL0%IV9ujz&)rO{3ZAu!{5sR8^1 zq_&u(v{2ksECe3;iH$_szWceR2%3|nI_veK*HtBsOY`&!-N)#5~8%zFphthBozdDo# z+_RWYtrH8gAMMt+hU<3u)(raQ`yf!oTOr zroU3@7_j32euMf7I!U)%3|hURdYt?jyDt%xvax>{d@}f`-3wQ?rx_|| zC9ylbvZB1)$>gX%Kco=HXDkwgN^^}%SB57EkG123?BEUf;KSE|CC!Tl$OK_?9C$4b ziq5vff&CVCu7h4hY^Xlcb@A;P@ggEYvpl+I)VAYgcR-GJo@8K+2EIPUe?&acyCxPT zB^)rKH1-Ov@#U!`>7RZ8@PuDcw2Lz+s($03jD`TUIM9Q#bd@>~IVDSBgPSQ$k@h0u zx6jGG{Q=U}PG*B@a&i0AwI@I2&LyA4Le7@36c5Bl?5K+qZm}XiE|E-FwEL zWu&nH0!u&H0@1W|?0zIA&4DkyRc)#L@GBvVDrNutPs%Ri(Q5Kk%p!^$N%fBlkr?00 zmT1E9ra_oLKBb=X#QcH&{C@k1xh#YjSD}|F*8QQhE_4HJw%7pRnr>N>mrw?BT zO0DSIjo+1142A}j5TA2JH3Mi0+`TT&w-{w9tw^<*ahPTqsR%}=v1-&>T5L~OaUTRnolY%5z`yP6PdaO9&z0m#MO<7)Y6X-0(r2{x5LH3Ca(SRpZZ zyz$~98^NWl2gWJuyGK>@wgtOltUFm?hEY^ScdItE`Kmy$8I>0zWx`hExEjr7v2+BM z{}wg_7c$*xaWny3DP2J$&Z;oamSIz^+XG5ib0&A~3q4J9SK3*DWF@u5U_-Gvc!wIP zt4pH4_UzGauT=isGEdLvOo0MMn@r$|i-TUG^eGfw^$o{mgBgjj9I^b0MptCKW?g7> zAe|)D`ZPC+H72;n{B_`!M!s!wSa#h=SI+XhW0lO;djiw;9VXVXcAko_?(FOZ0)3nP z)R!bvWP7BHU~?f5$hF{0u_p(PXY9`Fjz+P}vA^_058AHwSe+&jLu?hTy}Q|BIp`qM zd8#^7?Lg*GZwKaUCo^6U_7d2yv5OeP!$u|o*aVfcZW>cL95l@-rKs958W4+Pq#oKL zq6a2Q)%yQCH2vt_tY0h%dQsGbAa9-nV|oZm8+uy~olcKQ>z#hC#yd}BAiOeBcXK@N zr4H6?o%f8Sm5TX12SQ#2U5Gmms#gF0zNW_$4^rlQbrT0&>%+4m#zj zJ80m!eX{N&_bZ!`?mxBI`ZtnLui6j?kA%qUcYP)(T;4=_j8eC4g2cI2qTKm0(Zgl& zQg@C|+^6yQ{{%5t>+X97^p9+PzV$H3?(0Z_#_(DHtoD zZM`K8uCDU#WRqq~l?c=+EU2@(#0B%RT9uLwjv)tZpaxQQUYta&MVOb9&iX^hqhHjJ3hVeMO%WRz;zB#QDR14+)Pr^7YMv@QCxie^Rup7xm!ycVWH+u=%d)TwIwgVSi&jq0+k$f*|nc3|jl?=RNgo)Rk)K z(NpjrqK83-m8{1?o=Ry6SEpM2&Zs=n9b}x8Y*;STWF@`wQXl9(V)|~`oh!8~mCXiJ^bt-@+WojQgD`j#RsEY!$0xAzf#L`8n1FVmW^tlmp zIxCG7TF64)-AM=VSQpV&<{Lm20d6k&MJc9dRequlOuifce$au2gS`DLS8piFOOM%8 zDNLdnR5DaJ&zg>UAN48pwvzsnAA@i8i<1;^N z89nxvQqO9TyQu$1*srLyOq#a@0%AM0ILa69$*6%_DKPYm+#%SLy*vQkNP6f#t@u|< zm%f9*Aj9$FF~?Kw;P(^btK`kiB;R4|qT`GbcCZ`72=Ts&Y;9xxrJUB<rvZF2l|Fp$#l!Ff1GhlOP_-~UArv8MKUtUFBlQo zRGEi$x$Y6zCQA8+BD=J;F8o&mo2#`2qB~uRtEJ1r%JmmPUTn3aM$hadE&+xiO4lw)>M=^xlDt z*Xc}{+VXImF#^zrni$ET&s1|>dgoI_k6HnEiWjdHar79#e3gCnv}j4!O*AXkT0=9c ziQ4# z>V_l3(sRuQ$SLV&wk+~wclS2njfR=-KQSd-C)uGj^rFYsMPE^hPKQ!ffHge?olSx* z%8B4?VSBjKPNf*lR@I)+9run%Qf-)>n=`L!>dBV`5oz93`U28K&j%vbx!)=O%Q7MV({nU)FP%`6g1@#O=^ovb3{LY*>zf#(U13zug8yfm9RGj_9Q89K-hf^*8?Wcc~a<1GGs7-Ace+Lbm25Ra5Ol-Vn;Fn~M%+_C4J8SE}u< zzuzq-$@up)ftX>j*_oPqNN%Bra=sYo8e=56(QIrP?N?CD?HzL6EzN0h!kXK;)OB?; zI_R$|dED=>`7linWQsn49N8B%$1PNhEy*qixC|Vy<72;OD?i0?;82J# zWFH)+rC0VyDP0EWgdE~?=?TUfQyL1$dX@0JPoK^sW?PJ1FseUtI0#LnVPR;9<19yd z$-q=o2q%W4L>=97k2Tbi=e@<5=``YX^&h%eP}JLZ)Xb$8k@TSUkwza650BlIKSg6P zG55~$5u1qI4R7x>nxEmpVww6Vt507co&e{UF8F-Fe)9B-Z>*p7 zMeNOpZUBB+0eD}&!#m8&%VeSN4$4mZXD;oc{*Y=V1jw{CsaJWH{&kg5Uz&oX!-EVm zH(t>|J7}hZmmma6>BPp>fYQGasgztk>V2TwgaK z9Sys`a8Z>QS{ZGnE<+?EHl6EgE0~{v(f0QF)XRz!R+ODK6H#4E+WZxg=|32+g(Sw# zXyknPrLW$9%xKZN7wY1&X#I}v1U-fH5!GdM{ONarFqQOpvpb!-_s>B2L+)MHyR5aK zs0)OOshc29xos`GIbW&_`{CydS;A!>jo@Pn#Yj>r*-=3r{;k7j1w3L*R;)uNgW? z*nAMCl?&4d(N+&RgZ;hkF1b&Y-J2YNo+fKD5DMA-P^7%JwWr)*UN3`Lt1#J{x&+dxh)TLU1&NJ>Kdi9X@hT8|3uf)Bt5K_ct(e+|!R7o4=E+~4B7 zvQp7#F}Qbiu;_7XKF?KTBF}psj}bafj9r}#Q0LhkrM`WOg|PA>kmHR|GL=i`zp>Ru zE9P@e{`j`8pY#Pnl0N8AGrvIYiwC8OkjgShOI{BW>9-7Mx|xY%hG>a0Zqqb~KDE^M zYP}BD2w?{ivnsDkS)8%WFh4Li_hG@if>sE7Jsl5&wZv546O~sTqHwcj8`)F{JrFno z3eq}gKHca`_tUx8%(i|?DaAN?gj)$pTjCC;Ksi5w9#GleBL3nB&#}X_cPOxiv8zv8 zt*YuVsDu&%H)PsKc@EK}IhEgRzyCGcItuzN9E!L*Ir)rqJW__=BWCp)zjz)&Ub+Ju zSH0r)Qm0mj6@Lu-QhFyJFZLsg9_n#wB6Hx<;pyhg(b-_Ff0U)5(Xd69mOJnb3)|Sl zEi5?dv__n>S+MVGQ{7FZ#ojxV;3pW4ijQ5wM$}8$K>fjsOc~Vb*6NOE6tWGO-pkv* z+S3eox|+xH|Fi(sm=KftfH+xnNq1(@WsG2AcYBqKlzehx;+gDRszo?Yff|sBV7oli z{W8P}j{3m6sK(kmtvQ0TMztwArxk&huPQ~yr?9qcjwOm)=a18aBHq2av2YU_DAGHP zaA?XD^K*E^5bSHW^>BK)5BIy{-&r@Z)(_B50X>AjHr1UrZf-yI8D+3C8!CDGxVucZ z`F53^*ipJqyoK_iWC755%0c&X&!ypq)yjKGSm>t)UPsp2J}XjV`v%;7LIpgz+Mci8 z`*h#YT8V0sN2%nY$HBi2c6ZVEe-dq%h*Ztk=dHE1*IkF$H?T4(PrSW>T4YQULBn7P<4b!)lz9sR88n`NY?TQQa@Ws*8!w=Q?S8O+MWv`3>&^dO{ zIU33!EjBX^iS1o7>8f+B;V(l&*UxwN=`d4MSY#bC`H3ECRXR)B+zzi{HiPZflI5_!EPy;x|gFm+ye7jkMjUG(acHJRlXF{?;|=k4 z{Vm3ptF;4`S+qfuwd90Hr7#V8%L?gb)M;-GPt2|xP2QEq?TayeAEx?nTCz(_wJk#2 z`z?gGs2jwb#4spS#@5Cr<;qJeT#M`eIh$(WG-B}7`=xL+So>#HjH1+RFj5=vY=h=!RS-#h)=nBr~FC;tkQ~}^lUfjzx0}Q zTf5xK^w?J!HAkbpt#B3fEr+|(KHvSiGm02n%~|hK0qHHz=2DNSmS=M*1vr_wm~1dJ zChTi7>!+U->M1*ihLZ9_LYlVx{rw$YdHM*tT66Gr^}2`XA8=n4M9q#Rl&q^J>85Ov88#qA`LIwnaKI!E> zn7(Cr!!bg$^7&U`m)r|U%NFMRKJ0kycdC}P(~C>bTN68%mg#P4nWJLb1Kx)XCxtsq z1XWIzOTL4heSHOoq+vAaag@VrdQf(M;j7=vV6n^>grpDB_iu3H!bEauPr|v$De;XI zvmIh~lf|I7s;X)#RYu_F=pI*V?du-Fsv3A>6~<0fIDk=D>a}&?vd{|)$_?xW;i%N4 z5|%BQu=;`U{u=kBBJ4NbEs)65JFFQbx$&LhrS4;FSs77>x_NlkV1Lir)6-M%wGUIF zkl@zy%a31WK;8uDe{(?bb0%4Y+n6eDsy>^Gt`U|>PuMOSJZm6nZ5a0$W6YLEjN_d;hpU|c1O?{{tCjR>H1E1Ob+X>^&Yg*c`fYTdR-G43C|%gLc1bg8RJ!p5htB3))-X#&&qsi~>r zalh$s;FW4C=@sbLsYg?}(#zUvM3hx9Ms1lJaQ<66m%dRc9S#~fE{xJuRlb(LRwBl+FwEh){t(`}q}^AEZ++xRJA!Qo!1n z`@TYEPGjr4Q2MgV7*X$t_eGbnN?>46@z~htSz~qeKAD>K+HtTo+pOo&E?J;iVVcwj zHZC%h)~Su*4ib{PEH`H-rVsVv`a}1J4#61iC_Rf?Ux~sV|4EZFFLXH4+1uZnrnQ)P z!%9)|?^;=CWtKj`{qB1{*unskS*MV-E{vH4z4QjVQ#!m}{djbXj>f%vFW%R-jXE9D zKpl%7ZPbITAkiD80DM5C=37rlT|m3$R55(Wo)K^Lkm8WB^OW1~pfQoNymV9RrK{3P z<75yc!E7DMK4U+&bA!+vSPoS}z7wm>>iEgHIz+xmbLw!Fd_xhdr`A)&h8al=3k+2G z^yvtu8GK0NIwUf6JlUGi+^^J9@n($EX9B-WD&MtH4xY)AT4W^)3Z>-Tuv?RT8;0~EF zQRn^UO*hK_I?LU?k`BU)%atWyf~!a1++_WGfk5{RL5;qG3dH1|6z;>X9AwyExk-PRO{zk$uo^u_S%aNOGd;9yhTUfnqm=6I}u8_RDC zIe1lCQ)9W7<`NN|4eq!63hQgVd$4EV{oHT)51mdkY4J9Kt}mt{JVYZgXSFb3u2pdBsVp>&jWxl5S(|PTVz}@RN7_vZL3r=+v5P zf*+&~rg3##z^!4RD^V<8hLGX3(e?3ZUfRu?i7TO zOeiWzvg(zY>~gYKrOZ>(Ar6vN_Bl9?Eu>*(@03KwF>{=AtdMc6WE|rh`&fr#9D9DB z-rw8jm-7cauj^db<36wDn$~1zRb-R|@F(Q~{-kR&X4kd%V&SDTNe|fv${PvqVAx!o zNMAuX!pJB)m0wU08APHYRaX6$67NgeJ*gI;T^?!>OjJk? zaB_MSkApUNGT!Zo74tYTK1(T#2X$6wwsVh0%QjCWkWI9KxFVib($Qv$C{jV&vANl|NW@oe)K zkA*g1%gKO99d3Jke;UsV4{{2YYDuO+<9ojag@CP+Ck-bo==1nNj$GS7KDyzB6?AWB zr1#5Iy}AlB+5gJ+EmOQyVw*BKa;RWBCYSjevn6m*$FAIXas5TkQWp5k;(xx027i>v zj9`32fE-sv>CWgi@FM7rxY#HbD`+SU#oh)31&i4^ z<2cg}g}lOBV}7Q$m5hmq73t&TU$DpH9C{K2m(HN4`4zM`B0fZBDB%IALA?&CB{IRpQCxgf3Doh-&>qA?jL4NR*O)n4WXVy9&c5+u!j{#*G zFZlIvE!~6&Kb`FR0I2k;=skd%JfuAC=^@#{F|{fJ?X~K6R26;R_}a}5Y38n%Ld8G% zd@pgO6UcK@8j-QCmlEHJHxPK1@JcsHZ}*9vxdwc@SlAcmwI^@e5&2yj>5t0=kMxw@ zny&A}mVPJDFU84I!(dJtRAqZgzTA+}r#o$u*qZr7pDC8gC!-zi@unnk%1CHBJ%$Qd zef66JHT~liVTsz_+y;d$J9O@h#-wZcjcmyOdC{9|pjFC1^RiG8cMx2yEviAzeKH@_ z34s#TO`7|Un3_y1Ev^i%EeB{XVUEpE1*kUY1&BY#9f zBxjJJdhl_gEGzNru@ZGkf=M!QY`!~kp13+ekM}&3q1)J6A(0kWy1O0O^*c|F*PC&; zkd3tH=xF=Q>ehJnOn8$jJ?$(xax{Iq=X9s4p6*n`|A3v^_^WZ1mF)E@Wf)da8^+k& zoG|l>3&gU|ck<58K7~FZ_ny-G@!0G`%vq`(RQdZ({OhVZe*jbIW~qdhH=PIjC|D0xoA7EVO>qmV{Xf~6KPnYgJI3O zk(hxcXE4mgM;!I#&aU7<9Rrb^k$ezT@0n3$prvW@nVb=^C2^ihFS*IDFnqrGsa;@w z{`S|z$}}@^>jzy&H~{p37&h%QUB_?iPE#D*vF(jrOz4Guq zd9=JGauNLr*rK~jr?6}Pg)EcL2Xjll0+U)((J_1fz%?udH9hO=ac$3L7h?7X)Uw^f}YLoJiMcJ6J_kwScui@v4VqHKDwWUyZX zk4)V1`F*)#pL_#$bdWVW|K&u<)cL8}J|{;@q>ODxAI2b|b_&-LKW04ZO<9N-RZ;bv zZXx&m{vEtXUBvYD4FwgJ)CI@{ za{HQ#Uta3&{9)=k!QYi3pkYC6iy?%;u;oBo_GcsY0N?*VsjpFvW;+tvI+QQfUmW6G zk;#cVV0?4-E?xwA+q8p`x^^x5DJEJy*XW-9OK`7h)T2eMRc~SB*r;D^b@{qYkPlTx zXuLkC8e3le@vfp&BF>Y{xtI`lgJ z8}qhpXxKX#PtVvS#PCn80Julq>2*9v2)~Zw1CMJU4|n&<`_@lLgnsYJx;h$z?RVY3 zW1%K9S~|$&y1L@1bk6xax8>~rzFd(T?<5rrzsvgj;X}vlDexqBLgJkX?vKv+XaIB; z%>j(c8haxP5_`^9oq=t{Ntcl|se--C8~l$_#78B%SZx0dc3~(_WOug3G%|oUwQuJN={XG;}2#ewK2$d z{HEhb8FTT8@exuMY1FKtp`zLo;pR3sjsv-8H)n+0#Y--_W6xKvN2{HbB821IoM4de){@kj zJBr{zotX|(37)HM(iN#2igbG$6{T^y;u?vq+=y#ZYp(!IxfdIFGBc>lzI(-q886j( zRmRrwR`PuXxw&6oGkJ&om6fq#01S~+RQ9Xv8>=Ca`j1R>{SR0*kr3|0{PJ%Y*lTjf zn0x{1z0?Uy7);c+Ip+b4dWifWq5+?CflbdoE{aF9Knb0fVH)phuYEU!|ICe}_;oj` zGLr@#)beL?C$fL^`EY6VEr!qen(E1=h&pb2OHo-DBQA(vAN(gS+tq=_t*;1BSe@GWpL=`0K#KJ{epEqwpx5WyH z8Os4pinowE)Dq3TuOS$9=Lja3?Yf+o3fpR)lVGZFF#LBd6CN?yP>-#vqy+_fugK8! z*)@85do@n(+`Svo{|W|b@=c#Ld`S$FKiHRkcn>PR10Cvowy{tzc<}rbkV~Cn^G?xE zeD~P{2v_b2iwm^`eRTu*gvpW13Ph0!#@b59%3@-%#@Z4M^1~XwxP0`yaVp|WTA+W8 z`YOZF-T3#6ljaQhzyqDH=ar+C+%Mwmu(N-Tka?*bWg~wdWEJk(x5Q68ysgAlE0>*_ zHryZYNN-vgL%}vxoh&xn3CNzPg%X(|jI}JuOcF;05{NX! z8S_mK_4H7IpY4pKUxO#9Ss6H-ti}nIHZb5=Fv~W>Hvjteo-&aj^4sEWB7`0pzR~=~ z*R!FIVWJ!WrNM0=kkyN-M#0-27r;G%zHj!f2QlIg8>|AeH)xeo0nB5K_qQ)6OAt$XCV&%U?0ecd6^~R* zstt|}cP}vS33qq)aCZEMZr-P9jdWMn%ZL+Z-Ay&A!teD5VYCM<|EeyJicWVp+I->B z?*zsx1r>iDy}iw)fBzVkwL#w25yPpu z-?lz8f9$HXdo{lqyMFrV0lm)w(5E6DMr&rALf!u{urQMaQ&qq{%Rp10nQnZYXA@$T zE3~g8WxM`&{qMfdpJ$qNZh}}2_)b{BLCoa?It%x_&68>s6BGWM#HY3-vf;V)K zQeEkwDJ?uj)@s-C;t~f@o=eW}9i?r&#>l_n`1XB$mi_|ApY-`e8sqaW3zK%5qU_jE ztX!|7Jqt5-^}5+@lYz8|K*_W(8O8u$$Rsud%OE!wLJzGhE!$1c7mPhzDxTNISRcDg zfUPd-XA45O6h{%E2VFA(W}t-E1PHOeXB$` zq$7FA0k{jUdhV#s^7;@*IsYV)9*go48x-DOe31mFX5t=^!n`O3WDa&EEpV!hiL?Dsl|Hpaxw@QWc!SBdjS zO$Ah-r?WGS`TF4$Ue|%5cLsX)&WzuUjtp_KbgCoRO6&)*diUfxZKeKY4|A8nFD=}Y`WD^lvCRh4OMPt$wX!W z51m~E1loK`32N?4!!rJczF;eUI}Qn0M2#v7(Kr0WD|OQ7^Q5 zEk^@IYW0+QwVXMuqu#n@-}FoceX%x|>qQb4_NsP&-cph&Uth1`6``f-lTX!!AxrJiPs&B_JQTak(4wjMU!3-<5u%p(J**k9% zg;atJ4tV5dfk&8f*vO7`&l(`UwCf??KnMZ zB&)I35SQ*cK`*6+;Sxd#ilNxtEvLG1x6jSVS2?D1j@{4UA2+-mp;%WP`qZhYXlHJI zPB1Xw~rC;@V)b9dHizZ?58NOG#f@+NjWhK z+~(i+t!B<_u>YNexZ!J+rXut(?~v7om2JED;CCSeMp*3ql&bK4E!+KbZQV z4q!LS`T!A(H|05Od06g)SiWC&*!o*-H{}xb)J{WMjxwXc%4E8QAOi$pCGf{m%OZwV zR)$m>T+8^Zox2@+RXS(_Cr{Pc*0|=ix+BtOAVoOhi;>dCjMQ7n->dvIbeX0nGHNmk zP1&3FQ7nJq6ryQVq*OprX|a6AK1bF>QRc=q_^*0Qm;!G@%w@#!Yb((oHb-)H93WOj zrp8{?l$WAVH@H+HrWlV^9*OscBF8gyC%Aci$7(MxuCMH$Y324?#MZN+kI~M~l;A82 zt6GqTO6OB2A-PyUZPnu1@ir=pD^spz4*%1TNxe&iJ0Gb|@R z(dgK`zL;E=p-)+JdbxW7=KXsbIX`(*$70a_wP9Y?VqQ170%4mAauN|fGjoP}hGhP% zF4aVc_$)ED$%EI)`H{E4U!NV*p9PXm&WB>qrz^GmM2g?|J{EOio`391KF*q1oUt3~ z#SP(J&XtJIOsFJE-p7`HlmDa2xv03@G9t@_W%iKvd`Y0)E4T`$@rN}puNTs*Gj5h? zQyFVBUHARk>lBv#@0W^wSu5f1`T0(vI>61XM>qh70PSrZ2ezciG?oOu_P>D?m$^-Zre^q` z?9J!`Svk*Hz=!5aCeAE@PGb9H$+xv1OA`K`JSk3;@Bo!s^$ zyRPV%mFgGUQj+rVi8DPfc<B&(N7m3+N?t+K>D z5A4Rhk@?i^cL2bF2zA{|1obXNR<>sT$ zaMfeB@bJeIWixk1`05c}p)H>y0;hLp%Pn+t7*B{JBin1ko{ zz-xPFtUx!!3H{RWb;aI7_Ideyy4gjA747=KaeRD3UhfpWy}i4s94D@r2TIzCPcN~a zYt3%L))_@hSzB9k$p&w(z1+CK#Z@18U(^SB(wII#uY-9T;63MUV)!4Q3;ZP%wfsrg zK|kKKU{+=l8x)L0t_Q0d7;9KqnVSbt+Nw-A6TT&2uukXyhS>;_=6}lI+ zJUlq{`?to;uERIFjszvTzjW1dtP`-Mn#C>s$RY2Sx|Tmem(SthlUCot58jvxY(Zm# zFMuL7$H&IlBM#+>LwA3VdHyssveDR`b^GH&NkT1h5LvXwc=@lV(pLY55c!<`zKY0E z4WoW5@>Ag15;|XR;o4^Z219LA)nS`?pxIlR0vYdiAeYav0Aym|6GBoQuTw^UZ`)Yp z8QBf1GjoB-gJQjrBDFz8Df=8@l%MhX z2AGI7%iBsxw7YNB5^ANm)|8~)UBX3#Sn|CY$v?UJK-_)n&m}_amED-r8AGKWv;Gg5 zFYaKTLfhbo;2c2_aVtJ8@VZAD#BldA* z^!y?>aY$hYY+4(|=U1=OIqp;V9%qBfa_o{6pEI-_0e6&&qTNoIK-)8y zjEx9ecPLoXuL=){A?|6~faGiVi52_NpLHs|Bn8rLNL!2LeO9KH0zbJIbPkE_4JpEU zt#xxS=plz%;EYV6Gmb|`(~1Yat@RYcBI0OZijUBv=$8zrWmE<_P_g^f7y8O$b#d8V zy0L8Ir9cxeHAHMyc1pcYCcJm3pHc-`#*|0qs4~Lg0Zlday}Ma!-5XA;PdHY9LcES< z7EZba8DWKkZN-Ebp{|LSS{T(&8z@#fOb>dszzdoiN8^oD7)UvP&Zw)nq~zH9rRRF7 zc*J(VesjLWuzhZ&iH&LmjDpP;Mf6WNr+WvcbxfqHN=IzSUvU4CnDQGDz7h61##07> z<`JjRoChsub-$`H)M7FxC-Xq!Ei$;_gG6t99Y&<@nH1rllYoVV^#w&z-(6(D^zOp& z@SoogXM8xh>VKhybaV?@SUfM)o7%tZwH)|$vnVSVa^$vDG0xOZ3KVF`;?*45TL182 zc65ucV`U7Tu)hA`dqabDj_UXL1M{KIrO)#>(j3z<&huJ#;qcO;)P8|MghJBI8n@DI zbWbUt4s|tuYk1v&7j%F})h+LDsy~bfaF@b%C6RzpZq?z)HhG)BfUV!}Ba+T#C*!b$ zBNYPuqSWnj9UMH?k3dx_w-Qb9gKj@zZgs&0?@XjlHebKEyy5>|GI)FQr?7wS+aPeT zDR}(NHxLqXFU+UH-9oF0U(9;EPoS&P2IYY}?|+-2F`tfnqNJvBKp5HE+o1_LIvBQk zN0~j-RLb-63;2qBn08#`_DL6y`d?xP!`*JhGK`2acsJosT zhU9zy)E0k0H}?!v@~;H&)A4LGxh)HrC3~HVJs)#EI*MON;97mZ)16~xfs+1(zvrjv zvZ`|>?|KqB%AWKco?G5ag;nYWjcbMOsZ&E;@Ep>e*;)6HY`;3(g+a3G2*BAW{hRNV z6e$K~4u$2$l1=H+ZamM26`Vlx%Z1ZOf`>UZ1nH;FQV<8R);%g-xoQaW5AUUAWf&%>ByaoB7%T)XC(chW$7J~J$DF0ZNcSVslC^c-qO(Y(*A7tY z7v{$&<8{F&Xfm0Mi5@Hwarp+O62y#?V4QdaJvkjog0vUec5shEivXugSuzjeveeqq z3*d|H_`A;}0bjK3bTl@@3pRQ~347A-DH{fIXgy#aRyr@xBQKuMW(2gD`FnWS6!cwH zQdUA%Hps2XKuJ)ZugS)?$Wo;gnMZXLFPFfpgk9L;-}ElLdgDCNszlPC?nhe^9R8{ySoiwQ4P4sO`Zfz*Q00}gn8JfbD{f~&hJBl;J#}vQP8uk-oc(W_ zr2m%R-irJm(iis$t8t}+w)0xZ8!9;Om)1~d=!@gW6=fRqiNS}v7s>w|M5u??kDqQS z=R1w<#C&1uX-(y+tiUy{Ap73Gh#}X%&BmfFLO?RyDpwBdUHzTe*Jm<}Qua1=2ZSTdQ+pk~yI<|> zsrv?)CH@J(L{HGTF5u>>+n~Qib}fdW^pw8xt6Y#pPh<_l7|8-^YNR@~tfRJ5w==)s zG29)o`l|=kLjxzUlo17cP5IL|rEtVc{I&W(?W78VKX#s*Edbj-3% zcgQfdv(96RDbL#bG;_K|%OYkr|>CB*#94}X)czzc43csEt&J61SL zdI%?f1WYJr3+)fo!#(2(6gq6yTy1Em`W6ltKbp|zTjF|Uy7aGX=X+QOAMKmUpO?*# z7sRqi5w#BtEOOLk#e3uRukCEbbz*x6j-V~Sspz+l>T$Ig%%0P$z!`OX6Dg23MY{QT zt-7+ZgPeM~wHb^;Q6wenwa4|8?qIgE)pDPXzhV4D0fx1ZQ(csCeABn1kKyj^zqbn7@0eey|MT!Cg4pg$^qyhd>2_@u)-Rq&P zJM~10cxQL{lIc1Q<9*|i)Wna4cxoH6!la~aLnH5NLAvNizsE2op?21PhrL$Teo`W1 zjt8#U&^iOT2}<3kvB65sv(GSjp~id3epLe>5 zq1C*po!U@s>2>+x1v{wm#A65WdEjZGwju%6aUY*K*{kcce;ari+9z7{PHOu=YKf!;&e)m0dBjtxeI{p?m~s8Bv^WR#(=sC zc2Sz+&LKwMgj_{@wX_^Y7bGLRyo`(tGOzLpG!Q2yc3BJ8g%+D)V$4%ahes0L@!_0o zG5>Ueh`vVN8w0EVTqsfwwrIQZ{O9lJBfp1+yUq7nKXRJ@IvIkgmhy_~*&ab@lzpwX z_!Nm5W*dlXau4hW%-)6{T*dei4di0YQ}!ai$3+gT6~wLn?5M8&yo$97|9gqxIqfH& zivd|@dxrSDY!I=bmX<2rYVtT|WU|J|4?+LTO`hMe)~L=r=n2KtNo()jT1slrsz9g6 zSiiUJk$(-27r98xKG|j?)01(9ipcbv%>p(9^qAt?>6%K%KJ}U+kvxr?K*A}wyGQ2G z)yM64CI2VFWOt`2`UcNEG-{dKoS@HDYZ{6nYC99olKtImJevWrj&Lg05&eZqRbS-b z8T=z)FU8#1LiTdR$&WRD1YGfHLNoZ?U{^{0m8&x%=d%gS3+?TT7li{T&UcP^l&$g? znqnALSSL0##{r}URy*DL(IGqU%N+H+KvcZ2rAL9F{g_9v*S|vK!bqok7*;M0`(CW3>{hBXG4as z)&1%V8(os+hX1U(zPXGEPYK1Cc5){++fe;R%-)M8G24!KYb+iYBce4X4yCENE(Z*8 zV@HMTDwQSu_E|PTC&zWON^g=&=?2UNU3-JGE1*A9^LvZyQ);iShcHk%YB3#>3J;(Y zA{!NZ+DZJH^&fU<`Q6-X&Z_%DF0ARR52gc0UHr~ z>}*mh9G{AoaI#LEVL8((`moLY{JG5&xFcdGBBr{UH3TUGCD>OS-PAZ!xrq?SBSJbj zFXCB0FsaK2Zf~}~nsI4on__)Hfc$1jn z@I#k>6JL!d(l6q7#u;Xkfx)-rbnr!^6|KyG!PhK@H{Vx6-{qSPKgBALeIMsYT$}-fxWe!o5|ZjB`Io^(v2!E}|Z7J9OqJCFvyW zabFjFHoB9#l1g0!;zJ!01v4r1WWtl&%wPCL?0Db!%gQ1Zw#1dPcbclpZ{2X!O5V70 zM19+Kq`~5Co=Y-=g}PQ=p`dPY<~t+5`k7WdwU;s(uzTkiF-7kV7%#JIRJCL+k1^ES zqE>!G;#O#`P;_%|m3pj1NPjfR-9+1TPZ%aKxk}$fv3rGJxq!DEE19$ckCWz`#mR~n z^MD6O{6Qn5-h@De&0X$I>v~_OG%6$vC#>U z+WI*n?@s`cQogp^-OWYy#RSn;7KGlV9Q;J|W-$Rt8nQWow$*`1$P-~+zm->e4iBA- zVIAKl{+oUWSW>frFMZ;>qiW?@r78J8rfsy-7{!h=?JPHvV^^6PiFxIikNqwD+3JFTs&=*Hj4AP_bLiI$4>+428%Ma>>7wTx}s0@3|h`{h1ad6P{)xhLU$1y}%7gcn=-j6R!&8boIi7N!N>-m%O$r-QqZKP=~ukT|Gb_488vr9V<@1Lu=aDsN37iOX>ge zmJgh=CN=jr_LWWR%A3n=z?!7J`6a4)T zf|eGR?~%sG<=%2YI89-pE(vubPr825Tn6ug#wxI-KUk;b?Q094BcGV>#C)xQbX(kS zw-eX^?Cc_tQmC=CWldbB8bX?vpC8a@Kgrv7#ztJK?dV>&ZTHS*pR=dfQ5?#wn2-_U zw$8>$YsS~^#eGo5hijNP*FI>`=+d^QQpUoCllqVSU`96&^#hZw=n$xEWLWJc7QC>)ZbFmOdVAW$^6y9 zO8(;D82sl~Q2N0k^2#b>sJqdy(NyMy{q*)erni^^qhxm6eHp$nv3GQlQ%GvK!P)neIOL}Qo#QWN*hIk)4374G36HGkn1~Kb?fMY+1<;Uk&()_oeA62hmhP- zpzwZScQ-FIH1rGB-(Lpd?Ufz+LjC<#P4uE95-eB@5qt}`AP^(n7SBRja^^21_$Eg6 zu51J1^GIb!cLrMcV1J!UEI!E2mgjGk&1WsllVfcZ1;+IPFgZf;M=J_Rom9wv`;-f1 zDi!Vzae3|%;h}v+jM3~&#aV7P0o2hZzmwQoU&s8=btB=%8JmX)1Y{p5uBThI8Y2WJ zZU^7zY4??~2j_LxZvliZ;R7vM@rG>AcDYm|E69HDnI^$!wz=qo?wPomz1O<_|GQ05ykVz2p`_~>PS|!8%fk1ooDAg>8Fx48XaN`FkP zt|`at*}(&6eos#yHvcsKl3h|#TI$xU*2sXSU{SK!VX#|sXH`LYf0HfnSho|;$Dx+N zxGT|MD|FzWty9|_(WcHR`ZTxT6#AB#gAEUr-MJxPK5XcMF^a?Jyuk<~n|Uwc=@)jF zcmJI~OHosn^L*pvyQ>%MK5^Igm$mz<(-%$0(%xdptbvfH*$88VmfAuql_2gOe>LV{ z4f>i=4JadSzS}!u^F3L{)Wc1d0SS!+0|O(`g3fI0YrgB8juxfQ>(6`FxRK=B3QhOb z?#P^*U8)vruXaN>e3g4QU4O$5PIPNf*!i5oQhM0idt)C% zJ+Th(X@pT>`X{}p>RcPDC|^P-fB3z>l}+a+z49ki)-&E<&P`7;VX{h7QzXgckzpE} z@0rA4OB2DoF~ zU#Nx#7-E%6jPyR>kQ*7As*a&pG#+JJSwL}UfH$WsH#HTdEvD^^QTX_Dl@;vyeV(43 z@G*sTO)z7)S`kdZlPy-s#BPLj%9xGV5jAMPTUFGz=wPx9Siw{Dn|H`kySN^o%lx9O z(F&j=e|9`G*cJW!w)+0H$uZAY2te%URN++^uivuQUrOdY9}~sF$(eOk;2L(EuyAx! znVA3ioGbtQUwf5On1J-;?nKxUrqGN2y0OZ~dwI01CE;W-bA~7|uB*o7mzUqEov+9~Qgj5@*IqTDHv2udsIh{97$ZiKiky`-n7>z7GZ#PG zGH7sjJ8Q;jsiZj9Ga!{!D3&np?akY$ecbRJjRu9zM+Cs0F8miRkxAJi)CpO`)m&59 zOqYJFV4aJgPh}XQA87g~_|TPohk9u?`Cc}=JKQ=!$>|}~RzHu;bA9m4Q^o0~EJwSr z(>GD?Gjq>6|8zEqHwJ8b(dnGAYf%$mQ!4#3b>nK+SKSAo>|cTbK2sywO^+1f7<<`4 z#-Y_In^`wRhCVK#>E~?~eX>8*2NQR|BRk(HxN^%!<}$TyL{;9Qh^*d$%a%jt*H*^s za2=KT#(#V=d|Q`}^BC2#b&b-1Q-=bZNXT~y-lG?xgeKHgrkXL#9adCV)*aEWM)9;) zA9n)HkAVL7A|0A;k=~}k65<{;X@{aLHBp29c?TlS+r+SlhQYY>1sPxs{OLpvmBpRE z`R?Oq$=-aHmNG9US*lL+ZEHW;^kc3JhcT!BMv`h^JVOGqLN=t0n~!grboMd2>b6#2 zZZFY8p;i=oYI7M;#VgUj)qQ<9qYYxBt(JtGh^O}1v!HF-!rASwJi@;^OZHbpg8E~m zNqwI@C*2|mkh%;lj0>glyH}TUYx2$x=XKh?+5g<(oFN-C;t^+d0_b$mDc&S;!){9g z?SdOMNI;geF|i7VexL30Ne#y@;BJGd8w(*4gRm`to(Jz`&UfRpL;-MxbBJJfp~8 z#S4N!7PrkoBFaRf&HeGTC>W);hu1T;MOW<4{;OU7KGE;+)OHA1`cVr@F<|L`oi6=m zYg=c`6{kK1e}JR?W+1l{Uw;u_?iS2}ADe7NJs!9GMWlywS#W^1QR+42#s&tN@4f}( z<>#;Z8C$PrZC6*n^lCN75$$f6fVS^^&fp}AB$2XpO!`f@HGGz9 zH1~ivN`=||WhUd7tVTz+F4ZPUkYQXfJkmT0S+ktx_5}__49Ewc9Ip7({~{(fiH2GZ z_K@uv&6tcB=XP5V5k8^58TJ;9{Ty$c&fyBuu5=A@WBL}jYNlJR1{m#Uc%Yy$R_*+I868k9+p218DRume2I%+(} z54r+Lnn-tR<9`d3HnHUh+0WVIg0Ce-Lvz;UFCctCJK?oYH>h)ScXPpRb@qirofWV|^UO5OocWSU<8*e8b7nYDaD)CmHl?Zmt9;oLu|*90rSX zes8#ROx3zK>MV=0Y?d}yhzK>;+@khS4|{rsbcs9G$;rvoUK#27Jyiu7eHbX-tnn@4 zkpSXV2XhlM{%2xJTfC$fp~M)q9aTQtZSmal=4r~K5?K3T;nN#?>2wCxPwAkx9~Hx1 z$vC`PT{VUdFXE}%O50i3s)U1Lm^APrd_f_=3NbpgvFJWD;@~`I#r*z|)vcgyY*gi; zXO8q{d_ijlhue+y3`WxLaQ7cAU=+;))S6kIWmHk<@J31HI2YUj7;bNFb-0gXlMIXu zKI$21dXQA^R@M|HX4E^ME$fzgb48!ZP>Ykv1*;tR*cy1NAp(6yqmxr5X0ILSM`UW2 z)l}Wic~B$2{@Yn}D9Hnm+9mw+Jo|`3Tog1~;h`mTWb7%o8EJ@*2_{b7l%2ePZ$AHn z+UmvjZx%bN%wJLRD7`ZA#t@^%hZSXI*WZXveW2ZwNHyV|v%ZXs{XZ{&V!DT{e~6s6 zJ$?L21ffu~r|YOTCz|I2TbRAomvIyeY^J2%?3fyZ0&#?iKN z*)TK-J&fVnoHoGT1GhnhE2x@S{XSC!P|;n@JR^XKjeg=ZQk8KUsVaCCstoQq8epb* zAn%9RD)jtcAG7z(ObR(v94&ETDDgu8gqy3Awr6}Q-T5(+D<=t~#I;d6N zsQDxqhgtD|ckFx|L@@`QG7MxBa5w!gLw5`1vt}XA?EOJe$QyG+Z6Er2ZXlij zXEIssc81wzNrn&H0Z{}E2{q=<$&I!&FD@?5OHwG3?fca};c0XwMSgTG?6-hY`e*pg zR~=AU$Sx{jSV|k&pUe$8UGdY#3?Nlk)o6A5uM3?F(+t~Ux8*Rvefp_a^9Rib)ooN+ zrZ?7jy7%JqzWOK~@5e5>aIkN`ZG|k1+@eF#J2K|iDKjSK9l}@D~*9OeI zdAfcHUn5nYcTsrFLvL~;6EAz?nW=5`U4osHwZ0tWx>yuEkL1C3r4$@?-j(ixZD2e(&c_HaJ^^ z?atoWg$J_tWK%bD+1|d>tP#8-?ZTdi#H06)wqA9Tc2ZlD6r9z@F4Rd=CmO`=c23kH zv*_OR+xbQukddvaiuMWm%1cPudeszU9dDweM|P;vrKqxJ>6q7E0=fwkX<=e5j&ysy zPVBLtU61aPhWf53PHvSgYGZCq6Jyp~HB4j?OYt<(*O|yPc|eKT81fN464>AD=6%&+ z5qP6zEBAElze9042@(B}a+=D&P^MXlc)*>gPrzq9lOXJIBs!Lp>u|VmDwqVzlF{t> z5EApP>O!M3R#!^^$Owu(eD@ATFYBhWrxM{eq}!)O`Fw75I~I>=1RWQJ!(>=3Wq(*| zHMEqd<)`X{P{YP1A-2_97HBv2xGzfZD>ky%!ETB59spHUu6Sh5Jly44cTa;~U+`HY zWBKfB-BBgM)#{pVhKiqdsHfcdlyXy5Rbe8(oEvlxBUF{+UL#gn*EHwENRO&5u%+5j-BdFa{^E2zGY)dXvb-~6EgnEUxc3b zSbUNKY4!~J@j*B;JY|>rawDG>9V+3!0s65zL|J+wrXsW^6BNTaXFoDb5vRD+0g{;< z8)o>{V_zMRhqZOH$*c(e%Tbii`u&O$AciwJzG7oIz6);kW`^-}k+8Ej#5pl#goyQm zxHhWE=>d=}^|v^;ZeF16{An_@UZ4FA{1qZa(u1AlxdBHGr#zLf~?kFVlrnO~QVrEIL^qbaNyB9YAu3DspL-1Oh~4{e&EOZ8X7;V@OG4*)?D%w0zw&>5 zPZE_IEB}=oT_k%jIAWcCm*`*uLAWx*y^SG%EU#adHG1G{K&2D*&ept=W1{vzduqV}h{*Pn{8WB%j9cz7<;S77g zp(cCQOBB!*zYo9byfbtttH$b8rp*ly1FpZd*rR{W%ZK{pC#$h|3Lg`bdlI5H-2@qW z#S0UQcr;(g_lSBmt7tb`%2z0CYFQpdc7<;@g$j&Db>3AnH@Y#eB63y5NLIQv5flbT z>T=VKTPBuv;V9T~hW#v`Z|8##R?Ih+NBU=h?#hm$6q!o9P*jO(QZ2Zrn4#X5A!%sP% z=ePf|B~ny=u=S|@2{_w;U?s~paOz>0VTEKZS;SZVv8#_F`TYGMklxw93r`B5`De}? zlG1yetRf7q#%p@Z<(Ur#d3Xo8)b69CC%4yFk3{a7PQqu`tT(a>4*IOJLsF1D{tH@sTwScLwU29!m1`PlH?HRK4!a7#x>KdV zZm$ZtE1pT|I)#b1Fc}*%J-@?fns z17}y<)<~ULsWcGh#8%&Ae(JrRFD2RsK(EZR3(vY=3!!rFj#I4Qq%B_oi?Ox%#-rq6 z&+xn88-&+_uJ5w1qz`mg@!0(oiz|wZFkJibVf=gDq%jL|p!vU9tn@8Rmf7mKuUTr; zvcX%>9lQAH^S{-bckMPb=WabB9rRr=xnLZ-C^@ZoY#CZ-S68N8KQRnbxUOmZ$y5~% z)W8Go?f~g6ytQg@HplVzolbv9;t;P4JL)$+Y9f&ivP-(tOFK=u-P)D+hW@HBm-N!s}qG18QHZ zC$f{YUXVx#T$}Mbm7bYT1Lpsart^+w!+qPhy;qIetF68FCTOduQKR-Q>Wd%|o7&o% zwf8J)@4Z!Rq128ol#tk=M&I;z&U^B|-t>r{|x4Zbfl6IptTGH6!}5K zaB6MWV=u5IjOn?}$|H+feGFZ$y!2;K3yYEy|5n~_03~KwkdTl_W(CM zC7buK+jV^2#J8QUX*4IaS9!zxm}PzGM2r{jug@gMaxBWbpPTs(*H6h5c~wn1&{#Dltw}21JWcP-#8$CRo4c_Z z7&um=_=pbi->qG^v^8S#h|Ka=ImQBQ4QPnGJ?TOhC(YGl;xb(H>+Jl%pr*e24p{a4 z07K|JqKwq|R#^#!bf0>M>xWz&E$`mloZItM4!!m+Bi=Mud ztJr^@7W62B!G%wjhjEj8^)tRV>!_D&o3>^%tib6|#-I7?lq{f@Yc`Hq;lFi@mR#bK z_w;X{+o~x}*%zF1^lN`rWDb=6W|H30qjd=-pr^g~4m|2DMvkO6Sv8P@sD95^(T|Dr z-Q_9 z`%X^z(;_0%4*DMWX3vPWKAI-4?8x!%U*$Th82(U<<=O}7;`53`oOU7+j_yjssqDMj zPmu!Vn+pFn5~z#e;fc=}yCLZj{y1xDr9~TzJH$cSXJ=SgAGozjcu~x(P;@szAIaF} zTN2_=X_=OYJ*s;p#k9!iu)eS$7N)yRB^)hw0163=IIB)Imk>qMLHcO)7&A|%z5-vL zUG1y-c^Oh@~S)M@M-LkI&s4Cj4=JJ)*9{Tg1CQA{8*_|l%x z(l;P4z)KbzDuC}LGunIjF7FOsPR4s=6(F(b8YDN6s~ofh*>ReiYV#7OaYK_H-l5r}L9$yb>k4%yo}iWpr%oFc;pOQtbgK`UgjKcLO^p z;Xn&<_b(Cbh~&0Sp>D~CtG2&i1do{b-{9|dpmkzNI+XSB>HT=jSQ6X|VclKt`ErrS zN$Ayrr1&ODK$>4H9+s!iKLd z9OUx0RWmI(UFk7~;kh042#sM&=KW7l7!t7qe?iKUjDOhQQI$k0u#kCHI;+Ub6Y&Uo zdeGUTJu9Q2hs8=WQJ}dk^GgKvJnn`{e(}Vdtz&j$(HHl>CAmpuY`Tx7vqNcCbmyQ_ zO9wTbv#*7pkwYotARg{clJOS9^_YOMlHYeWT|P=Ta|I7^OY4TkwoFm8?-D5Zbo_}- zL}j@3)_Qbe+8PD3``A}CrB}C>8Z|uFfr1_050A8klkn*wYWtJU{P|$wwWJCH*DE({ zU;ezugT_`FdXv6%_DUiLV%puE5SO<7IpTim%Q-cLL;qYx~&?L8< zL}~pWim$Ypt>i7ZDIH=>f57deh8Wkx_y#F8o=X$(7fB*Z%kJpFJ)4bq_NGqLBn?Bk*pwL>qT^R?O(*}c z1hPgqBju{1`FcxtrIef0VNe24LDqfh$m!20d78)fY53~NI`vz=7!w_HEg;r^H>0E9 zu)*AzVga-i%3r|3mJ5R*e^J$020MeKy{(k&FJ9szKq)SZCP%;L`QDjOjO}rVG_VAiFMq8Yw zr$&|B(X#4|;+Gez`~`wxWetOIq)t5fR5el~71n3wM8?#C(67b@y5uDMJ2R&iT9(-S zQaPPLD@iT4eP-A?{7_jg-a`hvAcih>Iv7D?8g$~bvFw;!4CetYWL~m z(y7KN(K+Q+a%H)s(qo(d20h&EZCZQf2-S{STopTplDll70q8s{&5{DHSt9r=GNQB~ zvgv)I@v(*;s!2Hp%n5%nI@ozLNUeU-Ga~>|Q57I2mkUz}6q%~xrv)ROf)>$qMM2st zYcZ6lls=sC4?Q1j260W(XIPIW@;`{M<#I}rARL$H&BiCO|8SFZ@b1V(v1qP&_9@rZ z)IEIm9j%*)jrG`6J%#e`=HTq=wnE(M%of*%fP8*5P{`l|MjLkURQ-JQ3W?*(7=)qP zA|^P2^g<`N|FpK0eseoq8l)_t_!Ok$#yWLIlQrhnBE2m45bxEWzR2It7mmHW%My!> zR_L%c;-S#m9jsU{@0C9@%SRwu@Kisrsi|vui4}{IEBbuAss#sr^c!RI!<5WrHZOc6 z$$xD~J}2SBw+PqkYNC~K_dsm0F>}0H?QLxW*M2}Uu?2N@1KZ6LOGg!LvK9b6tofk0 znz8u>{GGJB1vRGPi37YAIvU4x~hn3!fm%V^4tJLbx#P5Ctd%y1!8lJ9315dFn z)#?z6f60|8Jm#&wCq@L<*vg;U@mvqFOGz4X{i+46K74(6wc51toU2?7$^a7HfkfKF z4PPkYd)|BN8@E)4bw*-$2sLE8x-q} zm$53PcLt#}#1^lLBWN$UH=oy$tXohV^#?CEGg6K_=3j~zlFCnKLh4K8$`AkeNY?q3T>1DVLC?qRI;otx$5k#hk735J=R?}1UDFnWt9 z7U@?hU1pAo@lQt@X@@1+E*+!J-qM0h=qRx}NRJ*=YA~~@u<4O6W;T`lkB$EZN#&lPtf$4{a^`=?hW+)JM??V?3rgLY<}%&>FkU@dsyHV zmhNYgF3TLD*ta-vjLI?9po)AaAsnjvm$;qWChGQ&%KcVBp^+}hv&@7K1V3u2;cEVm z`eXa8TSKsqTz+Ra?BanQK7A&~5~u3r(AOO;W*WisFnB^P+U$rO%io5R5q9WPL9T;U z9H6rZ>P)4nryb`ymu{VFG{f7_D^SrS_vVf(5$NiCV#r6|!fFfEix=SO|4E)T!ubyL zq!2u7ej4a+`HMAY|K&;G%~@1?mCDHT7E1(BAg;`|6btxGA$se*~letLfG z7BY_fvn|^u!I8<%sj(OauoVZm$(nP1F1L?GecZk%zZdyp>SQM+6`%9UNUfDFD6LfPNz4Sg48ENNXqXDgQ{FG! zXC?mQQWkE)zuPO0;TMo_&@;$9Qped1b8>?hvcEu zeCgtDDRqp-G3&y()qkMu-G7&4>5u;|$@iv(6uIS3a+UNYID9kqB^qUz4El1Hmm2CY ztVC~s`YD{Rx`Z%38GfAiRNWyZ^fS$?JD=LNuG=7tol3L4fo(+hcE%sEC-!wNCtce? z>0B_j(Yq6jJcf#we?K0EM2k1ZelA6pU$bBv<%aS5(`nrtuc~P7+a$liW>VAYIG8gR z)wX)+2s~V~tS#Q>v_YpCj&*p5w5B3l_Se>;BfolW4d45*jqmaRZkkh7Ev%i)s*F?c zpq0CKw4*q-r-`CJREfFU9pr?q`zW-2LuQ@Kf$_F4@Uw-tP}uuMzx{#0aG6E&e9vhI z(bn8g6SU+0f|b=-JvG{(SiR`6XMJ3_k8<;sgTu3DrZ-z3xZ^p?)etx)0UuvW{kk@9 zdbO{BHsV_|Zc{I>Oe&iYm!5`|l;$;&XNxpe^6twDD^Y&6mf1X~J!2May&H@o9rgFr zIeKxMbyaagjbM%&G3uALqhRQ7Xh4@qGARm}%2Qs=hB33xF#gr4BdomMpU$JVT>yg! zNt>rU13y)~Z0wQwSmiV*!4~@=(vNkBgt9`*Pagq@$?E7;Y@2#@GT3BLcj7re^J z4LE!@$p5og{Gmu?u})Sy7igqE5&LOF?RFMTRg`=6wdU{sht1vxM4foykActp9F#qQ zvszT^x18k(F@)6a1~QtzqvzJF!anzfQ>9a`=H#HL7S71fyKR`5b-nWwi;}fwQbF|lV~Cq=A~iO^43}*g+`U2z@3R$bCUV~TdrvcE>6!Pr1l3lNRp;?n zR|#*trDN)a?yZF~wWq}>;T24Koh@xxdyT=p4|2y6*xzJhS9VRXl-hvn$=Ak)y?g>O zdzHI(ix-ODVoymokrCZDR&iW1ZKEc8>WGRQ(E-BC$P~GEKg(j}))q4`FFvOOaaLTR zq?vO+Rzu2@HEp?nd+Be}a@TMo7f0R}!m+Su!o-xX$Pa^QpjppeJIu}ruHYE=aKFsc z2d*u(&}O$gtYTwzHoCf0zlAkk=F&c?Nazc>C((Z}(kl4r5SsM^e}xg(oilU6c=2?m z=K_`IA06kmPBwZUBOf7Ul^oVl*=g1ZnqXqttVjNJ%NcoOuG(@p9FO6-gxp<=H3)qt z|CLe%op^ry!w2vx)dxpEcNj2CTjrPpv7*`Hiz^QWPVAH0+eW$X&BC?E{1s)qc`zGZ zbkKz#%cR+0Klwa}V%M{OS0Z7m^(*j*1&rMdo@tlqqTEz240@%?e_=rx+o$-kU-!zc2v#TphW~S!D6}pd$lFCq7>HbarVy*#F zU@u`LPVsiY?~Hrgj{x=FayH<_>C5{I7e$(a6KlU{vfF9V`YQ_k2ewaZZ+|KqacZ1l ze_|yx(pCatgCB-{?=L0_U0N?ibXzaw^@Yp4x$lod_SlQ(yh&A3nQpfwS+<(ph zf=8HTUOhW0%d^yT#UOo3HUIBkb{ge|Mqu5_)Y}46r-?F5=GB4*i7c;+Rp{AP(L=~^ zRsjNu>{(b|gWw>iN4EGWG#_4x$OlzBK=1!MYb#dhqE|=yRKF+!rHS$HJa|+UH#8|w z_+G~9KdA%ol{0CYSa$AL9_}x4q3tZlc(;9~K+fv{6CtRW|>imXCWZew^v4MV<8^dXj}5}v>YK{ zba!_Hz7DYlq&4gVSKXXMPN~9#p5U~l&K8s7XJVA556svrMYQKM+O-z5tNPa)*-;Z5Vrsa?S z?G`u6Jw&j>-{hlOf(XvEpGfWIN(Kh0ZT%$hftjqmdyr#Qn|Bv{ox8feygaBAsg~ba z<@y*xy6?hzrpDr5nZ)d8!W)zJcr6n|-+hm=w^umuMN0%G4aO^}`8Q<%EZHzsqhJ3| zPr&<6PjKb%kCSncmpArTNUPlnsQi6-iEB6)5p4?-ZUP>&eqBT<&%^MY$o!!-Yw0gYd3R<{-vai>aDx)C zsYGl#2;e9X2%l!&a*6=S<4@y&!I(<$QVJaCj2CgQL}M*`_ro1&VJdQIm1yVs#^nA9@wL1Kg+0UjB9u8ia0ecwwDq=xfX$1 z&l&I5__IjI6Z@vx?ym42_7UnMiJW`B)aDFz;5-t=}!_R5SPPxif#cOAQf zH>Aa|rnO2n>jfuC)Bx=uE1P1_N7KJ1)c*ml5HA@e+os-Ii0Uiz>g%G?G~4SEB`R2I zSB;27xwc8hTj?#3A{!svIsz1o)H^7`GaKJ?`FMsZ5aH z+uy8ycVsRdD4N<{@YoJ&_57={ZT-5gu12}PaI`7y@-lIPl(ZnzF^@zpxswqe!yaRe zvgGW^T$+;H6d6nY#TC==c-(%xD%Fd=K6ohsiTFbaxckROSZc%c9@J{27vaAl#^^-r zw$xrI_y3Z+3Ord7+fngbzXaj zVP3bSB;pEY?jFzn(8fxLeLQaAW#u81Zn*@FCx(QW{75D}k^S7wE$h(1KL&DNYayP9 zvvCx9$L*K$dL?^zYM4Zuz^xzc&zomb=trG&kX%jT{`lII zuMAYP)Pxl;k5Q$$E+m7$POT&4@DHRYcfa_va9V(Fi*Enq$#Bu{!$)#5!)_s^eVLw5yu zNj8r>D2D&ie2i!A;0>o8kYX~Y zqXEU)3XA%4WM$+H_FXsZfYB?wk0`@i3n#Nz3b^C-zdYk2;3}I8_8C|mgm4bLBRP89 zt4*!1#V>OX{33|BUVRdWLLLeBJG=`4JDdx-Jvh0zY~dH)NztCYh-?yE7DOnta{{+p zbF1X9;GH$)NQ7)Uz&G7}t-CDctK@)1mN~G1HrT$gpJKK3X`D>p=+4={8I~?Ib7wQ1 z?#n3iPtS0TjTvP>EVnHFL~*4=ov8-l3=+dl7b|R#5gmj(Bzxa1glmtmz(fsrf&6=( zk5Ej%5r_kJCMFc>IPVC>-aRun7yM~#W0N9~HgDdVC6st`SDumfptFLoZy)ySer4~< z_Yg^P!)6;m<_X^UL*DLb(^xxz8#?DR*3Aa8q7>Nj$G3_*4E6nu4#9YNpZ}6d=a;g} z1&lv4hyA1tl4pg;M2+%LEuHxc|9Y|DbdQ&jf&5fw_e z5<7@iHn}KqfA3_3dG;!x$05ct)_rDguiUb5clpR}6N}-5%p{*@@Bk7zSlS`)8j3mrT5w4uk9uu{#K+Qwjk>}s9} z91W0)v{U-vF~1k2n-#mo*^RfPTcGk+=tlNZ^~yMoZhDc=nOPD=GD*)sS+!keMw&k1 zV&B*0r~B56!d3rpLyhzUx!4`opi=%0<4v3kFamk_QMf<4Yw0uo(fqt3-fq;jmm9*_ zB1R2pJ-^_dM;Xp;$QBN|{k+J-g|4V8!7K-Dd3dZr&HZ-&_R4k^vPewg&PaWKNRg%K z&m393wM9r)NhWR*GXb>5KEDzU(_LFIR&6`4W)7^(eA;_Qn$p+OkRWH7b4$ofe$f}B zC&|>KKhdT458TR%Hm07o85ZM5b8j9qnUxoW4g_kt}TlgqT8CP%JaD;Jr93 zIYNV494K+sYiRk_;{dH9J@#?41>M5j28;)Id@hUyVO&%x*S3Fue^9Payrif5n8@9iH3<%)7|n2ENskA&P6x}93-E!*CV^XOR05#W4F1uH4F-U=5E zR5=XS1n0DObnRO|DAi>mzz6w>j6*A5&LV@X^Oe<~s9D|;4yA$37*i2}s&!)f#raX4 zOPOA)P@N;$T0t|7=u1ed!fo91!vblUHb#{PCkW&QH-C=u_3!9DI+$LkO21VeF$`m| z2w~|cuv@!7=JKJ5vMlP#TJ2P3>+HR4-(}0I^f^|v*LfQo`|lD~jQ{zce#+v-Kly~J zX`wMMeRq9Ii0}TvgH~Y>)kKXwMN8MqZ5a{9T;4sSwRn3dYFMeKsj8-i)M!0%$V2^F zHjDyYfkfs@jEV-g*7UgJ)h;N?I!w*yq&bbFEQSTF zuUk5o`obZ(PRdO~BupB+d*WlsK7=O7+}9>XKpZPpbn<8|QXTR_MtF3sILXya5=Txo z*6WT0UYXjJWPIuQN>HvAK95+$IyJ%BHR2%7l;G`&nw-t-$Bp)@F#y_`qoM{|N;11h zIwAKh<0U1vh{D*8M^};)Y~PE`k>MS!t7PMAK1U!DCMDa<87)fOl~~P%TAM!M4XHQQ zP1G)m(u5MS`rki!p$%SA;9?x|m~EAVO5=sZ#Q?=`QB97Xr|(OcWjq+r5VA6=WJG`o z)p*vy{iD=v`u7rbTfNZ0<#@rfp2v++xAL5M$EvHO4r6je{X>y=wfPKt`E(9l;OVaO zkfg^&nC+3l?mFvU2pntUK{&@_*sSsR?$X<)nbo}(ms&4hIepf%7-QD{h*^-HDUZYE z=69Y(fm{${Uxad}uAoTh5%NkJk=QrX6V%(-DBaTDeh~r&yVLb$)Tlw3|D!vzJZMro z_R6&<+5VFUMC88x{An#)wZmWZJOv77zxP(GIt;c&&%H})m&H7aV?O_gTn&!@Rz)md z@y)})1;w9;L%5v!Be#y$8}vZ8lgA3Rv_8lRqAZ&3@!$ zSoHr-<$iLSl9HrddU1e?;)zmBd4CE|;v>VqE4=W7u40yP)->3g;ZiF@y8Q#Utzv1f zo>y!0L)kC^ zEKvN}EnR^VRxGfY3>G50hPA-kk?`nyJgbuMo5>$}to`I@XQO$H`yIv3&FH+q1M@+4>-$ImNKYiF|4yRPmP+HS7 zCYXzz=o@*A<4O?nv|Q(+bC=%(OSWk)!b!?JVH$2s@Bu{CR)6C(dZa*oxd6TBTNyI;S4^~$Be z#+s2a++WdO$wnnit}edJ@{CtrP^$r1mkg866&3wzg%vvy9arTVFK}^RUP#Jf$fnco z%9u^lT$Gje*R&o6y76UeB6#*@JcdE5k^bC*T67UFz+l>%&|5I|{Gp&9i-KmVA&zY| zej&5&KMCGGF0MbOB=P!C7Q9Jf02l%RpKwnsp}2{krMg;qtI0Lh&pGBVuPi$mahWKT zdLoC?Z!bruI(4aE+1I%5D@UT}#_#X>QYAP!d+@%c_W9qx%rCcG^Mp{2X27!)u(x|SPkPHdF);-byd===DnQ#nBgpUWwC#leb+fXC|jRdUb~Sj2hr z*R0B&PlAzq~^JO|4!Gg(_%+J5J%>+1XQY z<|uDlxQ=vpcI1j%Pt5u4m52t@M=^B2CARXnVuym-|9~mqA)Yq8Iq9OrEDlqvjIIfI zp0-KY>ADKhy0S%g?=1pHh%DhWoAjQBxU7gv|K zBJwPt7I8b-Da`75RV5MidVm}ERcBj_vG>$(9ehKrVpYC^yqvUm<_5k@RL@7Lxz>gW zF;cBM7{TS2XI+mC-(G`D@A^X}HSj@dDeVmE zH%2D!LeBgIKkY5>?fX`EB)C_mTE~CdJN+GSKOxfh%onwuHh>LPk9XX$&r@c|$1Fi= zEk=PjYcF4*3A6=ah+y#uzP->2t=#P>Du3*8s~2xM#95z@kED0;cUn^)4}HSro&3_MhP`hy#5JUKKR#w#*iH6 z&vI6$albRii3L`hmG$NP)fL#ob4U;*`11SV*_k8(RJqo}!+{J4A@`BC?U`!#QfvFg zsh8532JjR1$<3(K*NvfV_Omz>oNBZt9KSp`v6@q_J#-Y!mu^@h{hx;X@lqXrHlz^U z^|w9vUsWYKhB={VKlrnX(nEQ(K&7*PZc7u|N%tylhcg&wX2rq?+Ox7Z>kl2tB26{qi@E)y(_VKDw#TV$ zph%5lDL=1o_u-CnMkvxacJ{hm_(`j?O^)?Pr1SU)tbV$JXA9J z`s+6Fm^Idf$@mXf(FG%GL9J1>q%bl6B$IEbwvf;f^%7mZv?aarKs=U$bE zh1qR{tFhsDlKy(B*>-Xa@KYUVp70JK8YQh`C53aEI#_-nfLq(E5iYE`6R*8Tg9^BL zc#?BuJf57c=z&lSHrB>%mYiRtcl*gCE64iDqXig*ETHw!Hk5^YY$HeEYE;@%m6X7fcm%?D*bK zHf!_J{=~`qog^b0+n|qGpyrm0kW{(P6mA=p1JDz?%R1waQG=~my_#K?zRmMbjzl)p zmS1iWZwtm;T_4c!!o6)a#Ju2gQMssyi=G|coilMz>Zypf!mI7pmKLRW=N%>6J0UkE zQVwT9IfoGwEVx2(98JHDnoPK4h(}sSMS1OSl0#@YKu)Kju^0fIe!)I`*;bbtD|aN( z$leACp3GLgO`IqFXu|w&E6sz^rvp$fukcwerC)PaW+)+FKm6Cpuam1hxN}`LW1yX*6*+I zWM57+BswGE=MYNaQ(sM}sw(Y-ROq5$LaK_ut#@gwijjpMpeI>?Wl+IfmYr3m6qhi~? z4c#peWGHI#`#kh#dom_G5%nWE7~hz6akzDi+NGH*4HV!%la^Q6vLGbV^b|eP+SuFs z>8qavNQJAFh5A8#JiY8ODxakUx)BHcRZda=b=DT}Em zo41}q6RQ^b!@jM~zF52Urxz>3Oxn3R-*2%f#03O$JWWPA1}xV4WuHKc0!T6R8b;oc z9xXbshLFj%ZW?GPiP_{bSIwGu*RfETyD24PagWJhLS090&~H9gT=-u!&-*cq>&Zgg z#8U2`IJN8_bp{4`^)IY|(Lwk>|H^D|pV7?mgEk#la6~-idg^s@-dd21)D)xZdIE(4 zp5+bVd*sPVuNPocR{osFbd|+chM*5E#yjQd;tcX5n#KFz6xWvL67U(rLxrlOoWI1BhYT3nZ#%*sDRGSSAu1A0~HW zF+7nJuytfyiq~#@C+2)63?NARZx}@#N~BEATNL?(J7T9G)e85USeIPd+0AmtJM0mM zYSA|OsNC9l5;&gVU3#QdCIjhIF!iX5gV3j8httf+v&y5bZs*9C)|5M=6-k)DCbH$~ zf-Q4teRJ3Eicj7`j6|oAhD+p1xIoI8`z34k3-EZSB+iJta-ew>n-*-&upR8`iaSYq z3de~jz-u8tTlcJw$U4tD(b4*9R~$YykXWfA@$tL-dDFJzrdkL0goByna0((c;Tdsr z-|~W=aCe)V#GwInhHz>GfV6j!Z_xdg z<*N@}z8+s8@-|}Tp?Y-HPybBokdA~R}&v*hpQC*Gn#yop84rg_?Cym5-u}?Ef((ZYhUfg zE<(08`Y|hGej#J(s?YD}d>c(IV{emRi=*Ri{!aJo_ug7}(?9B4q!xVGFh1mT z!S25E@~3#`77lj`^6OqhN@!kbzVq=SZ`Ge)G~Ha(DqFqZUV%94sVAl0W^(MpzVu{* za2{iajq}h;l()U=+zx;JEd_r@Ln>vJ$RyV%e#S|>GZ7G0YW;jTn(N^O|H_p>vw z^Mxi?l0d4V&|;?DPP$Oj+I;tr5Gxw67&JVEiMky9^7K)PlT|lS%bPNQ!?t{Ig${(n zQ8=u7!QzQ30~?DI7kI*8(v_N)zgb}VF|LjueDdy28)nH7A0%L!fV%4B>q6OPDYlq z*&^4Ivqv@aXK*9;X43z73U(#_QJr^0!VB|v)>pfREOGbsd3__8UCF~Go|*bVQaGx8VA`@^Fe zcmshTs!Kbn8){@iV!}qmJuopL0XB$2QG_IV8nUyou!RVY%ZA{x9M3FyRYhw1Tn>eI z4!F)w)FTDpXN)1d(iO~!d5vnqdyU$EnnKVY(EeI}`lAvSqxIsZ9HzG1kKh0D${*|a z-Y|eOfD^lj6Tgz~RG7PPKA?yQWE$^KS-9M0-CT{>!R}dC+-uC^aJvF~?RBnWw-KVQ zm?A-+r0C~!3k=8Q=FfqGdB=Hq6Eh7q33y(v^&qQKOY2Y9t8~A+(bO|SnGy=LL*DPA ztBgpjtk!U(G5LW4)wrpKH%~=>ne^)5Yqw{tqWlr}=bDr45UWHwD+I_L2sMHJSDO+I zQiDb6JbS@)MqxGi$ONN(($eIxFBS^(45fCMyzwUs{c5XwImhesazKP$+v~O5!ke|- z=C^pHY&>GvevcApsa|lkeHwj!L+gv7EY%R|*H-dxjSoGqd+cb^gwdomS>wrN>5}q4 zwb~=z#RG@zt7RIrh*hNWOuPa}vYvm#ZsHru|~VPEQ2{S z4deHp%ptIsZtm__-|?-=f8%UD>!A`KSI4oy=o)k%UwNB3eW;59tzr10(WLbh1&Ut9 z0oeMwfok}^S(D^(CK_VX*AB0Ji5!FO2#ijdw~Lh}y>atN(G80IUg}HHjL?_;h&#uZ zajY`6hejQ5B!gmRFezlWh8d2IrWp>jD>uOTv&zXAx|tuoHS9_ljP9_1ycsCBQvmoo zX*0YfAjKn{jKXJvnx%)O-B^>6niJ0g{1^H z(t@k?u)6M%u=Sg@nktSfMX?Pz|3V`dfyV-&eaO~?gjysNs_cDjfn5&GyxOMAZ6pT z@&ak%jrMQJx%0b>ko9-ZF>n00q4lG_!en8#;Q;Qyxgvd;G0tf@@( z9sJvVFSK#?`ay71&!)tu@P}!~mu%gxwGMC&xJ7R;IQR~Bqc{8|5u2OEq57JL)qtv7 z)F>}A2ye5j>QBV!=^JjZt|(AvqIglxpQnHus&}ViGuQ1Cl}PFiIU?WxWT%Qfr>47& zAv);R8-&zEXP6fg?}wEp%zahtQ`>KJwQo&XeCo-|)uzfoQ+h!v%ts&7ZR95hg8miD z0FFchphUXti+$~C)B1U+rSXZM!k!oppq%y`FW2Igp1>Z`k`JESJ9|;!eYz)_%)cLb zE{-#;otLIXxC6xw(&j%t?qPL54t94>Qy$8pfo9nEm6qBQYwmP*ei5w-M6|l+5niD@ zY?_?hzX&(E@S?*qqwGU@SsmC49c^*`UkiY1##DHZnw#oG7K$pp$bcnb zX@p|VWszQ$yG#PFMR!6jVKv0jme2wfb_^mz*M2Rj$@=qn3z?+vp({awqlFkOn z?qt0z5*k4HTFn^=d?s*3fmWDJ#z#S!2>jmJysBgi`e4E|AmEvtLuh);g1TmIOx*74 z>zAdu=g}p~4wZeM0UqnxG>Hwuzq?U5aE9HPdP21hs7IZCE#${gDKjSa{&z)KM_v|y(L^|wdM%`mHfCXaO_L&LO6J9N;fcbUjkKd{IU!T|VxZ5w`O^6ol3KPLn-1mw`PqGqXF zT&^?`4!YOme|}qw=$!hn_}>aqC$oFO*v6!%TRot@|49p=gyQ^(l(yfIZJ2GCSu3EV zm0OQ1 z4xl0{qn~dc_gK!HqWFyYd-Qz+wSRy_EbTI|s53CY9@nV{Ttbe`T4ZF7)N=m%F*$6m zoXrsE_cLE+Bv`3IPpd_ztL7H{>aK)Ffb$cUE(4F7SJ9cKU#WN{ST`{MP-__fhPc#K zeoO0@UU)h_9loHoA!n>@t)XY>K(42w5ojm6nt08Kvm6Ay46wBB;rX3;)5NYdd}x@t z^M`itr3&OvYN&h-{tI`3l5tekiZhd$k~Br3 zKL*5l@x_;7U9`HNAD+F~A7iTXZZz!MR|9KJvfcNi5h@>>@buT6*A^<0TyYdMPY7Dp z3dXAmQty|}cUu;UQHo1uDin`D^%Q-`%6MuTYE^9@hXL{yx3f?EJ4Zx=^q3&!Pn zK7SHvA)lzn2M2a(|1MizU_XPg5KiS?36jIjX7b)n&H>hmS}}zISIOD({@>Uc!*rGL z*s;f3W)b+|_7i)U;F(FD)lh$sbKfvD^Q22TZH){fhg*m(Tajejd=r0ZEqC?Yk<>YSi~**;9h_tik1xFX6CXPj z+|Yi4ec9B`&G&P;u|h>X%_v>)ouW<0pl-v1Qt7E4L2gK4P;-zLGsAw1e>| zaZ1QwZFNCtc%oWy7S8drUuR9l*%SRZNQ+&sVs)i7Smp0p%Q-DSYoE)D5JvtWOPL@v zVVXPD)vUZo(OM*5kcN_-LhzH(gK&xWxvucL_}_aH`wI^*HxQ1L2x*Is%7<@EhZ>yp$a zlCm_foEe>Y-{B-ocnyEFCEMaddXo`|z4lz$SsLF=;Ctu4W?&n(Tn{KoICHann)?)U z%H=Qx2qi7!am8ViD0F3RXnW??0G0vj98B{pHI{#uNBdL`*b1BPA)N9U`7 z5}!Li$?1`iyt0=KmF9jS(u(^_^?(kbhELp>ZWpp|EYfqKeTyYNjlLAJSzK6Hj|%2X zb5`rv`u%SBSkiKWjcxK~qk>63YgdO?=lBXrN_NB%kUthWBc0Lo7Hy#K45fUeAY;HUj%wQt(E-xh;ql?qP zSJHXzbF`$f-5GKqZa?wGKMze5CAKA+f8}{HQ8tW}V zg0S(UIrNWxdEwj=XlyAlc;4Nrd|P{w-rrsXnTOs4QDF@e??Rix&2|rr?e?1%Raqbt zHmzFQQfqL5C?Pq2Bpjs&9Ki zk9D^Qt#>uy)6~y7((Z?<;nj3De`c!)uaK)~uAvMMf>gA)m!%T#v_bn1DmjkYTRj;> zfKnSoxir?$IgvS3!}JNjj?EzqT)B%&No4_Sa;KTh3R~kVd@JPpY2D3Dw8$i2_OSsB z{N7S-UJoZdZ~L=tZT-~2^tWi5S|Ygi36#MO^W!(e8}E)obk|nao77qVfI&?hfoF+W za2bs5+R)D>T+F1SMm&c(Kwslhx2x89Bzsl7)+;e%Fwq|t0C->TRh`eDYw^CRURe0h z5bON9+n9cJIty1C2>ZBnru6Fi%KHgv;JOi*Bv)Sa`w0OBOw>Ogr<0r5NXBPMgTpo< zU^t1Gwg2azV#sivNH)vNvj7QwAa%E$aA2gY=Q>0aNstD6hHn{-w)UFZr*&cC9sqN9 zlN;zGDSe*No|}yit`p5pHSrX|?jotIF{wwNu^SNesPbLYKM2&gV~uobwk= zW|d@p3-buBE_y~!Gam$N3O&|3TLS;~1`AjRUS387{_*W2U|7Ow@g+|E*(#Yj!ol{v zP0Luz$fP%>yU?*hxEdhAC>Pf z=6*Z0*BSCSaku)&idN#$NmG&9t#)pS6|j7>QsC9gX(hB@3qIgURp}h zbiG5304TOB&mYMyLUJMiv>}>A3=WwKi_Mt-eeG9Cc!X58b11HyQ>7yAF3iMg6B5eH z=vrXZ>woFgSijg_H{tEwvVS(we@A9N9kc6u4s-F8siGZ^spXX1Oi9#Z`LOTtaCNJJ znKIJe=L5%PNe z6{82epn=?S7(FhsGUxWR8c)=lGWpd>i{}BEf77z7Ojfr z>uriFa~mRB{~nf0t<*^lr8tXxQ)HnS{=k|(yvQ# zxy)@O#R?~yp_6ywF+HC?>=(v|3{MhmLk5C(s0bZoddo=R%K8(Mz*dT^O9uUu!fv0y zfWH^M4sgk%9OKBdu`gRiBa3W`46+~Yc0aKP|Mlqm%c%&62Ew`z3cIP)JBB|whqbFU ztd>*6-Fl+Rj<(dL zMt>TvYIvkwIO}v~?sId8JrCBHYX(srefP^9K)>xT~C{A9&;q% zfQcf!#Aa?< z7)r`~##z0(S;&#oIXQfYt_sRJgvG3O8H&H{ZsJ|hmod1%W9{wAPaaj0@|3_`G1|^t z9Jof(lwGPU=uasGoj{HZj%Q;VWZ8bo9&PNy`4Dr*0-jjaYT5(O3x#x?NXr(j_GV z`5Cv?UJ<<%61;ln;59ebIRiikAA0f3lg^5LO_NFPdhFy1NnK$E752P1J2K{}G$_pM zcINv^=x)&N)mB)>mEZ=N3gBpwr1KWpX`;ryepwqVUC}wL1U|cWA}_oqth z+8oPX=jinN8a}4ir2j9Ue^fcE^sW;o_MGgs)r;%wX_AKaTOVm6lS z5j&TDiGK2niwl_-pNP1FF7Cgryd;0~Mk>+W^9_O)w3MahAqh3|>nK}h5*^W*JmTl( za^fA}ev9^W_#Xb+=xqr~U!LssPgkG9!Irmg8pm@_Kk+}9Xi^*B%VB?0aS;7k5hPNA zmI^T|P^tA$(;^xmlh+5*a$sGVkelgMIB3gQeCg0vK&^lf%L2aYVqVCZX4B z9xQek7siw$?P+jrf3iLlqMP@EFyeOv?*aGqp9xaFR}mT^a5qmT_6iE1@98gT5D#F0 z_7DEfGK70rW%l#@p^(a_M-uyPNVqO+v`+!CafVsSJ21br)PpMrl3JKB*v7yu68FS_ z+vu(Z*gmxGrqPC<$rN}(9eZ@=1?R-PFHCH%l6UUg041gm(A-=4t@*^B(>s7Gfwt%T z-Pj$?KU5|qTn|2j2Er8$hP<-eHAeG;C-|9YtW${2kGBzHQLKU7Z>S7}2zpX(xO&x8 zOmVL?+)V$~E?6#4*yv@%H3TnM9Kb1q-+*o$7)OX%0)^|lux+k5Y5Ml#Rr z79IgQ+RunP+C#3K58|`wPkus+LD#8f@^5{-=i<`AkM*2sq)J#zOs$A(>~{ry8f>am z;_cYqU0j$EDb%`X>^M!|VQ%-`TeA6s*1^OZwnH_O%bef2u3;a@aAr1X0E$UBs27mK zQi6>cuYaQtTRLRh;8zuN{1iiIgLXVrOkjqU|9^I7nxhltJNfvY=JmbZ;$JYy(P8{k zW)0V~D_$q>-q_wadiN%leXXwgi?^lTK1dVE!C-{3rdX;9?V z!i##vN>lq;w_>C~yFz}WLtGce9DeY&_9p6Ggf#Kxy~~aF71~SvRHc8_>*Iraeax?w zC%GF<>Mp{~Z}4BheTalYQ(X#GI-bYq*hP9Z9ZPa|cyEiG%ElI_6P=xtXSyy75Hs|m@P!09q`fzV$?@pMGc$p9Mj)F68sng9RxXaRUPlfwy z$s8p#mD?ENo1~m(eI{^!ghei;pKi^;Y*(Cyqh+iaMov>bI|9oM6 zG7U6iUI~faO1=nq#tIADJ2ROWpMnE*rrNm+uOr#1(olR@`e{gHz_r!bO#tPDo?5?Z z*P4H+B@>0{`_G#^tKA&OtzejMTL2&fP~sPT+Tao60rH^!ovsZ>rL9NfDlmSmWJJsd zl0LErLn3PPzRP^tFds;LX^Xv2zODsjM1@kWG_fnuQv>+$HV)>~wgWzh=gO6deV~=i zcUv#(tCvi9XF9Y#9$V-NpGkhgD2#l^F*!SIfGN(Bw1l!OXU~tcVph|M!}&fq@>g-5 zyjNkyq6-!00O8H=e94bhSs}Y2+$jBF0N6UO>ST)^#EaJi*%3T*v(yTcim@$u`CYx| zgKSy4lm_*v=zA+j%1XOz3hq}g&A4x>{zCoxW+s=0RFBlM6aM6S$0?PRO|2!E&;tAY z8K{GaXtP#O3-y{Xm$dX9(xs9dKA`N}o{kX4+Txi`xNAn(6)5Q$Sjv@3R-|5l&3=ak zua$XOu89?-?+Q!>AO}O`j-I=?fsJX41j=+}g`zhGpl2D!w2CPSQo=|+`R{rZch4tin1Awwh7yCd{D`BNHQQY@ z*B=Xf_u_0JPstZk0po8#n;rzPd?#&|36(>xY3=!R>X|z$XK6_9 zEyA{_bo_^=J=NZo@Q!Xz)zs*~?(S(oTKw!j zI$f_X-`bSBV~5a#0e&Po4xTDOl_H0E=Z7)k6Pt|3)IjbHWZw=UD$I+KT%=MrfJPC} zD*8^uQ2%mc8$4f&XXY1vY{AI0$&%s7e?nt0JPg)_LA(8uJwt7Fk7dzENT?SAnBzs< z@<&{_Tn=BI9KtiDIzIWXUnDlbRDupUj-I>6sa|{UX`NH(He!ZX{QrW zL<1w4a;(fU?xNPj-kgDqz*O)4H{Aa05bdv%GI9{8hi7xc*sWH;aA^1xqD88ukt|cs zDNenDG0dcBDSH_T6`*FlgARozWs{VUqXGt#RUIeGZga1NO0qb2D&8vij8nI`oITnI zNiRG5ek4!w*?NM>V;1p+xC4H2BwUfbA<^YQ)2{J|qQxVia!)1Y=oCf=W6iV3j>Mf+ z1Ja3Y7e+xxLCgx$r=;#&(X}sR#Afxsv43dsx(pmB03ECKL{Ay?9Z7$5oOaA_Je@~7 zt0{TaenD;piWE02PXF^_%|PE5pK6ujzuP&H29TQu?5`~28^H^2TuyuUHn0yO!<0L& znTM!XJIk=ovHhSqWf1C&#ax)rpY&C-6+jSEU&zkz%-)NOh3?zQn}x6gR$+&nq}8^_ z`%#EQQYO#_*332^Wu1RY)MpD26DIbVndfts5I36X3ZDseYkRCAOXB+Rnd+%f(Mq9a z);FHt#H^HljUr0iTF|P}fb%Xol1sZhH`^)lQo%d$9I#xTv76W1N5UlwP=jC_v1x@C zgV$cHYp~e(BHapO)kXU)z@MD8F5l* z=GDRDt9{aa&S)z^-`H@T@WH&o*@;YCv-wWR?V4h)-1A&W;RK*ai1FQNewTb8J*v60 zmaSH*U0Vel`mp}+e{dOaP<24kLnvJy9~pKXS%BE$5MqZYunUHP zX5l?szTvN=sFz(0VdgGD;LbZvg^Sa(VVMm>dIRxaOgbWeF*S8s zHIgAg3oO;tEl`s3UoB(*;V*qS&B!_s<(_X()GeK8wx|<%U!OyqRXx9k@YXvvBO=-M zQ$IO?(O9tm>%o4 zUk!<42t5e)%ZCeV;0Ag-#sZQZIR~;+e5-iN!{?;kvezY|?9W7L+b4m7;{eXnlXw^f3cAan;TzCW#wy{lG%031hShu#3nntqyAaI2=a-1n$_m9)q9 zN|z<>esLDsk15>=IaeNvA^b6iU-$#Py&dC?csJ&~^OtUWuAXuHixtS#$uZGLHbFc) zBEU}@qu@t-kSHGN?&va96KNIk{%CP`bXR9c?-IYJ^6CV5&R5UKu}5xy-Wk9g@9e39 zwJ)`Ef&Tlm$5S^`3bBr>EryxWL_mI<_ntnd^=m};@wM9+873I^hR8KClHa{9sgly~ z0wU6k6E`zVOWf?U1v7AKFH2C08fw$5F;nT&9v;yKeW&+97)>6_Mv(b^lPN^dkx>wx zcKbFT(i}Mgw4BA4ek2#<&T0W>HzNCG%3zT8eN)J<4Y(GDHMuo;Mc-iqm$4&eh94yl z4+n8+W_-Ef0<6pXdgA^PFUo0eSOLm&CYn%c4QeQM^ty>;cm{H^FU`Ot7ya^6_b~K= zH3`#py}slAQ@H)Fli9cclOJaL3n;UuRM($?+>NtjG2_ag>kZ^?Qd>$TMC&Sx)Pn7{ z!J#2If7>cc1QC!ql8}52R{|pS@@#)L9fi7LH!1t|OKBJOLlzgmVo6w}pPm2W%053F zx!el6B7Hg6w}`)_Vy`Q-WO&;s*)xW2jdoCaxnQ4N!E8#bR-mo&O2#qWFx&4 zuANYAB~x$<*wM-lQYJnQ!ns_nwWT*WUAk-eOdU8oGvjW>Ba?}M-k5;+0@r)BfaG*q zHm#BsX;4K@tA+Zhbdf2vQGPU6Z4cSv^N79U+X^UyJf<22NLLEqU;28~B9vgNEX`#% zTfCraxY|*t*1pDVHE2|tM!s^N7u+1_&u#6dktMT@L6Qz2g*NS+4Vyg3*j|^qr&Ysa zHHQq^W&T!s6gE}uMDgLiaj3n0mpDZbzVF7a(<&z{y^rba48sETu&V>P)A*f?&ILV1 z4%NOJdI_5af}fiDq6Udg|9s@%)P3YM13xq`eQ_qeaTI9q{suCpq48DyP3-;aycJJi z)G5jbU)Im}$MvJ6uLF1kd@lYBbw^_t7lq`@zeVb~_U9Qh`aL|>y0m{!dHURaVgyEs z2QG^rgJx>B#fm;Y2Dr~AbBt+MWd6qm2%0;H9~ZTI zB}@@x;dBV8^hq1TO_rP9rg=k_z$)XXufOj&CF?Qn%E22KBkYP=?hWQz`lZozpTx5? zH2u3X{eVWj$0pQ>thWN(5qu-1-?FAtx>_(l;ebX(q487oXP!p1TL8#D>FBuOm^4h| z_CEWIZgIs^_qVod-;aFSry}YC_N`$7;yz!aWr)m(!RN)RWt2!E=*PJ~@V>Cz)Ki#a zq6d!O0&=l_m z`gR;Jl7Px?Sso5jRuThP5y)6`!r_+ydRR zDh+Zo#;e^Pd;xS8HO!`p69Cl%iRQqI=Ao||C&dx&M%o{1gda9pdcXAX{;4<g#W8%|wJfA$cYPn9T8JDZ0*y%7O0!UH z*+_*#se#YC^a=Z{md}DN2Usr`S+m-XM-`hCPvyG>katSK8d&q;G#|*^u_s+>$zXHP z$U$3k1nwF$8TZgT9NvZ8PUn>NyFN1M2KicNqguR*xU~GDH3gqJAw7wxt(H6Est*cU z4?E6rK^=~ReKD3>o12#e`hCfG^`!y{rnyqYjYCata(a!0t!JPWxUD3!S}bk=UXrE1 zoJk&M`p!Gh-4dGJ?*&6LAjg5>-u=Pk$Jdh)9ezizJ#oj*O$}Nf{98&8VxyV4-}>=n z#MrQL%ardmLyQHqjFb+{u?IBY{iSV>$DX+#NRUO=qlfSX5zR6R8vEieGqqzrufg zFYM~Tz;Y1O2aAy+{dIDJ4Z6aPhy;ZOoQ@($JM-y(#HLeuP7!WPC$`)_YDo=volhQ# zyLo+X3-k^RHZ7gQw^*)UT~03$KoE)bmbE!^FBFX8#dKke+gzB|lyuPgbN;sU8A!gN!H15x-(~LKawSLKoYb|lDsot`H|9R zqBroxPw%{Ka1Qdt2B=OZ0O{w&Ee{?%@9vJd?rex6swtEH1=y50;JhdY5tS@CBX?jE z7DovljartLmWP=;5c|Pc^A@V(W5Ek+RexOa=ic8ccqWX^6~Seu4L?Q{mxgTQPt!w#GL^<@g8=5CaiwW z)YJzyO`P?SstkF5R}W;vBW-I==UOZpm;sGAJ+Y_-IJWsnrrcLer{DJrZ0S!eEO~s^ zsxVudH5KS_ZSGu(V2qe{FWDjq{)(23N#h*%+KqkP&pfEh+P-R3JFfjBPILMpohj(s zV*c#ZQOfM}ez6iXsIs8PHr7iX>~-taY2w(|uN@u!*yHq+rJZh7Ay-Gr)yy>s9iQJ((k?bZ+Xujs@WWyc;F1CHj|Rssbk&If1A&L78RCQPe=4 zo6)G&548g4d#qP`&E=*(TN~!hD{9-$&R5Kxb`)%-gieM@6mOdfalCcZ)6E^tDU4p; z?+@Y!Pla<@_s&0=B|41Zs$EEWNK~U%Aj_4(opcawvSsw${E>$-=k%4k!;;d|?k#{>W-s|K7lp zv;wUU%l=#S;BS*#9(yQXV~Va|!|$e@a7KTsw;oqu0@Tx?H%vR&+gWb!oIF>q+Pn|W z((jIBckD}b97y^6U|_e@3vtnlDe!K^$fU!3=OhjSZ(9ZY^XRSB0LJ(W_V~G|@-Ooc z=6^EL;3NqHGXxcs{6IUeQ4ySkjU9$$mas|;`WKHVLSe) zQPOXWU49JFwfbn4sohfL+7h2yT>Yy=ihn?3063)Bt%o97zO(-Ujp|N)L=99M&ZyWJ z>IEynSX^$6T$Z`023@Vvso~oHOwJusHl1K@OuOo?HKg>8g;Wp@3>|Zo#%C#T$m=yTEGjbcyJ{SZ@{3S9g_oWbBKowG`Ph-GvTvFC zL-l_G#E*R~+#)~`-g>$GIq44@u7+BYk`W`NA$o>`g=DLoXvu7eWh8?VojYMjiXhzY zhO1qO?O;+G7>3=6YjBxoaYi&~1h=-ewb`bn9WFf2JB86!qr68$*9Oum&4f?6j(-`p zzMOc+E#9k(mffjrtfz}IimE~v#?#XF>%?7k9ITC;-dZcr29aC8I0b4<9%hhNu zomRO;49}S4B}wNYe$foNQ`|gqa#IN`m_ovxt!vKt#UuAsg*JSIkdW|p2-2_8ULIWL z&|k3*66GM9u8#BP^hK{43mN6l>OxD!+{8Tle`HM}E6aS|3T9_Mu0a-O30LGKV=-EB zoIW3Sqd3(3^5!_yzF*(~5i6TbITO+qW@ctR-efMQhirm|a)6bcP@cNB?i z5ZT5(GP^qLIawJ4mg!t9ldzsI*#kw|`_HF`*6-w)`DBu3;FPCGzcV^(8HE*NuGmX; zn!NvWIr0?%7hEN5iVYX*LyS0hy3xWuWcKGjqKnnnEJgY+{~b_^OD%bGTJ`NZ z)efwGhmpj|{vcB7sgrL*-t68W%6(4)?+Da6EX>4zvs`DU=;l@&!@< z@!sAF-iPV_$=GM!v&I@7rPi2=9Gv*OS%z)%!uNl;XJpKqRrdPt zU@)=G&CTE20Ah*%@uBL)h25fLD7dt(rnYj#pS#diF4Dh4Ttevd;McE@KB_8_b70(d zW8C-HxQhwP3%c_)q+^NTnjX^fv8Z`d7RIgIaH9L-8usuD1M&LQ?5!PH9OHGK*D3HM zv!OE8W^;S|7VI{{MA2?Dw#}cKMc#X}GKshMF8)AN=TknsXB-JHh46p5SQ3h(hxO)ok3Nnnv#mi^)G?geRBZhaIE|Jjx4pvI`>ORh z!wb!x==AR2O@#SQz22sFS+;f3ZOiXSaC#ZycR{Gr8t$Kz3i(4A1w>0yX}(yJTA*ptblN4 zIM`hT_tqc^cs=h8_-6m>bUbX77s(t_27TW>xvm*dj1r8$!==d-j0Hjw9jC)C^p-&v zM-56*Sv$aOo#Wktr1){XXReM>AQz zw2)pdOa;~k*lXPfTFFGR2ZC4qZii2)%!AF?#xlf+J>zmyZiehqa_{WS3y@2gPeZji zxT+fe^6?d?2`O*2!|l@q6G{c>+HJmIbC^Jw%fL&SQ?y3)fE(?zrQ5P*=_wiKi_<65 zam1|BCnt|DmmbSPz0i{@rY>y;mG>AF-14^lFm_nA`9aS($NCaFj5y$P-+Tp{rfY6r z)48MruM@O~Rh{aHF1t9FCe|EjKUAU-OiS)!={PG3zBZV+KN#F%)b*56hl)AatONxS zqchD4U->Hmqobz?H1s0E-szF*HM>}s=`>1wmg$8wnla61xou5~@)6z`EiYb(j9SJy1> zRq0O-3h>6x#)^v~WK}LiMk%;{rzBz7oNf<^w=ZLs^NkiZQI4dvsCz-Qhdd_AKuWK~ z;MY|aiq8ub)Xpe8dC22OR%ruG7FW6)R6M4#>-FI?c(uGZr&*Lj0mP1ZBF zFZN%x&Y;!mr!o;k7f`tc+&u_ziGbfZaoOFEBFwLSE5JO8BTCz3hi4-w zeg2hwpRCcRlzY3qUJH3`ae|z`Kqh|RnScGx<%&a{?`VGc`9<*EzC;fy9zNHp=Dew< zLasZmdyvZ1>{+AEi{;vy3a-Xi6fIe({3t<$PbxWr5C!?W0$CJ&DI@NEcJE$2a>c}hEjv9T zlWk{vtv8h`Hf}H;gNC@V>{A5q)85m@;T9MBOF`_}exD1bP=<^j4DyCcYkd5E@H8;4k84|cAyn|v7*~<|7>|bomawI=|m$k@Dd8S)V ze+ku2fnfjEJBC?aolQw}%zNhgHuvZAZ8&AxPhQ;$r@f9cHz*)k^eLdiy@S?%*Yayv z`zD0zT?q6&m&b_z$?hUm)45<*PxlCY$wVc7XBJ`WR^;s@M3XxoY|?1ZW^QkRFop_Iu+r3UZvd&!Z?20-5cLXH{uv%r^QohCsQWDm7J7+qm{*XG1EiBs#Ho zf-0=A*PqpE8v@;Q5)|Z%Ec_3z574KSdJAJ)=PximgNO!a^o`N2FdMWZN_Rt<+ic{K z3Pg;p;HJ&gTPtjQ$zJW}`*(fz@leD1+Fl%Xt4D}N7b&b)bH(*O#~cV`)-^h`NK&w; zdS&$$)l;OXeMvA^;}oXQC#|i6dUIG>Z(DW-50u42>=_^{V}bmQ=2>}vH%o=j$JEqR z|6S>GL<8uvc43}U6ct&*Puk~6cqosO1e@r0?kRe?x#x4K_bM-c=zj`~UGe7<8W5$z zdIbdne`Xw~5Rvx}Q`+?scudS>B&JhvkpbBVDSb*meF`wVt8D>UjJV7D!D=qn$@%eu z;$x${Za&{a3V#xMTDB}$cSZ0rmo;sOH&u?b1nHX`IT?<$juB}=RUb!{#f)goER@lz zr0Bz|)314|-#=$tL<^cX-=U=J*REKqp`Q2%X!1$UWvmD}F=}G}xM*=S_A-=W3cl#A z4p#bYn76sQ?J!BenzZY2Bb3rTrOWE*8bM}z&EDx3P(h{Z3;xY14@UtMMuOGP_hIi^ zUb>Kr0sSALB`<4Ox(=-V4*m-5iF7al^b^ggf~d)fj=%ruGiiFkUHVlAd3Nrl^3mxC z|La0piVyIyny6O)->ypkXSj|b5{_~LTX(dwq@lU5dADOYODu2v44|y4C1l>P;O9W( zCfzznGj?|YM4eYDGAn>ck7(R^F77fH9UI`OK08H*0?6fb+}SB?Yuv|gxtBEWH~N;( zGYb@2_mvO&Q?lj5_2SPpG%Zbu&`My2J{deC5wWjcZNvj~qs}zK^UN${6pu%L0yEOv|hz*{_*@|AZQ276|#~T!HFO;bb|6L;R zWt0>{qIg)Jzr#HV0DZ~E2XjBw z>M1OD!{bCdaJesL{ShxpRrXHeISj=&wmaZTnZWq8;Zqa!?^K~B1|N{KE^Qddr5;!n zBd7hlK`gWxIi}W^S*6VXslTdXW`feUFh_=B+B^eV_|4yFFBgIa61Uv2DEeq!c>hp( zq1nVv*%sQ}>`}hiR`$>;96zs47X&NjM7R71wV(7dyAs~l&3N837^Gag2VZyCSnUc+ z-x0sa8<-d3UaEc5s!JlWn{CgM@lPr_dEX<{5e^rtsk)n` zaOEHGWwmxnm@s0Usg3o@OPK#8d$#__&9Woh_g^X4Q5`I4@1^178*5!b`%S9fyPN}z zYw4IYv>JiTsTc_4f5EN2IBo2IiSXp|aI!EwPW$0ne87>gzx{!Ss3d$ci`Q z$PoR9h$JX(aJ#@Ytt$V;2xx=6hJSSN7!066(B7SsdMdQXpnYc03HMm{dfeag)++nG zIuyZ5Lc*=3L&hB`xP{%BkHgHh@y$%d;lUpJ>V1!ijagNaa4wNuDK_3WzGXD!Wza6x zCvDKiz_XTGuXC~Z>#ZUj>NV-3H_?0f7?%h4^uk2_ML#)71GPkrPRcYFp`uKyHoZw|A0}3P04m-znV3t%s;5{z}AM`<&G3u07y*Jc!V#UNU&T zj{3E($=5FP^8oPqcXh0yRIj6>g8)TN*znV4-_@bi`gP+S`PH3Db(M(9JiWI2qU}rw zUawrU+3{gd+sNB8Pu8&aTPh1zkG6-1phq4oLRe0HR4694u3w;%J4KQ#P_U3I|u` z0gc%~f~gIMow+t0>YUcXLVMWA6U)utYt$%~aF3*52=`inPy&MP4~n)(^$IWIoH@J` zLd@MEV!3q}^KaY@fb{QxVVGQ%|6^O(P}~~I{Vk|m=*Mig>_-Ruov>OQzDqjZCUdy= zPsIIKU?H+$fQH7}K-y&j~a-J3PI; zFVE+Iod1d3d7fdtPt(pnTZ{k!A4ky^{`274f7Z1U37R#H;wM7L5-RWZb8)tt@h4^} ztX<%B+JB4@pw^aE%U5p#pX}z!pZ?M-WG9r8rh6{H%ET0{@+G7V7zFQ>%JgcBtQ|l2 zW!iv5r|32u{DMWl8QhT%LUC{2yUi(Y+xX4Hx#ps(LGHfe3^DaDX+MOaSA}2u$ zYD}gU?h-1Idu}sipvk=^{J~43p-t>()ci?qR8lmvciF^=@l+^CwL8+19-Q zu((w!2bLk!%Qj<=0~z#bTiaHxP`|v6bw6~}Ibi-WU<_m4l9&17jQGef$uMA;IN@NX zI7Q^G;)pn)Xu?i8fv^7^pn_c)7HM9-sWFqC>u^R8nY}02er_1rXebcsI{y!VP{6M3 zN#89p>N=Dgf1t0bMsXC?oAz;X;e_t~<$Kd#`8~c3|3lr)T|LeIBsITAJd|DqRrsU6 zSlXfg3gOaV-Gz+ojmgWC>OH(HnuJ>Z-wI1$Ayo0j`&%-Z_j4IdOxJ^ zY)regy~$FnKuiP#%>1?$KDr;@B6J`rQsrS~=q*@&mKLQ=ReAg}6ziov?k&Nqe^sq5 zaHVHzy7)Uuz!XHx<}#5+kCD2r6;vCu$)8&DZ0!E0TOr_#A1X0BZItJ+k)!uNF2Hh| z6{Hn*bL+(k{q~LRa@D97^Yf{;>1#;(7?YcuyFQkuN~0D?E)Ph#kaeCGug|r$jOBHy zs!WuLAX9=+;nr|U=*&$1A&qz@-u_H1m-r)!kLZcFmX)+pm<8#6s=?lMpSxLYGWz$B#MMEUXldJBNw?~e6*f?{R8de-c*rg`YPkSi~Nj73O~@P zqlnY?+sP|o>cbm}Yx#?qM^st;d{jrtDP`sR4+R0NP*Wi0W;ZI+g82W7!EEpFhm7W^ zys9Zur?XkIqucdAlsxWMzK{@I864XK<-NwtPQP653J7>@;NaBY2(1n!V893$y%Q1!ufz_uhVOLb`4C z`baD;!Tlpg6the4*kjd+ZaJHz9&xq&&B7>Z*7p5jmq1z#IrR25vtqo{4qCboYzrNyzBhz z2u-jw)OkH`gYQ`pzfHUBj!_|--v_a2NlaY~v#zD$gFkgRx^OUyV5o{ReOgVFHrbT& z&AvVdZB_tjbTkjp4^3>UbsPfMu4TI5hFQ7eZmG#ie4>&1{A*N8d18tBb8iD{eZ7H; z%WTsg22yLN_*z6o&x9uT$IzaR*Z3-H8`Iq-hcX+N?gMnaf(+gQ6-skq}ZPG)+N zfNS+G{^T#21mv}!2PKhHaV#+f>LsH&=lv)j}>!2xv|({>1ye^rMOc~SS-6;7QYr)|O9J23j_ zq>{BlQ~i=)*;TIVe5XSmw@a!GTHT@eKV11H1nd$rdGYz#js_#>$$!uO4T!&U+P!Dl z+xjxkzJ!*xvPhi2Jx_ofJ&9JyAvjOkc&2#ip(%hxVO^|-FJb%b&clBuF%bD$4O(o)ha>Q)XT9+ zhdq^F%Z$CTYbMzv3XPt@R)5CFX#wdA)1=GGO9$#CmLU`PQTfdk$T1fgiu2p-jfCZ+ zTb7`_zIOA>qIN>9Bb$3SB|bI<^nGLWiQWCjTmTRymOf=;9t*w-UL^jPI?$&PjoyBo z^~~-2&88VL<*oa8E2V5(;=37+_%P-Ll&+BcY4oSe>7P*8*KOHuwh!ttD!mzR;NT$% z+rMkXCCPd}?$x*M=492WM1fe73W)2UP2o z08n87w4iZLJgZ=FW22YZzx7fx3n`FLtiAb|7+P|pxK?^v;%;Kqw+7Qg)O zopU(=2uN%6WbyaE*eg9lTJ^Xb6uR5U^g15-5@ z6m|uMG*>#NJ|UDcpGe)>-bW3NeSM_b6O-w-YDS6@(KwlOI&CCR5b0tp*p9!6R^RWt z;c~+xlc9W~P%&MA+vqU`k?U3F8`%wfFab>N0r<7UeTOV2GBkV3gP~-D=K0a8h zn~~8ASP%_MxY0l70k{t!!h#3y7&MLj`+^@tq74wIGQTQq-gBB&C4Z`wbEf0hWcjTW znFlmhY5c=MGo-86_7{%FV7;`gz%{ATn3mqz8^e>%s zqhhEE9Fxi1TLDJ&KY4EhoYllm1?__n|iq#bg+OX&5{L9R)tl94o^lAOalU~ zcuUp!=N*UXKvvFvQHQZ~+W2_6k~^RKg-G4$=QkPzb^ZQ-SgMN!23H$3O(LYO6NMBR ziWdm%wo6b;@Uz7kk%v!|k!QB5#;LTVFFD0s{qwiR%J)VFnT6I}{va z>C_f!yMP(`)97hpk0|a60`$PXr13TxdFV^37YlYY;(hTu)746M_5nE|SoaadgDymT zsC#Kr{8HDcLCH#X=*CEH;;BNuE`*{2J++wW%GmK!!o_E`**rb$z>)FsPD+bR?Xc?Q z2ZF#6B4@1CIB%;IB`vl;xCziW zL3it>3vYO}M(;Qq|J`dd7BHZQ_}I-YOJ$S1_Z}*pW%xsWXZK-d55H}M(3bcon|`;z zisicJHsO9n+qCP48cTDWuB`EDV`KhT7tZUZEmX)lNe^w1l!_|C|8Fzru|{-UhrZyQ z?0zw5Sx=j1H?MCXHH_$obA~UB!`$gh8jVKAJQ-39gJvjgcLlZ}E*#pM-7|utR({2Q zPZ`h8tVVgdu`;s8zuxG*68tn@tOz#E*RcLIRc?CMO0uGe6@-qWVu_w)Yk&yQv@3W; z^CrSVt6vHv^kddvQ#ZwVSY|&+@K_+JcO-BMq}~zV`+RfomE7Vt#+uBUJzvt_JRj&zwiB~lcdbB`RIfxoic)=92k>Sb zqzYsaAAR=&o+d$nUc_zMRvitOqvWL0_D4Mk-i2CfRGB9El{Tz@FEuRSF8=D8T7I`_ zQM{b8p3nU-wrsa~<%MR!ZRvu)eBF-9f2E(5bkaHyI3Kh1L3p=sxQNc; z6S^(axct)w!rEv5Zb#?oPY3Zxoi){I%yOE|a*Iz~SJ?ZdmiY@%N=3y4W9W6P_jm)u zOpiBzTw&KSNTNQNn*$KWFe~2fi`gHAC2p^uYmZ?<6%|J@EI$c;Cyf+{7(V>sqd>i* zpj8&nEW)2TD>$mrT@fl%eOso2Mo>N?f^9xTP+ZEMedcy2?v|_$4KuAK*5X7s_9rwZ zQ#|yPRLc7Jz~-=f8p^29ACvjCIhD$w)Hch7H23q?P&F+V^Rr+asX6L)tu&R-LP0Py z=(N}J>d4YE7QXP>ceW!K;ZMmt-qy6k+;qwUiF`S*wA9R!10gri?^^F76rp1HEUu;eseAiAUASoGpB>8DH9@YxWLsaej%R>u)As+uRS~h;olsEfVAP~ zn@&m5gHrJ=R%}oFK9GCg=-8%yGnj3KxBuiRrF;alQyW8qfB*0Hj>|K&GP@psE{3fd zQXT3;#qa$F5SK?tec8+-^u~K0rzRESz~|on zlgojIi#WDyITaJx&}O*%HwDwWou4QE5gj~Z)3}`uttM*nGlG(yMIC@rWCL92c=hXN zoB(WF_-GQm3*O$jtnjpRD7wH5yfA|1+5CE&U&F-QNVk5cTrtX?0|X*UvNcZ9WmZrv zV`P3E3dMKV>3`(?XQAK)(M(fC-tybu3F%afQXn%=M7U@7=>4C8Vly!_AwSz^Wn-yQ zo1QEMuESsSW{k>&I{)0t$hGN*&*0tdJPYeyVPB(T=?tVUYR)0Nyp{R1L?CW4P2v+A zd(ZsA;$=~0qdM+qeY1ye(=6f6S->qfi(rkc-gxQHBxbgqOgA{RB(U0`A?OqN=#lRB zrqsrBA+zbq4~$Y1?#(qKQc`rDyqjikgQV>8Zee=@pVUIEh#UDniD>l)Aj5x1P5ESH@}8P!P=L^5TBCuj zpLbXv-B=av^g29U%NDPuEx)4S$k@h&jTiEL$wA!W{Ub4nM26}7=5Xjp`tEG@$=>qQ zh}ubPz{d6;$9W-AzOeEezQITAi91iJ>X!Z=O=rOsXVW!nBv`QE?!gJ}?j*QFaCdi? z;10pv-F zr*pe{R<|K@f{;OAJ!jL!P}G%Ub|1z62JD9K{|(nkxPJd(|8N_F-2VM1Z?j{YGJI7Q z-~P=jycrWe!#)IE2L)A6mm$C2TntDTggE2==%O5A7VGSxbdOVe?4{rH#8^ZKYwD+wCkm}M4XxjjV2 zxjDR5BjCi`5m)wzw!3hlh#T_&Aenhbv_}9wV1x$8@(_mV)Adze68|^UjQqEpQ25_! zq8>MKvg0VDB`#s>SW^7f+(|)?i|?mS2$4aA;-uQqsa=0lI0K)6qxMnVCYp$w$7IH~ z4348p-;W~P@1)2&O~G13ZueW-)i{i~nILmi&oPY?g%Q3~)o!cZ z6K8tba}C;Kf&TJ>i~qkz0`tJl5zyH&lmhjmuq zrP?N=aF{5z2k^3=y;YfuVKel;DvRC5cGq883mwFH*@EE2U=rv2vfXDW#)RD)45ka5 zHK0fkiw9#@EplRUfcmBHF~IlE;X>Qnj^Jd$W}$YGby$bf)GL3F9PFZAWDWyD6r&6U zaR6CWde1~l2+V5P3rm9?kk@)C&wqQ5?4K3rX&rCDsgZUrL3KVXLU-ZJ&-G@HY@$uF z_Zp5X29W?K`)jV!igaHj^p4Pa=Wlih(h?V2a z<*9DjzM(t+eRU{L{*{FH_O2pl3m$c&YTzv?mv4ZN^yXf&(yb5W!PAdSys6Q6gqCu; zL;S@U%9Q7THGuHNw5sKZT5wnAbQu{m#%b-XJgxA_)ijNlA}9Z7${vf=kXU)z(qffj z+pwuI5F)y{p(2CE2@IztotEnj@pwEP48NA&4R@vd!#9eef`;0V{accJcZO*|8VtgL#e|wR6oZoE$LjuW*QTYSy&nVk>SS#Mx zKpjZ!$Y6Y8WOMA6oWPnpN?zN8Iz#eALHGkj1SPx%?Mhxf{8XK|EdX;0$FGdV+lY!kn1Z2PuqcgM5$#&6*Vzrn91iJ=S#kJzCzfwwpFn71#5 zw2h#DLgaK9hRI7hh&8bvCJX|MX)&&1MHI7F_8H~w=W%5utjaxt@HKDjhs3qq2l$(h z$FX^|WyVs_vP4U~sWteKH%K#(Q*6I@Q_*?)H$6&Jnc|LO08ym{=2%XLjybZT!^v3tRiUU(q)1s{E0p?-bkCPF1(||V{oZb!ntF*Izl;E5Kg>-is4^UAf z$f-T9&0&>+8T|Mb{k!)|Q*F82XmEPiHSbI3(=q>cn+Uij<64j|oo2wyb(APsgz~30 z7eDfXVA$XG0L|!e5t-D^Mt88y2z9%Bn|l-eTFK`%n$AoP=A6HD%T$cd(ssb0a0l1` z+}og{(RtMt{*!oSf~8XXQQ6aK`)-Cc+_B`+y){jHe+4x;tL1~0)`{0I>6LjhVtStG zDtJ#OypY9LJ8gr^-wU#*?_OeG;|ANE1+h7rId*6_fR%}cgEs-u(ja0Ff%uEt_|CB4 zUJ6KSO4Yh{|Emq(z{dX&4hxV2+S2BalOIIn>9^A^fO6Mc(66BLKMJi8i!j4_b^%^_ zBM*g79Szk;g$yeaag=d@>fDx4v}N-Zyapniy9RE@RF&%r!`OaX2!?|Phu_E#|Kd-4 ztxMkvN%L!yjq!Nxu7@AzXa_a}HuK&6>)Dxena_)IINEYZZn9U-*zj7 zXwh8>WF-3DfPMP>UYABQ|4JF}jg~eJqgAd5GIp%-?Qpb-*&cS!t*1a@0E{^ZK?(j| zM}VkR(DrTMg`-%xRISkee$}!l(XiW1#bl!1po8Hi-Sph-C*q}^4#kon>OSGPa%G11 zh_8=NQEAW>SB9_O8-Mbo{on}dT-KtkB$te;xC-PtNd#Z4yyaaH<=fNYX?YAK6~}K3 z%dhav_4h=~^aZuw%Ooe0l=nMG5b-#C9hw5;rC#+(h%4^lT7{e-*XRBicqDv9Su$-f zrfNAaPc+2JQ_|@7a)%>CX8@syoJdX#25Zvjo7%Noi|$%{T`eg2!i6yA3}f$Ddb^j> ztJN70pKV4qS<52{bJD};y@_?T`X;8`lb3Mo0;^ZpA@fy?cxhwUbgN&UBE29cpRxed z?uKzTs=(y=B}61tnP9+MdFt?vg?wGFp?~39!=;a$TDur8<$tg1zdEA3$j}@c%D7s^ zu3s~}6ra}v=PwfpA?<)jG5VG?zh`yveZ^P7n z-uWgpDzuY+H;REKN-_QR9zX-{)rVy@b4*gNr9zy5<9^Xy)DRgNj@DIiD33cj&4&pO zJzc%1WYn&7sfTy@2D3w)`{3JPA9^}z%eLJJD?90`{eemNZqK^y<5xzh(Ii2%#DqKI zT96}PKBMITfp8;8{Y!i>t6n=b&^IRfTtIgadSjcfAH!_e$&?s?C(GY%Y$K343JI;# zANpA4xBtpxCgZ^mY5JO|c2&k-rZu+}`E7rdeY@#>8VpAuLg?`s^!c|Ap{r%_8FTb|C%xQ_Gw+Q{ zriqlG_=Zmd-fnn|b=$@>ySwGeWYY!fGrNv^Bq(lzC_lC>+NZ-IIk`#5Mw%`kz4XgD zg|^X^PSDL<8$e?F;Mo=n6_s-AGNLlzyR(SUKMlBrjQhXH@tsF+>ZRhMk2fn z)uN0yZZA(gr%vlKS2MpJ5u&*KNOfJ=XAe5rw5{*qz7J#ZE5s^<769_|=Z#KU&Ge&1 z7^UwwupHVU1bRn%$CC^@U^?c7I$~w_Jr?Le$6SFz9j1*H5oL;mf?dS}lv_IV)FEQUQlM@usTGRIwAZaL!NX{p-Od(*M{bl1(Oc z_S-byF8>J39m{snm#L@dQS09~UzPnMn9no9Ji1u|LqjUugGEH-x372;*!0Qxrm~!E zN3mtSmgbM}1EW{ACNi2%cIw~O>c7FspBTn}>;TA*H*z)5z|KbrNo+tdV%ftLSNxy(^IW4uZ>2BbPU^98{K#>b} zgR<5`2W8bfWB?#1s8?dPBhFQYAqt;DpHMuy&TSD$h?z% zp1Yc+PQhJ=s^0tB3u>XIqVnoKKen=I1zFS{CYsY)a?qN&FG?-_7i?59uR^MLjrK6P_Ro*tEAJJK~{VC_8X;3~(ck~L#Bbc>#VS_&t|*`&x1aSF z9%LG>8XNA4iJFm7(7c+X3ZqjV7wcUfuY^6>b()xyJ=&5OBRJFc?US9nG#A4RM=mTs zPr6pmH>$5{IMps#mz3GtKr3KvZ@3AmTR#?PKpmyPeSdIyK6BsmuvQxcS9*(lc1D7T z9_f)fPHn+!p-K%48lj>n^vQz8sE%B=yFn0-J=jOjn5?O48JS~Z46_^Zmu2G9fY6cK z9X5tsh@7UMrY^L3wf6mn6bfmaE(S^D7T;6zDu11$0wTqF8ql96Gn`@gHWmZ~x;_nM zj>Vlkj;AuhjXx=Vp-s$wg`)Fs zBD_8b(gyMSJNh6BCqjc`G;g`jp=(p%RkrU#nq#fOMp)-8Y(lxal_jqL{Gt) zp;Q5T{P7g)*f>3-zAn{+86nEepLMg{S_2*pp|}z*dCHE?1lqM5rtPJ+l@|eW)GBL@ z8%>2MXr$xnme1*6P+0jiKM9@Gkja}CLt)g$x|#CG{M`XM#MeKHFR zfP&c_rIPnoOVqYR-ivjNOLa!x|Ku2q4AX(I?~rHTX@+d(BP0ZLPex0sPi(*{1?M1} zb%Juy5B`0Vqd#`G>*&!m@#PrzM%nj1??G?S3L(8e8Dk4(zP0g;k@k zeLB?&*w-3=d-L_IG3@hTiGB8~)H8r(WV_17|9MuvVTy31Ajh?cdpZP*wq1~FcB`rwSy`j>Gbo(;2;(I)Y{_;T|7xl;x=Oz{vm!$C6%H^E3AO( zX571vE1n@zJKHY1HjGAB=oWISGmRriyfwS-#7!!_V-#tN@qa!Un1d|)+`3cwd+DIV zqGfHSI9&*{^JUC&$xKa&3C7OrXFVdr9;ku`y?+@#xNbwr20@bq;aA`o8jz-?jHgIA1u56$zyyXM9ZNqdqyGFf?zjOYR!H z`c7{;5Zyff1Q3D8SZfBk--wT1sLbqTuKNbMDj4&PgHECQyUoi+ZL6FH6(PpNS(v!@ z8W!>7P#LuU7LIbrJG03LeR?2T1}`+ zp;NkE*h#vEyw|OMRk1Tv@ur4%VNH%YF=^aDufV8PNTnA>8ic-FZNMU+sT=y=EtY@5 zd!&{{s55>RJ z=71l>EUXc_iP}9Totc$I&{#)JINGrmki35X*$_AA*{V!Knh3hAz4#qDMdN4+!_%1$ zd5B#rkkiIu^`}34OP~4OU+WpAHp0l8_N7mI!lSJ)M>O7rSbCM+;ZZQ))UmKTAl7|( zJJTsdlzT?qC6gZ3z0_37^WplhIMD%ay+bW-wVRryiDDHfgT5HivAhB~r*<3=I*QLi ztmb+bg1+BWnVDz36vU7%YhBQceU&m^`%+r?6UXJ}1$6tHz;^owTd40@^Qu^0{ryGA zyU9(EkT-m9T3i@nrF?!(_5)=joYJr)b!~*9j z&c%_)*wOrT7oD3x2MuwLOFb6qS}WyYm)vsflyZIzE@g+A{ROl)gW{|q64sH-waqMW z%kZ*R>1Kp`ePC*k&sq2J@##-J%h{YwCgq*k%n$^g$|-vWSTH(|-DB9%TNR z(rt6tSejdG?NMd88>o}7vW)I`EAnQ(S)HkK&@9tiw>6!x71*r(>0Iu*ES!Tii*%q@ zk%%?MHKGS$Z_C^2cao@!io^^l^%*auB}bQ-wOiEAhT(D6Dnl7FmvBPxhc`Mn-d}SPt`7Lf!b!jXmnM=b?}O zP-;1MrcOA{AUHs!sSbyLTDX+cu(PwCY&#OymMf{K?x5G~d|P1eLvjmn^SS$8TX!t< zUoQOd$fmpt;Wr2wDBJx2=E}EfYN=1Q1M1>_nd2%{eKNvMH-I?5GOaIRYyZVc&Vi~o zhfnGk(F^fA)Ienj+`+&9-eCVach>)tF?->nk7ipHgtPRxbO<-}YsD#8G!5Z@Hgh0^ zb*~^F!6pjuxF2^DaIFvUXgC$;jfyhoPYHJ#U?mVpjc~e-^vqt=WM2Gm7eJU4DqXt> zGKcm~!!!WjXD9qYa+YW?(S__Xn{N1>P8pdv;5a{f&* z@(A(GKV}Y44sqxgzijz`h3pGJTqs?N&Ih9fEF%`*$i|z?#V0~s-tlXJ{K*{G4_*ZK zf-!Gf5&~ZM`@Ycb`(9k=b0TM9>rH1QMe|^I!EP2 z;_mco7mA!6O9~t2lX9(nV_kb7&#nkf+nZwB@!vk!O4qFVXRW`j536(+Ij_}J4x|??TTqM zNl#smFxt=FZvR#~LYh>WfY{)w@ND{-e^(%w@DZtvp`_6hFY&)P$}P;NpIe=I#@xni z3iNh_U}M#c^3F@j#n!aG*TjF@PvM=e+}iX31}}hYgL~WN@gG>Qg3gg-*HUrB%WbCP zH@>;;o*O$HPjo$;5_lhM|Jn3MKOJ1v+`wW{ zD)=_2zU-P?uea#bi`DCH(|YSO&<%TY)rk1x&)0Lo36<1)3!cpcJRYa`rxB78EI@~w z_II9(Ca9tLDnOdC94Du%Tk`vbCj7NogOo9g=9qh*+r9hEd;*S(A8CL6HS`i`eolsw z^clMGVS+NkIn3C_j;nl;>#e*(o@N<;h|N}%4*>q#0DL!D|J#{FHYy#9ofu=!r!77; z_-y3ZZ-CGw8uJoK42VW=t7gJ;-x&a2m38eT@i3}8Yt^W?MPR@4BQPT6si+jwRl;#R zy3gx0JVZ16;5z~I3dHgZ)?x@To$tQEGF=qd^F=rD#m}JsBJxe<5;(6t&*kUU z9swNc!ZrZ~YHx%2%E1`Yx5okbnUJ9NnM8oC(M_2`$jkj1c)i2-K`rQ)xzNUjzqTPW zjvSoI6zVC#MHun$#EOWoPYaZXb5CU9G~H3JZYM+luR0IZ%Fx>1i0dpNM5U)1`8}ww zkJY3xj+0K`6MI+s+gav8e_aFhke@6I*D9N{bQF@pxad6(IK*A@-W8;akUhtCd4*>Q zHrkT#X6JrXgD9mfCdH2=?AiCp0Z6e_9^E7lZ7>`eg=cvy!MH{Uzhl`x5KPC8cS6k^ z;6~!8$imzeJcYUWbtQ09K!43ex)jR(Ua~i2FU`MOmF)j>R$s0gIjgzz`qwA}JpX$k z4>UP6$+OG8QxfwFAfRs*_qg8B+I1IQ-psUqxV!jXN2~Tqe16=`Eo6Xa$m1Ni7L+|t zPUU;Yc7BX9zDHN{g#79d81B*$fB*95q4%NZiQj)Sxo&yq88YZD{ddUP&xH~}23=O% zL_Rwf{mvH5FAc~>&|%$=ID#9(^Q$qP>J;st0V-quD@zx+kCH-;P#}1QYx{~zJ6|<6 zdCUF|wOV@w7Nq^Px$6z$X8r)u1zVZMxvpFEGiSaK_{;`JUzZ;R?UqfsqAL+sQM1oQ zGRngd{A<8^3h4DO3)e^6!LYdyB~P!%XYqtN+hsf?$&b-)&l&-&NntbXT*!p5!9LoB-GWc<`W*j950h&X_l5+A*pBo?`1rE^E9 zwNuP%Qa5!njdV@MMSD=`i9>9TFoc_%(3YOLs0E=9xd2MxrRKL3-qh-e>?efil$J#V zYODpt{rVLF#V`Aq?deg$nD&<0{0U;97MOg23JB%e0jj_1=2<|YcQla2j^iv~#zSt` zH{7Mp9d_!|i8_S|dw&e;xzZQ;ci5q^90`GdxBoC|ym31JGtado{%4$1HV)H8#kG<` zCXeq%Sq3V)xp0Ht4f|hWj{KZg$GvT#ohBa@cv*7+HQuB15I>T~=fJ4xf_ea_%}%WL z6mxdKxo;2~&AOs4opQH-Y!|Xt%NYZ^6`_6Li=x^NAfMgBlxpSk~(hj^Vwgh09 zj3NtpjT+?+wI6+yeRB%&tV#iL4=7^(#H^7%B@~bx)$3uoS)mj>RR&zTAV@z=T){qUz7Tv6j=wNi^q<2S8~R_ z*hSRsBLSyC{@9(?_Gk#cW^H6tDOIb+3%~4#?Rh)N{b$?^76=5`JeTEx;D5290;z8e zkdYW|vb75(x3xzZ{Eib$oG?)7s%aejSag2!XttAWbY9KiyxXQuJ97b5WmE0E*UM<8 zDQ9^Hzf7R|;!_uawo*E1ArQRj{Nt!L?6CXnu268bQI3%tZQVxi>-=(pK+t{c@pS&# zVI_!qo4D~ndFp}+>wz`pI{014x9a8L>|&$WUqEoxH_g<4mM_bq< z#dsyyaVBUkcySNoG-L3`+?zAQ`8V%ec70+tjl^0kTM(qSY6Hq|YY6c#Qg?nRaR5wl z60Nc{dg9r;@TLZIZcldJZe~TisZQ@b0u>dbtf^^^=PNmB@D<3ez8zzv@ypVjJgY~J zsVf@5JY)KWnSb2Br!vBkGOW8sUEir9JgCPjWe$2RZf{-d8xxyv~s6>&F?Y;U!+6PX4 z8@E6`N`@GDi9B^ph_AKaMx+ZZ4~AF3$K#qA8e_R{;{3>5xWg68vxmG|F#DocuDIT= z;unVJ$}XA_akkaWHa%rsaw;fo)2hp()kdKFKEVD^C0|3J)cZUUz%_T5?eTCCe}BHQ+~YoR06}ilMr6Eyw0o8*xTyckivLFSpkAh0GW&~Log68+V2HA! z&Ze_-t;V|fgn+2ID#7%|{KWH8;D8n-f27mGD*L3YpDxXMNgTNdDpeE{^S7!hL;Kj6 z_JNS+4S0EjiZYeHw0u{=Nh&mgWjP-lu-pBR<9o5aJ$4jnBl;)5O5jdV$PC^z5nc-nXpp~~EWnM#%qNEIJ<#<4~1U|Gqk(OG~c^ezo znlSe2^Q%g+E&gyqjNOOV21m|meVpUyS*!0BfqT5m_jbfswb^Gz%^y@VUE1#?u4TNl-|3&@kBhx&^nar z1vfC*qKm#t>8G(Sqv@vz*AjQB8`p84#It_c=ce2lawN}dUh4WT&4dZ!bANXhOv+oe zWRqxd%%Mxj!Y?`9u967+a%d%A>A2PVM)PkqdnV7zX0B`-*Cl_&Yzr3y~rMkOQ(FLPrX*rJ2S5sYM)tKzp9rW1l~?jWmA*gZ}QUazV<1Q6Eub3usn zTi_8BqMv8nVv>T`S0jmFJW~}r_++-?M#R?NWyX@LFEv*(81}Y1J~;dLk3`htU8y|p zJ-t`OV9#0vAAh%8Y4F77j)=A8t6cfydv5L*A%niKx1Qjn6`rm?w6sd>F=8-Jw6h`Q zSsyV*NI!x;K`!=3f!IyoUcF7^`t2u=%3JoFuD&n?PyBeiGSTD(_jx>w`tiTb$6x{s zJdOcv?5IT><%C_^XDWvBY4pSg$}w0!l}|%{7}9{VdwTGjzdg3Tj7E*C`6kfap*3oo zZgk>3nc|?;^B||?k?+jsY^|dx>vqbjPyTR*-VKvo_ zKdrF?)p-)Z)KPxjWDTEX4Mu@)i6AxA-&I@x&9MOA13?|K)=m$gQoAtrXME8He^>-B zywP_ND~<9I%dpw7~K?6i1uJur>RpLGFJP-Ctd0d z*SM(0%FnJm8w#Ew$3#!^+w`I(XpO+QPLJ$GADx_vz?K^= zht@YTR1L@9IESuByzSO~kH1w=I4?+NI3k)f_cBG z%A;rhDb#p zWNk%eS8ZA*iy&hSGYKh>OM#6A`( zR7J%R`R0ykpJ3A`NR6~A#5ZNii(F%ikv7leO|^tC)eO1NNpGNbV~#`@d>5J=81@W;#*{X`NAzXguV$6?7wE4nTw`;WWJ5_tdL(ieRU#3 zQcl^D0SIy;-Eu&eNTHEayI>cc(GiCR4qZp{`WdlPMWbG5m^92MfU5Ow#axQK6B$e{(C-N#jja+NDAb@FwygTIxRFh zzxx5%A2O5mq>#?Kt5hum`W$|D8!JDPU5v?kL6pva7wS{C#>NF;+u5^E`ZBjhXhZj=YJ;3+|Oq^QgwoooCON>^jfNE)PYV_FNAz5`4$mmp>(6( zYyo1%aBxq=7hBMM=uTws2%V%G2MboZ69)|~Z*oCJ-GSgdEk&4z)c!`((JDw70_!`_ zkC676mKUjfdrkP$mr}DknmLcTKe1|u9@j-X7PLe{%bR_|)p#liMOOg?kN~<(x;9@orlsU_ zt=fsn-N7EOJC;NNrO<%GGy3-hx`4`EDWyi?vYoRt5}c1ja0vwmi1bY|@~@J{&V(-+*9 zJ7}cqdeMEOhzudaMku^93PIX|2FH9d?OJ6s%9`Fd$Gtu;T@eUY3tY}B5&~-mR_dY@ z%o#E*SK@&f6K+jgQmAE}#)@y?p>BJ@xVX0+Bp2IJ4uYS)2S5q?BfSUWZ^?K3wy?zs znpOx&E*JQj1M88__K`xy4kEg`5Rjs7ouY}*b8e)aKPUVTO|y*}o`P69!{Mi|j3A|o z`G>3L_ubvyZzT;AMvmvpmdO_)d3m3{lZW*8JXXA+BzHe|+YLsr|~l5tzR5}NGy^t zxdIydg6TeR=X3uG?pd-~t#LgK+P*>D&gpa(%{1w^It1DebHZ zhRQTC%+$^8YKDTl@sv_z?w2nDN{B>27?%KLoOwWP4Pk*8tk+ zSXQmMBk(WXx|r zP#pH8Ys{|m=^)$jzyu{kPY{Y}D1@eeq=4&7x!M916Tz4L)79qTt=9t{xEB83x(Vxm zpC6c_0k+vjW*C0#*9R;L0|GyKAf5Qv6-# z3DFPuetmTQ)~#K&TY!Kg+dnh*KemOj5?}P<3LFgXP-}h_fAi)tY)z-=wSBzIWm-Al zJYC0YwYZVB4|xA~dU|?&5%}?9&Nt%E?5GqGA(VEeF5*%$Pc{Tjrps`nf2McQx!;Y- z5z~ngO!l#JdpYeq^71q$z3?a@b;qMm_|%aE8lmgr^z_9MT07!otNoV!6til~g1RBu z8h5PbJ5+Qs{*{pEjHe)69H=vh4ed~TG}owh+Qsr-Jn;3@RkPUk>p%TF9$l-iFq#DN zmuf59o^#~yGG$Vtv&k7Vj##Hl#RNQ0DHcXl`wz2 zj&EjxIDsvF?~hq8BJ*)gbvfGx`btG}U4%vC9#9{!%b zm!N1!6T86aAp%qTAYVe31-mAHTanxmx94Sj)YK>UGog2Rlxy@sb#2iH3%Y4v6GJ#K zg0(1_SMiIAtfWoNMKmlPvi)Ag%pcro)9Gu+1juO@SF9w==X85CCnh;z2@hY@kh*V- z=*;`{d%EsfV9m<7QC*X&O-@}=+M^8;ojR>LBE4XF1RO*-QF)A|#C6Oj6FG;GBpBz> zzgTh2%B@eb8B~Dye*5B^bi+x+1T5KGk-diWm1Th@) z*0qB!pr$rmrmd6;U0PL?bS(@LfC65y6b6z%5me5j1U%1)gY|{~S#c*6#YS8bqwVYv zElim|vn^ck15F=#HifN67k%{A=Xnpgs-D3;6G&7CkZAnPWr(!$^13zSqVx#WV8y1? zfySxXY(^!aQLNBpWT?#HoUdh!rT=aVBETLclIyb>*K;QrB>=q$Y**N6mKeg=Fo8GQ zdre?>B@>yp1@l5^(Dk{v#s9~aF2LNkwf2cH4rXM|in)H5bUiK>m2;cNZv@+JtMuf3?)DHWAV{;j<^suO;FR{10o8U62RJyXhKR9AQPEV)|7&X!AODvi#DadP-RQbU60O7$nbz2w*I zDQWxG&5A`ZV+6w`sCaM@DR0J$`{BlmgewsD!v5kx1r2XLSc%Bq#|3L{AhtI{OJx@`M zZMqImW1qn?{lc)e-nf2jBx^ixe3=A$5dG-%afSSEikA|iuJ7sUzL|9L#%9h0&eXkx zr|eqh`K0jP$dNRS@TTV`m?vT6U(w3`lWd0{k;=6#BAtGif2#L5k##^AV|yioujO$e z<{k^+=Tu1gE1^BK2f7yZl_l$yAMVsb7c2!4(Pv09QFvyTH0oIWM3eTrWkd{wk zoWI>+rn+{VM5)g<{`etN@|>DPgHBKg>U;F^QIpYQD|aV;&t%|nZwwL^Oj3Q4j{QF0YU~5okIdLSg4jPxkcs-&}~A)Zo%^pnxVIQ*T~&9oJ2H zGq=UT?a|j3EfSCNMeQElj&73YxExU2dG|@F9?!2H7>265;|vp*OWzR!{-Gy^P+Mn7 z04ed!TdG-fIB7o+PA7vdRdI)j_M4Z)bJ6B|LKio1S#vk&T3*@LmnqTUH z==w=5Hs`jDL=?x^rg33H z`(N3bh~h#8;kyGreXoT|o`Z> zF0eEYuZXzs;x1U$oS?|Bk)Ia;)%y>h0lYC)nV#Z;l zIR{V=u^=3KaxFV>!BpJvY5xKO?lxJ{5w@&b$G7_4?z6R=N!X_tK2#Cye$ysibOw>9 zlU1Hq%jR5^c|^?;%5dl#~1r! zyoC^0KZ#;T(EI;6Y`_s@l2A5dIkA&HBWCc#IZ>ed*F2q^c&SYxGH|IC^P9V)1)we# zS{8cLLCE@pWEAT_(@tgpsN|_m?VOaBf$wR4`*Wi4&YhPYF96LUfyo~4k>ZcRu|b$V zQS@nv6?*PX3iPTfNnXvFAe)iea_P{f)KUA@S&@c?fB9L@+ufTA6S)!V{`rond|wU^_q-(aIc-){N4(P?DapmGk-QAzpLeYYYjzCL=LB+wcV5IA zB}BQfxc=aYT(#t89vfsT1N^wmi)-~NAF&u7d*Ys5@WZ)$sSHHdNI+s zmyJo3Ip8=MJ&!k;*fSWEUNZae=nL$0tj6l&IB*COa-h=aiCSgVfnBtbdq%6QhaoCv zXWyHl(a5+2^lU0;(29&+ytRar`-VuPk~qZqlJcylT?TnmHbfu#;yjGx&obRQvT~7a z_4>c5#ZC-cc}st*9X{Q!EV{7$S;F!}G1=woZM+kfYH`!IBLlW%wc_ACuHa+q*jOeU z8~uZ|%R)7tOTdP%^RB;5&Y?q!ceRsXr70;$U_JZFt(!4{-pK1$9p__gZQTK-Vj$XC zqH{QI8QSrd6Wd^AN%`%%$X}FkX%S<0ndIg|HPmO#KJDJj(&vg`x|z>G>u~MNA$LF& zDolJh`dIQ4@R`RW;*ysjf8%O5UezL0@Va3^00<}|c``Bf^D7GCb8eK!9vKAE&T~f$hYq1V()K*^;ucLaTB)fw~<^~2{1=GR?Wc7h2 z^ySIZ0VTSvnQOj6P1VzA2p+n+hW4h-0X&0u+|KmYuuJ!`)Sc+w9t_yWYYt)e(<@4z z7hd4K4Q^6-)!+i3F9?)Bi zsIr`?2uB?;zVDYtx@Ka_d&;?UFb3>vl0)5uyeMX|h)83-<+EaslFjixE+LTlk;58Y zvxGqnn}1IE5BduGd(-`9tyQg68q`;fA&VSlzv4D)r|95+$*Yor5cjF@s1;oTe^?8A z*UK;7tfQ@Cz`S6?2v^d?h@jG#YWObMBA6+BEMsdjo$ty?Nz0rWSHOKOi=8^v7Pq3y zx4yiwt1s!j3uX#Vq9`kNbKY;1N)nv$zRl%3TP{U+X# z-N5Tc7o6nyobnnSxxJ9h!yVO5Ss{nKX@WV&>WFf4zCC$dUzPw+YLRNk;mk`Dq&qu5 zmbu%)6FhRy{o^m)HA>c20VdW&-uERMR)>e(mmPr_#j=Z?mJVn!Yz@4EMTXkfU))7BXLn_&i$$(-jm?h`lk zL1%6t-Wat+REnuhK88G-4`wa@2adI{NC*ZnY9OBertN2Cct^?IC2n+)-&>KMoeL}m z0meRKYig0C)oeSP$9%>2>VSsWkHq(ratY}GX<0)l7OX!a4sQQ$zfWf6gXOR6XRy=x zkHz^JG}upY@utr!a)+9(SNJ2XKVA&lV-#yPSLtN6H)Y)mSUGvMGx9bKGIDZkOrZb+ zMjEI`IZmI?DCozzqNd&{%KrORS)*O7KS{0eH>IY1_B=d{xvs*zC{1pNvh!^3+Z4^7 zRs;)ZiEQP)dBn9JOvl^juQOLWw`lQHC(~V+)ni((F$)r}>VI^MVXk{*EB;#F)Xf`7 z@A~F369!=bH*e8>Spl<(JJ?qty4=#HV|!3f+n20=%$3qTSYN*Re-x*#a-}BHNVQG8x zXB5UL){EeEbPM8E$w0OyV7&cbI+XiIgOT4AY60D?7L0c>5~+KI|KFs8?k+ zvuC!o+V~jl7+EzA2=~H>HAeN)Y&Uq+mzZi)Q{!^TjzeB%w6O)iTC6#unVU&rE%tE| zl6v3J4V>ke#0cwRe0%*;IYk9UoU$?+AfyZ^Y-a~UUyFbPK{*Aib99#no^z}9=7@HQ zJ2l4I$DfyY{*AYdD0kwcQndHGu|$&Z-E|{Sk5izwI+43gMT_FY^A8?)B(1B(^JR4% z#P+gI-9_(#P|j1-slcw@(Z|0ePrzNKa|VVd{vKsVLR@7|&HkN;F95Rh z-$IvHp#6H554TX|bN6NHjB)Y*q;$Q8b1-{FWhV8HgX*X)s7JcHIY;a8(}ivvR^yJ%qYJv3m=GKBu`8 zX0*We?CreXgaj@!#$Ag^Fh;%*BcKR@*HOhQFwD+3w)&H&^C{h2&CX98T8urk)U0ds z(4`^q3`Be?| zHST#Pl|PT3BhD{l#g&M8mQ^Gz2&-L5>$mrHRmGlRJ}%Ra55CVCe~?2UDIxOh-`!L8 z&*P0wODZcvd*s{eZQ~MO{8wPr6<*uw#Up3XO|r&iJDT*E(=}()@!E~0o3oe4w_X1g zH_OO)s-3PHG6zl~`sxB*y>3dS>^2fo1B%Z#NXd?Tn;O^Y(LY`8ZH5(lA(%fQp6~hs zL|A(6mUNddGmGmj)xSu2M+iK$E*lW#)Toaf+O+n_RaeUp#x0SqYlHA509g@4dFFtb zPc`S$Ss{Yh2S2eAiZe1`nKV~emy4D={+#7(N72tWs<%Y&xY|YIGt+re8I8 z`VRHyMS>EfZeK=644va+K1OcxTeLv$sXQdYFY)O>dWN2Neu8hF4k?F0Pv((4xZBw# zjZq_&{Lg8IBt&Fgzmis1gxEQ5U_W_dQNhrbC`w;;A4YTzk^q5h+!9dLzf1GIdIWvC zj&5t44!X|SjqiOFSG~8~Ti}lLFW#V5nSN1bqf+>D6ogkR{O!!`#}g!>b5G{Xu-AuQ zCN`-1rZl;kB@|2d6mUzOFJAT!K&)xkjB~KGO+$H@_YF;|Q&C?_MzvHv+C~3yEYFfN zzH@Qs0o>KoG~{7o1W*=~37^T(Ff_A_eM>-~^{o;G5p}m;1SQt@kguS@XlJb7sxib0&NC zK6{>dwm)b@vJLxn2JD=8d*Fx`m*Z(8bD`1lVRgsg*0ND3+Mh{>R4|^5+{pqA7O-O6 zto;Q=ZTDc7(xz~zmEs+ICfQaphnnl_&#%(uir#S+Y$rGUcsfge8hSk=ixoPrS@oU* zPXh;wsw8$Q-rPgQv$J7vZLEc{&FICaWN#^V!G-IYXuI0YmkBou3<`teBU@X=oO>6k zG;6^Oa3H$AB0$VJ5ocvrcz;T$90pdmomuH;1v)1@?Miym(R!u)1DKq>w63_xULGZv z#o6HZ=i0o7b8U8R!|0LV*>yYK&5q03DV z%A23#2VU%vxL&ok@BdtI3L9Ce>O|Xr7F2y@L#e_cG%~f)Lf~=yXvgcja#xtZTSV*i$i zQg}oVtbf@NvgKB+eRnpn`m5iC!WnLA63&0L_}u!aQS<8c)$Ox@m>!|lrTX^8>qQ%N z(%=BONMm=V4Z6ke(tc%ge|{eie#w+l5P!RdOWZd z@Q=;pr|Uzq_<#q}ejD{eNVXvZRDNvT0!0xiNo9}0r(jB`r$k_DduU;{QosW(@f!25 zsy`;P!@V@7@3p4S60lTP(aAsoH}%j{6IDyuSljy<14!>#CjrTy`Wk;cEoZ&Ag{v)? zzMs?~G*4VxE{aP9RP-M6phKY*^@AD2JRFfsv~G22*s!rux`!5T`w+vCJ((2B(HqJ@ z%R*b{!gu8BbLxGU9cKrhTjcH}3gt!EwU3UIFEc}L>dWYTTJf>ZsUWi0=On)#$M2TR z&ma(pG!)lkiydHRzj~US*RM*?x%mQDr);Ic*2d-y%EBMO+e-wU+SNM|DAtsc@AyuxpM zf=)jB6r*^f-*omh-CHSi*4x~Z@`vnMW4?uo;z=(drXM5qRnfRD4m9Bsf?%xjXnlHu ziuHE3K+v;H(My$DCz0wlhYM|C_R<=M{8C~3!M3~eOh)=vQgw!QoXXrNg)hKmJ?3B_+TO#+2^G1xL9tE0U(XK3z zIDF2S$+r;(?W;YvRdIZ@^h!fEIQ9fC21&_;Hbg(oXSn%Fw4;IeDG|4;MctW$Az#t{ zoIj=4u9X-^)`D{K@LDQj)DpD*Sf`0cWmsI)Jg4b_PDF<7wgXHF8F9y{%2kMcSo!|_ zyLX~_z0b+IlHurIRKg>bJdgFBXp`y?)gzue&h%_k`20a%SS9OLbtMwuGrc9#`?6?9}iPNx#F?G-iOUcAKDYzo({{TBK?#QGqg zM`qx{fj)EETT0TWwyK#|dytUU@7h~pCJWjBTefGv^ZQW_6BE<@kpFQzr@OqcByFeD zbu^aSi{JvOnW=6#tV=;&?x&5*8a#sb++FGeuOA-qLKV`Fuxh+hXu5Gx!YTjk(QCd9e!29nkTbYCahP4I0bHDtJK%N zkLL^JO8c!M+Yiv9cO_lv_0Skvd4EPUG2`Fr-$aGyNEtHjj$-5D(*DHUFHE8Z`NLkm z$kZlNaFA`cR9_KlZdr2c2;K-_j&>XNiM}8(IMHu|^nF&ZwjDRw#a%w064RSAM!8ZO zl0*I^1&bp1s=hs+2g%s1AqhoX!X3Ur^kM|cZ{M*~r~$FfEX^OBKgjiSoMwuB@C26T zh-j;R((!dPva!&JM>f&snsk>9YQT^2#wT4T)qMhJE-y`M7G_W>)OH$BEZxas-i0}A zOi@@&r05?`A7N#bJPDEEeDxkhAJ90pa44PXbxT`){S2fty6)MzXB7W7l%gc0F&#Q< zkoY}VVUTDdNGudH#GozaXQkOvBZqc;;KAY2ED}vqIQ}XL9?+@O%#XsAsGeKkA*fCy zJ9A*UJAoao`lSwG%tqdJ-ru)z5mZ zmxa(Orx*3lbXTXfP#MkYo>Po0Y9nWFjj;?sn`XAq{Csutn}YCM8_`x2aDRSwDjp_> zM+;sUBW)qEI25H^)#ZyahbZz{@{u^nO+9d1`V~RloJe)}-lz=dTH59#F+YyhX!;Sx z98!%1;m6EUL&pp3J*I5OZub)|1=~-ACnP)r=BBRwL}#?phZW_8%Z zm%gk|Yk=)XbDa@MrjKfuOD!Ea!wjZfmeqZNh_?)T%8bu6+hn0v3$6lI;pTiK#^1jE z++$wgmaVJut+y+GGOYoN58RZLeBl3fi?JxHDE)wk*=iymIc{>ku~lt<#I!+AK1+wi zHQ1;uU6aCAy@ki{%&Yvv`NavmtBV4&cwEp$UQnJ=2GiC;Jc}p#bE$|5?+9zjQ@8m| z6C14l7DGvU^r#9S`b^W_O9b+sb*Z8S`B;Xz_mqKw&Xvjf%{Px{=`}Y@JkLjXV-&S* zPW%YAC~Wn#rLN@tNi3yr%#2WlR=N|Q^cm%lS^x7qF@n;?LPljZ9 zb86%MipWFagE?4%1Oz`W8UuzYG#tY@+5$NT$5w;0o!7&I6x%z(Lhjfi?ijF|L8BUl zZBg`5t%+TdxRgPcb-8i!DaY`1rq0ke_t=iT69&X2_(WG|EtB*Rrs};gr#s%|M`QeQhuz=m@K<569E>@juM+3V<}?(M+X5K-CwtaII?HS6G9sV~y|eVe=MszeS`J49K@IPs$I0HBq%SyOWf64z_?EOuHQ%>qU8{0HoB3%26~sb?Qa5vZ8J zG&lL9FY)dsFfz9_DHA1$pq>^^mk|md5-q+vK~J_`K5k8`mTO|AW{{=L5ETXNfe-=P zQs8?a*)6vu9kwj1n8thmz_$s!$@*rk9U{~ev%!^n-r8tg(^&anL?-D^4zn}c5_R+- zJAQx$VjL4w#su9R)Qt+zA`*!KacFo_W*DdpR*y4sa&qiN=s3;&&E6Ra7U1@)MV8sBYAASa~X z9M}Bp#e5TUmcBlvp7LnHB2H^6yid#KWR!h&JOO=&e;D(IHSk?gh+GShNqoYTH81D^cKgiHT>Yn1bfyA<7gPG<2IJj}{%aR! z!gz^YHWYbWD+hF|zt!?OaZ5$Ka5vkLMv95|($r)>ZdY|)fCuv_`lF#AaHu2_1ds(; zY~?g3ykQx4(5s+ce^*L&>syDcWAcwY+Fy!aZgKmFJYcEp;4Z6w$Uo;#o9H_ zmXbCdRUUBQic*A)u2CN6GpwtEABJeE+df#!Qmb*NIijc1f32Ei;C5lE1Mpmmg?8I` zXZ1@)v$cmQ44(FW4}0`-#=Zft%_p#oI_r;@f=z5`H24G)8O_QY!<5G*gJzt;)u;sP zh^fUzOqA-=qF+nnJ{aW&-T%(MZ)x{!U`yo1V7KCmBWyEAETf^(*s3YY>ktt!KDS)d zV$*oQz}dz&fSPb^5zk@?lV;j_X=F%rxC0E9)x$U;o;pph+QP3^y0p~>&ux9C1z%`r z3`25qnZF1K#yCCD^8xb^?z8uKwcL{QgVxU_z_ea6lfOn-sHZ?rfHF|%+Nc(=Mj|Nk zCu}7?*P^xL6i-ah^w%X+9qsrb1_Bw*#xC+oAvT%Bn;M&6nso&16m zQoqjleXw$xca5<`(0$vi5&o&MbSNJo-nk|UvE{9|n1rQjhKbvDvsb1N6BCn68u`ej z39-s0W8_HF>k1pd0Q5!3`!KJ6HN3Sl74k?(+o-q|9R!5BsAY+?L3%rA)~^3xA9qI7 zUGry+G1m;sC+h#2aV8%Nw{(ezz$Sei&nUC#)x1+mVQwh}K3cZAIaEK$j&&t!cnXSc z64deAaa~;(WkNB18HqEBj0c-@`}bYj2GM+gJ4;-ZTH9p$6Fpx#dxDjm+i%A2F^$Qk zzvoI;otLPX-dtigO*6yqZmZ|NLg+FWLRa{rvCwAhr9<7+_HN9D(@vP$(lju3Hw0tO zf9e!&SdN8>{`gU^z^7^cBFm#~q+ocRB`B;+Sw95si@c}vZ0pgQ;TP>l>iSH|^*n{d zOyp>H3ce@Mla?D=k=n8R2&L6^&q8dy3H5YaMh8^a0FFw01$I@lJgGWCb~RN%>PV5( zrJgHUI9xs@&1@orJpZ2QF8%lb1v}eC5p_?!`641(-Qrhd!owIPO?vA^iAWD&%t&&F zN{^uc-1;*udlaV!Wz>Zh$4Xcw``|w@x47t#vboBcu(z~>=ak9yTCfbz+I-4gp-0s}UsjK97!aFl5djSPT)X5cpPwZ1>TJ1Q%1GvOTTvK^nl&l;taJ&nE3C=7 z90`N2(m*qe9#rIF2RxKj5`lmaegzZ&cu0qe0E|IG6av6u`P$|C$v)NS7XRls9*DA~ zleM7lDL84Jb9bU9#4qc?3ILkb1YnRxVH0laQQDqh{K;@frgilAwS5Z;w)D82>Ad$m zyqGbiQ7Mka2|*XZIp}RxBF*iQ35wCTBP8Wiqr+tDm7acFjl)W-^vYw74a`r34bZV( zo)vb1JP>j^nY+2wiiwL~ff&BBB9Rbyyx_)-w>hk1X}yVKkW9(#JYe-@lBJ$1mXfku zZZ|u0;)8PVdcW%4gJY@m`P_4J^OG3C4pPLMJ9EYN=EjjO%kh!;=XZSIo_jQE*JW-o3xIHCc8;6*K? zVNcLnIWN5)6Imy$$ND3OWug&RPa({@WY&a!b_W7C844fv5!5i(Sc;G%IiDbk1#nBf zh(O?@RzJMwNS=dB6XA=G{?o-{7ng&BB9RQTXz0HII`{6^r)sK(w4(}+x1{m(aY;<) zqK%3eS^`A1K)nH;c%es`57N{%?}FZbB(Qa ze;qoRVhw}%)jFsL?Skd=aEa;Eg$frlNqV4oa?P$gm?PZ-FG>DFMsWktS{ilys!Cj_ zJ3`}yivO({6L(Go))7I7=ym4R)*mS@yhOPma;|?NCtZM6XjykIBJtfOk~o}4AQ^Qw zbNcBYS7IOXED+ax>wZ)tpFo^|KI>PEyM=cF=y1~hCTLtGC4C(8THaDbvW~*JT+de! zuM#MBtGJk5;u}a!)~*46y^S$)B&~FibylB&i!2|?@C6Dxzals&B04BN*W^nlS5f+6 z-LdSobZ!^5G20PqY234K%9f$+ELJ4~F6JfO{?+BlJwXi80kY4Lr6^_fWBPP5FMwAR zhS>$&zm%b);zIPANCiZ|HF0PmAg-SM1ZyCK{E^n`;AJJQ57EcVGai^%a%_02+gryo)4gE zzVh^?Uk!i2ur*Tr8MuW|(pITuh=kloP>lG}gNoOouX366mbm+r->-?4{%iR8;na|} zjEKj#L~IcNLWy>)s@>xi9kYw(IYPOcmrlx6qfhGZ*{Y3;XKnY`e>!^HsFknxPESuwkfi>6L4zI3O|A-b3Vkl|j9e2;DKF`y z*!={m5`G*L#}@}4n+d^SMZL{8-;>U|J2syE04IHy7rOhj$Ke49eC^U!h4gpxM{R${ zpt7anOiZ6$E!HTqRdb-Wl^o!`asLWr1iQVdgtSYd+k$U&xZOfcU5)jhN)?FeqeHt$C7xv3+d0)q8D`{+$P1fS%Iu8ke+oRik2}0%=)bP}FLo z3=XHN_6~ct2_2SkkK~7HP@UZbLdk6CH}w-En(7D91Kx@1fasYCP+!D}&Dr?-=C+-e zL>w@CkR#?>wpnbI7dI_K7tFnGxVP{SUH30T9@h4irpe8MoR7l3ZQ9RwL;x|4O?*C% zH);V4O*ec@<-<)wHs1dLjZA9|mv_vt3$IP-t3Lo`O?&Tkttbgu0UW#gQ%CGFXTpEj8AHp65DgI8W8;bXNp$OWCmGivo73B^5J$6k^6AT+P%v067f8issjfYL zwQiNn6?`bLNymv?3N@Ccp6ZI3sq>KzlWexpp5AJV3SyJPAVEicyhP=Z`{J=xN8nMK z2L9f90(Dapq>NHy_$CcS9)-V)^mGCVNxl(?r=up@icwBc@029#nps6gcZ*$FHnjNo z9xwalyHCm~4ZDtLfkX%8lLqiD*c0+Qi_gF0goG8{d{Q_7_@SE%j8SH(g47S-$mznb ztZ!ngRzVHNX7tfEi@|aq-PCUWSV!~4p;Q2I7(-)iv|{&qD?K}#vEPfLDKZ-hIfMt= zGr97)FbSo#L|d%&XcN1>aiS|EWYO=IK&Kwgf2)|$eh{Ma%xWHtZ z)+eT#IVr%@Cp)}c$wjwmYt{R^$(y137aTo41lA@>-O84Tk!&IlGE(^wj|=`kEVVlU z3UZ>6kS3RWD-=qAP!AcapJ%OJ&HO8~_;OskSz2oGt*Tx^z{m`!-Fz3h){RN}v%8vR z;E#OKW8rtfr-eI5r?@gPaa3eq`znJElN=dnJD(qvL(OW^fJseOo2n~LYWZoUO;#Au z0j&|REt=)`XFs1hEsWyJO>6n;e_5KJ5%}Uhx(d>!{sGk<^K08XLj_{*)KZpX4MPLi z*iBmYj3e6HLt`tCtz4eH?*JNvX#C!mbA_p3-`%Qo`7va%tJ{;L<0jC)UyeM( zC5T?%U!nW6z4mg1|I(z70~R^M{A=I@6U3MIEJ?(mn#6ZSs-^8$R5qH@?`}wUo6O$` z1US9pQ3u$Q5Oc<&t1kZwxHwp6r~v$h@KczZ@S9z|OH^u5{v?~}7m*nC%2J>ICjt{7tP;?$s#34F z%s)Il`HFbXrozM%T(y36)VH&P+h@ltNJ#WzJ;MpJ9O^bzW%_F1_er)@uOOoK|SLx>%TYDfT+< zZ55VxgK#(;KP#0A`nykBQrQi~zbZ8HWH-5R{jvO}=IS+|PX%d6hdqdlPjS(M&_~kS z?{(FEFxb#l4orLd8(>3k#K7Rl&)ULAY<<_*dFNEvk6Y`;BIM^fr}#0_rCot^Splv9 z(W*@1bD6cWFK8)(4e{RVv9(ig}dR?(8QnVUKOW>WK-NXHzQdS8rqBd@nU$NT=8o7{i5+`XZ znAJptmxzW}o))|(;C?CI$qnX_J}@LJ5H{b)361OaqE9U_A@|3pf71c^l7gr-ts)fQ zYpTCXkBeeao)4tI?354|uEW<_mJ74nkg;L$JnOgHnDOs-4I&?q2ys?sLG;?5s0O1x zUKQ}T%;Ud@g41gWLo#r1+}=?#`yUAHs#hGa1E>$-#p)4dsbG4tyN^&SMGePIn?goT z_TjBIsECCB3!#pD&yldd2X~3l9VSw;!{XeFk&apA3#zU5DoTQ2OU|2#G`dzVDsR+= z0RfBGJ^6u@qAx+=^n&s$ha8gmyhDV#Wy9*<2sJ9-&RWc=a5lj+k~NdWO9hG2K<-!I|L|qEkNsM zo9aJ@jA|GnMV`ksYFSaO@!#SH$fM#If?q$;pccRX7sdcBR)l ziT^ngPeb+RfbwCso&N%Idlg+30H7+43jhAre=*Qa!_*T1py~Rbk@UJ2*#ZDaYfUv3 zV?Rp_0odp>`}+R3Si*ig4tG<5Y&M2CJk5X1{h8bAhk`2oS$c?`TBQ-79qF>cQd~gye!sZ?pa140F^EVZiY`W z$NN<;<+m~%%dg61r>`@dDZP~c|3zHDfX-;q^0^gXg26-4Ko+3&xz>&zFQrxza06sEu!_=h}xbJm>POa(XhL=@kiN~7{@IQZ+7k`-{ZBVFi!hgX((S@_7_>X>iT-6rlvaCrt!l#@dDXj^)yYB zHA`}LT=%hUQwceykN`tWg*xrS(MaWC;Q~(4ZNA6$4a=@UOamoFmqC!d-waMN@F+Pz%*UNJejdPzkwZ)YEuo2w*sz1E=M)q!5{G2V!X z<XJ?{KjDxoyq zs{3Dz)#v~_8GJ&E2l#|zB+ZukvR2blSb?Efy6FxE3Va1X#^Q4Kwc;c<&JC;mn{U6e zUTF(D|4o=;M0BjM*0l_0H`MUO&HlL3%*^4aTiTAr?(mcZ*ftj43D9u+%gHtLu@lmY-na!|-Q!on|Bn<>HPvD^4W@AsdvrvoQH z>IV*ri*y5btv{*Qjq&Zs8hb9(Q%CLXNn^lD1a0Uzqt7bdT|T%s*1|ksDs{h_9V}}f zNyF~(%I?a^?*f2j8wFeo%0@?1VcUt9N(H55>;EToZc@d2(8q|iNO>!;|U^_ftl1`2yzqF&vV7ShL zp>ssYyyG(dNJj5^`;OlAppDP|n9%&(T)p$r!Eh`EkV$A2|4o;5-g#K96iD`YkbfxE zed>|lt<-mb=W(Qo2Nxx^>bZf9s;e=NPP5FVHW#pS8k17%E~#7oIf~yylrPXU3;zoCuh=*G%@tQbhIAk&~4#- z{iZkjtrE{6zq(kXR2*hzV-MY}R#6{50Pu>-mlCkeer939IptyCj9x5T73{(Y>{uapCB-Ts z_(SZKuc+HC>)}>_J3>NirgLEOF4Qjc?FzsTC$H4#FCrLvN9astj53l!!IShA|LaKZ z{{8#^jN3}JXV15a#crV<6 zG(}0oN2B`sp%YTY6QBuku&RrJ*)2JyO_+3TO^b_}{Iqj0?p~nXDl&}7g>A8bZcZa_ z&YL5Vr+sFa_8Lg72T{@9^1^xf;>C#C@sHf){i++^fsgttrQt&miz4mc0m?*T2y*k%^{7wtp<{rqDa<}G(Stz7iiTQG`!)q zk~JVh^!T8{_=-M{yThSM!E)eLD{sRd8(&3logf*%e)Jh@@R3I-xI&sqU6RmchQj+XNk8-Ow&_NT8`{Go3ls9H{@Ss z&YNJ8Oxj0s8qa7&Ii&Xc61cF~2IOK+z%G9vj%@iO^KcfSA9=zB+m3sY@FQ177pG0D zh#zgJD7}aa*_mIq9*l0mjuk>Gi;MmDboFNYF4Nvy*l^`-xF0IfSdZIfx?p`T9+Ip4*h|EX4E&pS55wz$KP54{=-?#PTi=3Yd-CoM^ zmvh6c#PgbL8Hy8jD99fj?9*$(cm6qD+n#%7OYw+#zXW`NoclLBq9SY$^tziC9#`5` z(HwfcZ++$t-+n$aXg*LXfghk%9CRwrRJ`C1Wd=a!w@ntyQwiK~zbX2F9y=3M0)Mu6 zW3o1E#?-{YadWWs9n^By-+bMs5L35>oL(Xvjm&p%)3Z;cTmB_;bFak?A0AHfW%cNT>A@>Ow@`~78nFcIIvR<*K7 zF6bO1rA692GvV&@#LQmsWrA{cVtekxR+`_nz}lmR#(utnMfDV28j<_oEtCb1# zu`xq2^NVpy4)FV+1{37H@nHkI<`i}2I7e-?rG0;E0hI^4Amaou5q zEzu8V-F6Lqg`FR^ z&73Q#PWglx?z314#CdbuE8zPV;3rQUX_l*I8)oGXiS`AN$@7$* zuL(OMFRVU9Mb=cDl_81h`e3)!1Zl;y6@D}GXMs1H_WyPiSu@klX5oMyYNz!y=U$Rw z;N07f&+X$5WB2E}C!&Tp9@eB^iDiaoffZalBY%M01ARg!&~!FIPGJDDJAS{EN$*P~ z78}t^u5bZ!Z}W~O70EwPM2rWdo+=y&SgYtR*x(fy^?MiCjj+Yci0Wg1$RCTgfO|EV zu|*`wv1Nf1hBDLz~OD!S9myUoQu(ki$i6@9OyF~|CfM3?{Ya(szR zu{<5^a&4^gbHtoiw6PARv|F@YeUmFyKl0c?Npjl184!EM>|t_4FYg~Tr?i#eFYgIm zpkd#eJvLhR*~KKEHnGV2`}D*<2M0k1p!&KqsDAgB)0;dWu<-q)({X?rD!9x*nPp`y z{Hc~ZDmhBJog(?ga|f*-KSvdE>bpYxTn7LsMwtDzqjtfsJ<+6xrQMg zqmN#lx^~eCfDgmopOs7=*5C3tsJcXK*4v_ zB2M8%UGy$Bx^ghx6Y2AUr>e#DqtKZ5nt*tfkPUe`~(XvOOP(7%<&1ljC;DzSS+$1$;?q54iVO zIAZ)z+&gi4`(pY?f*FUVMy1AB*Nw6+cUSMX3W`&1=S7%U~YG5~${QuT_u`C_~v4yO{1XHmRNFkLaY1p$dDl zrnSFopgw2#T>nj0sqze61KG#2hBvoZ_B=TBBTd1Fhw%HT`{mND?O&8$Y{AVd=3+g@C@C3I>4(eY&=bRgq*I=K#ccoUa4D?a_4(YC`WbSgUnRz@qBB~(rtJEZVipJwQ1PSd7t=E8!? z^85Piz(z@c>`dXWAz>v~?CGH-ZdBw7@P>vlt+&(i?xi>*S5HHPrJ5<}TWxgTdmV&HG`;L&92SjOG z*4jCFE$IQegK)8ksdw|u5yv$$0jFr~-gq&l?q3H2Wlm1RLwZAVPY&E0&OhCywu|9Z z3>}N1(qxr55~jef9p%4CmB-8z@eQ*F zU*VXwo+K$r>95VeXQZD28>JdP5Q*qScC}(@jOb?j+j#d8E+h48>_ES3`w6 z2j5qEsAb1%BKQ0Lbv1uqsXA6=<&t_I2_1e;@#Bw3&^fp^`@4VUOGWINcD;w=Vmrng z3|-HAV4|_{$hN^?EAayTI`opKh84bua2Go@6)9kX&(tXrYiGrw0&^?^{>e-!2Q(Kz zogJ#jP(ik_O)tnl$5?ElmV#GL^VQ#2j~5h4Q>lbhE1@)jXt}~+MLAs5aM#&ct**}Z z`Q5oceaBa)je<0kRaDr_9%$j^zq$t-Zri}>C5|;6YRyN32lM^Kcg?`~m}~`aLo048 zKk(J4D(!4Itx}ZAPNbS9o!hU0)`uwH1^37{0u^|=d|&B3W0KJknb-5TVZ-ny)^%yC z%X$6&b_b^|iqU41FX;9M!1%mIfNreb9BQL=h^+LqM%@Yekz=}8Q{D$7NHHLXZOWU! z&A~V?CnpynbKommWZf~W5B>lR^i$-p2>-RS!qT+i zYneM;Jdorc;*udxhRIx4?0U)PLv!#c>6uwrTh~mWdH322ko^PA8Ndr zJ&R&%>8uoqKNe%!W`A+H9=Dg1V4@=oz9LVMI9u(COo2;?rh}5WR@AploE`QI{c|Ip zZMW2mp4YPD@{m@LtG4xed=uD4p3Cgp*MIF$AMZpC36T+nL&wEKuVdyD2IE1{(>AM4t>qoxShyq)=5>g0ag9@2ji zlfwMZD=RVP9=fT>iT*sk+*s|Lz_WVVQ9aJzaAgqxMWVid&c!&FGr}yxFQ0=0D zxyzRdUdxWiuYT{a*_3mNMg&+&SnJvqpuhZyz->yj#-`H1#A! z=wz3s-Fd0O3hx)nY`W*YPvFh@M&JP?je{yT$&2l{0>6oc`bY~iAv5;aLuw=!MXzJEWS`B&Z!%X|9t!xI_{ zHlI7!-`Jb;ON4>7G5xF6$$t+n-TUww+yo0O>F`MeeCnXWNhE@o4oy@eCBL{Hr_pt9iqejHNX}2eKP?W48IgSB>A<+eh?r zl-Pwlt)?!JH%EishR0m+22w_wB&n~numI@5FKD4N8*_%(QO}&5AL9jPufDzc6VAun z>P+v*(i-RS=mi{8rz*mL+CvySeTxh5o^rLCEfwL4PXqaH2*Q;ON_pqbjMN0rHw33o z{)QCYhi!X@ST;~`3El~|qG1uceo==oXV*r5tLhh@*lZO#wg_L%-8DX7B++Olxl10S zJYrW9kRY}l5YGd;9i@5nD-Pr|V{Tf*5vr4m!4G?8q%<@%)FuBa?aVAq`s#8d0`ikc zYiRWvbU9ywn!q78E$hDgp=|*YT>9O-&*S|`Jlq1kn6$Tmg8$B6xC`!G{iQmvad5wN zvG3RjhIB_*cc$J?b+$>;&($syTBH9q`{rpKhoO}&C`zh$gL;(Nr5mMv2gxl<(JUYB z#=LG-(Dx5(#5bw5$*o>FQ(E*9=8>)XRE*_uu^~|2(~gplKPT(PjY)#3NdT64!YG8( zch9&;kST#m14~_S811A0i40DoM_lyXMn*=7LEi=s@3<;m{VWp_o?ja>8(1fZAasoQ zPECX^N434XZ-v)=-T7l#zVNngz3@=VoEFmsx{>MV#X0O7x^Mn)A_=Y)S;xP71Zv)t zF7%17t*Wx4qSCH+b7bjgvojH1?7;Yrr>4T4YDQF6<@;=Oes`)Fguixi(O4a%b;OXk zi(XXMewac2`HLvk3O7t?`KIZ0CTgLt$DC3QVP*ac0htYXgUGe*Lq4l1G)6@)Iwe~H z2fk4~G<@1W$qiPelyHj-au^uWKs?$seP8jMwByFDFIbj}_rVoE%gx(|_Oip(0k{wE zJ6$Z0k8#gZkuk>{GJ_j|e=|O*nD74d*!j&GwBGYGcz-&$gfK}w2hB{w#vA6h)4(j# zOY8ZD_Kra4Y~oUgWhlPTvUergn?3u)A?e-C%JYe?H-g+LZqnief6_;%3%vdZoz&)0WDPsd86v@uEEXU| z>oaY+B!;Mde5LH6@0Id5tAb%#cLn@WS4J?4y`^v_FhJ|N@}H7dLMWd^4+y)fR$pcYF_~OTMR0DbZdz| zWH*A2Mr7DpWLO!Cpa>F$kC@-zN`f-jFY5>I8m$G5{xu)Co@Q%uv|t11?AjthF1viw z6ZNfGNuW=0@j2i1^=u$!_3c#-jwO4IhZcWN{DCzGVL}x`jcDFy`}tDVZFk>uU$#r_d}oo5b7dF$iZ5!mF022xa8Xvo zF+&=uu_R**xe!9ilVzx4)c{&LJo%U8oS~1?xL@DeKMU~%OTgHHe+&ctT-wTP-?ja7 z&rAnXjIJ&DjL&ybp*ZJiYnz=|=UJ8ZKF-F-^_2>g?8Z~PiyRc@Zx%nB({J})q;4?@ zv!-W`$gxXSRpI|@cNdl6KlSk|xL;5`kys=4G}rb;^=r|yjiSMOywBR#^a{qJOY)Mu zX>OZqRBHg84J}mFFo(gvpcMBtd}S$5*BwdTRu5CB4|$97vwP6_lFXkowq6xbK2}#7 zecr8;h2ysay0v{=n>~~G{c{C~Y95z}6dkwhLB&PiffDa7c$K?4&!DlqsT1=C(V)yH zFCW-{6Xp;5-YE0jDlh$k+@}}cew+Wg`^UT6#XL_HRuI&G*HmUL`CEk7Ups!2d6L%J z0z)4{Kg;2qx9m3eT;h(6f{eGwcEHzv_ih;ANvv7Y!?juN>)cazhM+gkO)%0`7p?Hy zwn9Hiti#~22^rR{==_lK&U+pCcqh4Z1RTAUUmWNhGFf1nI_zevG#J22aHxY6tTG46 zUKc{q&K@6WE}Exb$3ng@biUJJK;eSXo0u{(ohgm}d5XCE158HPBb?sXkCIiB zSn1~B5Fiu(HXDE4V3YXRuZi;8kLLR8vYQN#ru&Dmhw1$Z<@j%Q_QCEkCy^Cw_A}g@ zUvehezQ1Ba-K-Q(dayJ%M~XdJl)F>RNSpKAggYvr_s8^E$2Xtre0_gT1TqJ3!S~3*dz|`bv_dz$3wu^j{}%= zM*|g0lUn|^+nzqyq`3D&4Qbu!z+CQWojcvy+DH5a$mVrwa%9m_Paxi{+IT}VXAo{2 zP+LY}V^O}%lwy(g6PqL#VDW2XOlMv-M9I$rJ3jv{#r&Z~;^_*%S7dA9<^4n=_ZR7C z%Riqxyc=aIWlk7h0o9a>)~eGEfm`F-sQ%XEbUx6YO`D|^YEA7Di zr#}lE(r0;EE^SRTtFQKBY{wWP?2_`Xu8u6|37W;`6THa^e@~ zkx{PmqIqi9#cQW%YLd-W9`vp{QunuASZ%kekGBVj^j;~xVRI&O7pT}YksabITfmS= zh#u!3Zhym`T-7fZt^1nExsEn@X}9T!u^a(Ufj!Y*cvE0TvQRf@3{ZEA|PdL z{x~hgmFEgP@i9~ft)GANBhg6s1Hs8-u;74w5E9`N^Jl55KRe0CWnY`K>#Kgxp+A8P z8v)xL+#g2-E!{6)Jo78*l%eo&oM_2M_TNS7z$NXph75Gy3o$xEvS!Vs@nv~u%)d{? zQFAn6z$mOeYKXSCvve%k1750wpmP^fQZ)Q(7+hWp`^b&JM2j1RV?i@@i zcuQfcX4%KUYW?TOT@rV#J7WyZkddbT)m4_F4h=N2v(fMPr{Zxpqa82rvF5X7Mx_wE zp8x_P!d;n8WyD0f;VfHwmD_gHb1{?G&^~TibClhf8`D2>xjj?VhK^pct-y^*&sE%< zLh4IIEQZZC#NEFANnrIhOkGz-wXtyh2y=SHVC0{g)^lwG`km_16YgokG$H%y3a5Xv z_@(CKY<#%KxQVqvlwk+?mgGl$|K{3a%vpp^sAfeY8?Eg6<8cHI9%sCh&iA}wN}^(c ze&i%#hh`@;11p0~@q3C*mx-1OCAUQwJALeK3zf?ygEf?lvLMQ@Z+&Gs(gC+P9>{GRa=+WM`Is5qI*S`LK(ZWoP?^ z`E$Ei$8FccNPqUcP#0)GR*1fz`{ZA}T=`*dVNS1#!QNxL!GGJ;tnep1@`c?c3O*nG zXKpVUm9O^^q82CV1Rii&H|$GXIcX1cqHrr1nTvmaq_VfWvvh$>N(N}!t~idIy1I1t zd70pu`reo1uZDZbr4Rkvw##pDY$T-(3EPY~#}57^>7DJJ_4**s{*co`SpWSB9PP`i zYU#Pi@9jUxE#5+dsnsm|zpoo_&N-tibzVdP$vfq2OnJ^8ie}sjmmR*3cN~j|A4~qh zvH4M$8NhI%%la`p&*w9wTOsNVwfS5s?(^pl(7om?W>rz^ouqL)3*YL*pE{pe!7LLQ z{;Ts{I%V7`a!Z`El=?pe{**pYw5Z1`{6|M6AluY>q(U=SHYuewT16~-qOx0wE~rGt zDFmfe%E3kJ`7{u?fG-?lQTEES9KJ(c97n|a5Euk||h8k{A z+s@s9bG<-F#PDb^@?RNStpM&P9g6hxx1AC~8QZh3hqx1o5#arv|L(of**E_QU+@R) zJ%~M49XW)_hIL?OcB1lh4kEij--su~mRZo%IMns}c{}BS*nyFMauaBv(w;UwcnO|P zSS9|$Xd|aEOX^h+jLdw#&6i=2IkD9@Gx%IOy=}c@G}h=&N*1aMa$Lv#+5WrC}><23yOnZrn~Y~30IibX>nbBJ$cgkVlA-QY!7evdBK|2KlbDa(DLu1 z&yk#)zgN!4CsIcyrP>5YYHsk%27 z9=vz)P&gC{BD}8A2UEG-sMLt41?LNP5z~%@VB;ccc-aM36V%NHTvBFOIQ;6@=-VK+_3?KOXfX}qX`e@K1 zfcIy&U;c9i+tu*JTIV_yk4wN&Jkky=-n6LeCg%3rGCsOKad6ho_LPY40IJWIm>s1= zJpFpyt(fZapcgR^-3esmsy;ce^@ety_YwxCpxc9bdSJOkFG8i9MZbdK@9?k9H>-6# zx*Ks7*GW(!K=~?rSu_v}483GVgwj7#Bs++JM0(V>ldN^S&~R}=Fm<5#pU1C zg2JJkOQG65kz72n>u}HiV>6DQTI=X~<~S?M)J(#u52OG0u{KD;o|e6p);xjMjiKS4 zT;6GLUnFf?k-iPkG2{(H47oVy&1R`w^XGz-k>JsuH&RZ=1KvW}{v&2EkPLiO^7#1e z)S{?}u%1)+yDrnj+!yRLOMoIL(fK>Yvnjp5*e>{o5qvyWy*;JUV!TIk@uwv4!wTMJ z*=?DQR}oITC#NmQIuL4EmiM;t7un9sBwZfQarJgLP$;SL38Z@Bcnk4|I*6Gj8_aNr zvJ>|M;?p6KgX5by49X>}=xi~F@s7bRRG}id?agfy2>%5PD&k3aIU+->#YfEJEl0P_ z&qJr1+xE%&{9pR1bd_qK%H~H!?&^T%Nulx+!dhpJyF%94s%neqeKLCPe`Vw%Uc;fg z_(vBW6x3;ti|i!Qlu@A4b@6mH|Gg7Qv*x;7L>7R>^s@^im??*HQQ<4U;%<%q$h*8W~8gL_5L=#S=rO7&+Q5f7%^FX`Oa*5d`q3fpPbK1jkqe(sbxxBX-S$cpw=HhU@IN%yj3ekChteq z82|20oF_l^mkl#h#jr%HTOWXLmH4;7Jgng`YKg11Ar^Ya@#~Bst{F{EdT8fWOJlN!a`2&6zL2w_C38|JI(}9f&r?G@ zS%R)G7D>Aw4pi65hM$&4*ctn>v8I=N0a`wK1r}ifUHbn=7_!sYPK`*l?v)IcLq6_~ zyT6!sIAP*TN@nmcTdCVZNgBNye;ED`)T_HaF#^M zZTM#^vJ9!Du}0We2VWZmqSNiQEPF27#SX*wOyBY`1x^GDlW2W0ijf*frB(jRGKIP` zdh#mykkeS?0*R5~m4UJmeuGf%57-lC9=igbcI0OLwl3ENR0x6o(%`op3Z`h0!+553kWwiSse0-X7GMwfC!>*JoDC*IgubavYCbokn{{BzU9~QH2 zh9F59;Jcv?fH+BpevxLn>RPF~Rex$U^X*nQsB8&C<(TYz7<&he=o0dzi>=xBZ&beG z7Z$j(p7II!mPfk6Cl)wTUQz7U%JV{m>^jOOF-P;~xg4JnBW1RP%wU(|rE2XDwTiMJB`&u@xK z%4$mjl2u{5ofFH~n^1MVG=gaAN-2)AeGu`M*y-AF<35~LXmjKRVhss+;cdb2KDtI| z#Un<9y#*9WvsMVnbP5$Ik%z` znL^FJ4lUp&%ikau1StV?Nwb!b3{kCgAEbr~#6sn1D)o-E@4fxyiQc4Epg?F4a}Oh6!L^N%ncX>{D504?T0omQmWHPugP*n^^Q|K)7@=sZ(Pq&z(Y= zWjHK*)(CXGDNcO<@DKt%m#5jNxV|1%6`bJL{B{!YzC?(+6J7ix&Q;RAep8S*R)~i^ zv+$qAK&-IYe}d1uT#pncsn9IWix*!YxRU&{1rgg-1*irIoOUZdyoFT0&A!@>r%Uw% zRw>D?$0$_jy2suMkWeF=MQzJDr@!;DOXZTe05(mJ|U{Y=HN+2`wYYFWV`(ony+-vs;M z_?X~p7GfynUM9)R%>eiqCO*s-Mm;U;O1b+KM^Y1_NceKo<9i*5EL~<@)xk{@!)Li% zKljURQy#zjKK}do=R_2bCzx7;w#Du2-X1z;u+=F3P|glpaB+%c{9{7jJ0eO?>kRuU z6gB%s+ujW!A^Jr4w{>v{R0W6K?3O!&<~0s2B)(_H+oI7*WBOyaKzyR!-F=mP!*Aj&TYY$XE`}*@uY#Q z@wTLCgJ$goYNJO=(qE4=ZZF^!o`uQrw;iMT#SfkLHY@$^$Q{}P-vE3WxH6PCVHPW3 z> zO%vX411s4oNmUB=8k1IA&Nx#G(-vi(Y7wHc+q*jd9z1WDF#?_P2y5cL$+vdWT^rybo6hHM0Hm<(AGZ^=n6=^aqA4zIXgiP!Lf zG5%+J6Hv>@(@V{=2LrzqlRu1e?-E+`0EfX)KAI9aas^jfhseOGN!-iujLSehpp{Uj z4Nw;mN(D7GF|+&Ez})&DZ(ZBaeqKiE8g?~PWs~U5!T|C*#&tNHmVQj-ag!bVX5$}| z4p$(ty4Inh)5qxy5?!Btr|O(|mikAGwT60cHCUKfaVXP)vJ)4fR`}w~!5pU%4s0NQ zz|$($L26lV#8GS%#;=k^CTbea@}l@Oo{841s#05azokkdQex8xB#8@#{aL=hM(urP zh0wL^gl$K-g^C}7iOI8$%e%B0m+it8n!Z*|SKyn98wWu)mtyezi+%+q3$(hV{;4YK z(P`V7$o0c&%tm?hVoI*twBZk&j4+6SK3m zZHAk(ob4ZVCa3wQOMD9&YHS{P;XhpemiM$@QbhSy<6P!QW8xBtQsdDYMDb%0uu;SD z7$90h!cE(qIM& z&cRUF-HT=<_Hd{jvxjQmKgM z;VR;0s7y%Sr`L3$m!0_m(3Uh~&<>sSl89XHY3} z6XEkaE4R%r|JIJvzLD+}fn+lphBspQ)CnJ&30RQ~!r`(5w&A9B7JS1B6;ax;dY!!> zorb#_B06CSuucrFeFy^~R?d0@5YA=u`Slaj%YU~}A-gbX91b>&p+r*Qa22{ONwXXw zZ?5?OC&1JXQ z6!mpz!Tt|mi;OLcdhz1<;f0^;HedgiAn60tQa;FD*xo=(DW3C*zesbqL~Y0i!;3%U zyr15|Xfmu;nelb`o3}eaAP)Cb_FlmfO8sV}cl^gM-viBs;GGka>()<>+}qu{ zIIGPcZoh`?Jkh*#+QMrnJC;d$_aYv+f5bSts*)f`38J;wlrIfdD?ialW_!T)$Uv{% zDwW^+^Uz5WBhpdb1+DzXyE{aH>2xT2IgniVl?F#DQR zBEUN`G+Ki+QH?ICern2@FeaHv3Mjk+-KkQ8#z?rM4aY_hlgA$9l29wao5Mwh+!dg3 zoIR9eW|q`^xFavkTU}=F8+&6=+>AOf^eg@ENJGi3qIg^QX=u@D92fb#_%|$rJ?-5y zJ;@2GsA3~=keF1Y`3Z}@>5g~n_PvrE^w9#ZdPs3$;+eyJDtVfJ`$u+`J=%h4YX8n1 zkuoWAnX6QF8_}FS!AG24d4q!q?2 z;RZ@P8l!zJ{tJG=QI!VZWsJ&lZ&>eQF%z+@c7#_9EL$ig`NPcHLDXOsDPV{GdnoU# z{_)XUwy1WSqCo1EgB>NfK0JG{kAktAR3N`ySc5%JBHd!Ynxv#dJ3VBM?1|4~=tpLa z-@Mivm!fJ-Rt#zF1sySx}L&yl33#rLp`as z1QgXU_9!iuv=-u3G0UWvK1VOM=`%3tzVFrd9~2>^eE^kWC9*CGoS7EM8?Suvi636i zItsWS(6Y;Y7T8Zq9mn6I8E83Z9z>(j?<7ROR^bJom8{!m@Y&0*Ti^eZwE|xIrOU3g zL>srpkv_PY;9k!1&-qwWsC?)d8J|t}M29!UGqImM4pb;5Ew756nA7pN`=&e*2 zanJgi;tia?!tuX#_|3$EQL8sKIS-RtEfZq1&MK%AuWHj52Ou-Kwz$f81EuBZ&AEcTWTlRA*flg0}~8cpt{S)sRcu3}lbWFxFnaZ^0x-@0zEdek3S$6NQVY zcy2ZuNq@Rw^{uF7rjELej&hyOfbB*parjlvT@B$MSH=$sY9gO9`Lv&hP`ZiRFKWYu zfgM@y{TItHB!|l}5x~b21zaEpe}zzHWp%~K#|19RhNWG!B~4}iIe8$h#|1bL{v^<& z@qjEZrac)X7Z?6$vdu;O<(E)X?p3Wy54sL`MJiH4+3M%hLtd>JgMz&n^@N!hRDNaE z8!-{Wv2Xd!u09~hJK8T5LpUyLr0_54kacRr%=SLaL8Qe=+v+s33zo8;Abn+~gMT&^ zfoltMm;nb&u1 zGLzARaDE4v6&%Jq z-bt=ZHHBiWDI005wAn2oF>~4$Cd;)Qs>FC)p8p*Fr|J<$Q_uNQvgqwI?%&Q=)pKW6 zblzzG`vDg9GYaH0-sz~v;8T3dgXyVlW@rpkB=;BBgcOutU@%&`V)6#z!^Uy=f>`CV?htq@< zgAF_S*o_!uCCMm2nK)qVzv=ZEp+;nz^T5+!z6bz(rJ4M@o(Ild1Zu)gGnZkmuC^zq zXE!fM0tD;Jyt}I_ z^pW@pX26@(PaA@4B7~~&g0;W3Kjlk|d0Mh=GCoXS{C$VDo?=fY|G+2u?eC13KilX- z^{kF;WncGxokyn}Z)?Q3Uw#T52(V7xzzn|snVxPKa49F(U$7_HAN@3Kc#(;n?KLw< zQ}^q_ACloYbu;t5l(_S9!HhPd{ZPnF8x49ZM-*3vxNv=ZtiIl)!}Ip)tB`O>QxIC6 z)88U+MNBZWGw2Q~PUR%YlKE=n?+^XQaR_k8bspgKY3R)!K*rv@_LN(gfwq-nk^0f` zAdakA%{du$_bn+do01L^O%*om($itb^f?aIz;|V4?%60Q%0@+uOh(_foHxy7@>r9_ zZA9ze@c%xTg{(QuN&jj3K}r`c^aEL+C?=K|&F zxG{^i<{GYJb6(@jrZ!IJr)1KH(9md?uee3h54%V7eIX-z)d0BnMxTiItPOA`JLxN0;%X>}K?3pPl z4Npf2?;e5u*;|R5JkHe2O6R{yQ4X29E~d@22mvw!HckY>$Pd@k3V_!FQOL{W>0`_~ z&F)~IfqbW?alexdR$V-}qO(mBbYMrk>{+*Fxw-Y7E3FupcGYn8Lm@P^OGTB(4!*() zdhzM;wfqo&suC&z2bzjVL+ zCsB!e;A=Qt81V6zh|GE^;$qI+2NFf8e+CcH1g@b%ZVz5?q|V^|53`&l6`n#99*Ez4 zeNIibdUOGw0EwMntFeWru|LS>Td~tO+@$gm|1^M`qYYXiyN;X-qJ>{H;F+KPCnOk; zluBgizS0zICzl#-B|m23wztl*4c;Nw={Pa?MSM=#!2-dX9I8mwh}f~VKD1Ndy!I|A znu&YHJz$-A=sn$SydV4bQA&1z==y(eXznY{p4n%jhxeyM;SWt8+uJU5kegGgxrYyLZ^0aHGXpt{(YH3E?~7(mn~y5 z3A!}je#tpy_mnY0B`7q7Sof+sAvDlpz3ttRMy0ZjCe5o4J)2H3ggbpsFgRJMli3m( z4rH@3OoMapiCONe2@-M8AQERp=R3DxfO8Hw$H7Y9uvi+fKtj;B|T$W-tKd zXspfrxQ*gzVO+S)KQ;~-j4ICg2+jzuVpHloC0`S@Zk_maNxxvmSkr1^a`v72^^#n z=>7VTak|@_6iMMdTo0VG$T|{#{~SIM6@j?Bp3X$7P{H#0+Cib=MfrqTBBXZA1z(q8 z97>PMn$trEmS%j-x}i& ztnB9=>TKkg?<5_sStTq#)ss9%?rQ98xUf;C{5K`yU3)KLI&+e)vQZ(h?K6ZX+Sf>C~eUAA>;G$+C;g?gZ z5y>P676b+F-8c@&vxVeY!GudSNZ#wn5R)poX<>iy-&es315{(zxYoF=570O@o zqN~KeA|8&@6*X}x_Gt~g-KSbhd&v9e2QAr^!@txOA&u443X5k!vE-pjZ%RGO7L;uiq6 z5p_^Dtj(if-+#9?|7>x&lwn-2t@^dnsgjXW8W3n~a4EsN$Rz}uQ^=o#8*gca`JJ7# zm=?{vF261J$-mbi%OppkC+td01N-$!OG@=r3xnV%-L_2b*q&bZ8<{+`Ffq>G`Vs6#bDtW-e>GTwUYqYGqIXF{l8lI zovzOChfU0&_aW2WpEDxGEYCi>yxLM2C=D()dZRKm`s^#5ufn{1YTJv`kD*mED#`-cI>!H(bn*FHcGuJ!Z1X-`47M-=_;H-A9q6bB z%!`JAyFhoH|COyHCoDcVoOj9m-<`(LYM? z@*<2Ka35K=MbRcDFfUkkQu0=Zsl3A{YR33MI@H?D~F3SY)4Jm#_%IWUuG zY5+^YAI?~9FJbAdd*96C8I4$-M~+>{^vwVYzshx}c2TdHm1kVXIf#&;P$Wu(-YOG% z@j=$%LaYzx;Z%I`igxJ(7GT|V*|5`5?~|dDm^oniTa>}!pnV6hcM+I>oQa`urtR;H z*p6mFA;m@rV(`fBn4LWHPW$|G-)QHS-enUvF5n7$-cHWmWoHiEYiEz%XBSR9Xm_4` z*zP|4i1@Bk58EBbAF$Jh?yse0;ZO2bJCppFg6cq&jl&d|+*$|mVlK1t zk;<;?T<{p~bq`H9?%pJHoEDPmWfEnVnN!)_wk3C|{np_A(+~idJ=HXW;01&QX3f0l zMgO{R=+H)SgLC%8m)qO#{Z9M+=fBs!X!bAL+k1b}-qQaL``oQ>vo~#gtG!|4TkH+% z-(qjv`c`}6&bQcGdVkj5G4mJf%g_EV_DA3N_w7yZ{!@1Bo(FAvWyAVwTL3YbAl`J| zp(JoIBlj^oODA|WGdp;9c`x0EuIV^zw2`(mo1DJ%hn_Dcg$~2HOB^%cyssrQ>(;d< zy~L=8)K~*ECC6R*Mf8DLNAZDFW!Mz5nG?1`5%1ET=4T%Lo!FqmO|y1WFL_xXBwhTU z!sDATVKc<{ut`c+L2%Uu?K4bK_zFQ+dMl|R&&>+=pBm)s8+m82UkF?&{2?r0LQ89~ z26^fMY8tz{ID5UjY-;q4HnIB#8|#C&-(*wvW*gahjje6pZL1^q+ScU5wmNs-R*syq z)#JzQ>h!j)VRl_zSh0;;Yqq(#4iInJE&&W6?`Sr5-ic-PuGqnAoOuc01Tkb^I@%;q zyX1S;-gf5}Sk-Umz?B@t4{h+DY17w=XYue0*yPG5HGR}WCe<^x+T>=m zIvAU1z8uoK6{h6%EmY-!GgOnRU?7u8%%!g?pfEOU=ONthqMJqhdSdwwFUy6@*|xMd z@{1%f#vBT4a+jq{P}Pi~pnV6hcSv-LI!p7f%skt)xPWs|*e>)}GMwYp#%>&w<#o3j4uh;6Q{+4}N|tuLG-iJ44e19 zq>L4vj7|DTQY$<4l2?Nsg1s3jtzx9wuUwroP!*7>ApUSTOo`JbKkt;vbvQ^meUV>? z`EX>Nlwvu|4rBT3K?r^nwyrazh(P7!)dy37vn?-%VmfY~9@|BwM*b`Z|8 z&%oI5Y%^0G$9(EB=#ic?9cRKF0C;nAL(A@oKF;X&uC1@$!fdr@y^RR~bKExh^Rp`e z@e)7`UL}|bV)D|4ZLe-(76yo87A`Zeo=^k0x*vAd{czkD?`Z#Mi)LfC$t6F0QgpU6 zxU`#$7ZgAKF5xU`zy|Z76+d-FJqL1vv2ggZOsdk;;4bOY#z~JMYRcT8D%I->sX#Ce zqmfC_wcqqtb&}Flkxsd!vad+yt-_h}u9M2*CCX$wN*x1iRTaL{ULRUb`I@@+KGXgJ zxO_||PajAfl*5?4D8-4O=&H@KHXb%uc>0?g<_x&n^r7|jscC% z_LUIw=#$M&>QpOTv}Y$xJZ}k@!(a87iVxZG-nUPkiNX2qhRo2rRN5Ib%cwkMw=LTF zZ7SOb+Ft>}(NvJygu6R!>o-tCy zLx}2D<^JTX10cDu84wa>eWX45paMaPbAu6^$9&?H+2mH(x}YTXNlhl8$tw=%&2@lyb;Gv!R?}84slm|wNi~=t z=B!Kr2beYc=1fekK~0^YO-Ue!J&1C^k~wztwZZU{>UcdviEbk^Mc=J-Z4=%OAOAp9ySA z`dZ2E8YbFj0Ou0Aq3j^XZuG8<(CL+q9&R2}1GumS2GmIq?_z1orS#^49iBU76EN1b{q-S#|@!#XT@U%o&;bCZ@X0)iwRg7BYdnjr(hYc$>>= zg10QAeKvOBLgFH#i%QJ_Qn8lS$$m_JTzg4_IwTKQj|AuoCP~)Zh(h%s*RG--QIsq7 z)byF`(6i+kl1-x){E$|be(xSv{9#N#ZvbsbPRyWe{UZosk}=YguO`aZUn6s_SC z{tFFjv`GQ()?j*<#ze1^lr{)0Qqh599<$fpqO5MnrJUje+mz5aIvHXgiKYb_W;3*s9cby2ZO~e4owXGYrzP=2*kC}MNMz%)e z=Zw3#2_REe>@iS$L1a)3GY&j?^{2wboL93ZX-b?HM=+TeT| zUFXYYS5k)zSEV>{KbcmCq<3<4T0%{#Q&dknLS}wlE^~^nt^_*2r2pVO0I@2Jdg03< z!*sHSO!!(%f@D|IWIv=ksrb8rpi@Ur{9B0IM1OAyr)dA^Z~o+0JTW&p^}g(>+-equ zPfwsVqq?256_=ja$o6HZ=kd*7f>##;#Q+{GqY0e#jU`)JT(D!)XRwr>!feaYiF}mj zl6PZkQ4hEX>fZJQcwEb7EuX=heYXJKEzHPbf*9c4+Va^rXJjz|ocF{6uT}$)`A{pD z%n4$#>w_o(E5=~u54cgUA6QYO9j->_hSG(U@;1|Lq{^UM(_JXz%8J86~&4Bd(}N> zek9C&r+o#m2vbV^o+aU{K15IY?8@GBufI6RT{@UCdy#1q*aR`ZI+XXu1TgGvfav(f$N z^-?kpAb~fx*KB$1ik+Oj+h#|P*hFu__?1BcO83S5`5k~5%w_jTf7Hfz_+8Z#ZH5TuNyE|oGl{4HPBpKbQA z`)G$x7a}P9FADGYT(dd;ezyWa)X6bSC`CDBLT^!>6RN7D(aqgMpEcq4l+ZoHK;9|p zKb!^cM*xwa6u}cV^+157~1W+yy#&`XFWCBzVvIu0(zyaO@U;-N8b*7D_G=aGm< zy3?PkWaS%7@&45iP;~2lk~e{!?I*;0PY`?(1fbivJO2ja83%Chh0o-R| zE}{EaFY}4?20*m3e#>U3=K$jS0pfX#iBZh5*cX@5D94#|b9)u{&HP8<0P)TUKsSvg zHD~NCpMmu>I%eN(NX^C$;vLM+0xy6}xt$=^MFMsAQTNWW_4?xiGiPA#mk+(V<3?S= zE`p)~4dy?^=5n(3CzCYzU3EVU0-=D8!ORK2$^>U&*_59lPQ4o|wvt?zN*Q*>TawIu zf!QYhA`3rl^~ImZ|1`*R?Bzwwb&*3Rhe(kHh+ygkyp%aNkg6CtccEc7Ww0sIJrXHZ>jH=leOqnw=A7<$b52$aW zzk;Rp8U|obGxBX8Vv%#S#sEKb%pYbY_;Myqn|TG8kU1)4r!R8SUuNU5$=V-f_!!Js z0xj)e~BE=(7DKjM>emXW2UePz`3+^$i}J5&0OS9yX-_2jCJQlG}Vb#q!Sj z_L6jLceiXAGwZ_Ib^Q$K;n@>*Wa_+)k4$Ly`u(eI0FPgenAn}w z{jA>i1#mg*ZeteqWivn65gfqfXQUm(zD(zRuS>KWyoG&i?XF_LwT4(jJWF5=cBmZa z{D;{5XWIf$GUK5afB0Ci#8U^8ie8sv8M^A+N*~Bku9Tr2I?K|ZfKOT1Ngppt{5Pgw z@aA26)BU@+#R>4D@JKvy;`e^(D#TMuN^tQ!x+p|I(!p{n>%*aujcAqY62{_gZ%kjC z7z#p{?JsTicYal!TN6(dI6>^7rKF$0qVD&@iV@(j_5Lqp{dGe!m(ZN0-5$}bcWwF8 zwzRftJGO1@42{#13hIO9`EfGsl6hK_6hCzK5%~oYKd)q9i+I zXmcOR1t$Qt-zr~v*n4|6rsc$idPjXVxDTC{oyGx_J-o@jiM?Vqfz7x7=f9d?0v1j-#q9g)UFZC?ZM4f}& zS%Br>PYwVuH_P}(F&)T$R+&o>`)tgITI<^@cIoDmwzR%xhvsH&0?X)`9%fc{31>pq z%jNVAFAQ7-unZq;t@sR&8F->UYh(Q>J*D2>0tn+X(GFlNu>nZ3J`qOXLU*u|9mu*r z*KExF@HqC8#;rE^i$P6*@xR{lepo=LK}pck$Nb1mA8q^<;P7zei+t5VKXv+pQ&$_3 ztFqnlB`1AVUda#Utb6o?**iaX*WQ3-Gyi3l?}r=e+JHgW35P+NBrRNcs=)=2%&B~( zhKz$sZpT-dd+5mg*1D0yjatWviG~*X{DlT;F7qBu`FUlqp?5*3|X=Tg+Mii^LZ=U%z^ z=KuF!`$b$fhl9|C`%7bE+wdAskCdu(QM-llppx*ztj!TqsbFjon@KgNu#Pi<{2>wcGw9_800 zMh;nTXB40XDEXf9CIHD_@R04`EZ z6$eb|V)l&2KP^}ZEP>u=GKyJ;~tmQkKulJ5+EMqe+C!W0ZJ{avCsG^9{)*N*qm`g z%9ieO5OI)pfh#)(^fAoBHCQyr$(h4gZ~{^H&6!ul6@yHmCa{$o@hnr9XPfH0jOG3^ zk2W8`z4>#@KJVdOo8>=Kk9PVoa>Gt{?#YH49xPx`QMj-XczN3M6jM;I?5IjZL&GC& z##oV*4n_GvA-g-|5D>d<|0zz;-pe3Z0Bv+J2YyJ81H6>#b?dY_E})YJSC0K{U?-UhWJ>c{>zaX-vYZt-CiV|*)U(&lY^ z7wbYb1^bE_nM_dgi8N>N2E=F$m(N;4^XYlh<|Gd81nwZ_!yn!c^WIS);p|G_K#m1y z3XmwfOh5M#Or5~ZI+&B?B`dpC9&MpNWyZ2SlT&8*-iuim%jL62a9~k}jICZG3I(d( zpbvezwc=)`;^cV_H{g0UR!R(m0^E97&<~r#PVw-GSvY+a4RGx%p$mtP^bjg~+<_Rt zgHKWqy~55VHP0kK;9Z>E+}L~(j{HCezx2=Z!-HSzU$c?1qk7o%;a_~pUi10)*z7Do zh^6#|?uT=vfY>I@#;nuZwbfq*kQeoK6K#GdWO8KArZ5|GHs{PLAfwz4meL$B`Gnj3 zSW3gGAHLIZ?IpG#2YPY>CTH2BCmqNIykO0;lnKI+HRx0i5a>xN~U;p&jpb?^mYgsi7J^ zO8F})KE^|G2&GSTPH)rNf^-?wb#(9(e%E|b%ihfE*;sD^Gx1@}Y}lMGPhEL~(BgH&!O zrv=i=u4VC~4FBcH>GJ^YYs~IBiQ5ab!`sZpR>wjSNTsROSEO)5FNXm8XCwZFDw)^7 zo%pZ&JoV-J9J%s^o~NIxZ-T;KDDpMr$mttm8VUesAGyR*iV{+Q2vT($~)$pjZ<0*u_%YrAmx#j%g{D@GqA_o@AY`H46r(6(AD_xWp`2arHL-xOCoH@+@{Ou9aS_ z;sQRN-Xz*dIRq-7$|P0g=pJ+~)aHYG;0|R^?KvY3RxP91y8+mojrrvTp8)~bxG5dc z4BaM{u9v`+ESC?nMiJ#b@%rX9>y6I?#5?x%<1b< z_KDdxe(Pz`Hnw9XMtk``k0wT^aWU}wVhsdj`sIKelvP$#gSQZEia3Lc6PREwqxm`M z1Y#|v6O`oC=_d%u^hKT+_0_;tIr>5$iYvSY@ z9p%Db>OBHfy@=lD*@CXwm%t|Tev-M7?=POI=3|t(#AU><=sY<(J>lnlG2z{_wT)M7 zbm{~=JGP1S+T-tk!5(_Uoi;f>4aoWZFh90|Aq!^Lv5qczi+GQ{u?rCIEMwUZ5bHD4 zxG&~gRCWY4;3iR|Aq!$Vo!oAy02fjiNM;j4my8?|zpX^TCBOxRAZmj8K+SBxX zru_#nsp=KI6~qC+UX*lQAf*g;KbSeKGspPtfLjxDIQC%&xWu5>ZUw!qjW zV^)SDpN_C|nCinUr)?xatX>|`z3&cKfFnmN(19D)>k=wJ!m zrEWL5oo^xW`@jxjoN6wc;nN2=6psg1oPm|+*KrbM>J2d`CD~_TLWuXm^ewMEho$sM z0eEv~!=8Ekl3lp}v`vo9#HX}ok;xMNYVRfIk*wdXEnCBqdI87cpV}hxLm#*#1c-r% zDAlC`(hNeEFGwnVp$kO8>U$-(PovR)@|Gl@~^ zT&`~e#OnYt-)_oW-XHphJ`SPg$*8A8aH_o#%pCb#by+(=%;zsyk_-3(fP26Tyic zT$Y8*a`Ywex;e@22pPn7$i<4NfJ>7Va9PT?XrOc7X#W9>0Z|B@s4H{!WL$QA`5eBO zY30i}xIUAvx!QF(-vf{Es99^|fKV}+!+(L|E-nZN^!#6GjTmW|I zCI7$%?>6}Ep+HozYK7G4r!OgVT_n+>J5-!fZ# z(QFe^;{h?wyrpYErJi8fq=-vk(*j{q>V8cZCtwTUlY^vod?eL>a1UG&21tw0L-}Iw zC2$D_U3TOB-ppf;V&ohZ#qTG&ob2#>IVX>CFPw$@XpTS3Vx6mN&)CT1F#(tviz_#6 z>Bfegz2h|Enul#>#6N1uuH+v1^3o(9zzus_sT0PVwuHU%eGy&76!SK=sQ{LgI;7Of zmX9*42p^eWbVzU(8G6pPeDJ0BlDl~kC(w`K-j^R~$+qTkvhVrww(__U(K%vFPA5&( z=uLF@+6@5r(<8RYk4Tcdi1Ev1)C+~5Rf(u~nId)HMPb!RofN~T#7U5yp(8t8HR(_e zX5fZyE?#R+3<g#8&_c zRaDwoH#(e5E%A!fe{}$f^zrSW0!GfF1ZTyXiEF06viVedhRa&MVkg=S&w;e$JP7Di z#n|AFABSAI>JO+kaqTME+CTujTxd1r==Hn;K2jAU#p!p-91{GDWxS-NO$nA+`O@E| z^-X@(eRvRzQ?$Qy_V_8TBc=QB*6`3Puk!Ng=`$qGpk`%&TN3Oa)?l97S*9-U)c7?Z zK$+wB!u+a>e?Hpph5MR?d*eqC<p-@v2Z3{#-0}8X}60cAkqyi0&uj}GT@1UR(y1#uxU88wEaNocdwrv*IAZxC+p@c==q## zNPWz@Snu_w0bf4U!W}WDimR7z+Wg^Jo1XHYqvieZbk9GfmGES}-mVW7eSp4oIEmST@U_v840`6*ZMwrXF>(Ri(~4UdwDp?F-Jstm)#Fo1goy zzyCLnhq>?M<9Z)ye9RusUgDMzm8OBf-c5#2>z{~&3F2HnOAk;dJ9tQGCw2WfH#&fM zKkN^)+@}Xl{p;4(EbPB*xrz~b^XiJ7JaY^Ke;m13N{{5PczCI7jZ^L`FE)8xWS{x@ zBR{&I?-1)Fn7SlCIb-2y`9P({j0Gr_1150OSM=HseGJVU<3$ujN_|oggjBonx3f7S z;BNB67pxyt@<}w54<=~yfmQlLEw&8T$x)>%^rcKnAJy7Vq8%K~buLP9Q0CM$K0Y>c z@zdM)hPm&A)3d)c;@?(iksJY3AMD_qadXhe%&Q@#%ecoIPNHP9MVkGap7VHn-8Vd z7CUXE(PbRAX59d<7Fs0e<@(&AbV*h@YDv=!rz*aOvK(aYOOh&NGJP7E<(H03NjyRd5qiCodt9-&vmlD@#FcP#~C&|^-n`%(=lUl5I zAZ3Fa(I&O2BG?*dSqA!^a&QQY9abWBitzD?^_c3&9l7MScbC&F<01r16Ip9Y^4*J;WXwg?Sj zTePXT-2dXR6VUATDe5H=r1dc_Zm4i=8H@jXtP}OuZAjLKGuUmFPn?uGCAvZ;cB8uL zSWu<5XwSY$l`QpzudYA!mfS-JGw^360ZhHeK^@!yuI4u6lviHX2XaLikvO{S>qa5<$vsnY8**@g0f)YNXAYL(NHV3x_Y(U<+wrP2*ULPG#xp4F-3z0>D*gv_I`(0UEv9+}=-4E-%8o_?j zX5y=dzDLjHj{QZQ6tlA0J(#?FG&v*(T`3U(*~J;eSj1BevrVio>%@j*mA|7f$J==Y z;fTK7!2NFd0Zww4m`?C=$&6xIuVmy)rkzZx^&qvk_R*1f!E)6(B-%W6BtOk^l``<9 zEtd=`!9z~Nv4qyysr$=&kApfvDtH0V&WPtHvG}Ww0dz59KGTvKf4&41uoFDow?Lh_ zPRu2M2~wYfIjb_x{jOsfy@pws|Jv9=%%{@}i_11XHExsB)2I`7&;T;OwKU25Vc7g% zOhg5N%H8G@Ztb5VN%eQA<4SW+=76Guh+W6j+oq#oaXOUC#Hmp#d6ICyyFFrC-M6ff zlKIjJULF!DC1W8=E-CejDI_bOD0KNdR9umhBs1(*ec-euqn#}ud5CE^me8GE5~$!4 zc-4z;J9r3SXN?eYE}uC&5DX~OEK!|UC1(`BD0uDMI-otFSsnSla~3Ahd>QTKeJQ=H zf6Pr?@880+wY_Oei)%J_WX5_E{!0_%Rok)7f*hws!0N+PRUbJEt$y*SGK6OKa-yndJct@ zqB=H!<>yeKOp2JUnWV70tbUP8RWiMtUGps^&ckeN=I~1n{IbJ3>f;ih?~m}8E!S;q zdc;ngKV);qrfhO<(x%3zu?#(AV*oRMos$1)kH^e^+@(VY(O zmSy(P?E>_pl1ZE%9-SQc+gL;IaamjuQ?(za@UZ};ccJ?`dghWcFXPGSD=`RB`l@>N zNEry)fTWB7|eVkO^Rdd=xgn956nGeT?te9gj}ig-7S@ z?0vI#_%r}KGjFq_^O%t_lVd48(j$-)xDI5^&DoTsz)nqm3>9_lB>Iy{-MY9>`apDt z>h(u#hTmF($;;jjfUEo7q^z5aZb|TpDe8FTPhIgKso@u8JZ!ZsPHUk$C;VyGe(J5f zU;(tQGoAvm9`{?< z$v)i1Qh18jEJT>g-)2@)G6f{Bmj%4xqpk}UNgCKukHb!F5iHqMmvm zB;{8=#_N4b<}gYhDBHJ}I`5n9BMk|FN!4kQnzjShdzQ?Z(P!HR#EqWJt*D#@mzk&8 zE?BQP%f9O-=IkHbAb9;wnBe8|n&4iyO@NqhDUAZelT#x$cN_!%P~XnpGi$GU^$EN0 zwI}TE2anmg3&-rl+)4e;v_P!isUd3pbJsi>+*_9h`AA)V9D=A7L!j77swAi`M@f}F z0(e3IMsMMe^`8JM;%Q-5@yq!tM`qWs0_sYtm=wB1=%u@pLeIF&&}CP8X?xmqP^W-Q zc87Bdm>pdvH`MD`iw>6175T>`qU$7mY{6zv%Z&{5W&&5XE}6kf3Lmz9e+#{wsg!ZT zv0=9F2PPDz()QVx1|?@&uXkr;3%W0(Juhcr|FJs$JPv2(Uazm8a-E$Yx0%^VJ8|}~ zox6tsK5chjIBj>FJZ&duPuS$xB$nKK$TbEG1Hk-%@}SefwuLH+Ls6SuEz}%k#4{lS zlv%!PDp^+mI>hI0QHcMSS6wX&9Caml3zHxR0XfT%a+gU7ya>BejG(R$dN-vwqOGM& zFxybtkv`<+v8h}Y>$cM!2QzR*1VR#f&7}h=0Hhw5n-(@TyAPs+SJaw0qRet%j2FoS zFFlRKz9UEgbB5i;49g{NzWu}dUOv3)+lFmn7UtVZ`iI_I{BL|cEUCwAd}6|8kIdMS zbMtoU?qhcT%vn2k6l!tsibBM zat5P=e)f;P76_l}1go!e;6qQpe3Yd0)pp9{$gj(n7%BCzOJ3M&M{uhiQb%uhiL5(o_R?gJ zDuz1vkx6}gvd3jKzoq0cJ}{%7v+yQ=f@gipHWs&SW4Vvn373H#{`?Tef^@+g5J$ZEJnR zCTFJX&>d5D@^$le_VbR|@jH*(836dq+#NPMIisbt{{%+v`7=|=D#rn0J0n1M35CLo zTdVd=pcA^f8SMS#53i>36Ih$!tca%}yIOT6gR~#$S!b=6x1eZKggk+k53@?JO3jGjKb zN1P{tV0MVMnIO$qJC@`b^!e8m@xs3J!48bT9^VFvc5^?}7~?Fwy0L7lH@ED@%Uibi z%8qTW0_tP_QOXej;@E?ecJ?iY?C9y^c6#;>J2`dQCdMW-3oD^RrB$V4DnVcRQ-W%D zDr{#dQ_G+PfBO0DBOlNswvHLNX$Z*Q@>aY{+7JE7q)J!yVV68o+DXt^SLW7vHHgU) zsZ)}|7Lz)9nwg(7uwp40*hAS-!$Cs;U;<=sx0Kn0!T10NUvh*_P-%u{4mO%SrNfF5 zOP?pupaezT6m>kc)LruoFVpugF`yp3m+MYt@BtS8ZOZ!2imflN+2Z95yZQX4tz5+{ zyasq5di?lnChX|L^LF&e2|F`&0ZVEAst1rjtu;)$@wFgPlvaN40g$$p@H6 z%M1-6I94&IsJD1hCpTx&=VGn_`!UH{o|p>P>7~waHm=MQO6k zJgy^br<^$alFIgT=7mr3?3!TtC@IorPUcrEJBamZ9|Q7g=4mYP6ye)bf445SV~`%K z&;F3ASiP^Lj=AqN1OQI*u4(QqD@IQ$icJGd_e;Q2W(00v#C$AYmLd81VI=p{rl>he zlBhMgT)uM|&7Sk6G>NtLu^&YH{1wY(TUi4yt=jUH4ZHG*4gJ)N07V8sj@&h3M_xZ+ zhfg2HER6f%@pCpY!v7iEX%o!i@tqawWVR`CyJbri2xOm$s3XW92tDe*+%DSPfs%QY zIlz-(Yqp{<8Mf-qygCN%0*kvUKGp}>${EDmXLrBgJ-|&rxhm6bv&zs%le!cS*W?$} zgZF{kgieX^f(~PsHG{?%ug0t{LBQ|^YlpQ;C z!p@J~W2eVYW9QwycbXrDx2GcbOHoQBD7_ReMMddvl>wdLe{hJtX_eYl`Apo5MAHxn4;*xX%}CZMali{A$G>W`@jPzM-uxj zdybmx9&P+dK8wU$iw%L?l%k7H*PNOM6hcR2mn0vBvFFaNisK*4Vc5!KC&*qK=?A6pwNRSWM(d(g6!gkcVm0S7S?X)Uz4uh z1c)OoyDDb)s2v1zHmG9y1U_>5Nhv{l%8`&Sf0iTFl713(uyUz}U32k8T~tNs56(JB zsn+$WJ1Vk%@gB?%a)ejpaj7DzET7Cx38Oq`OxImdp_=TJT2&MO z=%$H{1h!ryUix^_h>d9}T}3gP`vCFg_L?oN-msesS8eI)OL zqxa`=+lz_Ure6yXADe;C>uFKbNY|MH$*!qGdnj_16J_EW)}k52j!Z|?3R7(!2lC4->f5>hd_xMO5_vBU-y)-nm?*L{4I(^iT0@$b{wV?xQ z=#WyWW6+fkbyTA_wHm}Oxy>j@Dsm*TQ5_k_X`>p#i5kDiz zEpObi8wByS>$ZGx(Y9}G*~&9!*DqmwVStTbDZL9Ge;9?L{AVOop6!rKqb63uy0Ws$ zP8a_r)oDJo;<1V&P~AEt*MOj|t_~JR(npX-ZVN=2Q~9KK?2NbSfzT%N=nGlOhfgx? zWcus8kcAnmE>3yqC0l9T-GOp z0GDtIBiqu%)5>~z_Suo+@Nov^$0q%{mE9s)MjS0NdJ?)ik5aw{>?A!M4r4F`{H!n*!&SCtx~2N$@Qke6^SoRS zapgrc|Fge-U4yeQ8c}MCHgEMY^S{*d zcj3JOZGuaO9_AoooYb_r(HYALmOO^Deui&n@$AFFK2cBbDp2iY7uO@+r>kx=0LJvXqS32w?jiV0S^m+ zN#2{;kqu#Z$@ZS*&&cX(3$rYxvn*_tS0`&og7^t3DFeuJV)&}8Q+iw{3HVWe`#F<; zgp$slK3?h2Pr!IaUtcv`*<7&2wHvmuaKjca-L%zLHtp8OcJ1;@W{Znv8z_*g*F99# z*P?7@(tsoly72Q!^O;e8UzwI)>ino+(O|MnFO=VK)RNYdTP#piv#bVw#=xqR3_s)L zl%-zhQzu1k)=}4;=e~|5wQ@-*>paR1mon)i@$hTAkoVQF0qH&#!O*?~*!$QA3#sWZ z@4W<)wh?q6haJjb#Jd%Y5#s|9oD{kXZka%GofbQSR-}p;kAwuo8y)`BxBTbGoBkD`v1*`R5T ztCd|7|3wPH%O53ZYD$Tgvg0(GY5Osc@e5KsNno|3%jr*mXD%gy9lCPrSe6YRZJjsz zD8Xfa;S)!0DaTl_a+6Yza;bN@luNtvYkx5J(!mEg3S|RYV@_w16kv?r%_X!b`~s|0 z_g6(LN+b8;pih7E{MfkwBRpI-J7q@Jl;t=IFj`TN{}+i*q}3{nm-6S?Njgb^WOFFu;34oeiU^q}dyNv@%YK zKOQ{)c!rCJ?jn3Xky2`#=qvjz zYD0s{1nEih*sjgDu9V&`QWkAIpj=@f$ge1uk5iHp5Rd}_gIF%N8BcD-)0g#7RxCU6 zsV8UoRvu;KmNJo7%8|M;IYCr1k23OVUz_x|Ua5SMTujZxYpUF$S`G5X;N49O(}e#QR*fkF$Ax!69nFA0^78j_r{RTkS8~ zI%eVZ4crGW-?G)4i?()g#q2lNG5DMICeb4zN`~{yNhn)e~FQg2g_wM zLCLNqp{3!KDOJqRoaZ=s`A88t{CJpoCrZk~$=nihB(E*@TA~ej!3gj( z)*16W=JWH>xK#A~AAK`}If;2Lse4#k_eVBuZFkYO`m46JxnvuwS8Q$hx@}-4W?ciR z4)~6pLT8xoLLb9HaMq1mSC7|ap{p%W@(9#GSK4(m3vCvFJ75sNLN74_5nOD>m_w#N z^C1fksE2Hoqhu`dOBpgnrBiCGRGekRQHT6duMRWg!4#6UPtJ-|@ZcdmegD80PxBUlwrJ0bS1O6cAsgG1nY4)&tZ477|9&3o)t+d5Comx z>egRh# zQ-}K{oZr>Y&vF(9fccgZKukch6bDvl$k?&<-4*?BCH_0V{tiIA zab0BxlJ8bB2jdj@6l~78{6d0CMn8CZl^kXz;0?csUa-I%1eNDvA!gOW@FxiBfnV&9 zyr(U@PmZ|q!&bSBrJoeCuA?rq$CnbqHz7X*mwk~cpP2i|&PtMf@D#d5bswn@t6r6c zP08tWs7xm1z?1YO-uJqf+dSjdnUAOgD~X!>9SjkXz(#)#kRHJ)Eklg>Na8;)h4_D`;T;ZJVm1#2Iq%%vSN%hb80uJln> zImMSu3SX=4tSjOz9%32_0Ds0lVlcp|ZAq?%VKokQp9=D*Z!_#g2{P*baxj)k3we%f zDo-OSa!7J!b(V7+$`q|wyO9;60bl+N;ClMzxBZTXxWrVTN}_c{3B1+`WQ5<#Jvn#BP~f5uD) zeKGWr#5~TZdLoS_G&AXR%u)KAOdjFC2H&>zoi)@Em9zeen0pxapfh|!mz579l?|P( zg5C7nZOSl?c5BA3_bHuaz|hyQ!Y8eyb7U3cyi@wDtO@ze68s$-gQ%E9O|2b3oYIFZXlQ2*9XVfK7mN%RkiN_r;Eibz8HI-Obyc z47QJbqQOVocLK_z_xhcv#nDARl`QMzIZluWGR$q=_oQ1lJ@fhsHc)gv2&#$&%4GUd zW-RsKR#{5anX&r8S2W6Fp%-6pQpQ!TDl4K4f2oHeb#U%K?ZSJgbkI=H{sS0PcM0|8 zKCp>saD|qXTIMr{TEpq#nQ3a{@UHjiL{HNlUL%1KV538ld6^q=+RexZ#XccMai7fZ zDKW=Oprin;Qlf2)_%+=B>g#)TH9`Jlx`|QHLoF{vzO9JuEOqgp!+1|L#QLI^ydpq) zSF(TbLj3x5MdV+P9VbZYL0^0wz-FxFqpbYt%Xl7cU5DZ%mP@;ir9WiWuLWNCYcBOB zCsn@EmYViB_LqhNz)3kUg$4B!2U62vKF%`eF^@JmP6^%gtDwm1Ya&jJJ9{Q&bPXIn znBB*=Wfoy6q7M~%juYQf@;7u?j{}&6RjcN*rzN_p_r;K}_IQpn?s zsYojyuVRLRI+Z7#8xj@o+0D%nTjjqMg^R6S;D81|d00h;E(z8lr+Jm&zO-Y}5$pj!+10E5{1Ynfl1{Ep;aXGaE%)q<#cZI8R%42@d zwnuyx?jCoNyxIwgS()cP)hDLkW2!&NuP{&;%k0LgNp+*_CH`UvfhwQb;x<+ke1uMe zDFLVgy3`pDyA|)0%b5IWhhEF9GdXifvNJ|s#IuZ!E#iuWUbu?4a-x1uXsBcEI}HVZ z%K$>}>>W%&idEeQ)dz9T#7u~IoHdGoN^Fx*B66bysL9M1m%5r|m7Db=Qh-$F({Mip zH9lo#F@4Q2E&?h+Agij-nGd;v#WdYDrOlis#{K!eM2sm;AA6&TCD7%gS}JL3lcplj zvTdMiS6q^~e=bKCSPjz>Bpm2q9ct)e*1^0=*7>zwayvFzZApJ{f=&66SF`p>qRxD( z;a4m<%G1Zg&*N6CmKCX+hKPm&zXWg+p5gc$y&8*av&C=XD zH=vM>3Itx+kQ~^qfqaimHVN5KeHragEh9tV9YebaWW?x;Wwh^wANm-LZ#1>rnYB0f z`8Bn3Nwl;}Ssw;DXyZL*VRO=`&;DRM6)28f_ci+&^z602QnzbhO zT7W~niNA7bY!ki8_B3qLL*YGLm-VRI4m0MY=DMTMy&~EuLMuE?EVL}Ghf@N&lm11C zMjK$NhglgTXbIf_F!sR{5xb_QZ9~lVvh7IBwtiqG=0_M#Zq*LtqJNa5kjK40ykuI` zKK-&po`OP)n>eBgl!%xPk4(GLDOI-CGoCpSS5D2Ot`Drdq&imbtLCJRKXWr*?FwB? z>e@jabKhy-0i5q5wMb*K=_(GdwCLAt5{?|SDI4-RM&AI6WQPEE=sR@?Ihf)P`H%!Z zcM+qMer{Mx!bn?J8>U|<6fDIoMd0{7Fm52lEbsf3Cfi#R6}5@Y(BAh_W^=d7z{Y*t zMwG_`;yy^_q85Hy?m*Orz>YzZ^4x(<|*#D&8$51}*YYn!^t(3g7Jq|ghXBi<^P zzKYYA{yJXAYOdpTo{l{CSH+ZH`McyjcJO6}ilPb8S?V|Ro_7?9JxUQWsEG%`kpq-O zEp6AG+?Ua+gz8RTlU-C$igOHooj;McNJ^ z*6TB9s}m|}LJ9RMuk>BEgSByAycnux>HOo@Azyp}YPjTsAkn0LjlOu8rK&mLnLtVK zRZpeUF1{+304g>ssaS33_`7B0CsjFhy(JFP5l2oboAIu%wuhMZ9l-h?EtP8Qa-g#F z)PX@BrZfCt&X$Vk%;-;Q=JF+=6n}wMY(0mPw$GSg|5Jtjkf|v}kcB4J7iI&5oSt$Y z(lx{R+e9Qr{E0NP_?c*znt_o|J#zS6 zW?xdcNmazm(6s@Rj^z`jcUk(pTyU zz4#&a(!rM*3b6q>0pP_`0vJB`TUL$VgGMW_NNRTMElC_?3*(_g`DZY@ZpZ>@r>3Gt| zyx>wkZ3q#S%&p3le3~H((XQ*SscY{u?K^-;KGc%@Geg}@<$bSCUQLn2SffTIb~Q9iJxfSMk3Es_ew zAcknqlg`3ec{v0U$|S`#(8EK4YUCkEkf2z~V9k`8aU+*y(+}2tEnh4u$*q$wpvSNu zFE7&1@Oarg-WJiteQ`vo3Edppxd$b z4fFuh?Z7Bt1S_AExuhz$uA?rOKIuudkNMO|=?|{!mR{HQnYcsIokK%I0ATiH4yu?h zVql2sPLv*wuFfi=a}&%yJC-a^_{G?E&IWNo80jxU0$@u+msKE871#*4k)g~;@oyxB zf&KG+Sp8@JY6)FFd)b?=OG{JahGtR$sR>3TI=xj0R{K;qgy1V~)C6GVyq#`J*Rhp? z`r`o<_f%$Ix3HtkZdx|VeEs}vf|zxA*+G;wB!azrqAx0PTR~|esM&p9+U=(Fi2f_Y z)hiy;ZWvci_()-7UDUV0EAccs!Ix#bpiQ7C)?xXXPc!TmMV^>c+g&DgWm4p*KSRGQ zC)GMh_QBgoh2p%miGv8j2U+xBcBIa5=p>#Euuh7WmKl@>TlaYy6ImBV zPPHzow8)DK3+Yo&W-KJAL@OUfRh@RRiu>R~OkkHrnVk8u?qtO(z4oVG`@~UKxiC;b z-%}>zU<%nJ+H!;pT?dr*ARb5uPoWF-vV#kuN2|`08akdLM_*9(N$!Enum5@9ur6pyiE^cQvl3wLE3fR@+Nuoqa|70|+sfgTv2JxYul-X{^C_>7X(xw5feWiT| zuv6VFq3;>X?9qsF6KQEQ!?KxA6C6#<2YQJ^Fe-%v0O_;Bk?!yafbvCv;ZMM&&0=Ee zp2N>vG+8 z;O%FJ%x%8Hfuse-+|}=0SM|Wpr8axq_XnFF>d1Rx)~7n#M7ug# z5G?e8^4NX`3&MRvt0`00Sk2HNf|uQ|ZU(DN6ihv1HPxquw8(!@o_Q71N3{k-`lZvK z4BL;1n~<3kx^9v+(FlK`^mYBBgC%rBeSTmAgiSrva!Hz` zfv3*&9&P0YlPEJIeL0iTFCRAU0i>D&*k?S90uc2HE9$ZtLp~)pEW|+6LGHuPm;3NS zoy-;MDPJ0yS(I>NVzjy^S+obj(=9PFJMy39bOI{%;-g;sDZ(csWfEhRU%9lwI-<0bXj5nt zHaNOV`(e2-8ztH#&RCb^JeYwS%5O8UW8!S6b8}V!HTS@f_|tb!DdA1_jl!{YjfYsz zh4czs^zlz=jH4Z@BcSAAY5*A|4A#WD1Y&8P>wlRIKjMDRt854_)5EdqDYYXJgu3a| zG>BYXG_u_dsVe$~E(a!E1g>i|6q0muzxpl#PJ+(*o_Pux+-TDfuX8A+R(8?%(7_DcA_23a(vf-g z!0LDfF!~^KNM=fd_f!ZSf4T0Imdo%ERK-_dDd`>LUe5;+1X3W0hT7(qK!o4n3xEnV zU`W=;OO#)fm_|@DlK^JE*Hn`qd-^HqU}hexU-Y;SMdZ#{WMLD#v};#)_0~}iV)dbi zBxMJ?!@1kCtdCu=z|W?@?v^POdMlp$r=VVes^r0!`ytik)e~uxs@NW8-AT2-rnGMt zA3_=e0JCT7p#hy87ot!atuxk;Jb~g)Z6XeF4rR9kCIkh6g_l6aSJ@9Y%pyCuQrC!8 zw%40}2P|~_H6PTVjV*0T>F{x2q7-Ag57zxN!JQ3oqQ%;!l@KogVe)Y?>Z6_m-G!I( zEeS1+zI*CP?33?*$qIs!<-3&bI^0Tyu{n)n=FS)hR((9Z0Up{)$sAJXrD(>$)TxrB zvz~}4o;HbgN2gipOX}FIdP%gac&luogC+E5AkMZNY+TB$R;mr1YhqZz%RteYjcf2J#d+|dzx?zu=$reMwhE<`(J_`5m0jbF`Enf}Phy!wf+ z1SP>2x)f6CT_)8MtU7LI*OC-^wx_#Kl}%seA7&Z?05?ye3*{I@@2UUFfCa%(2D5B9 zLY+B2X@}0u*!-Dkn>#&aqf-P%hN;JZCt%?87V#yyRyxZPpV~#A9I{$l=2+zANljLkg3WODoG#XaA&+2~E8+;rELi+4M6xo10Qa ztit#IS*WR^lqqctKX7=<=r2bUaBQPbaL5~O-7 zZBiA_Shwy%gM9l)Ljd5o@2flJcAXd03?6C(g`02sn)~f5|H7N>OTPWJ_V#anz>eKF z7rDrh7WsJT{al7((0kl9R+qMNTXr=Q>*13}q!FNuC;=NNyffC_v0|R%G3Jo4H;fj4 z(B*sDbLet-s~oW0W(Ab2gL--?)9)UZy!eWgW`L3?)2?LdnV0S)>5Nl^T+c5y(4eZI z>t&f+`;uUnG70?5sU*)c%~ri6`e|1)d^auusZhl8-Z%ZCqJV0BNNETF+&yDK=+)N4 z1rl_caf--!&NwqfAwsqv%CX|z; za}%SniMqY8V0!Z0a)(~ITvjnsQR_tJK-BG94MRYS91+f=RQf|or(`VbflPud`{~36 zmL;)3Z9|sDNcupjW~^>^#%glk!P`g``A}|7k}j1`!Rc0l{~E!)xr& zoip~j_uOS?9zJZx@0~@siIW5%&Prg4X5Y?wQKikl1g-pZ@E#UzhVGGO>ptj|P&A)n zzdio6t88WYi?cVKURcTW4W3kiH6?BMmX+=cd~IAe9(ZOySz z>KU4K=>>4=(^*+AnZ-nL5FN@m_o>0?Es;Ydo2 z6%e2dbrq$ZGbEctXXZ6RN+}$t6|o7~O(BIaR~w&;ntb?kOFJj70{5N&WCpQy^owq{<7!_OQYNAeKU5CFLOs6`?5enVwYfEdy+jvW6$ zznd@o=2biM=wbVV-}_p7!#A9_sS{&3;hvaVKQTD$0Fb*A7!72-T;msbST=H%7qhB> zC_iNb*(|Fvd-A+~#zZ;{%$(J+l3FGV#j)``FDo?xn>My=FEbVwV7aqJUYD~($S$>f zX{dm!B$gfLcY`Ys)HxCzpIQ&SkNgCXtk~-0R^FJ6 zxs{(~pehcj&n^?Znh~jc4l|TRzkFU#16J61@rZqR+;tu$Gu!0H?u27OTl0uGyK11x zh9Vi_dtk1)_{RbQ4gn+B2%vh=2J7R&@wsHaRF-jqjyC+GeSMW5FP1Jfgw7cm zx%xyEBtaVBbQyN$@Hq643qIP|pANZ2>GQUDd*l$&olvJ)<-8vb-b3WVvxT> zzE7zFh3bYJ$E~57l1%FADN`raz^YjFc6`a|gSY@>j`E?3pw#^&JESON*+=MEXDJ`C zLaOB89=J_0_9VeRV@2;}2UZ=Kvu_p?Veo(8$DgyG{KgL;wQpbix9+rK4^OBr&32mc zsxQy$#SU=jId}!z@B2#CWOgCR@kLMJ|bjP|?XUOux{>yS(G45NL^5xTUa+egz zk;eT(DjzHpasQN7Q2HVJ)T@vJL0;BLvI0`>s_0#gSPK3a{AdMW3Cdu1R642h7p8y= zbue{u*=MRZsRQg%S;)*S@zg1Uxd~T?xVM8DxJ~FOodmZEmBEZbNa8@&&?HzCb&quX zz3x4C*q8s+hi!Ch#D4XAF51E;`4k$j$WNVSSpK4oeek7$Xq*utJYnJ>Cry^#)YWPy_26`q_T*6Q`Y6LLGi$}I**0X^UqybQ zJeYyoq%($%I!yCPIq7>PUdkb{0Bu?$_WZA0vw!ogkK41qaLexgidj4M>T%DfylV)Wge&Pky1BFHp?WJm*;oJObjCTYW!5h zG6Fs7&yep67XDPHSFCueeCnUc2U)^Yf?1C^K(>wh---B~b-CA!SaPA%2T5?9o4}%v zhmpDTD=+LUTl}QZvz(->r7Q(0r3djBaxfjtz-?-El#jL?&b96*fP*!Qgby1oDQ8bk z*gL-KZhPcC$87EDw%vN1H-Cbe@|s$>Ff@28=w8v4jeFS(kTAxXZEz2uiGFB_RCqW~DXfa0Cved9WbW%Nx&#@tn6gJ|Hu z4PS;7*2YP@#-ubE_uB3RmmPv=S7nM`NvgMNqx^L)_1bpP-an|WFE2J3qhP#Mrq&0L zpQ3{qxS{w5-|8<6Mjw1+bXIgChNvr`2+7lUq2ce)9aFgI_wCx#tG2bqL_m0>^^*vqBcRlUYWxLDM=!0l3n68s3vP>VqmV`y1r62VM2E_!Y6Z0tu zxPWp>6v(!-Eu{o~k>6tFBUpN${qjzCRZR3*X zE5S=i@~}CBQS%IT1DN0noxktgEWhIgTYybJMt1r&lQPQLRaw-@9&hxBLid?ld&b7= z8cgg6Z@FtE^pFf}P>-UttNuzlbO@W;RmDVUQ&ybrRMM{f+!bfw@eSA0UqDVhnWFZQ zQV*ukad!RW^pirW$I=JNxMtVNb|X~ExX{oicf=J-Ie>2G-!IbG*T>peXiKkA@RPH56q2W$cgFOup4$oy$B@q`Fj zz#`Md_EVg3yuAX;zhixl`#-$k>mP8ocH~M9pfZ@can^x9#<|Z(bep-mHam^=L_Ek!QZ2Bv z+#V){zQICkeEm^cM->WlR*h>R~)2na5L(i84T&G5NG{ z$+E?lHaP1LMXW_#d!K0t0Gw+X5IaXbh)s5sYzRmn-Z9J27h6JrAi3+S=Ixsgt^l4^w_NbTRZ#pY4 z0LOAN37w|F9eRmrusTso7`TKF)x7YZR_v*Nx^B<^AG`L#4^G(50;7@1@&FG}!k1=Y zz1;7!DO;ncOXh07uJga^^Bz|pmvnCv$17{(?5_RBK75~$dg}=$0OiYY#yn5?s&_9X zNI9UAof@Eu(l3cpXopPLXHH5jDM_UWlrj^t7JCLp%f?yJQ&5B+8&VNb8cJGbY9Dqes!F zowJ?QNwT`E#tVw1*42}$a-4Z*`2Z{ZAhwmU1ciut+7VA(pwBpC^as(Ou`J_#(dM!* zwiSA*pOiXfaMrOWFYVgjqT2@cg@ypY*@WyEjwH$k#7@*T+%?!S>hV{B0I!SxWy@ZA zZ(jrT>c5<_%@_GQj~RugnKmtdMFjP+9iEe5Ei)PgYkbV?_%Zn4RC-cf zEV#r&;cS@U;v-|T%_q=&S0!dXwWZ4OL@JFMW;0s`sVQl<5-WnQxU0BSZZb|8w#-WJ z#s=Ai_Yhlo@IG*%KGtBmr{w@fhp~HnSd!8rM8YDN5>ye%Eq@e_4{P{khMtzG%!??b zmca1wm3vV=@-gnOrrxj#*zod&0+MC6C1C4&Vb{DpN{0v1>vmv!8MXi>!5l3bG-kYi zni0jiyo4{URf>Oc5s;xGT-kUTg7EB_W~D<(RZG>hgS{>Zw@K-zNFRvr|Mmc45&W_D z*aT5euqJm2zEW?rspMrD=A@kjz0AlY+M%YeZg1+D)6JCxmm)<8QU$zX4F~Nzfc+s* z^jOtd-qAU*xj`P8F9JiF10t)8-LQ$X9Qr&&LMJ}f7`goC+VWyQ zw6mVvYGzdqZO-KMIgj8fp?o3RO8}DVk&I{*IUOBoY=>SV*4RkOkVkGbDhSIM6(!q6%Jdd%QxJzqgYwf~;-rwpOr@smv>~B=2XMLEMrUzpNnHaR zDy2Wb;wu0lnZ5=VH-2fvuKbH}yZLWs?Z!{f+ty3|Wd`MkbeQ0kOWyb=+wu!Ucv0d$ zHN4t#hIJsrqa|@L+rbNp9#GN8Gt4^3(SFXhjHOf_C8N#pDUY&C>>Dz%$NoW%&#a!S z3m{1%bdWSQf_ca%@b9?`UYPXO1C+Y#@MTD@^kqC5G!+1D-BTu$(oYe-l&zeQTCP*p zKI%1-Qj(yToS^PLN}V;6=ua73;%V=pgC%q!T`aSsqO*KhI{Dzlu;#$kABH|9K;VD_ z3sA80?>er`)KMuaKI# z1H^*|47*12sFM_Q0;Sl?vENir_^4|pCbMq1PoC`A)c8*6Z%XMwMGYlqGf}-uIm|}$ z{a-ho(xAW63)eKrA9jMd#0JQ^?eY(@YbMna%>H6Mt&0#<`dlsKv4bUaAs_6Z7$_RX z8qnUM(vd*F=hAQ~KuE)uU?hn2%2}1RbFGuPXXypR{?Y|NKD<;vU%V*ntyB5jvOSui zBaQ~E4zT`#H{(1Gym&C>MUbUU340K=mdME*Nnr@u?vxOPOW;QRjeo=*yx;BO>rw>D zKn^`^I&#ok-2dj_PwwUyig=#yI;Q-zD}U;H;$Zez%MU6xSR!pwEkn<^%=EE+1BmBo zm}m%=(B5ae7zkYA`3%BNYNSA+Q^l>@e!odStp;3rp`1s+&_@%H02AvBt9b?3>e;)g z*XtI*^m9AW0xp{g%=%&xW$6*1%d%QgvDXuAXAJGpppaieM1cA-nUbT)XH$(f4YCS^ z>L==uk>ZXpvP|S1Ki;#WM_5CUVxeX#Hm!KdjMGL!{=+inwBDl!&#!Tr%nOaaXp?k# zqf{)xy&fZrj_N;rH28B-{JTRcxgMlL%O{^d>;{;Rmq) z>g+38$~jj>niwg4;MM?wgL#8;ThdRtyRb=FbW+$NNF7DkWgo$5w|udWLUoLj#U{WB z&ODWu5*)O=vn<&FnDXErxFUY@XV?1tMZ=wb3}hd8DP8BF=V^onTL6X4U(W*VD&ODybb$rbA4pDz_ zz!1c18>@Et+7&trGv+GGhCf7MY}`$SHT!;KA~-c^cGm^e(Ck!YqL3(6$%re5CMB2; z#3{3y*pqx-aDYsz{a~5g5L6M{)22!%rJ4ID(bsB2FvU1l9(R9}**kv2?497d{s*&( zV+fF{Jno0L14- znOqkAE}4Y_UM^lfLPi8$GU>?|Kbj*4lFU40fn`c^iS4>OJs^L{aVdgw_k|Ig1d!!- zujd8RnKG%wKs>U3eB8XwZHC+y^2o|a3hxT6iuVzOc1HS6@8ULwGYtIbsnOn; zv|*rq2QbFp_UihY^|v^rIJ^lI4yQJ!kJ|zZf`t!?@`Dv+=5&za)I^!atJ#$-z=Ban zeyAfd9DwwxKKKH>n#CyrCNDn*8!=p97-?RxbOB&pu%mt`9w!)GQ(5KVm2zfsP8YSj z+W*+U`(ayJy9S%Htk1MQm?%*f2PkZE8L-M}W@Qb0C~|ARQta@o+1Yba8)7~=^b}(H z!$-$D2Y-5Vvs*=>TFwpCS2~XSVWmj3cb`{*;H%0NYLTenZ5YW!9NN8weC}y zDu?<1V&U()3g_nLrY@=z<5PTIGc;@HeFyN&^u)^A#+t3KZ}Z9)L)ZtHhPi&K)dzP0 zXaGU_X!ry^dL4v}Qu7(Ok^X|7b>Zb@9Hi_LT^Q&iNCkG!Yko<{2fA$d{Y zD{}edS{DTB+(&|#o=W$4&o-9V?dbezTUuJu#c6bORQJJu>nHwS*gr>?k1!u>K10h_ zgEd^f#Dv0GT0RH6{|KJPC?CGpY--AVVuWHhE`wDjDfC+aFwc{y$}L<26S4+t?l0q| z%m802mwFsS%lDaVP=CX0@sm5YwY_NXo64@uLL5!@QGPc?P_8Kx@6rR>7M6X4)*G$GJfF@ zb7o#PJAUX6Te!7gITHPnkem{C@Y3|IhZP{`ObeE7v}SOA_)i zNcBFf7=^i7DLN$IniFuza4AO6h7PG&8S?1tuARqH+I{$ooHEme%<7Z_F^1E#JkyjT zWjsM7JL}0<&5=h^JY?=uWiuzZRTpCsPhZAqW_j8pW9a!woY5)g9(lt1U<~)W|HrMr zY~OtGZMN9I&XQUI&CJZ$!oq^hPo2VeU0wRuzxMM>3JwAJ$k|8w=CAxm_g*;n;L{81 zOC#@o)0f-(e(vY(W5523cHimy?9A9P+u7W)ovprPA5zSLiF;L5?REFP-rn`tyX|%NzQIl(KPz8T zBPi7L5T{96iHEHL&VdbquC?F(7-rPl+~H+0fuy3z6|-|M!=E6cBvB9PN=Q_abyRl+ zO>U3?2X5_;c1TezLofL$LGo2Ol)RN)*tuyhZGF-{xc;B*qwBv6;NFM?r`g$Ad(V5` zV{`L!_Too(?U6g*^>csopZ(!?M|j_;S~WrUI{twB|Ef)q9o#F>>5 zpGhI%^BGZI>lph%`aWCpZU;V zx3_-58|;1Wd!If2_~Xhxpx=8sb?TIT^;dtjUA%b7&W-$jd&8p-f9p4V&s)Dg!uw7> zqW70}KmYZQ{lXZ4@?U=YSM9{H6E;0HZ(9JU9$@i4QTK{`Q96hOI{^;-Uwh z6i(JM7o~ex43CUK=lwSQtb^=#%36SP8BJh!>Mgl!g_hdx_kDTW_};H1^4Kov8N;@D zx#gD;*9GXsQQNt>W=ALQw`K^sbY4+RCkETU%PSBcrnbFJ>jquvj9Odppi>0Js05 zBVN2uCfEf8=LAiHgTUpzs_uJ7;S<0Zbzsu(PmGZ*i99j8$nzb%QD4}(S8hEPlJ&?Y zFnyj)yODUY4&-X)4*%TLq>bNo&VJ>i@3nL1&)C(gS8Zhl>(m4KJtLlz>FH^E?6Jo% z`(CuW4}Gy6Ieh3B{>qR1q3?^7p`c-yf$d+u|9hT0d35Sut}NfO|N60Cu)8087&l}) zw$b15L5`QtR0JX50l*e80bq)2#&igHMA4WVnG-&OQy$kj3pY=mn-TyH%a;qk4TqNbc%zAbmaPAq_9+PY)ao_z2H``B~; z-d?=*Yc?@4Vb4DMtWx}~ApfYPzYlys|G$vVDOi(0@Y%Cx?Z}ZMSPhQYJ0ATOJ8^vS z$G`iZeC?l%B11!E+zbPK#hd@~yEeB*{{68-$EU}~XY9hx9X4~VZ=)-lw!^2+;Qo#S zS)W}6fOS126T}3y?m_u#z@^z5;B`G_YyyQRjrjsIfUgrtkv^|QFAt=px_rw`*i3Pc zOAm&J)QU<*lFJc5nGfZHo<0A(y?Ew|U0wXBJ#q2h+3f7JmeTntt@`7Z)DP&tjcU;9 z{DOGD%O}r#mtwYekG<~B_t^6K@&`Zp%=2IT+t2>(1tkp;HKS!n=&@J*KmWj~BWHhn zY;^qa?DQ;_kq_Fb)oDArF>PC$+x`|(-V1{`0r^`IaVP>X4-7A!6akbc3nz&=e5$M$ za{`_;0`Pt!Bd4XimfQ5lpX{U@4DO12wh{g+%Z2{{=O=4TGs{LH+anm=K8&YiPS0GB-8 zv%h@3%@m}!cHB0NGq zdFxsG*p;VkYHG%g%>%q6*X`7qX&al`wS|?-*6*#N$ad8v)zYH$JA;b?- z010SI5)zUSCtlvn?AngS0V1(4wRd-R=IwfC?VWX_*2zn~TFNIG1}AHxuA^DrB2=2% zHMMT?aDVtAH#uGY z{6XW{l-hAjgY1Czd;8Q&GitXw6!Uk&UDz)Nv&fH@nMApTUE%np&yuo?D>U&|YNHh@ zudYD2-Gx?lTGp2Itbknf%aUVi^82)stCWGVlzV-J`V2Kl3aeWWj$ZP0 zPV?n&n$CaGWICexpXFBscrPNec=~SmOkXO;9qrlFU z2`QUt?1|auDDq2d7t=)XYWWf_UGT5D?o?oJIjIWj~Gm$~R%sn)42df)z zwo$EoC7gu-c|`jBj!x!k6Ro&~8#cwh7n_Mq@hy(y9@H{4)P`{ed;UeYOj0E+7T6^( zAYVmMJjN2s;me`iXiml7c)SwJip&kMOa?^?lK7iLM!=mJP+MT^KG>q*f9lGt|AaIb z(E&J)Q5vWeEYh&6$KeU;`3n3E0h-|$qdy}y#^(m|96Vg1FB$SF`m=^;34;_I5r!V) zAo0arYl{)a@4YSZwlVF=UN;?fJKdL$J{`S2r}OYaAs`?iARr(hARr(hARr(hARr(h dAmG0T(O;;~lHa#i;uin_002ovPDHLkV1iMgPQL&E diff --git a/arkoala-arkts/trivial/user/src/ets/page1.ets b/arkoala-arkts/trivial/user/src/ets/page1.ets index 7d28ff27e..7495a440b 100644 --- a/arkoala-arkts/trivial/user/src/ets/page1.ets +++ b/arkoala-arkts/trivial/user/src/ets/page1.ets @@ -116,7 +116,7 @@ struct Page1 { console.log("#### Set Button onClick! #" + this.state) }) Image($r('app.media.startIcon')).width(60).height(60) - Image($rawfile('phone.png')).width(400) + Image($rawfile('koala.png')).width(400) Text("Set Button onClick! #" + this.state) .width(200).height(100) TestProvide() -- Gitee From 87f395ae3801938c58e1286ead8ae394bf80559d Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Tue, 18 Feb 2025 15:38:44 +0300 Subject: [PATCH 09/20] rearrange code to remove cyclic dep Signed-off-by: naumovdmitrii --- .../libarkts/src/arkts-api/peers/AstNode.ts | 14 ++------- .../libarkts/src/arkts-api/peers/Context.ts | 3 -- arkoala-arkts/libarkts/src/arkts-api/types.ts | 29 ++++++------------- .../src/arkts-api/utilities/private.ts | 22 +++++++++----- .../src/arkts-api/utilities/public.ts | 4 +-- arkoala-arkts/libarkts/src/utils.ts | 9 +++--- 6 files changed, 33 insertions(+), 48 deletions(-) diff --git a/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts b/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts index 5fc86f188..5b0ae55cf 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts @@ -13,29 +13,22 @@ * limitations under the License. */ -import { KNativePointer } from "@koalaui/interop" +import { isNullPtr, KInt, KNativePointer, nullptr } from "@koalaui/interop" import { global } from "../static/global" -import { Es2pandaAstNodeType } from "../../Es2pandaEnums" -import { unpackNodeArray, unpackNonNullableNode, unpackString } from "../utilities/private" +import { allFlags, unpackNodeArray, unpackNonNullableNode, unpackString } from "../utilities/private" import { throwError } from "../../utils" import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums" -import { allFlags } from "../types" -import { KInt } from "@koalaui/interop" -import { isNullPtr, nullptr } from "@koalaui/interop" import { ArktsObject } from "./ArktsObject" export abstract class AstNode extends ArktsObject { protected constructor(peer: KNativePointer) { if (isNullPtr(peer)) { - throw new Error('trying to create new Node on NULLPTR') + throwError('trying to create new Node on NULLPTR') } super(peer) - this.type = global.generatedEs2panda._AstNodeTypeConst(global.context, this.peer) this.updateChildren() } - readonly type: Es2pandaAstNodeType - public get originalPeer(): KNativePointer { return global.generatedEs2panda._AstNodeOriginalNodeConst(global.context, this.peer) } @@ -75,7 +68,6 @@ export abstract class AstNode extends ArktsObject { .map((it) => it.dump(indentation + 1)) const msg = `${indentation}_` - + Es2pandaAstNodeType[this.type] + ` ` + this.dumpMessage() return "> " + " ".repeat(4 * indentation) + msg + "\n" + children.join("") diff --git a/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts b/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts index 07fede2a8..e6ee16f0b 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts @@ -24,9 +24,6 @@ export class Context extends ArktsObject { super(peer) } - // TODO: - // static create - static createFromString( source: string ): Context { diff --git a/arkoala-arkts/libarkts/src/arkts-api/types.ts b/arkoala-arkts/libarkts/src/arkts-api/types.ts index a3168d27b..37bf647dd 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/types.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/types.ts @@ -17,7 +17,6 @@ import { global } from "./static/global" import { throwError } from "../utils" import { KBoolean, KInt, KNativePointer as KPtr, nullptr } from "@koalaui/interop" import { - Es2pandaClassDefinitionModifiers, Es2pandaContextState, Es2pandaExpressionParseFlags, Es2pandaIdentifierFlags, @@ -31,10 +30,12 @@ import { Es2pandaVariableDeclaratorFlag, } from "../generated/Es2pandaEnums" import { + allFlags, + arrayOfNullptr, + nodeType, passNode, passNodeArray, passString, - resolveSource, unpackNode, unpackNodeArray, unpackNonNullableNode, @@ -47,17 +48,7 @@ import { AstNode } from "./peers/AstNode" import { ArktsObject } from "./peers/ArktsObject" import { Config } from "./peers/Config" import { Context } from "./peers/Context" -import { factory } from "@koalaui/ets-tsc" - -export const arrayOfNullptr = new BigUint64Array([nullptr]) - -export const allFlags: KInt = - Object.values(Es2pandaModifierFlags).filter( - (value: any) => { return (typeof value) === 'number' } - ).reduce( - (prev: KInt, next: KInt): KInt => (prev | next), - 0 as KInt - ) +import * as path from "node:path" export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): void { if (peer === nullptr) { @@ -72,7 +63,7 @@ export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): export class UnsupportedNode extends AstNode { constructor(peer: KPtr) { super(peer) - console.log(`WARNING: UNSUPPORTED NODE (arkts): ${Es2pandaAstNodeType[this.type]}`) + console.warn(`Warning: unsupported node ${Es2pandaAstNodeType[nodeType(this)]}`) } } @@ -255,10 +246,6 @@ export class ETSPrimitiveType extends AstNode { ) } - protected override dumpMessage(): string { - return ` ` - } - readonly primitiveType: Es2pandaPrimitiveType } @@ -607,7 +594,7 @@ export class ScriptFunction extends AstNode { // TODO: goes through whole subtree, optimizable (unnecessary now) this.body.getSubtree().forEach( (node: AstNode) => { - hasReturn = hasReturn || (node.type === Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT) + hasReturn = hasReturn || nodeType(node) === Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT } ) return hasReturn @@ -1192,7 +1179,9 @@ export class ImportSource extends ArktsObject { global.es2panda._CreateImportSource( global.context, source.peer, - resolveSource(source).peer, + StringLiteral.create( + path.resolve(source.str).toString() + ).peer, hasDecl ) ) diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts index c6ec7acdc..348af93bb 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts @@ -17,13 +17,11 @@ import { global } from "../static/global" import { throwError } from "../../utils" import { KInt, KNativePointer, nullptr, withString, withStringArray, withStringResult } from "@koalaui/interop" import { NativePtrDecoder } from "./nativePtrDecoder" -import * as path from "node:path" -import { allFlags, StringLiteral } from "../types" -import { Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums" -import { factory } from "../factory/nodeFactory" +import { Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums" import { classByPeer } from "../class-by-peer" import { AstNode } from "../peers/AstNode" import { ArktsObject } from "../peers/ArktsObject" +import { Es2pandaAstNodeType } from "../../Es2pandaEnums" export function unpackNonNullableNode(peer: KNativePointer): T { if (peer === nullptr) { @@ -130,8 +128,16 @@ export function updateNodeByNode(node: T, original: AstNode): return node } -export function resolveSource(source: StringLiteral): StringLiteral { - return factory.createStringLiteral( - path.resolve(source.str).toString() - ) +export function nodeType(node: AstNode): Es2pandaAstNodeType { + return global.generatedEs2panda._AstNodeTypeConst(global.context, passNode(node)) } + +export const arrayOfNullptr = new BigUint64Array([nullptr]) + +export const allFlags: KInt = + Object.values(Es2pandaModifierFlags).filter( + (value: any) => { return (typeof value) === 'number' } + ).reduce( + (prev: KInt, next: KInt): KInt => (prev | next), + 0 as KInt + ) \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts index 7231cc0f5..97b89a6fb 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts @@ -15,12 +15,12 @@ import { global } from "../static/global" import { throwError } from "../../utils" -import { KNativePointer, nullptr, withStringResult } from "@koalaui/interop" +import { nullptr, withStringResult } from "@koalaui/interop" +import { AnnotationUsageIr } from "../types" import { passNode, unpackNodeArray, unpackNonNullableNode } from "./private" import { isClassDefinition, isFunctionDeclaration, isScriptFunction } from "../factory/nodeTests" import { Es2pandaContextState } from "../../generated/Es2pandaEnums" import { AstNode } from "../peers/AstNode" -import { AnnotationUsageIr } from "../types" export function proceedToState(state: Es2pandaContextState): void { if (state <= global.es2panda._ContextState(global.context)) { diff --git a/arkoala-arkts/libarkts/src/utils.ts b/arkoala-arkts/libarkts/src/utils.ts index c30d3b0f5..15cc29473 100644 --- a/arkoala-arkts/libarkts/src/utils.ts +++ b/arkoala-arkts/libarkts/src/utils.ts @@ -26,10 +26,11 @@ export function isNumber(value: any): value is number { return typeof value === `number` } -// TODO: the lowerings insert %% and other special symbols -// into names of temporary variables. -// Until we keep feeding ast dumps back to the parser -// this function is needed. +/* + TODO: + The lowerings insert %% and other special symbols into names of temporary variables. + Until we keep feeding ast dumps back to the parser this function is needed. + */ export function filterSource(text: string): string { return text .replaceAll(/%/g, "_") -- Gitee From c7207cd081923c8a3527c82d39e55310b42cc1ff Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Tue, 18 Feb 2025 16:44:32 +0300 Subject: [PATCH 10/20] fix cyclic Signed-off-by: naumovdmitrii --- arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts index 348af93bb..4c8868a40 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts @@ -19,7 +19,7 @@ import { KInt, KNativePointer, nullptr, withString, withStringArray, withStringR import { NativePtrDecoder } from "./nativePtrDecoder" import { Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums" import { classByPeer } from "../class-by-peer" -import { AstNode } from "../peers/AstNode" +import type { AstNode } from "../peers/AstNode" import { ArktsObject } from "../peers/ArktsObject" import { Es2pandaAstNodeType } from "../../Es2pandaEnums" -- Gitee From e2469e864357f14e1db8fdf0a94ac59fd5cf5161 Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Tue, 18 Feb 2025 16:49:21 +0300 Subject: [PATCH 11/20] wip: fails cyclic, added AnnotationUsage Signed-off-by: naumovdmitrii --- .../plugins/src/builder-lambda-transformer.ts | 43 +++++++++---------- .../libarkts/src/arkts-api/class-by-peer.ts | 4 +- .../src/arkts-api/factory/nodeTests.ts | 4 ++ arkoala-arkts/libarkts/src/arkts-api/index.ts | 1 + arkoala-arkts/libarkts/src/arkts-api/types.ts | 26 +++++------ .../src/arkts-api/utilities/private.ts | 20 ++++----- .../src/arkts-api/utilities/public.ts | 4 +- 7 files changed, 53 insertions(+), 49 deletions(-) diff --git a/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts b/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts index e65728dba..0da11a7ea 100644 --- a/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts +++ b/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts @@ -66,22 +66,22 @@ function getLambdaArg(lambdaBody: arkts.AstNode, typeName: string|undefined): ar ) } -function isBuilderLambdaAnnotation(annotation: arkts.AnnotationUsageIr): boolean { +function isBuilderLambdaAnnotation(annotation: arkts.AnnotationUsage): boolean { if (!arkts.isIdentifier(annotation.expr)) { return false } return annotation.expr.name !== "BuilderLambda" } -function builderLambdaArgumentName(annotation: arkts.AnnotationUsageIr): string | undefined { +function builderLambdaArgumentName(annotation: arkts.AnnotationUsage): string | undefined { if (!isBuilderLambdaAnnotation(annotation)) return undefined + const property = annotation.properties[0] + if (property === undefined) return undefined + if (!arkts.isClassProperty(property)) return undefined + if (property.value === undefined) return undefined + if (!arkts.isStringLiteral(property.value)) return undefined - if (!annotation.properties[0].value || - !arkts.isStringLiteral(annotation.properties[0].value) - ) { - return undefined - } - return annotation.properties[0].value.str + return property.value.str } /* function builderLambdaTypeName(annotation: arkts.AnnotationUsageIr): string | undefined { @@ -95,8 +95,7 @@ function builderLambdaTypeName(annotation: arkts.AnnotationUsageIr): string | un return annotation.properties[1].value.str } */ -function findBuilderLambdaAnnotation(node: arkts.CallExpression): arkts.AnnotationUsageIr|undefined { - +function findBuilderLambdaAnnotation(node: arkts.CallExpression): arkts.AnnotationUsage | undefined { let decl: arkts.AstNode|undefined = undefined if (arkts.isIdentifier(node.expression)) { decl = arkts.getDecl(node.expression) @@ -172,20 +171,20 @@ function builderLambdaReplace(leaf: arkts.CallExpression): arkts.Identifier|arkt } if (arkts.isIdentifier(node)) { - return arkts.factory.createIdentifier( - funcName - ) + return arkts.factory.createIdentifier( + funcName + ) } if (arkts.isMemberExpression(node)) { - return arkts.factory.createMemberExpression( - node.object, - arkts.factory.createIdentifier( - funcName - ), - arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, - false, - false - ) + return arkts.factory.createMemberExpression( + node.object, + arkts.factory.createIdentifier( + funcName + ), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ) } return undefined } diff --git a/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts b/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts index 212f6a30c..8dbd1110f 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts @@ -14,7 +14,6 @@ */ import { - AnnotationUsageIr, ArrowFunctionExpression, AssignmentExpression, BinaryExpression, @@ -60,6 +59,7 @@ import { global } from "./static/global" import { KNativePointer, nullptr } from "@koalaui/interop" import { AstNode } from "./peers/AstNode" import { nodes as generatedNodes } from "../generated/node-map" +import { AnnotationUsage } from "../generated" export function classByPeer(peer: KNativePointer): AstNode { const nodes = new Map([ @@ -100,7 +100,7 @@ export function classByPeer(peer: KNativePointer): AstNode { [Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, SuperExpression], [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, EtsImportDeclaration], [Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, ImportSpecifier], - [Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, AnnotationUsageIr], + [Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, AnnotationUsage], ]) if (peer === nullptr) { diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts index 70089c669..5079f1668 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts @@ -107,3 +107,7 @@ export function isStringLiteral(node: AstNode): node is StringLiteral { export function isClassDefinition(node: AstNode): node is ClassDefinition { return node instanceof ClassDefinition } + +export function isClassProperty(node: AstNode): node is ClassProperty { + return node instanceof ClassProperty +} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/index.ts b/arkoala-arkts/libarkts/src/arkts-api/index.ts index 8e444fc04..1b08693df 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/index.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/index.ts @@ -15,6 +15,7 @@ export * from "../Es2pandaEnums" export * from "../generated/Es2pandaEnums" +export * from "../generated/peers/AnnotationUsage" export * from "./types" export * from "./utilities/private" diff --git a/arkoala-arkts/libarkts/src/arkts-api/types.ts b/arkoala-arkts/libarkts/src/arkts-api/types.ts index 37bf647dd..2490bd748 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/types.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/types.ts @@ -391,7 +391,7 @@ export class Identifier extends AstNode { if (isAnnotation) { return new Identifier( global.es2panda._ETSParserCreateExpression( - global.context, + global.context, passString(name), Es2pandaExpressionParseFlags.EXPRESSION_PARSE_FLAGS_ACCEPT_COMMA ) @@ -613,16 +613,16 @@ export class ScriptFunction extends AstNode { get annotations(): AnnotationUsageIr[] { return unpackNodeArray(global.es2panda._ScriptFunctionAnnotations( - global.context, - this.peer, + global.context, + this.peer, nullptr )) as AnnotationUsageIr[]; } set annotations(newAnnotations: AnnotationUsageIr[]) { global.es2panda._ScriptFunctionSetAnnotations( - global.context, - this.peer, + global.context, + this.peer, passNodeArray(newAnnotations), newAnnotations.length ); @@ -755,16 +755,16 @@ export class ETSParameterExpression extends AstNode { get annotations(): AnnotationUsageIr[] { return unpackNodeArray(global.es2panda._ETSParameterExpressionAnnotations( - global.context, - this.peer, + global.context, + this.peer, nullptr )) as AnnotationUsageIr[]; } set annotations(newAnnotations: AnnotationUsageIr[]) { global.es2panda._ETSParameterExpressionSetAnnotations( - global.context, - this.peer, + global.context, + this.peer, passNodeArray(newAnnotations), newAnnotations.length ); @@ -1068,16 +1068,16 @@ export class ClassProperty extends ClassElement { get annotations(): AnnotationUsageIr[] { return unpackNodeArray(global.es2panda._ScriptFunctionAnnotations( - global.context, - this.peer, + global.context, + this.peer, nullptr )) as AnnotationUsageIr[]; } set annotations(newAnnotations: AnnotationUsageIr[]) { global.es2panda._ScriptFunctionSetAnnotations( - global.context, - this.peer, + global.context, + this.peer, passNodeArray(newAnnotations), newAnnotations.length ); diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts index 4c8868a40..60d76e7c5 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts @@ -23,6 +23,16 @@ import type { AstNode } from "../peers/AstNode" import { ArktsObject } from "../peers/ArktsObject" import { Es2pandaAstNodeType } from "../../Es2pandaEnums" +export const arrayOfNullptr = new BigUint64Array([nullptr]) + +export const allFlags: KInt = + Object.values(Es2pandaModifierFlags).filter( + (value: any) => { return typeof value === 'number' } + ).reduce( + (prev: KInt, next: KInt): KInt => (prev | next), + 0 as KInt + ) + export function unpackNonNullableNode(peer: KNativePointer): T { if (peer === nullptr) { throwError('peer is NULLPTR (maybe you should use unpackNode)') @@ -131,13 +141,3 @@ export function updateNodeByNode(node: T, original: AstNode): export function nodeType(node: AstNode): Es2pandaAstNodeType { return global.generatedEs2panda._AstNodeTypeConst(global.context, passNode(node)) } - -export const arrayOfNullptr = new BigUint64Array([nullptr]) - -export const allFlags: KInt = - Object.values(Es2pandaModifierFlags).filter( - (value: any) => { return (typeof value) === 'number' } - ).reduce( - (prev: KInt, next: KInt): KInt => (prev | next), - 0 as KInt - ) \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts index 97b89a6fb..93b672792 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts @@ -16,11 +16,11 @@ import { global } from "../static/global" import { throwError } from "../../utils" import { nullptr, withStringResult } from "@koalaui/interop" -import { AnnotationUsageIr } from "../types" import { passNode, unpackNodeArray, unpackNonNullableNode } from "./private" import { isClassDefinition, isFunctionDeclaration, isScriptFunction } from "../factory/nodeTests" import { Es2pandaContextState } from "../../generated/Es2pandaEnums" import { AstNode } from "../peers/AstNode" +import { AnnotationUsage } from "../../generated" export function proceedToState(state: Es2pandaContextState): void { if (state <= global.es2panda._ContextState(global.context)) { @@ -61,7 +61,7 @@ export function getDecl(node: AstNode): AstNode | undefined { return unpackNonNullableNode(decl) } -export function getAnnotations(node: AstNode): readonly AnnotationUsageIr[] { +export function getAnnotations(node: AstNode): readonly AnnotationUsage[] { if (!isFunctionDeclaration(node) && !isScriptFunction(node) && !isClassDefinition(node)) { throwError('for now annotations allowed only for: functionDeclaration, scriptFunction, classDefinition') } -- Gitee From 8353f694c288a18eeab452fd8b15c7af4da28726 Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Tue, 18 Feb 2025 17:51:59 +0300 Subject: [PATCH 12/20] some rearranges, some renamings Signed-off-by: naumovdmitrii --- .../plugins/src/builder-lambda-transformer.ts | 3 ++ .../libarkts/src/arkts-api/class-by-peer.ts | 6 +-- .../src/arkts-api/factory/nodeTests.ts | 2 +- .../libarkts/src/arkts-api/peers/AstNode.ts | 12 +++--- .../to-be-generated/MemberExpression.ts | 3 +- arkoala-arkts/libarkts/src/arkts-api/types.ts | 12 +----- .../src/arkts-api/utilities/private.ts | 37 ++++++++++++++----- .../src/arkts-api/utilities/public.ts | 14 +++++-- .../libarkts/src/reexport-for-generated.ts | 6 +-- 9 files changed, 55 insertions(+), 40 deletions(-) diff --git a/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts b/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts index 0da11a7ea..ab1fc833e 100644 --- a/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts +++ b/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts @@ -67,6 +67,9 @@ function getLambdaArg(lambdaBody: arkts.AstNode, typeName: string|undefined): ar } function isBuilderLambdaAnnotation(annotation: arkts.AnnotationUsage): boolean { + if (annotation.expr === undefined) { + return false + } if (!arkts.isIdentifier(annotation.expr)) { return false } diff --git a/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts b/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts index 8dbd1110f..fdbe6afdf 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts @@ -57,11 +57,10 @@ import { MemberExpression } from "./to-be-generated/MemberExpression" import { throwError } from "../utils" import { global } from "./static/global" import { KNativePointer, nullptr } from "@koalaui/interop" -import { AstNode } from "./peers/AstNode" +import type { AstNode } from "./peers/AstNode" import { nodes as generatedNodes } from "../generated/node-map" -import { AnnotationUsage } from "../generated" -export function classByPeer(peer: KNativePointer): AstNode { +export function classByPeer(peer: KNativePointer): T | UnsupportedNode { const nodes = new Map([ [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, EtsScript], [Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, Identifier], @@ -100,7 +99,6 @@ export function classByPeer(peer: KNativePointer): AstNode { [Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, SuperExpression], [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, EtsImportDeclaration], [Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, ImportSpecifier], - [Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, AnnotationUsage], ]) if (peer === nullptr) { diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts index 5079f1668..898fb4e73 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts @@ -22,7 +22,7 @@ import { ClassProperty } from "../types" import { MemberExpression } from "../to-be-generated/MemberExpression" -import { AstNode } from "../peers/AstNode" +import type { AstNode } from "../peers/AstNode" export function isClassProperty(node: AstNode): node is ClassProperty { return global.es2panda._IsClassProperty(node.peer); diff --git a/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts b/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts index 5b0ae55cf..d615edcca 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts @@ -23,7 +23,7 @@ import { ArktsObject } from "./ArktsObject" export abstract class AstNode extends ArktsObject { protected constructor(peer: KNativePointer) { if (isNullPtr(peer)) { - throwError('trying to create new Node on NULLPTR') + throwError(`attempted to create AstNode from nullptr`) } super(peer) this.updateChildren() @@ -43,7 +43,7 @@ export abstract class AstNode extends ArktsObject { public getSubtree(): readonly AstNode[] { return this.getChildren().reduce( - (prev: readonly AstNode[], curr: AstNode): readonly AstNode[] => { + (prev: readonly AstNode[], curr) => { return prev.concat(curr.getSubtree()) }, [this] @@ -90,11 +90,11 @@ export abstract class AstNode extends ArktsObject { } public get parent(): AstNode { - const _parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer) - if (_parent === nullptr) { - throwError('BAD ACCESS: PARENT IS NULLPTR') + const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer) + if (parent === nullptr) { + throwError(`no parent`) } - return unpackNonNullableNode(_parent) + return unpackNonNullableNode(parent) } public set parent(node: AstNode) { diff --git a/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts b/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts index f760db27a..0ee0ac83a 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts @@ -14,9 +14,8 @@ */ import { global } from "../static/global" -import { assertValidPeer } from "../types" import { Es2pandaMemberExpressionKind } from "../../generated/Es2pandaEnums" -import { passNode, unpackNonNullableNode } from "../utilities/private" +import { assertValidPeer, passNode, unpackNonNullableNode } from "../utilities/private" import { KNativePointer } from "@koalaui/interop" import { Es2pandaAstNodeType } from "../../Es2pandaEnums" import { AstNode } from "../peers/AstNode" diff --git a/arkoala-arkts/libarkts/src/arkts-api/types.ts b/arkoala-arkts/libarkts/src/arkts-api/types.ts index 2490bd748..d02656427 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/types.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/types.ts @@ -14,7 +14,6 @@ */ import { global } from "./static/global" -import { throwError } from "../utils" import { KBoolean, KInt, KNativePointer as KPtr, nullptr } from "@koalaui/interop" import { Es2pandaContextState, @@ -32,6 +31,7 @@ import { import { allFlags, arrayOfNullptr, + assertValidPeer, nodeType, passNode, passNodeArray, @@ -50,16 +50,6 @@ import { Config } from "./peers/Config" import { Context } from "./peers/Context" import * as path from "node:path" -export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): void { - if (peer === nullptr) { - throwError(`invalid peer: NULLPTR`) - } - const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer) - if (peerType !== expectedKind) { - throwError(`actual type of peer: ${peerType} expected: ${expectedKind}`) - } -} - export class UnsupportedNode extends AstNode { constructor(peer: KPtr) { super(peer) diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts index 60d76e7c5..9f5d10457 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/private.ts @@ -14,8 +14,16 @@ */ import { global } from "../static/global" -import { throwError } from "../../utils" -import { KInt, KNativePointer, nullptr, withString, withStringArray, withStringResult } from "@koalaui/interop" +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" @@ -25,13 +33,24 @@ import { Es2pandaAstNodeType } from "../../Es2pandaEnums" export const arrayOfNullptr = new BigUint64Array([nullptr]) -export const allFlags: KInt = - Object.values(Es2pandaModifierFlags).filter( - (value: any) => { return typeof value === 'number' } - ).reduce( - (prev: KInt, next: KInt): KInt => (prev | next), - 0 as KInt - ) +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 !== expectedKind) { + throwError(`expected: ${Es2pandaAstNodeType[expectedKind]}, got: ${Es2pandaAstNodeType[peerType]}`) + } +} export function unpackNonNullableNode(peer: KNativePointer): T { if (peer === nullptr) { diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts index 93b672792..de723054e 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts @@ -19,8 +19,8 @@ import { nullptr, withStringResult } from "@koalaui/interop" import { passNode, unpackNodeArray, unpackNonNullableNode } from "./private" import { isClassDefinition, isFunctionDeclaration, isScriptFunction } from "../factory/nodeTests" import { Es2pandaContextState } from "../../generated/Es2pandaEnums" -import { AstNode } from "../peers/AstNode" -import { AnnotationUsage } from "../../generated" +import type { AstNode } from "../peers/AstNode" +import type { AnnotationUsage } from "../../generated" export function proceedToState(state: Es2pandaContextState): void { if (state <= global.es2panda._ContextState(global.context)) { @@ -31,9 +31,15 @@ export function proceedToState(state: Es2pandaContextState): void { if (global.es2panda._ContextState(global.context) === Es2pandaContextState.ES2PANDA_STATE_ERROR) { const errorMessage = withStringResult(global.es2panda._ContextErrorMessage(global.context)) if (errorMessage === undefined) { - throwError(`COULDN'T GET ContextErrorMessage`) + throwError(`Could not get ContextErrorMessage`) } - throwError("FAILED PROCEED TO: " + Es2pandaContextState[state] + "\n" + errorMessage) + throwError( + [ + `Failed to proceed to ${Es2pandaContextState[state]}`, + errorMessage + ] + .join(`\n`) + ) } } catch (e) { global.es2panda._DestroyContext(global.context) diff --git a/arkoala-arkts/libarkts/src/reexport-for-generated.ts b/arkoala-arkts/libarkts/src/reexport-for-generated.ts index 4fc36e327..c318a164b 100644 --- a/arkoala-arkts/libarkts/src/reexport-for-generated.ts +++ b/arkoala-arkts/libarkts/src/reexport-for-generated.ts @@ -14,8 +14,8 @@ */ export { KNativePointer } from "@koalaui/interop" +export { AstNode } from "./arkts-api/peers/AstNode" export { Es2pandaAstNodeType } from "./Es2pandaEnums" -export { assertValidPeer } from "./arkts-api//types" export { passNode, unpackNonNullableNode, @@ -24,8 +24,8 @@ export { unpackNode, unpackNonNullableObject, unpackString, - unpackObject + unpackObject, + assertValidPeer } from "./arkts-api/utilities/private" export { global } from "./arkts-api/static/global" export { Es2pandaMemberExpressionKind } from "./generated/Es2pandaEnums" -export { AstNode } from "./arkts-api/peers/AstNode" -- Gitee From 460db781fbdb34a7701e2df2da0b35744fdd82ce Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Tue, 18 Feb 2025 18:33:20 +0300 Subject: [PATCH 13/20] fix imports Signed-off-by: naumovdmitrii --- .../to-be-generated/MemberExpression.ts | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts b/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts index 0ee0ac83a..ac8213680 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/to-be-generated/MemberExpression.ts @@ -13,12 +13,17 @@ * limitations under the License. */ -import { global } from "../static/global" -import { Es2pandaMemberExpressionKind } from "../../generated/Es2pandaEnums" -import { assertValidPeer, passNode, unpackNonNullableNode } from "../utilities/private" -import { KNativePointer } from "@koalaui/interop" -import { Es2pandaAstNodeType } from "../../Es2pandaEnums" -import { AstNode } from "../peers/AstNode" + +import { + assertValidPeer, + AstNode, + Es2pandaAstNodeType, + Es2pandaMemberExpressionKind, + KNativePointer, + passNode, + unpackNonNullableNode, + global +} from "../../reexport-for-generated" export class MemberExpression extends AstNode { constructor(peer: KNativePointer) { -- Gitee From a4dcbe1556df3b8a97c16812140b9a8f13f477ec Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Wed, 19 Feb 2025 11:52:10 +0300 Subject: [PATCH 14/20] fix cyclic Signed-off-by: naumovdmitrii --- .../libarkts/src/arkts-api/class-by-peer.ts | 90 +------------------ arkoala-arkts/libarkts/src/arkts-api/index.ts | 3 +- arkoala-arkts/libarkts/src/arkts-api/types.ts | 46 +++++++++- .../src/generated/peers/AnnotatedAstNode.ts | 3 +- .../generated/peers/AnnotatedExpression.ts | 3 +- .../src/generated/peers/AnnotatedStatement.ts | 3 +- .../generated/peers/AnnotationDeclaration.ts | 6 +- .../src/generated/peers/AnnotationUsage.ts | 6 +- .../src/generated/peers/ArrayExpression.ts | 3 +- .../peers/ArrowFunctionExpression.ts | 6 +- .../src/generated/peers/AssertStatement.ts | 6 +- .../generated/peers/AssignmentExpression.ts | 3 +- .../src/generated/peers/AwaitExpression.ts | 6 +- .../src/generated/peers/BigIntLiteral.ts | 6 +- .../src/generated/peers/BinaryExpression.ts | 6 +- .../src/generated/peers/BlockExpression.ts | 6 +- .../src/generated/peers/BlockStatement.ts | 6 +- .../src/generated/peers/BooleanLiteral.ts | 6 +- .../src/generated/peers/BreakStatement.ts | 6 +- .../src/generated/peers/CallExpression.ts | 6 +- .../src/generated/peers/CatchClause.ts | 6 +- .../src/generated/peers/ChainExpression.ts | 6 +- .../src/generated/peers/CharLiteral.ts | 6 +- .../src/generated/peers/ClassDeclaration.ts | 6 +- .../src/generated/peers/ClassDefinition.ts | 6 +- .../src/generated/peers/ClassElement.ts | 3 +- .../src/generated/peers/ClassExpression.ts | 6 +- .../src/generated/peers/ClassProperty.ts | 6 +- .../src/generated/peers/ClassStaticBlock.ts | 6 +- .../generated/peers/ConditionalExpression.ts | 6 +- .../src/generated/peers/ContinueStatement.ts | 6 +- .../src/generated/peers/DebuggerStatement.ts | 6 +- .../libarkts/src/generated/peers/Decorator.ts | 6 +- .../generated/peers/DirectEvalExpression.ts | 6 +- .../src/generated/peers/DoWhileStatement.ts | 6 +- .../src/generated/peers/ETSClassLiteral.ts | 6 +- .../generated/peers/ETSDynamicFunctionType.ts | 3 +- .../src/generated/peers/ETSFunctionType.ts | 6 +- .../generated/peers/ETSImportDeclaration.ts | 6 +- .../generated/peers/ETSLaunchExpression.ts | 6 +- .../libarkts/src/generated/peers/ETSModule.ts | 6 +- .../peers/ETSNewArrayInstanceExpression.ts | 6 +- .../peers/ETSNewClassInstanceExpression.ts | 6 +- .../ETSNewMultiDimArrayInstanceExpression.ts | 6 +- .../src/generated/peers/ETSNullType.ts | 6 +- .../generated/peers/ETSPackageDeclaration.ts | 6 +- .../generated/peers/ETSParameterExpression.ts | 6 +- .../src/generated/peers/ETSPrimitiveType.ts | 6 +- .../generated/peers/ETSReExportDeclaration.ts | 6 +- .../generated/peers/ETSStructDeclaration.ts | 6 +- .../libarkts/src/generated/peers/ETSTuple.ts | 6 +- .../src/generated/peers/ETSTypeReference.ts | 6 +- .../generated/peers/ETSTypeReferencePart.ts | 6 +- .../src/generated/peers/ETSUndefinedType.ts | 6 +- .../src/generated/peers/ETSUnionType.ts | 6 +- .../src/generated/peers/ETSWildcardType.ts | 6 +- .../src/generated/peers/EmptyStatement.ts | 6 +- .../generated/peers/ExportAllDeclaration.ts | 6 +- .../peers/ExportDefaultDeclaration.ts | 6 +- .../generated/peers/ExportNamedDeclaration.ts | 6 +- .../src/generated/peers/ExportSpecifier.ts | 6 +- .../src/generated/peers/Expression.ts | 3 +- .../generated/peers/ExpressionStatement.ts | 6 +- .../src/generated/peers/ForInStatement.ts | 6 +- .../src/generated/peers/ForOfStatement.ts | 6 +- .../src/generated/peers/ForUpdateStatement.ts | 6 +- .../src/generated/peers/FunctionDecl.ts | 3 +- .../generated/peers/FunctionDeclaration.ts | 6 +- .../src/generated/peers/FunctionExpression.ts | 6 +- .../src/generated/peers/Identifier.ts | 6 +- .../src/generated/peers/IfStatement.ts | 6 +- .../src/generated/peers/ImportDeclaration.ts | 6 +- .../generated/peers/ImportDefaultSpecifier.ts | 6 +- .../src/generated/peers/ImportExpression.ts | 6 +- .../peers/ImportNamespaceSpecifier.ts | 6 +- .../src/generated/peers/ImportSpecifier.ts | 6 +- .../src/generated/peers/InterfaceDecl.ts | 3 +- .../src/generated/peers/LabelledStatement.ts | 6 +- .../libarkts/src/generated/peers/Literal.ts | 3 +- .../src/generated/peers/LoopStatement.ts | 3 +- .../peers/MaybeOptionalExpression.ts | 3 +- .../src/generated/peers/MemberExpression.ts | 6 +- .../src/generated/peers/MetaProperty.ts | 6 +- .../src/generated/peers/MethodDefinition.ts | 6 +- .../libarkts/src/generated/peers/NamedType.ts | 6 +- .../src/generated/peers/NewExpression.ts | 6 +- .../src/generated/peers/NullLiteral.ts | 6 +- .../src/generated/peers/NumberLiteral.ts | 6 +- .../src/generated/peers/ObjectExpression.ts | 3 +- .../src/generated/peers/OmittedExpression.ts | 6 +- .../src/generated/peers/OpaqueTypeNode.ts | 6 +- .../peers/PrefixAssertionExpression.ts | 6 +- .../libarkts/src/generated/peers/Property.ts | 6 +- .../src/generated/peers/RegExpLiteral.ts | 6 +- .../src/generated/peers/ReturnStatement.ts | 6 +- .../src/generated/peers/ScriptFunction.ts | 6 +- .../src/generated/peers/SequenceExpression.ts | 6 +- .../src/generated/peers/SpreadElement.ts | 3 +- .../libarkts/src/generated/peers/Statement.ts | 3 +- .../src/generated/peers/StringLiteral.ts | 6 +- .../src/generated/peers/SuperExpression.ts | 6 +- .../generated/peers/SwitchCaseStatement.ts | 6 +- .../src/generated/peers/SwitchStatement.ts | 6 +- .../src/generated/peers/TSAnyKeyword.ts | 6 +- .../src/generated/peers/TSArrayType.ts | 6 +- .../src/generated/peers/TSAsExpression.ts | 6 +- .../src/generated/peers/TSBigintKeyword.ts | 6 +- .../src/generated/peers/TSBooleanKeyword.ts | 6 +- .../src/generated/peers/TSClassImplements.ts | 6 +- .../src/generated/peers/TSConditionalType.ts | 6 +- .../src/generated/peers/TSConstructorType.ts | 6 +- .../src/generated/peers/TSEnumDeclaration.ts | 6 +- .../src/generated/peers/TSEnumMember.ts | 6 +- .../peers/TSExternalModuleReference.ts | 6 +- .../src/generated/peers/TSFunctionType.ts | 6 +- .../peers/TSImportEqualsDeclaration.ts | 6 +- .../src/generated/peers/TSImportType.ts | 6 +- .../src/generated/peers/TSIndexSignature.ts | 6 +- .../generated/peers/TSIndexedAccessType.ts | 6 +- .../src/generated/peers/TSInferType.ts | 6 +- .../src/generated/peers/TSInterfaceBody.ts | 6 +- .../generated/peers/TSInterfaceDeclaration.ts | 6 +- .../generated/peers/TSInterfaceHeritage.ts | 6 +- .../src/generated/peers/TSIntersectionType.ts | 6 +- .../src/generated/peers/TSLiteralType.ts | 6 +- .../src/generated/peers/TSMappedType.ts | 6 +- .../src/generated/peers/TSMethodSignature.ts | 6 +- .../src/generated/peers/TSModuleBlock.ts | 6 +- .../generated/peers/TSModuleDeclaration.ts | 6 +- .../src/generated/peers/TSNamedTupleMember.ts | 6 +- .../src/generated/peers/TSNeverKeyword.ts | 6 +- .../generated/peers/TSNonNullExpression.ts | 6 +- .../src/generated/peers/TSNullKeyword.ts | 6 +- .../src/generated/peers/TSNumberKeyword.ts | 6 +- .../src/generated/peers/TSObjectKeyword.ts | 6 +- .../generated/peers/TSParameterProperty.ts | 6 +- .../generated/peers/TSParenthesizedType.ts | 6 +- .../generated/peers/TSPropertySignature.ts | 6 +- .../src/generated/peers/TSQualifiedName.ts | 6 +- .../generated/peers/TSSignatureDeclaration.ts | 6 +- .../src/generated/peers/TSStringKeyword.ts | 6 +- .../src/generated/peers/TSThisType.ts | 6 +- .../src/generated/peers/TSTupleType.ts | 6 +- .../generated/peers/TSTypeAliasDeclaration.ts | 6 +- .../src/generated/peers/TSTypeAssertion.ts | 6 +- .../src/generated/peers/TSTypeLiteral.ts | 6 +- .../src/generated/peers/TSTypeOperator.ts | 6 +- .../src/generated/peers/TSTypeParameter.ts | 6 +- .../peers/TSTypeParameterDeclaration.ts | 6 +- .../peers/TSTypeParameterInstantiation.ts | 6 +- .../src/generated/peers/TSTypePredicate.ts | 6 +- .../src/generated/peers/TSTypeQuery.ts | 6 +- .../src/generated/peers/TSTypeReference.ts | 6 +- .../src/generated/peers/TSUndefinedKeyword.ts | 6 +- .../src/generated/peers/TSUnionType.ts | 6 +- .../src/generated/peers/TSUnknownKeyword.ts | 6 +- .../src/generated/peers/TSVoidKeyword.ts | 6 +- .../peers/TaggedTemplateExpression.ts | 6 +- .../src/generated/peers/TemplateElement.ts | 6 +- .../src/generated/peers/TemplateLiteral.ts | 6 +- .../src/generated/peers/ThisExpression.ts | 6 +- .../src/generated/peers/ThrowStatement.ts | 6 +- .../src/generated/peers/TryStatement.ts | 6 +- .../libarkts/src/generated/peers/TypeNode.ts | 3 +- .../src/generated/peers/TypedAstNode.ts | 3 +- .../src/generated/peers/TypedStatement.ts | 3 +- .../src/generated/peers/TypeofExpression.ts | 6 +- .../src/generated/peers/UnaryExpression.ts | 6 +- .../src/generated/peers/UndefinedLiteral.ts | 6 +- .../src/generated/peers/UpdateExpression.ts | 6 +- .../generated/peers/VariableDeclaration.ts | 6 +- .../src/generated/peers/VariableDeclarator.ts | 6 +- .../src/generated/peers/WhileStatement.ts | 6 +- .../src/generated/peers/YieldExpression.ts | 6 +- .../libarkts/src/reexport-for-generated.ts | 2 +- 175 files changed, 849 insertions(+), 261 deletions(-) diff --git a/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts b/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts index fdbe6afdf..6d3f50799 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts @@ -13,101 +13,19 @@ * limitations under the License. */ -import { - ArrowFunctionExpression, - AssignmentExpression, - BinaryExpression, - BlockStatement, - CallExpression, - ClassDeclaration, - ClassDefinition, - ClassProperty, - ClassStaticBlock, - ETSFunctionType, - EtsImportDeclaration, - ETSParameterExpression, - ETSPrimitiveType, - EtsScript, - ETSTypeReference, - ETSTypeReferencePart, - ETSUndefinedType, - ETSUnionType, - ExpressionStatement, - FunctionDeclaration, - FunctionExpression, - Identifier, - IfStatement, - ImportSpecifier, - MethodDefinition, - NumberLiteral, - ReturnStatement, - ScriptFunction, - StringLiteral, - StructDeclaration, - SuperExpression, - TSTypeParameter, - TSTypeParameterDeclaration, - UndefinedLiteral, - UnsupportedNode, - VariableDeclaration, - VariableDeclarator -} from "./types" import { Es2pandaAstNodeType } from "../Es2pandaEnums" -import { MemberExpression } from "./to-be-generated/MemberExpression" import { throwError } from "../utils" import { global } from "./static/global" import { KNativePointer, nullptr } from "@koalaui/interop" import type { AstNode } from "./peers/AstNode" -import { nodes as generatedNodes } from "../generated/node-map" -export function classByPeer(peer: KNativePointer): T | UnsupportedNode { - const nodes = new Map([ - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, EtsScript], - [Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, Identifier], - [Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, StringLiteral], - [Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, NumberLiteral], - [Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, ExpressionStatement], - [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, FunctionDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, ScriptFunction], - [Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, BlockStatement], - [Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, ReturnStatement], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, ETSParameterExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, ETSTypeReference], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART, ETSTypeReferencePart], - [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, TSTypeParameterDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, ETSPrimitiveType], - [Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, CallExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, MemberExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, TSTypeParameter], - [Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, IfStatement], - [Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, BinaryExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, ETSUnionType], - [Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, ArrowFunctionExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION, StructDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, ClassDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, ClassDefinition], - [Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, MethodDefinition], - [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, ClassProperty], - [Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, AssignmentExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, VariableDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, VariableDeclarator], - [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION, FunctionExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, ETSFunctionType], - [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, ClassStaticBlock], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, ETSUndefinedType], - [Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL, UndefinedLiteral], - [Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, SuperExpression], - [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, EtsImportDeclaration], - [Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, ImportSpecifier], - ]) +export const nodeByType = new Map([]) +export function classByPeer(peer: KNativePointer): T { if (peer === nullptr) { throwError('classByPeer: peer is NULLPTR') } const type = global.generatedEs2panda._AstNodeTypeConst(global.context, peer) - const node = nodes.get(type) ?? generatedNodes.get(type) - if (node === undefined) { - return new UnsupportedNode(peer) - } - return new node(peer) + const node = nodeByType.get(type) ?? throwError(Es2pandaAstNodeType[type]) + return new node(peer) as T } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/index.ts b/arkoala-arkts/libarkts/src/arkts-api/index.ts index 1b08693df..b6926ba0f 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/index.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/index.ts @@ -23,7 +23,8 @@ export * from "./utilities/public" export * from "./factory/nodeFactory" export * from "./factory/nodeTests" export * from "./visitor" -export * from "./peers/AstNode" +export type { AstNode } from "./peers/AstNode" +import "../generated" export * from "./peers/Config" export * from "./peers/Context" export * from "./to-be-generated/MemberExpression" diff --git a/arkoala-arkts/libarkts/src/arkts-api/types.ts b/arkoala-arkts/libarkts/src/arkts-api/types.ts index d02656427..964558698 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/types.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/types.ts @@ -12,9 +12,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - import { global } from "./static/global" -import { KBoolean, KInt, KNativePointer as KPtr, nullptr } from "@koalaui/interop" +import { KBoolean, KInt, KNativePointer, KNativePointer as KPtr, nullptr } from "@koalaui/interop" import { Es2pandaContextState, Es2pandaExpressionParseFlags, @@ -49,6 +48,8 @@ import { ArktsObject } from "./peers/ArktsObject" import { Config } from "./peers/Config" import { Context } from "./peers/Context" import * as path from "node:path" +import { nodeByType } from "./class-by-peer" +import { MemberExpression } from "./to-be-generated/MemberExpression" export class UnsupportedNode extends AstNode { constructor(peer: KPtr) { @@ -1337,3 +1338,44 @@ export class AnnotationDeclaration extends AstNode { ) } } + +const pairs: [Es2pandaAstNodeType, { new(peer: KNativePointer): AstNode }][] = [ + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, EtsScript], + [Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, Identifier], + [Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, StringLiteral], + [Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, NumberLiteral], + [Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, ExpressionStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, FunctionDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, ScriptFunction], + [Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, BlockStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, ReturnStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, ETSParameterExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, ETSTypeReference], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART, ETSTypeReferencePart], + [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, TSTypeParameterDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, ETSPrimitiveType], + [Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, CallExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, MemberExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, TSTypeParameter], + [Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, IfStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, BinaryExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, ETSUnionType], + [Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, ArrowFunctionExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION, StructDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, ClassDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, ClassDefinition], + [Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, MethodDefinition], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, ClassProperty], + [Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, AssignmentExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, VariableDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, VariableDeclarator], + [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION, FunctionExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, ETSFunctionType], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, ClassStaticBlock], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, ETSUndefinedType], + [Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL, UndefinedLiteral], + [Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, SuperExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, EtsImportDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, ImportSpecifier], +] +pairs.forEach(([tp, cctor]) => nodeByType.set(tp, cctor)) \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts index 07b9fbc43..36938c6cc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedAstNode.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" export abstract class AnnotatedAstNode extends AstNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts index e6bdfee72..63624f801 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts index 171ecd625..679236e02 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotatedStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts index aad6adc04..62469de01 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -67,4 +68,7 @@ export class AnnotationDeclaration extends Statement { } export function isAnnotationDeclaration(node: AstNode): node is AnnotationDeclaration { return node instanceof AnnotationDeclaration +} +if (!nodeByType.has(1)) { + nodeByType.set(1, AnnotationDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts index 326159dd1..a830f2ceb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -61,4 +62,7 @@ export class AnnotationUsage extends Statement { } export function isAnnotationUsage(node: AstNode): node is AnnotationUsage { return node instanceof AnnotationUsage +} +if (!nodeByType.has(2)) { + nodeByType.set(2, AnnotationUsage) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts index 56113fd26..fbdef9485 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ArrayExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedExpression } from "./AnnotatedExpression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts index 2e6d050e7..6a363283d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -62,4 +63,7 @@ export class ArrowFunctionExpression extends Expression { } export function isArrowFunctionExpression(node: AstNode): node is ArrowFunctionExpression { return node instanceof ArrowFunctionExpression +} +if (!nodeByType.has(0)) { + nodeByType.set(0, ArrowFunctionExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts index b21e36baf..aa11ed383 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -52,4 +53,7 @@ export class AssertStatement extends Statement { } export function isAssertStatement(node: AstNode): node is AssertStatement { return node instanceof AssertStatement +} +if (!nodeByType.has(3)) { + nodeByType.set(3, AssertStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts index 84f10656d..75085e0f2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AssignmentExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts index e1981e7dc..372d6e09c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -45,4 +46,7 @@ export class AwaitExpression extends Expression { } export function isAwaitExpression(node: AstNode): node is AwaitExpression { return node instanceof AwaitExpression +} +if (!nodeByType.has(4)) { + nodeByType.set(4, AwaitExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts index 1d6b844be..1e3cda0d3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -45,4 +46,7 @@ export class BigIntLiteral extends Literal { } export function isBigIntLiteral(node: AstNode): node is BigIntLiteral { return node instanceof BigIntLiteral +} +if (!nodeByType.has(5)) { + nodeByType.set(5, BigIntLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts index 9a7460643..d34a0a950 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -76,4 +77,7 @@ export class BinaryExpression extends Expression { } export function isBinaryExpression(node: AstNode): node is BinaryExpression { return node instanceof BinaryExpression +} +if (!nodeByType.has(6)) { + nodeByType.set(6, BinaryExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts index 39d766831..0a1465641 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BlockExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -43,4 +44,7 @@ export class BlockExpression extends Expression { } export function isBlockExpression(node: AstNode): node is BlockExpression { return node instanceof BlockExpression +} +if (!nodeByType.has(154)) { + nodeByType.set(154, BlockExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts index d6711fb04..0a7b0b1aa 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BlockStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -42,4 +43,7 @@ export class BlockStatement extends Statement { } export function isBlockStatement(node: AstNode): node is BlockStatement { return node instanceof BlockStatement +} +if (!nodeByType.has(7)) { + nodeByType.set(7, BlockStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts index 9390b9ae6..cf1d789d1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -45,4 +46,7 @@ export class BooleanLiteral extends Literal { } export function isBooleanLiteral(node: AstNode): node is BooleanLiteral { return node instanceof BooleanLiteral +} +if (!nodeByType.has(8)) { + nodeByType.set(8, BooleanLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts index 8fb8051b5..56c043d24 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -58,4 +59,7 @@ export class BreakStatement extends Statement { } export function isBreakStatement(node: AstNode): node is BreakStatement { return node instanceof BreakStatement +} +if (!nodeByType.has(9)) { + nodeByType.set(9, BreakStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts index 495b700fc..b3377ae77 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { MaybeOptionalExpression } from "./MaybeOptionalExpression" @@ -75,4 +76,7 @@ export class CallExpression extends MaybeOptionalExpression { } export function isCallExpression(node: AstNode): node is CallExpression { return node instanceof CallExpression +} +if (!nodeByType.has(10)) { + nodeByType.set(10, CallExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts b/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts index c22e26d92..c7a046355 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedStatement } from "./TypedStatement" @@ -56,4 +57,7 @@ export class CatchClause extends TypedStatement { } export function isCatchClause(node: AstNode): node is CatchClause { return node instanceof CatchClause +} +if (!nodeByType.has(11)) { + nodeByType.set(11, CatchClause) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts index da0e9826c..15acefb38 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -48,4 +49,7 @@ export class ChainExpression extends Expression { } export function isChainExpression(node: AstNode): node is ChainExpression { return node instanceof ChainExpression +} +if (!nodeByType.has(12)) { + nodeByType.set(12, ChainExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts index 73108082d..327437862 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -42,4 +43,7 @@ export class CharLiteral extends Literal { } export function isCharLiteral(node: AstNode): node is CharLiteral { return node instanceof CharLiteral +} +if (!nodeByType.has(13)) { + nodeByType.set(13, CharLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts index 7a126b6cd..1e8247d89 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -53,4 +54,7 @@ export class ClassDeclaration extends Statement { } export function isClassDeclaration(node: AstNode): node is ClassDeclaration { return node instanceof ClassDeclaration +} +if (!nodeByType.has(15)) { + nodeByType.set(15, ClassDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts index e46a32592..a98aac032 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedAstNode } from "./TypedAstNode" @@ -161,4 +162,7 @@ export class ClassDefinition extends TypedAstNode { } export function isClassDefinition(node: AstNode): node is ClassDefinition { return node instanceof ClassDefinition +} +if (!nodeByType.has(14)) { + nodeByType.set(14, ClassDefinition) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts index f61e0aad0..64378b296 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassElement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedStatement } from "./TypedStatement" diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts index 888be069f..2129f8733 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -46,4 +47,7 @@ export class ClassExpression extends Expression { } export function isClassExpression(node: AstNode): node is ClassExpression { return node instanceof ClassExpression +} +if (!nodeByType.has(16)) { + nodeByType.set(16, ClassExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts index 65083a584..14bda3d26 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ClassElement } from "./ClassElement" @@ -55,4 +56,7 @@ export class ClassProperty extends ClassElement { } export function isClassProperty(node: AstNode): node is ClassProperty { return node instanceof ClassProperty +} +if (!nodeByType.has(17)) { + nodeByType.set(17, ClassProperty) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts index 880888735..eac95b0c6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ClassElement } from "./ClassElement" @@ -43,4 +44,7 @@ export class ClassStaticBlock extends ClassElement { } export function isClassStaticBlock(node: AstNode): node is ClassStaticBlock { return node instanceof ClassStaticBlock +} +if (!nodeByType.has(18)) { + nodeByType.set(18, ClassStaticBlock) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts index d92ad39b5..0d69eda4b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -60,4 +61,7 @@ export class ConditionalExpression extends Expression { } export function isConditionalExpression(node: AstNode): node is ConditionalExpression { return node instanceof ConditionalExpression +} +if (!nodeByType.has(19)) { + nodeByType.set(19, ConditionalExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts index 51ad34eb0..5d0b3190c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -58,4 +59,7 @@ export class ContinueStatement extends Statement { } export function isContinueStatement(node: AstNode): node is ContinueStatement { return node instanceof ContinueStatement +} +if (!nodeByType.has(20)) { + nodeByType.set(20, ContinueStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts index b4f3c236a..85db8fab6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -42,4 +43,7 @@ export class DebuggerStatement extends Statement { } export function isDebuggerStatement(node: AstNode): node is DebuggerStatement { return node instanceof DebuggerStatement +} +if (!nodeByType.has(21)) { + nodeByType.set(21, DebuggerStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts b/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts index 87db27b5d..e5e93c549 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -46,4 +47,7 @@ export class Decorator extends Statement { } export function isDecorator(node: AstNode): node is Decorator { return node instanceof Decorator +} +if (!nodeByType.has(22)) { + nodeByType.set(22, Decorator) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts index 314fc2522..6b76722e0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { CallExpression } from "./CallExpression" @@ -44,4 +45,7 @@ export class DirectEvalExpression extends CallExpression { } export function isDirectEvalExpression(node: AstNode): node is DirectEvalExpression { return node instanceof DirectEvalExpression +} +if (!nodeByType.has(23)) { + nodeByType.set(23, DirectEvalExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts index f69393d17..c6f8f0615 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DoWhileStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { LoopStatement } from "./LoopStatement" @@ -50,4 +51,7 @@ export class DoWhileStatement extends LoopStatement { } export function isDoWhileStatement(node: AstNode): node is DoWhileStatement { return node instanceof DoWhileStatement +} +if (!nodeByType.has(24)) { + nodeByType.set(24, DoWhileStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts index 30f74e4f5..4ee1b4f87 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -46,4 +47,7 @@ export class ETSClassLiteral extends Expression { } export function isETSClassLiteral(node: AstNode): node is ETSClassLiteral { return node instanceof ETSClassLiteral +} +if (!nodeByType.has(70)) { + nodeByType.set(70, ETSClassLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts index 4a24d4bfa..3a37dd0fa 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSDynamicFunctionType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ETSFunctionType } from "./ETSFunctionType" diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts index 3456e57b9..627678b97 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSFunctionType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -73,4 +74,7 @@ export class ETSFunctionType extends TypeNode { } export function isETSFunctionType(node: AstNode): node is ETSFunctionType { return node instanceof ETSFunctionType +} +if (!nodeByType.has(66)) { + nodeByType.set(66, ETSFunctionType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts index 7143ac0b8..16205bfaa 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSImportDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ImportDeclaration } from "./ImportDeclaration" @@ -58,4 +59,7 @@ export class ETSImportDeclaration extends ImportDeclaration { } export function isETSImportDeclaration(node: AstNode): node is ETSImportDeclaration { return node instanceof ETSImportDeclaration +} +if (!nodeByType.has(78)) { + nodeByType.set(78, ETSImportDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts index af9f15d70..e81f14a28 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -46,4 +47,7 @@ export class ETSLaunchExpression extends Expression { } export function isETSLaunchExpression(node: AstNode): node is ETSLaunchExpression { return node instanceof ETSLaunchExpression +} +if (!nodeByType.has(74)) { + nodeByType.set(74, ETSLaunchExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts index f7fc73b62..18df46b99 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSModule.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { BlockStatement } from "./BlockStatement" @@ -59,4 +60,7 @@ export class ETSModule extends BlockStatement { } export function isETSModule(node: AstNode): node is ETSModule { return node instanceof ETSModule +} +if (!nodeByType.has(81)) { + nodeByType.set(81, ETSModule) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts index 5d2dfca72..53ff15d7e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -55,4 +56,7 @@ export class ETSNewArrayInstanceExpression extends Expression { } export function isETSNewArrayInstanceExpression(node: AstNode): node is ETSNewArrayInstanceExpression { return node instanceof ETSNewArrayInstanceExpression +} +if (!nodeByType.has(75)) { + nodeByType.set(75, ETSNewArrayInstanceExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts index b75bab626..67343bdc6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -54,4 +55,7 @@ export class ETSNewClassInstanceExpression extends Expression { } export function isETSNewClassInstanceExpression(node: AstNode): node is ETSNewClassInstanceExpression { return node instanceof ETSNewClassInstanceExpression +} +if (!nodeByType.has(77)) { + nodeByType.set(77, ETSNewClassInstanceExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts index 88a7b6be6..23592d087 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -61,4 +62,7 @@ export class ETSNewMultiDimArrayInstanceExpression extends Expression { } export function isETSNewMultiDimArrayInstanceExpression(node: AstNode): node is ETSNewMultiDimArrayInstanceExpression { return node instanceof ETSNewMultiDimArrayInstanceExpression +} +if (!nodeByType.has(76)) { + nodeByType.set(76, ETSNewMultiDimArrayInstanceExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts index 279fc8472..d3f4b52b1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class ETSNullType extends TypeNode { } export function isETSNullType(node: AstNode): node is ETSNullType { return node instanceof ETSNullType +} +if (!nodeByType.has(62)) { + nodeByType.set(62, ETSNullType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts index f784110d9..fd00e6d3b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -43,4 +44,7 @@ export class ETSPackageDeclaration extends Statement { } export function isETSPackageDeclaration(node: AstNode): node is ETSPackageDeclaration { return node instanceof ETSPackageDeclaration +} +if (!nodeByType.has(69)) { + nodeByType.set(69, ETSPackageDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts index 44a6f7f48..a9f95c8af 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -59,4 +60,7 @@ export class ETSParameterExpression extends Expression { } export function isETSParameterExpression(node: AstNode): node is ETSParameterExpression { return node instanceof ETSParameterExpression +} +if (!nodeByType.has(79)) { + nodeByType.set(79, ETSParameterExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts index 761c6f1b9..8dffc9d92 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -46,4 +47,7 @@ export class ETSPrimitiveType extends TypeNode { } export function isETSPrimitiveType(node: AstNode): node is ETSPrimitiveType { return node instanceof ETSPrimitiveType +} +if (!nodeByType.has(68)) { + nodeByType.set(68, ETSPrimitiveType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts index f9df26fee..ec203d068 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSReExportDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -46,4 +47,7 @@ export class ETSReExportDeclaration extends Statement { } export function isETSReExportDeclaration(node: AstNode): node is ETSReExportDeclaration { return node instanceof ETSReExportDeclaration +} +if (!nodeByType.has(57)) { + nodeByType.set(57, ETSReExportDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts index b341a7ed3..3e7b67e85 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ClassDeclaration } from "./ClassDeclaration" @@ -43,4 +44,7 @@ export class ETSStructDeclaration extends ClassDeclaration { } export function isETSStructDeclaration(node: AstNode): node is ETSStructDeclaration { return node instanceof ETSStructDeclaration +} +if (!nodeByType.has(83)) { + nodeByType.set(83, ETSStructDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts index fbcee5019..b0b5ff49e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -63,4 +64,7 @@ export class ETSTuple extends TypeNode { } export function isETSTuple(node: AstNode): node is ETSTuple { return node instanceof ETSTuple +} +if (!nodeByType.has(80)) { + nodeByType.set(80, ETSTuple) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts index eb65893c4..8b16766d3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -49,4 +50,7 @@ export class ETSTypeReference extends TypeNode { } export function isETSTypeReference(node: AstNode): node is ETSTypeReference { return node instanceof ETSTypeReference +} +if (!nodeByType.has(71)) { + nodeByType.set(71, ETSTypeReference) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts index 9d33ec09b..e2954eabd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -65,4 +66,7 @@ export class ETSTypeReferencePart extends TypeNode { } export function isETSTypeReferencePart(node: AstNode): node is ETSTypeReferencePart { return node instanceof ETSTypeReferencePart +} +if (!nodeByType.has(72)) { + nodeByType.set(72, ETSTypeReferencePart) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts index ac8aa77c6..f7a6c1eb8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class ETSUndefinedType extends TypeNode { } export function isETSUndefinedType(node: AstNode): node is ETSUndefinedType { return node instanceof ETSUndefinedType +} +if (!nodeByType.has(63)) { + nodeByType.set(63, ETSUndefinedType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts index ab58232f1..3a2b63fa8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -45,4 +46,7 @@ export class ETSUnionType extends TypeNode { } export function isETSUnionType(node: AstNode): node is ETSUnionType { return node instanceof ETSUnionType +} +if (!nodeByType.has(73)) { + nodeByType.set(73, ETSUnionType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts index ae5dbb3b4..a3945b2af 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -50,4 +51,7 @@ export class ETSWildcardType extends TypeNode { } export function isETSWildcardType(node: AstNode): node is ETSWildcardType { return node instanceof ETSWildcardType +} +if (!nodeByType.has(67)) { + nodeByType.set(67, ETSWildcardType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts index a74af4e3a..baadf4ee5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -42,4 +43,7 @@ export class EmptyStatement extends Statement { } export function isEmptyStatement(node: AstNode): node is EmptyStatement { return node instanceof EmptyStatement +} +if (!nodeByType.has(25)) { + nodeByType.set(25, EmptyStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts index d827b1a94..155b49768 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -50,4 +51,7 @@ export class ExportAllDeclaration extends Statement { } export function isExportAllDeclaration(node: AstNode): node is ExportAllDeclaration { return node instanceof ExportAllDeclaration +} +if (!nodeByType.has(26)) { + nodeByType.set(26, ExportAllDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts index 4da8c11d4..6d9c7334f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -51,4 +52,7 @@ export class ExportDefaultDeclaration extends Statement { } export function isExportDefaultDeclaration(node: AstNode): node is ExportDefaultDeclaration { return node instanceof ExportDefaultDeclaration +} +if (!nodeByType.has(27)) { + nodeByType.set(27, ExportDefaultDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts index a90bb6bbd..5b7fb1463 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -65,4 +66,7 @@ export class ExportNamedDeclaration extends Statement { } export function isExportNamedDeclaration(node: AstNode): node is ExportNamedDeclaration { return node instanceof ExportNamedDeclaration +} +if (!nodeByType.has(28)) { + nodeByType.set(28, ExportNamedDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts index 382c89054..1f11d0bfe 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -49,4 +50,7 @@ export class ExportSpecifier extends Statement { } export function isExportSpecifier(node: AstNode): node is ExportSpecifier { return node instanceof ExportSpecifier +} +if (!nodeByType.has(29)) { + nodeByType.set(29, ExportSpecifier) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Expression.ts b/arkoala-arkts/libarkts/src/generated/peers/Expression.ts index 29c10a05b..a10db93e7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Expression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Expression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedAstNode } from "./TypedAstNode" diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts index bbc0cfb2e..f91dc0b6d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -49,4 +50,7 @@ export class ExpressionStatement extends Statement { } export function isExpressionStatement(node: AstNode): node is ExpressionStatement { return node instanceof ExpressionStatement +} +if (!nodeByType.has(30)) { + nodeByType.set(30, ExpressionStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts index 832fed72c..6bfbe4adf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForInStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { LoopStatement } from "./LoopStatement" @@ -56,4 +57,7 @@ export class ForInStatement extends LoopStatement { } export function isForInStatement(node: AstNode): node is ForInStatement { return node instanceof ForInStatement +} +if (!nodeByType.has(31)) { + nodeByType.set(31, ForInStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts index affdb4ed3..cbde8c02a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForOfStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { LoopStatement } from "./LoopStatement" @@ -59,4 +60,7 @@ export class ForOfStatement extends LoopStatement { } export function isForOfStatement(node: AstNode): node is ForOfStatement { return node instanceof ForOfStatement +} +if (!nodeByType.has(32)) { + nodeByType.set(32, ForOfStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts index 509fe7646..ad9600df4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ForUpdateStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { LoopStatement } from "./LoopStatement" @@ -59,4 +60,7 @@ export class ForUpdateStatement extends LoopStatement { } export function isForUpdateStatement(node: AstNode): node is ForUpdateStatement { return node instanceof ForUpdateStatement +} +if (!nodeByType.has(33)) { + nodeByType.set(33, ForUpdateStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts index e11cd95f9..44d73ed8e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionDecl.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ScriptFunction } from "./ScriptFunction" diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts index 2a71f9ee2..a7ed67609 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -65,4 +66,7 @@ export class FunctionDeclaration extends Statement { } export function isFunctionDeclaration(node: AstNode): node is FunctionDeclaration { return node instanceof FunctionDeclaration +} +if (!nodeByType.has(34)) { + nodeByType.set(34, FunctionDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts index 549488ee3..86b988839 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -62,4 +63,7 @@ export class FunctionExpression extends Expression { } export function isFunctionExpression(node: AstNode): node is FunctionExpression { return node instanceof FunctionExpression +} +if (!nodeByType.has(35)) { + nodeByType.set(35, FunctionExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts b/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts index 04b8cb47f..5a7a409c0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedExpression } from "./AnnotatedExpression" @@ -101,4 +102,7 @@ export class Identifier extends AnnotatedExpression { } export function isIdentifier(node: AstNode): node is Identifier { return node instanceof Identifier +} +if (!nodeByType.has(36)) { + nodeByType.set(36, Identifier) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts index 688ea8080..e2c428239 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/IfStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -55,4 +56,7 @@ export class IfStatement extends Statement { } export function isIfStatement(node: AstNode): node is IfStatement { return node instanceof IfStatement +} +if (!nodeByType.has(38)) { + nodeByType.set(38, IfStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts index 38a6ff2af..d655c481d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -59,4 +60,7 @@ export class ImportDeclaration extends Statement { } export function isImportDeclaration(node: AstNode): node is ImportDeclaration { return node instanceof ImportDeclaration +} +if (!nodeByType.has(39)) { + nodeByType.set(39, ImportDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts index 28d39da39..336b81eef 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -49,4 +50,7 @@ export class ImportDefaultSpecifier extends Statement { } export function isImportDefaultSpecifier(node: AstNode): node is ImportDefaultSpecifier { return node instanceof ImportDefaultSpecifier +} +if (!nodeByType.has(41)) { + nodeByType.set(41, ImportDefaultSpecifier) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts index 489f8b840..b81ea4a4d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -48,4 +49,7 @@ export class ImportExpression extends Expression { } export function isImportExpression(node: AstNode): node is ImportExpression { return node instanceof ImportExpression +} +if (!nodeByType.has(40)) { + nodeByType.set(40, ImportExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts index b50dd642c..4e60b59b9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -49,4 +50,7 @@ export class ImportNamespaceSpecifier extends Statement { } export function isImportNamespaceSpecifier(node: AstNode): node is ImportNamespaceSpecifier { return node instanceof ImportNamespaceSpecifier +} +if (!nodeByType.has(42)) { + nodeByType.set(42, ImportNamespaceSpecifier) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts index 54ea216c9..4a0994258 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -55,4 +56,7 @@ export class ImportSpecifier extends Statement { } export function isImportSpecifier(node: AstNode): node is ImportSpecifier { return node instanceof ImportSpecifier +} +if (!nodeByType.has(43)) { + nodeByType.set(43, ImportSpecifier) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts b/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts index 4bfb4ab11..53d42c93e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/InterfaceDecl.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TSInterfaceDeclaration } from "./TSInterfaceDeclaration" diff --git a/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts index 255075d6e..04137ff53 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/LabelledStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -46,4 +47,7 @@ export class LabelledStatement extends Statement { } export function isLabelledStatement(node: AstNode): node is LabelledStatement { return node instanceof LabelledStatement +} +if (!nodeByType.has(44)) { + nodeByType.set(44, LabelledStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Literal.ts b/arkoala-arkts/libarkts/src/generated/peers/Literal.ts index 8b2a04106..1ea75b77c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Literal.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Literal.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts index 73b0ba804..b8e4df54c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/LoopStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" diff --git a/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts index 175973148..9269c8186 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MaybeOptionalExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts index fc70b945f..6528a6e1a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { MaybeOptionalExpression } from "./MaybeOptionalExpression" @@ -65,4 +66,7 @@ export class MemberExpression extends MaybeOptionalExpression { } export function isMemberExpression(node: AstNode): node is MemberExpression { return node instanceof MemberExpression +} +if (!nodeByType.has(45)) { + nodeByType.set(45, MemberExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts index 6d02a0c56..aba6fefdd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -46,4 +47,7 @@ export class MetaProperty extends Expression { } export function isMetaProperty(node: AstNode): node is MetaProperty { return node instanceof MetaProperty +} +if (!nodeByType.has(46)) { + nodeByType.set(46, MetaProperty) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts b/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts index 502e8f193..b4e457114 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { ClassElement } from "./ClassElement" @@ -69,4 +70,7 @@ export class MethodDefinition extends ClassElement { } export function isMethodDefinition(node: AstNode): node is MethodDefinition { return node instanceof MethodDefinition +} +if (!nodeByType.has(47)) { + nodeByType.set(47, MethodDefinition) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts b/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts index a8060bb1b..01a691a22 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -53,4 +54,7 @@ export class NamedType extends TypeNode { } export function isNamedType(node: AstNode): node is NamedType { return node instanceof NamedType +} +if (!nodeByType.has(48)) { + nodeByType.set(48, NamedType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts index 1c43309d0..88ed0c1c0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -48,4 +49,7 @@ export class NewExpression extends Expression { } export function isNewExpression(node: AstNode): node is NewExpression { return node instanceof NewExpression +} +if (!nodeByType.has(49)) { + nodeByType.set(49, NewExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts index b61e7aa8c..831fe8324 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -42,4 +43,7 @@ export class NullLiteral extends Literal { } export function isNullLiteral(node: AstNode): node is NullLiteral { return node instanceof NullLiteral +} +if (!nodeByType.has(50)) { + nodeByType.set(50, NullLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts index 0677d42de..25df8b1f0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NumberLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -39,4 +40,7 @@ export class NumberLiteral extends Literal { } export function isNumberLiteral(node: AstNode): node is NumberLiteral { return node instanceof NumberLiteral +} +if (!nodeByType.has(52)) { + nodeByType.set(52, NumberLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts index 1c8e9eea7..5191506de 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ObjectExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedExpression } from "./AnnotatedExpression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts index ec426f5fc..63a037be2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -42,4 +43,7 @@ export class OmittedExpression extends Expression { } export function isOmittedExpression(node: AstNode): node is OmittedExpression { return node instanceof OmittedExpression +} +if (!nodeByType.has(53)) { + nodeByType.set(53, OmittedExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts b/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts index 2dde8584e..b24192a52 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class OpaqueTypeNode extends TypeNode { } export function isOpaqueTypeNode(node: AstNode): node is OpaqueTypeNode { return node instanceof OpaqueTypeNode +} +if (!nodeByType.has(153)) { + nodeByType.set(153, OpaqueTypeNode) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts index 115f28cb4..0b67dd535 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -49,4 +50,7 @@ export class PrefixAssertionExpression extends Expression { } export function isPrefixAssertionExpression(node: AstNode): node is PrefixAssertionExpression { return node instanceof PrefixAssertionExpression +} +if (!nodeByType.has(54)) { + nodeByType.set(54, PrefixAssertionExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/Property.ts b/arkoala-arkts/libarkts/src/generated/peers/Property.ts index 67f37e128..cfb988e2a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Property.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Property.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -76,4 +77,7 @@ export class Property extends Expression { } export function isProperty(node: AstNode): node is Property { return node instanceof Property +} +if (!nodeByType.has(55)) { + nodeByType.set(55, Property) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts index 002fab298..ec60b7314 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -49,4 +50,7 @@ export class RegExpLiteral extends Literal { } export function isRegExpLiteral(node: AstNode): node is RegExpLiteral { return node instanceof RegExpLiteral +} +if (!nodeByType.has(56)) { + nodeByType.set(56, RegExpLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts index 6d416cdbe..f544d98c0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -55,4 +56,7 @@ export class ReturnStatement extends Statement { } export function isReturnStatement(node: AstNode): node is ReturnStatement { return node instanceof ReturnStatement +} +if (!nodeByType.has(58)) { + nodeByType.set(58, ReturnStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts b/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts index 062ae458e..ec0eff15a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ScriptFunction.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Identifier } from "./Identifier" @@ -168,4 +169,7 @@ export class ScriptFunction extends AstNode { } export function isScriptFunction(node: AstNode): node is ScriptFunction { return node instanceof ScriptFunction +} +if (!nodeByType.has(59)) { + nodeByType.set(59, ScriptFunction) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts index df3665420..f636a3609 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -48,4 +49,7 @@ export class SequenceExpression extends Expression { } export function isSequenceExpression(node: AstNode): node is SequenceExpression { return node instanceof SequenceExpression +} +if (!nodeByType.has(60)) { + nodeByType.set(60, SequenceExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts b/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts index 85b1a750c..b8b5489ec 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SpreadElement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedExpression } from "./AnnotatedExpression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/Statement.ts b/arkoala-arkts/libarkts/src/generated/peers/Statement.ts index b3c39e95d..f1d2849fa 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Statement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Statement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" export abstract class Statement extends AstNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts index cec3d65cd..e1fb6c668 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -48,4 +49,7 @@ export class StringLiteral extends Literal { } export function isStringLiteral(node: AstNode): node is StringLiteral { return node instanceof StringLiteral +} +if (!nodeByType.has(61)) { + nodeByType.set(61, StringLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts index cfd0c78ca..4552c4463 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -42,4 +43,7 @@ export class SuperExpression extends Expression { } export function isSuperExpression(node: AstNode): node is SuperExpression { return node instanceof SuperExpression +} +if (!nodeByType.has(82)) { + nodeByType.set(82, SuperExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts index 64bcdb304..a56fdb3cc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SwitchCaseStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -46,4 +47,7 @@ export class SwitchCaseStatement extends Statement { } export function isSwitchCaseStatement(node: AstNode): node is SwitchCaseStatement { return node instanceof SwitchCaseStatement +} +if (!nodeByType.has(84)) { + nodeByType.set(84, SwitchCaseStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts index 824fc4be8..92046a01f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -56,4 +57,7 @@ export class SwitchStatement extends Statement { } export function isSwitchStatement(node: AstNode): node is SwitchStatement { return node instanceof SwitchStatement +} +if (!nodeByType.has(85)) { + nodeByType.set(85, SwitchStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts index a9e9bc5c4..2390a90a2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class TSAnyKeyword extends TypeNode { } export function isTSAnyKeyword(node: AstNode): node is TSAnyKeyword { return node instanceof TSAnyKeyword +} +if (!nodeByType.has(90)) { + nodeByType.set(90, TSAnyKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts index 7c08bd7bc..d3d817d8c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -45,4 +46,7 @@ export class TSArrayType extends TypeNode { } export function isTSArrayType(node: AstNode): node is TSArrayType { return node instanceof TSArrayType +} +if (!nodeByType.has(101)) { + nodeByType.set(101, TSArrayType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts index 6d892689c..4a4ecdb61 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedExpression } from "./AnnotatedExpression" @@ -53,4 +54,7 @@ export class TSAsExpression extends AnnotatedExpression { } export function isTSAsExpression(node: AstNode): node is TSAsExpression { return node instanceof TSAsExpression +} +if (!nodeByType.has(137)) { + nodeByType.set(137, TSAsExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts index 5c5e0204e..4c06a44b5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class TSBigintKeyword extends TypeNode { } export function isTSBigintKeyword(node: AstNode): node is TSBigintKeyword { return node instanceof TSBigintKeyword +} +if (!nodeByType.has(97)) { + nodeByType.set(97, TSBigintKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts index 25fd5d2b4..5b49168cb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class TSBooleanKeyword extends TypeNode { } export function isTSBooleanKeyword(node: AstNode): node is TSBooleanKeyword { return node instanceof TSBooleanKeyword +} +if (!nodeByType.has(92)) { + nodeByType.set(92, TSBooleanKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts b/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts index a5e43b62a..11e237d6b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -58,4 +59,7 @@ export class TSClassImplements extends Expression { } export function isTSClassImplements(node: AstNode): node is TSClassImplements { return node instanceof TSClassImplements +} +if (!nodeByType.has(138)) { + nodeByType.set(138, TSClassImplements) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts index 21f9982bd..e59021171 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -55,4 +56,7 @@ export class TSConditionalType extends TypeNode { } export function isTSConditionalType(node: AstNode): node is TSConditionalType { return node instanceof TSConditionalType +} +if (!nodeByType.has(110)) { + nodeByType.set(110, TSConditionalType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts index eeb36fa8a..daf1cc754 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSConstructorType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -56,4 +57,7 @@ export class TSConstructorType extends TypeNode { } export function isTSConstructorType(node: AstNode): node is TSConstructorType { return node instanceof TSConstructorType +} +if (!nodeByType.has(125)) { + nodeByType.set(125, TSConstructorType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts index d02c58204..247ba42ec 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedStatement } from "./TypedStatement" @@ -66,4 +67,7 @@ export class TSEnumDeclaration extends TypedStatement { } export function isTSEnumDeclaration(node: AstNode): node is TSEnumDeclaration { return node instanceof TSEnumDeclaration +} +if (!nodeByType.has(86)) { + nodeByType.set(86, TSEnumDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts b/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts index 30fd92c70..089827e0a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -64,4 +65,7 @@ export class TSEnumMember extends Statement { } export function isTSEnumMember(node: AstNode): node is TSEnumMember { return node instanceof TSEnumMember +} +if (!nodeByType.has(87)) { + nodeByType.set(87, TSEnumMember) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts b/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts index 68f06199e..24015578b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -45,4 +46,7 @@ export class TSExternalModuleReference extends Expression { } export function isTSExternalModuleReference(node: AstNode): node is TSExternalModuleReference { return node instanceof TSExternalModuleReference +} +if (!nodeByType.has(88)) { + nodeByType.set(88, TSExternalModuleReference) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts index a69de43ee..aa112e1bf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSFunctionType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -53,4 +54,7 @@ export class TSFunctionType extends TypeNode { } export function isTSFunctionType(node: AstNode): node is TSFunctionType { return node instanceof TSFunctionType +} +if (!nodeByType.has(124)) { + nodeByType.set(124, TSFunctionType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts index 15d089924..8d5dcfacc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -53,4 +54,7 @@ export class TSImportEqualsDeclaration extends Statement { } export function isTSImportEqualsDeclaration(node: AstNode): node is TSImportEqualsDeclaration { return node instanceof TSImportEqualsDeclaration +} +if (!nodeByType.has(123)) { + nodeByType.set(123, TSImportEqualsDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts index d3baf27b2..bb821894a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -56,4 +57,7 @@ export class TSImportType extends TypeNode { } export function isTSImportType(node: AstNode): node is TSImportType { return node instanceof TSImportType +} +if (!nodeByType.has(111)) { + nodeByType.set(111, TSImportType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts index 929d213b3..d8762b0f5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedAstNode } from "./TypedAstNode" @@ -53,4 +54,7 @@ export class TSIndexSignature extends TypedAstNode { } export function isTSIndexSignature(node: AstNode): node is TSIndexSignature { return node instanceof TSIndexSignature +} +if (!nodeByType.has(135)) { + nodeByType.set(135, TSIndexSignature) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts index f1792697d..37cd54b06 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -48,4 +49,7 @@ export class TSIndexedAccessType extends TypeNode { } export function isTSIndexedAccessType(node: AstNode): node is TSIndexedAccessType { return node instanceof TSIndexedAccessType +} +if (!nodeByType.has(129)) { + nodeByType.set(129, TSIndexedAccessType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts index f0b45fdbf..e305bf923 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -46,4 +47,7 @@ export class TSInferType extends TypeNode { } export function isTSInferType(node: AstNode): node is TSInferType { return node instanceof TSInferType +} +if (!nodeByType.has(109)) { + nodeByType.set(109, TSInferType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts index 284f28809..90f7004ee 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -51,4 +52,7 @@ export class TSInterfaceBody extends Expression { } export function isTSInterfaceBody(node: AstNode): node is TSInterfaceBody { return node instanceof TSInterfaceBody +} +if (!nodeByType.has(131)) { + nodeByType.set(131, TSInterfaceBody) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts index f9bea7253..ee2bb7383 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedStatement } from "./TypedStatement" @@ -97,4 +98,7 @@ export class TSInterfaceDeclaration extends TypedStatement { } export function isTSInterfaceDeclaration(node: AstNode): node is TSInterfaceDeclaration { return node instanceof TSInterfaceDeclaration +} +if (!nodeByType.has(130)) { + nodeByType.set(130, TSInterfaceDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts index d7b633693..f5e2b0fc4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -49,4 +50,7 @@ export class TSInterfaceHeritage extends Expression { } export function isTSInterfaceHeritage(node: AstNode): node is TSInterfaceHeritage { return node instanceof TSInterfaceHeritage +} +if (!nodeByType.has(132)) { + nodeByType.set(132, TSInterfaceHeritage) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts index e3cc6b959..f169e2791 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -46,4 +47,7 @@ export class TSIntersectionType extends TypeNode { } export function isTSIntersectionType(node: AstNode): node is TSIntersectionType { return node instanceof TSIntersectionType +} +if (!nodeByType.has(112)) { + nodeByType.set(112, TSIntersectionType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts index 558cbcc67..c42467791 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -46,4 +47,7 @@ export class TSLiteralType extends TypeNode { } export function isTSLiteralType(node: AstNode): node is TSLiteralType { return node instanceof TSLiteralType +} +if (!nodeByType.has(108)) { + nodeByType.set(108, TSLiteralType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts index 4bec564d2..1a55b5380 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -56,4 +57,7 @@ export class TSMappedType extends TypeNode { } export function isTSMappedType(node: AstNode): node is TSMappedType { return node instanceof TSMappedType +} +if (!nodeByType.has(113)) { + nodeByType.set(113, TSMappedType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts index 96072c65e..cb1219662 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSMethodSignature.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -65,4 +66,7 @@ export class TSMethodSignature extends AstNode { } export function isTSMethodSignature(node: AstNode): node is TSMethodSignature { return node instanceof TSMethodSignature +} +if (!nodeByType.has(105)) { + nodeByType.set(105, TSMethodSignature) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts b/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts index dd276c788..99b04712e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSModuleBlock.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -39,4 +40,7 @@ export class TSModuleBlock extends Statement { } export function isTSModuleBlock(node: AstNode): node is TSModuleBlock { return node instanceof TSModuleBlock +} +if (!nodeByType.has(114)) { + nodeByType.set(114, TSModuleBlock) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts index 98adfc7cc..6dd73bc7e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSModuleDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -49,4 +50,7 @@ export class TSModuleDeclaration extends Statement { } export function isTSModuleDeclaration(node: AstNode): node is TSModuleDeclaration { return node instanceof TSModuleDeclaration +} +if (!nodeByType.has(122)) { + nodeByType.set(122, TSModuleDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts index b7d1d4663..f1020d9b8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -55,4 +56,7 @@ export class TSNamedTupleMember extends TypeNode { } export function isTSNamedTupleMember(node: AstNode): node is TSNamedTupleMember { return node instanceof TSNamedTupleMember +} +if (!nodeByType.has(134)) { + nodeByType.set(134, TSNamedTupleMember) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts index f5dff1d60..635f34a50 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class TSNeverKeyword extends TypeNode { } export function isTSNeverKeyword(node: AstNode): node is TSNeverKeyword { return node instanceof TSNeverKeyword +} +if (!nodeByType.has(98)) { + nodeByType.set(98, TSNeverKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts index c349ead31..5bd56f711 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -48,4 +49,7 @@ export class TSNonNullExpression extends Expression { } export function isTSNonNullExpression(node: AstNode): node is TSNonNullExpression { return node instanceof TSNonNullExpression +} +if (!nodeByType.has(99)) { + nodeByType.set(99, TSNonNullExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts index fdb0363c9..a2025727f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class TSNullKeyword extends TypeNode { } export function isTSNullKeyword(node: AstNode): node is TSNullKeyword { return node instanceof TSNullKeyword +} +if (!nodeByType.has(100)) { + nodeByType.set(100, TSNullKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts index 14c7a45c0..2d791b858 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class TSNumberKeyword extends TypeNode { } export function isTSNumberKeyword(node: AstNode): node is TSNumberKeyword { return node instanceof TSNumberKeyword +} +if (!nodeByType.has(89)) { + nodeByType.set(89, TSNumberKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts index ee05fa504..569106312 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class TSObjectKeyword extends TypeNode { } export function isTSObjectKeyword(node: AstNode): node is TSObjectKeyword { return node instanceof TSObjectKeyword +} +if (!nodeByType.has(96)) { + nodeByType.set(96, TSObjectKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts index 4206b7b5c..940c8aa53 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -58,4 +59,7 @@ export class TSParameterProperty extends Expression { } export function isTSParameterProperty(node: AstNode): node is TSParameterProperty { return node instanceof TSParameterProperty +} +if (!nodeByType.has(121)) { + nodeByType.set(121, TSParameterProperty) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts index 1e091bef9..4bfbedf07 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -46,4 +47,7 @@ export class TSParenthesizedType extends TypeNode { } export function isTSParenthesizedType(node: AstNode): node is TSParenthesizedType { return node instanceof TSParenthesizedType +} +if (!nodeByType.has(107)) { + nodeByType.set(107, TSParenthesizedType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts index d14000f2a..528b234b1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedAstNode } from "./AnnotatedAstNode" @@ -62,4 +63,7 @@ export class TSPropertySignature extends AnnotatedAstNode { } export function isTSPropertySignature(node: AstNode): node is TSPropertySignature { return node instanceof TSPropertySignature +} +if (!nodeByType.has(104)) { + nodeByType.set(104, TSPropertySignature) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts b/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts index d7c41cff3..5420eddc5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -55,4 +56,7 @@ export class TSQualifiedName extends Expression { } export function isTSQualifiedName(node: AstNode): node is TSQualifiedName { return node instanceof TSQualifiedName +} +if (!nodeByType.has(128)) { + nodeByType.set(128, TSQualifiedName) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts index 4fc3e85cb..8f3335b4a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSSignatureDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedAstNode } from "./TypedAstNode" @@ -58,4 +59,7 @@ export class TSSignatureDeclaration extends TypedAstNode { } export function isTSSignatureDeclaration(node: AstNode): node is TSSignatureDeclaration { return node instanceof TSSignatureDeclaration +} +if (!nodeByType.has(106)) { + nodeByType.set(106, TSSignatureDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts index 6638b1b3e..f19cc22fd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class TSStringKeyword extends TypeNode { } export function isTSStringKeyword(node: AstNode): node is TSStringKeyword { return node instanceof TSStringKeyword +} +if (!nodeByType.has(91)) { + nodeByType.set(91, TSStringKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts index c5a813ea9..0231fbcea 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class TSThisType extends TypeNode { } export function isTSThisType(node: AstNode): node is TSThisType { return node instanceof TSThisType +} +if (!nodeByType.has(115)) { + nodeByType.set(115, TSThisType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts index f780da746..ec1d90e8e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -45,4 +46,7 @@ export class TSTupleType extends TypeNode { } export function isTSTupleType(node: AstNode): node is TSTupleType { return node instanceof TSTupleType +} +if (!nodeByType.has(133)) { + nodeByType.set(133, TSTupleType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts index cc5654dfb..8cf089e12 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedStatement } from "./AnnotatedStatement" @@ -74,4 +75,7 @@ export class TSTypeAliasDeclaration extends AnnotatedStatement { } export function isTSTypeAliasDeclaration(node: AstNode): node is TSTypeAliasDeclaration { return node instanceof TSTypeAliasDeclaration +} +if (!nodeByType.has(126)) { + nodeByType.set(126, TSTypeAliasDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts index 8d1915b7d..49b0638c2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { AnnotatedExpression } from "./AnnotatedExpression" @@ -50,4 +51,7 @@ export class TSTypeAssertion extends AnnotatedExpression { } export function isTSTypeAssertion(node: AstNode): node is TSTypeAssertion { return node instanceof TSTypeAssertion +} +if (!nodeByType.has(139)) { + nodeByType.set(139, TSTypeAssertion) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts index db04fb73b..1b4566d0a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -45,4 +46,7 @@ export class TSTypeLiteral extends TypeNode { } export function isTSTypeLiteral(node: AstNode): node is TSTypeLiteral { return node instanceof TSTypeLiteral +} +if (!nodeByType.has(103)) { + nodeByType.set(103, TSTypeLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts index 0245e44c4..4d52ae226 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -55,4 +56,7 @@ export class TSTypeOperator extends TypeNode { } export function isTSTypeOperator(node: AstNode): node is TSTypeOperator { return node instanceof TSTypeOperator +} +if (!nodeByType.has(116)) { + nodeByType.set(116, TSTypeOperator) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts index df61b3d5e..ea8865287 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -73,4 +74,7 @@ export class TSTypeParameter extends Expression { } export function isTSTypeParameter(node: AstNode): node is TSTypeParameter { return node instanceof TSTypeParameter +} +if (!nodeByType.has(117)) { + nodeByType.set(117, TSTypeParameter) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts index 649b62924..a94ae0748 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -49,4 +50,7 @@ export class TSTypeParameterDeclaration extends Expression { } export function isTSTypeParameterDeclaration(node: AstNode): node is TSTypeParameterDeclaration { return node instanceof TSTypeParameterDeclaration +} +if (!nodeByType.has(118)) { + nodeByType.set(118, TSTypeParameterDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts index bb571ed29..6d0836ed5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -46,4 +47,7 @@ export class TSTypeParameterInstantiation extends Expression { } export function isTSTypeParameterInstantiation(node: AstNode): node is TSTypeParameterInstantiation { return node instanceof TSTypeParameterInstantiation +} +if (!nodeByType.has(119)) { + nodeByType.set(119, TSTypeParameterInstantiation) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts index 0af99af29..af4f9de44 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -52,4 +53,7 @@ export class TSTypePredicate extends TypeNode { } export function isTSTypePredicate(node: AstNode): node is TSTypePredicate { return node instanceof TSTypePredicate +} +if (!nodeByType.has(120)) { + nodeByType.set(120, TSTypePredicate) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts index e4be5cc26..299d73516 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -46,4 +47,7 @@ export class TSTypeQuery extends TypeNode { } export function isTSTypeQuery(node: AstNode): node is TSTypeQuery { return node instanceof TSTypeQuery +} +if (!nodeByType.has(136)) { + nodeByType.set(136, TSTypeQuery) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts index 286229070..85e47701a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -50,4 +51,7 @@ export class TSTypeReference extends TypeNode { } export function isTSTypeReference(node: AstNode): node is TSTypeReference { return node instanceof TSTypeReference +} +if (!nodeByType.has(127)) { + nodeByType.set(127, TSTypeReference) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts index 617f53697..cfedbf5b7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class TSUndefinedKeyword extends TypeNode { } export function isTSUndefinedKeyword(node: AstNode): node is TSUndefinedKeyword { return node instanceof TSUndefinedKeyword +} +if (!nodeByType.has(94)) { + nodeByType.set(94, TSUndefinedKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts index 7602a8fbe..c49af47c5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -45,4 +46,7 @@ export class TSUnionType extends TypeNode { } export function isTSUnionType(node: AstNode): node is TSUnionType { return node instanceof TSUnionType +} +if (!nodeByType.has(102)) { + nodeByType.set(102, TSUnionType) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts index 0b4030231..34cc18e2f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class TSUnknownKeyword extends TypeNode { } export function isTSUnknownKeyword(node: AstNode): node is TSUnknownKeyword { return node instanceof TSUnknownKeyword +} +if (!nodeByType.has(95)) { + nodeByType.set(95, TSUnknownKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts index 392412c70..8b4f2fb81 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypeNode } from "./TypeNode" @@ -42,4 +43,7 @@ export class TSVoidKeyword extends TypeNode { } export function isTSVoidKeyword(node: AstNode): node is TSVoidKeyword { return node instanceof TSVoidKeyword +} +if (!nodeByType.has(93)) { + nodeByType.set(93, TSVoidKeyword) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts index 991244956..d8b5e12ff 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -53,4 +54,7 @@ export class TaggedTemplateExpression extends Expression { } export function isTaggedTemplateExpression(node: AstNode): node is TaggedTemplateExpression { return node instanceof TaggedTemplateExpression +} +if (!nodeByType.has(140)) { + nodeByType.set(140, TaggedTemplateExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts b/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts index 0d505f70f..4caf056f4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -54,4 +55,7 @@ export class TemplateElement extends Expression { } export function isTemplateElement(node: AstNode): node is TemplateElement { return node instanceof TemplateElement +} +if (!nodeByType.has(141)) { + nodeByType.set(141, TemplateElement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts index 952583ba0..2f9722608 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -49,4 +50,7 @@ export class TemplateLiteral extends Expression { } export function isTemplateLiteral(node: AstNode): node is TemplateLiteral { return node instanceof TemplateLiteral +} +if (!nodeByType.has(142)) { + nodeByType.set(142, TemplateLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts index 28563e464..6de59a46e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -42,4 +43,7 @@ export class ThisExpression extends Expression { } export function isThisExpression(node: AstNode): node is ThisExpression { return node instanceof ThisExpression +} +if (!nodeByType.has(143)) { + nodeByType.set(143, ThisExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts index c2468f34c..b362f6e97 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -46,4 +47,7 @@ export class ThrowStatement extends Statement { } export function isThrowStatement(node: AstNode): node is ThrowStatement { return node instanceof ThrowStatement +} +if (!nodeByType.has(145)) { + nodeByType.set(145, ThrowStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts index cbf22f6dc..b790a1d19 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TryStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -53,4 +54,7 @@ export class TryStatement extends Statement { } export function isTryStatement(node: AstNode): node is TryStatement { return node instanceof TryStatement +} +if (!nodeByType.has(146)) { + nodeByType.set(146, TryStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts b/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts index bd893051b..789c66b72 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypeNode.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts b/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts index a93cec213..2e9212727 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypedAstNode.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" export abstract class TypedAstNode extends AstNode { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts index f277f2845..d3efbbbab 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypedStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts index e12144926..622ddb28e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -45,4 +46,7 @@ export class TypeofExpression extends Expression { } export function isTypeofExpression(node: AstNode): node is TypeofExpression { return node instanceof TypeofExpression +} +if (!nodeByType.has(144)) { + nodeByType.set(144, TypeofExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts index 3664948fc..cfd26a359 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -52,4 +53,7 @@ export class UnaryExpression extends Expression { } export function isUnaryExpression(node: AstNode): node is UnaryExpression { return node instanceof UnaryExpression +} +if (!nodeByType.has(147)) { + nodeByType.set(147, UnaryExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts index ff60f1550..ee3bb46bc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Literal } from "./Literal" @@ -42,4 +43,7 @@ export class UndefinedLiteral extends Literal { } export function isUndefinedLiteral(node: AstNode): node is UndefinedLiteral { return node instanceof UndefinedLiteral +} +if (!nodeByType.has(51)) { + nodeByType.set(51, UndefinedLiteral) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts index e0f3f1374..1db3cd5cb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -55,4 +56,7 @@ export class UpdateExpression extends Expression { } export function isUpdateExpression(node: AstNode): node is UpdateExpression { return node instanceof UpdateExpression +} +if (!nodeByType.has(148)) { + nodeByType.set(148, UpdateExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts index b145115d8..c82b5ae81 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Statement } from "./Statement" @@ -61,4 +62,7 @@ export class VariableDeclaration extends Statement { } export function isVariableDeclaration(node: AstNode): node is VariableDeclaration { return node instanceof VariableDeclaration +} +if (!nodeByType.has(149)) { + nodeByType.set(149, VariableDeclaration) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts index 9d46bd035..5db1da15b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { TypedStatement } from "./TypedStatement" @@ -65,4 +66,7 @@ export class VariableDeclarator extends TypedStatement { } export function isVariableDeclarator(node: AstNode): node is VariableDeclarator { return node instanceof VariableDeclarator +} +if (!nodeByType.has(150)) { + nodeByType.set(150, VariableDeclarator) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts index b5ca5e0be..d2b24f274 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/WhileStatement.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { LoopStatement } from "./LoopStatement" @@ -50,4 +51,7 @@ export class WhileStatement extends LoopStatement { } export function isWhileStatement(node: AstNode): node is WhileStatement { return node instanceof WhileStatement +} +if (!nodeByType.has(151)) { + nodeByType.set(151, WhileStatement) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts index 6a1279f7b..fb025cb58 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts @@ -23,7 +23,8 @@ import { assertValidPeer, AstNode, Es2pandaAstNodeType, - KNativePointer + KNativePointer, + nodeByType } from "../../reexport-for-generated" import { Expression } from "./Expression" @@ -48,4 +49,7 @@ export class YieldExpression extends Expression { } export function isYieldExpression(node: AstNode): node is YieldExpression { return node instanceof YieldExpression +} +if (!nodeByType.has(152)) { + nodeByType.set(152, YieldExpression) } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/reexport-for-generated.ts b/arkoala-arkts/libarkts/src/reexport-for-generated.ts index c318a164b..648817510 100644 --- a/arkoala-arkts/libarkts/src/reexport-for-generated.ts +++ b/arkoala-arkts/libarkts/src/reexport-for-generated.ts @@ -12,7 +12,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - export { KNativePointer } from "@koalaui/interop" export { AstNode } from "./arkts-api/peers/AstNode" export { Es2pandaAstNodeType } from "./Es2pandaEnums" @@ -27,5 +26,6 @@ export { unpackObject, assertValidPeer } from "./arkts-api/utilities/private" +export { nodeByType } from "./arkts-api/class-by-peer" export { global } from "./arkts-api/static/global" export { Es2pandaMemberExpressionKind } from "./generated/Es2pandaEnums" -- Gitee From 5910a1b5ef8e00e0cb56d2f615048422389c1c14 Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Wed, 19 Feb 2025 12:05:05 +0300 Subject: [PATCH 15/20] non-nullable create Signed-off-by: naumovdmitrii --- .../src/generated/peers/AnnotationDeclaration.ts | 8 ++++---- .../libarkts/src/generated/peers/AnnotationUsage.ts | 8 ++++---- .../src/generated/peers/ArrowFunctionExpression.ts | 8 ++++---- .../libarkts/src/generated/peers/AssertStatement.ts | 4 ++-- .../libarkts/src/generated/peers/AwaitExpression.ts | 4 ++-- .../libarkts/src/generated/peers/BigIntLiteral.ts | 4 ++-- .../libarkts/src/generated/peers/BinaryExpression.ts | 4 ++-- .../libarkts/src/generated/peers/BooleanLiteral.ts | 4 ++-- .../libarkts/src/generated/peers/BreakStatement.ts | 8 ++++---- .../libarkts/src/generated/peers/CallExpression.ts | 6 +++--- .../libarkts/src/generated/peers/CatchClause.ts | 4 ++-- .../libarkts/src/generated/peers/ChainExpression.ts | 4 ++-- .../libarkts/src/generated/peers/CharLiteral.ts | 4 ++-- .../libarkts/src/generated/peers/ClassDeclaration.ts | 4 ++-- .../libarkts/src/generated/peers/ClassDefinition.ts | 12 ++++++------ .../libarkts/src/generated/peers/ClassExpression.ts | 4 ++-- .../libarkts/src/generated/peers/ClassProperty.ts | 4 ++-- .../libarkts/src/generated/peers/ClassStaticBlock.ts | 4 ++-- .../src/generated/peers/ConditionalExpression.ts | 4 ++-- .../src/generated/peers/ContinueStatement.ts | 8 ++++---- .../src/generated/peers/DebuggerStatement.ts | 4 ++-- .../libarkts/src/generated/peers/Decorator.ts | 4 ++-- .../src/generated/peers/DirectEvalExpression.ts | 4 ++-- .../libarkts/src/generated/peers/ETSClassLiteral.ts | 4 ++-- .../src/generated/peers/ETSLaunchExpression.ts | 4 ++-- .../generated/peers/ETSNewArrayInstanceExpression.ts | 4 ++-- .../generated/peers/ETSNewClassInstanceExpression.ts | 8 ++++---- .../peers/ETSNewMultiDimArrayInstanceExpression.ts | 8 ++++---- .../libarkts/src/generated/peers/ETSNullType.ts | 4 ++-- .../src/generated/peers/ETSPackageDeclaration.ts | 4 ++-- .../src/generated/peers/ETSParameterExpression.ts | 4 ++-- .../libarkts/src/generated/peers/ETSPrimitiveType.ts | 4 ++-- .../src/generated/peers/ETSStructDeclaration.ts | 4 ++-- .../libarkts/src/generated/peers/ETSTuple.ts | 12 ++++++------ .../libarkts/src/generated/peers/ETSTypeReference.ts | 4 ++-- .../src/generated/peers/ETSTypeReferencePart.ts | 8 ++++---- .../libarkts/src/generated/peers/ETSUndefinedType.ts | 4 ++-- .../libarkts/src/generated/peers/ETSUnionType.ts | 4 ++-- .../libarkts/src/generated/peers/ETSWildcardType.ts | 4 ++-- .../libarkts/src/generated/peers/EmptyStatement.ts | 4 ++-- .../src/generated/peers/ExportAllDeclaration.ts | 4 ++-- .../src/generated/peers/ExportDefaultDeclaration.ts | 4 ++-- .../src/generated/peers/ExportNamedDeclaration.ts | 12 ++++++------ .../libarkts/src/generated/peers/ExportSpecifier.ts | 4 ++-- .../src/generated/peers/ExpressionStatement.ts | 4 ++-- .../src/generated/peers/FunctionDeclaration.ts | 8 ++++---- .../src/generated/peers/FunctionExpression.ts | 8 ++++---- .../libarkts/src/generated/peers/Identifier.ts | 12 ++++++------ .../src/generated/peers/ImportDeclaration.ts | 4 ++-- .../src/generated/peers/ImportDefaultSpecifier.ts | 4 ++-- .../libarkts/src/generated/peers/ImportExpression.ts | 4 ++-- .../src/generated/peers/ImportNamespaceSpecifier.ts | 4 ++-- .../libarkts/src/generated/peers/ImportSpecifier.ts | 4 ++-- .../libarkts/src/generated/peers/MemberExpression.ts | 4 ++-- .../libarkts/src/generated/peers/MetaProperty.ts | 4 ++-- .../libarkts/src/generated/peers/MethodDefinition.ts | 4 ++-- .../libarkts/src/generated/peers/NamedType.ts | 4 ++-- .../libarkts/src/generated/peers/NewExpression.ts | 4 ++-- .../libarkts/src/generated/peers/NullLiteral.ts | 4 ++-- .../src/generated/peers/OmittedExpression.ts | 4 ++-- .../libarkts/src/generated/peers/OpaqueTypeNode.ts | 4 ++-- .../src/generated/peers/PrefixAssertionExpression.ts | 4 ++-- .../libarkts/src/generated/peers/Property.ts | 8 ++++---- .../libarkts/src/generated/peers/RegExpLiteral.ts | 4 ++-- .../libarkts/src/generated/peers/ReturnStatement.ts | 8 ++++---- .../src/generated/peers/SequenceExpression.ts | 4 ++-- .../libarkts/src/generated/peers/StringLiteral.ts | 6 +++--- .../libarkts/src/generated/peers/SuperExpression.ts | 4 ++-- .../libarkts/src/generated/peers/SwitchStatement.ts | 4 ++-- .../libarkts/src/generated/peers/TSAnyKeyword.ts | 4 ++-- .../libarkts/src/generated/peers/TSArrayType.ts | 4 ++-- .../libarkts/src/generated/peers/TSAsExpression.ts | 4 ++-- .../libarkts/src/generated/peers/TSBigintKeyword.ts | 4 ++-- .../libarkts/src/generated/peers/TSBooleanKeyword.ts | 4 ++-- .../src/generated/peers/TSClassImplements.ts | 8 ++++---- .../src/generated/peers/TSConditionalType.ts | 4 ++-- .../src/generated/peers/TSEnumDeclaration.ts | 4 ++-- .../libarkts/src/generated/peers/TSEnumMember.ts | 8 ++++---- .../src/generated/peers/TSExternalModuleReference.ts | 4 ++-- .../src/generated/peers/TSImportEqualsDeclaration.ts | 4 ++-- .../libarkts/src/generated/peers/TSImportType.ts | 4 ++-- .../libarkts/src/generated/peers/TSIndexSignature.ts | 4 ++-- .../src/generated/peers/TSIndexedAccessType.ts | 4 ++-- .../libarkts/src/generated/peers/TSInferType.ts | 4 ++-- .../libarkts/src/generated/peers/TSInterfaceBody.ts | 4 ++-- .../src/generated/peers/TSInterfaceDeclaration.ts | 4 ++-- .../src/generated/peers/TSInterfaceHeritage.ts | 4 ++-- .../src/generated/peers/TSIntersectionType.ts | 4 ++-- .../libarkts/src/generated/peers/TSLiteralType.ts | 4 ++-- .../libarkts/src/generated/peers/TSMappedType.ts | 4 ++-- .../src/generated/peers/TSNamedTupleMember.ts | 4 ++-- .../libarkts/src/generated/peers/TSNeverKeyword.ts | 4 ++-- .../src/generated/peers/TSNonNullExpression.ts | 4 ++-- .../libarkts/src/generated/peers/TSNullKeyword.ts | 4 ++-- .../libarkts/src/generated/peers/TSNumberKeyword.ts | 4 ++-- .../libarkts/src/generated/peers/TSObjectKeyword.ts | 4 ++-- .../src/generated/peers/TSParameterProperty.ts | 4 ++-- .../src/generated/peers/TSParenthesizedType.ts | 4 ++-- .../src/generated/peers/TSPropertySignature.ts | 4 ++-- .../libarkts/src/generated/peers/TSQualifiedName.ts | 4 ++-- .../libarkts/src/generated/peers/TSStringKeyword.ts | 4 ++-- .../libarkts/src/generated/peers/TSThisType.ts | 4 ++-- .../libarkts/src/generated/peers/TSTupleType.ts | 4 ++-- .../src/generated/peers/TSTypeAliasDeclaration.ts | 8 ++++---- .../libarkts/src/generated/peers/TSTypeAssertion.ts | 4 ++-- .../libarkts/src/generated/peers/TSTypeLiteral.ts | 4 ++-- .../libarkts/src/generated/peers/TSTypeOperator.ts | 4 ++-- .../libarkts/src/generated/peers/TSTypeParameter.ts | 8 ++++---- .../generated/peers/TSTypeParameterDeclaration.ts | 4 ++-- .../generated/peers/TSTypeParameterInstantiation.ts | 4 ++-- .../libarkts/src/generated/peers/TSTypePredicate.ts | 4 ++-- .../libarkts/src/generated/peers/TSTypeQuery.ts | 4 ++-- .../libarkts/src/generated/peers/TSTypeReference.ts | 4 ++-- .../src/generated/peers/TSUndefinedKeyword.ts | 4 ++-- .../libarkts/src/generated/peers/TSUnionType.ts | 4 ++-- .../libarkts/src/generated/peers/TSUnknownKeyword.ts | 4 ++-- .../libarkts/src/generated/peers/TSVoidKeyword.ts | 4 ++-- .../src/generated/peers/TaggedTemplateExpression.ts | 4 ++-- .../libarkts/src/generated/peers/TemplateElement.ts | 8 ++++---- .../libarkts/src/generated/peers/TemplateLiteral.ts | 4 ++-- .../libarkts/src/generated/peers/ThisExpression.ts | 4 ++-- .../libarkts/src/generated/peers/ThrowStatement.ts | 4 ++-- .../libarkts/src/generated/peers/TypeofExpression.ts | 4 ++-- .../libarkts/src/generated/peers/UnaryExpression.ts | 4 ++-- .../libarkts/src/generated/peers/UndefinedLiteral.ts | 4 ++-- .../libarkts/src/generated/peers/UpdateExpression.ts | 4 ++-- .../src/generated/peers/VariableDeclaration.ts | 4 ++-- .../src/generated/peers/VariableDeclarator.ts | 8 ++++---- .../libarkts/src/generated/peers/YieldExpression.ts | 4 ++-- 129 files changed, 312 insertions(+), 312 deletions(-) diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts index 62469de01..17c10a02c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotationDeclaration.ts @@ -35,16 +35,16 @@ export class AnnotationDeclaration extends Statement { super(pointer) console.warn("Warning: stub node AnnotationDeclaration") } - static createAnnotationDeclaration(expr?: Expression): AnnotationDeclaration | undefined { + static createAnnotationDeclaration(expr?: Expression): AnnotationDeclaration { return new AnnotationDeclaration(global.generatedEs2panda._CreateAnnotationDeclaration(global.context, passNode(expr))) } - static updateAnnotationDeclaration(original?: AnnotationDeclaration, expr?: Expression): AnnotationDeclaration | undefined { + static updateAnnotationDeclaration(original?: AnnotationDeclaration, expr?: Expression): AnnotationDeclaration { return new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration(global.context, passNode(original), passNode(expr))) } - static create1AnnotationDeclaration(expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationDeclaration | undefined { + static create1AnnotationDeclaration(expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationDeclaration { return new AnnotationDeclaration(global.generatedEs2panda._CreateAnnotationDeclaration1(global.context, passNode(expr), passNodeArray(properties), propertiesLen)) } - static update1AnnotationDeclaration(original: AnnotationDeclaration | undefined, expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationDeclaration | undefined { + static update1AnnotationDeclaration(original: AnnotationDeclaration | undefined, expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationDeclaration { return new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration1(global.context, passNode(original), passNode(expr), passNodeArray(properties), propertiesLen)) } get internalNameConst(): string { diff --git a/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts b/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts index a830f2ceb..8e324f9da 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AnnotationUsage.ts @@ -35,16 +35,16 @@ export class AnnotationUsage extends Statement { super(pointer) console.warn("Warning: stub node AnnotationUsage") } - static createAnnotationUsage(expr?: Expression): AnnotationUsage | undefined { + static createAnnotationUsage(expr?: Expression): AnnotationUsage { return new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsageIr(global.context, passNode(expr))) } - static updateAnnotationUsage(original?: AnnotationUsage, expr?: Expression): AnnotationUsage | undefined { + static updateAnnotationUsage(original?: AnnotationUsage, expr?: Expression): AnnotationUsage { return new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsageIr(global.context, passNode(original), passNode(expr))) } - static create1AnnotationUsage(expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationUsage | undefined { + static create1AnnotationUsage(expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationUsage { return new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsageIr1(global.context, passNode(expr), passNodeArray(properties), propertiesLen)) } - static update1AnnotationUsage(original: AnnotationUsage | undefined, expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationUsage | undefined { + static update1AnnotationUsage(original: AnnotationUsage | undefined, expr: Expression | undefined, properties: readonly AstNode[], propertiesLen: number): AnnotationUsage { return new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsageIr1(global.context, passNode(original), passNode(expr), passNodeArray(properties), propertiesLen)) } get expr(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts index 6a363283d..90de76f6a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ArrowFunctionExpression.ts @@ -36,16 +36,16 @@ export class ArrowFunctionExpression extends Expression { super(pointer) console.warn("Warning: stub node ArrowFunctionExpression") } - static createArrowFunctionExpression(func?: ScriptFunction): ArrowFunctionExpression | undefined { + static createArrowFunctionExpression(func?: ScriptFunction): ArrowFunctionExpression { return new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression(global.context, passNode(func))) } - static updateArrowFunctionExpression(original?: ArrowFunctionExpression, func?: ScriptFunction): ArrowFunctionExpression | undefined { + static updateArrowFunctionExpression(original?: ArrowFunctionExpression, func?: ScriptFunction): ArrowFunctionExpression { return new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression(global.context, passNode(original), passNode(func))) } - static create1ArrowFunctionExpression(other?: ArrowFunctionExpression): ArrowFunctionExpression | undefined { + static create1ArrowFunctionExpression(other?: ArrowFunctionExpression): ArrowFunctionExpression { return new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression1(global.context, passNode(other))) } - static update1ArrowFunctionExpression(original?: ArrowFunctionExpression, other?: ArrowFunctionExpression): ArrowFunctionExpression | undefined { + static update1ArrowFunctionExpression(original?: ArrowFunctionExpression, other?: ArrowFunctionExpression): ArrowFunctionExpression { return new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression1(global.context, passNode(original), passNode(other))) } get functionConst(): ScriptFunction | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts index aa11ed383..d9ff4e1d5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AssertStatement.ts @@ -35,10 +35,10 @@ export class AssertStatement extends Statement { super(pointer) console.warn("Warning: stub node AssertStatement") } - static createAssertStatement(test?: Expression, second?: Expression): AssertStatement | undefined { + static createAssertStatement(test?: Expression, second?: Expression): AssertStatement { return new AssertStatement(global.generatedEs2panda._CreateAssertStatement(global.context, passNode(test), passNode(second))) } - static updateAssertStatement(original?: AssertStatement, test?: Expression, second?: Expression): AssertStatement | undefined { + static updateAssertStatement(original?: AssertStatement, test?: Expression, second?: Expression): AssertStatement { return new AssertStatement(global.generatedEs2panda._UpdateAssertStatement(global.context, passNode(original), passNode(test), passNode(second))) } get testConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts index 372d6e09c..47492db2d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/AwaitExpression.ts @@ -34,10 +34,10 @@ export class AwaitExpression extends Expression { super(pointer) console.warn("Warning: stub node AwaitExpression") } - static createAwaitExpression(argument?: Expression): AwaitExpression | undefined { + static createAwaitExpression(argument?: Expression): AwaitExpression { return new AwaitExpression(global.generatedEs2panda._CreateAwaitExpression(global.context, passNode(argument))) } - static updateAwaitExpression(original?: AwaitExpression, argument?: Expression): AwaitExpression | undefined { + static updateAwaitExpression(original?: AwaitExpression, argument?: Expression): AwaitExpression { return new AwaitExpression(global.generatedEs2panda._UpdateAwaitExpression(global.context, passNode(original), passNode(argument))) } get argumentConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts index 1e3cda0d3..5138e43be 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BigIntLiteral.ts @@ -34,10 +34,10 @@ export class BigIntLiteral extends Literal { super(pointer) console.warn("Warning: stub node BigIntLiteral") } - static createBigIntLiteral(src: string): BigIntLiteral | undefined { + static createBigIntLiteral(src: string): BigIntLiteral { return new BigIntLiteral(global.generatedEs2panda._CreateBigIntLiteral(global.context, src)) } - static updateBigIntLiteral(original: BigIntLiteral | undefined, src: string): BigIntLiteral | undefined { + static updateBigIntLiteral(original: BigIntLiteral | undefined, src: string): BigIntLiteral { return new BigIntLiteral(global.generatedEs2panda._UpdateBigIntLiteral(global.context, passNode(original), src)) } get strConst(): string { diff --git a/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts index d34a0a950..ac197bf48 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BinaryExpression.ts @@ -35,10 +35,10 @@ export class BinaryExpression extends Expression { super(pointer) console.warn("Warning: stub node BinaryExpression") } - static createBinaryExpression(left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression | undefined { + static createBinaryExpression(left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression { return new BinaryExpression(global.generatedEs2panda._CreateBinaryExpression(global.context, passNode(left), passNode(right), operatorType)) } - static updateBinaryExpression(original: BinaryExpression | undefined, left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression | undefined { + static updateBinaryExpression(original: BinaryExpression | undefined, left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression { return new BinaryExpression(global.generatedEs2panda._UpdateBinaryExpression(global.context, passNode(original), passNode(left), passNode(right), operatorType)) } get leftConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts index cf1d789d1..d31f4b5a4 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BooleanLiteral.ts @@ -34,10 +34,10 @@ export class BooleanLiteral extends Literal { super(pointer) console.warn("Warning: stub node BooleanLiteral") } - static createBooleanLiteral(value: boolean): BooleanLiteral | undefined { + static createBooleanLiteral(value: boolean): BooleanLiteral { return new BooleanLiteral(global.generatedEs2panda._CreateBooleanLiteral(global.context, value)) } - static updateBooleanLiteral(original: BooleanLiteral | undefined, value: boolean): BooleanLiteral | undefined { + static updateBooleanLiteral(original: BooleanLiteral | undefined, value: boolean): BooleanLiteral { return new BooleanLiteral(global.generatedEs2panda._UpdateBooleanLiteral(global.context, passNode(original), value)) } get valueConst(): boolean { diff --git a/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts index 56c043d24..44785b47a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/BreakStatement.ts @@ -35,16 +35,16 @@ export class BreakStatement extends Statement { super(pointer) console.warn("Warning: stub node BreakStatement") } - static createBreakStatement(): BreakStatement | undefined { + static createBreakStatement(): BreakStatement { return new BreakStatement(global.generatedEs2panda._CreateBreakStatement(global.context)) } - static updateBreakStatement(original?: BreakStatement): BreakStatement | undefined { + static updateBreakStatement(original?: BreakStatement): BreakStatement { return new BreakStatement(global.generatedEs2panda._UpdateBreakStatement(global.context, passNode(original))) } - static create1BreakStatement(ident?: Identifier): BreakStatement | undefined { + static create1BreakStatement(ident?: Identifier): BreakStatement { return new BreakStatement(global.generatedEs2panda._CreateBreakStatement1(global.context, passNode(ident))) } - static update1BreakStatement(original?: BreakStatement, ident?: Identifier): BreakStatement | undefined { + static update1BreakStatement(original?: BreakStatement, ident?: Identifier): BreakStatement { return new BreakStatement(global.generatedEs2panda._UpdateBreakStatement1(global.context, passNode(original), passNode(ident))) } get identConst(): Identifier | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts index b3377ae77..b86739498 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CallExpression.ts @@ -37,13 +37,13 @@ export class CallExpression extends MaybeOptionalExpression { super(pointer) console.warn("Warning: stub node CallExpression") } - static createCallExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, trailingComma: boolean): CallExpression | undefined { + static createCallExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, trailingComma: boolean): CallExpression { return new CallExpression(global.generatedEs2panda._CreateCallExpression(global.context, passNode(callee), passNodeArray(_arguments), argumentsLen, passNode(typeParams), optional_arg, trailingComma)) } - static create1CallExpression(other?: CallExpression): CallExpression | undefined { + static create1CallExpression(other?: CallExpression): CallExpression { return new CallExpression(global.generatedEs2panda._CreateCallExpression1(global.context, passNode(other))) } - static update1CallExpression(original?: CallExpression, other?: CallExpression): CallExpression | undefined { + static update1CallExpression(original?: CallExpression, other?: CallExpression): CallExpression { return new CallExpression(global.generatedEs2panda._UpdateCallExpression1(global.context, passNode(original), passNode(other))) } get calleeConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts b/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts index c7a046355..6e214900d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CatchClause.ts @@ -36,10 +36,10 @@ export class CatchClause extends TypedStatement { super(pointer) console.warn("Warning: stub node CatchClause") } - static createCatchClause(param?: Expression, body?: BlockStatement): CatchClause | undefined { + static createCatchClause(param?: Expression, body?: BlockStatement): CatchClause { return new CatchClause(global.generatedEs2panda._CreateCatchClause(global.context, passNode(param), passNode(body))) } - static updateCatchClause(original?: CatchClause, param?: Expression, body?: BlockStatement): CatchClause | undefined { + static updateCatchClause(original?: CatchClause, param?: Expression, body?: BlockStatement): CatchClause { return new CatchClause(global.generatedEs2panda._UpdateCatchClause(global.context, passNode(original), passNode(param), passNode(body))) } get param(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts index 15acefb38..992c8db0e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ChainExpression.ts @@ -34,10 +34,10 @@ export class ChainExpression extends Expression { super(pointer) console.warn("Warning: stub node ChainExpression") } - static createChainExpression(expression?: Expression): ChainExpression | undefined { + static createChainExpression(expression?: Expression): ChainExpression { return new ChainExpression(global.generatedEs2panda._CreateChainExpression(global.context, passNode(expression))) } - static updateChainExpression(original?: ChainExpression, expression?: Expression): ChainExpression | undefined { + static updateChainExpression(original?: ChainExpression, expression?: Expression): ChainExpression { return new ChainExpression(global.generatedEs2panda._UpdateChainExpression(global.context, passNode(original), passNode(expression))) } get getExpressionConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts index 327437862..cc0c0d2b7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/CharLiteral.ts @@ -34,10 +34,10 @@ export class CharLiteral extends Literal { super(pointer) console.warn("Warning: stub node CharLiteral") } - static createCharLiteral(): CharLiteral | undefined { + static createCharLiteral(): CharLiteral { return new CharLiteral(global.generatedEs2panda._CreateCharLiteral(global.context)) } - static updateCharLiteral(original?: CharLiteral): CharLiteral | undefined { + static updateCharLiteral(original?: CharLiteral): CharLiteral { return new CharLiteral(global.generatedEs2panda._UpdateCharLiteral(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts index 1e8247d89..ba2f55301 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassDeclaration.ts @@ -36,10 +36,10 @@ export class ClassDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ClassDeclaration") } - static createClassDeclaration(def?: ClassDefinition): ClassDeclaration | undefined { + static createClassDeclaration(def?: ClassDefinition): ClassDeclaration { return new ClassDeclaration(global.generatedEs2panda._CreateClassDeclaration(global.context, passNode(def))) } - static updateClassDeclaration(original?: ClassDeclaration, def?: ClassDefinition): ClassDeclaration | undefined { + static updateClassDeclaration(original?: ClassDeclaration, def?: ClassDefinition): ClassDeclaration { return new ClassDeclaration(global.generatedEs2panda._UpdateClassDeclaration(global.context, passNode(original), passNode(def))) } get definition(): ClassDefinition | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts index a98aac032..7a55b8e16 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassDefinition.ts @@ -45,22 +45,22 @@ export class ClassDefinition extends TypedAstNode { super(pointer) console.warn("Warning: stub node ClassDefinition") } - static createClassDefinition(ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], implementsLen: number, ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { + static createClassDefinition(ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], implementsLen: number, ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { return new ClassDefinition(global.generatedEs2panda._CreateClassDefinition(global.context, passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), implementsLen, passNode(ctor), passNode(superClass), passNodeArray(body), bodyLen, modifiers, flags)) } - static updateClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], implementsLen: number, ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { + static updateClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], implementsLen: number, ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { return new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition(global.context, passNode(original), passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), implementsLen, passNode(ctor), passNode(superClass), passNodeArray(body), bodyLen, modifiers, flags)) } - static create1ClassDefinition(ident: Identifier | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { + static create1ClassDefinition(ident: Identifier | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { return new ClassDefinition(global.generatedEs2panda._CreateClassDefinition1(global.context, passNode(ident), passNodeArray(body), bodyLen, modifiers, flags)) } - static update1ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { + static update1ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, body: readonly AstNode[], bodyLen: number, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { return new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition1(global.context, passNode(original), passNode(ident), passNodeArray(body), bodyLen, modifiers, flags)) } - static create2ClassDefinition(ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { + static create2ClassDefinition(ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { return new ClassDefinition(global.generatedEs2panda._CreateClassDefinition2(global.context, passNode(ident), modifiers, flags)) } - static update2ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition | undefined { + static update2ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition { return new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition2(global.context, passNode(original), passNode(ident), modifiers, flags)) } get identConst(): Identifier | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts index 2129f8733..503561f90 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassExpression.ts @@ -35,10 +35,10 @@ export class ClassExpression extends Expression { super(pointer) console.warn("Warning: stub node ClassExpression") } - static createClassExpression(def?: ClassDefinition): ClassExpression | undefined { + static createClassExpression(def?: ClassDefinition): ClassExpression { return new ClassExpression(global.generatedEs2panda._CreateClassExpression(global.context, passNode(def))) } - static updateClassExpression(original?: ClassExpression, def?: ClassDefinition): ClassExpression | undefined { + static updateClassExpression(original?: ClassExpression, def?: ClassDefinition): ClassExpression { return new ClassExpression(global.generatedEs2panda._UpdateClassExpression(global.context, passNode(original), passNode(def))) } get definitionConst(): ClassDefinition | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts index 14bda3d26..fb7de87a5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassProperty.ts @@ -38,10 +38,10 @@ export class ClassProperty extends ClassElement { super(pointer) console.warn("Warning: stub node ClassProperty") } - static createClassProperty(key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty | undefined { + static createClassProperty(key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty { return new ClassProperty(global.generatedEs2panda._CreateClassProperty(global.context, passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed)) } - static updateClassProperty(original: ClassProperty | undefined, key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty | undefined { + static updateClassProperty(original: ClassProperty | undefined, key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty { return new ClassProperty(global.generatedEs2panda._UpdateClassProperty(global.context, passNode(original), passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed)) } get typeAnnotationConst(): TypeNode | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts b/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts index eac95b0c6..4772fea2b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ClassStaticBlock.ts @@ -35,10 +35,10 @@ export class ClassStaticBlock extends ClassElement { super(pointer) console.warn("Warning: stub node ClassStaticBlock") } - static createClassStaticBlock(value?: Expression): ClassStaticBlock | undefined { + static createClassStaticBlock(value?: Expression): ClassStaticBlock { return new ClassStaticBlock(global.generatedEs2panda._CreateClassStaticBlock(global.context, passNode(value))) } - static updateClassStaticBlock(original?: ClassStaticBlock, value?: Expression): ClassStaticBlock | undefined { + static updateClassStaticBlock(original?: ClassStaticBlock, value?: Expression): ClassStaticBlock { return new ClassStaticBlock(global.generatedEs2panda._UpdateClassStaticBlock(global.context, passNode(original), passNode(value))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts index 0d69eda4b..b9e7fba20 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ConditionalExpression.ts @@ -34,10 +34,10 @@ export class ConditionalExpression extends Expression { super(pointer) console.warn("Warning: stub node ConditionalExpression") } - static createConditionalExpression(test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression | undefined { + static createConditionalExpression(test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression { return new ConditionalExpression(global.generatedEs2panda._CreateConditionalExpression(global.context, passNode(test), passNode(consequent), passNode(alternate))) } - static updateConditionalExpression(original?: ConditionalExpression, test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression | undefined { + static updateConditionalExpression(original?: ConditionalExpression, test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression { return new ConditionalExpression(global.generatedEs2panda._UpdateConditionalExpression(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate))) } get testConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts index 5d0b3190c..52c66fd96 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ContinueStatement.ts @@ -35,16 +35,16 @@ export class ContinueStatement extends Statement { super(pointer) console.warn("Warning: stub node ContinueStatement") } - static createContinueStatement(): ContinueStatement | undefined { + static createContinueStatement(): ContinueStatement { return new ContinueStatement(global.generatedEs2panda._CreateContinueStatement(global.context)) } - static updateContinueStatement(original?: ContinueStatement): ContinueStatement | undefined { + static updateContinueStatement(original?: ContinueStatement): ContinueStatement { return new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement(global.context, passNode(original))) } - static create1ContinueStatement(ident?: Identifier): ContinueStatement | undefined { + static create1ContinueStatement(ident?: Identifier): ContinueStatement { return new ContinueStatement(global.generatedEs2panda._CreateContinueStatement1(global.context, passNode(ident))) } - static update1ContinueStatement(original?: ContinueStatement, ident?: Identifier): ContinueStatement | undefined { + static update1ContinueStatement(original?: ContinueStatement, ident?: Identifier): ContinueStatement { return new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement1(global.context, passNode(original), passNode(ident))) } get identConst(): Identifier | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts index 85db8fab6..a22d4fe29 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DebuggerStatement.ts @@ -34,10 +34,10 @@ export class DebuggerStatement extends Statement { super(pointer) console.warn("Warning: stub node DebuggerStatement") } - static createDebuggerStatement(): DebuggerStatement | undefined { + static createDebuggerStatement(): DebuggerStatement { return new DebuggerStatement(global.generatedEs2panda._CreateDebuggerStatement(global.context)) } - static updateDebuggerStatement(original?: DebuggerStatement): DebuggerStatement | undefined { + static updateDebuggerStatement(original?: DebuggerStatement): DebuggerStatement { return new DebuggerStatement(global.generatedEs2panda._UpdateDebuggerStatement(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts b/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts index e5e93c549..1bef25a96 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Decorator.ts @@ -35,10 +35,10 @@ export class Decorator extends Statement { super(pointer) console.warn("Warning: stub node Decorator") } - static createDecorator(expr?: Expression): Decorator | undefined { + static createDecorator(expr?: Expression): Decorator { return new Decorator(global.generatedEs2panda._CreateDecorator(global.context, passNode(expr))) } - static updateDecorator(original?: Decorator, expr?: Expression): Decorator | undefined { + static updateDecorator(original?: Decorator, expr?: Expression): Decorator { return new Decorator(global.generatedEs2panda._UpdateDecorator(global.context, passNode(original), passNode(expr))) } get exprConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts index 6b76722e0..8892919d0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/DirectEvalExpression.ts @@ -36,10 +36,10 @@ export class DirectEvalExpression extends CallExpression { super(pointer) console.warn("Warning: stub node DirectEvalExpression") } - static createDirectEvalExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression | undefined { + static createDirectEvalExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression { return new DirectEvalExpression(global.generatedEs2panda._CreateDirectEvalExpression(global.context, passNode(callee), passNodeArray(_arguments), argumentsLen, passNode(typeParams), optional_arg, parserStatus)) } - static updateDirectEvalExpression(original: DirectEvalExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression | undefined { + static updateDirectEvalExpression(original: DirectEvalExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number, typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression { return new DirectEvalExpression(global.generatedEs2panda._UpdateDirectEvalExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), argumentsLen, passNode(typeParams), optional_arg, parserStatus)) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts index 4ee1b4f87..2090b961f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSClassLiteral.ts @@ -35,10 +35,10 @@ export class ETSClassLiteral extends Expression { super(pointer) console.warn("Warning: stub node ETSClassLiteral") } - static createETSClassLiteral(expr?: TypeNode): ETSClassLiteral | undefined { + static createETSClassLiteral(expr?: TypeNode): ETSClassLiteral { return new ETSClassLiteral(global.generatedEs2panda._CreateETSClassLiteral(global.context, passNode(expr))) } - static updateETSClassLiteral(original?: ETSClassLiteral, expr?: TypeNode): ETSClassLiteral | undefined { + static updateETSClassLiteral(original?: ETSClassLiteral, expr?: TypeNode): ETSClassLiteral { return new ETSClassLiteral(global.generatedEs2panda._UpdateETSClassLiteral(global.context, passNode(original), passNode(expr))) } get exprConst(): TypeNode | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts index e81f14a28..24c8748f7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSLaunchExpression.ts @@ -35,10 +35,10 @@ export class ETSLaunchExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSLaunchExpression") } - static createETSLaunchExpression(expr?: CallExpression): ETSLaunchExpression | undefined { + static createETSLaunchExpression(expr?: CallExpression): ETSLaunchExpression { return new ETSLaunchExpression(global.generatedEs2panda._CreateETSLaunchExpression(global.context, passNode(expr))) } - static updateETSLaunchExpression(original?: ETSLaunchExpression, expr?: CallExpression): ETSLaunchExpression | undefined { + static updateETSLaunchExpression(original?: ETSLaunchExpression, expr?: CallExpression): ETSLaunchExpression { return new ETSLaunchExpression(global.generatedEs2panda._UpdateETSLaunchExpression(global.context, passNode(original), passNode(expr))) } get callConst(): CallExpression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts index 53ff15d7e..bc727dd58 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts @@ -35,10 +35,10 @@ export class ETSNewArrayInstanceExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSNewArrayInstanceExpression") } - static createETSNewArrayInstanceExpression(typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression | undefined { + static createETSNewArrayInstanceExpression(typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression { return new ETSNewArrayInstanceExpression(global.generatedEs2panda._CreateETSNewArrayInstanceExpression(global.context, passNode(typeReference), passNode(dimension))) } - static updateETSNewArrayInstanceExpression(original?: ETSNewArrayInstanceExpression, typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression | undefined { + static updateETSNewArrayInstanceExpression(original?: ETSNewArrayInstanceExpression, typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression { return new ETSNewArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNode(dimension))) } get typeReference(): TypeNode | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts index 67343bdc6..65dfaf041 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts @@ -34,16 +34,16 @@ export class ETSNewClassInstanceExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSNewClassInstanceExpression") } - static createETSNewClassInstanceExpression(typeReference: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression | undefined { + static createETSNewClassInstanceExpression(typeReference: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression { return new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression(global.context, passNode(typeReference), passNodeArray(_arguments), argumentsLen)) } - static updateETSNewClassInstanceExpression(original: ETSNewClassInstanceExpression | undefined, typeReference: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression | undefined { + static updateETSNewClassInstanceExpression(original: ETSNewClassInstanceExpression | undefined, typeReference: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): ETSNewClassInstanceExpression { return new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(_arguments), argumentsLen)) } - static create1ETSNewClassInstanceExpression(other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression | undefined { + static create1ETSNewClassInstanceExpression(other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression { return new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression1(global.context, passNode(other))) } - static update1ETSNewClassInstanceExpression(original?: ETSNewClassInstanceExpression, other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression | undefined { + static update1ETSNewClassInstanceExpression(original?: ETSNewClassInstanceExpression, other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression { return new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression1(global.context, passNode(original), passNode(other))) } get getTypeRefConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts index 23592d087..fa74403f1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts @@ -35,16 +35,16 @@ export class ETSNewMultiDimArrayInstanceExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSNewMultiDimArrayInstanceExpression") } - static createETSNewMultiDimArrayInstanceExpression(typeReference: TypeNode | undefined, dimensions: readonly Expression[], dimensionsLen: number): ETSNewMultiDimArrayInstanceExpression | undefined { + static createETSNewMultiDimArrayInstanceExpression(typeReference: TypeNode | undefined, dimensions: readonly Expression[], dimensionsLen: number): ETSNewMultiDimArrayInstanceExpression { return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._CreateETSNewMultiDimArrayInstanceExpression(global.context, passNode(typeReference), passNodeArray(dimensions), dimensionsLen)) } - static updateETSNewMultiDimArrayInstanceExpression(original: ETSNewMultiDimArrayInstanceExpression | undefined, typeReference: TypeNode | undefined, dimensions: readonly Expression[], dimensionsLen: number): ETSNewMultiDimArrayInstanceExpression | undefined { + static updateETSNewMultiDimArrayInstanceExpression(original: ETSNewMultiDimArrayInstanceExpression | undefined, typeReference: TypeNode | undefined, dimensions: readonly Expression[], dimensionsLen: number): ETSNewMultiDimArrayInstanceExpression { return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(dimensions), dimensionsLen)) } - static create1ETSNewMultiDimArrayInstanceExpression(other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression | undefined { + static create1ETSNewMultiDimArrayInstanceExpression(other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression { return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._CreateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(other))) } - static update1ETSNewMultiDimArrayInstanceExpression(original?: ETSNewMultiDimArrayInstanceExpression, other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression | undefined { + static update1ETSNewMultiDimArrayInstanceExpression(original?: ETSNewMultiDimArrayInstanceExpression, other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression { return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(original), passNode(other))) } get typeReference(): TypeNode | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts index d3f4b52b1..0f551fd82 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSNullType.ts @@ -34,10 +34,10 @@ export class ETSNullType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSNullType") } - static createETSNullType(): ETSNullType | undefined { + static createETSNullType(): ETSNullType { return new ETSNullType(global.generatedEs2panda._CreateETSNullTypeIr(global.context)) } - static updateETSNullType(original?: ETSNullType): ETSNullType | undefined { + static updateETSNullType(original?: ETSNullType): ETSNullType { return new ETSNullType(global.generatedEs2panda._UpdateETSNullTypeIr(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts index fd00e6d3b..f651e034c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSPackageDeclaration.ts @@ -35,10 +35,10 @@ export class ETSPackageDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ETSPackageDeclaration") } - static createETSPackageDeclaration(name?: Expression): ETSPackageDeclaration | undefined { + static createETSPackageDeclaration(name?: Expression): ETSPackageDeclaration { return new ETSPackageDeclaration(global.generatedEs2panda._CreateETSPackageDeclaration(global.context, passNode(name))) } - static updateETSPackageDeclaration(original?: ETSPackageDeclaration, name?: Expression): ETSPackageDeclaration | undefined { + static updateETSPackageDeclaration(original?: ETSPackageDeclaration, name?: Expression): ETSPackageDeclaration { return new ETSPackageDeclaration(global.generatedEs2panda._UpdateETSPackageDeclaration(global.context, passNode(original), passNode(name))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts index a9f95c8af..5820b193d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSParameterExpression.ts @@ -36,10 +36,10 @@ export class ETSParameterExpression extends Expression { super(pointer) console.warn("Warning: stub node ETSParameterExpression") } - static createETSParameterExpression(identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression | undefined { + static createETSParameterExpression(identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression { return new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression(global.context, passNode(identOrSpread), passNode(initializer))) } - static updateETSParameterExpression(original?: ETSParameterExpression, identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression | undefined { + static updateETSParameterExpression(original?: ETSParameterExpression, identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression { return new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression(global.context, passNode(original), passNode(identOrSpread), passNode(initializer))) } get isDefaultConst(): boolean { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts index 8dffc9d92..49428e2ab 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSPrimitiveType.ts @@ -35,10 +35,10 @@ export class ETSPrimitiveType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSPrimitiveType") } - static createETSPrimitiveType(type: Es2pandaPrimitiveType): ETSPrimitiveType | undefined { + static createETSPrimitiveType(type: Es2pandaPrimitiveType): ETSPrimitiveType { return new ETSPrimitiveType(global.generatedEs2panda._CreateETSPrimitiveType(global.context, type)) } - static updateETSPrimitiveType(original: ETSPrimitiveType | undefined, type: Es2pandaPrimitiveType): ETSPrimitiveType | undefined { + static updateETSPrimitiveType(original: ETSPrimitiveType | undefined, type: Es2pandaPrimitiveType): ETSPrimitiveType { return new ETSPrimitiveType(global.generatedEs2panda._UpdateETSPrimitiveType(global.context, passNode(original), type)) } get getPrimitiveTypeConst(): Es2pandaPrimitiveType { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts index 3e7b67e85..0d5dabfee 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSStructDeclaration.ts @@ -35,10 +35,10 @@ export class ETSStructDeclaration extends ClassDeclaration { super(pointer) console.warn("Warning: stub node ETSStructDeclaration") } - static createETSStructDeclaration(def?: ClassDefinition): ETSStructDeclaration | undefined { + static createETSStructDeclaration(def?: ClassDefinition): ETSStructDeclaration { return new ETSStructDeclaration(global.generatedEs2panda._CreateETSStructDeclaration(global.context, passNode(def))) } - static updateETSStructDeclaration(original?: ETSStructDeclaration, def?: ClassDefinition): ETSStructDeclaration | undefined { + static updateETSStructDeclaration(original?: ETSStructDeclaration, def?: ClassDefinition): ETSStructDeclaration { return new ETSStructDeclaration(global.generatedEs2panda._UpdateETSStructDeclaration(global.context, passNode(original), passNode(def))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts index b0b5ff49e..1b8e46741 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTuple.ts @@ -34,22 +34,22 @@ export class ETSTuple extends TypeNode { super(pointer) console.warn("Warning: stub node ETSTuple") } - static createETSTuple(): ETSTuple | undefined { + static createETSTuple(): ETSTuple { return new ETSTuple(global.generatedEs2panda._CreateETSTuple(global.context)) } - static updateETSTuple(original?: ETSTuple): ETSTuple | undefined { + static updateETSTuple(original?: ETSTuple): ETSTuple { return new ETSTuple(global.generatedEs2panda._UpdateETSTuple(global.context, passNode(original))) } - static create1ETSTuple(size: number): ETSTuple | undefined { + static create1ETSTuple(size: number): ETSTuple { return new ETSTuple(global.generatedEs2panda._CreateETSTuple1(global.context, size)) } - static update1ETSTuple(original: ETSTuple | undefined, size: number): ETSTuple | undefined { + static update1ETSTuple(original: ETSTuple | undefined, size: number): ETSTuple { return new ETSTuple(global.generatedEs2panda._UpdateETSTuple1(global.context, passNode(original), size)) } - static create2ETSTuple(typeList: readonly TypeNode[], typeListLen: number): ETSTuple | undefined { + static create2ETSTuple(typeList: readonly TypeNode[], typeListLen: number): ETSTuple { return new ETSTuple(global.generatedEs2panda._CreateETSTuple2(global.context, passNodeArray(typeList), typeListLen)) } - static update2ETSTuple(original: ETSTuple | undefined, typeList: readonly TypeNode[], typeListLen: number): ETSTuple | undefined { + static update2ETSTuple(original: ETSTuple | undefined, typeList: readonly TypeNode[], typeListLen: number): ETSTuple { return new ETSTuple(global.generatedEs2panda._UpdateETSTuple2(global.context, passNode(original), passNodeArray(typeList), typeListLen)) } get getTupleSizeConst(): number { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts index 8b16766d3..850ddc4eb 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReference.ts @@ -35,10 +35,10 @@ export class ETSTypeReference extends TypeNode { super(pointer) console.warn("Warning: stub node ETSTypeReference") } - static createETSTypeReference(part?: ETSTypeReferencePart): ETSTypeReference | undefined { + static createETSTypeReference(part?: ETSTypeReferencePart): ETSTypeReference { return new ETSTypeReference(global.generatedEs2panda._CreateETSTypeReference(global.context, passNode(part))) } - static updateETSTypeReference(original?: ETSTypeReference, part?: ETSTypeReferencePart): ETSTypeReference | undefined { + static updateETSTypeReference(original?: ETSTypeReference, part?: ETSTypeReferencePart): ETSTypeReference { return new ETSTypeReference(global.generatedEs2panda._UpdateETSTypeReference(global.context, passNode(original), passNode(part))) } get part(): ETSTypeReferencePart | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts index e2954eabd..6e6f029b6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSTypeReferencePart.ts @@ -36,16 +36,16 @@ export class ETSTypeReferencePart extends TypeNode { super(pointer) console.warn("Warning: stub node ETSTypeReferencePart") } - static createETSTypeReferencePart(name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart | undefined { + static createETSTypeReferencePart(name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart { return new ETSTypeReferencePart(global.generatedEs2panda._CreateETSTypeReferencePart(global.context, passNode(name), passNode(typeParams), passNode(prev))) } - static updateETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart | undefined { + static updateETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart { return new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart(global.context, passNode(original), passNode(name), passNode(typeParams), passNode(prev))) } - static create1ETSTypeReferencePart(name?: Expression): ETSTypeReferencePart | undefined { + static create1ETSTypeReferencePart(name?: Expression): ETSTypeReferencePart { return new ETSTypeReferencePart(global.generatedEs2panda._CreateETSTypeReferencePart1(global.context, passNode(name))) } - static update1ETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression): ETSTypeReferencePart | undefined { + static update1ETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression): ETSTypeReferencePart { return new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart1(global.context, passNode(original), passNode(name))) } get previous(): ETSTypeReferencePart | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts index f7a6c1eb8..967d6b175 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSUndefinedType.ts @@ -34,10 +34,10 @@ export class ETSUndefinedType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSUndefinedType") } - static createETSUndefinedType(): ETSUndefinedType | undefined { + static createETSUndefinedType(): ETSUndefinedType { return new ETSUndefinedType(global.generatedEs2panda._CreateETSUndefinedTypeIr(global.context)) } - static updateETSUndefinedType(original?: ETSUndefinedType): ETSUndefinedType | undefined { + static updateETSUndefinedType(original?: ETSUndefinedType): ETSUndefinedType { return new ETSUndefinedType(global.generatedEs2panda._UpdateETSUndefinedTypeIr(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts index 3a2b63fa8..4c84dd484 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSUnionType.ts @@ -34,10 +34,10 @@ export class ETSUnionType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSUnionType") } - static createETSUnionType(types: readonly TypeNode[], typesLen: number): ETSUnionType | undefined { + static createETSUnionType(types: readonly TypeNode[], typesLen: number): ETSUnionType { return new ETSUnionType(global.generatedEs2panda._CreateETSUnionTypeIr(global.context, passNodeArray(types), typesLen)) } - static updateETSUnionType(original: ETSUnionType | undefined, types: readonly TypeNode[], typesLen: number): ETSUnionType | undefined { + static updateETSUnionType(original: ETSUnionType | undefined, types: readonly TypeNode[], typesLen: number): ETSUnionType { return new ETSUnionType(global.generatedEs2panda._UpdateETSUnionTypeIr(global.context, passNode(original), passNodeArray(types), typesLen)) } get typesConst(): readonly TypeNode[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts b/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts index a3945b2af..c1ad2314d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ETSWildcardType.ts @@ -36,10 +36,10 @@ export class ETSWildcardType extends TypeNode { super(pointer) console.warn("Warning: stub node ETSWildcardType") } - static createETSWildcardType(typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType | undefined { + static createETSWildcardType(typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType { return new ETSWildcardType(global.generatedEs2panda._CreateETSWildcardType(global.context, passNode(typeReference), flags)) } - static updateETSWildcardType(original: ETSWildcardType | undefined, typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType | undefined { + static updateETSWildcardType(original: ETSWildcardType | undefined, typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType { return new ETSWildcardType(global.generatedEs2panda._UpdateETSWildcardType(global.context, passNode(original), passNode(typeReference), flags)) } get typeReference(): ETSTypeReference | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts index baadf4ee5..d3dc1d031 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/EmptyStatement.ts @@ -34,10 +34,10 @@ export class EmptyStatement extends Statement { super(pointer) console.warn("Warning: stub node EmptyStatement") } - static createEmptyStatement(): EmptyStatement | undefined { + static createEmptyStatement(): EmptyStatement { return new EmptyStatement(global.generatedEs2panda._CreateEmptyStatement(global.context)) } - static updateEmptyStatement(original?: EmptyStatement): EmptyStatement | undefined { + static updateEmptyStatement(original?: EmptyStatement): EmptyStatement { return new EmptyStatement(global.generatedEs2panda._UpdateEmptyStatement(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts index 155b49768..43a236881 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportAllDeclaration.ts @@ -36,10 +36,10 @@ export class ExportAllDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ExportAllDeclaration") } - static createExportAllDeclaration(source?: StringLiteral, exported?: Identifier): ExportAllDeclaration | undefined { + static createExportAllDeclaration(source?: StringLiteral, exported?: Identifier): ExportAllDeclaration { return new ExportAllDeclaration(global.generatedEs2panda._CreateExportAllDeclaration(global.context, passNode(source), passNode(exported))) } - static updateExportAllDeclaration(original?: ExportAllDeclaration, source?: StringLiteral, exported?: Identifier): ExportAllDeclaration | undefined { + static updateExportAllDeclaration(original?: ExportAllDeclaration, source?: StringLiteral, exported?: Identifier): ExportAllDeclaration { return new ExportAllDeclaration(global.generatedEs2panda._UpdateExportAllDeclaration(global.context, passNode(original), passNode(source), passNode(exported))) } get sourceConst(): StringLiteral | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts index 6d9c7334f..8f0f43509 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportDefaultDeclaration.ts @@ -34,10 +34,10 @@ export class ExportDefaultDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ExportDefaultDeclaration") } - static createExportDefaultDeclaration(decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration | undefined { + static createExportDefaultDeclaration(decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration { return new ExportDefaultDeclaration(global.generatedEs2panda._CreateExportDefaultDeclaration(global.context, passNode(decl), exportEquals)) } - static updateExportDefaultDeclaration(original: ExportDefaultDeclaration | undefined, decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration | undefined { + static updateExportDefaultDeclaration(original: ExportDefaultDeclaration | undefined, decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration { return new ExportDefaultDeclaration(global.generatedEs2panda._UpdateExportDefaultDeclaration(global.context, passNode(original), passNode(decl), exportEquals)) } get decl(): AstNode | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts index 5b7fb1463..d7f7a23db 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportNamedDeclaration.ts @@ -36,22 +36,22 @@ export class ExportNamedDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ExportNamedDeclaration") } - static createExportNamedDeclaration(source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration | undefined { + static createExportNamedDeclaration(source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiersLen)) } - static updateExportNamedDeclaration(original: ExportNamedDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration | undefined { + static updateExportNamedDeclaration(original: ExportNamedDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { return new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiersLen)) } - static create1ExportNamedDeclaration(decl: AstNode | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration | undefined { + static create1ExportNamedDeclaration(decl: AstNode | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration1(global.context, passNode(decl), passNodeArray(specifiers), specifiersLen)) } - static update1ExportNamedDeclaration(original: ExportNamedDeclaration | undefined, decl: AstNode | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration | undefined { + static update1ExportNamedDeclaration(original: ExportNamedDeclaration | undefined, decl: AstNode | undefined, specifiers: readonly ExportSpecifier[], specifiersLen: number): ExportNamedDeclaration { return new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration1(global.context, passNode(original), passNode(decl), passNodeArray(specifiers), specifiersLen)) } - static create2ExportNamedDeclaration(decl?: AstNode): ExportNamedDeclaration | undefined { + static create2ExportNamedDeclaration(decl?: AstNode): ExportNamedDeclaration { return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration2(global.context, passNode(decl))) } - static update2ExportNamedDeclaration(original?: ExportNamedDeclaration, decl?: AstNode): ExportNamedDeclaration | undefined { + static update2ExportNamedDeclaration(original?: ExportNamedDeclaration, decl?: AstNode): ExportNamedDeclaration { return new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration2(global.context, passNode(original), passNode(decl))) } get declConst(): AstNode | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts index 1f11d0bfe..e5a2f111d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExportSpecifier.ts @@ -35,10 +35,10 @@ export class ExportSpecifier extends Statement { super(pointer) console.warn("Warning: stub node ExportSpecifier") } - static createExportSpecifier(local?: Identifier, exported?: Identifier): ExportSpecifier | undefined { + static createExportSpecifier(local?: Identifier, exported?: Identifier): ExportSpecifier { return new ExportSpecifier(global.generatedEs2panda._CreateExportSpecifier(global.context, passNode(local), passNode(exported))) } - static updateExportSpecifier(original?: ExportSpecifier, local?: Identifier, exported?: Identifier): ExportSpecifier | undefined { + static updateExportSpecifier(original?: ExportSpecifier, local?: Identifier, exported?: Identifier): ExportSpecifier { return new ExportSpecifier(global.generatedEs2panda._UpdateExportSpecifier(global.context, passNode(original), passNode(local), passNode(exported))) } get localConst(): Identifier | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts index f91dc0b6d..e5df62dc1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ExpressionStatement.ts @@ -35,10 +35,10 @@ export class ExpressionStatement extends Statement { super(pointer) console.warn("Warning: stub node ExpressionStatement") } - static createExpressionStatement(expr?: Expression): ExpressionStatement | undefined { + static createExpressionStatement(expr?: Expression): ExpressionStatement { return new ExpressionStatement(global.generatedEs2panda._CreateExpressionStatement(global.context, passNode(expr))) } - static updateExpressionStatement(original?: ExpressionStatement, expr?: Expression): ExpressionStatement | undefined { + static updateExpressionStatement(original?: ExpressionStatement, expr?: Expression): ExpressionStatement { return new ExpressionStatement(global.generatedEs2panda._UpdateExpressionStatement(global.context, passNode(original), passNode(expr))) } get getExpressionConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts index a7ed67609..a1e8986a6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionDeclaration.ts @@ -36,16 +36,16 @@ export class FunctionDeclaration extends Statement { super(pointer) console.warn("Warning: stub node FunctionDeclaration") } - static createFunctionDeclaration(func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration | undefined { + static createFunctionDeclaration(func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration { return new FunctionDeclaration(global.generatedEs2panda._CreateFunctionDeclaration(global.context, passNode(func), passNodeArray(annotations), annotationsLen, isAnonymous)) } - static updateFunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration | undefined { + static updateFunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], annotationsLen: number, isAnonymous: boolean): FunctionDeclaration { return new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration(global.context, passNode(original), passNode(func), passNodeArray(annotations), annotationsLen, isAnonymous)) } - static create1FunctionDeclaration(func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration | undefined { + static create1FunctionDeclaration(func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration { return new FunctionDeclaration(global.generatedEs2panda._CreateFunctionDeclaration1(global.context, passNode(func), isAnonymous)) } - static update1FunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration | undefined { + static update1FunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration { return new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration1(global.context, passNode(original), passNode(func), isAnonymous)) } get function(): ScriptFunction | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts index 86b988839..44ad0227a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/FunctionExpression.ts @@ -36,16 +36,16 @@ export class FunctionExpression extends Expression { super(pointer) console.warn("Warning: stub node FunctionExpression") } - static createFunctionExpression(func?: ScriptFunction): FunctionExpression | undefined { + static createFunctionExpression(func?: ScriptFunction): FunctionExpression { return new FunctionExpression(global.generatedEs2panda._CreateFunctionExpression(global.context, passNode(func))) } - static updateFunctionExpression(original?: FunctionExpression, func?: ScriptFunction): FunctionExpression | undefined { + static updateFunctionExpression(original?: FunctionExpression, func?: ScriptFunction): FunctionExpression { return new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression(global.context, passNode(original), passNode(func))) } - static create1FunctionExpression(namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression | undefined { + static create1FunctionExpression(namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression { return new FunctionExpression(global.generatedEs2panda._CreateFunctionExpression1(global.context, passNode(namedExpr), passNode(func))) } - static update1FunctionExpression(original?: FunctionExpression, namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression | undefined { + static update1FunctionExpression(original?: FunctionExpression, namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression { return new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression1(global.context, passNode(original), passNode(namedExpr), passNode(func))) } get functionConst(): ScriptFunction | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts b/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts index 5a7a409c0..f1962692d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Identifier.ts @@ -36,22 +36,22 @@ export class Identifier extends AnnotatedExpression { super(pointer) console.warn("Warning: stub node Identifier") } - static createIdentifier(): Identifier | undefined { + static createIdentifier(): Identifier { return new Identifier(global.generatedEs2panda._CreateIdentifier(global.context)) } - static updateIdentifier(original?: Identifier): Identifier | undefined { + static updateIdentifier(original?: Identifier): Identifier { return new Identifier(global.generatedEs2panda._UpdateIdentifier(global.context, passNode(original))) } - static create1Identifier(name: string): Identifier | undefined { + static create1Identifier(name: string): Identifier { return new Identifier(global.generatedEs2panda._CreateIdentifier1(global.context, name)) } - static update1Identifier(original: Identifier | undefined, name: string): Identifier | undefined { + static update1Identifier(original: Identifier | undefined, name: string): Identifier { return new Identifier(global.generatedEs2panda._UpdateIdentifier1(global.context, passNode(original), name)) } - static create2Identifier(name: string, typeAnnotation?: TypeNode): Identifier | undefined { + static create2Identifier(name: string, typeAnnotation?: TypeNode): Identifier { return new Identifier(global.generatedEs2panda._CreateIdentifier2(global.context, name, passNode(typeAnnotation))) } - static update2Identifier(original: Identifier | undefined, name: string, typeAnnotation?: TypeNode): Identifier | undefined { + static update2Identifier(original: Identifier | undefined, name: string, typeAnnotation?: TypeNode): Identifier { return new Identifier(global.generatedEs2panda._UpdateIdentifier2(global.context, passNode(original), name, passNode(typeAnnotation))) } get nameConst(): string { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts index d655c481d..8426d022d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportDeclaration.ts @@ -36,10 +36,10 @@ export class ImportDeclaration extends Statement { super(pointer) console.warn("Warning: stub node ImportDeclaration") } - static createImportDeclaration(source: StringLiteral | undefined, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration | undefined { + static createImportDeclaration(source: StringLiteral | undefined, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration { return new ImportDeclaration(global.generatedEs2panda._CreateImportDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiersLen, importKind)) } - static updateImportDeclaration(original: ImportDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration | undefined { + static updateImportDeclaration(original: ImportDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly AstNode[], specifiersLen: number, importKind: Es2pandaImportKinds): ImportDeclaration { return new ImportDeclaration(global.generatedEs2panda._UpdateImportDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiersLen, importKind)) } get sourceConst(): StringLiteral | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts index 336b81eef..d0e1af481 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportDefaultSpecifier.ts @@ -35,10 +35,10 @@ export class ImportDefaultSpecifier extends Statement { super(pointer) console.warn("Warning: stub node ImportDefaultSpecifier") } - static createImportDefaultSpecifier(local?: Identifier): ImportDefaultSpecifier | undefined { + static createImportDefaultSpecifier(local?: Identifier): ImportDefaultSpecifier { return new ImportDefaultSpecifier(global.generatedEs2panda._CreateImportDefaultSpecifier(global.context, passNode(local))) } - static updateImportDefaultSpecifier(original?: ImportDefaultSpecifier, local?: Identifier): ImportDefaultSpecifier | undefined { + static updateImportDefaultSpecifier(original?: ImportDefaultSpecifier, local?: Identifier): ImportDefaultSpecifier { return new ImportDefaultSpecifier(global.generatedEs2panda._UpdateImportDefaultSpecifier(global.context, passNode(original), passNode(local))) } get localConst(): Identifier | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts index b81ea4a4d..239332713 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportExpression.ts @@ -34,10 +34,10 @@ export class ImportExpression extends Expression { super(pointer) console.warn("Warning: stub node ImportExpression") } - static createImportExpression(source?: Expression): ImportExpression | undefined { + static createImportExpression(source?: Expression): ImportExpression { return new ImportExpression(global.generatedEs2panda._CreateImportExpression(global.context, passNode(source))) } - static updateImportExpression(original?: ImportExpression, source?: Expression): ImportExpression | undefined { + static updateImportExpression(original?: ImportExpression, source?: Expression): ImportExpression { return new ImportExpression(global.generatedEs2panda._UpdateImportExpression(global.context, passNode(original), passNode(source))) } get source(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts index 4e60b59b9..8f31b6bdd 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts @@ -35,10 +35,10 @@ export class ImportNamespaceSpecifier extends Statement { super(pointer) console.warn("Warning: stub node ImportNamespaceSpecifier") } - static createImportNamespaceSpecifier(local?: Identifier): ImportNamespaceSpecifier | undefined { + static createImportNamespaceSpecifier(local?: Identifier): ImportNamespaceSpecifier { return new ImportNamespaceSpecifier(global.generatedEs2panda._CreateImportNamespaceSpecifier(global.context, passNode(local))) } - static updateImportNamespaceSpecifier(original?: ImportNamespaceSpecifier, local?: Identifier): ImportNamespaceSpecifier | undefined { + static updateImportNamespaceSpecifier(original?: ImportNamespaceSpecifier, local?: Identifier): ImportNamespaceSpecifier { return new ImportNamespaceSpecifier(global.generatedEs2panda._UpdateImportNamespaceSpecifier(global.context, passNode(original), passNode(local))) } get local(): Identifier | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts b/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts index 4a0994258..ed85cc9ff 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ImportSpecifier.ts @@ -35,10 +35,10 @@ export class ImportSpecifier extends Statement { super(pointer) console.warn("Warning: stub node ImportSpecifier") } - static createImportSpecifier(imported?: Identifier, local?: Identifier): ImportSpecifier | undefined { + static createImportSpecifier(imported?: Identifier, local?: Identifier): ImportSpecifier { return new ImportSpecifier(global.generatedEs2panda._CreateImportSpecifier(global.context, passNode(imported), passNode(local))) } - static updateImportSpecifier(original?: ImportSpecifier, imported?: Identifier, local?: Identifier): ImportSpecifier | undefined { + static updateImportSpecifier(original?: ImportSpecifier, imported?: Identifier, local?: Identifier): ImportSpecifier { return new ImportSpecifier(global.generatedEs2panda._UpdateImportSpecifier(global.context, passNode(original), passNode(imported), passNode(local))) } get imported(): Identifier | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts index 6528a6e1a..f37fa993b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MemberExpression.ts @@ -36,10 +36,10 @@ export class MemberExpression extends MaybeOptionalExpression { super(pointer) console.warn("Warning: stub node MemberExpression") } - static createMemberExpression(object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression | undefined { + static createMemberExpression(object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression { return new MemberExpression(global.generatedEs2panda._CreateMemberExpression(global.context, passNode(object_arg), passNode(property), kind, computed, optional_arg)) } - static updateMemberExpression(original: MemberExpression | undefined, object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression | undefined { + static updateMemberExpression(original: MemberExpression | undefined, object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression { return new MemberExpression(global.generatedEs2panda._UpdateMemberExpression(global.context, passNode(original), passNode(object_arg), passNode(property), kind, computed, optional_arg)) } get object(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts index aba6fefdd..4bb2da92c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MetaProperty.ts @@ -35,10 +35,10 @@ export class MetaProperty extends Expression { super(pointer) console.warn("Warning: stub node MetaProperty") } - static createMetaProperty(kind: Es2pandaMetaPropertyKind): MetaProperty | undefined { + static createMetaProperty(kind: Es2pandaMetaPropertyKind): MetaProperty { return new MetaProperty(global.generatedEs2panda._CreateMetaProperty(global.context, kind)) } - static updateMetaProperty(original: MetaProperty | undefined, kind: Es2pandaMetaPropertyKind): MetaProperty | undefined { + static updateMetaProperty(original: MetaProperty | undefined, kind: Es2pandaMetaPropertyKind): MetaProperty { return new MetaProperty(global.generatedEs2panda._UpdateMetaProperty(global.context, passNode(original), kind)) } get kindConst(): Es2pandaMetaPropertyKind { diff --git a/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts b/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts index b4e457114..060bfa53b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/MethodDefinition.ts @@ -37,10 +37,10 @@ export class MethodDefinition extends ClassElement { super(pointer) console.warn("Warning: stub node MethodDefinition") } - static createMethodDefinition(kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition | undefined { + static createMethodDefinition(kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition { return new MethodDefinition(global.generatedEs2panda._CreateMethodDefinition(global.context, kind, passNode(key), passNode(value), modifiers, isComputed)) } - static updateMethodDefinition(original: MethodDefinition | undefined, kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition | undefined { + static updateMethodDefinition(original: MethodDefinition | undefined, kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition { return new MethodDefinition(global.generatedEs2panda._UpdateMethodDefinition(global.context, passNode(original), kind, passNode(key), passNode(value), modifiers, isComputed)) } get kindConst(): Es2pandaMethodDefinitionKind { diff --git a/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts b/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts index 01a691a22..c94085776 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NamedType.ts @@ -36,10 +36,10 @@ export class NamedType extends TypeNode { super(pointer) console.warn("Warning: stub node NamedType") } - static createNamedType(name?: Identifier): NamedType | undefined { + static createNamedType(name?: Identifier): NamedType { return new NamedType(global.generatedEs2panda._CreateNamedType(global.context, passNode(name))) } - static updateNamedType(original?: NamedType, name?: Identifier): NamedType | undefined { + static updateNamedType(original?: NamedType, name?: Identifier): NamedType { return new NamedType(global.generatedEs2panda._UpdateNamedType(global.context, passNode(original), passNode(name))) } get nameConst(): Identifier | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts index 88ed0c1c0..a303f11b0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NewExpression.ts @@ -34,10 +34,10 @@ export class NewExpression extends Expression { super(pointer) console.warn("Warning: stub node NewExpression") } - static createNewExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): NewExpression | undefined { + static createNewExpression(callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): NewExpression { return new NewExpression(global.generatedEs2panda._CreateNewExpression(global.context, passNode(callee), passNodeArray(_arguments), argumentsLen)) } - static updateNewExpression(original: NewExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): NewExpression | undefined { + static updateNewExpression(original: NewExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], argumentsLen: number): NewExpression { return new NewExpression(global.generatedEs2panda._UpdateNewExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), argumentsLen)) } get calleeConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts index 831fe8324..138dca3e5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/NullLiteral.ts @@ -34,10 +34,10 @@ export class NullLiteral extends Literal { super(pointer) console.warn("Warning: stub node NullLiteral") } - static createNullLiteral(): NullLiteral | undefined { + static createNullLiteral(): NullLiteral { return new NullLiteral(global.generatedEs2panda._CreateNullLiteral(global.context)) } - static updateNullLiteral(original?: NullLiteral): NullLiteral | undefined { + static updateNullLiteral(original?: NullLiteral): NullLiteral { return new NullLiteral(global.generatedEs2panda._UpdateNullLiteral(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts index 63a037be2..0b7bb2292 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/OmittedExpression.ts @@ -34,10 +34,10 @@ export class OmittedExpression extends Expression { super(pointer) console.warn("Warning: stub node OmittedExpression") } - static createOmittedExpression(): OmittedExpression | undefined { + static createOmittedExpression(): OmittedExpression { return new OmittedExpression(global.generatedEs2panda._CreateOmittedExpression(global.context)) } - static updateOmittedExpression(original?: OmittedExpression): OmittedExpression | undefined { + static updateOmittedExpression(original?: OmittedExpression): OmittedExpression { return new OmittedExpression(global.generatedEs2panda._UpdateOmittedExpression(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts b/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts index b24192a52..402149a3b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/OpaqueTypeNode.ts @@ -34,10 +34,10 @@ export class OpaqueTypeNode extends TypeNode { super(pointer) console.warn("Warning: stub node OpaqueTypeNode") } - static create1OpaqueTypeNode(): OpaqueTypeNode | undefined { + static create1OpaqueTypeNode(): OpaqueTypeNode { return new OpaqueTypeNode(global.generatedEs2panda._CreateOpaqueTypeNode1(global.context)) } - static update1OpaqueTypeNode(original?: OpaqueTypeNode): OpaqueTypeNode | undefined { + static update1OpaqueTypeNode(original?: OpaqueTypeNode): OpaqueTypeNode { return new OpaqueTypeNode(global.generatedEs2panda._UpdateOpaqueTypeNode1(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts index 0b67dd535..0f0f3b40b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/PrefixAssertionExpression.ts @@ -35,10 +35,10 @@ export class PrefixAssertionExpression extends Expression { super(pointer) console.warn("Warning: stub node PrefixAssertionExpression") } - static createPrefixAssertionExpression(expr?: Expression, type?: TypeNode): PrefixAssertionExpression | undefined { + static createPrefixAssertionExpression(expr?: Expression, type?: TypeNode): PrefixAssertionExpression { return new PrefixAssertionExpression(global.generatedEs2panda._CreatePrefixAssertionExpression(global.context, passNode(expr), passNode(type))) } - static updatePrefixAssertionExpression(original?: PrefixAssertionExpression, expr?: Expression, type?: TypeNode): PrefixAssertionExpression | undefined { + static updatePrefixAssertionExpression(original?: PrefixAssertionExpression, expr?: Expression, type?: TypeNode): PrefixAssertionExpression { return new PrefixAssertionExpression(global.generatedEs2panda._UpdatePrefixAssertionExpression(global.context, passNode(original), passNode(expr), passNode(type))) } get exprConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/Property.ts b/arkoala-arkts/libarkts/src/generated/peers/Property.ts index cfb988e2a..79ad82d32 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/Property.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/Property.ts @@ -35,16 +35,16 @@ export class Property extends Expression { super(pointer) console.warn("Warning: stub node Property") } - static createProperty(key?: Expression, value?: Expression): Property | undefined { + static createProperty(key?: Expression, value?: Expression): Property { return new Property(global.generatedEs2panda._CreateProperty(global.context, passNode(key), passNode(value))) } - static updateProperty(original?: Property, key?: Expression, value?: Expression): Property | undefined { + static updateProperty(original?: Property, key?: Expression, value?: Expression): Property { return new Property(global.generatedEs2panda._UpdateProperty(global.context, passNode(original), passNode(key), passNode(value))) } - static create1Property(kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property | undefined { + static create1Property(kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property { return new Property(global.generatedEs2panda._CreateProperty1(global.context, kind, passNode(key), passNode(value), isMethod, isComputed)) } - static update1Property(original: Property | undefined, kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property | undefined { + static update1Property(original: Property | undefined, kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property { return new Property(global.generatedEs2panda._UpdateProperty1(global.context, passNode(original), kind, passNode(key), passNode(value), isMethod, isComputed)) } get key(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts index ec60b7314..e5d7aca88 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/RegExpLiteral.ts @@ -35,10 +35,10 @@ export class RegExpLiteral extends Literal { super(pointer) console.warn("Warning: stub node RegExpLiteral") } - static createRegExpLiteral(pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral | undefined { + static createRegExpLiteral(pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral { return new RegExpLiteral(global.generatedEs2panda._CreateRegExpLiteral(global.context, pattern, flags, flagsStr)) } - static updateRegExpLiteral(original: RegExpLiteral | undefined, pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral | undefined { + static updateRegExpLiteral(original: RegExpLiteral | undefined, pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral { return new RegExpLiteral(global.generatedEs2panda._UpdateRegExpLiteral(global.context, passNode(original), pattern, flags, flagsStr)) } get patternConst(): string { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts index f544d98c0..066ed62b6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ReturnStatement.ts @@ -35,16 +35,16 @@ export class ReturnStatement extends Statement { super(pointer) console.warn("Warning: stub node ReturnStatement") } - static createReturnStatement(): ReturnStatement | undefined { + static createReturnStatement(): ReturnStatement { return new ReturnStatement(global.generatedEs2panda._CreateReturnStatement(global.context)) } - static updateReturnStatement(original?: ReturnStatement): ReturnStatement | undefined { + static updateReturnStatement(original?: ReturnStatement): ReturnStatement { return new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement(global.context, passNode(original))) } - static create1ReturnStatement(argument?: Expression): ReturnStatement | undefined { + static create1ReturnStatement(argument?: Expression): ReturnStatement { return new ReturnStatement(global.generatedEs2panda._CreateReturnStatement1(global.context, passNode(argument))) } - static update1ReturnStatement(original?: ReturnStatement, argument?: Expression): ReturnStatement | undefined { + static update1ReturnStatement(original?: ReturnStatement, argument?: Expression): ReturnStatement { return new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement1(global.context, passNode(original), passNode(argument))) } get argument(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts index f636a3609..db6bbc5e5 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SequenceExpression.ts @@ -34,10 +34,10 @@ export class SequenceExpression extends Expression { super(pointer) console.warn("Warning: stub node SequenceExpression") } - static createSequenceExpression(sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression | undefined { + static createSequenceExpression(sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression { return new SequenceExpression(global.generatedEs2panda._CreateSequenceExpression(global.context, passNodeArray(sequence_arg), sequenceLen)) } - static updateSequenceExpression(original: SequenceExpression | undefined, sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression | undefined { + static updateSequenceExpression(original: SequenceExpression | undefined, sequence_arg: readonly Expression[], sequenceLen: number): SequenceExpression { return new SequenceExpression(global.generatedEs2panda._UpdateSequenceExpression(global.context, passNode(original), passNodeArray(sequence_arg), sequenceLen)) } get sequenceConst(): readonly Expression[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts index e1fb6c668..877d51956 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/StringLiteral.ts @@ -34,13 +34,13 @@ export class StringLiteral extends Literal { super(pointer) console.warn("Warning: stub node StringLiteral") } - static updateStringLiteral(original?: StringLiteral): StringLiteral | undefined { + static updateStringLiteral(original?: StringLiteral): StringLiteral { return new StringLiteral(global.generatedEs2panda._UpdateStringLiteral(global.context, passNode(original))) } - static create1StringLiteral(str: string): StringLiteral | undefined { + static create1StringLiteral(str: string): StringLiteral { return new StringLiteral(global.generatedEs2panda._CreateStringLiteral1(global.context, str)) } - static update1StringLiteral(original: StringLiteral | undefined, str: string): StringLiteral | undefined { + static update1StringLiteral(original: StringLiteral | undefined, str: string): StringLiteral { return new StringLiteral(global.generatedEs2panda._UpdateStringLiteral1(global.context, passNode(original), str)) } get strConst(): string { diff --git a/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts index 4552c4463..7257a67a9 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SuperExpression.ts @@ -34,10 +34,10 @@ export class SuperExpression extends Expression { super(pointer) console.warn("Warning: stub node SuperExpression") } - static createSuperExpression(): SuperExpression | undefined { + static createSuperExpression(): SuperExpression { return new SuperExpression(global.generatedEs2panda._CreateSuperExpression(global.context)) } - static updateSuperExpression(original?: SuperExpression): SuperExpression | undefined { + static updateSuperExpression(original?: SuperExpression): SuperExpression { return new SuperExpression(global.generatedEs2panda._UpdateSuperExpression(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts index 92046a01f..e2dec7709 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/SwitchStatement.ts @@ -36,10 +36,10 @@ export class SwitchStatement extends Statement { super(pointer) console.warn("Warning: stub node SwitchStatement") } - static createSwitchStatement(discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement | undefined { + static createSwitchStatement(discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement { return new SwitchStatement(global.generatedEs2panda._CreateSwitchStatement(global.context, passNode(discriminant), passNodeArray(cases), casesLen)) } - static updateSwitchStatement(original: SwitchStatement | undefined, discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement | undefined { + static updateSwitchStatement(original: SwitchStatement | undefined, discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[], casesLen: number): SwitchStatement { return new SwitchStatement(global.generatedEs2panda._UpdateSwitchStatement(global.context, passNode(original), passNode(discriminant), passNodeArray(cases), casesLen)) } get discriminantConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts index 2390a90a2..0554e0ec0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSAnyKeyword.ts @@ -34,10 +34,10 @@ export class TSAnyKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSAnyKeyword") } - static createTSAnyKeyword(): TSAnyKeyword | undefined { + static createTSAnyKeyword(): TSAnyKeyword { return new TSAnyKeyword(global.generatedEs2panda._CreateTSAnyKeyword(global.context)) } - static updateTSAnyKeyword(original?: TSAnyKeyword): TSAnyKeyword | undefined { + static updateTSAnyKeyword(original?: TSAnyKeyword): TSAnyKeyword { return new TSAnyKeyword(global.generatedEs2panda._UpdateTSAnyKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts index d3d817d8c..5b83f3e2e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSArrayType.ts @@ -34,10 +34,10 @@ export class TSArrayType extends TypeNode { super(pointer) console.warn("Warning: stub node TSArrayType") } - static createTSArrayType(elementType?: TypeNode): TSArrayType | undefined { + static createTSArrayType(elementType?: TypeNode): TSArrayType { return new TSArrayType(global.generatedEs2panda._CreateTSArrayType(global.context, passNode(elementType))) } - static updateTSArrayType(original?: TSArrayType, elementType?: TypeNode): TSArrayType | undefined { + static updateTSArrayType(original?: TSArrayType, elementType?: TypeNode): TSArrayType { return new TSArrayType(global.generatedEs2panda._UpdateTSArrayType(global.context, passNode(original), passNode(elementType))) } get elementTypeConst(): TypeNode | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts index 4a4ecdb61..e2e94a689 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSAsExpression.ts @@ -36,10 +36,10 @@ export class TSAsExpression extends AnnotatedExpression { super(pointer) console.warn("Warning: stub node TSAsExpression") } - static createTSAsExpression(expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression | undefined { + static createTSAsExpression(expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression { return new TSAsExpression(global.generatedEs2panda._CreateTSAsExpression(global.context, passNode(expression), passNode(typeAnnotation), isConst)) } - static updateTSAsExpression(original: TSAsExpression | undefined, expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression | undefined { + static updateTSAsExpression(original: TSAsExpression | undefined, expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression { return new TSAsExpression(global.generatedEs2panda._UpdateTSAsExpression(global.context, passNode(original), passNode(expression), passNode(typeAnnotation), isConst)) } get exprConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts index 4c06a44b5..7b09d8a02 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSBigintKeyword.ts @@ -34,10 +34,10 @@ export class TSBigintKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSBigintKeyword") } - static createTSBigintKeyword(): TSBigintKeyword | undefined { + static createTSBigintKeyword(): TSBigintKeyword { return new TSBigintKeyword(global.generatedEs2panda._CreateTSBigintKeyword(global.context)) } - static updateTSBigintKeyword(original?: TSBigintKeyword): TSBigintKeyword | undefined { + static updateTSBigintKeyword(original?: TSBigintKeyword): TSBigintKeyword { return new TSBigintKeyword(global.generatedEs2panda._UpdateTSBigintKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts index 5b49168cb..f5310ed5f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSBooleanKeyword.ts @@ -34,10 +34,10 @@ export class TSBooleanKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSBooleanKeyword") } - static createTSBooleanKeyword(): TSBooleanKeyword | undefined { + static createTSBooleanKeyword(): TSBooleanKeyword { return new TSBooleanKeyword(global.generatedEs2panda._CreateTSBooleanKeyword(global.context)) } - static updateTSBooleanKeyword(original?: TSBooleanKeyword): TSBooleanKeyword | undefined { + static updateTSBooleanKeyword(original?: TSBooleanKeyword): TSBooleanKeyword { return new TSBooleanKeyword(global.generatedEs2panda._UpdateTSBooleanKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts b/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts index 11e237d6b..2580d32a6 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSClassImplements.ts @@ -35,16 +35,16 @@ export class TSClassImplements extends Expression { super(pointer) console.warn("Warning: stub node TSClassImplements") } - static createTSClassImplements(expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements | undefined { + static createTSClassImplements(expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements { return new TSClassImplements(global.generatedEs2panda._CreateTSClassImplements(global.context, passNode(expression), passNode(typeParameters))) } - static updateTSClassImplements(original?: TSClassImplements, expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements | undefined { + static updateTSClassImplements(original?: TSClassImplements, expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements { return new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements(global.context, passNode(original), passNode(expression), passNode(typeParameters))) } - static create1TSClassImplements(expression?: Expression): TSClassImplements | undefined { + static create1TSClassImplements(expression?: Expression): TSClassImplements { return new TSClassImplements(global.generatedEs2panda._CreateTSClassImplements1(global.context, passNode(expression))) } - static update1TSClassImplements(original?: TSClassImplements, expression?: Expression): TSClassImplements | undefined { + static update1TSClassImplements(original?: TSClassImplements, expression?: Expression): TSClassImplements { return new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements1(global.context, passNode(original), passNode(expression))) } get expr(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts index e59021171..d65e3496c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSConditionalType.ts @@ -35,10 +35,10 @@ export class TSConditionalType extends TypeNode { super(pointer) console.warn("Warning: stub node TSConditionalType") } - static createTSConditionalType(checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType | undefined { + static createTSConditionalType(checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType { return new TSConditionalType(global.generatedEs2panda._CreateTSConditionalType(global.context, passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType))) } - static updateTSConditionalType(original?: TSConditionalType, checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType | undefined { + static updateTSConditionalType(original?: TSConditionalType, checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType { return new TSConditionalType(global.generatedEs2panda._UpdateTSConditionalType(global.context, passNode(original), passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType))) } get checkTypeConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts index 247ba42ec..a53d96c14 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSEnumDeclaration.ts @@ -37,10 +37,10 @@ export class TSEnumDeclaration extends TypedStatement { super(pointer) console.warn("Warning: stub node TSEnumDeclaration") } - static createTSEnumDeclaration(key: Identifier | undefined, members: readonly AstNode[], membersLen: number, isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration | undefined { + static createTSEnumDeclaration(key: Identifier | undefined, members: readonly AstNode[], membersLen: number, isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration { return new TSEnumDeclaration(global.generatedEs2panda._CreateTSEnumDeclaration(global.context, passNode(key), passNodeArray(members), membersLen, isConst, isStatic, isDeclare)) } - static updateTSEnumDeclaration(original: TSEnumDeclaration | undefined, key: Identifier | undefined, members: readonly AstNode[], membersLen: number, isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration | undefined { + static updateTSEnumDeclaration(original: TSEnumDeclaration | undefined, key: Identifier | undefined, members: readonly AstNode[], membersLen: number, isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration { return new TSEnumDeclaration(global.generatedEs2panda._UpdateTSEnumDeclaration(global.context, passNode(original), passNode(key), passNodeArray(members), membersLen, isConst, isStatic, isDeclare)) } get keyConst(): Identifier | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts b/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts index 089827e0a..2dada9d1d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSEnumMember.ts @@ -35,16 +35,16 @@ export class TSEnumMember extends Statement { super(pointer) console.warn("Warning: stub node TSEnumMember") } - static createTSEnumMember(key?: Expression, init?: Expression): TSEnumMember | undefined { + static createTSEnumMember(key?: Expression, init?: Expression): TSEnumMember { return new TSEnumMember(global.generatedEs2panda._CreateTSEnumMember(global.context, passNode(key), passNode(init))) } - static updateTSEnumMember(original?: TSEnumMember, key?: Expression, init?: Expression): TSEnumMember | undefined { + static updateTSEnumMember(original?: TSEnumMember, key?: Expression, init?: Expression): TSEnumMember { return new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember(global.context, passNode(original), passNode(key), passNode(init))) } - static create1TSEnumMember(key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember | undefined { + static create1TSEnumMember(key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember { return new TSEnumMember(global.generatedEs2panda._CreateTSEnumMember1(global.context, passNode(key), passNode(init), isGenerated)) } - static update1TSEnumMember(original: TSEnumMember | undefined, key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember | undefined { + static update1TSEnumMember(original: TSEnumMember | undefined, key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember { return new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember1(global.context, passNode(original), passNode(key), passNode(init), isGenerated)) } get keyConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts b/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts index 24015578b..09292e1a8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSExternalModuleReference.ts @@ -34,10 +34,10 @@ export class TSExternalModuleReference extends Expression { super(pointer) console.warn("Warning: stub node TSExternalModuleReference") } - static createTSExternalModuleReference(expr?: Expression): TSExternalModuleReference | undefined { + static createTSExternalModuleReference(expr?: Expression): TSExternalModuleReference { return new TSExternalModuleReference(global.generatedEs2panda._CreateTSExternalModuleReference(global.context, passNode(expr))) } - static updateTSExternalModuleReference(original?: TSExternalModuleReference, expr?: Expression): TSExternalModuleReference | undefined { + static updateTSExternalModuleReference(original?: TSExternalModuleReference, expr?: Expression): TSExternalModuleReference { return new TSExternalModuleReference(global.generatedEs2panda._UpdateTSExternalModuleReference(global.context, passNode(original), passNode(expr))) } get exprConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts index 8d5dcfacc..4439807d1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts @@ -36,10 +36,10 @@ export class TSImportEqualsDeclaration extends Statement { super(pointer) console.warn("Warning: stub node TSImportEqualsDeclaration") } - static createTSImportEqualsDeclaration(id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration | undefined { + static createTSImportEqualsDeclaration(id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration { return new TSImportEqualsDeclaration(global.generatedEs2panda._CreateTSImportEqualsDeclaration(global.context, passNode(id), passNode(moduleReference), isExport)) } - static updateTSImportEqualsDeclaration(original: TSImportEqualsDeclaration | undefined, id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration | undefined { + static updateTSImportEqualsDeclaration(original: TSImportEqualsDeclaration | undefined, id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration { return new TSImportEqualsDeclaration(global.generatedEs2panda._UpdateTSImportEqualsDeclaration(global.context, passNode(original), passNode(id), passNode(moduleReference), isExport)) } get idConst(): Identifier | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts index bb821894a..01cce7661 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSImportType.ts @@ -36,10 +36,10 @@ export class TSImportType extends TypeNode { super(pointer) console.warn("Warning: stub node TSImportType") } - static createTSImportType(param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType | undefined { + static createTSImportType(param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType { return new TSImportType(global.generatedEs2panda._CreateTSImportType(global.context, passNode(param), passNode(typeParams), passNode(qualifier), isTypeof)) } - static updateTSImportType(original: TSImportType | undefined, param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType | undefined { + static updateTSImportType(original: TSImportType | undefined, param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType { return new TSImportType(global.generatedEs2panda._UpdateTSImportType(global.context, passNode(original), passNode(param), passNode(typeParams), passNode(qualifier), isTypeof)) } get paramConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts index d8762b0f5..cc1ae8a70 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIndexSignature.ts @@ -36,10 +36,10 @@ export class TSIndexSignature extends TypedAstNode { super(pointer) console.warn("Warning: stub node TSIndexSignature") } - static createTSIndexSignature(param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature | undefined { + static createTSIndexSignature(param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature { return new TSIndexSignature(global.generatedEs2panda._CreateTSIndexSignature(global.context, passNode(param), passNode(typeAnnotation), readonly_arg)) } - static updateTSIndexSignature(original: TSIndexSignature | undefined, param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature | undefined { + static updateTSIndexSignature(original: TSIndexSignature | undefined, param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature { return new TSIndexSignature(global.generatedEs2panda._UpdateTSIndexSignature(global.context, passNode(original), passNode(param), passNode(typeAnnotation), readonly_arg)) } get paramConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts index 37cd54b06..3a4735dc7 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIndexedAccessType.ts @@ -34,10 +34,10 @@ export class TSIndexedAccessType extends TypeNode { super(pointer) console.warn("Warning: stub node TSIndexedAccessType") } - static createTSIndexedAccessType(objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType | undefined { + static createTSIndexedAccessType(objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType { return new TSIndexedAccessType(global.generatedEs2panda._CreateTSIndexedAccessType(global.context, passNode(objectType), passNode(indexType))) } - static updateTSIndexedAccessType(original?: TSIndexedAccessType, objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType | undefined { + static updateTSIndexedAccessType(original?: TSIndexedAccessType, objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType { return new TSIndexedAccessType(global.generatedEs2panda._UpdateTSIndexedAccessType(global.context, passNode(original), passNode(objectType), passNode(indexType))) } get objectTypeConst(): TypeNode | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts index e305bf923..fd155eb76 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInferType.ts @@ -35,10 +35,10 @@ export class TSInferType extends TypeNode { super(pointer) console.warn("Warning: stub node TSInferType") } - static createTSInferType(typeParam?: TSTypeParameter): TSInferType | undefined { + static createTSInferType(typeParam?: TSTypeParameter): TSInferType { return new TSInferType(global.generatedEs2panda._CreateTSInferType(global.context, passNode(typeParam))) } - static updateTSInferType(original?: TSInferType, typeParam?: TSTypeParameter): TSInferType | undefined { + static updateTSInferType(original?: TSInferType, typeParam?: TSTypeParameter): TSInferType { return new TSInferType(global.generatedEs2panda._UpdateTSInferType(global.context, passNode(original), passNode(typeParam))) } get typeParamConst(): TSTypeParameter | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts index 90f7004ee..73133678f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceBody.ts @@ -34,10 +34,10 @@ export class TSInterfaceBody extends Expression { super(pointer) console.warn("Warning: stub node TSInterfaceBody") } - static createTSInterfaceBody(body: readonly AstNode[], bodyLen: number): TSInterfaceBody | undefined { + static createTSInterfaceBody(body: readonly AstNode[], bodyLen: number): TSInterfaceBody { return new TSInterfaceBody(global.generatedEs2panda._CreateTSInterfaceBody(global.context, passNodeArray(body), bodyLen)) } - static updateTSInterfaceBody(original: TSInterfaceBody | undefined, body: readonly AstNode[], bodyLen: number): TSInterfaceBody | undefined { + static updateTSInterfaceBody(original: TSInterfaceBody | undefined, body: readonly AstNode[], bodyLen: number): TSInterfaceBody { return new TSInterfaceBody(global.generatedEs2panda._UpdateTSInterfaceBody(global.context, passNode(original), passNodeArray(body), bodyLen)) } get bodyPtr(): readonly AstNode[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts index ee2bb7383..d015665ef 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceDeclaration.ts @@ -41,10 +41,10 @@ export class TSInterfaceDeclaration extends TypedStatement { super(pointer) console.warn("Warning: stub node TSInterfaceDeclaration") } - static createTSInterfaceDeclaration(_extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration | undefined { + static createTSInterfaceDeclaration(_extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration { return new TSInterfaceDeclaration(global.generatedEs2panda._CreateTSInterfaceDeclaration(global.context, passNodeArray(_extends), extendsLen, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal)) } - static updateTSInterfaceDeclaration(original: TSInterfaceDeclaration | undefined, _extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration | undefined { + static updateTSInterfaceDeclaration(original: TSInterfaceDeclaration | undefined, _extends: readonly TSInterfaceHeritage[], extendsLen: number, id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration { return new TSInterfaceDeclaration(global.generatedEs2panda._UpdateTSInterfaceDeclaration(global.context, passNode(original), passNodeArray(_extends), extendsLen, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal)) } get body(): TSInterfaceBody | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts index f5e2b0fc4..8e59d11af 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSInterfaceHeritage.ts @@ -35,10 +35,10 @@ export class TSInterfaceHeritage extends Expression { super(pointer) console.warn("Warning: stub node TSInterfaceHeritage") } - static createTSInterfaceHeritage(expr?: TypeNode): TSInterfaceHeritage | undefined { + static createTSInterfaceHeritage(expr?: TypeNode): TSInterfaceHeritage { return new TSInterfaceHeritage(global.generatedEs2panda._CreateTSInterfaceHeritage(global.context, passNode(expr))) } - static updateTSInterfaceHeritage(original?: TSInterfaceHeritage, expr?: TypeNode): TSInterfaceHeritage | undefined { + static updateTSInterfaceHeritage(original?: TSInterfaceHeritage, expr?: TypeNode): TSInterfaceHeritage { return new TSInterfaceHeritage(global.generatedEs2panda._UpdateTSInterfaceHeritage(global.context, passNode(original), passNode(expr))) } get expr(): TypeNode | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts index f169e2791..b4f380718 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSIntersectionType.ts @@ -35,10 +35,10 @@ export class TSIntersectionType extends TypeNode { super(pointer) console.warn("Warning: stub node TSIntersectionType") } - static createTSIntersectionType(types: readonly Expression[], typesLen: number): TSIntersectionType | undefined { + static createTSIntersectionType(types: readonly Expression[], typesLen: number): TSIntersectionType { return new TSIntersectionType(global.generatedEs2panda._CreateTSIntersectionType(global.context, passNodeArray(types), typesLen)) } - static updateTSIntersectionType(original: TSIntersectionType | undefined, types: readonly Expression[], typesLen: number): TSIntersectionType | undefined { + static updateTSIntersectionType(original: TSIntersectionType | undefined, types: readonly Expression[], typesLen: number): TSIntersectionType { return new TSIntersectionType(global.generatedEs2panda._UpdateTSIntersectionType(global.context, passNode(original), passNodeArray(types), typesLen)) } get typesConst(): readonly Expression[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts index c42467791..514a5e1b8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSLiteralType.ts @@ -35,10 +35,10 @@ export class TSLiteralType extends TypeNode { super(pointer) console.warn("Warning: stub node TSLiteralType") } - static createTSLiteralType(literal?: Expression): TSLiteralType | undefined { + static createTSLiteralType(literal?: Expression): TSLiteralType { return new TSLiteralType(global.generatedEs2panda._CreateTSLiteralType(global.context, passNode(literal))) } - static updateTSLiteralType(original?: TSLiteralType, literal?: Expression): TSLiteralType | undefined { + static updateTSLiteralType(original?: TSLiteralType, literal?: Expression): TSLiteralType { return new TSLiteralType(global.generatedEs2panda._UpdateTSLiteralType(global.context, passNode(original), passNode(literal))) } get literalConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts index 1a55b5380..df7036c68 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSMappedType.ts @@ -36,10 +36,10 @@ export class TSMappedType extends TypeNode { super(pointer) console.warn("Warning: stub node TSMappedType") } - static createTSMappedType(typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType | undefined { + static createTSMappedType(typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType { return new TSMappedType(global.generatedEs2panda._CreateTSMappedType(global.context, passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg)) } - static updateTSMappedType(original: TSMappedType | undefined, typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType | undefined { + static updateTSMappedType(original: TSMappedType | undefined, typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType { return new TSMappedType(global.generatedEs2panda._UpdateTSMappedType(global.context, passNode(original), passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg)) } get typeParameter(): TSTypeParameter | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts index f1020d9b8..d71cc25a2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNamedTupleMember.ts @@ -35,10 +35,10 @@ export class TSNamedTupleMember extends TypeNode { super(pointer) console.warn("Warning: stub node TSNamedTupleMember") } - static createTSNamedTupleMember(label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember | undefined { + static createTSNamedTupleMember(label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember { return new TSNamedTupleMember(global.generatedEs2panda._CreateTSNamedTupleMember(global.context, passNode(label), passNode(elementType), optional_arg)) } - static updateTSNamedTupleMember(original: TSNamedTupleMember | undefined, label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember | undefined { + static updateTSNamedTupleMember(original: TSNamedTupleMember | undefined, label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember { return new TSNamedTupleMember(global.generatedEs2panda._UpdateTSNamedTupleMember(global.context, passNode(original), passNode(label), passNode(elementType), optional_arg)) } get labelConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts index 635f34a50..61a9a3eb2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNeverKeyword.ts @@ -34,10 +34,10 @@ export class TSNeverKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSNeverKeyword") } - static createTSNeverKeyword(): TSNeverKeyword | undefined { + static createTSNeverKeyword(): TSNeverKeyword { return new TSNeverKeyword(global.generatedEs2panda._CreateTSNeverKeyword(global.context)) } - static updateTSNeverKeyword(original?: TSNeverKeyword): TSNeverKeyword | undefined { + static updateTSNeverKeyword(original?: TSNeverKeyword): TSNeverKeyword { return new TSNeverKeyword(global.generatedEs2panda._UpdateTSNeverKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts index 5bd56f711..a154667c2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNonNullExpression.ts @@ -34,10 +34,10 @@ export class TSNonNullExpression extends Expression { super(pointer) console.warn("Warning: stub node TSNonNullExpression") } - static createTSNonNullExpression(expr?: Expression): TSNonNullExpression | undefined { + static createTSNonNullExpression(expr?: Expression): TSNonNullExpression { return new TSNonNullExpression(global.generatedEs2panda._CreateTSNonNullExpression(global.context, passNode(expr))) } - static updateTSNonNullExpression(original?: TSNonNullExpression, expr?: Expression): TSNonNullExpression | undefined { + static updateTSNonNullExpression(original?: TSNonNullExpression, expr?: Expression): TSNonNullExpression { return new TSNonNullExpression(global.generatedEs2panda._UpdateTSNonNullExpression(global.context, passNode(original), passNode(expr))) } get exprConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts index a2025727f..a338f0527 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNullKeyword.ts @@ -34,10 +34,10 @@ export class TSNullKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSNullKeyword") } - static createTSNullKeyword(): TSNullKeyword | undefined { + static createTSNullKeyword(): TSNullKeyword { return new TSNullKeyword(global.generatedEs2panda._CreateTSNullKeyword(global.context)) } - static updateTSNullKeyword(original?: TSNullKeyword): TSNullKeyword | undefined { + static updateTSNullKeyword(original?: TSNullKeyword): TSNullKeyword { return new TSNullKeyword(global.generatedEs2panda._UpdateTSNullKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts index 2d791b858..ef48ea57c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSNumberKeyword.ts @@ -34,10 +34,10 @@ export class TSNumberKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSNumberKeyword") } - static createTSNumberKeyword(): TSNumberKeyword | undefined { + static createTSNumberKeyword(): TSNumberKeyword { return new TSNumberKeyword(global.generatedEs2panda._CreateTSNumberKeyword(global.context)) } - static updateTSNumberKeyword(original?: TSNumberKeyword): TSNumberKeyword | undefined { + static updateTSNumberKeyword(original?: TSNumberKeyword): TSNumberKeyword { return new TSNumberKeyword(global.generatedEs2panda._UpdateTSNumberKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts index 569106312..f8bfb3d1e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSObjectKeyword.ts @@ -34,10 +34,10 @@ export class TSObjectKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSObjectKeyword") } - static createTSObjectKeyword(): TSObjectKeyword | undefined { + static createTSObjectKeyword(): TSObjectKeyword { return new TSObjectKeyword(global.generatedEs2panda._CreateTSObjectKeyword(global.context)) } - static updateTSObjectKeyword(original?: TSObjectKeyword): TSObjectKeyword | undefined { + static updateTSObjectKeyword(original?: TSObjectKeyword): TSObjectKeyword { return new TSObjectKeyword(global.generatedEs2panda._UpdateTSObjectKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts b/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts index 940c8aa53..18d1991d8 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSParameterProperty.ts @@ -35,10 +35,10 @@ export class TSParameterProperty extends Expression { super(pointer) console.warn("Warning: stub node TSParameterProperty") } - static createTSParameterProperty(accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty | undefined { + static createTSParameterProperty(accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty { return new TSParameterProperty(global.generatedEs2panda._CreateTSParameterProperty(global.context, accessibility, passNode(parameter), readonly_arg, isStatic, isExport)) } - static updateTSParameterProperty(original: TSParameterProperty | undefined, accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty | undefined { + static updateTSParameterProperty(original: TSParameterProperty | undefined, accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty { return new TSParameterProperty(global.generatedEs2panda._UpdateTSParameterProperty(global.context, passNode(original), accessibility, passNode(parameter), readonly_arg, isStatic, isExport)) } get accessibilityConst(): Es2pandaAccessibilityOption { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts index 4bfbedf07..cdfc0257e 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSParenthesizedType.ts @@ -35,10 +35,10 @@ export class TSParenthesizedType extends TypeNode { super(pointer) console.warn("Warning: stub node TSParenthesizedType") } - static createTSParenthesizedType(type?: TypeNode): TSParenthesizedType | undefined { + static createTSParenthesizedType(type?: TypeNode): TSParenthesizedType { return new TSParenthesizedType(global.generatedEs2panda._CreateTSParenthesizedType(global.context, passNode(type))) } - static updateTSParenthesizedType(original?: TSParenthesizedType, type?: TypeNode): TSParenthesizedType | undefined { + static updateTSParenthesizedType(original?: TSParenthesizedType, type?: TypeNode): TSParenthesizedType { return new TSParenthesizedType(global.generatedEs2panda._UpdateTSParenthesizedType(global.context, passNode(original), passNode(type))) } get typeConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts b/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts index 528b234b1..fb9f0eead 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSPropertySignature.ts @@ -36,10 +36,10 @@ export class TSPropertySignature extends AnnotatedAstNode { super(pointer) console.warn("Warning: stub node TSPropertySignature") } - static createTSPropertySignature(key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature | undefined { + static createTSPropertySignature(key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature { return new TSPropertySignature(global.generatedEs2panda._CreateTSPropertySignature(global.context, passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg)) } - static updateTSPropertySignature(original: TSPropertySignature | undefined, key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature | undefined { + static updateTSPropertySignature(original: TSPropertySignature | undefined, key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature { return new TSPropertySignature(global.generatedEs2panda._UpdateTSPropertySignature(global.context, passNode(original), passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg)) } get keyConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts b/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts index 5420eddc5..8a23a4275 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSQualifiedName.ts @@ -35,10 +35,10 @@ export class TSQualifiedName extends Expression { super(pointer) console.warn("Warning: stub node TSQualifiedName") } - static createTSQualifiedName(left?: Expression, right?: Identifier): TSQualifiedName | undefined { + static createTSQualifiedName(left?: Expression, right?: Identifier): TSQualifiedName { return new TSQualifiedName(global.generatedEs2panda._CreateTSQualifiedName(global.context, passNode(left), passNode(right))) } - static updateTSQualifiedName(original?: TSQualifiedName, left?: Expression, right?: Identifier): TSQualifiedName | undefined { + static updateTSQualifiedName(original?: TSQualifiedName, left?: Expression, right?: Identifier): TSQualifiedName { return new TSQualifiedName(global.generatedEs2panda._UpdateTSQualifiedName(global.context, passNode(original), passNode(left), passNode(right))) } get leftConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts index f19cc22fd..e0e7a8ac2 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSStringKeyword.ts @@ -34,10 +34,10 @@ export class TSStringKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSStringKeyword") } - static createTSStringKeyword(): TSStringKeyword | undefined { + static createTSStringKeyword(): TSStringKeyword { return new TSStringKeyword(global.generatedEs2panda._CreateTSStringKeyword(global.context)) } - static updateTSStringKeyword(original?: TSStringKeyword): TSStringKeyword | undefined { + static updateTSStringKeyword(original?: TSStringKeyword): TSStringKeyword { return new TSStringKeyword(global.generatedEs2panda._UpdateTSStringKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts index 0231fbcea..f41c0b7f1 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSThisType.ts @@ -34,10 +34,10 @@ export class TSThisType extends TypeNode { super(pointer) console.warn("Warning: stub node TSThisType") } - static createTSThisType(): TSThisType | undefined { + static createTSThisType(): TSThisType { return new TSThisType(global.generatedEs2panda._CreateTSThisType(global.context)) } - static updateTSThisType(original?: TSThisType): TSThisType | undefined { + static updateTSThisType(original?: TSThisType): TSThisType { return new TSThisType(global.generatedEs2panda._UpdateTSThisType(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts index ec1d90e8e..4189b9d06 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTupleType.ts @@ -34,10 +34,10 @@ export class TSTupleType extends TypeNode { super(pointer) console.warn("Warning: stub node TSTupleType") } - static createTSTupleType(elementTypes: readonly TypeNode[], elementTypesLen: number): TSTupleType | undefined { + static createTSTupleType(elementTypes: readonly TypeNode[], elementTypesLen: number): TSTupleType { return new TSTupleType(global.generatedEs2panda._CreateTSTupleType(global.context, passNodeArray(elementTypes), elementTypesLen)) } - static updateTSTupleType(original: TSTupleType | undefined, elementTypes: readonly TypeNode[], elementTypesLen: number): TSTupleType | undefined { + static updateTSTupleType(original: TSTupleType | undefined, elementTypes: readonly TypeNode[], elementTypesLen: number): TSTupleType { return new TSTupleType(global.generatedEs2panda._UpdateTSTupleType(global.context, passNode(original), passNodeArray(elementTypes), elementTypesLen)) } get elementTypeConst(): readonly TypeNode[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts index 8cf089e12..e9ff06a0f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts @@ -39,16 +39,16 @@ export class TSTypeAliasDeclaration extends AnnotatedStatement { super(pointer) console.warn("Warning: stub node TSTypeAliasDeclaration") } - static createTSTypeAliasDeclaration(id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration | undefined { + static createTSTypeAliasDeclaration(id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration { return new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration(global.context, passNode(id), passNode(typeParams), passNode(typeAnnotation))) } - static updateTSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration | undefined { + static updateTSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration { return new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration(global.context, passNode(original), passNode(id), passNode(typeParams), passNode(typeAnnotation))) } - static create1TSTypeAliasDeclaration(id?: Identifier): TSTypeAliasDeclaration | undefined { + static create1TSTypeAliasDeclaration(id?: Identifier): TSTypeAliasDeclaration { return new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration1(global.context, passNode(id))) } - static update1TSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier): TSTypeAliasDeclaration | undefined { + static update1TSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier): TSTypeAliasDeclaration { return new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration1(global.context, passNode(original), passNode(id))) } get id(): Identifier | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts index 49b0638c2..ad6d47764 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeAssertion.ts @@ -36,10 +36,10 @@ export class TSTypeAssertion extends AnnotatedExpression { super(pointer) console.warn("Warning: stub node TSTypeAssertion") } - static createTSTypeAssertion(typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion | undefined { + static createTSTypeAssertion(typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion { return new TSTypeAssertion(global.generatedEs2panda._CreateTSTypeAssertion(global.context, passNode(typeAnnotation), passNode(expression))) } - static updateTSTypeAssertion(original?: TSTypeAssertion, typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion | undefined { + static updateTSTypeAssertion(original?: TSTypeAssertion, typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion { return new TSTypeAssertion(global.generatedEs2panda._UpdateTSTypeAssertion(global.context, passNode(original), passNode(typeAnnotation), passNode(expression))) } get getExpressionConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts index 1b4566d0a..0f66760cf 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeLiteral.ts @@ -34,10 +34,10 @@ export class TSTypeLiteral extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypeLiteral") } - static createTSTypeLiteral(members: readonly AstNode[], membersLen: number): TSTypeLiteral | undefined { + static createTSTypeLiteral(members: readonly AstNode[], membersLen: number): TSTypeLiteral { return new TSTypeLiteral(global.generatedEs2panda._CreateTSTypeLiteral(global.context, passNodeArray(members), membersLen)) } - static updateTSTypeLiteral(original: TSTypeLiteral | undefined, members: readonly AstNode[], membersLen: number): TSTypeLiteral | undefined { + static updateTSTypeLiteral(original: TSTypeLiteral | undefined, members: readonly AstNode[], membersLen: number): TSTypeLiteral { return new TSTypeLiteral(global.generatedEs2panda._UpdateTSTypeLiteral(global.context, passNode(original), passNodeArray(members), membersLen)) } get membersConst(): readonly AstNode[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts index 4d52ae226..c69211c1d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeOperator.ts @@ -35,10 +35,10 @@ export class TSTypeOperator extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypeOperator") } - static createTSTypeOperator(type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator | undefined { + static createTSTypeOperator(type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator { return new TSTypeOperator(global.generatedEs2panda._CreateTSTypeOperator(global.context, passNode(type), operatorType)) } - static updateTSTypeOperator(original: TSTypeOperator | undefined, type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator | undefined { + static updateTSTypeOperator(original: TSTypeOperator | undefined, type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator { return new TSTypeOperator(global.generatedEs2panda._UpdateTSTypeOperator(global.context, passNode(original), passNode(type), operatorType)) } get typeConst(): TypeNode | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts index ea8865287..69d217e48 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameter.ts @@ -38,16 +38,16 @@ export class TSTypeParameter extends Expression { super(pointer) console.warn("Warning: stub node TSTypeParameter") } - static createTSTypeParameter(name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter | undefined { + static createTSTypeParameter(name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter { return new TSTypeParameter(global.generatedEs2panda._CreateTSTypeParameter(global.context, passNode(name), passNode(constraint), passNode(defaultType))) } - static updateTSTypeParameter(original?: TSTypeParameter, name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter | undefined { + static updateTSTypeParameter(original?: TSTypeParameter, name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter { return new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType))) } - static create1TSTypeParameter(name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter | undefined { + static create1TSTypeParameter(name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter { return new TSTypeParameter(global.generatedEs2panda._CreateTSTypeParameter1(global.context, passNode(name), passNode(constraint), passNode(defaultType), flags)) } - static update1TSTypeParameter(original: TSTypeParameter | undefined, name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter | undefined { + static update1TSTypeParameter(original: TSTypeParameter | undefined, name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter { return new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter1(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType), flags)) } get nameConst(): Identifier | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts index a94ae0748..2be0b6bff 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts @@ -35,10 +35,10 @@ export class TSTypeParameterDeclaration extends Expression { super(pointer) console.warn("Warning: stub node TSTypeParameterDeclaration") } - static createTSTypeParameterDeclaration(params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration | undefined { + static createTSTypeParameterDeclaration(params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration { return new TSTypeParameterDeclaration(global.generatedEs2panda._CreateTSTypeParameterDeclaration(global.context, passNodeArray(params), paramsLen, requiredParams)) } - static updateTSTypeParameterDeclaration(original: TSTypeParameterDeclaration | undefined, params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration | undefined { + static updateTSTypeParameterDeclaration(original: TSTypeParameterDeclaration | undefined, params: readonly TSTypeParameter[], paramsLen: number, requiredParams: number): TSTypeParameterDeclaration { return new TSTypeParameterDeclaration(global.generatedEs2panda._UpdateTSTypeParameterDeclaration(global.context, passNode(original), passNodeArray(params), paramsLen, requiredParams)) } get paramsConst(): readonly TSTypeParameter[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts index 6d0836ed5..faeb4299a 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts @@ -35,10 +35,10 @@ export class TSTypeParameterInstantiation extends Expression { super(pointer) console.warn("Warning: stub node TSTypeParameterInstantiation") } - static createTSTypeParameterInstantiation(params: readonly TypeNode[], paramsLen: number): TSTypeParameterInstantiation | undefined { + static createTSTypeParameterInstantiation(params: readonly TypeNode[], paramsLen: number): TSTypeParameterInstantiation { return new TSTypeParameterInstantiation(global.generatedEs2panda._CreateTSTypeParameterInstantiation(global.context, passNodeArray(params), paramsLen)) } - static updateTSTypeParameterInstantiation(original: TSTypeParameterInstantiation | undefined, params: readonly TypeNode[], paramsLen: number): TSTypeParameterInstantiation | undefined { + static updateTSTypeParameterInstantiation(original: TSTypeParameterInstantiation | undefined, params: readonly TypeNode[], paramsLen: number): TSTypeParameterInstantiation { return new TSTypeParameterInstantiation(global.generatedEs2panda._UpdateTSTypeParameterInstantiation(global.context, passNode(original), passNodeArray(params), paramsLen)) } get paramsConst(): readonly TypeNode[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts index af4f9de44..5c605d795 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypePredicate.ts @@ -35,10 +35,10 @@ export class TSTypePredicate extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypePredicate") } - static createTSTypePredicate(parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate | undefined { + static createTSTypePredicate(parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate { return new TSTypePredicate(global.generatedEs2panda._CreateTSTypePredicate(global.context, passNode(parameterName), passNode(typeAnnotation), asserts)) } - static updateTSTypePredicate(original: TSTypePredicate | undefined, parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate | undefined { + static updateTSTypePredicate(original: TSTypePredicate | undefined, parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate { return new TSTypePredicate(global.generatedEs2panda._UpdateTSTypePredicate(global.context, passNode(original), passNode(parameterName), passNode(typeAnnotation), asserts)) } get parameterNameConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts index 299d73516..8cc40264c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeQuery.ts @@ -35,10 +35,10 @@ export class TSTypeQuery extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypeQuery") } - static createTSTypeQuery(exprName?: Expression): TSTypeQuery | undefined { + static createTSTypeQuery(exprName?: Expression): TSTypeQuery { return new TSTypeQuery(global.generatedEs2panda._CreateTSTypeQuery(global.context, passNode(exprName))) } - static updateTSTypeQuery(original?: TSTypeQuery, exprName?: Expression): TSTypeQuery | undefined { + static updateTSTypeQuery(original?: TSTypeQuery, exprName?: Expression): TSTypeQuery { return new TSTypeQuery(global.generatedEs2panda._UpdateTSTypeQuery(global.context, passNode(original), passNode(exprName))) } get exprNameConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts b/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts index 85e47701a..53215db15 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSTypeReference.ts @@ -36,10 +36,10 @@ export class TSTypeReference extends TypeNode { super(pointer) console.warn("Warning: stub node TSTypeReference") } - static createTSTypeReference(typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference | undefined { + static createTSTypeReference(typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference { return new TSTypeReference(global.generatedEs2panda._CreateTSTypeReference(global.context, passNode(typeName), passNode(typeParams))) } - static updateTSTypeReference(original?: TSTypeReference, typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference | undefined { + static updateTSTypeReference(original?: TSTypeReference, typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference { return new TSTypeReference(global.generatedEs2panda._UpdateTSTypeReference(global.context, passNode(original), passNode(typeName), passNode(typeParams))) } get typeParamsConst(): TSTypeParameterInstantiation | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts index cfedbf5b7..895f5f82c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUndefinedKeyword.ts @@ -34,10 +34,10 @@ export class TSUndefinedKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSUndefinedKeyword") } - static createTSUndefinedKeyword(): TSUndefinedKeyword | undefined { + static createTSUndefinedKeyword(): TSUndefinedKeyword { return new TSUndefinedKeyword(global.generatedEs2panda._CreateTSUndefinedKeyword(global.context)) } - static updateTSUndefinedKeyword(original?: TSUndefinedKeyword): TSUndefinedKeyword | undefined { + static updateTSUndefinedKeyword(original?: TSUndefinedKeyword): TSUndefinedKeyword { return new TSUndefinedKeyword(global.generatedEs2panda._UpdateTSUndefinedKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts index c49af47c5..9b696f94c 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUnionType.ts @@ -34,10 +34,10 @@ export class TSUnionType extends TypeNode { super(pointer) console.warn("Warning: stub node TSUnionType") } - static createTSUnionType(types: readonly TypeNode[], typesLen: number): TSUnionType | undefined { + static createTSUnionType(types: readonly TypeNode[], typesLen: number): TSUnionType { return new TSUnionType(global.generatedEs2panda._CreateTSUnionType(global.context, passNodeArray(types), typesLen)) } - static updateTSUnionType(original: TSUnionType | undefined, types: readonly TypeNode[], typesLen: number): TSUnionType | undefined { + static updateTSUnionType(original: TSUnionType | undefined, types: readonly TypeNode[], typesLen: number): TSUnionType { return new TSUnionType(global.generatedEs2panda._UpdateTSUnionType(global.context, passNode(original), passNodeArray(types), typesLen)) } get typesConst(): readonly TypeNode[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts index 34cc18e2f..b7d88e15b 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSUnknownKeyword.ts @@ -34,10 +34,10 @@ export class TSUnknownKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSUnknownKeyword") } - static createTSUnknownKeyword(): TSUnknownKeyword | undefined { + static createTSUnknownKeyword(): TSUnknownKeyword { return new TSUnknownKeyword(global.generatedEs2panda._CreateTSUnknownKeyword(global.context)) } - static updateTSUnknownKeyword(original?: TSUnknownKeyword): TSUnknownKeyword | undefined { + static updateTSUnknownKeyword(original?: TSUnknownKeyword): TSUnknownKeyword { return new TSUnknownKeyword(global.generatedEs2panda._UpdateTSUnknownKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts b/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts index 8b4f2fb81..8197ebb73 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TSVoidKeyword.ts @@ -34,10 +34,10 @@ export class TSVoidKeyword extends TypeNode { super(pointer) console.warn("Warning: stub node TSVoidKeyword") } - static createTSVoidKeyword(): TSVoidKeyword | undefined { + static createTSVoidKeyword(): TSVoidKeyword { return new TSVoidKeyword(global.generatedEs2panda._CreateTSVoidKeyword(global.context)) } - static updateTSVoidKeyword(original?: TSVoidKeyword): TSVoidKeyword | undefined { + static updateTSVoidKeyword(original?: TSVoidKeyword): TSVoidKeyword { return new TSVoidKeyword(global.generatedEs2panda._UpdateTSVoidKeyword(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts index d8b5e12ff..00cd6f6dc 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TaggedTemplateExpression.ts @@ -36,10 +36,10 @@ export class TaggedTemplateExpression extends Expression { super(pointer) console.warn("Warning: stub node TaggedTemplateExpression") } - static createTaggedTemplateExpression(tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression | undefined { + static createTaggedTemplateExpression(tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression { return new TaggedTemplateExpression(global.generatedEs2panda._CreateTaggedTemplateExpression(global.context, passNode(tag), passNode(quasi), passNode(typeParams))) } - static updateTaggedTemplateExpression(original?: TaggedTemplateExpression, tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression | undefined { + static updateTaggedTemplateExpression(original?: TaggedTemplateExpression, tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression { return new TaggedTemplateExpression(global.generatedEs2panda._UpdateTaggedTemplateExpression(global.context, passNode(original), passNode(tag), passNode(quasi), passNode(typeParams))) } get tagConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts b/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts index 4caf056f4..cb05a99e0 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TemplateElement.ts @@ -34,16 +34,16 @@ export class TemplateElement extends Expression { super(pointer) console.warn("Warning: stub node TemplateElement") } - static createTemplateElement(): TemplateElement | undefined { + static createTemplateElement(): TemplateElement { return new TemplateElement(global.generatedEs2panda._CreateTemplateElement(global.context)) } - static updateTemplateElement(original?: TemplateElement): TemplateElement | undefined { + static updateTemplateElement(original?: TemplateElement): TemplateElement { return new TemplateElement(global.generatedEs2panda._UpdateTemplateElement(global.context, passNode(original))) } - static create1TemplateElement(raw: string, cooked: string): TemplateElement | undefined { + static create1TemplateElement(raw: string, cooked: string): TemplateElement { return new TemplateElement(global.generatedEs2panda._CreateTemplateElement1(global.context, raw, cooked)) } - static update1TemplateElement(original: TemplateElement | undefined, raw: string, cooked: string): TemplateElement | undefined { + static update1TemplateElement(original: TemplateElement | undefined, raw: string, cooked: string): TemplateElement { return new TemplateElement(global.generatedEs2panda._UpdateTemplateElement1(global.context, passNode(original), raw, cooked)) } get rawConst(): string { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts index 2f9722608..227569f5d 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TemplateLiteral.ts @@ -35,10 +35,10 @@ export class TemplateLiteral extends Expression { super(pointer) console.warn("Warning: stub node TemplateLiteral") } - static createTemplateLiteral(quasis: readonly TemplateElement[], quasisLen: number, expressions: readonly Expression[], expressionsLen: number, multilineString: string): TemplateLiteral | undefined { + static createTemplateLiteral(quasis: readonly TemplateElement[], quasisLen: number, expressions: readonly Expression[], expressionsLen: number, multilineString: string): TemplateLiteral { return new TemplateLiteral(global.generatedEs2panda._CreateTemplateLiteral(global.context, passNodeArray(quasis), quasisLen, passNodeArray(expressions), expressionsLen, multilineString)) } - static updateTemplateLiteral(original: TemplateLiteral | undefined, quasis: readonly TemplateElement[], quasisLen: number, expressions: readonly Expression[], expressionsLen: number, multilineString: string): TemplateLiteral | undefined { + static updateTemplateLiteral(original: TemplateLiteral | undefined, quasis: readonly TemplateElement[], quasisLen: number, expressions: readonly Expression[], expressionsLen: number, multilineString: string): TemplateLiteral { return new TemplateLiteral(global.generatedEs2panda._UpdateTemplateLiteral(global.context, passNode(original), passNodeArray(quasis), quasisLen, passNodeArray(expressions), expressionsLen, multilineString)) } get quasisConst(): readonly TemplateElement[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts index 6de59a46e..d622b5e56 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ThisExpression.ts @@ -34,10 +34,10 @@ export class ThisExpression extends Expression { super(pointer) console.warn("Warning: stub node ThisExpression") } - static createThisExpression(): ThisExpression | undefined { + static createThisExpression(): ThisExpression { return new ThisExpression(global.generatedEs2panda._CreateThisExpression(global.context)) } - static updateThisExpression(original?: ThisExpression): ThisExpression | undefined { + static updateThisExpression(original?: ThisExpression): ThisExpression { return new ThisExpression(global.generatedEs2panda._UpdateThisExpression(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts b/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts index b362f6e97..46ece221f 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/ThrowStatement.ts @@ -35,10 +35,10 @@ export class ThrowStatement extends Statement { super(pointer) console.warn("Warning: stub node ThrowStatement") } - static createThrowStatement(argument?: Expression): ThrowStatement | undefined { + static createThrowStatement(argument?: Expression): ThrowStatement { return new ThrowStatement(global.generatedEs2panda._CreateThrowStatement(global.context, passNode(argument))) } - static updateThrowStatement(original?: ThrowStatement, argument?: Expression): ThrowStatement | undefined { + static updateThrowStatement(original?: ThrowStatement, argument?: Expression): ThrowStatement { return new ThrowStatement(global.generatedEs2panda._UpdateThrowStatement(global.context, passNode(original), passNode(argument))) } get argumentConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts index 622ddb28e..541ef9675 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/TypeofExpression.ts @@ -34,10 +34,10 @@ export class TypeofExpression extends Expression { super(pointer) console.warn("Warning: stub node TypeofExpression") } - static createTypeofExpression(argument?: Expression): TypeofExpression | undefined { + static createTypeofExpression(argument?: Expression): TypeofExpression { return new TypeofExpression(global.generatedEs2panda._CreateTypeofExpression(global.context, passNode(argument))) } - static updateTypeofExpression(original?: TypeofExpression, argument?: Expression): TypeofExpression | undefined { + static updateTypeofExpression(original?: TypeofExpression, argument?: Expression): TypeofExpression { return new TypeofExpression(global.generatedEs2panda._UpdateTypeofExpression(global.context, passNode(original), passNode(argument))) } get argumentConst(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts index cfd26a359..d0ab980f3 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UnaryExpression.ts @@ -35,10 +35,10 @@ export class UnaryExpression extends Expression { super(pointer) console.warn("Warning: stub node UnaryExpression") } - static createUnaryExpression(argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression | undefined { + static createUnaryExpression(argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression { return new UnaryExpression(global.generatedEs2panda._CreateUnaryExpression(global.context, passNode(argument), unaryOperator)) } - static updateUnaryExpression(original: UnaryExpression | undefined, argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression | undefined { + static updateUnaryExpression(original: UnaryExpression | undefined, argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression { return new UnaryExpression(global.generatedEs2panda._UpdateUnaryExpression(global.context, passNode(original), passNode(argument), unaryOperator)) } get operatorTypeConst(): Es2pandaTokenType { diff --git a/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts b/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts index ee3bb46bc..7928c3511 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UndefinedLiteral.ts @@ -34,10 +34,10 @@ export class UndefinedLiteral extends Literal { super(pointer) console.warn("Warning: stub node UndefinedLiteral") } - static createUndefinedLiteral(): UndefinedLiteral | undefined { + static createUndefinedLiteral(): UndefinedLiteral { return new UndefinedLiteral(global.generatedEs2panda._CreateUndefinedLiteral(global.context)) } - static updateUndefinedLiteral(original?: UndefinedLiteral): UndefinedLiteral | undefined { + static updateUndefinedLiteral(original?: UndefinedLiteral): UndefinedLiteral { return new UndefinedLiteral(global.generatedEs2panda._UpdateUndefinedLiteral(global.context, passNode(original))) } } diff --git a/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts index 1db3cd5cb..14ad0b275 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/UpdateExpression.ts @@ -35,10 +35,10 @@ export class UpdateExpression extends Expression { super(pointer) console.warn("Warning: stub node UpdateExpression") } - static createUpdateExpression(argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression | undefined { + static createUpdateExpression(argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression { return new UpdateExpression(global.generatedEs2panda._CreateUpdateExpression(global.context, passNode(argument), updateOperator, isPrefix)) } - static updateUpdateExpression(original: UpdateExpression | undefined, argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression | undefined { + static updateUpdateExpression(original: UpdateExpression | undefined, argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression { return new UpdateExpression(global.generatedEs2panda._UpdateUpdateExpression(global.context, passNode(original), passNode(argument), updateOperator, isPrefix)) } get operatorTypeConst(): Es2pandaTokenType { diff --git a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts index c82b5ae81..2d562e5fe 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclaration.ts @@ -38,10 +38,10 @@ export class VariableDeclaration extends Statement { super(pointer) console.warn("Warning: stub node VariableDeclaration") } - static createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration | undefined { + static createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration { return new VariableDeclaration(global.generatedEs2panda._CreateVariableDeclaration(global.context, kind, passNodeArray(declarators), declaratorsLen)) } - static updateVariableDeclaration(original: VariableDeclaration | undefined, kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration | undefined { + static updateVariableDeclaration(original: VariableDeclaration | undefined, kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], declaratorsLen: number): VariableDeclaration { return new VariableDeclaration(global.generatedEs2panda._UpdateVariableDeclaration(global.context, passNode(original), kind, passNodeArray(declarators), declaratorsLen)) } get declaratorsConst(): readonly VariableDeclarator[] { diff --git a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts index 5db1da15b..bebada215 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/VariableDeclarator.ts @@ -36,16 +36,16 @@ export class VariableDeclarator extends TypedStatement { super(pointer) console.warn("Warning: stub node VariableDeclarator") } - static createVariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator | undefined { + static createVariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator { return new VariableDeclarator(global.generatedEs2panda._CreateVariableDeclarator(global.context, flag, passNode(ident))) } - static updateVariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator | undefined { + static updateVariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator { return new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator(global.context, passNode(original), flag, passNode(ident))) } - static create1VariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator | undefined { + static create1VariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator { return new VariableDeclarator(global.generatedEs2panda._CreateVariableDeclarator1(global.context, flag, passNode(ident), passNode(init))) } - static update1VariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator | undefined { + static update1VariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator { return new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator1(global.context, passNode(original), flag, passNode(ident), passNode(init))) } get init(): Expression | undefined { diff --git a/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts b/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts index fb025cb58..5de301724 100644 --- a/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts +++ b/arkoala-arkts/libarkts/src/generated/peers/YieldExpression.ts @@ -34,10 +34,10 @@ export class YieldExpression extends Expression { super(pointer) console.warn("Warning: stub node YieldExpression") } - static createYieldExpression(argument: Expression | undefined, isDelegate: boolean): YieldExpression | undefined { + static createYieldExpression(argument: Expression | undefined, isDelegate: boolean): YieldExpression { return new YieldExpression(global.generatedEs2panda._CreateYieldExpression(global.context, passNode(argument), isDelegate)) } - static updateYieldExpression(original: YieldExpression | undefined, argument: Expression | undefined, isDelegate: boolean): YieldExpression | undefined { + static updateYieldExpression(original: YieldExpression | undefined, argument: Expression | undefined, isDelegate: boolean): YieldExpression { return new YieldExpression(global.generatedEs2panda._UpdateYieldExpression(global.context, passNode(original), passNode(argument), isDelegate)) } get hasDelegateConst(): boolean { -- Gitee From ab4358485a7fc70842ca997c57408df46a227bd6 Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Wed, 19 Feb 2025 14:29:40 +0300 Subject: [PATCH 16/20] rebase, need id Signed-off-by: naumovdmitrii --- .../libarkts/plugins/src/arkts-utils.ts | 4 +- .../src/arkts-api/factory/nodeFactory.ts | 6 +-- .../src/arkts-api/factory/nodeTests.ts | 11 +--- arkoala-arkts/libarkts/src/arkts-api/types.ts | 52 ++++++------------- 4 files changed, 22 insertions(+), 51 deletions(-) diff --git a/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts b/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts index 549790fd7..e6201eda8 100644 --- a/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts +++ b/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts @@ -1,8 +1,8 @@ import * as arkts from "@koalaui/libarkts" -export function annotation(name: string): arkts.AnnotationUsageIr { +export function annotation(name: string): arkts.AnnotationUsage { const ident: arkts.Identifier = arkts.factory.createIdentifier(name).setAnnotationUsage(); - const annotation: arkts.AnnotationUsageIr = arkts.factory.createAnnotationUsageIr(ident); + const annotation: arkts.AnnotationUsage = arkts.factory.createAnnotationUsage(ident); annotation.modifiers = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_ANNOTATION_USAGE; ident.parent = annotation; diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts index 778cb68cd..4f3f39b21 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts @@ -15,7 +15,6 @@ import { updateNodeByNode } from "../utilities/private" import { - AnnotationUsageIr, ArrowFunctionExpression, BinaryExpression, BlockStatement, @@ -54,6 +53,7 @@ import { } from "../types" import { MemberExpression } from "../to-be-generated/MemberExpression" import { AstNode } from "../peers/AstNode" +import { AnnotationUsage } from "../../generated" function compose( create: (...args: ARGS) => T, @@ -289,8 +289,8 @@ export const factory = { get updateUndefinedLiteral() { return compose(UndefinedLiteral.create) }, - get createAnnotationUsageIr() { - return AnnotationUsageIr.create + get createAnnotationUsage() { + return AnnotationUsage.createAnnotationUsage }, get updateAnnotationUsageIr() { return compose(UndefinedLiteral.create) diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts index 898fb4e73..dd87fe0c4 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts @@ -1,7 +1,6 @@ import { global } from "../static/global" import { AnnotationDeclaration, - AnnotationUsageIr, ArrowFunctionExpression, BlockStatement, CallExpression, @@ -22,15 +21,7 @@ import { ClassProperty } from "../types" import { MemberExpression } from "../to-be-generated/MemberExpression" -import type { AstNode } from "../peers/AstNode" - -export function isClassProperty(node: AstNode): node is ClassProperty { - return global.es2panda._IsClassProperty(node.peer); -} - -export function isAnnotationUsage(node: AstNode): node is AnnotationUsageIr { - return global.es2panda._IsAnnotationUsage(node.peer); -} +import { AstNode } from "../peers/AstNode" export function isAnnotationDeclaration(node: AstNode): node is AnnotationDeclaration { return global.es2panda._IsAnnotationDeclaration(node.peer); diff --git a/arkoala-arkts/libarkts/src/arkts-api/types.ts b/arkoala-arkts/libarkts/src/arkts-api/types.ts index 964558698..3d4666013 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/types.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/types.ts @@ -50,6 +50,7 @@ import { Context } from "./peers/Context" import * as path from "node:path" import { nodeByType } from "./class-by-peer" import { MemberExpression } from "./to-be-generated/MemberExpression" +import { AnnotationUsage } from "../generated" export class UnsupportedNode extends AstNode { constructor(peer: KPtr) { @@ -602,15 +603,15 @@ export class ScriptFunction extends AstNode { readonly scriptFunctionFlags: KInt readonly ident?: Identifier - get annotations(): AnnotationUsageIr[] { + get annotations(): AnnotationUsage[] { return unpackNodeArray(global.es2panda._ScriptFunctionAnnotations( global.context, this.peer, nullptr - )) as AnnotationUsageIr[]; + )) } - set annotations(newAnnotations: AnnotationUsageIr[]) { + set annotations(newAnnotations: AnnotationUsage[]) { global.es2panda._ScriptFunctionSetAnnotations( global.context, this.peer, @@ -744,15 +745,15 @@ export class ETSParameterExpression extends AstNode { ) } - get annotations(): AnnotationUsageIr[] { + get annotations(): AnnotationUsage[] { return unpackNodeArray(global.es2panda._ETSParameterExpressionAnnotations( global.context, this.peer, nullptr - )) as AnnotationUsageIr[]; + )) } - set annotations(newAnnotations: AnnotationUsageIr[]) { + set annotations(newAnnotations: AnnotationUsage[]) { global.es2panda._ETSParameterExpressionSetAnnotations( global.context, this.peer, @@ -1057,15 +1058,17 @@ export class ClassProperty extends ClassElement { ) } - get annotations(): AnnotationUsageIr[] { - return unpackNodeArray(global.es2panda._ScriptFunctionAnnotations( - global.context, - this.peer, - nullptr - )) as AnnotationUsageIr[]; + get annotations(): AnnotationUsage[] { + return unpackNodeArray( + global.es2panda._ScriptFunctionAnnotations( + global.context, + this.peer, + nullptr + ) + ) } - set annotations(newAnnotations: AnnotationUsageIr[]) { + set annotations(newAnnotations: AnnotationUsage[]) { global.es2panda._ScriptFunctionSetAnnotations( global.context, this.peer, @@ -1237,29 +1240,6 @@ export class ImportSpecifier extends AstNode { } } -export class AnnotationUsageIr extends AstNode { - constructor(peer: KPtr) { - assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE) - super(peer) - this.expr = unpackNonNullableNode(global.generatedEs2panda._AnnotationUsageIrExpr(global.context, this.peer)) - this.properties = unpackNodeArray(global.generatedEs2panda._AnnotationUsageIrPropertiesConst(global.context, this.peer)) - } - - static create( - annoIdent: AstNode - ): AnnotationUsageIr { - return new AnnotationUsageIr( - global.es2panda._CreateAnnotationUsageIr( - global.context, - passNode(annoIdent) - ) - ); - } - - readonly expr: AstNode - readonly properties: readonly ClassProperty[] -} - export class TSTypeParameterInstantiation extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION) -- Gitee From 6bdf459687a7248cc150e5adf7458ebf4ab461c9 Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Wed, 19 Feb 2025 14:45:35 +0300 Subject: [PATCH 17/20] id, ts tests Signed-off-by: naumovdmitrii --- arkoala-arkts/libarkts/.mocharc.json | 3 +- arkoala-arkts/libarkts/src/arkts-api/types.ts | 25 ++------ .../arkts-api/general/annotations.test.ts | 3 + arkoala-arkts/libarkts/test/test-util.ts | 57 ++----------------- .../create-function-declaration.test.ts | 2 +- .../update-function-declaration.test.ts | 2 +- .../lambda-param-memoization.test.ts | 2 +- .../test/ts-api/general/abc-gen.test.ts | 2 +- .../test/ts-api/general/basic.test.ts | 2 +- .../ts-api/variables/create-variable.test.ts | 2 +- .../memo-rewrite.test.ts | 2 +- 11 files changed, 22 insertions(+), 80 deletions(-) diff --git a/arkoala-arkts/libarkts/.mocharc.json b/arkoala-arkts/libarkts/.mocharc.json index 1799d0fb2..62699a6cd 100644 --- a/arkoala-arkts/libarkts/.mocharc.json +++ b/arkoala-arkts/libarkts/.mocharc.json @@ -1,7 +1,6 @@ { "ui": "tdd", - "spec": "./test/**/*.test.ts", - "exclude": "./test/ts-api/**/*", + "spec": "./test/arkts-api/**/*.test.ts", "extension": [ "ts" ], diff --git a/arkoala-arkts/libarkts/src/arkts-api/types.ts b/arkoala-arkts/libarkts/src/arkts-api/types.ts index 3d4666013..d3770a007 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/types.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/types.ts @@ -50,7 +50,7 @@ import { Context } from "./peers/Context" import * as path from "node:path" import { nodeByType } from "./class-by-peer" import { MemberExpression } from "./to-be-generated/MemberExpression" -import { AnnotationUsage } from "../generated" +import { AnnotationUsage, Expression } from "../generated" export class UnsupportedNode extends AstNode { constructor(peer: KPtr) { @@ -369,7 +369,7 @@ export class ETSFunctionType extends AstNode { } } -export class Identifier extends AstNode { +export class Identifier extends Expression { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER) super(peer) @@ -378,25 +378,10 @@ export class Identifier extends AstNode { static create( name: string, typeAnnotation?: AstNode, - isAnnotation?: boolean ): Identifier { - if (isAnnotation) { - return new Identifier( - global.es2panda._ETSParserCreateExpression( - global.context, - passString(name), - Es2pandaExpressionParseFlags.EXPRESSION_PARSE_FLAGS_ACCEPT_COMMA - ) - ) - } else if (typeAnnotation === undefined) { - return new Identifier( - global.es2panda._CreateIdentifier1(global.context, passString(name)) - ) - } else { - return new Identifier( - global.es2panda._CreateIdentifier2(global.context, passString(name), typeAnnotation.peer) - ) - } + return new Identifier( + global.es2panda._CreateIdentifier2(global.context, passString(name), passNode(typeAnnotation)) + ) } setOptional(optional: boolean): Identifier { diff --git a/arkoala-arkts/libarkts/test/arkts-api/general/annotations.test.ts b/arkoala-arkts/libarkts/test/arkts-api/general/annotations.test.ts index 1f1335b87..b4d4b3611 100644 --- a/arkoala-arkts/libarkts/test/arkts-api/general/annotations.test.ts +++ b/arkoala-arkts/libarkts/test/arkts-api/general/annotations.test.ts @@ -19,6 +19,9 @@ suite(util.basename(__filename), () => { const annotations = arkts.getAnnotations(script.statements[0]) const names = annotations.map((annot) => { + if (annot.expr === undefined) { + throw new Error('annotation expression is undefined') + } if (!arkts.isIdentifier(annot.expr)) { throw new Error('annotation expected to be Identifier') } diff --git a/arkoala-arkts/libarkts/test/test-util.ts b/arkoala-arkts/libarkts/test/test-util.ts index 3d85b1ea1..c065bbe35 100644 --- a/arkoala-arkts/libarkts/test/test-util.ts +++ b/arkoala-arkts/libarkts/test/test-util.ts @@ -14,7 +14,6 @@ */ import { global } from "../src/arkts-api/static/global" -import * as ts from "../src/ts-api" import * as arkts from "../src/arkts-api" import * as pth from "path" @@ -24,13 +23,6 @@ import { exec, execSync } from "child_process" export { Es2pandaNativeModule } from "../src/Es2pandaNativeModule" export { assert } from "chai" -class defaultTransformationContext implements ts.TransformationContext { -} - -export function getDefaultTransformationContext(): ts.TransformationContext { - return new defaultTransformationContext() -} - export function alignText(text: string): string { const lines = text.replace(/\t/gy, ' ').split('\n') @@ -63,19 +55,15 @@ export function assertEqualsSource(sourceResult: string, sourceExpect: string, m ) } -export function TS_TEST_ASSERTION(node: ts.SourceFile, source: string, state?: ts.ContextState) { - ARKTS_TEST_ASSERTION(node.node, source, state) -} - -export function ARKTS_TEST_ASSERTION(node: arkts.EtsScript, source: string, state?: ts.ContextState) { - const finalState: ts.ContextState = (() => { +export function ARKTS_TEST_ASSERTION(node: arkts.EtsScript, source: string, state?: arkts.Es2pandaContextState) { + const finalState: arkts.Es2pandaContextState = (() => { if (state !== undefined) { return state } if (process.env.STATE_CHECKED !== undefined) { - return ts.ContextState.ES2PANDA_STATE_CHECKED + return arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED } - return ts.ContextState.ES2PANDA_STATE_PARSED + return arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED })() arkts.proceedToState(finalState) @@ -94,40 +82,7 @@ export function ARKTS_TEST_ASSERTION(node: arkts.EtsScript, source: string, stat } } -export function addMemoParamsToFunctionDeclaration(func: ts.FunctionDeclaration): ts.FunctionDeclaration { - return ts.factory.updateFunctionDeclaration( - func, - undefined, - undefined, - func.name, - undefined, - [ - ts.factory.createParameterDeclaration( - undefined, - undefined, - ts.factory.createIdentifier("__memo_context"), - undefined, - ts.factory.createTypeReferenceNode( - ts.factory.createIdentifier("__memo_context_type") - ), - undefined - ), - ts.factory.createParameterDeclaration( - undefined, - undefined, - ts.factory.createIdentifier("__memo_id"), - undefined, - ts.factory.createTypeReferenceNode( - ts.factory.createIdentifier("__memo_id_type") - ), - undefined - ), - ...func.parameters - ], - undefined, - func.body - ) -} + export function cleanGenerated(): void { exec('npm run clean:generated') @@ -142,7 +97,7 @@ export function fileToAbc(path: string, isModule?: boolean): void { } export function contextToAbc(): void { - arkts.proceedToState(ts.ContextState.ES2PANDA_STATE_BIN_GENERATED) + arkts.proceedToState(arkts.Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) // TODO: get name of file execSync('mkdir -p ./generated') execSync('mv ./main.abc ./generated/main.abc') diff --git a/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/create-function-declaration.test.ts b/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/create-function-declaration.test.ts index 0071bb839..120ce4949 100644 --- a/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/create-function-declaration.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/create-function-declaration.test.ts @@ -2,7 +2,7 @@ import * as util from "../../../test-util" import * as ts from "../../../../src/ts-api" import { factory } from "../../../../src/ts-api" -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { test("empty-function", function() { // function test_func() { // // empty diff --git a/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/update-function-declaration.test.ts b/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/update-function-declaration.test.ts index 2c2229a8a..ca2966d4d 100644 --- a/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/update-function-declaration.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/functions/function-declaration/update-function-declaration.test.ts @@ -1,7 +1,7 @@ import * as util from "../../../test-util" import * as ts from "../../../../src/ts-api" -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { // adding y: string to signature test("update-name-and-add-param-to-function", function() { // function new_test_func(x: number, y: string) { diff --git a/arkoala-arkts/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts b/arkoala-arkts/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts index 470141df7..bfad65152 100644 --- a/arkoala-arkts/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts @@ -1,7 +1,7 @@ import * as util from "../../../test-util" import * as ts from "../../../../src/ts-api" -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { // full memo rewrite test("memo-function-with-lambda-memo-param", function() { // function foo( diff --git a/arkoala-arkts/libarkts/test/ts-api/general/abc-gen.test.ts b/arkoala-arkts/libarkts/test/ts-api/general/abc-gen.test.ts index 05106f2a2..00c60f8de 100644 --- a/arkoala-arkts/libarkts/test/ts-api/general/abc-gen.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/general/abc-gen.test.ts @@ -2,7 +2,7 @@ import * as util from "../../test-util" import * as ts from "../../../src/ts-api" // tests for abc generation (now failing on CI) -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { test("updating-expression-statement", function() { const sample_in = ` diff --git a/arkoala-arkts/libarkts/test/ts-api/general/basic.test.ts b/arkoala-arkts/libarkts/test/ts-api/general/basic.test.ts index 62c53242f..72f8253b9 100644 --- a/arkoala-arkts/libarkts/test/ts-api/general/basic.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/general/basic.test.ts @@ -2,7 +2,7 @@ import * as util from "../../test-util" import * as ts from "../../../src/ts-api" import { factory } from "../../../src/ts-api" -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { test("sample-1", function() { const sample_in = ` diff --git a/arkoala-arkts/libarkts/test/ts-api/variables/create-variable.test.ts b/arkoala-arkts/libarkts/test/ts-api/variables/create-variable.test.ts index 33a83fe9b..66369eefa 100644 --- a/arkoala-arkts/libarkts/test/ts-api/variables/create-variable.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/variables/create-variable.test.ts @@ -2,7 +2,7 @@ import * as util from "../../test-util" import * as ts from "../../../src/ts-api" import { factory } from "../../../src/ts-api" -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { test("const-number", function() { const sample_in = ` diff --git a/arkoala-arkts/libarkts/test/ts-api/visitors-and-transformers/memo-rewrite.test.ts b/arkoala-arkts/libarkts/test/ts-api/visitors-and-transformers/memo-rewrite.test.ts index 9bdc32742..1ece5e82a 100644 --- a/arkoala-arkts/libarkts/test/ts-api/visitors-and-transformers/memo-rewrite.test.ts +++ b/arkoala-arkts/libarkts/test/ts-api/visitors-and-transformers/memo-rewrite.test.ts @@ -2,7 +2,7 @@ import * as util from "../../test-util" import * as ts from "../../../src/ts-api" import { MemoTransformer } from "../../../plugins/src/memo-transformer" -suite(util.basename(__filename), () => { +suite.skip(util.basename(__filename), () => { test("memo-transformer-sample-1", function() { const sample_in = ` -- Gitee From 8ad689873a8ee8ab0c462d484cbb397df8fe53a7 Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Wed, 19 Feb 2025 14:58:23 +0300 Subject: [PATCH 18/20] fix unsupported Signed-off-by: naumovdmitrii --- .../libarkts/src/arkts-api/class-by-peer.ts | 4 ++-- .../libarkts/src/arkts-api/peers/AstNode.ts | 13 +++++++++++-- arkoala-arkts/libarkts/src/arkts-api/types.ts | 7 ------- 3 files changed, 13 insertions(+), 11 deletions(-) diff --git a/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts b/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts index 6d3f50799..fa2a83a5a 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/class-by-peer.ts @@ -17,7 +17,7 @@ import { Es2pandaAstNodeType } from "../Es2pandaEnums" import { throwError } from "../utils" import { global } from "./static/global" import { KNativePointer, nullptr } from "@koalaui/interop" -import type { AstNode } from "./peers/AstNode" +import { AstNode, UnsupportedNode } from "./peers/AstNode" export const nodeByType = new Map([]) @@ -26,6 +26,6 @@ export function classByPeer(peer: KNativePointer): T { throwError('classByPeer: peer is NULLPTR') } const type = global.generatedEs2panda._AstNodeTypeConst(global.context, peer) - const node = nodeByType.get(type) ?? throwError(Es2pandaAstNodeType[type]) + const node = nodeByType.get(type) ?? UnsupportedNode return new node(peer) as T } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts b/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts index d615edcca..2ba4dfb1e 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/peers/AstNode.ts @@ -13,12 +13,13 @@ * limitations under the License. */ -import { isNullPtr, KInt, KNativePointer, nullptr } from "@koalaui/interop" +import { isNullPtr, KInt, KNativePointer as KPtr, KNativePointer, nullptr } from "@koalaui/interop" import { global } from "../static/global" -import { allFlags, unpackNodeArray, unpackNonNullableNode, unpackString } from "../utilities/private" +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) { @@ -110,3 +111,11 @@ export abstract class AstNode extends ArktsObject { 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)]}`) + } +} diff --git a/arkoala-arkts/libarkts/src/arkts-api/types.ts b/arkoala-arkts/libarkts/src/arkts-api/types.ts index d3770a007..e546bff6e 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/types.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/types.ts @@ -52,13 +52,6 @@ import { nodeByType } from "./class-by-peer" import { MemberExpression } from "./to-be-generated/MemberExpression" import { AnnotationUsage, Expression } from "../generated" -export class UnsupportedNode extends AstNode { - constructor(peer: KPtr) { - super(peer) - console.warn(`Warning: unsupported node ${Es2pandaAstNodeType[nodeType(this)]}`) - } -} - export class EtsScript extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) -- Gitee From 7160772e8dd3da5050bab3595a769779263e7ee0 Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Wed, 19 Feb 2025 15:06:23 +0300 Subject: [PATCH 19/20] bump Signed-off-by: naumovdmitrii --- arkoala-arkts/libarkts/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arkoala-arkts/libarkts/package.json b/arkoala-arkts/libarkts/package.json index c635b15b2..fd2fb9326 100644 --- a/arkoala-arkts/libarkts/package.json +++ b/arkoala-arkts/libarkts/package.json @@ -11,7 +11,7 @@ "./build/*" ], "config": { - "gen_version": "3.0.18", + "gen_version": "3.0.19", "input_file": "../../incremental/tools/panda/node_modules/@panda/sdk/ohos_arm64/include/tools/es2panda/generated/es2panda_lib/es2panda_lib.idl" }, "dependencies": { -- Gitee From 2a129426946fb7a9f6d0e497d1e7d7f25182972f Mon Sep 17 00:00:00 2001 From: naumovdmitrii Date: Wed, 19 Feb 2025 15:58:01 +0300 Subject: [PATCH 20/20] fix memo plugin Signed-off-by: naumovdmitrii --- .../memo-plugin/src/function-transformer.ts | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/arkoala-arkts/memo-plugin/src/function-transformer.ts b/arkoala-arkts/memo-plugin/src/function-transformer.ts index 0c86fe39a..b42df68bd 100644 --- a/arkoala-arkts/memo-plugin/src/function-transformer.ts +++ b/arkoala-arkts/memo-plugin/src/function-transformer.ts @@ -15,11 +15,18 @@ import * as arkts from "@koalaui/libarkts" import { AbstractVisitor } from "./AbstractVisitor" -import { createContextParameter, createIdParameter, createContextArgument, createIdArgument, RuntimeNames, PositionalIdTracker } from "./utils" +import { + createContextArgument, + createContextParameter, + createIdArgument, + createIdParameter, + PositionalIdTracker, + RuntimeNames +} from "./utils" function hasMemoAnnotation(node: arkts.ScriptFunction) { return arkts.getAnnotations(node).some((it) => - arkts.isIdentifier(it.expr) && it.expr.name === RuntimeNames.ANNOTATION + it.expr !== undefined && arkts.isIdentifier(it.expr) && it.expr.name === RuntimeNames.ANNOTATION ) } @@ -34,7 +41,7 @@ function createHiddenArguments(hash: arkts.NumberLiteral | arkts.StringLiteral): function updateFunctionBody(node: arkts.BlockStatement | undefined, hash: arkts.NumberLiteral | arkts.StringLiteral): arkts.BlockStatement | undefined { if (node === undefined) return node - const scopeDeclaraion = arkts.factory.createVariableDeclaration( + const scopeDeclaration = arkts.factory.createVariableDeclaration( 0, arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_CONST, [ @@ -93,7 +100,7 @@ function updateFunctionBody(node: arkts.BlockStatement | undefined, hash: arkts. return arkts.factory.updateBlock( node, [ - scopeDeclaraion, + scopeDeclaration, unchangedCheck, ...node.statements, recache @@ -115,7 +122,7 @@ export class FunctionTransformer extends AbstractVisitor { if (node instanceof arkts.MethodDefinition) { if (methodDefinitionHasMemoAnnotation) { // TODO: fix - const updatedNode = arkts.factory.updateMethodDefinition( + return arkts.factory.updateMethodDefinition( node, 2, node.name, @@ -134,7 +141,6 @@ export class FunctionTransformer extends AbstractVisitor { node.modifiers, false ) - return updatedNode } } if (node instanceof arkts.CallExpression) { -- Gitee