arkanalyzer 1.0.5

package/lib/save/GraphPrinter.js

@@ -0,0 +1,135 @@
+"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.GraphPrinter = void 0;
+const Printer_1 = require("./Printer");
+function escapeStr(input) {
+    let str = input;
+    for (let i = 0; i < str.length; ++i) {
+        switch (str[i]) {
+            case '\n':
+                str = str.substring(0, i) + '\\n' + str.substring(i + 1);
+                ++i;
+                break;
+            case '\t':
+                str = str.substring(0, i) + '  ' + str.substring(i + 1);
+                ++i;
+                break;
+            case '\\':
+                if (i + 1 < str.length) {
+                    switch (str[i + 1]) {
+                        case 'l':
+                            continue; // don't disturb \l
+                        case '|':
+                        case '{':
+                        case '}':
+                            str = str.substring(0, i) + str.substring(i + 1);
+                            continue;
+                        default:
+                            break;
+                    }
+                }
+                str = str.substring(0, i) + '\\\\' + str.substring(i + 1);
+                ++i;
+                break;
+            case '{':
+            case '}':
+            case '<':
+            case '>':
+            case '|':
+            case '"':
+                str = str.substring(0, i) + '\\' + str[i] + str.substring(i + 1);
+                ++i;
+                break;
+        }
+    }
+    return str;
+}
+class GraphPrinter extends Printer_1.Printer {
+    constructor(g, t) {
+        super();
+        this.startID = undefined;
+        this.graph = g;
+        if (t) {
+            this.title = t;
+        }
+    }
+    setStartID(n) {
+        this.startID = n;
+    }
+    dump() {
+        this.printer.clear();
+        this.writeGraph();
+        return this.printer.toString();
+    }
+    dumpOriginal() {
+        return "";
+    }
+    writeGraph() {
+        this.writeHeader();
+        this.writeNodes();
+        this.writeFooter();
+    }
+    writeNodes() {
+        var _a;
+        let itor = this.graph.nodesItor();
+        if (this.startID) {
+            // from start id
+            let nodes = new Set();
+            let startNode = this.graph.getNode(this.startID);
+            let worklist = [startNode];
+            while (worklist.length > 0) {
+                let n = worklist.shift();
+                if (nodes.has(n)) {
+                    continue;
+                }
+                nodes.add(n);
+                (_a = n.getOutgoingEdges()) === null || _a === void 0 ? void 0 : _a.forEach(e => worklist.push(e.getDstNode()));
+            }
+            itor = nodes.values();
+        }
+        for (let node of itor) {
+            let nodeAttr = node.getDotAttr();
+            if (nodeAttr == '') {
+                continue;
+            }
+            let nodeLabel = escapeStr(node.getDotLabel());
+            this.printer.writeLine(`\tNode${node.getID()} [shape=recode,${nodeAttr},label="${nodeLabel}"];`);
+            for (let edge of node.getOutgoingEdges()) {
+                this.writeEdge(edge);
+            }
+        }
+    }
+    writeEdge(edge) {
+        let edgeAttr = edge.getDotAttr();
+        if (edgeAttr == '') {
+            return;
+        }
+        this.printer.writeLine(`\tNode${edge.getSrcID()} -> Node${edge.getDstID()}[${edgeAttr}]`);
+    }
+    writeHeader() {
+        const GraphName = this.graph.getGraphName();
+        let graphNameStr = `digraph "${escapeStr(this.title || GraphName || 'unnamed')}" {\n`;
+        this.printer.writeLine(graphNameStr);
+        let labelStr = `\tlabel="${escapeStr(this.title || GraphName)}";\n`;
+        this.printer.writeLine(labelStr);
+        // TODO: need graph attr?
+    }
+    writeFooter() {
+        this.printer.writeLine("}\n");
+    }
+}
+exports.GraphPrinter = GraphPrinter;

package/lib/save/JsonPrinter.d.ts

