@lcap/nasl 3.6.0-alpha.7 → 3.6.0-alpha.8

package/out/concepts/Match__.js

@@ -0,0 +1,731 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 time_slicing_1 = require("../utils/time-slicing");
+const translator_1 = require("../translator");
+const getMemberIdentifier_1 = require("../server/getMemberIdentifier");
+const Enum__1 = __importDefault(require("./Enum__"));
+const EnumItem__1 = __importDefault(require("./EnumItem__"));
+const i18nInfo_1 = require("../utils/i18nInfo");
+const decorators_1 = require("../decorators");
+const asserts = __importStar(require("./utils/asserts"));
+const LogicItem__1 = __importDefault(require("./LogicItem__"));
+/**
+ * 匹配
+ */
+let Match = Match_1 = class Match extends LogicItem__1.default {
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source) {
+        source = Object.assign({}, Match_1.getDefaultOptions(), source);
+        super(source);
+        /**
+         * 是否表达式形态
+         */
+        this.isExpression = false;
+        /**
+         * 匹配分支列表
+         */
+        this.cases = [];
+        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' };
+        const MatchCase = (0, decorators_1.getConceptConstructor)('MatchCase');
+        let matchCase;
+        if (asserts.isMatchCase(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            matchCase = options;
+            Object.assign(matchCase, relationOptions);
+        }
+        else {
+            matchCase = MatchCase.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 {
+                const q = t[parentKey];
+                if ((q.__v_raw || q) === n) {
+                    params.index = 0;
+                    this[parentKey] = undefined;
+                }
+            }
+        }
+        return params;
+    }
+    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 (asserts.isTypeAnnotation(pattern)) {
+                                const patternTypeKey = pattern.typeKey;
+                                map[patternTypeKey] = true;
+                            }
+                            else if (asserts.isMemberExpression(pattern) || asserts.isBooleanLiteral(pattern)) {
+                                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;
+        const TypeAnnotation = (0, decorators_1.getConceptConstructor)('TypeAnnotation');
+        const BooleanLiteral = (0, decorators_1.getConceptConstructor)('BooleanLiteral');
+        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 (asserts.isTypeAnnotation(typeArg)) {
+                    typeArgJson = typeArg.toJSON();
+                }
+                return new TypeAnnotation(typeArgJson);
+            });
+        }
+        if (typeKind === 'reference') {
+            const nameArr = [typeName];
+            if (typeNamespace) {
+                nameArr.unshift(typeNamespace);
+            }
+            // 特殊逻辑处理国际化枚举先，后续会删掉
+            if (typeNamespace === 'app.enums' && typeName === '_naslI18nEnum') {
+                const enumItems = i18nInfo_1.languageList.map((language) => {
+                    return new EnumItem__1.default({
+                        label: language.title,
+                        value: language.id,
+                    });
+                });
+                const newEnum = new Enum__1.default({
+                    name: '_naslI18nEnum',
+                    enumItems: enumItems,
+                });
+                Enum__1.default.from(newEnum, this.app, 'enums');
+                const enums = (0, getMemberIdentifier_1.formatEnums)([newEnum]);
+                const { children } = enums?.[0] || {};
+                if (Array.isArray(children)) {
+                    return children.map((child) => child?.expression);
+                }
+            }
+            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({
+                    value: 'true',
+                }),
+                new BooleanLiteral({
+                    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 }) {
+        const LogicItem = (0, decorators_1.getConceptConstructor)('LogicItem');
+        let obj;
+        try {
+            obj = JSON.parse(oldAst);
+        }
+        catch (err) { }
+        const oldExpression = LogicItem.from(obj);
+        oldExpression.__TypeAnnotation = cacheType;
+        await this.autoGenCases(oldExpression);
+    }
+    async changeGenCases() {
+        const { expression } = this;
+        const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
+        const MatchCase = (0, decorators_1.getConceptConstructor)('MatchCase');
+        let cases = [];
+        let isMatchedTypeEnumable = false;
+        if (currTypeAnnotation) {
+            cases = [new MatchCase()];
+            const enumerableItems = await this.getEnumerableItems();
+            if (Array.isArray(enumerableItems) && enumerableItems.length) {
+                isMatchedTypeEnumable = true;
+                cases = enumerableItems.map((enumerableItem) => new MatchCase({
+                    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({
+                        isMatchedTypeEnumable,
+                    });
+                    cases.push(caseItem);
+                }
+                caseItem.update({
+                    body,
+                });
+            });
+        }
+        // 如果分支项存在时，加上“其他”项
+        if (cases.length) {
+            const otherCase = new MatchCase();
+            // “其他”项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)()) {
+        const self = this;
+        let code = '';
+        if (self.parentNode.concept === 'Logic') {
+            code += '\n';
+        }
+        code += (0, translator_1.indent)(state?.tabSize || 0);
+        code += '(() => { \n';
+        let parentCode;
+        if (self.expression) {
+            code += (0, translator_1.indent)(state?.tabSize || 0);
+            // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
+            if (asserts.isIdentifier(self.expression) || asserts.isMemberExpression(self.expression)) {
+                code += parentCode = yield* self.expression.toEmbeddedTS((0, translator_1.shiftState)(state, code));
+            }
+            else {
+                parentCode = '__matchExpression';
+                code += `let ${parentCode} = `;
+                code += yield* self.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
+        yield* (0, time_slicing_1.wrapForEachToGenerator)(self.cases, function* warpForEachGenerator(item, index) {
+            // 如果是最后一项
+            code += yield* 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 (self.parentNode.concept !== 'Argument' &&
+            self.parentKey !== 'test' &&
+            self.parentKey !== 'patterns' &&
+            self.parentNode.concept !== 'Assignment' &&
+            self.parentNode.concept !== 'ForEachStatement' &&
+            self.parentNode.concept !== 'SelectMembers' &&
+            self.parentNode.concept !== 'UnaryExpression' &&
+            self.parentNode.concept !== 'BinaryExpression' &&
+            self.parentNode.concept !== 'StringInterpolation' &&
+            self.parentNode.concept !== 'MemberExpression' &&
+            !['NewMap', 'NewList'].includes(self.parentNode.concept) &&
+            self.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 || 0);
+        code += '(function match(_value) { \n';
+        let parentCode;
+        if (this.expression) {
+            code += (0, translator_1.indent)((state?.tabSize || 0) + 1);
+            // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
+            if (asserts.isIdentifier(this.expression) || asserts.isMemberExpression(this.expression)) {
+                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 || 0) + 1 }), index, parentCode);
+        });
+        code += (0, translator_1.indent)(state?.tabSize || 0);
+        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;
+    }
+};
+/** 类名 */
+Match.ConceptName = 'Match';
+/** 继承链 */
+Match.inheritanceChain = ['LogicItem', 'BaseNode'];
+__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([
+    translator_1.withSourceMapGenerator
+], Match.prototype, "toEmbeddedTS", null);
+__decorate([
+    (0, translator_1.withSourceMap)()
+], Match.prototype, "toNaturalTS", null);
+Match = Match_1 = __decorate([
+    (0, decorators_1.concept)('匹配')
+], Match);
+exports.Match = Match;
+exports.default = Match;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================
+// @ts-check
+//# sourceMappingURL=Match__.js.map