@bleedingdev/modern-js-server-utils 3.2.0-ultramodern.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/dist/cjs/common/index.js

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    FILE_EXTENSIONS: ()=>FILE_EXTENSIONS,
+    compile: ()=>compile
+});
+const external_path_namespaceObject = require("path");
+const FILE_EXTENSIONS = [
+    '.js',
+    '.ts',
+    '.mjs',
+    '.ejs'
+];
+const validateAbsolutePath = (filename, message)=>{
+    if (!external_path_namespaceObject.isAbsolute(filename)) throw new Error(message);
+};
+const validateAbsolutePaths = (filenames, messageFunc)=>{
+    filenames.forEach((filename)=>validateAbsolutePath(filename, messageFunc(filename)));
+};
+const compile = async (appDirectory, modernConfig, compileOptions)=>{
+    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+    validateAbsolutePaths(sourceDirs, (dir)=>`source dir ${dir} is not an absolute path.`);
+    validateAbsolutePath(distDir, `dist dir ${distDir} is not an absolute path.`);
+    const { compileByTs } = await import("../compilers/typescript/index.js");
+    await compileByTs(appDirectory, modernConfig, compileOptions);
+};
+exports.FILE_EXTENSIONS = __webpack_exports__.FILE_EXTENSIONS;
+exports.compile = __webpack_exports__.compile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "FILE_EXTENSIONS",
+    "compile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/compilers/typescript/index.js

