xshell 1.0.84 → 1.0.86

package/net.js

@@ -80,7 +80,7 @@ export async function request(url, options = {}) {
     let headers = {
         'accept-language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,ja-JP;q=0.6,ja;q=0.5',
         'accept-encoding': 'gzip, deflate, br',
-        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36',
         'sec-ch-ua-platform': '"Windows"',
         'sec-ch-ua-platform-version': '"15.0.0"',
     };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.0.84",
+    "version": "1.0.86",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -53,17 +53,18 @@
         ]
     },
     "dependencies": {
-        "@babel/core": "^7.24.0",
-        "@babel/parser": "^7.24.0",
-        "@babel/traverse": "^7.24.0",
+        "@babel/core": "^7.24.4",
+        "@babel/parser": "^7.24.4",
+        "@babel/traverse": "^7.24.1",
         "@koa/cors": "^5.0.0",
         "@types/ws": "^8.5.10",
+        "@typescript-eslint/utils": "^7.5.0",
         "ali-oss": "^6.20.0",
-        "archiver": "^7.0.0",
+        "archiver": "^7.0.1",
         "byte-size": "^8.1.1",
         "chalk": "^5.3.0",
         "chardet": "^2.0.0",
-        "cli-table3": "^0.6.3",
+        "cli-table3": "^0.6.4",
         "cli-truncate": "^4.0.0",
         "colors": "^1.4.0",
         "commander": "^12.0.0",
@@ -73,7 +74,7 @@
         "i18next": "^23.10.1",
         "i18next-scanner": "^4.4.0",
         "js-cookie": "^3.0.5",
-        "koa": "^2.15.0",
+        "koa": "^2.15.2",
         "koa-compress": "^5.1.1",
         "lodash": "^4.17.21",
         "map-stream": "0.0.7",
@@ -81,15 +82,15 @@
         "ora": "^8.0.1",
         "react": "^18.2.0",
         "react-i18next": "^14.1.0",
-        "react-object-model": "^1.2.2",
+        "react-object-model": "^1.2.3",
         "resolve-path": "^1.4.0",
         "strip-ansi": "^7.1.0",
         "through2": "^4.0.2",
         "tough-cookie": "^4.1.3",
         "tslib": "^2.6.2",
-        "typescript": "^5.4.2",
+        "typescript": "^5.4.4",
         "ua-parser-js": "2.0.0-alpha.2",
-        "undici": "^6.7.0",
+        "undici": "^6.11.1",
         "vinyl": "^3.0.0",
         "vinyl-fs": "^4.0.0",
         "ws": "^8.16.0",
@@ -105,24 +106,27 @@
         "@types/babel__traverse": "^7.20.5",
         "@types/byte-size": "^8.1.2",
         "@types/chardet": "^0.8.3",
+        "@types/eslint": "^8.56.7",
+        "@types/estree": "^1.0.5",
         "@types/gulp-sort": "2.0.4",
         "@types/js-cookie": "^3.0.6",
         "@types/koa": "^2.15.0",
         "@types/koa-compress": "^4.0.6",
-        "@types/lodash": "^4.14.202",
+        "@types/lodash": "^4.17.0",
         "@types/mime-types": "^2.1.4",
-        "@types/node": "^20.11.25",
-        "@types/react": "^18.2.64",
+        "@types/node": "^20.12.5",
+        "@types/react": "^18.2.74",
         "@types/through2": "^2.0.41",
         "@types/tough-cookie": "^4.0.5",
         "@types/ua-parser-js": "^0.7.39",
         "@types/vinyl-fs": "^3.0.5",
-        "@types/vscode": "^1.87.0"
+        "@types/vscode": "^1.88.0",
+        "eslint": "^9.0.0"
     },
     "pnpm": {
         "patchedDependencies": {
             "@types/byte-size@8.1.2": "patches/@types__byte-size@8.1.2.patch",
-            "koa@2.15.0": "patches/koa@2.15.0.patch"
+            "koa@2.15.2": "patches/koa@2.15.2.patch"
         }
     }
 }

package/process.d.ts

