arkanalyzer 1.0.40 → 1.0.42

package/lib/pass/Dispatcher.js

@@ -0,0 +1,202 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dispatcher = exports.Dispatch = void 0;
+const Stmt_1 = require("../core/base/Stmt");
+const Expr_1 = require("../core/base/Expr");
+const Constant_1 = require("../core/base/Constant");
+const logger_1 = __importStar(require("../utils/logger"));
+const Local_1 = require("../core/base/Local");
+const Ref_1 = require("../core/base/Ref");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'Inst');
+/**
+ * Represents all statement types used within the system.
+ */
+const STMTS = [
+    Stmt_1.ArkAssignStmt,
+    Stmt_1.ArkInvokeStmt,
+    Stmt_1.ArkIfStmt,
+    Stmt_1.ArkReturnStmt,
+    Stmt_1.ArkReturnVoidStmt,
+    Stmt_1.ArkThrowStmt,
+    Stmt_1.ArkAliasTypeDefineStmt,
+    Stmt_1.Stmt,
+];
+/**
+ * Represents all values types used within the system.
+ */
+const VALUES = [
+    // expr
+    Expr_1.AliasTypeExpr,
+    Expr_1.ArkUnopExpr,
+    Expr_1.ArkPhiExpr,
+    Expr_1.ArkCastExpr,
+    Expr_1.ArkInstanceOfExpr,
+    Expr_1.ArkTypeOfExpr,
+    Expr_1.ArkNormalBinopExpr,
+    Expr_1.ArkConditionExpr,
+    Expr_1.AbstractBinopExpr,
+    Expr_1.ArkYieldExpr,
+    Expr_1.ArkAwaitExpr,
+    Expr_1.ArkDeleteExpr,
+    Expr_1.ArkNewArrayExpr,
+    Expr_1.ArkNewExpr,
+    Expr_1.ArkPtrInvokeExpr,
+    Expr_1.ArkStaticInvokeExpr,
+    Expr_1.ArkInstanceInvokeExpr,
+    Expr_1.AbstractInvokeExpr,
+    Expr_1.AbstractExpr,
+    // ref
+    Ref_1.ClosureFieldRef,
+    Ref_1.GlobalRef,
+    Ref_1.ArkCaughtExceptionRef,
+    Ref_1.ArkThisRef,
+    Ref_1.ArkParameterRef,
+    Ref_1.ArkStaticFieldRef,
+    Ref_1.ArkInstanceFieldRef,
+    Ref_1.AbstractFieldRef,
+    Ref_1.AbstractRef,
+    // constant
+    Constant_1.UndefinedConstant,
+    Constant_1.NullConstant,
+    Constant_1.StringConstant,
+    Constant_1.BigIntConstant,
+    Constant_1.NumberConstant,
+    Constant_1.BooleanConstant,
+    Constant_1.Constant,
+    // local
+    Local_1.Local,
+];
+/**
+ * the dispatch table, it can be cached
+ */
+class Dispatch {
+    constructor(stmts = [], values = []) {
+        this.name = 'dispatch';
+        this.stmts = [];
+        this.smap = new Map();
+        this.values = [];
+        this.vmap = new Map();
+        this.stmts = stmts.map(v => v[0]);
+        const smap = new Map();
+        for (const [k, v] of stmts) {
+            if (Array.isArray(v)) {
+                smap.set(k, v);
+            }
+            else {
+                smap.set(k, [v]);
+            }
+        }
+        // replace it, in case of modified
+        this.smap = smap;
+        this.values = values.map(v => v[0]);
+        const vmap = new Map();
+        for (const [k, v] of values) {
+            if (Array.isArray(v)) {
+                vmap.set(k, v);
+            }
+            else {
+                vmap.set(k, [v]);
+            }
+        }
+        // replace it, in case of modified
+        this.vmap = vmap;
+    }
+}
+exports.Dispatch = Dispatch;
+/**
+ * the ArkIR dispatcher, to dispatch stmts and values actions
+ */
+class Dispatcher {
+    constructor(ctx, dispatch = new Dispatch()) {
+        // action when match stmts
+        this.fallAction = 1 /* FallAction.Break */;
+        // value cache to prevent cycle dependencies
+        this.cache = new Set();
+        this.ctx = ctx;
+        this.dispatch = dispatch;
+    }
+    dispatchStmt(mtd, stmt) {
+        var _a;
+        logger.debug(`dispatch stmt ${stmt}`);
+        const tys = this.dispatch.stmts;
+        for (let ty of tys) {
+            if (stmt instanceof ty) {
+                let pass = (_a = this.dispatch.smap.get(ty)) !== null && _a !== void 0 ? _a : [];
+                for (const p of pass) {
+                    p(stmt, this.ctx, mtd);
+                }
+                if (this.fallAction === 1 /* FallAction.Break */) {
+                    break;
+                }
+            }
+        }
+        for (let use of stmt.getUses()) {
+            this.dispatchValue(mtd, use);
+        }
+    }
+    dispatchValue(mtd, value) {
+        var _a;
+        logger.debug(`dispatch value ${value}`);
+        // skip uses if there is no value pass
+        if (this.dispatch.values.length === 0) {
+            return;
+        }
+        if (this.cache.has(value)) {
+            return;
+        }
+        this.cache.add(value);
+        const tys = this.dispatch.values;
+        for (let ty of tys) {
+            if (value instanceof ty) {
+                let pass = (_a = this.dispatch.vmap.get(ty)) !== null && _a !== void 0 ? _a : [];
+                for (const p of pass) {
+                    p(value, this.ctx, mtd);
+                }
+                if (this.fallAction === 1 /* FallAction.Break */) {
+                    break;
+                }
+            }
+        }
+        for (let use of value.getUses()) {
+            this.dispatchValue(mtd, use);
+        }
+    }
+}
+exports.Dispatcher = Dispatcher;

