xshell 1.1.9 → 1.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.1.9",
+    "version": "1.1.11",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -57,16 +57,16 @@
         "@svgr/webpack": "^8.1.0",
         "@types/sass-loader": "^8.0.9",
         "@types/ws": "^8.5.13",
-        "@typescript-eslint/eslint-plugin": "^8.18.1",
-        "@typescript-eslint/parser": "^8.18.1",
-        "@typescript-eslint/utils": "^8.18.1",
+        "@typescript-eslint/eslint-plugin": "^8.18.2",
+        "@typescript-eslint/parser": "^8.18.2",
+        "@typescript-eslint/utils": "^8.18.2",
         "@xterm/addon-fit": "^0.10.0",
         "@xterm/addon-web-links": "^0.11.0",
         "@xterm/addon-webgl": "^0.18.0",
         "@xterm/xterm": "^5.5.0",
         "ali-oss": "^6.22.0",
         "archiver": "^7.0.1",
-        "chalk": "^5.4.0",
+        "chalk": "^5.4.1",
         "chardet": "^2.0.0",
         "cli-table3": "^0.6.5",
         "cli-truncate": "^4.0.0",
@@ -76,7 +76,7 @@
         "emoji-regex": "^10.4.0",
         "eslint": "^9.17.0",
         "eslint-plugin-import": "^2.31.0",
-        "eslint-plugin-react": "^7.37.2",
+        "eslint-plugin-react": "^7.37.3",
         "gulp-sort": "^2.0.0",
         "hash-string": "^1.0.0",
         "https-proxy-agent": "^7.0.6",

package/path.d.ts

@@ -1,5 +1,4 @@
 import { default as npath, type FormatInputPathObject } from 'path';
-export declare function to_fp(str: string): string;
 /** Normalize a string path, reducing '..' and '.' parts.
     When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved.
     @param path string path to normalize.
@@ -55,7 +54,7 @@ export declare function extname(path: string): string;
 /** `/` */
 export declare const sep = "/";
 /** The platform-specific file delimiter. ';' or ':'. */
-export declare const delimiter: ":" | ";";
+export declare const delimiter: ";" | ":";
 /** Returns an object from a path string - the opposite of format().
     @param path path to evaluate.
     @throws {TypeError} if `path` is not a string. */
@@ -67,12 +66,11 @@ export declare function format(pathObject: FormatInputPathObject): string;
     If path is not a string, path will be returned without modifications.
     This method is meaningful only on Windows system.
     On POSIX systems, the method is non-operational and always returns path without modifications. */