@@ -48,8 +48,7 @@ interface StartOptions {
         - encoding?: `'utf-8'` 子进程输出编码  child output encoding
         - print?: `true` print 选项，支持设置细项  print option (with details)
         - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理  when 'ignore' then ignore stdio processing
-        - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)  whether to break the connection with child (ignore stdio, unref)
-*/
+        - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)  whether to break the connection with child (ignore stdio, unref) */
 export declare function start(exe: string, args?: string[], { cwd, encoding, print, stdio, detached, envs, window: _window, }?: StartOptions): Promise<ChildProcess>;
 export declare function start_nodejs(js: string, args?: string[], options?: StartOptions): Promise<ChildProcess>;
 export interface CallOptions extends StartOptions {

package/process.js

@@ -15,8 +15,7 @@ export const username = os.userInfo().username;
         - encoding?: `'utf-8'` 子进程输出编码  child output encoding
         - print?: `true` print 选项，支持设置细项  print option (with details)
         - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理  when 'ignore' then ignore stdio processing
-        - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)  whether to break the connection with child (ignore stdio, unref)
-*/
+        - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)  whether to break the connection with child (ignore stdio, unref) */
 export async function start(exe, args = [], { cwd, encoding = 'utf-8', print = true, stdio = 'pipe', detached = false, envs, window: _window = true, } = {}) {
     const options = {
         cwd,

package/prototype.browser.d.ts

@@ -75,6 +75,10 @@ declare global {
             text: string;
         };
         space(this: string): string;
+        /** assert 确保字符串以 prefix 开头（失败时抛出错误），并返回去掉该 prefix 的字符串 */
+        strip_start(this: string, prefix: string): string;
+        /** assert 确保字符串以 suffix 结尾（失败时抛出错误），并返回去掉该 suffix 的字符串 */
+        strip_end(this: string, suffix: string): string;
         /** 等价于 .endsWith('/') */
         isdir: boolean;
         /** 以 `/` 分割的路径，可能以 / 结尾 */

package/prototype.browser.js

@@ -259,6 +259,18 @@ Object.defineProperties(String.prototype, {
                 text: this.slice(i)
             };
         },
+        strip_start(prefix) {
+            if (this.startsWith(prefix))
+                return this.slice(prefix.length);
+            else
+                throw new Error(`字符串没有以前缀 ${prefix} 开头: ${this}`);
+        },
+        strip_end(suffix) {
+            if (this.endsWith(suffix))
+                return this.slice(0, -suffix.length);
+            else
+                throw new Error(`字符串没有以后缀 ${suffix} 结尾: ${this}`);
+        },
         space() {
             if (!this)
                 return this;

package/prototype.d.ts

@@ -98,6 +98,10 @@ declare global {
         decode_base64(this: string, buffer: true): Buffer;
         decode_base64(this: string, buffer?: boolean): string | Buffer;
         space(this: string): string;
+        /** assert 确保字符串以 prefix 开头（失败时抛出错误），并返回去掉该 prefix 的字符串 */
+        strip_start(this: string, prefix: string): string;
+        /** assert 确保字符串以 suffix 结尾（失败时抛出错误），并返回去掉该 suffix 的字符串 */
+        strip_end(this: string, suffix: string): string;
         /** 等价于 .endsWith('/') */
         isdir: boolean;
         /** 以 `/` 分割的路径，可能以 / 结尾 */

package/prototype.js

@@ -278,6 +278,18 @@ if (!globalThis.my_prototype_defined) {
             strip_ansi() {
                 return strip_ansi(this);
             },
+            strip_start(prefix) {
+                if (this.startsWith(prefix))
+                    return this.slice(prefix.length);
+                else
+                    throw new Error(`字符串没有以前缀 ${prefix} 开头: ${this}`);
+            },
+            strip_end(suffix) {
+                if (this.endsWith(suffix))
+                    return this.slice(0, -suffix.length);
+                else
+                    throw new Error(`字符串没有以后缀 ${suffix} 结尾: ${this}`);
+            },
             space() {
                 if (!this)
                     return this;

package/xlint.d.ts

@@ -0,0 +1,108 @@
+import type ESTree from 'estree';
+import type { Rule } from 'eslint';
+import { TSESTree, type TSESLint } from '@typescript-eslint/utils';
+export declare const xlint_plugin: {
+    rules: {
+        'fold-jsdoc-comments': {
+            meta: {
+                readonly fixable: "whitespace";
+                readonly type: "layout";
+            };
+            create: (context: Rule.RuleContext) => {
+                Program(): void;
+            };
+        };
+        'nonblock-statement-body-position-with-indentation': {
+            meta: {
+                readonly fixable: "whitespace";
+                readonly type: "layout";
+            };
+            create(context: Rule.RuleContext): {
+                IfStatement(node: ESTree.IfStatement & Rule.NodeParentExtension): void;
+                WhileStatement: (node: ESTree.WhileStatement & Rule.NodeParentExtension) => void;
+                DoWhileStatement: (node: ESTree.DoWhileStatement & Rule.NodeParentExtension) => void;
+                ForStatement: (node: ESTree.ForStatement & Rule.NodeParentExtension) => void;
+                ForInStatement: (node: ESTree.ForInStatement & Rule.NodeParentExtension) => void;
+                ForOfStatement: (node: ESTree.ForOfStatement & Rule.NodeParentExtension) => void;
+            };
+        };
+        'empty-bracket-spacing': {
+            meta: {
+                readonly fixable: "whitespace";
+                readonly type: "layout";
+            };
+            create(context: Rule.RuleContext): {
+                ObjectExpression(node: ESTree.ObjectExpression & Rule.NodeParentExtension): void;
+                ArrayExpression(node: ESTree.ArrayExpression & Rule.NodeParentExtension): void;
+                BlockStatement(node: ESTree.BlockStatement & Rule.NodeParentExtension): void;
+            };
+        };
+        'space-infix-ops-except-exponentiation': {
+            meta: {
+                messages: {
+                    missingSpace: string;
+                    redundantSpace: string;
+                };
+                fixable: "whitespace";
+                type: "layout";
+            };
+            create(context: TSESLint.RuleContext<'missingSpace' | 'redundantSpace', any[]>): {
+                AssignmentExpression: (node: any) => void;
+                AssignmentPattern: (node: any) => void;
+                BinaryExpression: (node: any) => void;
+                LogicalExpression: (node: any) => void;
+                ConditionalExpression: (node: any) => void;
+                VariableDeclarator: (node: any) => void;
+                TSEnumMember: (node: TSESTree.TSEnumMember) => void;
+                PropertyDefinition: (node: TSESTree.PropertyDefinition) => void;
+                TSTypeAliasDeclaration: (node: TSESTree.TSTypeAliasDeclaration) => void;
+                TSUnionType: (typeAnnotation: TSESTree.TSIntersectionType | TSESTree.TSUnionType) => void;
+                TSIntersectionType: (typeAnnotation: TSESTree.TSIntersectionType | TSESTree.TSUnionType) => void;
+                TSConditionalType: (node: TSESTree.TSConditionalType) => void;
+            };
+        };
+        'space-in-for-statement': {
+            meta: {
+                readonly fixable: "whitespace";
+                readonly type: "layout";
+            };
+            create(context: Rule.RuleContext): {
+                ForStatement(node: ESTree.ForStatement & Rule.NodeParentExtension): void;
+            };
+        };
+        'jsx-no-redundant-parenthesis-in-return': {
+            meta: {
+                readonly fixable: "whitespace";
+                readonly type: "layout";
+            };
+            create(context: Rule.RuleContext): {
+                ReturnStatement(node: ESTree.ReturnStatement & Rule.NodeParentExtension): void;
+                ArrowFunctionExpression(node: ESTree.ArrowFunctionExpression & Rule.NodeParentExtension): void;
+            };
+        };
+        'keep-indent': {
+            meta: {
+                readonly fixable: "whitespace";
+                readonly type: "layout";
+            };
+            create(context: Rule.RuleContext): {
+                Program(): void;
+            };
+        };
+        'func-style': {
+            meta: {
+                readonly fixable: "whitespace";
+                readonly type: "layout";
+            };
+            create(context: Rule.RuleContext): {
+                FunctionDeclaration(node: ESTree.FunctionDeclaration & Rule.NodeParentExtension): void;
+                'FunctionDeclaration:exit'(): void;
+                FunctionExpression(node: ESTree.FunctionExpression & Rule.NodeParentExtension): void;
+                'FunctionExpression:exit'(): void;
+                ThisExpression(): void;
+                ArrowFunctionExpression(): void;
+                'ArrowFunctionExpression:exit'(node: ESTree.ArrowFunctionExpression & Rule.NodeParentExtension): void;
+            };
+        };
+    };
+};

package/xlint.js

@@ -0,0 +1,748 @@
+import { AST_TOKEN_TYPES, ASTUtils, TSESTree } from '@typescript-eslint/utils';
+const line_break_pattern = /\r\n|[\r\n\u2028\u2029]/u;
+const meta = {
+    fixable: 'whitespace',
+    type: 'layout',
+};
+const UNIONS = ['|', '&'];
+// 用 ast explorer 选 esprima 来看
+// node.loc.start.line 下标从 1 开始
+export const xlint_plugin = {
+    rules: {
+        'fold-jsdoc-comments': {
+            meta,
+            create: context => ({
+                Program() {
+                    for (const comment of context.sourceCode.getAllComments())
+                        if (comment.type === 'Block') {
+                            const lines = comment.value.split(line_break_pattern);
+                            if (lines.length >= 3 &&
+                                /^\*\s*$/u.test(lines[0]) &&
+                                lines.slice(1, -1).every(line => /^\s*\*/u.test(line)) &&
+                                /^[\s\*]*$/u.test(lines.at(-1)))
+                                context.report({
+                                    loc: {
+                                        start: comment.loc.start,
+                                        end: comment.loc.end
+                                    },
+                                    message: 'Redundant jsdoc comment.',
+                                    fix(fixer) {
+                                        const indent = ' '.repeat(comment.loc.start.column);
+                                        const indenter = (line) => line.replace(/^\s*\*\s?/u, `${indent}    `);
+                                        return fixer.replaceTextRange(comment.range, lines.length === 3 ?
+                                            `/** ${lines[1].replace(/^\s*\*\s*/u, '')} */`
+                                            :
+                                                [
+                                                    `/** ${lines[1].replace(/^\s*\*\s?/u, '')}`,
+                                                    ...lines.slice(2, -2).map(indenter),
+                                                    `${indenter(lines.at(-2))} */`
+                                                ].join('\n'));
+                                    }
+                                });
+                        }
+                }
+            })
+        },
+        // 一条语句作为 body 时强制换行缩进
+        // if (1) body
+        // 更改为
+        // if (1)
+        //     body
+        'nonblock-statement-body-position-with-indentation': {
+            meta,
+            create(context) {
+                const source = context.sourceCode;
+                const lines = source.getLines();
+                function lint(body, node) {
+                    if (body.type !== 'BlockStatement') {
+                        const token_before = source.getTokenBefore(body);
+                        let indent = 0;
+                        const line = lines[node.loc.start.line - 1];
+                        for (let i = 0; i < line.length; i++)
+                            if (line[i] === ' ')
+                                indent++;
+                            else if (line[i] === '\t')
+                                indent += 4;
+                            else
+                                break;
+                        if (token_before.loc.end.line === body.loc.start.line ||
+                            body.loc.start.column !== indent + 4)
+                            context.report({
+                                node: body,
+                                message: 'Expected a linebreak before this statement.',
+                                fix: fixer => fixer.replaceTextRange([token_before.range[1], body.range[0]], '\n' + ' '.repeat(indent + 4))
+                            });
+                    }
+                }
+                return {
+                    IfStatement(node) {
+                        lint(node.consequent, node);
+                        // Check the `else` node, but don't check 'else if' statements.
+                        if (node.alternate && node.alternate.type !== 'IfStatement')
+                            lint(node.alternate, node);
+                    },
+                    WhileStatement: node => lint(node.body, node),
+                    DoWhileStatement: node => lint(node.body, node),
+                    ForStatement: node => lint(node.body, node),
+                    ForInStatement: node => lint(node.body, node),
+                    ForOfStatement: node => lint(node.body, node)
+                };
+            },
+        },
+        // let o = { }
+        // let a = [ ]
+        // function foo () { }
+        'empty-bracket-spacing': {
+            meta,
+            create(context) {
+                const source = context.sourceCode;
+                return {
+                    ObjectExpression(node) {
+                        // 是 {} 这样的空对象
+                        if (node.properties.length === 0 && source.getText(node) === '{}')
+                            context.report({
+                                node,
+                                message: 'Expected a space in this empty object.',
+                                fix: fixer => fixer.replaceText(node, '{ }')
+                            });
+                    },
+                    ArrayExpression(node) {
+                        // 是 [] 这样的空数组
+                        if (node.elements.length === 0 && source.getText(node) === '[]')
+                            context.report({
+                                node,
+                                message: 'Expected a space in this empty array.',
+                                fix: fixer => fixer.replaceText(node, '[ ]')
+                            });
+                    },
+                    BlockStatement(node) {
+                        if (node.body.length === 0 && source.getText(node) === '{}')
+                            context.report({
+                                node,
+                                message: 'Expected a space in this empty block.',
+                                fix: fixer => fixer.replaceText(node, '{ }')
+                            });
+                    },
+                };
+            }
+        },
+        // a + b**c
+        'space-infix-ops-except-exponentiation': {
+            meta: {
+                ...meta,
+                messages: {
+                    missingSpace: "Operator '{{operator}}' must be spaced.",
+                    redundantSpace: "Operator '{{operator}}' must not be spaced."
+                }
+            },
+            // @ts-ignore
+            create(context) {
+                const int32Hint = true;
+                const { sourceCode } = context;
+                /** Returns the first token which violates the rule
+                    @param {ASTNode} left The left node of the main node
+                    @param {ASTNode} right The right node of the main node
+                    @param {string} op The operator of the main node
+                    @returns {Object} The violator token or null
+                    @private */
+                function getFirstNonSpacedToken(left, right, op) {
+                    const operator = sourceCode.getFirstTokenBetween(left, right, token => token.value === op);
+                    const prev = sourceCode.getTokenBefore(operator);
+                    const next = sourceCode.getTokenAfter(operator);
+                    if (!sourceCode.isSpaceBetween(prev, operator) || !sourceCode.isSpaceBetween(operator, next))
+                        return operator;
+                    return null;
+                }
+                /**
+                    Reports an AST node as a rule violation
+                    @param {ASTNode} mainNode The node to report
+                    @param {Object} culpritToken The token which has a problem
+                    @returns {void}
+                    @private
+                */
+                function report(mainNode, culpritToken) {
+                    context.report({
+                        node: mainNode,
+                        loc: culpritToken.loc,
+                        messageId: 'missingSpace',
+                        data: {
+                            operator: culpritToken.value
+                        },
+                        fix(fixer) {
+                            const previousToken = sourceCode.getTokenBefore(culpritToken);
+                            const afterToken = sourceCode.getTokenAfter(culpritToken);
+                            let fixString = '';
+                            if (culpritToken.range[0] - previousToken.range[1] === 0)
+                                fixString = ' ';
+                            fixString += culpritToken.value;
+                            if (afterToken.range[0] - culpritToken.range[1] === 0)
+                                fixString += ' ';
+                            return fixer.replaceText(culpritToken, fixString);
+                        }
+                    });
+                }
+                /**
+                    Check if the node is binary then report
+                    @param {ASTNode} node node to evaluate
+                    @returns {void}
+                    @private
+                */
+                function checkBinary(node) {
+                    const leftNode = node.left.typeAnnotation ? node.left.typeAnnotation : node.left;
+                    const rightNode = node.right;
+                    // search for = in AssignmentPattern nodes
+                    const operator = node.operator || '=';
+                    // 找到 ** operator
+                    if (operator === '**') {
+                        const op = sourceCode.getFirstTokenBetween(leftNode, rightNode, token => token.value === operator);
+                        const prev = sourceCode.getTokenBefore(op);
+                        const next = sourceCode.getTokenAfter(op);
+                        if (sourceCode.isSpaceBetween(prev, op) || sourceCode.isSpaceBetween(op, next))
+                            context.report({
+                                node,
+                                loc: op.loc,
+                                messageId: 'redundantSpace',
+                                data: {
+                                    operator: op.value
+                                },
+                                fix(fixer) {
+                                    const previousToken = sourceCode.getTokenBefore(op);
+                                    const afterToken = sourceCode.getTokenAfter(op);
+                                    let fixes = [];
+                                    if (op.range[0] > previousToken.range[1])
+                                        fixes.push(
+                                        // @ts-ignore
+                                        fixer.removeRange([previousToken.range[1], op.range[0]]));
+                                    if (afterToken.range[0] > op.range[1])
+                                        fixes.push(
+                                        // @ts-ignore
+                                        fixer.removeRange([op.range[1], afterToken.range[0]]));
+                                    return fixes;
+                                }
+                            });
+                    }
+                    else {
+                        const nonSpacedNode = getFirstNonSpacedToken(leftNode, rightNode, operator);
+                        if (nonSpacedNode)
+                            if (!(int32Hint && sourceCode.getText(node).endsWith('|0')))
+                                report(node, nonSpacedNode);
+                    }
+                }
+                /**
+                    Check if the node is conditional
+                    @param {ASTNode} node node to evaluate
+                    @returns {void}
+                    @private
+                */
+                function checkConditional(node) {
+                    const nonSpacedConsequentNode = getFirstNonSpacedToken(node.test, node.consequent, '?');
+                    const nonSpacedAlternateNode = getFirstNonSpacedToken(node.consequent, node.alternate, ':');
+                    if (nonSpacedConsequentNode)
+                        report(node, nonSpacedConsequentNode);
+                    if (nonSpacedAlternateNode)
+                        report(node, nonSpacedAlternateNode);
+                }
+                /**
+                    Check if the node is a variable
+                    @param {ASTNode} node node to evaluate
+                    @returns {void}
+                    @private
+                */
+                function checkVar(node) {
+                    const leftNode = node.id.typeAnnotation ? node.id.typeAnnotation : node.id;
+                    const rightNode = node.init;
+                    if (rightNode) {
+                        const nonSpacedNode = getFirstNonSpacedToken(leftNode, rightNode, '=');
+                        if (nonSpacedNode)
+                            report(node, nonSpacedNode);
+                    }
+                }
+                function ts_report(operator) {
+                    context.report({
+                        node: operator,
+                        messageId: 'missingSpace',
+                        data: {
+                            operator: operator.value
+                        },
+                        fix(fixer) {
+                            const previousToken = sourceCode.getTokenBefore(operator);
+                            const afterToken = sourceCode.getTokenAfter(operator);
+                            let fixString = '';
+                            if (operator.range[0] - previousToken.range[1] === 0)
+                                fixString = ' ';
+                            fixString += operator.value;
+                            if (afterToken.range[0] - operator.range[1] === 0)
+                                fixString += ' ';
+                            return fixer.replaceText(operator, fixString);
+                        }
+                    });
+                }
+                function isSpaceChar(token) {
+                    return token.type === AST_TOKEN_TYPES.Punctuator && /^[=?:]$/.test(token.value);
+                }
+                function checkAndReportAssignmentSpace(leftNode, rightNode) {
+                    if (!rightNode || !leftNode)
+                        return;
+                    const operator = sourceCode.getFirstTokenBetween(leftNode, rightNode, isSpaceChar);
+                    const prev = sourceCode.getTokenBefore(operator);
+                    const next = sourceCode.getTokenAfter(operator);
+                    if (!sourceCode.isSpaceBetween(prev, operator) || !sourceCode.isSpaceBetween(operator, next))
+                        ts_report(operator);
+                }
+                /**
+                    Check if it has an assignment char and report if it's faulty
+                    @param node The node to report
+                */
+                function checkForEnumAssignmentSpace(node) {
+                    checkAndReportAssignmentSpace(node.id, node.initializer);
+                }
+                /**
+                    Check if it has an assignment char and report if it's faulty
+                    @param node The node to report
+                */
+                function checkForPropertyDefinitionAssignmentSpace(node) {
+                    const leftNode = node.optional && !node.typeAnnotation ? sourceCode.getTokenAfter(node.key) : node.typeAnnotation ?? node.key;
+                    checkAndReportAssignmentSpace(leftNode, node.value);
+                }
+                /**
+                    Check if it is missing spaces between type annotations chaining
+                    @param typeAnnotation TypeAnnotations list
+                */
+                function checkForTypeAnnotationSpace(typeAnnotation) {
+                    const types = typeAnnotation.types;
+                    types.forEach(type => {
+                        const skipFunctionParenthesis = type.type === TSESTree.AST_NODE_TYPES.TSFunctionType ? ASTUtils.isNotOpeningBraceToken : 0;
+                        const operator = sourceCode.getTokenBefore(type, skipFunctionParenthesis);
+                        if (operator && UNIONS.includes(operator.value)) {
+                            const prev = sourceCode.getTokenBefore(operator);
+                            const next = sourceCode.getTokenAfter(operator);
+                            if (!sourceCode.isSpaceBetween(prev, operator) || !sourceCode.isSpaceBetween(operator, next))
+                                ts_report(operator);
+                        }
+                    });
+                }
+                /**
+                    Check if it has an assignment char and report if it's faulty
+                    @param node The node to report
+                */
+                function checkForTypeAliasAssignment(node) {
+                    checkAndReportAssignmentSpace(node.typeParameters ?? node.id, node.typeAnnotation);
+                }
+                function checkForTypeConditional(node) {
+                    checkAndReportAssignmentSpace(node.extendsType, node.trueType);
+                    checkAndReportAssignmentSpace(node.trueType, node.falseType);
+                }
+                return {
+                    AssignmentExpression: checkBinary,
+                    AssignmentPattern: checkBinary,
+                    BinaryExpression: checkBinary,
+                    LogicalExpression: checkBinary,
+                    ConditionalExpression: checkConditional,
+                    VariableDeclarator: checkVar,
+                    TSEnumMember: checkForEnumAssignmentSpace,
+                    PropertyDefinition: checkForPropertyDefinitionAssignmentSpace,
+                    TSTypeAliasDeclaration: checkForTypeAliasAssignment,
+                    TSUnionType: checkForTypeAnnotationSpace,
+                    TSIntersectionType: checkForTypeAnnotationSpace,
+                    TSConditionalType: checkForTypeConditional
+                };
+            }
+        },
+        // for (;;)
+        //     1;
+        // for (let i = 0;  i < 10;  i++)
+        // for (  ;  i < 10;  )
+        'space-in-for-statement': {
+            meta,
+            create(context) {
+                const source = context.sourceCode;
+                return {
+                    ForStatement(node) {
+                        const paren_left = source.getFirstToken(node, token => token.value === '(');
+                        const semi0 = source.getTokenAfter(node.init || paren_left);
+                        const semi1 = source.getTokenAfter(node.test || semi0);
+                        const semi0_prev = source.getTokenBefore(semi0, { includeComments: true });
+                        const semi0_next = source.getTokenAfter(semi0, { includeComments: true });
+                        const semi1_next = source.getTokenAfter(semi1, { includeComments: true });
+                        if (node.init || node.test || node.update) {
+                            // for (let i = 0;  i < 10;  i++)
+                            // for (  ;  i < 10;  )
+                            // for (  ;  ;  i++)
+                            // for (let i = 0;)
+                            if (node.init) {
+                                if (semi0.loc.start.line === semi0_prev.loc.end.line &&
+                                    semi0.loc.start.column !== semi0_prev.loc.end.column)
+                                    context.report({
+                                        loc: {
+                                            start: semi0_prev.loc.end,
+                                            end: semi0.loc.start
+                                        },
+                                        message: 'for 语句第一个分号前面应该没有多余空格',
+                                        node,
+                                        fix: fixer => fixer.removeRange([semi0_prev.range[1], semi0.range[0]])
+                                    });
+                            }
+                            else // for (  ;)
+                             if (semi0.loc.start.line === semi0_prev.loc.end.line &&
+                                semi0.loc.start.column - semi0_prev.loc.end.column !== 2)
+                                context.report({
+                                    loc: {
+                                        start: semi0_prev.loc.end,
+                                        end: semi0.loc.start
+                                    },
+                                    message: 'for 语句第一个分号前面应该为 2 个空格',
+                                    node,
+                                    fix: fixer => fixer.replaceTextRange([semi0_prev.range[1], semi0.range[0]], '  ')
+                                });
+                            // for (  ;  ;)
+                            if (semi0_next.loc.start.line === semi0.loc.end.line &&
+                                semi0_next.loc.start.column - semi0.loc.end.column !== 2)
+                                context.report({
+                                    loc: {
+                                        start: semi0.loc.end,
+                                        end: semi0_next.loc.start
+                                    },
+                                    message: 'for 语句第一个分号后面应为 2 个空格',
+                                    node,
+                                    fix: fixer => fixer.replaceTextRange([semi0.range[1], semi0_next.range[0]], '  ')
+                                });
+                            // // for (  ;  i > 0;)
+                            if (node.test) {
+                                const test_end = source.getLastToken(node.test);
+                                if (semi1.loc.start.line === test_end.loc.end.line &&
+                                    semi1.loc.start.column !== test_end.loc.end.column)
+                                    context.report({
+                                        loc: {
+                                            start: test_end.loc.end,
+                                            end: semi1.loc.start,
+                                        },
+                                        message: 'for 语句第二个分号前面没有多余的空格',
+                                        node,
+                                        fix: fixer => fixer.removeRange([test_end.range[1], semi1.range[0]])
+                                    });
+                            }
+                            if (semi1_next.loc.start.line === semi1.loc.end.line &&
+                                semi1_next.loc.start.column - semi1.loc.end.column !== 2)
+                                context.report({
+                                    loc: {
+                                        start: semi1.loc.end,
+                                        end: semi1_next.loc.start
+                                    },
+                                    message: 'for 语句第二个分号后面应为 2 个空格',
+                                    node,
+                                    fix: fixer => fixer.replaceTextRange([semi1.range[1], semi1_next.range[0]], '  ')
+                                });
+                        }
+                        else { // for (;;)
+                            if (semi0.loc.start.line === semi0_prev.loc.end.line &&
+                                semi0.loc.start.column !== semi0_prev.loc.end.column)
+                                context.report({
+                                    loc: {
+                                        start: semi0_prev.loc.end,
+                                        end: semi0.loc.start
+                                    },
+                                    message: '无条件 for 语句第一个分号前面应该没有空格',
+                                    node,
+                                    fix: fixer => fixer.removeRange([semi0_prev.range[1], semi0.range[0]])
+                                });
+                            if (semi0_next.loc.start.line === semi0.loc.end.line &&
+                                semi0_next.loc.start.column !== semi0.loc.end.column)
+                                context.report({
+                                    loc: {
+                                        start: semi0.loc.end,
+                                        end: semi0_next.loc.start
+                                    },
+                                    message: '无条件 for 语句第一个分号后面应该没有空格',
+                                    node,
+                                    fix: fixer => fixer.removeRange([semi0.range[1], semi0_next.range[0]])
+                                });
+                            if (semi1_next.loc.start.line === semi1.loc.end.line &&
+                                semi1_next.loc.start.column !== semi1.loc.end.column)
+                                context.report({
+                                    loc: {
+                                        start: semi1.loc.end,
+                                        end: semi1_next.loc.start
+                                    },
+                                    message: '无条件 for 语句第二个分号后面应该没有空格',
+                                    node,
+                                    fix: fixer => fixer.removeRange([semi1.range[1], semi1_next.range[0]])
+                                });
+                        }
+                    },
+                };
+            }
+        },
+        // return (
+        //     <div>1234</div>
+        // )
+        // 改为
+        // return <div>1234</div>
+        'jsx-no-redundant-parenthesis-in-return': {
+            meta,
+            create(context) {
+                const source = context.sourceCode;
+                return {
+                    ReturnStatement(node) {
+                        if (node.argument?.type === 'JSXElement' || node.argument?.type === 'JSXFragment') {
+                            const paren0 = source.getTokenBefore(node.argument);
+                            const paren1 = source.getTokenAfter(node.argument);
+                            if (paren0.type === 'Punctuator' && paren0.value === '(' &&
+                                paren1.type === 'Punctuator' && paren1.value === ')') {
+                                const paren0_next = source.getTokenAfter(paren0);
+                                const paren1_prev = source.getTokenBefore(paren1);
+                                context.report({
+                                    loc: {
+                                        start: paren0.loc.start,
+                                        end: paren1.loc.end
+                                    },
+                                    message: 'return jsx 表达式不应该有多余的括号',
+                                    node,
+                                    fix: fixer => ([
+                                        fixer.removeRange([paren0.range[0], paren0_next.range[0]]),
+                                        fixer.removeRange([paren1_prev.range[1], paren1.range[1]])
+                                    ])
+                                });
+                            }
+                        }
+                    },
+                    ArrowFunctionExpression(node) {
+                        if (node.body?.type === 'JSXElement' || node.body?.type === 'JSXFragment') {
+                            const paren0 = source.getTokenBefore(node.body);
+                            const paren1 = source.getTokenAfter(node.body);
+                            if (paren0.type === 'Punctuator' && paren0.value === '(' &&
+                                paren1.type === 'Punctuator' && paren1.value === ')') {
+                                const paren0_next = source.getTokenAfter(paren0);
+                                const paren1_prev = source.getTokenBefore(paren1);
+                                context.report({
+                                    loc: {
+                                        start: paren0.loc.start,
+                                        end: paren1.loc.end
+                                    },
+                                    message: 'return jsx 表达式不应该有多余的括号',
+                                    node,
+                                    fix: fixer => ([
+                                        fixer.removeRange([paren0.range[0], paren0_next.range[0]]),
+                                        fixer.removeRange([paren1_prev.range[1], paren1.range[1]])
+                                    ])
+                                });
+                            }
+                        }
+                    },
+                };
+            }
+        },
+        'keep-indent': {
+            meta,
+            create(context) {
+                const source = context.sourceCode;
+                const lines = source.getLines();
+                return {
+                    Program() {
+                        // 参考 keep_indent 逻辑
+                        if (lines.length >= 2) {
+                            let last_line = { indent: 0, text: '' };
+                            for (let i = 0; i < lines.length - 1; i++) {
+                                const _line = split_indent(lines[i]);
+                                if (!_line.indent && !_line.text && last_line.indent) {
+                                    const pos = { column: 0, line: i + 1 };
+                                    const index = source.getIndexFromLoc(pos);
+                                    const node = source.getNodeByRangeIndex(index);
+                                    if (node && node.type !== 'Program')
+                                        context.report({
+                                            message: '空行应保留与上一个区块相同的缩进',
+                                            loc: { start: pos, end: pos },
+                                            fix: fixer => fixer.replaceTextRange([index, index], ' '.repeat(last_line.indent))
+                                        });
+                                }
+                                last_line = _line;
+                            }
+                        }
+                    }
+                };
+            }
+        },
+        'func-style': {
+            meta,
+            create(context) {
+                const source = context.sourceCode;
+                let stack = [];
+                const fix = (fixer, node) => fixer.replaceText(node.parent.parent, `${node.async ? 'async ' : ''}function ${node.generator ? '* ' : ''}` +
+                    // todo: 丢失了泛型参数 const foo = <D = Zippable> (xxx: D) => { }，如何加回来？
+                    node.parent.id.name +
+                    ' (' +
+                    node.params.map(param => source.getText(param)).join(', ') +
+                    ') ' +
+                    source.getText(node.body));
+                return {
+                    FunctionDeclaration(node) {
+                        stack.push(false);
+                    },
+                    'FunctionDeclaration:exit'() {
+                        stack.pop();
+                    },
+                    FunctionExpression(node) {
+                        stack.push(false);
+                        if (node.parent.type === 'VariableDeclarator')
+                            context.report({
+                                node: node.parent.parent,
+                                message: '函数应该使用 function foo { } 这样来声明而不是 const foo = function () { }',
+                                loc: node.parent.parent.loc,
+                                fix: fixer => fix(fixer, node)
+                            });
+                    },
+                    'FunctionExpression:exit'() {
+                        stack.pop();
+                    },
+                    ThisExpression() {
+                        if (stack.length > 0)
+                            stack[stack.length - 1] = true;
+                    },
+                    ArrowFunctionExpression() {
+                        stack.push(false);
+                    },
+                    'ArrowFunctionExpression:exit'(node) {
+                        if (!stack.pop() && // not has this expr
+                            node.parent.type === 'VariableDeclarator' &&
+                            node.body.type === 'BlockStatement' && node.body.body.length // 多条语句才转换
+                        )
+                            context.report({
+                                node: node.parent.parent,
+                                message: '多条语句的函数应该使用 function foo { } 这样来声明而不是 const foo = () => { }',
+                                loc: node.parent.parent.loc,
+                                fix: fixer => fix(fixer, node)
+                            });
+                    }
+                };
+            }
+        },
+        // 规则太复杂了，暂时写不出来
+        // ... color ? [ ] : [
+        //     '-c', 'color.status=false', 
+        //     '-c', 'color.ui=false', 
+        //     '-c', 'color.branch=false',
+        //     '-c', 'color.ui=false',
+        // ],
+        // test ? 
+        //      ...
+        // : [ ]
+        // 'conditional-expresssion-style': {
+        //     meta,
+        //     create (context) {
+        //         const source = context.sourceCode
+        //         const lines = source.getLines()
+        //         return {
+        //             ConditionalExpression (node) {
+        //                 const question = source.getTokenAfter(node.test, not_closing_paren)
+        //                 const colon = source.getTokenAfter(node.consequent, not_closing_paren)
+        //                 const test_tail = source.getTokenBefore(question, { includeComments: true })
+        //                 const test_head = source.getFirstToken(node, { includeComments: true })
+        //                 const consequent_start = source.getTokenAfter(question, not_opening_paren)
+        //                 const consequent_tail = source.getTokenBefore(colon, not_closing_paren)
+        //                 const alternate_start = source.getTokenAfter(colon, not_opening_paren)
+        //                 const node_tail = source.getLastToken(node)
+        //                 // 三元运算符的 ? 应该和 test 条件末尾在同一行
+        //                 if (test_tail.loc.start.line !== question.loc.start.line)
+        //                     context.report({
+        //                         node,
+        //                         loc: {
+        //                             start: colon.loc.start,
+        //                             end: colon.loc.end
+        //                         },
+        //                         message: '条件表达式的 ? 应该和 test 条件末尾在同一行',
+        //                         fix: fixer => fixer.replaceTextRange([test_tail.range[1], colon.range[0]], ' ')
+        //                     })
+        //                 // 单行的条件表达式
+        //                 if (colon.loc.start.line === question.loc.start.line) {
+        //                     const alternate_start_with_comments = source.getTokenAfter(colon, { includeComments: true, filter: not_opening_paren })
+        //                     if (node_tail.loc.end.line !== colon.loc.start.line)
+        //                         context.report({
+        //                             node,
+        //                             loc: {
+        //                                 start: node.alternate.loc.start,
+        //                                 end: node_tail.loc.end
+        //                             },
+        //                             message: '单行条件表达式的 else 条件也应该在同一行',
+        //                             fix: fixer => fixer.replaceTextRange([colon.range[1], alternate_start_with_comments.range[0]], ' ')
+        //                         })
+        //                 } else {  // 多行条件表达式
+        //                     if (consequent_tail.loc.end.line === colon.loc.start.line)
+        //                         context.report({
+        //                             node,
+        //                             loc: {
+        //                                 start: consequent_tail.loc.start,
+        //                                 end: colon.loc.start
+        //                             },
+        //                             message: '多行条件表达式的 : 应该在单独的一行',
+        //                             fix: fixer => 
+        //                                 fixer.insertTextBefore(
+        //                                     colon,
+        //                                     '\n' +
+        //                                     ' '.repeat(
+        //                                         Math.max(split_indent(lines[consequent_tail.loc.end.line - 1]).indent - 4, 0)
+        //                                     )
+        //                                 )
+        //                         })
+        //                     if (
+        //                         alternate_start.loc.start.line === colon.loc.start.line && 
+        //                         (node.alternate.loc.start.line !== node.alternate.loc.end.line)
+        //                     )
+        //                         context.report({
+        //                             node,
+        //                             loc: {
+        //                                 start: colon.loc.end,
+        //                                 end: alternate_start.loc.start
+        //                             },
+        //                             message: '多行条件表达式的 : 应该在单独的一行',
+        //                             fix: fixer => fixer.insertTextBefore(
+        //                                 alternate_start,
+        //                                 '\n' +
+        //                                 ' '.repeat(
+        //                                     split_indent(lines[colon.loc.start.line - 1]).indent + 4
+        //                                 )
+        //                             )
+        //                         })
+        //                     if (consequent_start.loc.start.line === question.loc.start.line)
+        //                         context.report({
+        //                             node,
+        //                             loc: {
+        //                                 start: question.loc.end,
+        //                                 end: test_head.loc.start
+        //                             },
+        //                             message: '多行条件表达式的 ? 这一行后面不应该有其他表达式，请换行',
+        //                             fix: fixer => fixer.insertTextBefore(
+        //                                 consequent_start,
+        //                                 '\n' +
+        //                                 ' '.repeat(
+        //                                     split_indent(lines[colon.loc.start.line - 1]).indent + 4
+        //                                 )
+        //                             )
+        //                         })
+        //                 }
+        //             }
+        //         }
+        //     }
+        // }
+    }
+};
+function split_indent(line) {
+    let i = 0;
+    let indent = 0;
+    for (; i < line.length; i++)
+        if (line[i] === ' ')
+            indent++;
+        else if (line[i] === '\t')
+            indent += 4;
+        else
+            break;
+    return {
+        indent,
+        text: line.slice(i)
+    };
+}
+function not_opening_paren(token) {
+    return !(['(', '[', '{'].includes(token.value) && token.type === 'Punctuator');
+}
+function not_closing_paren(token) {
+    return !([')', ']', '}'].includes(token.value) && token.type === 'Punctuator');
+}
+//# sourceMappingURL=xlint.js.map