package/lib/pass/Pass.d.ts

@@ -0,0 +1,83 @@
+import { ArkMethod } from '../core/model/ArkMethod';
+import { Context, CtxArg } from './Context';
+import { SceneCtx } from './ScenePassMgr';
+import { ArkFile } from '../core/model/ArkFile';
+import { ArkClass } from '../core/model/ArkClass';
+/**
+    fallthrough actions
+    Continue: will run next pass
+    Break: will break the pass list
+*/
+export declare const enum FallAction {
+    Continue = 0,
+    Break = 1
+}
+/**
+ * Represents an abstract file responsible for handling file-related operations.
+ * The ClassPass class is designed to define a contract for executing specific logic
+ * when processing a given class within a particular context. Implementations of this
+ * class are expected to provide concrete behavior for the `run` method.
+ *
+ * @param cls:ArkFile - The class to be executed
+ * @param ctx:FileCtx - The context used in executed
+ * @returns The result of the method execution, which can be of FallAction or void.
+ */
+export declare abstract class FilePass {
+    abstract run(file: ArkFile, ctx: FileCtx): FallAction | void;
+}
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The FileCtx is bound to a SceneCtx and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx by traversing the context hierarchy.
+ */
+export declare class FileCtx extends Context<SceneCtx, CtxArg> {
+    root(): SceneCtx;
+}
+/**
+ * Represents an abstract class responsible for handling class-related operations.
+ * The ClassPass class is designed to define a contract for executing specific logic
+ * when processing a given class within a particular context. Implementations of this
+ * class are expected to provide concrete behavior for the `run` method.
+ *
+ * @param cls:ArkClass - The class to be executed
+ * @param ctx:ClassCtx - The context used in executed
+ * @returns The result of the method execution, which can be of FallAction or void.
+ */
+export declare abstract class ClassPass {
+    abstract run(cls: ArkClass, ctx: ClassCtx): FallAction | void;
+}
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The ClassCtx is bound to a FileCtx and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx by traversing the context hierarchy.
+ */
+export declare class ClassCtx extends Context<FileCtx, CtxArg> {
+    root(): SceneCtx;
+}
+/**
+ * Represents an abstract class for executing a method within a specific context.
+ * The MethodPass class is designed to be extended by concrete implementations
+ * that define how a given method should be processed or executed.
+ *
+ * The `run` method must be implemented by subclasses to provide the logic
+ * for handling the execution of the provided method using the given context.
+ *
+ * @param method: ArkMethod - The method to be executed
+ * @param ctx: MethodCtx - The context used in executed
+ * @returns The result of the method execution, which can be of FallAction or void.
+ */
+export declare abstract class MethodPass {
+    abstract run(method: ArkMethod, ctx: MethodCtx): FallAction | void;
+}
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The MethodCtx is bound to a ClassCtx and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx by traversing the context hierarchy.
+ */
+export declare class MethodCtx extends Context<ClassCtx, CtxArg> {
+    root(): SceneCtx;
+}
+//# sourceMappingURL=Pass.d.ts.map

