arkanalyzer 1.0.5

package/lib/core/dataflow/UndefinedVariable.js

@@ -0,0 +1,235 @@
+"use strict";
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndefinedVariableSolver = exports.UndefinedVariableChecker = void 0;
+const DataflowProblem_1 = require("./DataflowProblem");
+const Local_1 = require("../base/Local");
+const Type_1 = require("../base/Type");
+const Stmt_1 = require("../base/Stmt");
+const Constant_1 = require("../base/Constant");
+const Ref_1 = require("../base/Ref");
+const DataflowSolver_1 = require("./DataflowSolver");
+const Expr_1 = require("../base/Expr");
+const DataflowSolver_2 = require("../dataflow/DataflowSolver");
+class UndefinedVariableChecker extends DataflowProblem_1.DataflowProblem {
+    constructor(stmt, method) {
+        super();
+        this.zeroValue = new Constant_1.Constant('undefined', Type_1.UndefinedType.getInstance());
+        this.entryPoint = stmt;
+        this.entryMethod = method;
+        this.scene = method.getDeclaringArkFile().getScene();
+        this.classMap = this.scene.getClassMap();
+        this.globalVariableMap = this.scene.getGlobalVariableMap();
+    }
+    getEntryPoint() {
+        return this.entryPoint;
+    }
+    getEntryMethod() {
+        return this.entryMethod;
+    }
+    isUndefined(val) {
+        if (val instanceof Constant_1.Constant) {
+            let constant = val;
+            if (constant.getType() instanceof Type_1.UndefinedType) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getNormalFlowFunction(srcStmt, tgtStmt) {
+        let checkerInstance = this;
+        return new class {
+            getDataFacts(dataFact) {
+                let ret = new Set();
+                if (checkerInstance.getEntryPoint() == srcStmt && checkerInstance.getZeroValue() == dataFact) {
+                    let entryMethod = checkerInstance.getEntryMethod();
+                    const parameters = [...entryMethod.getCfg().getBlocks()][0].getStmts().slice(0, entryMethod.getParameters().length);
+                    for (let i = 0; i < parameters.length; i++) {
+                        const para = parameters[i].getDef();
+                        if (para)
+                            ret.add(para);
+                    }
+                    ret.add(checkerInstance.getZeroValue());
+                    // 加入所有的全局变量和静态属性（may analysis）
+                    const staticFields = entryMethod.getDeclaringArkClass().getStaticFields(checkerInstance.classMap);
+                    for (const field of staticFields) {
+                        const initializer = field.getInitializer();
+                        if (initializer.length == 1 && initializer[0] instanceof Stmt_1.ArkAssignStmt && initializer[0].getRightOp() == undefined) {
+                            ret.add(new Ref_1.ArkStaticFieldRef(field.getSignature()));
+                        }
+                    }
+                    for (const local of entryMethod.getDeclaringArkClass().getGlobalVariable(checkerInstance.globalVariableMap)) {
+                        ret.add(local);
+                    }
+                    return ret;
+                }
+                if (!(0, DataflowSolver_2.factEqual)(srcStmt.getDef(), dataFact)) {
+                    if (!(dataFact instanceof Local_1.Local && dataFact.getName() == srcStmt.getDef().toString()))
+                        ret.add(dataFact);
+                }
+                if (srcStmt instanceof Stmt_1.ArkAssignStmt) {
+                    let ass = srcStmt;
+                    let assigned = ass.getLeftOp();
+                    let rightOp = ass.getRightOp();
+                    if (checkerInstance.getZeroValue() == dataFact) {
+                        if (checkerInstance.isUndefined(rightOp)) {
+                            ret.add(assigned);
+                        }
+                    }
+                    else if ((0, DataflowSolver_2.factEqual)(rightOp, dataFact) || rightOp.getType() instanceof Type_1.UndefinedType) {
+                        ret.add(assigned);
+                    }
+                    else if (rightOp instanceof Ref_1.ArkInstanceFieldRef) {
+                        const base = rightOp.getBase();
+                        if (base == dataFact || !base.getDeclaringStmt() && base.getName() == dataFact.toString()) {
+                            console.log("undefined base");
+                            console.log(srcStmt.toString());
+                            console.log(srcStmt.getOriginPositionInfo().toString());
+                        }
+                    }
+                    else if (dataFact instanceof Ref_1.ArkInstanceFieldRef && rightOp == dataFact.getBase()) {
+                        const field = new Ref_1.ArkInstanceFieldRef(srcStmt.getLeftOp(), dataFact.getFieldSignature());
+                        ret.add(field);
+                    }
+                }
+                return ret;
+            }
+        };
+    }
+    getCallFlowFunction(srcStmt, method) {
+        let checkerInstance = this;
+        return new class {
+            getDataFacts(dataFact) {
+                const ret = new Set();
+                if (checkerInstance.getZeroValue() == dataFact) {
+                    ret.add(checkerInstance.getZeroValue());
+                    // 加上调用函数能访问到的所有静态变量，如果不考虑多线程，加上所有变量，考虑则要统计之前已经处理过的变量并排除
+                    for (const field of method.getDeclaringArkClass().getStaticFields(checkerInstance.classMap)) {
+                        if (field.getInitializer() == undefined) {
+                            ret.add(new Ref_1.ArkStaticFieldRef(field.getSignature()));
+                        }
+                    }
+                    for (const local of method.getDeclaringArkClass().getGlobalVariable(checkerInstance.globalVariableMap)) {
+                        ret.add(local);
+                    }
+                }
+                else {
+                    const callExpr = srcStmt.getExprs()[0];
+                    if (callExpr instanceof Expr_1.ArkInstanceInvokeExpr && dataFact instanceof Ref_1.ArkInstanceFieldRef && callExpr.getBase().getName() == dataFact.getBase().getName()) {
+                        // todo:base转this
+                        const baseType = callExpr.getBase().getType();
+                        const arkClass = checkerInstance.scene.getClass(baseType.getClassSignature());
+                        const constructor = arkClass === null || arkClass === void 0 ? void 0 : arkClass.getMethodWithName("constructor");
+                        const block = [...constructor.getCfg().getBlocks()][0];
+                        for (const stmt of block.getStmts()) {
+                            const def = stmt.getDef();
+                            if (def && def instanceof Ref_1.ArkInstanceFieldRef && def.getBase().getName() == "this" && def.getFieldName() == dataFact.getFieldName()) {
+                                ret.add(def);
+                                break;
+                            }
+                        }
+                    }
+                    else if (callExpr instanceof Expr_1.ArkStaticInvokeExpr && dataFact instanceof Ref_1.ArkStaticFieldRef && callExpr.getMethodSignature().getDeclaringClassSignature() == dataFact.getFieldSignature().getDeclaringSignature()) {
+                        ret.add(dataFact);
+                    }
+                }
+                const callStmt = srcStmt;
+                const args = callStmt.getInvokeExpr().getArgs();
+                for (let i = 0; i < args.length; i++) {
+                    if (args[i] == dataFact || checkerInstance.isUndefined(args[i]) && checkerInstance.getZeroValue() == dataFact) {
+                        const realParameter = [...method.getCfg().getBlocks()][0].getStmts()[i].getDef();
+                        if (realParameter)
+                            ret.add(realParameter);
+                    }
+                    else if (dataFact instanceof Ref_1.ArkInstanceFieldRef && dataFact.getBase().getName() == args[i].toString()) {
+                        const realParameter = [...method.getCfg().getBlocks()][0].getStmts()[i].getDef();
+                        if (realParameter) {
+                            const retRef = new Ref_1.ArkInstanceFieldRef(realParameter, dataFact.getFieldSignature());
+                            ret.add(retRef);
+                        }
+                    }
+                }
+                return ret;
+            }
+        };
+    }
+    getExitToReturnFlowFunction(srcStmt, tgtStmt, callStmt) {
+        let checkerInstance = this;
+        return new class {
+            getDataFacts(dataFact) {
+                let ret = new Set();
+                if (dataFact == checkerInstance.getZeroValue()) {
+                    ret.add(checkerInstance.getZeroValue());
+                }
+                if (dataFact instanceof Ref_1.ArkInstanceFieldRef && dataFact.getBase().getName() == "this") {
+                    // todo:this转base。
+                    const expr = callStmt.getExprs()[0];
+                    if (expr instanceof Expr_1.ArkInstanceInvokeExpr) {
+                        const fieldRef = new Ref_1.ArkInstanceFieldRef(expr.getBase(), dataFact.getFieldSignature());
+                        ret.add(fieldRef);
+                    }
+                }
+                if (!(callStmt instanceof Stmt_1.ArkAssignStmt)) {
+                    return ret;
+                }
+                if (srcStmt instanceof Stmt_1.ArkReturnStmt) {
+                    let ass = callStmt;
+                    let leftOp = ass.getLeftOp();
+                    let retVal = srcStmt.getOp();
+                    if (dataFact == checkerInstance.getZeroValue()) {
+                        ret.add(checkerInstance.getZeroValue());
+                        if (checkerInstance.isUndefined(retVal)) {
+                            ret.add(leftOp);
+                        }
+                    }
+                    else if (retVal == dataFact) {
+                        ret.add(leftOp);
+                    }
+                }
+                return ret;
+            }
+        };
+    }
+    getCallToReturnFlowFunction(srcStmt, tgtStmt) {
+        let checkerInstance = this;
+        return new class {
+            getDataFacts(dataFact) {
+                const ret = new Set();
+                if (checkerInstance.getZeroValue() == dataFact) {
+                    ret.add(checkerInstance.getZeroValue());
+                }
+                const defValue = srcStmt.getDef();
+                if (!(defValue && defValue == dataFact)) {
+                    ret.add(dataFact);
+                }
+                return ret;
+            }
+        };
+    }
+    createZeroValue() {
+        return this.zeroValue;
+    }
+    getZeroValue() {
+        return this.zeroValue;
+    }
+}
+exports.UndefinedVariableChecker = UndefinedVariableChecker;
+class UndefinedVariableSolver extends DataflowSolver_1.DataflowSolver {
+    constructor(problem, scene) {
+        super(problem, scene);
+    }
+}
+exports.UndefinedVariableSolver = UndefinedVariableSolver;

package/lib/core/dataflow/Util.d.ts

@@ -0,0 +1,8 @@
+import { ArkInvokeStmt } from "../base/Stmt";
+import { ArkMethod } from "../model/ArkMethod";
+import { Scene } from "../../Scene";
+export declare const INTERNAL_PARAMETER_SOURCE: string[];
+export declare const INTERNAL_SINK_METHOD: string[];
+export declare function Json2ArkMethod(str: string, scene: Scene): ArkMethod | null;
+export declare function getRecallMethodInParam(stmt: ArkInvokeStmt): ArkMethod | null;
+//# sourceMappingURL=Util.d.ts.map

package/lib/core/dataflow/Util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Util.d.ts","sourceRoot":"","sources":["../../../src/core/dataflow/Util.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAG7C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGpC,eAAO,MAAM,yBAAyB,EAAE,MAAM,EAE7C,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,MAAM,EAMxC,CAAA;AAID,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,IAAI,CAsF1E;AAGD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,GAAG,IAAI,CAW5E"}

package/lib/core/dataflow/Util.js

@@ -0,0 +1,137 @@
+"use strict";
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRecallMethodInParam = exports.Json2ArkMethod = exports.INTERNAL_SINK_METHOD = exports.INTERNAL_PARAMETER_SOURCE = void 0;
+const Type_1 = require("../base/Type");
+exports.INTERNAL_PARAMETER_SOURCE = [
+    '@ohos.app.ability.Want.d.ts: Want'
+];
+exports.INTERNAL_SINK_METHOD = [
+    'console.<@_UnknownProjectName/_UnknownFileName: .log()>',
+    'console.<@_UnknownProjectName/_UnknownFileName: .error()>',
+    'console.<@_UnknownProjectName/_UnknownFileName: .info()>',
+    'console.<@_UnknownProjectName/_UnknownFileName: .warn()>',
+    'console.<@_UnknownProjectName/_UnknownFileName: .assert()>'
+];
+const filenamePrefix = '@etsSdk/api/';
+function Json2ArkMethod(str, scene) {
+    const mes = str.split(': ');
+    const fileName = filenamePrefix + mes[0] + ': ';
+    const otherMes = mes.slice(1).join(': ').split('.');
+    if (otherMes.length < 3) {
+        return null;
+    }
+    const namespaceName = otherMes[0], className = otherMes[1], methodName = otherMes[2].split('(')[0];
+    let paramNames = [];
+    if (otherMes[2]) {
+        if (!otherMes[2].match(/\((.*?)\)/)) {
+            return null;
+        }
+        paramNames = otherMes[2].match(/\((.*?)\)/)[1].split(',').map((item) => item.replace(/\s/g, '')).filter((item) => item !== '');
+    }
+    const file = scene.getSdkArkFilesMap().get(fileName);
+    if (!file) {
+        // console.log("no file: " + fileName);
+        return null;
+    }
+    let arkClass = null;
+    if (namespaceName == "_") {
+        if (className == '_') {
+            arkClass = file.getDefaultClass();
+        }
+        else {
+            for (const clas of file.getClasses()) {
+                if (clas.getName() == className) {
+                    arkClass = clas;
+                    break;
+                }
+            }
+        }
+    }
+    else {
+        let arkNamespace = null;
+        for (const ns of file.getNamespaces()) {
+            if (ns.getName() == namespaceName) {
+                arkNamespace = ns;
+                break;
+            }
+        }
+        if (arkNamespace) {
+            if (className == '_') {
+                arkClass = arkNamespace.getDefaultClass();
+            }
+            else {
+                for (const clas of arkNamespace.getClasses()) {
+                    if (clas.getName() == className) {
+                        arkClass = clas;
+                        break;
+                    }
+                }
+            }
+        }
+        else {
+            // console.log("no namespace: " + namespaceName);
+            return null;
+        }
+    }
+    if (!arkClass) {
+        // console.log("no class: " + className);
+        return null;
+    }
+    else {
+        let arkMethod = null;
+        for (const method of arkClass.getMethods()) {
+            if (method.getName() == methodName) {
+                arkMethod = method;
+                break;
+            }
+        }
+        if (arkMethod && arkMethod.getParameters().length == paramNames.length) {
+            let paramEqual = true;
+            for (let i = 0; i < arkMethod.getParameters().length; i++) {
+                const param = arkMethod.getParameters()[i];
+                if (param.getName() + ':' + param.getType().toString() != paramNames[i]) {
+                    paramEqual = false;
+                    break;
+                }
+            }
+            if (paramEqual) {
+                return arkMethod;
+            }
+        }
+        else {
+            // console.log("no method: " + methodName);
+            return null;
+        }
+    }
+    return null;
+}
+exports.Json2ArkMethod = Json2ArkMethod;
+// 如果调用回调函数的函数是项目内函数就不用管，会进函数内部执行，只有是sdk函数才需要分析
+function getRecallMethodInParam(stmt) {
+    var _a;
+    for (const param of stmt.getInvokeExpr().getArgs()) {
+        if (param.getType() instanceof Type_1.FunctionType) {
+            const methodSignature = param.getType().getMethodSignature();
+            const method = (_a = stmt.getCfg()) === null || _a === void 0 ? void 0 : _a.getDeclaringMethod().getDeclaringArkClass().getMethod(methodSignature);
+            if (method) {
+                return method;
+            }
+        }
+    }
+    return null;
+}
+exports.getRecallMethodInParam = getRecallMethodInParam;

package/lib/core/graph/BasicBlock.d.ts

@@ -0,0 +1,26 @@
+import { Stmt } from '../base/Stmt';
+/**
+ * @category core/graph
+ */
+export declare class BasicBlock {
+    private id;
+    private stmts;
+    private predecessorBlocks;
+    private successorBlocks;
+    constructor();
+    getId(): number;
+    setId(id: number): void;
+    getStmts(): Stmt[];
+    addStmt(stmt: Stmt): void;
+    getHead(): Stmt | null;
+    getTail(): Stmt | null;
+    getSuccessors(): BasicBlock[];
+    getPredecessors(): BasicBlock[];
+    addPredecessorBlock(block: BasicBlock): void;
+    setPredecessorBlock(idx: number, block: BasicBlock): boolean;
+    setSuccessorBlock(idx: number, block: BasicBlock): boolean;
+    addStmtToFirst(stmt: Stmt): void;
+    addSuccessorBlock(block: BasicBlock): void;
+    toString(): string;
+}
+//# sourceMappingURL=BasicBlock.d.ts.map

package/lib/core/graph/BasicBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BasicBlock.d.ts","sourceRoot":"","sources":["../../../src/core/graph/BasicBlock.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEpC;;GAEG;AACH,qBAAa,UAAU;IACnB,OAAO,CAAC,EAAE,CAAc;IACxB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,eAAe,CAAoB;;IAKpC,KAAK,IAAI,MAAM;IAIf,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIvB,QAAQ,IAAI,IAAI,EAAE;IAIlB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAIzB,OAAO,IAAI,IAAI,GAAG,IAAI;IAOtB,OAAO,IAAI,IAAI,GAAG,IAAI;IAQtB,aAAa,IAAI,UAAU,EAAE;IAI7B,eAAe,IAAI,UAAU,EAAE;IAI/B,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAI5C,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO;IAQ5D,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO;IAS1D,cAAc,CAAC,IAAI,EAAE,IAAI;IAKzB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAI1C,QAAQ,IAAI,MAAM;CAO5B"}

package/lib/core/graph/BasicBlock.js

@@ -0,0 +1,92 @@
+"use strict";
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicBlock = void 0;
+/**
+ * @category core/graph
+ */
+class BasicBlock {
+    constructor() {
+        this.id = -1;
+        this.stmts = [];
+        this.predecessorBlocks = [];
+        this.successorBlocks = [];
+    }
+    getId() {
+        return this.id;
+    }
+    setId(id) {
+        this.id = id;
+    }
+    getStmts() {
+        return this.stmts;
+    }
+    addStmt(stmt) {
+        this.stmts.push(stmt);
+    }
+    getHead() {
+        if (this.stmts.length == 0) {
+            return null;
+        }
+        return this.stmts[0];
+    }
+    getTail() {
+        let size = this.stmts.length;
+        if (size == 0) {
+            return null;
+        }
+        return this.stmts[size - 1];
+    }
+    getSuccessors() {
+        return this.successorBlocks;
+    }
+    getPredecessors() {
+        return this.predecessorBlocks;
+    }
+    addPredecessorBlock(block) {
+        this.predecessorBlocks.push(block);
+    }
+    setPredecessorBlock(idx, block) {
+        if (idx < this.predecessorBlocks.length) {
+            this.predecessorBlocks[idx] = block;
+            return true;
+        }
+        return false;
+    }
+    setSuccessorBlock(idx, block) {
+        if (idx < this.successorBlocks.length) {
+            this.successorBlocks[idx] = block;
+            return true;
+        }
+        return false;
+    }
+    // Temp just for SSA
+    addStmtToFirst(stmt) {
+        this.stmts.splice(0, 0, stmt);
+    }
+    // Temp just for SSA
+    addSuccessorBlock(block) {
+        this.successorBlocks.push(block);
+    }
+    toString() {
+        let strs = [];
+        for (const stmt of this.stmts) {
+            strs.push(stmt.toString() + '\n');
+        }
+        return strs.join('');
+    }
+}
+exports.BasicBlock = BasicBlock;

package/lib/core/graph/Cfg.d.ts

@@ -0,0 +1,29 @@
+import { DefUseChain } from '../base/DefUseChain';
+import { Stmt } from '../base/Stmt';
+import { ArkMethod } from '../model/ArkMethod';
+import { BasicBlock } from './BasicBlock';
+/**
+ * @category core/graph
+ */
+export declare class Cfg {
+    private blocks;
+    private stmtToBlock;
+    private startingStmt;
+    private defUseChains;
+    private declaringMethod;
+    constructor();
+    getStmts(): Stmt[];
+    insertBefore(beforeStmt: Stmt, newStmt: Stmt): void;
+    addBlock(block: BasicBlock): void;
+    getBlocks(): Set<BasicBlock>;
+    getStartingBlock(): BasicBlock | undefined;
+    getStartingStmt(): Stmt;
+    setStartingStmt(newStartingStmt: Stmt): void;
+    getDeclaringMethod(): ArkMethod;
+    setDeclaringMethod(method: ArkMethod): void;
+    getDefUseChains(): DefUseChain[];
+    toString(): string;
+    buildDefUseStmt(): void;
+    buildDefUseChain(): void;
+}
+//# sourceMappingURL=Cfg.d.ts.map

package/lib/core/graph/Cfg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cfg.d.ts","sourceRoot":"","sources":["../../../src/core/graph/Cfg.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,EAAgB,IAAI,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C;;GAEG;AACH,qBAAa,GAAG;IACZ,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,YAAY,CAAuD;IAE3E,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,eAAe,CAA8B;;IAM9C,QAAQ,IAAI,IAAI,EAAE;IASlB,YAAY,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,GAAG,IAAI;IAQnD,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IASjC,SAAS,IAAI,GAAG,CAAC,UAAU,CAAC;IAK5B,gBAAgB,IAAI,UAAU,GAAG,SAAS;IAI1C,eAAe,IAAI,IAAI;IAIvB,eAAe,CAAC,eAAe,EAAE,IAAI,GAAG,IAAI;IAI5C,kBAAkB,IAAI,SAAS;IAI/B,kBAAkB,CAAC,MAAM,EAAE,SAAS;IAIpC,eAAe,IAAI,WAAW,EAAE;IAKhC,QAAQ,IAAI,MAAM;IAIlB,eAAe;IAiBf,gBAAgB;CAyD1B"}