-export declare function toNamespacedPath(path: string): any;
+export declare function toNamespacedPath(path: string): string;
 export declare const posix: npath.PlatformPath;
 export declare const win32: npath.PlatformPath;
 /** 统一使用 / 作为分隔符的 path 模块 */
 export declare let path: {
-    to_fp: typeof to_fp;
     normalize: typeof normalize;
     join: typeof join;
     resolve: typeof resolve;
@@ -83,7 +81,7 @@ export declare let path: {
     basename: typeof basename;
     extname: typeof extname;
     sep: string;
-    delimiter: ":" | ";";
+    delimiter: ";" | ":";
     parse: typeof parse;
     format: typeof format;
     toNamespacedPath: typeof toNamespacedPath;

package/path.js

@@ -1,25 +1,16 @@
 import { default as npath } from 'path';
-export function to_fp(str) {
-    if (!str)
-        return str;
-    const fp = str.replaceAll('\\', '/');
-    // 转换小写盘符开头的路径
-    return fp[1] === ':' && 'a' <= fp[0] && fp[0] <= 'z'
-        ? fp[0].toUpperCase() + fp.slice(1)
-        : fp;
-}
 /** Normalize a string path, reducing '..' and '.' parts.
     When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved.
     @param path string path to normalize.
     @throws {TypeError} if `path` is not a string. */
 export function normalize(path) {
-    return to_fp(npath.normalize(to_fp(path)));
+    return npath.normalize(path).fp;
 }
 /** Join all arguments together and normalize the resulting path.
     @param paths paths to join.
     @throws {TypeError} if any of the path segments is not a string. */
 export function join(...paths) {
-    return to_fp(npath.join(...paths.map(p => to_fp(p))));
+    return npath.join(...paths.map(p => p.fp)).fp;
 }
 /** The right-most parameter is considered {to}. Other parameters are considered an array of {from}.
     
@@ -33,7 +24,7 @@ export function join(...paths) {
     @param paths A sequence of paths or path segments.
     @throws {TypeError} if any of the arguments is not a string. */
 export function resolve(...paths) {
-    return to_fp(npath.resolve(...paths.map(p => to_fp(p))));
+    return npath.resolve(...paths.map(p => p.fp)).fp;
 }
 /** 和 resolve 一样，但是保留最后一个 path 结尾的 / */
 export function resolve_with_slash(...paths) {
@@ -50,20 +41,20 @@ export function resolve_with_slash(...paths) {
     @param path path to test.
     @throws {TypeError} if `path` is not a string. */
 export function isAbsolute(path) {
-    return npath.isAbsolute(to_fp(path));
+    return npath.isAbsolute(path.fp);
 }
 /** Solve the relative path from {from} to {to} based on the current working directory.
     At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve.
     
     @throws {TypeError} if either `from` or `to` is not a string. */
 export function relative(from, to) {
-    return to_fp(npath.relative(to_fp(from), to_fp(to)));
+    return npath.relative(from.fp, to.fp).fp;
 }
 /** Return the directory name of a path. Similar to the Unix dirname command.
     @param path the path to evaluate.
     @throws {TypeError} if `path` is not a string. */
 export function dirname(path) {
-    return to_fp(npath.dirname(path));
+    return npath.dirname(path.fp).fp;
 }
 /** Return the last portion of a path. Similar to the Unix basename command.
     Often used to extract the file name from a fully qualified path.
@@ -71,7 +62,7 @@ export function dirname(path) {
     @param suffix optionally, an extension to remove from the result.
     @throws {TypeError} if `path` is not a string or if `ext` is given and is not a string. */
 export function basename(path, suffix) {
-    return npath.basename(to_fp(path), suffix);
+    return npath.basename(path.fp, suffix);
 }
 /** Return the extension of the path, from the last '.' to end of string in the last portion of the path.
     If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string.
@@ -79,7 +70,7 @@ export function basename(path, suffix) {
     @param path the path to evaluate.
     @throws {TypeError} if `path` is not a string. */
 export function extname(path) {
-    return npath.extname(to_fp(path));
+    return npath.extname(path.fp);
 }
 /** `/` */
 export const sep = '/';
@@ -89,25 +80,24 @@ export const delimiter = npath.delimiter;
     @param path path to evaluate.
     @throws {TypeError} if `path` is not a string. */
 export function parse(path) {
-    return npath.parse(to_fp(path));
+    return npath.parse(path.fp);
 }
 /** Returns a path string from an object - the opposite of parse().
     @param pathObject path to evaluate. */
 export function format(pathObject) {
-    return to_fp(npath.format(pathObject));
+    return npath.format(pathObject).fp;
 }
 /** On Windows systems only, returns an equivalent namespace-prefixed path for the given path.
     If path is not a string, path will be returned without modifications.
     This method is meaningful only on Windows system.
     On POSIX systems, the method is non-operational and always returns path without modifications. */
 export function toNamespacedPath(path) {
-    return to_fp(toNamespacedPath(to_fp(path)));
+    return npath.toNamespacedPath(path.fp).fp;
 }
 export const posix = npath.posix;
 export const win32 = npath.win32;
 /** 统一使用 / 作为分隔符的 path 模块 */
 export let path = {
-    to_fp,
     normalize,
     join,
     resolve,

package/process.d.ts

@@ -2,6 +2,7 @@ import { type ChildProcess } from 'child_process';
 import './prototype.ts';
 import type { Encoding } from './file.ts';
 import type { MyProxy } from './net.ts';
+import { inspect } from './utils.ts';
 export declare const sea: boolean;
 export declare const exe_nodejs: string;
 export declare const platform: NodeJS.Platform;
@@ -97,19 +98,25 @@ export interface CallResult<TOutput extends string | Buffer = string> {
     stderr: TOutput;
     code: number | null;
     signal: NodeJS.Signals | null;
+    command: string;
+    message: string;
     child: ChildProcess;
+    print: FullPrintOptions;
 }
-export interface CallError<TOutput extends string | Buffer = string> {
-    result: {
-        pid: number;
-        stdout: TOutput;
-        stderr: TOutput;
-        code: number;
-        signal: NodeJS.Signals;
-        child: ChildProcess;
-    };
+export declare class CallError<TOutput extends string | Buffer = string> extends Error {
+    name: string;
+    pid: number;
+    stdout: TOutput;
+    stderr: TOutput;
+    code: number;
+    signal: NodeJS.Signals;
+    command: string;
+    child: ChildProcess;
+    print: FullPrintOptions;
+    constructor({ message, pid, stdout, stderr, code, signal, command, child, print }: CallResult<TOutput>);
+    [inspect.custom](): string;
 }
-/** 调用可执行文件，获取返回结果
+/** 调用可执行文件，获取返回结果，错误时抛出 CallError
     - exe: .exe 路径或文件名 (建议使用路径，跳过 path 搜索，性能更高)
     - args: `[ ]` 参数列表
     - options?:
@@ -122,6 +129,9 @@ export interface CallError<TOutput extends string | Buffer = string> {
         - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理
         - input?: string, 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin
         - on_child?: 可以传入回调函数及时获取通过 start 创建的子进程，便于执行 kill、获得 pid 等操作 */
+export declare function call(exe: string, args: string[], options: CallOptions & {
+    encoding: 'binary';
+}): Promise<CallResult<Buffer>>;
 export declare function call(exe: string, args?: string[], options?: CallOptions): Promise<CallResult<string>>;
 export interface CallNodeJsOptions extends CallOptions {
     inspect?: number | true;

package/process.js

@@ -9,12 +9,6 @@ export const platform = os.platform();
 export const username = os.userInfo().username;
 export const noprint = { print: false };
 export const print_no_command = { print: { command: false, code: false, stdout: true, stderr: true } };
-function get_command(exe, args) {
-    return (short_exe_names[exe] || exe.quote_if_space()) +
-        (args.length
-            ? ' ' + args.map(arg => arg.quote_if_space()).join(' ')
-            : '');
-}
 async function prepare_spawn(detached, exe, args, { cwd, window: _window = true, envs, 
 // @ts-ignore
 input, fp_stdin, fp_stdout, fp_stderr, print = true, proxy, 
@@ -84,9 +78,15 @@ stdio }) {
             stdout: print,
             stderr: print
         };
-    let command;
+    const command = (short_exe_names[exe] || exe.quote_if_space()) +
+        (args.length
+            ? ' ' +
+                args
+                    .map(arg => arg.quote_if_space())
+                    .join(' ')
+            : '');
     if (print.command)
-        console.log((command = get_command(exe, args)).blue);
+        console.log(command.blue);
     return {
         print,
         command,
@@ -126,8 +126,35 @@ export async function start(exe, args = [], options = {}) {
             await close_all_handles();
     }
 }
+export class CallError extends Error {
+    name = 'CallError';
+    pid;
+    stdout;
+    stderr;
+    code;
+    signal;
+    command;
+    child;
+    print;
+    constructor({ message, pid, stdout, stderr, code, signal, command, child, print }) {
+        super(message);
+        this.pid = pid;
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.code = code;
+        this.signal = signal;
+        this.command = command;
+        this.child = child;
+        this.print = print;
+    }
+    [inspect.custom]() {
+        return (!this.print.stdout && this.stdout ? `标准输出:\n${this.stdout}\n` : '') +
+            (!this.print.stderr && this.stderr ? `标准错误:\n${this.stderr}\n` : '') +
+            this.stack;
+    }
+}
 export async function call(exe, args = [], options = {}) {
-    const { print, command, spawn_options, close_all_handles } = await prepare_spawn(false, exe, args, options);
+    const { print, spawn_options, close_all_handles, command } = await prepare_spawn(false, exe, args, options);
     let child;
     try {
         child = spawn(exe, args, spawn_options);
@@ -191,14 +218,11 @@ export async function call(exe, args = [], options = {}) {
             resolve();
         });
     });
-    let message;
-    const code_error = throw_code && (code || signal);
-    if (print.code || code_error) {
-        message = `进程 ${command || get_command(exe, args)} ` + (code
-            ? `${throw_code ? '异常' : ''}结束，退出码: ${code}${signal ? `，信号: ${signal}` : ''}`
-            : '正常结束');
-        console.log(message[code_error ? 'red' : 'blue']);
-    }
+    const message = `进程 ${command} ` + (code
+        ? `${throw_code ? '异常' : ''}结束，退出码: ${code}${signal ? `，信号: ${signal}` : ''}`
+        : '正常结束');
+    if (print.code && !code)
+        console.log(message.blue);
     const result = {
         pid: child.pid,
         stdout: encoding === 'binary'
@@ -209,16 +233,28 @@ export async function call(exe, args = [], options = {}) {
             : stderrs.join(''),
         code,
         signal,
+        command,
+        message,
         child,
+        print,
         [inspect.custom]() {
-            return inspect(this, { omit: ['child'] });
+            return inspect(this, {
+                omit: [
+                    'child',
+                    'message',
+                    'command',
+                    'code',
+                    'signal',
+                    'pid',
+                    'print',
+                    ...print.stdout ? ['stdout'] : [],
+                    ...print.stderr ? ['stderr'] : [],
+                ]
+            });
         }
     };
-    if (code_error) {
-        let error = new Error(message);
-        error.result = result;
-        throw error;
-    }
+    if (throw_code && (code || signal))
+        throw new CallError(result);
     return result;
 }
 /** 调用 node <js> 并等待结果

package/prototype.browser.d.ts

@@ -57,12 +57,11 @@ declare global {
             
             - preservations?: `''` 保留的正则表达式字符
             - flags?: `''` 正则匹配选项
-            - pattern_placeholder?: `/\{.*?\}/g`
-        */
+            - pattern_placeholder?: `/\{.*?\}/g` */
         find(this: string, pattern: string, preservations?: string, flags?: string, pattern_placeholder?: RegExp): Record<string, string>;
         /** 查找子串或字符出现的次数 */
         count(this: string, search: string): number;
-        /** - type?: `'single'` */
+        /** - type?: `'single'` 引号类型 */
         quote(this: string, type?: keyof typeof quotes | 'psh'): string;
         /** - shape?: `'parenthesis'` */
         bracket(this: string, shape?: keyof typeof brackets): string;
@@ -105,17 +104,25 @@ declare global {
         slice_to(this: string, search: string, options?: SliceOptions): string;
         /** 等价于 .endsWith('/') */
         isdir: boolean;
-        /** 以 `/` 分割的路径，可能以 / 结尾 */
+        /** 转换为以 `/` 分割的路径，可能以 / 结尾 */
         fp: string;
-        /** 以 `/` 分割的文件夹路径，一定以 / 结尾 */
+        /** 转换为以 `/` 分割的文件夹路径，一定以 / 结尾 */
         fpd: string;
-        /** 父文件夹路径 (path.dirname)，一定以 `/` 结尾 */
+        /** 父文件夹路径，一定以 `/` 结尾，或为空
+            特殊情况:
+            - '/'.fdir === ''
+            - 'D:/'.fdir === '' */
         fdir: string;
-        /** 文件名 (path.basename 的结果), 保留结尾的 /，如:
+        /** 文件或文件夹名, 保留结尾的 /
+            常规情况:
             - D:/0/aaa.txt -> aaa.txt
-            - D:/aaa/ -> aaa/ */
+            - D:/aaa/ -> aaa/
+            特殊情况:
+            - '/'.fname === '/'
+            - 'D:/'.fname === 'D:/' */
         fname: string;
-        /** .txt */
+        /** 文件后缀名，不带点，如: txt, zip，没有后缀时返回空字符串
+            特殊情况: .aaa 的 fext 为 '' */
         fext: string;
     }
     interface Date {
@@ -148,15 +155,15 @@ declare global {
         /** 等价于 .at(-1) */
         last: T;
         indent(this: string[], width?: number, c?: string): string[];
-        /** 对数组中所有元素求和 (+), 返回结果，可传入 selector 选择某个属性，或者计算出某个值，用作求和 */
-        sum<TReturn = T>(this: T[], selector?: keyof T | KeySelector<T>): TReturn;
-        /** 查找数组中最大的元素，可传入 selector 选择某个属性，或者计算出某个值，用作大小比较 */
-        max(this: T[], selector?: keyof T | KeySelector<T>): T;
-        /** 查找数组中最小的元素，可传入 selector 选择某个属性，或者计算出某个值，用作大小比较 */
-        min(this: T[], selector?: keyof T | KeySelector<T>): T;
-        /** 去除重复元素（可按 selector 去重），重复值保留最后出现的那个
-            - selector?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
-        unique(this: T[], selector?: keyof T | KeySelector<T>): T[];
+        /** 对数组中所有元素求和 (+), 返回结果，可传入 mapper 计算出某个值，用作求和 */
+        sum<TReturn = T>(this: T[], mapper?: keyof T | Mapper<T>): TReturn;
+        /** 查找数组中最大的元素，可传入 mapper 计算出某个值，用作大小比较 */
+        max(this: T[], mapper?: keyof T | Mapper<T>): T;
+        /** 查找数组中最小的元素，可传入 mapper 计算出某个值，用作大小比较 */
+        min(this: T[], mapper?: keyof T | Mapper<T>): T;
+        /** 去除重复元素（可按 mapper 选择或计算某个值来去重），重复值保留最后出现的那个
+            - mapper?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
+        unique(this: T[], mapper?: keyof T | Mapper<T>): T[];
         /**
             - trim_line?: `true`
             - rm_empty_lines?: `true`
@@ -179,7 +186,7 @@ declare global {
         toJSON(this: Error): string;
     }
     interface Set<T> {
-        map<TResult>(mapfn: (value: T, index: number) => TResult): TResult[];
+        map<TResult>(mapper: (value: T, index: number) => TResult): TResult[];
     }
 }
 interface SliceOptions {
@@ -189,8 +196,8 @@ interface SliceOptions {
 export declare const emoji_regex: RegExp;
 export declare const noop: () => void;
 export declare const ident: <T>(x: T) => T;
-export declare const build_selector: <TObj>(key: keyof TObj) => (obj: TObj) => TObj[keyof TObj];
-export type KeySelector<TObj = any, TKey extends keyof TObj = keyof TObj> = (key: TObj) => TObj[TKey];
+export declare const build_mapper: <TObj>(key: keyof TObj) => (obj: TObj) => TObj[keyof TObj];
+export type Mapper<TObj = any, TKey extends keyof TObj = keyof TObj> = (obj: TObj) => TObj[TKey];
 /** value 不为 null 或 undefined */
 export declare const not_empty: (value: any) => boolean;
 export declare const empty: (value: any) => boolean;

package/prototype.browser.js

@@ -4,7 +4,7 @@ import { t } from "./i18n/instance.js";
 export const emoji_regex = EmojiRegex();
 export const noop = () => { };
 export const ident = (x) => x;
-export const build_selector = (key) => (obj) => obj[key];
+export const build_mapper = (key) => (obj) => obj[key];
 /** value 不为 null 或 undefined */
 export const not_empty = (value) => value !== null && value !== undefined;
 export const empty = (value) => value === undefined || value === null;
@@ -42,16 +42,6 @@ export const brackets = {
     fat: ['【', '】'],
     tortoise_shell: ['〔', '〕'],
 };
-function to_fp(str) {
-    if (!str)
-        return str;
-    const fp = str.replaceAll('\\', '/');
-    // 转换小写盘符开头的路径
-    return fp[1] === ':' && 'a' <= fp[0] && fp[0] <= 'z' ?
-        fp[0].toUpperCase() + fp.slice(1)
-        :
-            fp;
-}
 // ------------------------------------ String.prototype
 Object.defineProperties(String.prototype, {
     ...to_getter_property_descriptors({
@@ -223,6 +213,7 @@ Object.defineProperties(String.prototype, {
             return Object.fromEntries(Object.entries($placeholders)
                 .map(([name, $i]) => [name, matches[$i] || '']));
         },
+        /** 查找子串或字符出现的次数 */
         count(search) {
             if (!search)
                 throw new Error('count 的 search 不能为空');
@@ -320,9 +311,9 @@ Object.defineProperties(String.prototype, {
                 .replace(/(["']+)\s*(.+?)\s*(["']+)/g, '$1$2$3')
                 .replace(new RegExp(cjk + '([\\+\\-\\*\\/=&\\\\\\|<>])([A-Za-z0-9])', 'g'), '$1 $2 $3')
                 .replace(new RegExp('([A-Za-z0-9])([\\+\\-\\*\\/=&\\\\\\|<>])' + cjk, 'g'), '$1 $2 $3');
-            const textBak = text_;
+            const text_bak = text_;
             text_ = text_.replace(new RegExp(cjk + '([\\(\\[\\{<\u201c]+(.*?)[\\)\\]\\}>\u201d]+)' + cjk, 'g'), '$1 $2 $4');
-            if (text_ === textBak)
+            if (text_ === text_bak)
                 text_ = text_
                     .replace(new RegExp(cjk + '([\\(\\[\\{<\u201c>])', 'g'), '$1 $2')
                     .replace(new RegExp('([\\)\\]\\}>\u201d<])' + cjk, 'g'), '$1 $2');
@@ -331,7 +322,7 @@ Object.defineProperties(String.prototype, {
                 .replace(new RegExp(cjk + '([~!;:,\\.\\?\u2026])([A-Za-z0-9])', 'g'), '$1$2 $3')
                 .replace(new RegExp(cjk + '([A-Za-z0-9`\\$%\\^&\\*\\-=\\+\\\\\\|\\/@\u00a1-\u00ff\u2022\u2027\u2150-\u218f])', 'g'), '$1 $2')
                 .replace(new RegExp('([A-Za-z0-9`\\$%\\^&\\*\\-=\\+\\\\\\|\\/@\u00a1-\u00ff\u2022\u2027\u2150-\u218f])' + cjk, 'g'), '$1 $2');
-        },
+        }
     }),
     // ------------ 文件路径操作
     ...to_getter_property_descriptors({
@@ -339,30 +330,43 @@ Object.defineProperties(String.prototype, {
             return this.endsWith('/');
         },
         fp() {
-            return to_fp(this);
-        },
-        fpd() {
             if (!this)
                 return this;
-            const fp = to_fp(this);
+            const fp = this.replaceAll('\\', '/');
+            // 转换小写盘符开头的路径
+            return fp[1] === ':' && 'a' <= fp[0] && fp[0] <= 'z'
+                ? fp[0].toUpperCase() + fp.slice(1)
+                : fp;
+        },
+        fpd() {
+            const { fp } = this;
             return fp.endsWith('/') ? fp : `${fp}/`;
         },
         fdir() {
-            const fname = (this.endsWith('/') ? this.slice(0, -1) : this).split('/').at(-1);
-            return this.slice(0, this.length - (fname.length + (this.endsWith('/') ? 1 : 0)));
+            return this.strip_end(this.fname);
         },
         fname() {
-            const fname = (this.endsWith('/') ? this.slice(0, -1) : this).split('/').at(-1);
-            if (fname)
-                return `${fname}${this.endsWith('/') ? '/' : ''}`;
-            else
-                return '';
+            const ilast = this.lastIndexOf('/');
+            if (ilast === -1)
+                return this; // 没有斜杠时返回整个字符串
+            // 以斜杠结尾的情况
+            if (ilast === this.length - 1) {
+                const iprev = this.lastIndexOf('/', ilast - 1);
+                return iprev === -1
+                    ? this // 只有一个斜杠且在末尾
+                    : this.slice(iprev + 1);
+            }
+            // 返回最后一个斜杠后的内容
+            return this.slice(ilast + 1);
         },
         fext() {
-            const index = this.lastIndexOf('.');
-            return index === -1 ? '' : this.slice(index);
-        },
-    }),
+            const { fname } = this;
+            const index = fname.lastIndexOf('.');
+            return index <= 0
+                ? ''
+                : fname.slice(index + 1);
+        }
+    })
 });
 // ------------------------------------ Date.prototype
 Object.defineProperties(Date.prototype, to_method_property_descriptors({
@@ -418,10 +422,9 @@ function get_time_str(date, hour, ms, splitter) {
     return String(hour).padStart(2, '0') + splitter +
         String(date.getMinutes()).padStart(2, '0') + splitter +
         String(date.getSeconds()).padStart(2, '0') +
-        (ms ?
-            '.' + String(date.getMilliseconds()).padStart(3, '0')
-            :
-                '');
+        (ms
+            ? '.' + String(date.getMilliseconds()).padStart(3, '0')
+            : '');
 }
 // ------------------------------------ Number.prototype
 Object.defineProperties(Number.prototype, to_method_property_descriptors({
@@ -473,27 +476,27 @@ Object.defineProperties(Array.prototype, {
             const indent = character.repeat(width);
             return this.map(line => indent + line);
         },
-        sum(selector) {
+        sum(mapper) {
             if (!this.length)
                 return undefined;
             // 快捷路径
             const first = this[0];
-            if ((typeof first === 'number' || typeof first === 'bigint') && !selector)
+            if ((typeof first === 'number' || typeof first === 'bigint') && !mapper)
                 return this.reduce((acc, x) => acc + x, first);
-            if (is_key_type(selector))
-                selector = build_selector(selector);
-            selector ??= ident;
-            return this.reduce((acc, x) => acc + selector(x), selector(first));
+            if (is_key_type(mapper))
+                mapper = build_mapper(mapper);
+            mapper ??= ident;
+            return this.reduce((acc, x) => acc + mapper(x), mapper(first));
         },
-        max(selector = ident) {
+        max(mapper = ident) {
             if (!this.length)
                 return undefined;
-            if (typeof selector === 'string')
-                selector = build_selector(selector);
-            let max = selector(this[0]);
+            if (is_key_type(mapper))
+                mapper = build_mapper(mapper);
+            let max = mapper(this[0]);
             let imax = 0;
             for (let i = 0; i < this.length; i++) {
-                const value = selector(this[i]);
+                const value = mapper(this[i]);
                 if (value > max) {
                     max = value;
                     imax = i;
@@ -501,15 +504,15 @@ Object.defineProperties(Array.prototype, {
             }
             return this[imax];
         },
-        min(selector = ident) {
+        min(mapper = ident) {
             if (!this.length)
                 return undefined;
-            if (typeof selector === 'string')
-                selector = build_selector(selector);
-            let min = selector(this[0]);
+            if (is_key_type(mapper))
+                mapper = build_mapper(mapper);
+            let min = mapper(this[0]);
             let imin = 0;
             for (let i = 0; i < this.length; i++) {
-                const value = selector(this[i]);
+                const value = mapper(this[i]);
                 if (value < min) {
                     min = value;
                     imin = i;
@@ -517,14 +520,14 @@ Object.defineProperties(Array.prototype, {
             }
             return this[imin];
         },
-        unique(selector) {
-            if (!selector)
+        unique(mapper) {
+            if (!mapper)
                 return [...new Set(this)];
-            if (is_key_type(selector))
-                selector = build_selector(selector);
+            if (is_key_type(mapper))
+                mapper = build_mapper(mapper);
             let map = new Map();
             for (const x of this)
-                map.set(selector(x), x);
+                map.set(mapper(x), x);
             return [...map.values()];
         },
         join_lines(append = true) {