@@ -0,0 +1,196 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    compileByTs: ()=>compileByTs
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_child_process_namespaceObject = require("child_process");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_tsconfigPathsPlugin_js_namespaceObject = require("./tsconfigPathsPlugin.js");
+const importSpecifierRE = /((?:from\s*|import\s*\(\s*|require\s*\(\s*)['"])([^'"]+)(['"])/g;
+const copyFiles = async (from, to, appDirectory)=>{
+    if (await utils_namespaceObject.fs.pathExists(from)) {
+        const relativePath = external_path_default().relative(appDirectory, from);
+        const targetDir = external_path_default().join(to, relativePath);
+        await utils_namespaceObject.fs.copy(from, targetDir, {
+            filter: (src)=>![
+                    '.ts',
+                    '.js'
+                ].includes(external_path_default().extname(src)) && !src.endsWith('tsconfig.json')
+        });
+    }
+};
+const createResolvedTsgoConfig = async (appDirectory, tsconfigPath, distDir, sourceDirs)=>{
+    const output = await runTsgo([
+        '--showConfig',
+        '-p',
+        tsconfigPath
+    ], {
+        cwd: external_path_default().dirname(tsconfigPath)
+    });
+    const config = JSON.parse(output.stdout);
+    config.compilerOptions ??= {};
+    config.compilerOptions.rootDir = appDirectory;
+    config.compilerOptions.outDir = distDir;
+    config.files = filterSourceFiles(appDirectory, sourceDirs, config.files);
+    delete config.include;
+    delete config.compilerOptions.baseUrl;
+    if ([
+        'node',
+        'node10'
+    ].includes(String(config.compilerOptions.moduleResolution).toLowerCase())) delete config.compilerOptions.moduleResolution;
+    const resolvedConfigPath = external_path_default().join(appDirectory, `.tsgo.${process.pid}.resolved.json`);
+    await utils_namespaceObject.fs.writeFile(resolvedConfigPath, JSON.stringify(config, null, 2));
+    return {
+        config,
+        resolvedConfigPath
+    };
+};
+const filterSourceFiles = (appDirectory, sourceDirs, files = [])=>{
+    const sourcePosixPaths = sourceDirs.map((sourceDir)=>sourceDir.split(external_path_default().sep).join(external_path_default().posix.sep));
+    return files.filter((fileName)=>{
+        const absoluteFileName = external_path_default().resolve(appDirectory, fileName).split(external_path_default().sep).join(external_path_default().posix.sep);
+        return fileName.endsWith('.d.ts') || sourcePosixPaths.some((sourceDir)=>absoluteFileName.includes(sourceDir));
+    });
+};
+const runTsgo = (args, options)=>new Promise((resolve, reject)=>{
+        const child = (0, external_child_process_namespaceObject.spawn)(process.execPath, [
+            getTsgoBinPath(),
+            ...args
+        ], {
+            cwd: options.cwd,
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ]
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data)=>{
+            stdout += data;
+        });
+        child.stderr.on('data', (data)=>{
+            stderr += data;
+        });
+        child.on('error', reject);
+        child.on('close', (code)=>{
+            const result = {
+                stdout,
+                stderr,
+                code: code ?? 1
+            };
+            if (false !== options.reject && 0 !== result.code) return void reject(new Error(stderr || stdout || `tsgo exited with ${result.code}`));
+            resolve(result);
+        });
+    });
+const getTsgoBinPath = ()=>external_path_default().join(external_path_default().dirname(require.resolve("@typescript/native-preview/package.json")), 'bin/tsgo.js');
+const getSourceFileForOutput = (appDirectory, distDir, outputFile)=>{
+    const relativeOutput = external_path_default().relative(distDir, outputFile);
+    const parsed = external_path_default().parse(relativeOutput);
+    const sourceBase = external_path_default().join(appDirectory, parsed.dir, parsed.name);
+    return findExistingSource(`${sourceBase}.ts`) || findExistingSource(`${sourceBase}.tsx`) || findExistingSource(`${sourceBase}.js`) || findExistingSource(`${sourceBase}.jsx`);
+};
+const findExistingSource = (filePath)=>utils_namespaceObject.fs.existsSync(filePath) ? filePath : void 0;
+const rewriteOutputSpecifiers = async (appDirectory, distDir, baseUrl, paths, moduleType)=>{
+    if (0 === Object.keys(paths).length || !await utils_namespaceObject.fs.pathExists(distDir)) return;
+    const matcher = (0, external_tsconfigPathsPlugin_js_namespaceObject.createTsconfigPathsMatcher)(baseUrl, paths);
+    if (!matcher) return;
+    const files = await collectOutputFiles(distDir);
+    await Promise.all(files.map(async (file)=>{
+        const sourceFile = getSourceFileForOutput(appDirectory, distDir, file);
+        if (!sourceFile) return;
+        const content = await utils_namespaceObject.fs.readFile(file, 'utf8');
+        let changed = false;
+        const rewritten = content.replace(importSpecifierRE, (match, prefix, specifier, suffix)=>{
+            const nextSpecifier = (0, external_tsconfigPathsPlugin_js_namespaceObject.getNotAliasedPath)(sourceFile, matcher, specifier, moduleType);
+            if (!nextSpecifier || nextSpecifier === specifier) return match;
+            changed = true;
+            return `${prefix}${nextSpecifier}${suffix}`;
+        });
+        if (changed) await utils_namespaceObject.fs.writeFile(file, rewritten);
+    }));
+};
+const collectOutputFiles = async (dir)=>{
+    const entries = await utils_namespaceObject.fs.readdir(dir, {
+        withFileTypes: true
+    });
+    const files = await Promise.all(entries.map(async (entry)=>{
+        const fullPath = external_path_default().join(dir, entry.name);
+        if (entry.isDirectory()) return collectOutputFiles(fullPath);
+        return /\.(?:c|m)?js$/.test(entry.name) ? [
+            fullPath
+        ] : [];
+    }));
+    return files.flat();
+};
+const compileByTs = async (appDirectory, config, compileOptions)=>{
+    utils_namespaceObject.logger.info("Running tsgo compile...");
+    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+    if (!tsconfigPath) return;
+    const { alias } = config;
+    const aliasOption = (0, utils_namespaceObject.getAliasConfig)(alias, {
+        appDirectory,
+        tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasOption;
+    const { config: tsgoConfig, resolvedConfigPath } = await createResolvedTsgoConfig(appDirectory, tsconfigPath, distDir, sourceDirs);
+    const result = await runTsgo([
+        '-p',
+        resolvedConfigPath
+    ], {
+        cwd: appDirectory,
+        reject: false
+    });
+    await utils_namespaceObject.fs.remove(resolvedConfigPath);
+    if (result.stderr) utils_namespaceObject.logger.error(result.stderr);
+    if (result.stdout) utils_namespaceObject.logger.info(result.stdout);
+    if (0 !== result.code) {
+        const noEmitOnError = tsgoConfig.compilerOptions?.noEmitOnError;
+        if (void 0 === noEmitOnError || true === noEmitOnError) if (compileOptions.throwErrorInsteadOfExit) utils_namespaceObject.logger.error('TS-Go compilation failed');
+        else process.exit(1);
+    }
+    await rewriteOutputSpecifiers(appDirectory, distDir, absoluteBaseUrl, paths, compileOptions.moduleType);
+    for (const source of sourceDirs)await copyFiles(source, distDir, appDirectory);
+    utils_namespaceObject.logger.info("TS-Go compile succeed");
+};
+exports.compileByTs = __webpack_exports__.compileByTs;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "compileByTs"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/compilers/typescript/tsconfigPathsPlugin.js

@@ -0,0 +1,148 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module1)=>{
+        var getter = module1 && module1.__esModule ? ()=>module1['default'] : ()=>module1;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createTsconfigPathsMatcher: ()=>createTsconfigPathsMatcher,
+    getNotAliasedPath: ()=>getNotAliasedPath
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const tsconfig_paths_namespaceObject = require("@modern-js/utils/tsconfig-paths");
+const external_os_namespaceObject = require("os");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const toEsmOutputPath = (resolvedPath)=>{
+    const sourcePath = (0, utils_namespaceObject.findSourceEntry)(resolvedPath) || resolvedPath;
+    const ext = external_path_default().extname(sourcePath);
+    return ext ? `${sourcePath.slice(0, -ext.length)}.js` : `${sourcePath}.js`;
+};
+const resolveRelativeEsmSpecifier = (sourceFile, text)=>{
+    if (!text.startsWith('./') && !text.startsWith('../')) return;
+    const importerDir = (0, external_path_namespaceObject.dirname)(sourceFile);
+    return external_path_default().resolve(importerDir, text);
+};
+const isRegExpKey = (str)=>str.startsWith('^') || str.endsWith('$');
+const resolveAliasPath = (baseUrl, filePath)=>{
+    if (filePath.startsWith('.') || filePath.startsWith('..')) return external_path_default().resolve(baseUrl, filePath);
+    return filePath;
+};
+const createAliasMatcher = (baseUrl, alias)=>{
+    const aliasPairs = Object.keys(alias).reduce((o, key)=>{
+        if (isRegExpKey(key)) {
+            const regexp = new RegExp(key);
+            const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+            o.push([
+                regexp,
+                aliasPath
+            ]);
+        } else {
+            const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+            o.push([
+                key,
+                aliasPath
+            ]);
+        }
+        return o;
+    }, []);
+    const cacheMap = new Map();
+    return (requestedModule)=>{
+        if (cacheMap.has(requestedModule)) return cacheMap.get(requestedModule);
+        for (const [key, value] of aliasPairs){
+            if (key instanceof RegExp) {
+                if (key.test(requestedModule)) {
+                    cacheMap.set(requestedModule, value);
+                    return value;
+                }
+            }
+            if (requestedModule === key) {
+                cacheMap.set(requestedModule, value);
+                return value;
+            }
+        }
+    };
+};
+const createTsconfigPathsMatcher = (baseUrl, paths)=>{
+    const tsPaths = {};
+    const alias = {};
+    Object.keys(paths).forEach((key)=>{
+        if (Array.isArray(paths[key])) tsPaths[key] = paths[key];
+        else alias[key] = paths[key];
+    });
+    const matchAliasPath = createAliasMatcher(baseUrl, alias);
+    const matchTsPath = (0, tsconfig_paths_namespaceObject.createMatchPath)(baseUrl, tsPaths, [
+        'main'
+    ]);
+    return (requestedModule, readJSONSync, fileExists, extensions)=>{
+        const result = matchTsPath(requestedModule, readJSONSync, fileExists, extensions);
+        if (result) return result;
+        return matchAliasPath(requestedModule);
+    };
+};
+function getNotAliasedPath(sourceFile, matcher, text, moduleType) {
+    let result = (0, utils_namespaceObject.findMatchedSourcePath)(matcher, text);
+    if (!result && 'module' === moduleType) result = resolveRelativeEsmSpecifier(sourceFile, text);
+    if (!result) return;
+    if ('win32' === external_os_namespaceObject.platform()) result = result.replace(/\\/g, '/');
+    if (!external_path_default().isAbsolute(result)) {
+        if (!result.startsWith('.') && !result.startsWith('..')) try {
+            const packagePath = require.resolve(result, {
+                paths: [
+                    process.cwd(),
+                    ...module.paths
+                ]
+            });
+            if (packagePath) return result;
+        } catch  {}
+        try {
+            const packagePath = require.resolve(text, {
+                paths: [
+                    process.cwd(),
+                    ...module.paths
+                ]
+            });
+            if (packagePath) return text;
+        } catch  {}
+    }
+    if ('module' === moduleType) result = toEsmOutputPath(result);
+    const resolvedPath = external_path_namespaceObject.posix.relative((0, external_path_namespaceObject.dirname)(sourceFile), result) || './';
+    return '.' === resolvedPath[0] ? resolvedPath : `./${resolvedPath}`;
+}
+exports.createTsconfigPathsMatcher = __webpack_exports__.createTsconfigPathsMatcher;
+exports.getNotAliasedPath = __webpack_exports__.getNotAliasedPath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createTsconfigPathsMatcher",
+    "getNotAliasedPath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    compile: ()=>index_js_namespaceObject.compile
+});
+const index_js_namespaceObject = require("./common/index.js");
+exports.compile = __webpack_exports__.compile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "compile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/common/index.mjs

@@ -0,0 +1,21 @@
+import * as __rspack_external_path from "path";
+const FILE_EXTENSIONS = [
+    '.js',
+    '.ts',
+    '.mjs',
+    '.ejs'
+];
+const validateAbsolutePath = (filename, message)=>{
+    if (!__rspack_external_path.isAbsolute(filename)) throw new Error(message);
+};
+const validateAbsolutePaths = (filenames, messageFunc)=>{
+    filenames.forEach((filename)=>validateAbsolutePath(filename, messageFunc(filename)));
+};
+const compile = async (appDirectory, modernConfig, compileOptions)=>{
+    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+    validateAbsolutePaths(sourceDirs, (dir)=>`source dir ${dir} is not an absolute path.`);
+    validateAbsolutePath(distDir, `dist dir ${distDir} is not an absolute path.`);
+    const { compileByTs } = await import("../compilers/typescript/index.mjs");
+    await compileByTs(appDirectory, modernConfig, compileOptions);
+};
+export { FILE_EXTENSIONS, compile };

package/dist/esm/compilers/typescript/index.mjs

@@ -0,0 +1,152 @@
+import { fs, getAliasConfig, logger } from "@modern-js/utils";
+import { spawn } from "child_process";
+import path from "path";
+import { createTsconfigPathsMatcher, getNotAliasedPath } from "./tsconfigPathsPlugin.mjs";
+const importSpecifierRE = /((?:from\s*|import\s*\(\s*|require\s*\(\s*)['"])([^'"]+)(['"])/g;
+const copyFiles = async (from, to, appDirectory)=>{
+    if (await fs.pathExists(from)) {
+        const relativePath = path.relative(appDirectory, from);
+        const targetDir = path.join(to, relativePath);
+        await fs.copy(from, targetDir, {
+            filter: (src)=>![
+                    '.ts',
+                    '.js'
+                ].includes(path.extname(src)) && !src.endsWith('tsconfig.json')
+        });
+    }
+};
+const createResolvedTsgoConfig = async (appDirectory, tsconfigPath, distDir, sourceDirs)=>{
+    const output = await runTsgo([
+        '--showConfig',
+        '-p',
+        tsconfigPath
+    ], {
+        cwd: path.dirname(tsconfigPath)
+    });
+    const config = JSON.parse(output.stdout);
+    config.compilerOptions ??= {};
+    config.compilerOptions.rootDir = appDirectory;
+    config.compilerOptions.outDir = distDir;
+    config.files = filterSourceFiles(appDirectory, sourceDirs, config.files);
+    delete config.include;
+    delete config.compilerOptions.baseUrl;
+    if ([
+        'node',
+        'node10'
+    ].includes(String(config.compilerOptions.moduleResolution).toLowerCase())) delete config.compilerOptions.moduleResolution;
+    const resolvedConfigPath = path.join(appDirectory, `.tsgo.${process.pid}.resolved.json`);
+    await fs.writeFile(resolvedConfigPath, JSON.stringify(config, null, 2));
+    return {
+        config,
+        resolvedConfigPath
+    };
+};
+const filterSourceFiles = (appDirectory, sourceDirs, files = [])=>{
+    const sourcePosixPaths = sourceDirs.map((sourceDir)=>sourceDir.split(path.sep).join(path.posix.sep));
+    return files.filter((fileName)=>{
+        const absoluteFileName = path.resolve(appDirectory, fileName).split(path.sep).join(path.posix.sep);
+        return fileName.endsWith('.d.ts') || sourcePosixPaths.some((sourceDir)=>absoluteFileName.includes(sourceDir));
+    });
+};
+const runTsgo = (args, options)=>new Promise((resolve, reject)=>{
+        const child = spawn(process.execPath, [
+            getTsgoBinPath(),
+            ...args
+        ], {
+            cwd: options.cwd,
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ]
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data)=>{
+            stdout += data;
+        });
+        child.stderr.on('data', (data)=>{
+            stderr += data;
+        });
+        child.on('error', reject);
+        child.on('close', (code)=>{
+            const result = {
+                stdout,
+                stderr,
+                code: code ?? 1
+            };
+            if (false !== options.reject && 0 !== result.code) return void reject(new Error(stderr || stdout || `tsgo exited with ${result.code}`));
+            resolve(result);
+        });
+    });
+const getTsgoBinPath = ()=>path.join(path.dirname(require.resolve("@typescript/native-preview/package.json")), 'bin/tsgo.js');
+const getSourceFileForOutput = (appDirectory, distDir, outputFile)=>{
+    const relativeOutput = path.relative(distDir, outputFile);
+    const parsed = path.parse(relativeOutput);
+    const sourceBase = path.join(appDirectory, parsed.dir, parsed.name);
+    return findExistingSource(`${sourceBase}.ts`) || findExistingSource(`${sourceBase}.tsx`) || findExistingSource(`${sourceBase}.js`) || findExistingSource(`${sourceBase}.jsx`);
+};
+const findExistingSource = (filePath)=>fs.existsSync(filePath) ? filePath : void 0;
+const rewriteOutputSpecifiers = async (appDirectory, distDir, baseUrl, paths, moduleType)=>{
+    if (0 === Object.keys(paths).length || !await fs.pathExists(distDir)) return;
+    const matcher = createTsconfigPathsMatcher(baseUrl, paths);
+    if (!matcher) return;
+    const files = await collectOutputFiles(distDir);
+    await Promise.all(files.map(async (file)=>{
+        const sourceFile = getSourceFileForOutput(appDirectory, distDir, file);
+        if (!sourceFile) return;
+        const content = await fs.readFile(file, 'utf8');
+        let changed = false;
+        const rewritten = content.replace(importSpecifierRE, (match, prefix, specifier, suffix)=>{
+            const nextSpecifier = getNotAliasedPath(sourceFile, matcher, specifier, moduleType);
+            if (!nextSpecifier || nextSpecifier === specifier) return match;
+            changed = true;
+            return `${prefix}${nextSpecifier}${suffix}`;
+        });
+        if (changed) await fs.writeFile(file, rewritten);
+    }));
+};
+const collectOutputFiles = async (dir)=>{
+    const entries = await fs.readdir(dir, {
+        withFileTypes: true
+    });
+    const files = await Promise.all(entries.map(async (entry)=>{
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) return collectOutputFiles(fullPath);
+        return /\.(?:c|m)?js$/.test(entry.name) ? [
+            fullPath
+        ] : [];
+    }));
+    return files.flat();
+};
+const compileByTs = async (appDirectory, config, compileOptions)=>{
+    logger.info("Running tsgo compile...");
+    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+    if (!tsconfigPath) return;
+    const { alias } = config;
+    const aliasOption = getAliasConfig(alias, {
+        appDirectory,
+        tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasOption;
+    const { config: tsgoConfig, resolvedConfigPath } = await createResolvedTsgoConfig(appDirectory, tsconfigPath, distDir, sourceDirs);
+    const result = await runTsgo([
+        '-p',
+        resolvedConfigPath
+    ], {
+        cwd: appDirectory,
+        reject: false
+    });
+    await fs.remove(resolvedConfigPath);
+    if (result.stderr) logger.error(result.stderr);
+    if (result.stdout) logger.info(result.stdout);
+    if (0 !== result.code) {
+        const noEmitOnError = tsgoConfig.compilerOptions?.noEmitOnError;
+        if (void 0 === noEmitOnError || true === noEmitOnError) if (compileOptions.throwErrorInsteadOfExit) logger.error('TS-Go compilation failed');
+        else process.exit(1);
+    }
+    await rewriteOutputSpecifiers(appDirectory, distDir, absoluteBaseUrl, paths, compileOptions.moduleType);
+    for (const source of sourceDirs)await copyFiles(source, distDir, appDirectory);
+    logger.info("TS-Go compile succeed");
+};
+export { compileByTs };

package/dist/esm/compilers/typescript/tsconfigPathsPlugin.mjs

@@ -0,0 +1,101 @@
+import { findMatchedSourcePath, findSourceEntry } from "@modern-js/utils";
+import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
+import path, { dirname, posix } from "path";
+import * as __rspack_external_os from "os";
+const toEsmOutputPath = (resolvedPath)=>{
+    const sourcePath = findSourceEntry(resolvedPath) || resolvedPath;
+    const ext = path.extname(sourcePath);
+    return ext ? `${sourcePath.slice(0, -ext.length)}.js` : `${sourcePath}.js`;
+};
+const resolveRelativeEsmSpecifier = (sourceFile, text)=>{
+    if (!text.startsWith('./') && !text.startsWith('../')) return;
+    const importerDir = dirname(sourceFile);
+    return path.resolve(importerDir, text);
+};
+const isRegExpKey = (str)=>str.startsWith('^') || str.endsWith('$');
+const resolveAliasPath = (baseUrl, filePath)=>{
+    if (filePath.startsWith('.') || filePath.startsWith('..')) return path.resolve(baseUrl, filePath);
+    return filePath;
+};
+const createAliasMatcher = (baseUrl, alias)=>{
+    const aliasPairs = Object.keys(alias).reduce((o, key)=>{
+        if (isRegExpKey(key)) {
+            const regexp = new RegExp(key);
+            const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+            o.push([
+                regexp,
+                aliasPath
+            ]);
+        } else {
+            const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+            o.push([
+                key,
+                aliasPath
+            ]);
+        }
+        return o;
+    }, []);
+    const cacheMap = new Map();
+    return (requestedModule)=>{
+        if (cacheMap.has(requestedModule)) return cacheMap.get(requestedModule);
+        for (const [key, value] of aliasPairs){
+            if (key instanceof RegExp) {
+                if (key.test(requestedModule)) {
+                    cacheMap.set(requestedModule, value);
+                    return value;
+                }
+            }
+            if (requestedModule === key) {
+                cacheMap.set(requestedModule, value);
+                return value;
+            }
+        }
+    };
+};
+const createTsconfigPathsMatcher = (baseUrl, paths)=>{
+    const tsPaths = {};
+    const alias = {};
+    Object.keys(paths).forEach((key)=>{
+        if (Array.isArray(paths[key])) tsPaths[key] = paths[key];
+        else alias[key] = paths[key];
+    });
+    const matchAliasPath = createAliasMatcher(baseUrl, alias);
+    const matchTsPath = createMatchPath(baseUrl, tsPaths, [
+        'main'
+    ]);
+    return (requestedModule, readJSONSync, fileExists, extensions)=>{
+        const result = matchTsPath(requestedModule, readJSONSync, fileExists, extensions);
+        if (result) return result;
+        return matchAliasPath(requestedModule);
+    };
+};
+function getNotAliasedPath(sourceFile, matcher, text, moduleType) {
+    let result = findMatchedSourcePath(matcher, text);
+    if (!result && 'module' === moduleType) result = resolveRelativeEsmSpecifier(sourceFile, text);
+    if (!result) return;
+    if ('win32' === __rspack_external_os.platform()) result = result.replace(/\\/g, '/');
+    if (!path.isAbsolute(result)) {
+        if (!result.startsWith('.') && !result.startsWith('..')) try {
+            const packagePath = require.resolve(result, {
+                paths: [
+                    process.cwd(),
+                    ...module.paths
+                ]
+            });
+            if (packagePath) return result;
+        } catch  {}
+        try {
+            const packagePath = require.resolve(text, {
+                paths: [
+                    process.cwd(),
+                    ...module.paths
+                ]
+            });
+            if (packagePath) return text;
+        } catch  {}
+    }
+    if ('module' === moduleType) result = toEsmOutputPath(result);
+    const resolvedPath = posix.relative(dirname(sourceFile), result) || './';
+    return '.' === resolvedPath[0] ? resolvedPath : `./${resolvedPath}`;
+}
+export { createTsconfigPathsMatcher, getNotAliasedPath };

package/dist/esm/index.mjs

@@ -0,0 +1 @@
+export { compile } from "./common/index.mjs";

package/dist/esm-node/common/index.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+import * as __rspack_external_path from "path";
+const FILE_EXTENSIONS = [
+    '.js',
+    '.ts',
+    '.mjs',
+    '.ejs'
+];
+const validateAbsolutePath = (filename, message)=>{
+    if (!__rspack_external_path.isAbsolute(filename)) throw new Error(message);
+};
+const validateAbsolutePaths = (filenames, messageFunc)=>{
+    filenames.forEach((filename)=>validateAbsolutePath(filename, messageFunc(filename)));
+};
+const compile = async (appDirectory, modernConfig, compileOptions)=>{
+    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+    validateAbsolutePaths(sourceDirs, (dir)=>`source dir ${dir} is not an absolute path.`);
+    validateAbsolutePath(distDir, `dist dir ${distDir} is not an absolute path.`);
+    const { compileByTs } = await import("../compilers/typescript/index.mjs");
+    await compileByTs(appDirectory, modernConfig, compileOptions);
+};
+export { FILE_EXTENSIONS, compile };

package/dist/esm-node/compilers/typescript/index.mjs

@@ -0,0 +1,154 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { fs, getAliasConfig, logger } from "@modern-js/utils";
+import { spawn } from "child_process";
+import path from "path";
+import { createTsconfigPathsMatcher, getNotAliasedPath } from "./tsconfigPathsPlugin.mjs";
+const importSpecifierRE = /((?:from\s*|import\s*\(\s*|require\s*\(\s*)['"])([^'"]+)(['"])/g;
+const copyFiles = async (from, to, appDirectory)=>{
+    if (await fs.pathExists(from)) {
+        const relativePath = path.relative(appDirectory, from);
+        const targetDir = path.join(to, relativePath);
+        await fs.copy(from, targetDir, {
+            filter: (src)=>![
+                    '.ts',
+                    '.js'
+                ].includes(path.extname(src)) && !src.endsWith('tsconfig.json')
+        });
+    }
+};
+const createResolvedTsgoConfig = async (appDirectory, tsconfigPath, distDir, sourceDirs)=>{
+    const output = await runTsgo([
+        '--showConfig',
+        '-p',
+        tsconfigPath
+    ], {
+        cwd: path.dirname(tsconfigPath)
+    });
+    const config = JSON.parse(output.stdout);
+    config.compilerOptions ??= {};
+    config.compilerOptions.rootDir = appDirectory;
+    config.compilerOptions.outDir = distDir;
+    config.files = filterSourceFiles(appDirectory, sourceDirs, config.files);
+    delete config.include;
+    delete config.compilerOptions.baseUrl;
+    if ([
+        'node',
+        'node10'
+    ].includes(String(config.compilerOptions.moduleResolution).toLowerCase())) delete config.compilerOptions.moduleResolution;
+    const resolvedConfigPath = path.join(appDirectory, `.tsgo.${process.pid}.resolved.json`);
+    await fs.writeFile(resolvedConfigPath, JSON.stringify(config, null, 2));
+    return {
+        config,
+        resolvedConfigPath
+    };
+};
+const filterSourceFiles = (appDirectory, sourceDirs, files = [])=>{
+    const sourcePosixPaths = sourceDirs.map((sourceDir)=>sourceDir.split(path.sep).join(path.posix.sep));
+    return files.filter((fileName)=>{
+        const absoluteFileName = path.resolve(appDirectory, fileName).split(path.sep).join(path.posix.sep);
+        return fileName.endsWith('.d.ts') || sourcePosixPaths.some((sourceDir)=>absoluteFileName.includes(sourceDir));
+    });
+};
+const runTsgo = (args, options)=>new Promise((resolve, reject)=>{
+        const child = spawn(process.execPath, [
+            getTsgoBinPath(),
+            ...args
+        ], {
+            cwd: options.cwd,
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ]
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data)=>{
+            stdout += data;
+        });
+        child.stderr.on('data', (data)=>{
+            stderr += data;
+        });
+        child.on('error', reject);
+        child.on('close', (code)=>{
+            const result = {
+                stdout,
+                stderr,
+                code: code ?? 1
+            };
+            if (false !== options.reject && 0 !== result.code) return void reject(new Error(stderr || stdout || `tsgo exited with ${result.code}`));
+            resolve(result);
+        });
+    });
+const getTsgoBinPath = ()=>path.join(path.dirname(require.resolve("@typescript/native-preview/package.json")), 'bin/tsgo.js');
+const getSourceFileForOutput = (appDirectory, distDir, outputFile)=>{
+    const relativeOutput = path.relative(distDir, outputFile);
+    const parsed = path.parse(relativeOutput);
+    const sourceBase = path.join(appDirectory, parsed.dir, parsed.name);
+    return findExistingSource(`${sourceBase}.ts`) || findExistingSource(`${sourceBase}.tsx`) || findExistingSource(`${sourceBase}.js`) || findExistingSource(`${sourceBase}.jsx`);
+};
+const findExistingSource = (filePath)=>fs.existsSync(filePath) ? filePath : void 0;
+const rewriteOutputSpecifiers = async (appDirectory, distDir, baseUrl, paths, moduleType)=>{
+    if (0 === Object.keys(paths).length || !await fs.pathExists(distDir)) return;
+    const matcher = createTsconfigPathsMatcher(baseUrl, paths);
+    if (!matcher) return;
+    const files = await collectOutputFiles(distDir);
+    await Promise.all(files.map(async (file)=>{
+        const sourceFile = getSourceFileForOutput(appDirectory, distDir, file);
+        if (!sourceFile) return;
+        const content = await fs.readFile(file, 'utf8');
+        let changed = false;
+        const rewritten = content.replace(importSpecifierRE, (match, prefix, specifier, suffix)=>{
+            const nextSpecifier = getNotAliasedPath(sourceFile, matcher, specifier, moduleType);
+            if (!nextSpecifier || nextSpecifier === specifier) return match;
+            changed = true;
+            return `${prefix}${nextSpecifier}${suffix}`;
+        });
+        if (changed) await fs.writeFile(file, rewritten);
+    }));
+};
+const collectOutputFiles = async (dir)=>{
+    const entries = await fs.readdir(dir, {
+        withFileTypes: true
+    });
+    const files = await Promise.all(entries.map(async (entry)=>{
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) return collectOutputFiles(fullPath);
+        return /\.(?:c|m)?js$/.test(entry.name) ? [
+            fullPath
+        ] : [];
+    }));
+    return files.flat();
+};
+const compileByTs = async (appDirectory, config, compileOptions)=>{
+    logger.info("Running tsgo compile...");
+    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+    if (!tsconfigPath) return;
+    const { alias } = config;
+    const aliasOption = getAliasConfig(alias, {
+        appDirectory,
+        tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasOption;
+    const { config: tsgoConfig, resolvedConfigPath } = await createResolvedTsgoConfig(appDirectory, tsconfigPath, distDir, sourceDirs);
+    const result = await runTsgo([
+        '-p',
+        resolvedConfigPath
+    ], {
+        cwd: appDirectory,
+        reject: false
+    });
+    await fs.remove(resolvedConfigPath);
+    if (result.stderr) logger.error(result.stderr);
+    if (result.stdout) logger.info(result.stdout);
+    if (0 !== result.code) {
+        const noEmitOnError = tsgoConfig.compilerOptions?.noEmitOnError;
+        if (void 0 === noEmitOnError || true === noEmitOnError) if (compileOptions.throwErrorInsteadOfExit) logger.error('TS-Go compilation failed');
+        else process.exit(1);
+    }
+    await rewriteOutputSpecifiers(appDirectory, distDir, absoluteBaseUrl, paths, compileOptions.moduleType);
+    for (const source of sourceDirs)await copyFiles(source, distDir, appDirectory);
+    logger.info("TS-Go compile succeed");
+};
+export { compileByTs };

package/dist/esm-node/compilers/typescript/tsconfigPathsPlugin.mjs

@@ -0,0 +1,103 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { findMatchedSourcePath, findSourceEntry } from "@modern-js/utils";
+import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
+import path, { dirname, posix } from "path";
+import * as __rspack_external_os from "os";
+const toEsmOutputPath = (resolvedPath)=>{
+    const sourcePath = findSourceEntry(resolvedPath) || resolvedPath;
+    const ext = path.extname(sourcePath);
+    return ext ? `${sourcePath.slice(0, -ext.length)}.js` : `${sourcePath}.js`;
+};
+const resolveRelativeEsmSpecifier = (sourceFile, text)=>{
+    if (!text.startsWith('./') && !text.startsWith('../')) return;
+    const importerDir = dirname(sourceFile);
+    return path.resolve(importerDir, text);
+};
+const isRegExpKey = (str)=>str.startsWith('^') || str.endsWith('$');
+const resolveAliasPath = (baseUrl, filePath)=>{
+    if (filePath.startsWith('.') || filePath.startsWith('..')) return path.resolve(baseUrl, filePath);
+    return filePath;
+};
+const createAliasMatcher = (baseUrl, alias)=>{
+    const aliasPairs = Object.keys(alias).reduce((o, key)=>{
+        if (isRegExpKey(key)) {
+            const regexp = new RegExp(key);
+            const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+            o.push([
+                regexp,
+                aliasPath
+            ]);
+        } else {
+            const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+            o.push([
+                key,
+                aliasPath
+            ]);
+        }
+        return o;
+    }, []);
+    const cacheMap = new Map();
+    return (requestedModule)=>{
+        if (cacheMap.has(requestedModule)) return cacheMap.get(requestedModule);
+        for (const [key, value] of aliasPairs){
+            if (key instanceof RegExp) {
+                if (key.test(requestedModule)) {
+                    cacheMap.set(requestedModule, value);
+                    return value;
+                }
+            }
+            if (requestedModule === key) {
+                cacheMap.set(requestedModule, value);
+                return value;
+            }
+        }
+    };
+};
+const createTsconfigPathsMatcher = (baseUrl, paths)=>{
+    const tsPaths = {};
+    const alias = {};
+    Object.keys(paths).forEach((key)=>{
+        if (Array.isArray(paths[key])) tsPaths[key] = paths[key];
+        else alias[key] = paths[key];
+    });
+    const matchAliasPath = createAliasMatcher(baseUrl, alias);
+    const matchTsPath = createMatchPath(baseUrl, tsPaths, [
+        'main'
+    ]);
+    return (requestedModule, readJSONSync, fileExists, extensions)=>{
+        const result = matchTsPath(requestedModule, readJSONSync, fileExists, extensions);
+        if (result) return result;
+        return matchAliasPath(requestedModule);
+    };
+};
+function getNotAliasedPath(sourceFile, matcher, text, moduleType) {
+    let result = findMatchedSourcePath(matcher, text);
+    if (!result && 'module' === moduleType) result = resolveRelativeEsmSpecifier(sourceFile, text);
+    if (!result) return;
+    if ('win32' === __rspack_external_os.platform()) result = result.replace(/\\/g, '/');
+    if (!path.isAbsolute(result)) {
+        if (!result.startsWith('.') && !result.startsWith('..')) try {
+            const packagePath = require.resolve(result, {
+                paths: [
+                    process.cwd(),
+                    ...module.paths
+                ]
+            });
+            if (packagePath) return result;
+        } catch  {}
+        try {
+            const packagePath = require.resolve(text, {
+                paths: [
+                    process.cwd(),
+                    ...module.paths
+                ]
+            });
+            if (packagePath) return text;
+        } catch  {}
+    }
+    if ('module' === moduleType) result = toEsmOutputPath(result);
+    const resolvedPath = posix.relative(dirname(sourceFile), result) || './';
+    return '.' === resolvedPath[0] ? resolvedPath : `./${resolvedPath}`;
+}
+export { createTsconfigPathsMatcher, getNotAliasedPath };

package/dist/esm-node/index.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { compile } from "./common/index.mjs";

package/dist/types/common/index.d.ts

@@ -0,0 +1,22 @@
+import type { SourceNormalizedConfig } from '@modern-js/server-core';
+export interface Pattern {
+    from: string;
+    to: string;
+    tsconfigPath?: string;
+}
+export interface IConfig {
+    alias?: SourceNormalizedConfig['alias'];
+    server?: {
+        compiler?: 'typescript';
+    };
+}
+export interface CompileOptions {
+    sourceDirs: string[];
+    distDir: string;
+    tsconfigPath?: string;
+    moduleType?: 'module' | 'commonjs';
+    throwErrorInsteadOfExit?: boolean;
+}
+export type CompileFunc = (appDirectory: string, modernConfig: IConfig, compileOptions: CompileOptions) => Promise<void>;
+export declare const FILE_EXTENSIONS: string[];
+export declare const compile: CompileFunc;

package/dist/types/compilers/typescript/index.d.ts

@@ -0,0 +1,2 @@
+import type { CompileFunc } from '../../common';
+export declare const compileByTs: CompileFunc;

package/dist/types/compilers/typescript/tsconfigPathsPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { MatchPath } from '@modern-js/utils/tsconfig-paths';
+export declare const createTsconfigPathsMatcher: (baseUrl: string, paths: Record<string, string[] | string>) => MatchPath | undefined;
+export declare function getNotAliasedPath(sourceFile: string, matcher: MatchPath, text: string, moduleType?: 'module' | 'commonjs'): string | undefined;

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { compile } from './common';

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@bleedingdev/modern-js-server-utils",
+  "description": "A Progressive React Framework for modern web development.",
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/server/utils"
+  },
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js"
+  ],
+  "version": "3.2.0-ultramodern.0",
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "modern:source": "./src/index.ts",
+      "node": {
+        "import": "./dist/esm-node/index.mjs",
+        "require": "./dist/cjs/index.js"
+      },
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types/index.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@swc/helpers": "^0.5.21",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.0"
+  },
+  "devDependencies": {
+    "@rslib/core": "0.21.5",
+    "@types/node": "^25.8.0",
+    "@typescript/native-preview": "7.0.0-dev.20260516.1",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.0",
+    "@scripts/rstest-config": "2.66.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "rslib build --watch",
+    "build": "rslib build && pnpm -w tsgo:dts \"$PWD\"",
+    "test": "rstest --passWithNoTests"
+  }
+}

package/rslib.config.mts

@@ -0,0 +1,4 @@
+import { rslibConfig } from '@modern-js/rslib';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig(rslibConfig);

package/rstest.config.mts

@@ -0,0 +1,6 @@
+import { withTestPreset } from '@scripts/rstest-config';
+
+export default withTestPreset({
+  root: __dirname,
+  globals: true,
+});