@@ -0,0 +1,28 @@
+import { Printer } from './Printer';
+import { ArkFile } from '../core/model/ArkFile';
+export declare class JsonPrinter extends Printer {
+    private arkFile;
+    constructor(arkFile: ArkFile);
+    dump(): string;
+    dumpOriginal(): string;
+    private serializeArkFile;
+    private serializeNamespace;
+    private serializeClass;
+    private serializeField;
+    private serializeMethod;
+    private serializeMethodBody;
+    private serializeMethodParameter;
+    private serializeImportInfo;
+    private serializeExportInfo;
+    private serializeLineColPosition;
+    private serializeType;
+    private serializeClassSignature;
+    private serializeFieldSignature;
+    private serializeMethodSignature;
+    private serializeCfg;
+    private serializeBasicBlock;
+    private serializeLocal;
+    private serializeValue;
+    private serializeStmt;
+}
+//# sourceMappingURL=JsonPrinter.d.ts.map

package/lib/save/JsonPrinter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonPrinter.d.ts","sourceRoot":"","sources":["../../src/save/JsonPrinter.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAgEhD,qBAAa,WAAY,SAAQ,OAAO;IACxB,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,OAAO;IAI7B,IAAI,IAAI,MAAM;IAKd,YAAY,IAAI,MAAM;IAI7B,OAAO,CAAC,gBAAgB;IAiBxB,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,cAAc;IAYtB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,wBAAwB;IAQhC,OAAO,CAAC,mBAAmB;IAW3B,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,wBAAwB;IAOhC,OAAO,CAAC,aAAa;IAyFrB,OAAO,CAAC,uBAAuB;IAM/B,OAAO,CAAC,uBAAuB;IAS/B,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,YAAY;IAuBpB,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,cAAc;IAmJtB,OAAO,CAAC,aAAa;CA4CxB"}

package/lib/save/JsonPrinter.js

