xshell 1.0.38 → 1.0.40

package/file.d.ts

@@ -79,12 +79,12 @@ export interface FListOptions {
     - fpd: 文件夹完整路径 absolute path of directory
     - options?:
         - deep?: `false` 递归遍历 recursively
-        - absolute?: `false` 返回、打印完整路径而不是相对路径 Return, print full path instead of relative path
+        - absolute?: `false` 返回、打印完整路径而不是相对路径，为 false 时返回的 FStats.fp 也会被修改 Return, print full path instead of relative path, FStats.fp returned when false will also be modified
         - print?: `true`
         - filter?: `true`  RegExp | (fp: string) => any 注意当 deep = true 时被 filter 过滤掉的目录及目录中的文件不会包含在结果中
                     Note that when deep = true, directories and files in directories that are filtered out by the filter will not be included in the results
-        - stats?: `false` 启用后返回 FStats 列表, 不能和 deep 一起使用
-                   Returns the FStats list when enabled, cannot be used with deep */
+        - stats?: `false` 启用后返回 FStats 列表
+                   Returns the FStats list when enabled */
 export declare function flist(fpd: string): Promise<string[]>;
 export declare function flist(fpd: string, options?: FListOptions & {
     stats: true;
@@ -109,7 +109,7 @@ export declare function fdelete(fp: string, { print }?: {
         - overwrite?: `true`
     
     @example
-    fcopy('d:/temp/camera/', 'd:/camera/') */
+    fcopy('D:/temp/camera/', 'D:/camera/') */
 export declare function fcopy(fp_src: string, fp_dst: string, { print, overwrite, }?: {
     print?: boolean;
     overwrite?: boolean;
@@ -118,7 +118,7 @@ export declare function fcopy(fp_src: string, fp_dst: string, { print, overwrite
     - src: 源 文件/文件夹 完整路径  src file/directory absolute path
     - dst: 目标 文件/文件夹 完整路径  dst file/directory absolute path
     @example
-    fmove('d:/temp/camera/', 'd:/camera/') */
+    fmove('D:/temp/camera/', 'D:/camera/') */
 export declare function fmove(src: string, dst: string, { overwrite, print }?: {
     overwrite?: boolean;
     print?: boolean;

package/file.js

@@ -1,7 +1,7 @@
-import { promises as fsp, default as fs, } from 'fs';
+import { promises as fsp, default as fs } from 'fs';
 import { isUint8Array } from 'util/types';
-import path from 'upath';
 import fse from 'fs-extra';
+import { path } from './path.js';
 import { t } from './i18n/instance.js';
 import { to_json } from './prototype.js';
 import { assert } from './utils.js';
@@ -30,10 +30,10 @@ export async function fopen(fp, flags, { mode, print } = {}) {
 }
 export async function fread(fp, { dir, encoding = 'utf-8', print = true } = {}) {
     if (dir) {
-        assert(dir.endsWith('/'), t('dir 必须以 / 结尾'));
+        assert(dir.isdir, t('dir 必须以 / 结尾'));
         fp = dir + fp;
     }
-    assert(!fp.endsWith('/'), t('fp 必须是文件，不能以 / 结尾'));
+    assert(!fp.isdir, t('fp 必须是文件，不能以 / 结尾'));
     assert(path.isAbsolute(fp), `${t('fp 必须是绝对路径:')} ${fp}`);
     assert(encoding !== 'auto');
     if (print)
@@ -69,7 +69,7 @@ export async function fwrite(fp, data, { dir, print = true, mkdir = false, } = {
     }
     else {
         if (dir) {
-            assert(dir.endsWith('/'), t('dir 必须以 / 结尾'));
+            assert(dir.isdir, t('dir 必须以 / 结尾'));
             fp = dir + fp;
         }
         assert(path.isAbsolute(fp), `${t('fp 必须是绝对路径，当前为:')} ${fp}`);
@@ -90,7 +90,7 @@ export async function fwrite(fp, data, { dir, print = true, mkdir = false, } = {
 }
 export async function fappend(fp, data, { dir, print = true } = {}) {
     if (dir) {
-        assert(dir.endsWith('/'), t('dir 必须以 / 结尾'));
+        assert(dir.isdir, t('dir 必须以 / 结尾'));
         fp = dir + fp;
     }
     assert(path.isAbsolute(fp), `${t('fp 必须是绝对路径，当前为:')} ${fp}`);
@@ -101,9 +101,11 @@ export async function fappend(fp, data, { dir, print = true } = {}) {
 }
 export async function flist(fpd, options = {}) {
     const { filter, deep = false, absolute = false, print = true, stats = false } = options;
+    assert(path.isAbsolute(fpd), t("flist: 参数 fpd: '{{fpd}}' 必须是绝对路径", { fpd }));
+    assert(fpd.isdir, t("flist: 参数 fpd: '{{fpd}}' 必须以 / 结尾", { fpd }));
     if (!path.isAbsolute(fpd))
         throw new Error(t('参数 fpd: ') + fpd + t(' 必须是绝对路径'));
-    if (!fpd.endsWith('/'))
+    if (!fpd.isdir)
         throw new Error(t('参数 fpd: ') + fpd + t(' 必须以 / 结尾'));
     // readdir withFileTypes 参数在底层有什么区别，速度上有什么差异
     // 都调用了 uv_fs_scandir, 且调用参数相同，仅仅是 Node.js 侧的回调不同 AfterScanDir / AfterScanDirWithTypes
@@ -125,22 +127,39 @@ export async function flist(fpd, options = {}) {
             console.log(fp);
         fps.push(fp);
     }
+    async function _fstat(fp) {
+        let _stats = await fstat(absolute ? fp : fpd + fp);
+        if (!absolute)
+            _stats.fp = fp;
+        return _stats;
+    }
     if (deep)
-        return (await Promise.all(fps.map(async (fp) => fp.endsWith('/') ?
-            [
-                fp,
-                ...(await flist(absolute ? fp : fpd + fp, options)).map(fp_ => absolute ? fp_ : fp + fp_)
-            ]
-            :
-                fp))).flat();
+        return (await Promise.all(fps.map(async (fp) => {
+            let fpd_stats;
+            return fp.isdir ?
+                [
+                    stats ? (fpd_stats = await _fstat(fp)) : fp,
+                    ...(await flist(absolute ? fp : fpd + fp, options)).map((fp_or_stats) => {
+                        if (stats) {
+                            if (!absolute)
+                                fp_or_stats.fp = fp + fp_or_stats.fp;
+                            fpd_stats.size += fp_or_stats.size;
+                            return fp_or_stats;
+                        }
+                        else
+                            return absolute ? fp_or_stats : fp + fp_or_stats;
+                    })
+                ]
+                :
+                    stats ? _fstat(fp) : fp;
+        }))).flat();
     else if (stats)
-        return Promise.all(fps.map(async (fp) => fstat(absolute ? fp : fpd + fp)));
+        return Promise.all(fps.map(_fstat));
     else
         return fps;
 }
 export async function fstat(fp) {
-    if (!path.isAbsolute(fp))
-        throw new Error('fp: ' + fp + t(' 必须是绝对路径'));
+    assert(path.isAbsolute(fp), t("fstat: 参数 fp: '{{fp}}' 必须是绝对路径", { fp }));
     let stat = await fsp.stat(fp, { bigint: true });
     stat.fp = fp;
     return stat;
@@ -158,7 +177,7 @@ export async function fdelete(fp, { print = true } = {}) {
     try {
         await fsp.rm(fp, { recursive: true });
         if (print)
-            if (fp.endsWith('/'))
+            if (fp.isdir)
                 console.log((t('删除了文件夹: ') + fp).red);
             else
                 console.log((t('删除了文件: ') + fp).red);
@@ -167,7 +186,7 @@ export async function fdelete(fp, { print = true } = {}) {
     catch (error) {
         if (error.code === 'ENOENT') {
             if (print)
-                if (fp.endsWith('/'))
+                if (fp.isdir)
                     console.log(t('文件夹已不存在: ') + fp);
                 else
                     console.log(t('文件已不存在: ') + fp);
@@ -184,9 +203,9 @@ export async function fdelete(fp, { print = true } = {}) {
         - overwrite?: `true`
     
     @example
-    fcopy('d:/temp/camera/', 'd:/camera/') */
+    fcopy('D:/temp/camera/', 'D:/camera/') */
 export async function fcopy(fp_src, fp_dst, { print = true, overwrite = true, } = {}) {
-    assert(fp_src.endsWith('/') === fp_dst.endsWith('/'), t('fp_src 和 fp_dst 必须同为文件路径或文件夹路径'));
+    assert(fp_src.isdir === fp_dst.isdir, t('fp_src 和 fp_dst 必须同为文件路径或文件夹路径'));
     assert(path.isAbsolute(fp_src) && path.isAbsolute(fp_dst), t('fp_src 和 fp_dst 必须为完整路径'));
     if (print)
         console.log(t('复制'), fp_src, '→', fp_dst);
@@ -196,9 +215,9 @@ export async function fcopy(fp_src, fp_dst, { print = true, overwrite = true, }
     - src: 源 文件/文件夹 完整路径  src file/directory absolute path
     - dst: 目标 文件/文件夹 完整路径  dst file/directory absolute path
     @example
-    fmove('d:/temp/camera/', 'd:/camera/') */
+    fmove('D:/temp/camera/', 'D:/camera/') */
 export async function fmove(src, dst, { overwrite = false, print = true } = {}) {
-    if (src.endsWith('/') !== dst.endsWith('/'))
+    if (src.isdir !== dst.isdir)
         throw new Error(t('src 和 dst 必须同为文件路径或文件夹路径'));
     if (!path.isAbsolute(src) || !path.isAbsolute(dst))
         throw new Error(t('src 和 dst 必须为完整路径'));
@@ -236,7 +255,7 @@ export async function frename(fp, fp_, { fpd, print = true, overwrite = true } =
         - mode?: `'0o777'` */
 export async function fmkdir(fpd, { print = true, mode, } = {}) {
     assert(path.isAbsolute(fpd), t('fpd 必须是绝对路径: ') + fpd);
-    assert(fpd.endsWith('/'), t('fpd 必须以 / 结尾: ') + fpd);
+    assert(fpd.isdir, t('fpd 必须以 / 结尾: ') + fpd);
     // CallingfsPromises.mkdir() when path is a directory that exists results in a rejection only when recursive is false.
     const fpd_ = (await fsp.mkdir(fpd, { recursive: true, mode }))?.replaceAll('\\', '/');
     if (fpd_) {
@@ -252,8 +271,8 @@ export async function fmkdir(fpd, { print = true, mode, } = {}) {
     - fp_link: 目标链接文件/文件夹的路径  target file/directory path */
 export async function flink(fp_real, fp_link, { junction = false, print = true } = {}) {
     assert(path.isAbsolute(fp_real) && path.isAbsolute(fp_link), t('fp 必须是绝对路径'));
-    const is_fpd_real = fp_real.endsWith('/');
-    const is_fpd_link = fp_link.endsWith('/');
+    const is_fpd_real = fp_real.isdir;
+    const is_fpd_link = fp_link.isdir;
     assert(is_fpd_real === is_fpd_link, t('fp_real 和 fp_link 必须同为文件路径或文件夹路径'));
     if (fexists(fp_link))
         throw new Error(t('存在同名') + (is_fpd_link ? t('文件夹') : t('文件')) + ': ' + fp_link + t('，无法创建链接'));

package/i18n/i18n-scan.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import path from 'upath';
 import { program } from 'commander';
+import { path } from '../path.js';
 import { scanner } from './scanner/index.js';
 import { try_load_dict } from './utils.js';
 (async function main() {

package/i18n/scanner/index.js

@@ -1,5 +1,4 @@
 import i18n_scanner from 'i18next-scanner';
-import path from 'upath';
 import vfs from 'vinyl-fs';
 import sort from 'gulp-sort';
 import ora from 'ora';
@@ -8,6 +7,7 @@ import Vinyl from 'vinyl';
 import through2 from 'through2';
 import CliTable from 'cli-table3';
 import '../../prototype.js';
+import { path } from '../../path.js';
 import { map_stream } from '../../utils.js';
 import { LANGUAGES, } from '../index.js';
 import { RWDict } from '../rwdict.js';

package/index.d.ts

@@ -1,3 +1,4 @@
+export * from './path.js';
 export * from './prototype.js';
 export * from './utils.js';
 export * from './file.js';

package/index.js

@@ -1,3 +1,4 @@
+export * from './path.js';
 export * from './prototype.js';
 export * from './utils.js';
 export * from './file.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xshell",
-  "version": "1.0.38",
+  "version": "1.0.40",
   "type": "module",
   "main": "./index.js",
   "bin": {
@@ -16,7 +16,7 @@
     "interactive programming"
   ],
   "engines": {
-    "node": ">=20.3.0",
+    "node": ">=20.5.0",
     "vscode": ">=1.79.0"
   },
   "author": "ShenHongFei <shen.hongfei@outlook.com> (https://github.com/ShenHongFei)",
@@ -45,7 +45,7 @@
     ]
   },
   "dependencies": {
-    "@babel/core": "^7.22.8",
+    "@babel/core": "^7.22.9",
     "@babel/parser": "^7.22.7",
     "@babel/traverse": "^7.22.8",
     "@koa/cors": "^4.0.0",
@@ -62,7 +62,7 @@
     "fs-extra": "^11.1.1",
     "gulp-sort": "^2.0.0",
     "hash-string": "^1.0.0",
-    "i18next": "^23.2.10",
+    "i18next": "^23.2.11",
     "i18next-scanner": "^4.3.0",
     "js-cookie": "^3.0.5",
     "koa": "^2.14.2",
@@ -70,6 +70,7 @@
     "koa-useragent": "^4.1.0",
     "lodash": "^4.17.21",
     "map-stream": "0.0.7",
+    "mime-types": "^2.1.35",
     "ora": "^6.3.1",
     "qs": "^6.11.2",
     "react": "^18.2.0",
@@ -81,7 +82,6 @@
     "tslib": "^2.6.0",
     "typescript": "^5.1.6",
     "undici": "^5.22.1",
-    "upath": "^2.0.1",
     "vinyl": "^3.0.0",
     "vinyl-fs": "^4.0.0",
     "ws": "^8.13.0"
@@ -97,20 +97,19 @@
     "@types/koa": "^2.13.6",
     "@types/koa-compress": "^4.0.3",
     "@types/lodash": "^4.14.195",
-    "@types/node": "^20.4.1",
+    "@types/mime-types": "^2.1.1",
+    "@types/node": "^20.4.4",
     "@types/qs": "^6.9.7",
-    "@types/react": "^18.2.14",
+    "@types/react": "^18.2.15",
     "@types/through2": "^2.0.38",
     "@types/tough-cookie": "^4.0.2",
     "@types/vinyl-fs": "^3.0.2",
     "@types/vscode": "^1.80.0",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "eslint": "^8.44.0",
-    "eslint-plugin-react": "^7.32.2",
-    "eslint-plugin-xlint": "^1.0.6",
-    "source-map-loader": "^4.0.1",
-    "ts-loader": "^9.4.4"
+    "@typescript-eslint/eslint-plugin": "^6.1.0",
+    "@typescript-eslint/parser": "^6.1.0",
+    "eslint": "^8.45.0",
+    "eslint-plugin-react": "^7.33.0",
+    "eslint-plugin-xlint": "^1.0.6"
   },
   "scripts": {
     "start": "node --title=xshell --inspect=0.0.0.0:8420 ./xshell.js",

package/path.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" resolution-mode="require"/>
+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.
+    @throws {TypeError} if `path` is not a string. */
+export declare function normalize(path: string): string;
+/** 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 declare function join(...paths: string[]): string;
+/** The right-most parameter is considered {to}. Other parameters are considered an array of {from}.
+    
+    Starting from leftmost {from} parameter, resolves {to} to an absolute path.
+    
+    If {to} isn't already absolute, {from} arguments are prepended in right to left order,
+    until an absolute path is found. If after using all {from} paths still no absolute path is found,
+    the current working directory is used as well. The resulting path is normalized,
+    and trailing slashes are removed unless the path gets resolved to the root directory.
+    
+    @param paths A sequence of paths or path segments.
+    @throws {TypeError} if any of the arguments is not a string. */
+export declare function resolve(...paths: string[]): string;
+/** Determines whether {path} is an absolute path.
+    An absolute path will always resolve to the same location, regardless of the working directory.
+    
+    If the given {path} is a zero-length string, `false` will be returned.
+    
+    @param path path to test.
+    @throws {TypeError} if `path` is not a string. */
+export declare function isAbsolute(path: string): boolean;
+/** 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 declare function relative(from: string, to: string): string;
+/** 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 declare function dirname(path: string): string;
+/** 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.
+    @param path the path to evaluate.
+    @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 declare function basename(path: string, suffix?: string): string;
+/** 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.
+    
+    @param path the path to evaluate.
+    @throws {TypeError} if `path` is not a string. */
+export declare function extname(path: string): string;
+/** `/` */
+export declare const sep = "/";
+/** The platform-specific file delimiter. ';' or ':'. */
+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. */
+export declare function parse(path: string): npath.ParsedPath;
+/** Returns a path string from an object - the opposite of parse().
+    @param pathObject path to evaluate. */
+export declare function format(pathObject: FormatInputPathObject): string;
+/** 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 declare function toNamespacedPath(path: string): any;
+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;
+    isAbsolute: typeof isAbsolute;
+    relative: typeof relative;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    sep: string;
+    delimiter: ":" | ";";
+    parse: typeof parse;
+    format: typeof format;
+    toNamespacedPath: typeof toNamespacedPath;
+};

package/path.js

@@ -0,0 +1,119 @@
+import { default as npath } from 'path';
+export function to_fp(str) {
+    if (!str)
+        return str;
+    const fp = str.replaceAll('\\', '/');
+    // 转换小写盘符开头的路径
+    if (fp[1] === ':' && 'a' <= fp[0] && fp[0] <= 'z')
+        return fp[0].toUpperCase() + fp.slice(1);
+    else
+        return 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)));
+}
+/** 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))));
+}
+/** The right-most parameter is considered {to}. Other parameters are considered an array of {from}.
+    
+    Starting from leftmost {from} parameter, resolves {to} to an absolute path.
+    
+    If {to} isn't already absolute, {from} arguments are prepended in right to left order,
+    until an absolute path is found. If after using all {from} paths still no absolute path is found,
+    the current working directory is used as well. The resulting path is normalized,
+    and trailing slashes are removed unless the path gets resolved to the root directory.
+    
+    @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))));
+}
+/** Determines whether {path} is an absolute path.
+    An absolute path will always resolve to the same location, regardless of the working directory.
+    
+    If the given {path} is a zero-length string, `false` will be returned.
+    
+    @param path path to test.
+    @throws {TypeError} if `path` is not a string. */
+export function isAbsolute(path) {
+    return npath.isAbsolute(to_fp(path));
+}
+/** 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 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 the last portion of a path. Similar to the Unix basename command.
+    Often used to extract the file name from a fully qualified path.
+    @param path the path to evaluate.
+    @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 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.
+    
+    @param path the path to evaluate.
+    @throws {TypeError} if `path` is not a string. */
+export function extname(path) {
+    return npath.extname(to_fp(path));
+}
+/** `/` */
+export const sep = '/';
+/** The platform-specific file delimiter. ';' or ':'. */
+export const delimiter = npath.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. */
+export function parse(path) {
+    return npath.parse(to_fp(path));
+}
+/** 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));
+}
+/** 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)));
+}
+export const posix = npath.posix;
+export const win32 = npath.win32;
+/** 统一使用 / 作为分隔符的 path 模块 */
+export let path = {
+    to_fp,
+    normalize,
+    join,
+    resolve,
+    isAbsolute,
+    relative,
+    dirname,
+    basename,
+    extname,
+    sep,
+    delimiter,
+    parse,
+    format,
+    toNamespacedPath
+};
+//# sourceMappingURL=path.js.map

package/process.d.ts

@@ -26,15 +26,14 @@ interface StartOptions {
     detached?: boolean;
     /** 为 true 时会设置 UV_PROCESS_WINDOWS_HIDE
         然后设置启动进程的参数 CREATE_NO_WINDOW, 和 SW_HIDE
-        d:/0/libuv/src/win/process.c
+        D:/0/libuv/src/win/process.c
         CREATE_NO_WINDOW:
         The process is a console application that is being run without a console window.
         Therefore, the console handle for the application is not set.
         This flag is ignored if the application is not a console application, or
         if it is used with either CREATE_NEW_CONSOLE or DETACHED_PROCESS.
         
-        具体有什么用还不清楚
-    */
+        具体有什么用还不清楚 */
     window?: boolean;
 }
 /** start process
@@ -66,7 +65,7 @@ export interface CallResult<TOutput extends string | Buffer = string> {
     - exe: .exe 路径或文件名 (建议使用路径，跳过 path 搜索，性能更高)  path or filename (full path is recommanded to skip path searching for better perf)
     - args: `[]` 参数列表  arguments list
     - options?:
-        - cwd?: `'d:/'`
+        - cwd?: `process.cwd()`
         - env?: `process.env` 覆盖／添加到 process.env 的环境变量  overwrite/add to process.env
         - encoding?: `'utf-8'` 子进程输出编码, 设置为 binary 时返回 stdout, stderr 类型为 Buffer; 否则是 string
             child output encoding. When set to binary, return stdout, stderr is of type Buffer; otherwise it is string
@@ -84,7 +83,7 @@ export declare function call(exe: string, args?: string[], options?: CallOptions
     - js: .js 路径 (相对路径根据 cwd 解析)  path (relative path will resolve based on cwd)
     - args: `[]` 参数列表  arguments list
     - options
-        - cwd?: `'d:/'`
+        - cwd?: `process.cwd()`
         - env?: `process.env` 覆盖／添加到 process.env 的环境变量  overwrite/add to process.env
         - encoding?: `'utf-8'` 子进程输出编码  child process output encoding
         - print?: `true` print 选项，支持设置细项  print option (with details)
@@ -93,7 +92,7 @@ export declare function call(exe: string, args?: string[], options?: CallOptions
         - throw_code?: `true` code 不为 0 时是否抛出异常  whether to throw Error when code is not 0 */
 export declare function call_nodejs(js: string, args?: string[], options?: CallOptions): Promise<CallResult<string>>;
 export interface TermOptions {
-    /** `d:/t/` */
+    /** `process.cwd()` */
     cwd?: string;
     /** `true` 打印参数 */
     print?: boolean;

package/process.js

@@ -3,7 +3,7 @@ import { userInfo } from 'os';
 import { t } from './i18n/instance.js';
 import './prototype.js';
 import { inspect, DecoderStream } from './utils.js';
-export const exe_nodejs = process.execPath.to_slash();
+export const exe_nodejs = process.execPath.fp;
 /** start process
     - exe: .exe 路径或文件名 (建议使用完整路径，跳过 path 搜索，性能更高)  path or filename (full path is recommanded to skip path searching for better perf)
     - args: `[]` 参数列表  arguments list
@@ -165,7 +165,7 @@ export async function call(exe, args = [], options = {}) {
     - js: .js 路径 (相对路径根据 cwd 解析)  path (relative path will resolve based on cwd)
     - args: `[]` 参数列表  arguments list
     - options
-        - cwd?: `'d:/'`
+        - cwd?: `process.cwd()`
         - env?: `process.env` 覆盖／添加到 process.env 的环境变量  overwrite/add to process.env
         - encoding?: `'utf-8'` 子进程输出编码  child process output encoding
         - print?: `true` print 选项，支持设置细项  print option (with details)
@@ -181,7 +181,7 @@ export const exe_winterm = `C:/Users/${userInfo().username}/AppData/Local/Micros
     - args: 调用参数  call parameter
     - options?: WinTermOptions
 */
-export async function term(exe, args = [], { cwd = 'd:/t/', print = true, title,
+export async function term(exe, args = [], { cwd = process.cwd().fp, print = true, title,
 // env
  } = {}) {
     return start(exe_winterm, [

package/prototype.browser.d.ts

@@ -21,7 +21,6 @@ declare global {
             position?: 'left' | 'right';
         }): string;
         to_regexp(this: string, preservations?: string, flags?: string): RegExp;
-        to_bool(this: string): boolean;
         /** 字符串模式替换
             - pattern: 匹配部分的格式
             - pattern_: 替换后的格式
@@ -67,21 +66,26 @@ declare global {
         surround(this: string, left: string, right?: string): string;
         surround_tag(this: string, tag_name: string): string;
         to_lf(this: string): string;
-        to_crlf(this: string): string;
         /** 'xxx'.replace(/pattern/g, '')
-            如果 pattern 是 string 则在创建 RegExp 时自动加上 flags (默认 'g'), 否则忽略 flags
-        */
+            如果 pattern 是 string 则在创建 RegExp 时自动加上 flags (默认 'g'), 否则忽略 flags */
         rm(this: string, pattern: string | RegExp, flags?: string): string;
         /** 将 string 划分为行，并去掉最后一个 \n 之后的 '' */
         split_lines(this: string): string[];
-        trim_doc_comment(this: string): string;
         split_indent(this: string): {
             indent: number;
             text: string;
         };
         space(this: string): string;
-        to_slash(this: string): string;
-        to_backslash(this: string): string;
+        /** 等价于 .endsWith('/') */
+        isdir: boolean;
+        /** 以 `/` 分割的路径 */
+        fp: string;
+        /** 文件名 (path.basename 的结果), 保留结尾的 /，如:
+            - D:/0/aaa.txt -> aaa.txt
+            - D:/aaa/ -> aaa/ */
+        fname: string;
+        /** .txt */
+        fext: string;
     }
     interface Date {
         /** - ms?: `false` 显示到 ms */

package/prototype.browser.js

@@ -109,9 +109,6 @@ Object.defineProperties(String.prototype, {
                 .map((c) => c === ']' ? '\\]' : c).join('');
             return new RegExp(this.replace(new RegExp(`[${replace_chars}]`, 'g'), '\\$&'), flags);
         },
-        to_bool() {
-            return this.length && this !== '0' && this.toLowerCase() !== 'false';
-        },
         refmt(pattern, pattern_, preservations = '', flags = '', transformer = (name, value) => value || '', pattern_placeholder = /\{.*?\}/g) {
             // --- 转换 pattern 为 pattern_regx
             let last_end = 0;
@@ -226,9 +223,6 @@ Object.defineProperties(String.prototype, {
         to_lf() {
             return this.replace(/\r\n/g, '\n');
         },
-        to_crlf() {
-            return this.replace(/\n/g, '\r\n');
-        },
         rm(pattern, flags = 'g') {
             if (typeof pattern === 'string')
                 pattern = new RegExp(pattern, flags);
@@ -277,13 +271,38 @@ Object.defineProperties(String.prototype, {
                 .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_slash() {
-            return this.replaceAll('\\', '/');
+    }),
+    // ------------ 文件路径操作
+    ...to_getter_property_descriptors({
+        isdir() {
+            return this.endsWith('/');
+        },
+        fp() {
+            if (!this)
+                return this;
+            const fp = this.replaceAll('\\', '/');
+            // 转换小写盘符开头的路径
+            if (fp[1] === ':' && 'a' <= fp[0] && fp[0] <= 'z')
+                return fp[0].toUpperCase() + fp.slice(1);
+            else
+                return 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)));
+        },
+        fname() {
+            const fname = (this.endsWith('/') ? this.slice(0, -1) : this).split('/').at(-1);
+            if (fname)
+                return `${fname}${this.endsWith('/') ? '/' : ''}`;
+            else
+                return '';
         },
-        to_backslash() {
-            return this.replaceAll('/', '\\');
+        fext() {
+            const index = this.lastIndexOf('.');
+            return index === -1 ? '' : this.slice(index + 1);
         },
-    })
+    }),
 });
 // ------------------------------------ Date.prototype
 Object.defineProperties(Date.prototype, to_method_property_descriptors({

package/prototype.d.ts

@@ -11,8 +11,7 @@ declare global {
         truncate(this: string, width: number): string;
         /** pad string to `<width>`
             - character?: `' '`
-            - position?: `'right'`
-         */
+            - position?: `'right'` */
         pad(this: string, width: number, { character, position }?: {
             character?: string;
             position?: 'left' | 'right';
@@ -22,7 +21,6 @@ declare global {
             position?: 'left' | 'right';
         }): string;
         to_regexp(this: string, preservations?: string, flags?: string): RegExp;
-        to_bool(this: string): boolean;
         /** 字符串模式替换
             - pattern: 匹配部分的格式
             - pattern_: 替换后的格式
@@ -68,7 +66,6 @@ declare global {
         surround(this: string, left: string, right?: string): string;
         surround_tag(this: string, tag_name: string): string;
         to_lf(this: string): string;
-        to_crlf(this: string): string;
         /** 'xxx'.replace(/pattern/g, '')
             如果 pattern 是 string 则在创建 RegExp 时自动加上 flags (默认 'g'), 否则忽略 flags
         */
@@ -90,7 +87,6 @@ declare global {
         strip_ansi(this: string): string;
         /** 将 string 划分为行，并去掉最后一个 \n 之后的 '' */
         split_lines(this: string): string[];
-        trim_doc_comment(this: string): string;
         split_indent(this: string): {
             indent: number;
             text: string;
@@ -101,14 +97,18 @@ declare global {
         decode_base64(this: string, buffer: true): Buffer;
         decode_base64(this: string, buffer?: boolean): string | Buffer;
         space(this: string): string;
+        /** 等价于 .endsWith('/') */
+        isdir: boolean;
+        /** 以 `/` 分割的路径 */
+        fp: string;
+        /** 父文件夹路径 (path.dirname)，并保证以 `/` 结尾 */
         fdir: string;
-        /** path.basename, 如:
-            - d:/0/aaa.txt -> aaa.txt
-            - d:/aaa/ -> aaa/ */
+        /** 文件名 (path.basename 的结果), 保留结尾的 /，如:
+            - D:/0/aaa.txt -> aaa.txt
+            - D:/aaa/ -> aaa/ */
         fname: string;
         /** .txt */
         fext: string;
-        to_slash(this: string): string;
         to_backslash(this: string): string;
     }
     interface Date {

package/prototype.js

@@ -1,10 +1,10 @@
-import path from 'upath';
 import byte_size from 'byte-size';
 import EmojiRegex from 'emoji-regex';
 import strip_ansi from 'strip-ansi';
 import chalk from 'chalk';
-chalk.level = 2;
+import { to_fp, dirname, basename, extname } from './path.js';
 import { t } from './i18n/instance.js';
+chalk.level = 2;
 export const emoji_regex = EmojiRegex();
 export { chalk };
 export function to_method_property_descriptors(methods) {
@@ -40,7 +40,7 @@ export const brackets = {
     tortoise_shell: ['〔', '〕'],
 };
 const color_map = Object.fromEntries(['red_', 'green_', 'yellow_', 'blue_', 'magenta_', 'cyan_'].map(color => [color, `${color.slice(0, -1)}Bright`]));
-if (!global.my_prototype_defined) {
+if (!globalThis.my_prototype_defined) {
     // ------------------------------------ String.prototype
     Object.defineProperties(String.prototype, {
         ...to_getter_property_descriptors({
@@ -116,9 +116,6 @@ if (!global.my_prototype_defined) {
                     .map((c) => c === ']' ? '\\]' : c).join('');
                 return new RegExp(this.replace(new RegExp(`[${replace_chars}]`, 'g'), '\\$&'), flags);
             },
-            to_bool() {
-                return this.length && this !== '0' && this.toLowerCase() !== 'false';
-            },
             refmt(pattern, pattern_, preservations = '', flags = '', transformer = (name, value) => value || '', pattern_placeholder = /\{.*?\}/g) {
                 // --- 转换 pattern 为 pattern_regx
                 let last_end = 0;
@@ -313,23 +310,25 @@ if (!global.my_prototype_defined) {
             }]))),
         // ------------ 文件路径操作
         ...to_getter_property_descriptors({
+            isdir() {
+                return this.endsWith('/');
+            },
+            fp() {
+                return to_fp(this);
+            },
             fdir() {
-                const dir = path.dirname(this);
-                return dir.endsWith('/') ? dir : `${dir}/`;
+                const fpd = dirname(this);
+                // 有可能 fpd 是 '/'
+                return fpd.endsWith('/') ? fpd : `${fpd}/`;
             },
             fname() {
-                return `${path.basename(this)}${this.endsWith('/') ? '/' : ''}`;
+                return `${basename(this)}${this.endsWith('/') ? '/' : ''}`;
             },
             fext() {
-                return path.extname(this);
+                return extname(this);
             },
         }),
         ...to_method_property_descriptors({
-            to_slash() {
-                if (!this)
-                    return this;
-                return path.normalizeSafe(this);
-            },
             to_backslash() {
                 return this.replaceAll('/', '\\');
             },

package/repl.js

@@ -2,9 +2,9 @@ import nvm from 'vm';
 import repl from 'repl';
 import process from 'process';
 import { fileURLToPath } from 'url';
-import path from 'upath';
 import ts from 'typescript';
 const { factory, createPrinter, SyntaxKind, NodeFlags, ModifierFlags, isIdentifier, isNamedImports, isImportDeclaration, isAwaitExpression, isExpressionStatement, isVariableStatement, isNamespaceImport, isClassDeclaration, isCallExpression, isReturnStatement, isBinaryExpression, isFunctionDeclaration, } = ts;
+import { path } from './path.js';
 import { t } from './i18n/instance.js';
 import './prototype.js';
 import { log_line, delay, inspect, set_inspect_options, Timer, delta2str } from './utils.js';
@@ -323,11 +323,11 @@ export async function pollute_global() {
         exports: global
     });
     await Promise.all([
-        pollute_module_default_export('upath', 'path'),
         pollute_module_default_export('lodash/omit.js', 'omit'),
         pollute_module_default_export('lodash/sortBy.js', 'sort_by'),
         pollute_module_default_export('lodash/groupBy.js', 'group_by'),
         pollute_module_default_export('qs', 'qs'),
+        pollute_module_exports('./path.js'),
         pollute_module_exports('./prototype.js'),
         pollute_module_exports('./utils.js'),
         pollute_module_exports('./process.js'),

package/server.d.ts

@@ -29,6 +29,7 @@ declare module 'http' {
 export declare class Server {
     /** proxy 时需要丢弃的 resposne headers */
     static drop_response_headers: Set<string>;
+    js_exts: Set<string>;
     app: Koa;
     handler: ReturnType<Koa['callback']>;
     port: number;
@@ -50,6 +51,7 @@ export declare class Server {
     */
     parse(ctx: Context): Promise<void>;
     _router(ctx: Context, next: Next): Promise<void>;
+    /** 被子类重写以自定义处理逻辑 */
     router(ctx: Context): Promise<boolean>;
     logger(ctx: Context): void;
     proxy(ctx: Context, url: string | URL, headers_?: Record<string, string>): Promise<void>;
@@ -58,10 +60,17 @@ export declare class Server {
         root: string;
         log_404?: boolean;
     }): Promise<boolean>;
-    /** send file at `path` with the  given `options` to the koa `ctx`. */
-    fsend(ctx: Context, path: string, { root, absolute }?: {
+    /** 将 body 设置为 fp 所指文件的 ReadStream
+        检查 fp 是否合法，设置对应的 content-type，支持缓存，支持分块下载
+        - ctx: Koa.Context
+        - fp: 文件路径，有 root 时为相对路径或以 root 开头的绝对路径，无 root 时必须是绝对路径
+        - options?:
+            - root?: 只能访问 root 下面的文件
+            - absolute?: `false` 使用绝对路径指定发送的文件
+            - download?: `undefined` 在 response.headers 中加上 content-disposition: attachment 指示浏览器下载文件 */
+    fsend(ctx: Context, fp: string, { root, absolute, download, }?: {
         root?: string;
-        /** `false` */
         absolute?: boolean;
+        download?: boolean;
     }): Promise<string>;
 }

package/server.js

@@ -4,10 +4,10 @@ import { createReadStream } from 'fs';
 import { Readable } from 'stream';
 import util from 'util';
 // --- 3rd party
-import upath from 'upath';
 import qs from 'qs';
 import resolve_safely from 'resolve-path';
 import { WebSocketServer } from 'ws';
+import { contentType } from 'mime-types';
 // --- koa & koa middleware
 import { default as Koa } from 'koa';
 import KoaCors from '@koa/cors';
@@ -28,6 +28,7 @@ export class Server {
         'transfer-encoding',
         'x-powered-by'
     ]);
+    js_exts = new Set(['.js', '.mjs', '.cjs']);
     app;
     handler;
     port;
@@ -160,6 +161,7 @@ export class Server {
             return;
         await next?.();
     }
+    /** 被子类重写以自定义处理逻辑 */
     async router(ctx) {
         return false;
     }
@@ -295,31 +297,37 @@ export class Server {
             return false;
         }
     }
-    /** send file at `path` with the  given `options` to the koa `ctx`. */
-    async fsend(ctx, path, { root, absolute } = {}) {
+    /** 将 body 设置为 fp 所指文件的 ReadStream
+        检查 fp 是否合法，设置对应的 content-type，支持缓存，支持分块下载
+        - ctx: Koa.Context
+        - fp: 文件路径，有 root 时为相对路径或以 root 开头的绝对路径，无 root 时必须是绝对路径
+        - options?:
+            - root?: 只能访问 root 下面的文件
+            - absolute?: `false` 使用绝对路径指定发送的文件
+            - download?: `undefined` 在 response.headers 中加上 content-disposition: attachment 指示浏览器下载文件 */
+    async fsend(ctx, fp, { root, absolute, download, } = {}) {
+        assert(root.isdir);
         const { request } = ctx;
         let { response } = ctx;
         if (!absolute && !root)
             throw new Error('fsend with `!absolute && !root`');
-        if (absolute)
-            path = upath.resolve(path);
-        else {
-            if (path.startsWith(root))
-                path = path.slice(root.length);
-            if (path.startsWith('/'))
-                path = path.slice(1);
+        if (!absolute) {
+            if (fp.startsWith(root))
+                fp = fp.slice(root.length);
+            if (fp.startsWith('/'))
+                fp = fp.slice(1);
             try {
-                path = upath.normalize(resolve_safely(root, path));
+                fp = resolve_safely(root, fp).fp;
             }
             catch (error) {
-                error.message += `, path: ${path}`;
+                error.message += `, fp: ${fp}`;
                 throw error;
             }
         }
         // stat
         let stats;
         try {
-            stats = await fstat(path);
+            stats = await fstat(fp);
         }
         catch (error) {
             if (['ENOENT', 'ENAMETOOLONG', 'ENOTDIR'].includes(error.code)) {
@@ -330,12 +338,6 @@ export class Server {
             error.message = `fs.stat 出错: ${error.message}`;
             throw error;
         }
-        // size limit
-        // if (stats.size >= 100 * 2**20) {
-        //     let error = new Error('body.length >= 100 mb')
-        //     ;(error as any).status = 500
-        //     throw error
-        // }
         // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Ranges
         // advertise server support of partial requests
         response.set('accept-ranges', 'bytes');
@@ -343,15 +345,17 @@ export class Server {
             response.set('cache-control', 'max-age=0, must-revalidate');
         if (!response.get('last-modified'))
             response.set('last-modified', stats.mtime.toUTCString());
-        const fext = path.fext;
-        if (!response.type)
-            response.type = fext;
-        if (fext === '.pdf')
-            response.set('content-disposition', `attachment; filename="${encodeURIComponent(path.fname)}"`);
+        if (download)
+            response.set('content-disposition', `attachment; filename="${encodeURIComponent(fp.fname)}"`);
+        if (!response.get('content-type')) {
+            const fext = fp.fext;
+            response.set('content-type', (this.js_exts.has(fext) ? 'text/javascript; chatset=utf-8' : contentType(fp.fext))
+                || 'application/octet-stream');
+        }
         if (request.fresh) {
             response.status = 304;
             // 以上会自动设置 response.body = null
-            return path;
+            return fp;
         }
         if (request.headers.range)
             try {
@@ -369,19 +373,19 @@ export class Server {
                 response.status = 206;
                 response.set('content-length', String(chunksize));
                 response.set('content-range', `bytes ${start}-${end}/${stats.size}`);
-                response.body = createReadStream(path, { start, end });
+                response.body = createReadStream(fp, { start, end });
             }
-            catch (err) {
+            catch {
                 response.status = 416;
                 response.set('content-length', String(stats.size));
                 response.set('content-range', `bytes */${stats.size}`);
-                response.body = createReadStream(path);
+                response.body = createReadStream(fp);
             }
         else {
             response.set('content-length', String(stats.size));
-            response.body = createReadStream(path);
+            response.body = createReadStream(fp);
         }
-        return path;
+        return fp;
     }
 }
 //# sourceMappingURL=server.js.map