package/lib/pass/Pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pass.d.ts","sourceRoot":"","sources":["../../src/pass/Pass.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAElD;;;;EAIE;AACF,0BAAkB,UAAU;IACxB,QAAQ,IAAA;IACR,KAAK,IAAA;CACR;AAED;;;;;;;;;GASG;AACH,8BAAsB,QAAQ;IAC1B,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI;CAC/D;AAED;;;;;GAKG;AACH,qBAAa,OAAQ,SAAQ,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC;IAClD,IAAI,IAAI,QAAQ;CAGnB;AAGD;;;;;;;;;GASG;AACH,8BAAsB,SAAS;IAC3B,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI;CAChE;AAGD;;;;;GAKG;AACH,qBAAa,QAAS,SAAQ,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC;IAClD,IAAI,IAAI,QAAQ;CAGnB;AAED;;;;;;;;;;;GAWG;AACH,8BAAsB,UAAU;IAC5B,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG,UAAU,GAAG,IAAI;CACrE;AAED;;;;;GAKG;AACH,qBAAa,SAAU,SAAQ,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC;IACpD,IAAI,IAAI,QAAQ;CAGnB"}

package/lib/pass/Pass.js

@@ -0,0 +1,95 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodCtx = exports.MethodPass = exports.ClassCtx = exports.ClassPass = exports.FileCtx = exports.FilePass = void 0;
+const Context_1 = require("./Context");
+/**
+ * Represents an abstract file responsible for handling file-related operations.
+ * The ClassPass class is designed to define a contract for executing specific logic
+ * when processing a given class within a particular context. Implementations of this
+ * class are expected to provide concrete behavior for the `run` method.
+ *
+ * @param cls:ArkFile - The class to be executed
+ * @param ctx:FileCtx - The context used in executed
+ * @returns The result of the method execution, which can be of FallAction or void.
+ */
+class FilePass {
+}
+exports.FilePass = FilePass;
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The FileCtx is bound to a SceneCtx and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx by traversing the context hierarchy.
+ */
+class FileCtx extends Context_1.Context {
+    root() {
+        return this.upper.root();
+    }
+}
+exports.FileCtx = FileCtx;
+/**
+ * Represents an abstract class responsible for handling class-related operations.
+ * The ClassPass class is designed to define a contract for executing specific logic
+ * when processing a given class within a particular context. Implementations of this
+ * class are expected to provide concrete behavior for the `run` method.
+ *
+ * @param cls:ArkClass - The class to be executed
+ * @param ctx:ClassCtx - The context used in executed
+ * @returns The result of the method execution, which can be of FallAction or void.
+ */
+class ClassPass {
+}
+exports.ClassPass = ClassPass;
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The ClassCtx is bound to a FileCtx and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx by traversing the context hierarchy.
+ */
+class ClassCtx extends Context_1.Context {
+    root() {
+        return this.upper.root();
+    }
+}
+exports.ClassCtx = ClassCtx;
+/**
+ * Represents an abstract class for executing a method within a specific context.
+ * The MethodPass class is designed to be extended by concrete implementations
+ * that define how a given method should be processed or executed.
+ *
+ * The `run` method must be implemented by subclasses to provide the logic
+ * for handling the execution of the provided method using the given context.
+ *
+ * @param method: ArkMethod - The method to be executed
+ * @param ctx: MethodCtx - The context used in executed
+ * @returns The result of the method execution, which can be of FallAction or void.
+ */
+class MethodPass {
+}
+exports.MethodPass = MethodPass;
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The MethodCtx is bound to a ClassCtx and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx by traversing the context hierarchy.
+ */
+class MethodCtx extends Context_1.Context {
+    root() {
+        return this.upper.root();
+    }
+}
+exports.MethodCtx = MethodCtx;