@@ -0,0 +1,511 @@
+"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.JsonPrinter = void 0;
+const Printer_1 = require("./Printer");
+const Type_1 = require("../core/base/Type");
+const Stmt_1 = require("../core/base/Stmt");
+const Expr_1 = require("../core/base/Expr");
+const Constant_1 = require("../core/base/Constant");
+const Ref_1 = require("../core/base/Ref");
+const Local_1 = require("../core/base/Local");
+class JsonPrinter extends Printer_1.Printer {
+    constructor(arkFile) {
+        super();
+        this.arkFile = arkFile;
+    }
+    dump() {
+        const jsonObject = this.serializeArkFile(this.arkFile);
+        return JSON.stringify(jsonObject, null, 2);
+    }
+    dumpOriginal() {
+        return "";
+    }
+    serializeArkFile(arkFile) {
+        return {
+            name: arkFile.getName(),
+            namespaces: arkFile
+                .getNamespaces()
+                .map((ns) => this.serializeNamespace(ns)),
+            classes: arkFile
+                .getClasses()
+                .map((cls) => this.serializeClass(cls)),
+            importInfos: arkFile
+                .getImportInfos()
+                .map((info) => this.serializeImportInfo(info)),
+            exportInfos: arkFile
+                .getExportInfos().map((info) => this.serializeExportInfo(info)),
+        };
+    }
+    serializeNamespace(ns) {
+        return {
+            name: ns.getName(),
+            namespaces: ns.getNamespaces().map((ns) => this.serializeNamespace(ns)),
+            classes: ns.getClasses().map((cls) => this.serializeClass(cls)),
+        };
+    }
+    serializeClass(cls) {
+        var _a;
+        return {
+            signature: this.serializeClassSignature(cls.getSignature()),
+            modifiers: Array.from(cls.getModifiers()),
+            typeParameters: (_a = cls.getGenericsTypes()) === null || _a === void 0 ? void 0 : _a.map((type) => this.serializeType(type)),
+            superClassName: cls.getSuperClassName(),
+            implementedInterfaceNames: cls.getImplementedInterfaceNames(),
+            fields: cls.getFields().map((field) => this.serializeField(field)),
+            methods: cls.getMethods(true).map((method) => this.serializeMethod(method)),
+        };
+    }
+    serializeField(field) {
+        return {
+            signature: this.serializeFieldSignature(field.getSignature()),
+            modifiers: Array.from(field.getModifiers()),
+            questionToken: field.getQuestionToken(),
+            exclamationToken: field.getExclamationToken(),
+        };
+    }
+    serializeMethod(method) {
+        var _a;
+        return {
+            signature: this.serializeMethodSignature(method.getSignature()),
+            modifiers: Array.from(method.getModifiers()),
+            typeParameters: ((_a = method.getGenericTypes()) === null || _a === void 0 ? void 0 : _a.map(type => this.serializeType(type))) || [],
+            body: this.serializeMethodBody(method.getBody()),
+        };
+    }
+    serializeMethodBody(body) {
+        if (body === undefined) {
+            return null;
+        }
+        return {
+            locals: Array.from(body.getLocals().values()).map(local => this.serializeLocal(local)),
+            cfg: this.serializeCfg(body.getCfg()),
+        };
+    }
+    serializeMethodParameter(parameter) {
+        return {
+            name: parameter.getName(),
+            type: this.serializeType(parameter.getType()),
+            isOptional: parameter.isOptional(),
+        };
+    }
+    serializeImportInfo(importInfo) {
+        return {
+            importClauseName: importInfo.getImportClauseName(),
+            importType: importInfo.getImportType(),
+            importFrom: importInfo.getFrom(),
+            nameBeforeAs: importInfo.getNameBeforeAs(),
+            modifiers: Array.from(importInfo.getModifiers()),
+            originTsPosition: this.serializeLineColPosition(importInfo.getOriginTsPosition()),
+        };
+    }
+    serializeExportInfo(exportInfo) {
+        return {
+            exportClauseName: exportInfo.getExportClauseName(),
+            exportClauseType: exportInfo.getExportClauseType(),
+            exportFrom: exportInfo.getFrom(),
+            nameBeforeAs: exportInfo.getNameBeforeAs(),
+            isDefault: exportInfo.isDefault(),
+            modifiers: Array.from(exportInfo.getModifiers()),
+            originTsPosition: this.serializeLineColPosition(exportInfo.getOriginTsPosition()),
+        };
+    }
+    serializeLineColPosition(position) {
+        return {
+            line: position.getLineNo(),
+            col: position.getColNo(),
+        };
+    }
+    serializeType(type) {
+        if (type === undefined) {
+            return {
+                "_": "UnknownType"
+            };
+        }
+        if (type instanceof Type_1.AnyType) {
+            return {
+                "_": "AnyType"
+            };
+        }
+        else if (type instanceof Type_1.UnknownType) {
+            return {
+                "_": "UnknownType"
+            };
+        }
+        else if (type instanceof Type_1.VoidType) {
+            return {
+                "_": "VoidType"
+            };
+        }
+        else if (type instanceof Type_1.NeverType) {
+            return {
+                "_": "NeverType"
+            };
+        }
+        else if (type instanceof Type_1.UnionType) {
+            return {
+                "_": "UnionType",
+                "types": type.getTypes().map(t => this.serializeType(t)),
+            };
+        }
+        else if (type instanceof Type_1.TupleType) {
+            return {
+                "_": "TupleType",
+                "types": type.getTypes().map(t => this.serializeType(t)),
+            };
+        }
+        else if (type instanceof Type_1.BooleanType) {
+            return {
+                "_": "BooleanType"
+            };
+        }
+        else if (type instanceof Type_1.NumberType) {
+            return {
+                "_": "NumberType"
+            };
+        }
+        else if (type instanceof Type_1.StringType) {
+            return {
+                "_": "StringType"
+            };
+        }
+        else if (type instanceof Type_1.NullType) {
+            return {
+                "_": "NullType"
+            };
+        }
+        else if (type instanceof Type_1.UndefinedType) {
+            return {
+                "_": "UndefinedType"
+            };
+        }
+        else if (type instanceof Type_1.LiteralType) {
+            return {
+                "_": "LiteralType",
+                "literal": type.getLiteralName(),
+            };
+        }
+        else if (type instanceof Type_1.PrimitiveType) {
+            throw new Error("Unhandled PrimitiveType: " + type.toString());
+        }
+        else if (type instanceof Type_1.ClassType) {
+            return {
+                "_": "ClassType",
+                "signature": this.serializeClassSignature(type.getClassSignature()),
+            };
+        }
+        else if (type instanceof Type_1.FunctionType) {
+            return {
+                "_": "FunctionType",
+                "signature": this.serializeMethodSignature(type.getMethodSignature()),
+            };
+        }
+        else if (type instanceof Type_1.ArrayType) {
+            return {
+                "_": "ArrayType",
+                "elementType": this.serializeType(type.getBaseType()),
+                "dimensions": type.getDimension(),
+            };
+        }
+        else if (type instanceof Type_1.UnclearReferenceType) {
+            return {
+                "_": "UnclearReferenceType",
+                "name": type.getName(),
+            };
+        }
+        else {
+            return {
+                "_": "UNKNOWN_TYPE",
+                "type": type.toString(),
+            };
+        }
+    }
+    serializeClassSignature(clazz) {
+        return {
+            name: clazz.getClassName(),
+        };
+    }
+    serializeFieldSignature(field) {
+        return {
+            // TODO: handle NOT class signature
+            enclosingClass: this.serializeClassSignature(field.getDeclaringSignature()),
+            name: field.getFieldName(),
+            type: this.serializeType(field.getType()),
+        };
+    }
+    serializeMethodSignature(method) {
+        return {
+            enclosingClass: this.serializeClassSignature(method.getDeclaringClassSignature()),
+            name: method.getMethodSubSignature().getMethodName(),
+            parameters: method
+                .getMethodSubSignature()
+                .getParameters()
+                .map(param => this.serializeMethodParameter(param)),
+            returnType: this.serializeType(method.getType()),
+        };
+    }
+    serializeCfg(cfg) {
+        // Traverse CFG basic blocks and fill their `id` fields in topological order:
+        const visited = new Set();
+        const stack = [];
+        const startingBlock = cfg.getStartingBlock();
+        if (startingBlock) {
+            stack.push(startingBlock);
+        }
+        let id = 0;
+        while (stack.length > 0) {
+            const block = stack.pop();
+            if (visited.has(block)) {
+                continue;
+            }
+            visited.add(block);
+            block.setId(id++);
+            stack.push(...block.getSuccessors());
+        }
+        return {
+            blocks: Array.from(visited).map(block => this.serializeBasicBlock(block)),
+        };
+    }
+    serializeBasicBlock(block) {
+        const successors = block.getSuccessors().map(successor => successor.getId());
+        successors.sort((a, b) => a - b);
+        return {
+            id: block.getId(),
+            successors,
+            stmts: block.getStmts().map(stmt => this.serializeStmt(stmt)),
+        };
+    }
+    serializeLocal(local) {
+        return {
+            name: local.getName(),
+            type: this.serializeType(local.getType()),
+        };
+    }
+    serializeValue(value) {
+        if (value == null) {
+            return null;
+        }
+        if (value === undefined) {
+            throw new Error("Value is undefined");
+        }
+        if (value instanceof Local_1.Local) {
+            return Object.assign({ _: 'Local' }, this.serializeLocal(value));
+        }
+        else if (value instanceof Constant_1.Constant) {
+            return {
+                _: 'Constant',
+                value: value.getValue(),
+                type: this.serializeType(value.getType()),
+            };
+        }
+        else if (value instanceof Expr_1.ArkNewExpr) {
+            return {
+                _: 'NewExpr',
+                classType: this.serializeType(value.getClassType()),
+            };
+        }
+        else if (value instanceof Expr_1.ArkNewArrayExpr) {
+            return {
+                _: 'NewArrayExpr',
+                elementType: this.serializeType(value.getBaseType()),
+                size: this.serializeValue(value.getSize()),
+            };
+        }
+        else if (value instanceof Expr_1.ArkDeleteExpr) {
+            return {
+                _: 'DeleteExpr',
+                arg: this.serializeValue(value.getField()),
+            };
+        }
+        else if (value instanceof Expr_1.ArkAwaitExpr) {
+            return {
+                _: "AwaitExpr",
+                arg: this.serializeValue(value.getPromise()),
+            };
+        }
+        else if (value instanceof Expr_1.ArkYieldExpr) {
+            return {
+                _: "YieldExpr",
+                arg: this.serializeValue(value.getYieldValue()),
+            };
+        }
+        else if (value instanceof Expr_1.ArkTypeOfExpr) {
+            return {
+                _: 'TypeOfExpr',
+                arg: this.serializeValue(value.getOp()),
+            };
+        }
+        else if (value instanceof Expr_1.ArkInstanceOfExpr) {
+            return {
+                _: 'InstanceOfExpr',
+                arg: this.serializeValue(value.getOp()),
+                checkType: this.serializeType(value.getCheckType()),
+            };
+        }
+        else if (value instanceof Expr_1.ArkCastExpr) {
+            return {
+                _: 'CastExpr',
+                arg: this.serializeValue(value.getOp()),
+                type: this.serializeType(value.getType()),
+            };
+        }
+        else if (value instanceof Expr_1.ArkPhiExpr) {
+            const args = value.getArgs();
+            const argToBlock = value.getArgToBlock();
+            return {
+                _: 'PhiExpr',
+                args: args.map(arg => this.serializeValue(arg)),
+                blocks: args.map(arg => argToBlock.get(arg).getId()),
+                type: this.serializeType(value.getType()),
+            };
+        }
+        else if (value instanceof Expr_1.ArkConditionExpr) {
+            return {
+                _: 'ConditionExpr',
+                op: value.getOperator(),
+                left: this.serializeValue(value.getOp1()),
+                right: this.serializeValue(value.getOp2()),
+                type: this.serializeType(value.getType()),
+            };
+        }
+        else if (value instanceof Expr_1.AbstractBinopExpr) {
+            return {
+                _: 'BinopExpr',
+                op: value.getOperator(),
+                left: this.serializeValue(value.getOp1()),
+                right: this.serializeValue(value.getOp2()),
+            };
+        }
+        else if (value instanceof Expr_1.ArkUnopExpr) {
+            return {
+                _: 'UnopExpr',
+                op: value.getOperator(),
+                arg: this.serializeValue(value.getOp()),
+            };
+        }
+        else if (value instanceof Expr_1.ArkInstanceInvokeExpr) {
+            return {
+                _: 'InstanceCallExpr',
+                instance: this.serializeValue(value.getBase()),
+                method: this.serializeMethodSignature(value.getMethodSignature()),
+                args: value.getArgs().map(arg => this.serializeValue(arg)),
+            };
+        }
+        else if (value instanceof Expr_1.ArkStaticInvokeExpr) {
+            return {
+                _: 'StaticCallExpr',
+                method: this.serializeMethodSignature(value.getMethodSignature()),
+                args: value.getArgs().map(arg => this.serializeValue(arg)),
+            };
+        }
+        else if (value instanceof Ref_1.ArkThisRef) {
+            return {
+                _: 'ThisRef',
+                type: this.serializeType(value.getType()),
+            };
+        }
+        else if (value instanceof Ref_1.ArkParameterRef) {
+            return {
+                _: 'ParameterRef',
+                index: value.getIndex(),
+                type: this.serializeType(value.getType()),
+            };
+        }
+        else if (value instanceof Ref_1.ArkArrayRef) {
+            return {
+                _: 'ArrayRef',
+                array: this.serializeValue(value.getBase()),
+                index: this.serializeValue(value.getIndex()),
+                type: this.serializeType(value.getType()),
+            };
+        }
+        else if (value instanceof Ref_1.ArkInstanceFieldRef) {
+            return {
+                _: 'InstanceFieldRef',
+                instance: this.serializeValue(value.getBase()),
+                field: this.serializeFieldSignature(value.getFieldSignature()),
+            };
+        }
+        else if (value instanceof Ref_1.ArkStaticFieldRef) {
+            return {
+                _: 'StaticFieldRef',
+                field: this.serializeFieldSignature(value.getFieldSignature()),
+            };
+        }
+        else {
+            return {
+                _: 'UNKNOWN_VALUE',
+                // TODO: add simple 'value' field here to be able to see the "unknown" value
+                //       currently not possible due to circular structure
+                //       which cannot be serialized via `JSON.stringify`
+                // value,
+                value: value.toString(),
+            };
+        }
+    }
+    serializeStmt(stmt) {
+        if (stmt instanceof Stmt_1.ArkAssignStmt) {
+            return {
+                _: 'AssignStmt',
+                left: this.serializeValue(stmt.getLeftOp()),
+                right: this.serializeValue(stmt.getRightOp()),
+            };
+        }
+        else if (stmt instanceof Stmt_1.ArkInvokeStmt) {
+            return {
+                _: 'CallStmt',
+                expr: this.serializeValue(stmt.getInvokeExpr()),
+            };
+        }
+        else if (stmt instanceof Stmt_1.ArkIfStmt) {
+            return {
+                _: 'IfStmt',
+                condition: this.serializeValue(stmt.getConditionExprExpr()),
+            };
+        }
+        else if (stmt instanceof Stmt_1.ArkReturnVoidStmt) {
+            return {
+                _: 'ReturnVoidStmt',
+            };
+        }
+        else if (stmt instanceof Stmt_1.ArkReturnStmt) {
+            return {
+                _: 'ReturnStmt',
+                arg: this.serializeValue(stmt.getOp())
+            };
+        }
+        else if (stmt instanceof Stmt_1.ArkThrowStmt) {
+            return {
+                _: 'ThrowStmt',
+                arg: this.serializeValue(stmt.getOp()),
+            };
+        }
+        else if (stmt instanceof Stmt_1.ArkSwitchStmt) {
+            return {
+                _: 'SwitchStmt',
+                arg: this.serializeValue(stmt.getKey()),
+                cases: stmt.getCases().map((caseValue) => this.serializeValue(caseValue)),
+            };
+        }
+        else {
+            return {
+                _: 'UNKNOWN_STMT',
+                stmt: stmt.toString(),
+            };
+        }
+    }
+}
+exports.JsonPrinter = JsonPrinter;

package/lib/save/Printer.d.ts

@@ -0,0 +1,17 @@
+import { ArkCodeBuffer } from './ArkStream';
+/**
+ * @category save
+ */
+export declare abstract class Printer {
+    protected printer: ArkCodeBuffer;
+    constructor(indent?: string);
+    /**
+     * ArkIR dump
+     */
+    abstract dump(): string;
+    /**
+     * Original dump
+     */
+    abstract dumpOriginal(): string;
+}
+//# sourceMappingURL=Printer.d.ts.map

package/lib/save/Printer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Printer.d.ts","sourceRoot":"","sources":["../../src/save/Printer.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C;;GAEG;AACH,8BAAsB,OAAO;IACzB,SAAS,CAAC,OAAO,EAAE,aAAa,CAAC;gBAEd,MAAM,GAAE,MAAW;IAItC;;OAEG;aACa,IAAI,IAAI,MAAM;IAE9B;;OAEG;aACa,YAAY,IAAI,MAAM;CACzC"}