@lcap/nasl 3.4.0-beta.3 → 3.4.0-beta.4

package/out/concepts/Match__.js

@@ -1,696 +1,698 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var Match_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Match = void 0;
-const translator_1 = require("../translator");
-const TypeAnnotation__1 = __importDefault(require("./TypeAnnotation__"));
-const BooleanLiteral__1 = __importDefault(require("./BooleanLiteral__"));
-const MemberExpression__1 = __importDefault(require("./MemberExpression__"));
-const getMemberIdentifier_1 = require("../server/getMemberIdentifier");
-const Identifier__1 = __importDefault(require("./Identifier__"));
-const decorators_1 = require("../decorators");
-const LogicItem__1 = __importDefault(require("./LogicItem__"));
-const MatchCase__1 = __importDefault(require("./MatchCase__"));
-/**
- * 匹配
- */
-let Match = class Match extends LogicItem__1.default {
-    static { Match_1 = this; }
-    /** 类名 */
-    static ConceptName = 'Match';
-    /**
-     * 产品概念
-     */
-    concept;
-    /**
-     * 逻辑项
-     */
-    // @ts-ignore
-    expression;
-    /**
-     * 是否表达式形态
-     */
-    isExpression = false;
-    /**
-     * 匹配分支列表
-     */
-    cases = [];
-    /**
-     * @param source 需要合并的部分参数
-     */
-    constructor(source) {
-        source = Object.assign({}, Match_1.getDefaultOptions(), source);
-        super(source);
-        super.subConstructor(source);
-    }
-    static from(source, parentNode, parentKey) {
-        return super.from(source, parentNode, parentKey);
-    }
-    _insertMatchCaseAt(options, index) {
-        const matchCaseOptions = {};
-        const relationOptions = { parentNode: this, parentKey: 'cases' };
-        let matchCase;
-        if (options instanceof MatchCase__1.default) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            matchCase = options;
-            Object.assign(matchCase, relationOptions);
-        }
-        else {
-            matchCase = MatchCase__1.default.from({
-                ...matchCaseOptions,
-                ...options,
-            }, this, 'cases');
-        }
-        this.cases.splice(index, 0, matchCase);
-        return matchCase;
-    }
-    insertMatchCaseAt(options, index) {
-        const node = this._insertMatchCaseAt(options, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'cases',
-        });
-        return node;
-    }
-    _addMatchCase(options) {
-        const index = this.cases.length;
-        return this._insertMatchCaseAt(options, index);
-    }
-    addMatchCase(options) {
-        const node = this._addMatchCase(options);
-        const index = this.cases.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'cases',
-        });
-        return node;
-    }
-    removeExpression(options) {
-        let expression;
-        if (typeof options === 'string') {
-            expression = this.expression;
-            if (!expression) {
-                throw new Error('找不到逻辑项 ' + options);
-            }
-        }
-        else {
-            expression = options;
-        }
-        return expression.delete();
-    }
-    removeMatchCaseInCases(options) {
-        let matchCase = options;
-        return matchCase.delete();
-    }
-    __removeLogicItem(logicItem) {
-        const parentKey = logicItem.parentKey;
-        const params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: logicItem,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            // @ts-ignore
-            const t = this.__v_raw || this;
-            // @ts-ignore
-            const n = logicItem.__v_raw || logicItem;
-            if (Array.isArray(t[parentKey])) {
-                const index = t[parentKey].indexOf(n);
-                ~index && this[parentKey].splice(index, 1);
-                params.index = index;
-            }
-            else if (t[parentKey] === n) {
-                params.index = 0;
-                this[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-    //================================================================================
-    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
-    // 自动生成的代码已结束。下面可以手动编写。
-    //================================================================================
-    enumerableItems;
-    get isEnumerable() {
-        return !!this.enumerableItems?.length;
-    }
-    async cacheStatus() {
-        this.enumerableItems = await this.getEnumerableItems();
-    }
-    /**
-     * 是否允许新建case
-     */
-    get canAddCase() {
-        const cases = this?.cases;
-        if (Array.isArray(cases) && cases.length > 1) {
-            const { enumerableItems } = this;
-            if (Array.isArray(enumerableItems)) {
-                const map = {};
-                cases.forEach((caseItem) => {
-                    const { patterns } = caseItem || {};
-                    if (Array.isArray(patterns)) {
-                        patterns.forEach((pattern) => {
-                            if (pattern instanceof TypeAnnotation__1.default) {
-                                const patternTypeKey = pattern.typeKey;
-                                map[patternTypeKey] = true;
-                            }
-                            else if (pattern instanceof MemberExpression__1.default || pattern instanceof BooleanLiteral__1.default) {
-                                const patternValue = pattern.getValue();
-                                map[patternValue] = true;
-                            }
-                        });
-                    }
-                });
-                const enumerableKeys = Object.keys(map);
-                if (enumerableKeys.length === enumerableItems.length) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    // 获取可枚举项
-    async getEnumerableItems(typeAnnotation) {
-        const { expression } = this;
-        let currTypeAnnotation = typeAnnotation;
-        if (!currTypeAnnotation) {
-            currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
-        }
-        const { typeKind, typeNamespace, typeName, typeArguments } = currTypeAnnotation || {};
-        if (typeKind === 'union' && Array.isArray(typeArguments)) {
-            return typeArguments.map((typeArg) => {
-                let typeArgJson = typeArg;
-                if (typeArg instanceof TypeAnnotation__1.default) {
-                    typeArgJson = typeArg.toJSON();
-                }
-                return new TypeAnnotation__1.default(typeArgJson);
-            });
-        }
-        if (typeKind === 'reference') {
-            const nameArr = [typeName];
-            if (typeNamespace) {
-                nameArr.unshift(typeNamespace);
-            }
-            const typeNode = this.app.findNodeByCompleteName(nameArr.join('.')) || {};
-            if (typeNode.concept === 'Enum') {
-                const enums = (0, getMemberIdentifier_1.formatEnums)([typeNode]);
-                const { children } = enums?.[0] || {};
-                if (Array.isArray(children)) {
-                    return children.map((child) => child?.expression);
-                }
-            }
-        }
-        else if (typeKind === 'primitive' && typeNamespace === 'nasl.core' && typeName === 'Boolean') {
-            return [
-                new BooleanLiteral__1.default({
-                    value: 'true',
-                }),
-                new BooleanLiteral__1.default({
-                    value: 'false',
-                }),
-            ];
-        }
-    }
-    setIsExpression(isExpression) {
-        const object = {
-            isExpression,
-        };
-        this.update({
-            ...object,
-        });
-    }
-    /**
-     * 设置逻辑项
-     */
-    setExpression(expression) {
-        if (expression) {
-            expression._delete();
-            const relationOptions = { parentNode: this, parentKey: 'expression' };
-            Object.assign(expression, relationOptions);
-        }
-        const object = {
-            expression,
-        };
-        this.update({
-            ...object,
-        });
-    }
-    // 设置 expression ，如果 expression 是可枚举类型，加上默认匹配条件
-    async setExpressionWitchCase(expression) {
-        const oldExpression = this.expression;
-        this.app.emit('collect:start', {
-            actionMsg: `修改${this?.name || this?.label || this?.constructor?.nodeTitle}`,
-        });
-        this.setExpression(expression);
-        // expression切换并且自动生成分支
-        await this.autoGenCases(oldExpression);
-        this.app.emit('collect:end');
-    }
-    // 自动生成分支
-    async autoGenCases(oldExpression) {
-        const { expression } = this;
-        // 没有新的expression要保留分支不去更新
-        if (!expression) {
-            return;
-        }
-        // 如果没有旧的oldExpression， 但是已有就分支了，就不去更新了
-        if (!oldExpression && this.cases.length) {
-            // 而且case的 patterns 有长度，就说明里面是有值的，就不去更新了，其余就去更新
-            if (this.cases.some((item) => item.patterns.length)) {
-                return;
-            }
-        }
-        // 如果新旧nasl一样，就算类型变了也不重新计算
-        if (JSON.stringify(oldExpression?.toJSON()) === JSON.stringify(expression?.toJSON())) {
-            return;
-        }
-        const oldTypeAnnotation = oldExpression?.__TypeAnnotation;
-        const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
-        // 如果nasl变了，但是新旧类型都是union就return
-        if (currTypeAnnotation?.typeKind === 'union' && oldTypeAnnotation?.typeKind === 'union') {
-            return;
-        }
-        // 如果不可枚举 变 不可枚举，都会保留分支
-        // 原来不是 布尔类型 也不是枚举类型， 现在 也不是布尔类型 也不是枚举类型
-        // 就满足了
-        if (expression && oldExpression && currTypeAnnotation && oldTypeAnnotation) {
-            const { typeName: oldTypeName, typeNamespace: oldTypeNamespace, typeKind: oldTypeKind } = oldTypeAnnotation;
-            const { typeName, typeNamespace, typeKind } = currTypeAnnotation;
-            // 类型的 name 和 namespace都有值，而且都不是 可枚举
-            if (oldTypeName &&
-                oldTypeNamespace &&
-                typeName &&
-                typeNamespace &&
-                oldTypeName !== 'Boolean' &&
-                !oldTypeNamespace.endsWith('enums') &&
-                oldTypeKind !== 'union' &&
-                typeName !== 'Boolean' &&
-                !typeNamespace.endsWith('enums') &&
-                typeKind !== 'union') {
-                return;
-            }
-            if (oldTypeName &&
-                oldTypeNamespace &&
-                oldTypeName !== 'Boolean' &&
-                !oldTypeNamespace.endsWith('enums') &&
-                oldTypeKind !== 'union' &&
-                typeKind === 'anonymousStructure') {
-                /**
-                 * 新旧都是匿名数据结构
-                 * 匿名到 可枚举 动
-                 * 可枚举到匿名 动
-                 * 匿名到 不可枚举 不动
-                 * 不可枚举到匿名 不动
-                 * 匿名到匿名 不动
-                 * 因为不能在match上不能直接 匿名数据结构替换匿名数据结构
-                 * 而且 匿名数据结构不能 直接换别的分支，所以下面的直留 不可枚举到匿名数据结构的情况
-                 *  */
-                // 不可枚举到匿名 不动
-                return;
-            }
-            if (typeKind === 'anonymousStructure' && oldTypeKind === typeKind) {
-                // 匿名到匿名 不动
-                return;
-            }
-            //  else if (currTypeName && typeNamespace && currTypeName !== 'Boolean' && !typeNamespace.endsWith('enums') && oldTypeKind === 'anonymousStructure') {
-            //     // 匿名到 不可枚举 不动
-            //     return;
-            // }
-        }
-        // 修改分支
-        await this.changeGenCases();
-    }
-    // jflow缓存模式下的传过来参数
-    async autoGenCasesAST({ oldAst, cacheType }) {
-        let obj;
-        try {
-            obj = JSON.parse(oldAst);
-        }
-        catch (err) { }
-        const oldExpression = LogicItem__1.default.from(obj);
-        oldExpression.__TypeAnnotation = cacheType;
-        await this.autoGenCases(oldExpression);
-    }
-    async changeGenCases() {
-        const { expression } = this;
-        const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
-        let cases = [];
-        let isMatchedTypeEnumable = false;
-        if (currTypeAnnotation) {
-            cases = [new MatchCase__1.default()];
-            const enumerableItems = await this.getEnumerableItems();
-            if (Array.isArray(enumerableItems) && enumerableItems.length) {
-                isMatchedTypeEnumable = true;
-                cases = enumerableItems.map((enumerableItem) => new MatchCase__1.default({
-                    patterns: [enumerableItem],
-                    isMatchedTypeEnumable,
-                }));
-            }
-        }
-        // body的暂存数组
-        const bodys = [];
-        // 最后一项的body
-        let lastCaseBody;
-        if (Array.isArray(this.cases) && this.cases.length) {
-            // 将原分支body中存在的内容拿出来
-            this.cases.forEach((caseItem, index) => {
-                const { body } = caseItem || {};
-                if (Array.isArray(body) && body.length) {
-                    // “其他”分支单独处理
-                    if (index < this.cases.length - 1) {
-                        bodys.push({
-                            body,
-                            isMatchedTypeEnumable: currTypeAnnotation ? isMatchedTypeEnumable : true,
-                        });
-                    }
-                    else {
-                        lastCaseBody = body;
-                    }
-                }
-            });
-            // 将原分支body中存在的内容拿出来赋到新的分支中去
-            bodys.forEach(({ body, isMatchedTypeEnumable }, index) => {
-                let caseItem = cases[index];
-                if (!caseItem) {
-                    caseItem = new MatchCase__1.default({
-                        isMatchedTypeEnumable,
-                    });
-                    cases.push(caseItem);
-                }
-                caseItem.update({
-                    body,
-                });
-            });
-        }
-        // 如果分支项存在时，加上“其他”项
-        if (cases.length) {
-            const otherCase = new MatchCase__1.default();
-            // “其他”项body存在内容时,给新的分支上加上内容
-            if (lastCaseBody) {
-                otherCase.update({
-                    body: lastCaseBody,
-                });
-            }
-            cases.push(otherCase);
-        }
-        this.update({
-            cases,
-        });
-    }
-    static getDefaultOptions() {
-        return {
-            label: '匹配',
-        };
-    }
-    async isTypeMatching() {
-        if (this.expression) {
-            const typeAnnotation = await this.expression.getCurrentTypeAnnotation();
-            const { typeKind, typeArguments } = typeAnnotation || {};
-            if (typeKind === 'union' && Array.isArray(typeArguments)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    onChange($event) {
-        const { action, object, eventList } = $event || {};
-        // expression修改时，通知tsserver，让tsserver重新生成ts文件，为了后续能获取expression的类型
-        if (action === 'update' && object.hasOwnProperty('expression')) {
-            this.app?.naslServer?.embeddedTSEmitter.emit('change', {
-                value: eventList,
-            });
-        }
-        this.emit('change', $event);
-    }
-    // 获取在页面中的名字
-    get expressionNameInView() {
-        const nameList = [];
-        let node = this;
-        while (node) {
-            if (node === this) {
-                nameList.unshift('viewMatchExpression');
-            }
-            else {
-                nameList.unshift(node.name);
-            }
-            if (node.concept === 'ViewElement') {
-                node = null;
-            }
-            else {
-                nameList.unshift(node.parentKey);
-                node = node.parentNode;
-            }
-        }
-        return nameList.join('_').replace(/-/g, '_');
-    }
-    getViewMatchExpressionBuilder() {
-        return `gen${this.expressionNameInView}`;
-    }
-    getInViewMethod(state) {
-        const viewElement = this?.getAncestor('ViewElement');
-        const argsList = [];
-        let parent = viewElement?.parentNode;
-        let index = 0;
-        while (parent && parent.concept !== 'View') {
-            if (parent.slotScope) {
-                argsList.unshift(index === 0 ? 'current' : `current${index}`);
-                index++;
-            }
-            parent = parent.parentNode;
-        }
-        let code = '';
-        code += `${this.getViewMatchExpressionBuilder()} (${argsList.join(', ')}) {\n`;
-        code += `return ${this.toJS()}`;
-        code += `;\n`;
-        code += '}';
-        return code;
-    }
-    setIsExpressionCustom(isExpression) {
-        if (isExpression === this.isExpression) {
-            return;
-        }
-        this.update({
-            isExpression,
-        });
-        this.cases.forEach((c) => {
-            c.update({
-                body: [],
-            });
-        });
-    }
-    toVue(state) {
-        if (state?.finalCode === false) {
-            return this.toUI();
-        }
-        const viewElement = this?.getAncestor('ViewElement');
-        const argsList = [];
-        let parent = viewElement?.parentNode;
-        let index = 0;
-        while (parent && parent.concept !== 'View') {
-            if (parent.slotScope) {
-                argsList.unshift(index === 0 ? 'current' : `current${index}`);
-                index++;
-            }
-            parent = parent.parentNode;
-        }
-        return `${this.getViewMatchExpressionBuilder()}(${argsList.join(', ')})`;
-        //        let code = 'await (async () => {\n';
-        //        if (this.expression && Array.isArray(this.cases)) {
-        //            this.cases.forEach((item, index) => {
-        //                code += item?.toJS?.(this.expression, index, this.cases.length);
-        //            });
-        //        }
-        //        code += `})()`;
-        //        return code;
-    }
-    toUI(state) {
-        let code = '匹配 ';
-        if (this.expression) {
-            code += this.expression.toUI?.();
-        }
-        if (Array.isArray(this.cases)) {
-            code += ' { ';
-            this.cases.forEach((item, index) => {
-                code += item?.toUI?.();
-            });
-            code += '}';
-        }
-        return code;
-    }
-    toJS(state) {
-        // let code = 'await (async () => {\n';
-        // if (this.expression && Array.isArray(this.cases)) {
-        //    this.cases.forEach((item, index) => {
-        //        code += item?.toJS?.(this.expression, index, this.cases.length);
-        //    });
-        // }
-        // code += `})()`;
-        // return code;
-        let code = '';
-        // 祖先逻辑
-        const ancestorLogic = this.getAncestor('Logic');
-        if (this.isExpression || !ancestorLogic) {
-            if (ancestorLogic) {
-                code += 'await (async () => {\n';
-            }
-            else {
-                code += '(() => {\n';
-            }
-        }
-        if (this.expression && Array.isArray(this.cases)) {
-            this.cases.forEach((item, index) => {
-                code += item?.toJS?.(this.expression, index, this.cases.length);
-            });
-        }
-        if (this.isExpression || !ancestorLogic) {
-            code += '})()';
-        }
-        return code;
-    }
-    toEmbeddedTS(state = (0, translator_1.createCompilerState)()) {
-        let code = '';
-        if (this.parentNode.concept === 'Logic') {
-            code += '\n';
-        }
-        code += (0, translator_1.indent)(state?.tabSize || 0);
-        code += '(() => { \n';
-        let parentCode;
-        if (this.expression) {
-            code += (0, translator_1.indent)(state?.tabSize || 0);
-            // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
-            if (this.expression instanceof Identifier__1.default || this.expression instanceof MemberExpression__1.default) {
-                code += parentCode = this.expression.toEmbeddedTS((0, translator_1.shiftState)(state, code));
-            }
-            else {
-                parentCode = '__matchExpression';
-                code += `let ${parentCode} = `;
-                code += this.expression.toEmbeddedTS((0, translator_1.shiftState)(state, code));
-            }
-            code += ';\n';
-        }
-        else {
-            code += '__IDENTIFIER__;\n';
-        }
-        code += (0, translator_1.indent)(state?.tabSize + 1 || 0);
-        code += ' function __MatchExpressionFuntion() {\n';
-        //  最后一项是else
-        this.cases.forEach((item, index) => {
-            // 如果是最后一项
-            code += item.toEmbeddedTS((0, translator_1.shiftState)(state, code, { tabSize: state?.tabSize || 0 }), index, parentCode);
-        });
-        code += (0, translator_1.indent)(state?.tabSize || 0);
-        code += '};\n';
-        code += (0, translator_1.indent)(state?.tabSize || 0);
-        code += 'return __MatchExpressionFuntion();\n';
-        code += (0, translator_1.indent)(state?.tabSize || 0);
-        code += '})()';
-        if (this.parentNode.concept !== 'Argument' &&
-            this.parentKey !== 'test' &&
-            this.parentKey !== 'patterns' &&
-            this.parentNode.concept !== 'Assignment' &&
-            this.parentNode.concept !== 'ForEachStatement' &&
-            this.parentNode.concept !== 'SelectMembers' &&
-            this.parentNode.concept !== 'UnaryExpression' &&
-            this.parentNode.concept !== 'BinaryExpression' &&
-            this.parentNode.concept !== 'StringInterpolation' &&
-            this.parentNode.concept !== 'MemberExpression' &&
-            !['NewMap', 'NewList'].includes(this.parentNode.concept) &&
-            this.parentKey !== 'returnExpression') {
-            code += ';\n';
-        }
-        return code;
-    }
-    toNaturalTS(state = (0, translator_1.createCompilerState)()) {
-        let code = '';
-        if (this.parentNode?.concept === 'Logic') {
-            code += '\n';
-        }
-        code += (0, translator_1.indent)(state.tabSize);
-        code += '(function match(_value) { \n';
-        let parentCode;
-        if (this.expression) {
-            code += (0, translator_1.indent)(state.tabSize + 1);
-            // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
-            if (this.expression instanceof Identifier__1.default || this.expression instanceof MemberExpression__1.default) {
-                parentCode = this.expression.toNaturalTS((0, translator_1.shiftState)(state, code, { inline: true }));
-            }
-            else {
-                parentCode = '_value';
-            }
-        }
-        // 最后一项是else
-        this.cases.forEach((item, index) => {
-            // 如果是最后一项
-            code += item.toNaturalTS((0, translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1 }), index, parentCode);
-        });
-        code += (0, translator_1.indent)(state.tabSize);
-        code += `})(${this.expression.toNaturalTS((0, translator_1.shiftState)(state, code, { inline: true }))})`;
-        if (this.parentNode?.concept !== 'Argument' &&
-            this.parentKey !== 'test' &&
-            this.parentKey !== 'patterns' &&
-            this.parentNode?.concept !== 'Assignment' &&
-            this.parentNode?.concept !== 'ForEachStatement' &&
-            this.parentNode?.concept !== 'SelectMembers' &&
-            this.parentNode?.concept !== 'BinaryExpression' &&
-            this.parentNode?.concept !== 'StringInterpolation' &&
-            this.parentNode?.concept !== 'MemberExpression' &&
-            !['NewMap', 'NewList'].includes(this.parentNode.concept) &&
-            this.parentKey !== 'returnExpression') {
-            code += ';\n';
-        }
-        return code;
-    }
-};
-exports.Match = Match;
-__decorate([
-    (0, decorators_1.property)('concept')
-    // @ts-ignore
-], Match.prototype, "concept", void 0);
-__decorate([
-    (0, decorators_1.property)({
-        objectRef: 'LogicItem',
-    })
-    // @ts-ignore
-], Match.prototype, "expression", void 0);
-__decorate([
-    (0, decorators_1.property)()
-], Match.prototype, "isExpression", void 0);
-__decorate([
-    (0, decorators_1.property)({
-        objectRef: 'MatchCase',
-        isArray: true,
-        defaultValue: [],
-    })
-], Match.prototype, "cases", void 0);
-__decorate([
-    (0, translator_1.withSourceMap)()
-], Match.prototype, "toEmbeddedTS", null);
-__decorate([
-    (0, translator_1.withSourceMap)()
-], Match.prototype, "toNaturalTS", null);
-exports.Match = Match = Match_1 = __decorate([
-    decorators_1.className,
-    (0, decorators_1.concept)('匹配')
-    // @ts-ignore
-], Match);
-exports.default = Match;
-//================================================================================
-// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
-// 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
-// @ts-check
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var Match_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Match = void 0;
+const translator_1 = require("../translator");
+const TypeAnnotation__1 = __importDefault(require("./TypeAnnotation__"));
+const BooleanLiteral__1 = __importDefault(require("./BooleanLiteral__"));
+const MemberExpression__1 = __importDefault(require("./MemberExpression__"));
+const getMemberIdentifier_1 = require("../server/getMemberIdentifier");
+const Identifier__1 = __importDefault(require("./Identifier__"));
+const decorators_1 = require("../decorators");
+const LogicItem__1 = __importDefault(require("./LogicItem__"));
+const MatchCase__1 = __importDefault(require("./MatchCase__"));
+/**
+ * 匹配
+ */
+let Match = Match_1 = 
+// @ts-ignore
+class Match extends LogicItem__1.default {
+    /** 类名 */
+    static ConceptName = 'Match';
+    /** 继承链 */
+    static inheritanceChain = ['LogicItem', 'BaseNode'];
+    /**
+     * 产品概念
+     */
+    concept;
+    /**
+     * 逻辑项
+     */
+    // @ts-ignore
+    expression;
+    /**
+     * 是否表达式形态
+     */
+    isExpression = false;
+    /**
+     * 匹配分支列表
+     */
+    cases = [];
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source) {
+        source = Object.assign({}, Match_1.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+    static from(source, parentNode, parentKey) {
+        return super.from(source, parentNode, parentKey);
+    }
+    _insertMatchCaseAt(options, index) {
+        const matchCaseOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'cases' };
+        let matchCase;
+        if (options instanceof MatchCase__1.default) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            matchCase = options;
+            Object.assign(matchCase, relationOptions);
+        }
+        else {
+            matchCase = MatchCase__1.default.from({
+                ...matchCaseOptions,
+                ...options,
+            }, this, 'cases');
+        }
+        this.cases.splice(index, 0, matchCase);
+        return matchCase;
+    }
+    insertMatchCaseAt(options, index) {
+        const node = this._insertMatchCaseAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'cases',
+        });
+        return node;
+    }
+    _addMatchCase(options) {
+        const index = this.cases.length;
+        return this._insertMatchCaseAt(options, index);
+    }
+    addMatchCase(options) {
+        const node = this._addMatchCase(options);
+        const index = this.cases.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'cases',
+        });
+        return node;
+    }
+    removeExpression(options) {
+        let expression;
+        if (typeof options === 'string') {
+            expression = this.expression;
+            if (!expression) {
+                throw new Error('找不到逻辑项 ' + options);
+            }
+        }
+        else {
+            expression = options;
+        }
+        return expression.delete();
+    }
+    removeMatchCaseInCases(options) {
+        let matchCase = options;
+        return matchCase.delete();
+    }
+    __removeLogicItem(logicItem) {
+        const parentKey = logicItem.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: logicItem,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            // @ts-ignore
+            const t = this.__v_raw || this;
+            // @ts-ignore
+            const n = logicItem.__v_raw || logicItem;
+            if (Array.isArray(t[parentKey])) {
+                // @ts-ignore
+                const index = t[parentKey].findIndex((el) => (el.__v_raw || el) === n);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (t[parentKey] === n) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    enumerableItems;
+    get isEnumerable() {
+        return !!this.enumerableItems?.length;
+    }
+    async cacheStatus() {
+        this.enumerableItems = await this.getEnumerableItems();
+    }
+    /**
+     * 是否允许新建case
+     */
+    get canAddCase() {
+        const cases = this?.cases;
+        if (Array.isArray(cases) && cases.length > 1) {
+            const { enumerableItems } = this;
+            if (Array.isArray(enumerableItems)) {
+                const map = {};
+                cases.forEach((caseItem) => {
+                    const { patterns } = caseItem || {};
+                    if (Array.isArray(patterns)) {
+                        patterns.forEach((pattern) => {
+                            if (pattern instanceof TypeAnnotation__1.default) {
+                                const patternTypeKey = pattern.typeKey;
+                                map[patternTypeKey] = true;
+                            }
+                            else if (pattern instanceof MemberExpression__1.default || pattern instanceof BooleanLiteral__1.default) {
+                                const patternValue = pattern.getValue();
+                                map[patternValue] = true;
+                            }
+                        });
+                    }
+                });
+                const enumerableKeys = Object.keys(map);
+                if (enumerableKeys.length === enumerableItems.length) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    // 获取可枚举项
+    async getEnumerableItems(typeAnnotation) {
+        const { expression } = this;
+        let currTypeAnnotation = typeAnnotation;
+        if (!currTypeAnnotation) {
+            currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
+        }
+        const { typeKind, typeNamespace, typeName, typeArguments } = currTypeAnnotation || {};
+        if (typeKind === 'union' && Array.isArray(typeArguments)) {
+            return typeArguments.map((typeArg) => {
+                let typeArgJson = typeArg;
+                if (typeArg instanceof TypeAnnotation__1.default) {
+                    typeArgJson = typeArg.toJSON();
+                }
+                return new TypeAnnotation__1.default(typeArgJson);
+            });
+        }
+        if (typeKind === 'reference') {
+            const nameArr = [typeName];
+            if (typeNamespace) {
+                nameArr.unshift(typeNamespace);
+            }
+            const typeNode = this.app.findNodeByCompleteName(nameArr.join('.')) || {};
+            if (typeNode.concept === 'Enum') {
+                const enums = (0, getMemberIdentifier_1.formatEnums)([typeNode]);
+                const { children } = enums?.[0] || {};
+                if (Array.isArray(children)) {
+                    return children.map((child) => child?.expression);
+                }
+            }
+        }
+        else if (typeKind === 'primitive' && typeNamespace === 'nasl.core' && typeName === 'Boolean') {
+            return [
+                new BooleanLiteral__1.default({
+                    value: 'true',
+                }),
+                new BooleanLiteral__1.default({
+                    value: 'false',
+                }),
+            ];
+        }
+    }
+    setIsExpression(isExpression) {
+        const object = {
+            isExpression,
+        };
+        this.update({
+            ...object,
+        });
+    }
+    /**
+     * 设置逻辑项
+     */
+    setExpression(expression) {
+        if (expression) {
+            expression._delete();
+            const relationOptions = { parentNode: this, parentKey: 'expression' };
+            Object.assign(expression, relationOptions);
+        }
+        const object = {
+            expression,
+        };
+        this.update({
+            ...object,
+        });
+    }
+    // 设置 expression ，如果 expression 是可枚举类型，加上默认匹配条件
+    async setExpressionWitchCase(expression) {
+        const oldExpression = this.expression;
+        this.app.emit('collect:start', {
+            actionMsg: `修改${this?.name || this?.label || this?.constructor?.nodeTitle}`,
+        });
+        this.setExpression(expression);
+        // expression切换并且自动生成分支
+        await this.autoGenCases(oldExpression);
+        this.app.emit('collect:end');
+    }
+    // 自动生成分支
+    async autoGenCases(oldExpression) {
+        const { expression } = this;
+        // 没有新的expression要保留分支不去更新
+        if (!expression) {
+            return;
+        }
+        // 如果没有旧的oldExpression， 但是已有就分支了，就不去更新了
+        if (!oldExpression && this.cases.length) {
+            // 而且case的 patterns 有长度，就说明里面是有值的，就不去更新了，其余就去更新
+            if (this.cases.some((item) => item.patterns.length)) {
+                return;
+            }
+        }
+        // 如果新旧nasl一样，就算类型变了也不重新计算
+        if (JSON.stringify(oldExpression?.toJSON()) === JSON.stringify(expression?.toJSON())) {
+            return;
+        }
+        const oldTypeAnnotation = oldExpression?.__TypeAnnotation;
+        const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
+        // 如果nasl变了，但是新旧类型都是union就return
+        if (currTypeAnnotation?.typeKind === 'union' && oldTypeAnnotation?.typeKind === 'union') {
+            return;
+        }
+        // 如果不可枚举 变 不可枚举，都会保留分支
+        // 原来不是 布尔类型 也不是枚举类型， 现在 也不是布尔类型 也不是枚举类型
+        // 就满足了
+        if (expression && oldExpression && currTypeAnnotation && oldTypeAnnotation) {
+            const { typeName: oldTypeName, typeNamespace: oldTypeNamespace, typeKind: oldTypeKind } = oldTypeAnnotation;
+            const { typeName, typeNamespace, typeKind } = currTypeAnnotation;
+            // 类型的 name 和 namespace都有值，而且都不是 可枚举
+            if (oldTypeName &&
+                oldTypeNamespace &&
+                typeName &&
+                typeNamespace &&
+                oldTypeName !== 'Boolean' &&
+                !oldTypeNamespace.endsWith('enums') &&
+                oldTypeKind !== 'union' &&
+                typeName !== 'Boolean' &&
+                !typeNamespace.endsWith('enums') &&
+                typeKind !== 'union') {
+                return;
+            }
+            if (oldTypeName &&
+                oldTypeNamespace &&
+                oldTypeName !== 'Boolean' &&
+                !oldTypeNamespace.endsWith('enums') &&
+                oldTypeKind !== 'union' &&
+                typeKind === 'anonymousStructure') {
+                /**
+                 * 新旧都是匿名数据结构
+                 * 匿名到 可枚举 动
+                 * 可枚举到匿名 动
+                 * 匿名到 不可枚举 不动
+                 * 不可枚举到匿名 不动
+                 * 匿名到匿名 不动
+                 * 因为不能在match上不能直接 匿名数据结构替换匿名数据结构
+                 * 而且 匿名数据结构不能 直接换别的分支，所以下面的直留 不可枚举到匿名数据结构的情况
+                 *  */
+                // 不可枚举到匿名 不动
+                return;
+            }
+            if (typeKind === 'anonymousStructure' && oldTypeKind === typeKind) {
+                // 匿名到匿名 不动
+                return;
+            }
+            //  else if (currTypeName && typeNamespace && currTypeName !== 'Boolean' && !typeNamespace.endsWith('enums') && oldTypeKind === 'anonymousStructure') {
+            //     // 匿名到 不可枚举 不动
+            //     return;
+            // }
+        }
+        // 修改分支
+        await this.changeGenCases();
+    }
+    // jflow缓存模式下的传过来参数
+    async autoGenCasesAST({ oldAst, cacheType }) {
+        let obj;
+        try {
+            obj = JSON.parse(oldAst);
+        }
+        catch (err) { }
+        const oldExpression = LogicItem__1.default.from(obj);
+        oldExpression.__TypeAnnotation = cacheType;
+        await this.autoGenCases(oldExpression);
+    }
+    async changeGenCases() {
+        const { expression } = this;
+        const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
+        let cases = [];
+        let isMatchedTypeEnumable = false;
+        if (currTypeAnnotation) {
+            cases = [new MatchCase__1.default()];
+            const enumerableItems = await this.getEnumerableItems();
+            if (Array.isArray(enumerableItems) && enumerableItems.length) {
+                isMatchedTypeEnumable = true;
+                cases = enumerableItems.map((enumerableItem) => new MatchCase__1.default({
+                    patterns: [enumerableItem],
+                    isMatchedTypeEnumable,
+                }));
+            }
+        }
+        // body的暂存数组
+        const bodys = [];
+        // 最后一项的body
+        let lastCaseBody;
+        if (Array.isArray(this.cases) && this.cases.length) {
+            // 将原分支body中存在的内容拿出来
+            this.cases.forEach((caseItem, index) => {
+                const { body } = caseItem || {};
+                if (Array.isArray(body) && body.length) {
+                    // “其他”分支单独处理
+                    if (index < this.cases.length - 1) {
+                        bodys.push({
+                            body,
+                            isMatchedTypeEnumable: currTypeAnnotation ? isMatchedTypeEnumable : true,
+                        });
+                    }
+                    else {
+                        lastCaseBody = body;
+                    }
+                }
+            });
+            // 将原分支body中存在的内容拿出来赋到新的分支中去
+            bodys.forEach(({ body, isMatchedTypeEnumable }, index) => {
+                let caseItem = cases[index];
+                if (!caseItem) {
+                    caseItem = new MatchCase__1.default({
+                        isMatchedTypeEnumable,
+                    });
+                    cases.push(caseItem);
+                }
+                caseItem.update({
+                    body,
+                });
+            });
+        }
+        // 如果分支项存在时，加上“其他”项
+        if (cases.length) {
+            const otherCase = new MatchCase__1.default();
+            // “其他”项body存在内容时,给新的分支上加上内容
+            if (lastCaseBody) {
+                otherCase.update({
+                    body: lastCaseBody,
+                });
+            }
+            cases.push(otherCase);
+        }
+        this.update({
+            cases,
+        });
+    }
+    static getDefaultOptions() {
+        return {
+            label: '匹配',
+        };
+    }
+    async isTypeMatching() {
+        if (this.expression) {
+            const typeAnnotation = await this.expression.getCurrentTypeAnnotation();
+            const { typeKind, typeArguments } = typeAnnotation || {};
+            if (typeKind === 'union' && Array.isArray(typeArguments)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    onChange($event) {
+        const { action, object, eventList } = $event || {};
+        // expression修改时，通知tsserver，让tsserver重新生成ts文件，为了后续能获取expression的类型
+        if (action === 'update' && object.hasOwnProperty('expression')) {
+            this.app?.naslServer?.embeddedTSEmitter.emit('change', {
+                value: eventList,
+            });
+        }
+        this.emit('change', $event);
+    }
+    // 获取在页面中的名字
+    get expressionNameInView() {
+        const nameList = [];
+        let node = this;
+        while (node) {
+            if (node === this) {
+                nameList.unshift('viewMatchExpression');
+            }
+            else {
+                nameList.unshift(node.name);
+            }
+            if (node.concept === 'ViewElement') {
+                node = null;
+            }
+            else {
+                nameList.unshift(node.parentKey);
+                node = node.parentNode;
+            }
+        }
+        return nameList.join('_').replace(/-/g, '_');
+    }
+    getViewMatchExpressionBuilder() {
+        return `gen${this.expressionNameInView}`;
+    }
+    getInViewMethod(state) {
+        const viewElement = this?.getAncestor('ViewElement');
+        const argsList = [];
+        let parent = viewElement?.parentNode;
+        let index = 0;
+        while (parent && parent.concept !== 'View') {
+            if (parent.slotScope) {
+                argsList.unshift(index === 0 ? 'current' : `current${index}`);
+                index++;
+            }
+            parent = parent.parentNode;
+        }
+        let code = '';
+        code += `${this.getViewMatchExpressionBuilder()} (${argsList.join(', ')}) {\n`;
+        code += `return ${this.toJS()}`;
+        code += `;\n`;
+        code += '}';
+        return code;
+    }
+    setIsExpressionCustom(isExpression) {
+        if (isExpression === this.isExpression) {
+            return;
+        }
+        this.update({
+            isExpression,
+        });
+        this.cases.forEach((c) => {
+            c.update({
+                body: [],
+            });
+        });
+    }
+    toVue(state) {
+        if (state?.finalCode === false) {
+            return this.toUI();
+        }
+        const viewElement = this?.getAncestor('ViewElement');
+        const argsList = [];
+        let parent = viewElement?.parentNode;
+        let index = 0;
+        while (parent && parent.concept !== 'View') {
+            if (parent.slotScope) {
+                argsList.unshift(index === 0 ? 'current' : `current${index}`);
+                index++;
+            }
+            parent = parent.parentNode;
+        }
+        return `${this.getViewMatchExpressionBuilder()}(${argsList.join(', ')})`;
+        //        let code = 'await (async () => {\n';
+        //        if (this.expression && Array.isArray(this.cases)) {
+        //            this.cases.forEach((item, index) => {
+        //                code += item?.toJS?.(this.expression, index, this.cases.length);
+        //            });
+        //        }
+        //        code += `})()`;
+        //        return code;
+    }
+    toUI(state, hideDetails) {
+        let code = '匹配 ';
+        if (this.expression) {
+            code += this.expression.toUI?.(state, hideDetails);
+        }
+        if (Array.isArray(this.cases)) {
+            code += ' { ';
+            this.cases.forEach((item, index) => {
+                code += item?.toUI?.(state, hideDetails);
+            });
+            code += '}';
+        }
+        return code;
+    }
+    toJS(state) {
+        // let code = 'await (async () => {\n';
+        // if (this.expression && Array.isArray(this.cases)) {
+        //    this.cases.forEach((item, index) => {
+        //        code += item?.toJS?.(this.expression, index, this.cases.length);
+        //    });
+        // }
+        // code += `})()`;
+        // return code;
+        let code = '';
+        // 祖先逻辑
+        const ancestorLogic = this.getAncestor('Logic');
+        if (this.isExpression || !ancestorLogic) {
+            if (ancestorLogic) {
+                code += 'await (async () => {\n';
+            }
+            else {
+                code += '(() => {\n';
+            }
+        }
+        if (this.expression && Array.isArray(this.cases)) {
+            this.cases.forEach((item, index) => {
+                code += item?.toJS?.(this.expression, index, this.cases.length);
+            });
+        }
+        if (this.isExpression || !ancestorLogic) {
+            code += '})()';
+        }
+        return code;
+    }
+    toEmbeddedTS(state = (0, translator_1.createCompilerState)()) {
+        let code = '';
+        if (this.parentNode.concept === 'Logic') {
+            code += '\n';
+        }
+        code += (0, translator_1.indent)(state?.tabSize || 0);
+        code += '(() => { \n';
+        let parentCode;
+        if (this.expression) {
+            code += (0, translator_1.indent)(state?.tabSize || 0);
+            // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
+            if (this.expression instanceof Identifier__1.default || this.expression instanceof MemberExpression__1.default) {
+                code += parentCode = this.expression.toEmbeddedTS((0, translator_1.shiftState)(state, code));
+            }
+            else {
+                parentCode = '__matchExpression';
+                code += `let ${parentCode} = `;
+                code += this.expression.toEmbeddedTS((0, translator_1.shiftState)(state, code));
+            }
+            code += ';\n';
+        }
+        else {
+            code += '__IDENTIFIER__;\n';
+        }
+        code += (0, translator_1.indent)(state?.tabSize + 1 || 0);
+        code += ' function __MatchExpressionFuntion() {\n';
+        //  最后一项是else
+        this.cases.forEach((item, index) => {
+            // 如果是最后一项
+            code += item.toEmbeddedTS((0, translator_1.shiftState)(state, code, { tabSize: state?.tabSize || 0 }), index, parentCode);
+        });
+        code += (0, translator_1.indent)(state?.tabSize || 0);
+        code += '};\n';
+        code += (0, translator_1.indent)(state?.tabSize || 0);
+        code += 'return __MatchExpressionFuntion();\n';
+        code += (0, translator_1.indent)(state?.tabSize || 0);
+        code += '})()';
+        if (this.parentNode.concept !== 'Argument' &&
+            this.parentKey !== 'test' &&
+            this.parentKey !== 'patterns' &&
+            this.parentNode.concept !== 'Assignment' &&
+            this.parentNode.concept !== 'ForEachStatement' &&
+            this.parentNode.concept !== 'SelectMembers' &&
+            this.parentNode.concept !== 'UnaryExpression' &&
+            this.parentNode.concept !== 'BinaryExpression' &&
+            this.parentNode.concept !== 'StringInterpolation' &&
+            this.parentNode.concept !== 'MemberExpression' &&
+            !['NewMap', 'NewList'].includes(this.parentNode.concept) &&
+            this.parentKey !== 'returnExpression') {
+            code += ';\n';
+        }
+        return code;
+    }
+    toNaturalTS(state = (0, translator_1.createCompilerState)()) {
+        let code = '';
+        if (this.parentNode?.concept === 'Logic') {
+            code += '\n';
+        }
+        code += (0, translator_1.indent)(state.tabSize);
+        code += '(function match(_value) { \n';
+        let parentCode;
+        if (this.expression) {
+            code += (0, translator_1.indent)(state.tabSize + 1);
+            // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
+            if (this.expression instanceof Identifier__1.default || this.expression instanceof MemberExpression__1.default) {
+                parentCode = this.expression.toNaturalTS((0, translator_1.shiftState)(state, code, { inline: true }));
+            }
+            else {
+                parentCode = '_value';
+            }
+        }
+        // 最后一项是else
+        this.cases.forEach((item, index) => {
+            // 如果是最后一项
+            code += item.toNaturalTS((0, translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1 }), index, parentCode);
+        });
+        code += (0, translator_1.indent)(state.tabSize);
+        code += `})(${this.expression.toNaturalTS((0, translator_1.shiftState)(state, code, { inline: true }))})`;
+        if (this.parentNode?.concept !== 'Argument' &&
+            this.parentKey !== 'test' &&
+            this.parentKey !== 'patterns' &&
+            this.parentNode?.concept !== 'Assignment' &&
+            this.parentNode?.concept !== 'ForEachStatement' &&
+            this.parentNode?.concept !== 'SelectMembers' &&
+            this.parentNode?.concept !== 'BinaryExpression' &&
+            this.parentNode?.concept !== 'StringInterpolation' &&
+            this.parentNode?.concept !== 'MemberExpression' &&
+            !['NewMap', 'NewList'].includes(this.parentNode.concept) &&
+            this.parentKey !== 'returnExpression') {
+            code += ';\n';
+        }
+        return code;
+    }
+};
+__decorate([
+    (0, decorators_1.property)('concept')
+], Match.prototype, "concept", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'LogicItem',
+    })
+], Match.prototype, "expression", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Match.prototype, "isExpression", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'MatchCase',
+        isArray: true,
+        defaultValue: [],
+    })
+], Match.prototype, "cases", void 0);
+__decorate([
+    (0, translator_1.withSourceMap)()
+], Match.prototype, "toEmbeddedTS", null);
+__decorate([
+    (0, translator_1.withSourceMap)()
+], Match.prototype, "toNaturalTS", null);
+Match = Match_1 = __decorate([
+    decorators_1.className,
+    (0, decorators_1.concept)('匹配')
+    // @ts-ignore
+], Match);
+exports.Match = Match;
+exports.default = Match;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================
+// @ts-check
 //# sourceMappingURL=Match__.js.map