package/lib/pass/ScenePassMgr.d.ts

@@ -0,0 +1,73 @@
+import { Scene } from '../Scene';
+import { AnyKey, Context, CtxArg, UpperRoot } from './Context';
+import { Dispatcher } from './Dispatcher';
+import { ClassPass, FilePass, MethodPass } from './Pass';
+import { ArkFile } from '../core/model/ArkFile';
+import { ArkClass } from '../core/model/ArkClass';
+import { ArkMethod } from '../core/model/ArkMethod';
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The SceneCtx is bound to a UpperRoot and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx itself.
+ */
+export declare class SceneCtx extends Context<UpperRoot, CtxArg> {
+    constructor();
+    root(): SceneCtx;
+}
+/**
+ * Represents the properties required for configuring various passes in a system.
+ * The PassProps interface is designed to hold arrays of different types of passes,
+ * specifically file-level, class-level, and method-level passes. Each pass type
+ * is identified by a unique key and associated with specific configurations or rules.
+ * These passes are used to define how certain operations or validations should be
+ * applied at different levels of granularity within the system.
+ */
+export interface PassProps {
+    file: AnyKey<FilePass>[];
+    klass: AnyKey<ClassPass>[];
+    method: AnyKey<MethodPass>[];
+}
+/**
+ * Represents the properties for a selector configuration.
+ * Provides options to define callback functions for selecting files, classes, and methods.
+ * The file property allows specifying a function to select files from a given scene.
+ * The klass property allows specifying a function to select classes from a given file.
+ * The method property allows specifying a function to select methods from a given class.
+ */
+export interface SelectorProps {
+    file?: (s: Scene) => ArkFile[];
+    klass?: (s: ArkFile) => ArkClass[];
+    method?: (s: ArkClass) => ArkMethod[];
+}
+/**
+ * Represents the properties for configuring a scene pass manager.
+ *
+ * The SceneProps interface allows defining optional configurations for a scene,
+ * including rendering passes, selector properties, and a dispatcher implementation.
+ *
+ * The passes property defines the configuration for rendering stages or phases within the scene.
+ *
+ * The selectors property provides options for selecting elements or components within the scene.
+ *
+ * The dispatcher property specifies the dispatcher class responsible for handling events or actions
+ * within the scene, defaulting to the base Dispatcher type if not provided.
+ */
+export interface SceneProps {
+    passes?: PassProps;
+    selectors?: SelectorProps;
+    dispatcher?: typeof Dispatcher;
+}
+export declare class ScenePassMgr {
+    private passes;
+    private selectors?;
+    private dispatcher?;
+    private sctx;
+    constructor(props: SceneProps);
+    sceneContext(): SceneCtx;
+    run(scene: Scene): void;
+    private iterFile;
+    private iterClass;
+    private iterMethod;
+}
+//# sourceMappingURL=ScenePassMgr.d.ts.map

package/lib/pass/ScenePassMgr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScenePassMgr.d.ts","sourceRoot":"","sources":["../../src/pass/ScenePassMgr.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE/D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAY,SAAS,EAAuB,QAAQ,EAAa,UAAU,EAAE,MAAM,QAAQ,CAAC;AACnG,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAIpD;;;;;GAKG;AACH,qBAAa,QAAS,SAAQ,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC;;IAKpD,IAAI,IAAI,QAAQ;CAGnB;AAGD;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IAEtB,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IAEzB,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;IAE3B,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAE,CAAA;CAC/B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAE1B,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,OAAO,EAAE,CAAC;IAE/B,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,QAAQ,EAAE,CAAC;IAEnC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,SAAS,EAAE,CAAA;CACxC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,UAAU;IACvB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,UAAU,CAAC,EAAE,OAAO,UAAU,CAAC;CAClC;AAED,qBAAa,YAAY;IACrB,OAAO,CAAC,MAAM,CAIZ;IACF,OAAO,CAAC,SAAS,CAAC,CAA4B;IAC9C,OAAO,CAAC,UAAU,CAAC,CAAiC;IACpD,OAAO,CAAC,IAAI,CAA4B;gBAE5B,KAAK,EAAE,UAAU;IAY7B,YAAY,IAAI,QAAQ;IAIxB,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAavB,OAAO,CAAC,QAAQ;IAmBhB,OAAO,CAAC,SAAS;IAmBjB,OAAO,CAAC,UAAU;CAgBrB"}

package/lib/pass/ScenePassMgr.js

@@ -0,0 +1,156 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScenePassMgr = exports.SceneCtx = void 0;
+const Context_1 = require("./Context");
+const logger_1 = __importStar(require("../utils/logger"));
+const Dispatcher_1 = require("./Dispatcher");
+const Pass_1 = require("./Pass");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'SceneMgr');
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The SceneCtx is bound to a UpperRoot and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx itself.
+ */
+class SceneCtx extends Context_1.Context {
+    constructor() {
+        super(Context_1.UpperRoot.getInstance());
+    }
+    root() {
+        return this;
+    }
+}
+exports.SceneCtx = SceneCtx;
+class ScenePassMgr {
+    constructor(props) {
+        this.passes = {
+            file: [],
+            klass: [],
+            method: [],
+        };
+        this.selectors = undefined;
+        this.dispatcher = Dispatcher_1.Dispatcher;
+        this.sctx = new SceneCtx();
+        if (props.passes) {
+            this.passes = props.passes;
+        }
+        if (props.selectors) {
+            this.selectors = props.selectors;
+        }
+        if (props.dispatcher) {
+            this.dispatcher = props.dispatcher;
+        }
+    }
+    sceneContext() {
+        return this.sctx;
+    }
+    run(scene) {
+        var _a;
+        logger.info('run scene');
+        let files;
+        if ((_a = this.selectors) === null || _a === void 0 ? void 0 : _a.file) {
+            files = this.selectors.file(scene);
+        }
+        else {
+            files = scene.getFiles();
+        }
+        for (let file of files) {
+            this.iterFile(file);
+        }
+    }
+    iterFile(file) {
+        var _a;
+        let fctx = new Pass_1.FileCtx(this.sctx);
+        for (let P of this.passes.file) {
+            let p = new P();
+            if (p.run(file, fctx) === 1 /* FallAction.Break */) {
+                break;
+            }
+        }
+        let classes;
+        if ((_a = this.selectors) === null || _a === void 0 ? void 0 : _a.klass) {
+            classes = this.selectors.klass(file);
+        }
+        else {
+            classes = file.getClasses();
+        }
+        for (let cls of classes) {
+            this.iterClass(cls, fctx);
+        }
+    }
+    iterClass(cls, fctx) {
+        var _a;
+        let cctx = new Pass_1.ClassCtx(fctx);
+        for (let P of this.passes.klass) {
+            let p = new P();
+            if (p.run(cls, cctx) === 1 /* FallAction.Break */) {
+                break;
+            }
+        }
+        let methods;
+        if ((_a = this.selectors) === null || _a === void 0 ? void 0 : _a.method) {
+            methods = this.selectors.method(cls);
+        }
+        else {
+            methods = cls.getMethods();
+        }
+        for (let mtd of methods) {
+            this.iterMethod(mtd, cctx);
+        }
+    }
+    iterMethod(mtd, cctx) {
+        var _a;
+        let mctx = new Pass_1.MethodCtx(cctx);
+        for (let P of this.passes.method) {
+            let p = new P();
+            if (p.run(mtd, mctx) === 1 /* FallAction.Break */) {
+                break;
+            }
+        }
+        if (this.dispatcher) {
+            let stmts = ((_a = mtd.getCfg()) === null || _a === void 0 ? void 0 : _a.getStmts()) || [];
+            let dispatcher = new this.dispatcher(mctx);
+            for (let s of stmts) {
+                dispatcher.dispatchStmt(mtd, s);
+            }
+        }
+    }
+}
+exports.ScenePassMgr = ScenePassMgr;