@rslib/core 0.0.6 → 0.0.8

package/dist/index.js

@@ -7,11 +7,6 @@ import * as __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__ from "../co
 import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_core__ from "@rsbuild/core";
 import * as __WEBPACK_EXTERNAL_MODULE__compiled_fast_glob_index_js__ from "../compiled/fast-glob/index.js";
 import * as __WEBPACK_EXTERNAL_MODULE_module__ from "module";
-var index_js_namespaceObject = __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__;
-var external_node_fs_namespaceObject = __WEBPACK_EXTERNAL_MODULE_node_fs__;
-var promises_namespaceObject = __WEBPACK_EXTERNAL_MODULE_node_fs_promises__;
-var external_node_path_namespaceObject = __WEBPACK_EXTERNAL_MODULE_node_path__;
-var picocolors_index_js_namespaceObject = __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__;
 /**
  * Node.js built-in modules.
  * Copied from https://github.com/webpack/webpack/blob/dd44b206a9c50f4b4cb4d134e1a0bd0387b159a3/lib/node/NodeTargetPlugin.js#L12-L72
@@ -80,7 +75,7 @@ async function calcLongestCommonPath(absPaths) {
     // we support two cases
     // 1. /packages-a/src/index.ts
     // 2. D:/packages-a/src/index.ts
-    const sep = external_node_path_namespaceObject["default"].posix.sep;
+    const sep = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].posix.sep;
     const splitPaths = absPaths.map((p)=>p.split(sep));
     let lcaFragments = splitPaths[0];
     for(let i = 1; i < splitPaths.length; i++){
@@ -91,20 +86,20 @@ async function calcLongestCommonPath(absPaths) {
         lcaFragments = lcaFragments.slice(0, j);
     }
     let lca = lcaFragments.length > 0 ? lcaFragments.join(sep) : sep;
-    const stats = await promises_namespaceObject["default"].stat(lca);
-    if (stats?.isFile()) lca = external_node_path_namespaceObject["default"].dirname(lca);
+    const stats = await __WEBPACK_EXTERNAL_MODULE_node_fs_promises__["default"].stat(lca);
+    if (stats?.isFile()) lca = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(lca);
     return lca;
 }
 const readPackageJson = (rootPath)=>{
-    const pkgJsonPath = external_node_path_namespaceObject["default"].join(rootPath, './package.json');
-    if (!external_node_fs_namespaceObject["default"].existsSync(pkgJsonPath)) {
-        index_js_namespaceObject.logger.warn(`package.json does not exist in the ${rootPath} directory`);
+    const pkgJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(rootPath, './package.json');
+    if (!__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(pkgJsonPath)) {
+        __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn(`package.json does not exist in the ${rootPath} directory`);
         return;
     }
     try {
-        return JSON.parse(external_node_fs_namespaceObject["default"].readFileSync(pkgJsonPath, 'utf8'));
+        return JSON.parse(__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].readFileSync(pkgJsonPath, 'utf8'));
     } catch (err) {
-        index_js_namespaceObject.logger.warn(`Failed to parse ${pkgJsonPath}, it might not be valid JSON`);
+        __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn(`Failed to parse ${pkgJsonPath}, it might not be valid JSON`);
         return;
     }
 };
@@ -123,7 +118,7 @@ function omit(obj, keys) {
     }, {});
 }
 // setup the logger level
-if (process.env.DEBUG) index_js_namespaceObject.logger.level = 'verbose';
+if (process.env.DEBUG) __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.level = 'verbose';
 function initNodeEnv() {
     if (!process.env.NODE_ENV) {
         const command = process.argv[2] ?? '';
@@ -138,13 +133,10 @@ function prepareCli() {
     // Some package managers automatically output a blank line, some do not.
     const { npm_execpath } = process.env;
     if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) console.log();
-    index_js_namespaceObject.logger.greet(`  Rslib v0.0.6\n`);
+    __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.greet(`  Rslib v0.0.8\n`);
 }
-var commander_index_js_namespaceObject = __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__;
-var core_namespaceObject = __WEBPACK_EXTERNAL_MODULE__rsbuild_core__;
-var fast_glob_index_js_namespaceObject = __WEBPACK_EXTERNAL_MODULE__compiled_fast_glob_index_js__;
 const DEFAULT_CONFIG_NAME = 'rslib.config';
-const DEFAULT_EXTENSIONS = [
+const DEFAULT_CONFIG_EXTENSIONS = [
     '.js',
     '.ts',
     '.mjs',
@@ -153,6 +145,65 @@ const DEFAULT_EXTENSIONS = [
     '.cts'
 ];
 const SWC_HELPERS = '@swc/helpers';
+const JS_EXTENSIONS = [
+    'js',
+    'mjs',
+    'jsx',
+    'ts',
+    'mts',
+    'tsx',
+    'cjs',
+    'cjsx',
+    'mjsx',
+    'mtsx',
+    'cts',
+    'ctsx'
+];
+const CSS_EXTENSIONS = [
+    'css',
+    'sass',
+    'scss',
+    'less'
+];
+const ENTRY_EXTENSIONS = [
+    ...JS_EXTENSIONS,
+    ...CSS_EXTENSIONS
+];
+const JS_EXTENSIONS_PATTERN = new RegExp(`\\.(${JS_EXTENSIONS.join('|')})$`);
+const ENTRY_EXTENSIONS_PATTERN = new RegExp(`\\.(${ENTRY_EXTENSIONS.join('|')})$`);
+const importMetaUrlShim = `var __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+`;
+// This Rsbuild plugin will shim `import.meta.url` for CommonJS modules.
+// - Replace `import.meta.url` with `importMetaUrl`.
+// - Inject `importMetaUrl` to the end of the module (can't inject at the beginning because of `"use strict";`).
+// This is a short-term solution, and we hope to provide built-in polyfills like `node.__filename` on Rspack side.
+const pluginCjsShim = ()=>({
+        name: 'rsbuild-plugin-cjs-shim',
+        setup (api) {
+            api.modifyEnvironmentConfig((config)=>{
+                config.source.define = {
+                    ...config.source.define,
+                    'import.meta.url': '__rslib_import_meta_url__'
+                };
+            });
+            api.modifyRspackConfig((config)=>{
+                config.plugins ??= [];
+                config.plugins.push(new __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.BannerPlugin({
+                    banner: importMetaUrlShim,
+                    // Just before minify stage, to perform tree shaking.
+                    stage: __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE - 1,
+                    raw: true,
+                    footer: true,
+                    include: /\.(js|cjs)$/
+                }));
+            });
+        }
+    });
 const getDefaultExtension = (options)=>{
     const { format, pkgJson, autoExtension } = options;
     let jsExtension = '.js';
@@ -162,7 +213,7 @@ const getDefaultExtension = (options)=>{
         dtsExtension
     };
     if (!pkgJson) {
-        index_js_namespaceObject.logger.warn('autoExtension configuration will not be applied due to read package.json failed');
+        __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn('autoExtension configuration will not be applied due to read package.json failed');
         return {
             jsExtension,
             dtsExtension
@@ -207,6 +258,11 @@ const calcEsnextBrowserslistByTarget = (target)=>{
     if ('node' === target) return LATEST_TARGET_VERSIONS.node;
     return LATEST_TARGET_VERSIONS.web;
 };
+const RSPACK_TARGET_UNLISTED_MODERN_ECMA_VERSIONS = [
+    'es2023',
+    'es2024',
+    'esnext'
+];
 /**
  * The esX to browserslist mapping is transformed from esbuild:
  * https://github.com/evanw/esbuild/blob/main/internal/compat/js_table.go
@@ -324,6 +380,25 @@ const calcEsnextBrowserslistByTarget = (target)=>{
         Safari: '3.1.0'
     }
 };
+function transformSyntaxToRspackTarget(syntax) {
+    const handleSyntaxItem = (syntaxItem)=>{
+        const normalizedSyntaxItem = syntaxItem.toLowerCase();
+        if (normalizedSyntaxItem.startsWith('es')) {
+            if (normalizedSyntaxItem in ESX_TO_BROWSERSLIST) {
+                // The latest EcmaScript version supported by Rspack's `target` is es2022.
+                // Higher versions are treated as es2022.
+                if (RSPACK_TARGET_UNLISTED_MODERN_ECMA_VERSIONS.includes(normalizedSyntaxItem)) return 'es2022';
+                return normalizedSyntaxItem;
+            }
+            throw new Error(`Unsupported ES version: ${syntaxItem}`);
+        }
+        return `browserslist:${syntaxItem}`;
+    };
+    if (Array.isArray(syntax)) return syntax.map(handleSyntaxItem);
+    return [
+        handleSyntaxItem(syntax)
+    ];
+}
 function transformSyntaxToBrowserslist(syntax, target) {
     const handleSyntaxItem = (syntaxItem)=>{
         const normalizedSyntaxItem = syntaxItem.toLowerCase();
@@ -345,8 +420,8 @@ function transformSyntaxToBrowserslist(syntax, target) {
     if (Array.isArray(syntax)) return syntax.flatMap(handleSyntaxItem);
     return handleSyntaxItem(syntax);
 }
-const POSIX_SEP_RE = new RegExp('\\' + external_node_path_namespaceObject["default"].posix.sep, 'g');
-const NATIVE_SEP_RE = new RegExp('\\' + external_node_path_namespaceObject["default"].sep, 'g');
+const POSIX_SEP_RE = new RegExp('\\' + __WEBPACK_EXTERNAL_MODULE_node_path__["default"].posix.sep, 'g');
+const NATIVE_SEP_RE = new RegExp('\\' + __WEBPACK_EXTERNAL_MODULE_node_path__["default"].sep, 'g');
 /** @type {Map<string,RegExp>}*/ const PATTERN_REGEX_CACHE = new Map();
 const GLOB_ALL_PATTERN = "**/*";
 const TS_EXTENSIONS = [
@@ -355,16 +430,16 @@ const TS_EXTENSIONS = [
     '.mts',
     '.cts'
 ];
-const JS_EXTENSIONS = [
+const util_JS_EXTENSIONS = [
     '.js',
     '.jsx',
     '.mjs',
     '.cjs'
 ];
-const TSJS_EXTENSIONS = TS_EXTENSIONS.concat(JS_EXTENSIONS);
+const TSJS_EXTENSIONS = TS_EXTENSIONS.concat(util_JS_EXTENSIONS);
 const TS_EXTENSIONS_RE_GROUP = `\\.(?:${TS_EXTENSIONS.map((ext)=>ext.substring(1)).join('|')})`;
 const TSJS_EXTENSIONS_RE_GROUP = `\\.(?:${TSJS_EXTENSIONS.map((ext)=>ext.substring(1)).join('|')})`;
-const IS_POSIX = external_node_path_namespaceObject["default"].posix.sep === external_node_path_namespaceObject["default"].sep;
+const IS_POSIX = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].posix.sep === __WEBPACK_EXTERNAL_MODULE_node_path__["default"].sep;
 /**
  * @template T
  * @returns {{resolve:(result:T)=>void, reject:(error:any)=>void, promise: Promise<T>}}
@@ -385,10 +460,10 @@ const IS_POSIX = external_node_path_namespaceObject["default"].posix.sep === ext
  * @param {import('./cache.js').TSConfckCache} [cache]
  * @returns {Promise<string|void>}
  */ async function util_resolveTSConfigJson(filename, cache) {
-    if ('.json' !== external_node_path_namespaceObject["default"].extname(filename)) return; // ignore files that are not json
-    const tsconfig = external_node_path_namespaceObject["default"].resolve(filename);
+    if ('.json' !== __WEBPACK_EXTERNAL_MODULE_node_path__["default"].extname(filename)) return; // ignore files that are not json
+    const tsconfig = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].resolve(filename);
     if (cache && (cache.hasParseResult(tsconfig) || cache.hasParseResult(filename))) return tsconfig;
-    return external_node_fs_namespaceObject.promises.stat(tsconfig).then((stat)=>{
+    return __WEBPACK_EXTERNAL_MODULE_node_fs__.promises.stat(tsconfig).then((stat)=>{
         if (stat.isFile() || stat.isFIFO()) return tsconfig;
         throw new Error(`${filename} exists but is not a regular file.`);
     });
@@ -407,7 +482,7 @@ const IS_POSIX = external_node_path_namespaceObject["default"].posix.sep === ext
  *
  * @param {string} filename with posix separators
  * @returns {string} filename with native separators
- */ const posix2native = IS_POSIX ? (filename)=>filename : (filename)=>filename.replace(POSIX_SEP_RE, external_node_path_namespaceObject["default"].sep);
+ */ const posix2native = IS_POSIX ? (filename)=>filename : (filename)=>filename.replace(POSIX_SEP_RE, __WEBPACK_EXTERNAL_MODULE_node_path__["default"].sep);
 /**
  * convert native separator to posix separator
  *
@@ -417,7 +492,7 @@ const IS_POSIX = external_node_path_namespaceObject["default"].posix.sep === ext
  *
  * @param {string} filename - filename with native separators
  * @returns {string} filename with posix separators
- */ const util_native2posix = IS_POSIX ? (filename)=>filename : (filename)=>filename.replace(NATIVE_SEP_RE, external_node_path_namespaceObject["default"].posix.sep);
+ */ const util_native2posix = IS_POSIX ? (filename)=>filename : (filename)=>filename.replace(NATIVE_SEP_RE, __WEBPACK_EXTERNAL_MODULE_node_path__["default"].posix.sep);
 /**
  * converts params to native separator, resolves path and converts native back to posix
  *
@@ -426,16 +501,16 @@ const IS_POSIX = external_node_path_namespaceObject["default"].posix.sep === ext
  * @param dir {string|null} directory to resolve from
  * @param filename {string} filename or pattern to resolve
  * @returns string
- */ const resolve2posix = IS_POSIX ? (dir, filename)=>dir ? external_node_path_namespaceObject["default"].resolve(dir, filename) : external_node_path_namespaceObject["default"].resolve(filename) : (dir, filename)=>util_native2posix(dir ? external_node_path_namespaceObject["default"].resolve(posix2native(dir), posix2native(filename)) : external_node_path_namespaceObject["default"].resolve(posix2native(filename)));
+ */ const resolve2posix = IS_POSIX ? (dir, filename)=>dir ? __WEBPACK_EXTERNAL_MODULE_node_path__["default"].resolve(dir, filename) : __WEBPACK_EXTERNAL_MODULE_node_path__["default"].resolve(filename) : (dir, filename)=>util_native2posix(dir ? __WEBPACK_EXTERNAL_MODULE_node_path__["default"].resolve(posix2native(dir), posix2native(filename)) : __WEBPACK_EXTERNAL_MODULE_node_path__["default"].resolve(posix2native(filename)));
 /**
  *
  * @param {import('./public.d.ts').TSConfckParseResult} result
  * @param {import('./public.d.ts').TSConfckParseOptions} [options]
  * @returns {string[]}
  */ function util_resolveReferencedTSConfigFiles(result, options) {
-    const dir = external_node_path_namespaceObject["default"].dirname(result.tsconfigFile);
+    const dir = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(result.tsconfigFile);
     return result.tsconfig.references.map((ref)=>{
-        const refPath = ref.path.endsWith('.json') ? ref.path : external_node_path_namespaceObject["default"].join(ref.path, options?.configName ?? 'tsconfig.json');
+        const refPath = ref.path.endsWith('.json') ? ref.path : __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(ref.path, options?.configName ?? 'tsconfig.json');
         return resolve2posix(dir, refPath);
     });
 }
@@ -458,7 +533,7 @@ const IS_POSIX = external_node_path_namespaceObject["default"].posix.sep === ext
  * @param {import('./public.d.ts').TSConfckParseResult} result
  * @returns {boolean}
  */ function util_isIncluded(filename, result) {
-    const dir = util_native2posix(external_node_path_namespaceObject["default"].dirname(result.tsconfigFile));
+    const dir = util_native2posix(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(result.tsconfigFile));
     const files = (result.tsconfig.files || []).map((file)=>resolve2posix(dir, file));
     const absoluteFilename = resolve2posix(null, filename);
     if (files.includes(filename)) return true;
@@ -560,13 +635,13 @@ const IS_POSIX = external_node_path_namespaceObject["default"].posix.sep === ext
  * @param {import('./public.d.ts').TSConfckFindOptions} [options] - options
  * @returns {Promise<string|null>} absolute path to closest tsconfig.json or null if not found
  */ async function find(filename, options) {
-    let dir = external_node_path_namespaceObject["default"].dirname(external_node_path_namespaceObject["default"].resolve(filename));
+    let dir = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].resolve(filename));
     if (options?.ignoreNodeModules && util_isInNodeModules(dir)) return null;
     const cache = options?.cache;
     const configName = options?.configName ?? 'tsconfig.json';
     if (cache?.hasConfigPath(dir, configName)) return cache.getConfigPath(dir, configName);
     const { promise, resolve, reject } = util_makePromise();
-    if (options?.root && !external_node_path_namespaceObject["default"].isAbsolute(options.root)) options.root = external_node_path_namespaceObject["default"].resolve(options.root);
+    if (options?.root && !__WEBPACK_EXTERNAL_MODULE_node_path__["default"].isAbsolute(options.root)) options.root = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].resolve(options.root);
     findUp(dir, {
         promise,
         resolve,
@@ -594,13 +669,13 @@ const IS_POSIX = external_node_path_namespaceObject["default"].posix.sep === ext
             else resolve(cached);
         } else cache.setConfigPath(dir, promise, configName);
     }
-    const tsconfig = external_node_path_namespaceObject["default"].join(dir, options?.configName ?? 'tsconfig.json');
-    external_node_fs_namespaceObject["default"].stat(tsconfig, (err, stats)=>{
+    const tsconfig = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(dir, options?.configName ?? 'tsconfig.json');
+    __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].stat(tsconfig, (err, stats)=>{
         if (stats && (stats.isFile() || stats.isFIFO())) resolve(tsconfig);
         else if (err?.code !== 'ENOENT') reject(err);
         else {
             let parent;
-            if (root === dir || (parent = external_node_path_namespaceObject["default"].dirname(dir)) === dir) resolve(null);
+            if (root === dir || (parent = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(dir)) === dir) resolve(null);
             else findUp(parent, {
                 promise,
                 resolve,
@@ -617,7 +692,7 @@ const IS_POSIX = external_node_path_namespaceObject["default"].posix.sep === ext
  * @property {(dir: string)=>boolean} skip - function to skip dirs
  * @property {boolean} err - error flag
  * @property {string[]} configNames - config file names
- */ external_node_path_namespaceObject["default"].sep;
+ */ __WEBPACK_EXTERNAL_MODULE_node_path__["default"].sep;
 /*
  this file contains code from strip-bom and strip-json-comments by Sindre Sorhus
  https://github.com/sindresorhus/strip-json-comments/blob/v4.0.0/index.js
@@ -752,7 +827,6 @@ const multiComment = Symbol('multiComment');
     if (0xfeff === string.charCodeAt(0)) return string.slice(1);
     return string;
 }
-var external_module_namespaceObject = __WEBPACK_EXTERNAL_MODULE_module__;
 const not_found_result = {
     tsconfigFile: null,
     tsconfig: {}
@@ -784,7 +858,7 @@ const not_found_result = {
                 parseReferences(result, options)
             ]);
         }
-        result.tsconfig = util_replaceTokens(result.tsconfig, external_node_path_namespaceObject["default"].dirname(tsconfigFile));
+        result.tsconfig = util_replaceTokens(result.tsconfig, __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(tsconfigFile));
         resolve(util_resolveSolutionTSConfig(filename, result));
     } catch (e) {
         reject(e);
@@ -817,12 +891,12 @@ const not_found_result = {
  * @returns {Promise<import('./public.d.ts').TSConfckParseResult>}
  */ async function parseFile(tsconfigFile, cache, skipCache) {
     if (!skipCache && cache?.hasParseResult(tsconfigFile) && !cache.getParseResult(tsconfigFile)._isRootFile_) return cache.getParseResult(tsconfigFile);
-    const promise = external_node_fs_namespaceObject.promises.readFile(tsconfigFile, 'utf-8').then(toJson).then((json)=>{
+    const promise = __WEBPACK_EXTERNAL_MODULE_node_fs__.promises.readFile(tsconfigFile, 'utf-8').then(toJson).then((json)=>{
         const parsed = JSON.parse(json);
         applyDefaults(parsed, tsconfigFile);
         return {
             tsconfigFile,
-            tsconfig: normalizeTSConfig(parsed, external_node_path_namespaceObject["default"].dirname(tsconfigFile))
+            tsconfig: normalizeTSConfig(parsed, __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(tsconfigFile))
         };
     }).catch((e)=>{
         throw new TSConfckParseError(`parsing ${tsconfigFile} failed: ${e}`, 'PARSE_FILE', tsconfigFile, e);
@@ -838,7 +912,7 @@ const not_found_result = {
  */ function normalizeTSConfig(tsconfig, dir) {
     // set baseUrl to absolute path
     const baseUrl = tsconfig.compilerOptions?.baseUrl;
-    if (baseUrl && !baseUrl.startsWith('${') && !external_node_path_namespaceObject["default"].isAbsolute(baseUrl)) tsconfig.compilerOptions.baseUrl = resolve2posix(dir, baseUrl);
+    if (baseUrl && !baseUrl.startsWith('${') && !__WEBPACK_EXTERNAL_MODULE_node_path__["default"].isAbsolute(baseUrl)) tsconfig.compilerOptions.baseUrl = resolve2posix(dir, baseUrl);
     return tsconfig;
 }
 /**
@@ -913,14 +987,14 @@ const not_found_result = {
  */ function resolveExtends(extended, from) {
     if ('..' === extended) // see #149
     extended = '../tsconfig.json';
-    const req = (0, external_module_namespaceObject.createRequire)(from);
+    const req = (0, __WEBPACK_EXTERNAL_MODULE_module__.createRequire)(from);
     let error;
     try {
         return req.resolve(extended);
     } catch (e) {
         error = e;
     }
-    if ('.' !== extended[0] && !external_node_path_namespaceObject["default"].isAbsolute(extended)) try {
+    if ('.' !== extended[0] && !__WEBPACK_EXTERNAL_MODULE_node_path__["default"].isAbsolute(extended)) try {
         return req.resolve(`${extended}/tsconfig.json`);
     } catch (e) {
         error = e;
@@ -946,7 +1020,7 @@ const EXTENDABLE_KEYS = [
  */ function extendTSConfig(extending, extended) {
     const extendingConfig = extending.tsconfig;
     const extendedConfig = extended.tsconfig;
-    const relativePath = util_native2posix(external_node_path_namespaceObject["default"].relative(external_node_path_namespaceObject["default"].dirname(extending.tsconfigFile), external_node_path_namespaceObject["default"].dirname(extended.tsconfigFile)));
+    const relativePath = util_native2posix(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].relative(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(extending.tsconfigFile), __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(extended.tsconfigFile)));
     for (const key of Object.keys(extendedConfig).filter((key)=>EXTENDABLE_KEYS.includes(key)))if ('compilerOptions' === key) {
         if (!extendingConfig.compilerOptions) extendingConfig.compilerOptions = {};
         for (const option of Object.keys(extendedConfig.compilerOptions)){
@@ -993,9 +1067,9 @@ const REBASE_KEYS = [
  * @param {string} prependPath
  * @returns {string}
  */ function rebasePath(value, prependPath) {
-    if (external_node_path_namespaceObject["default"].isAbsolute(value) || value.startsWith('${configDir}')) return value;
+    if (__WEBPACK_EXTERNAL_MODULE_node_path__["default"].isAbsolute(value) || value.startsWith('${configDir}')) return value;
     // relative paths use posix syntax in tsconfig
-    return external_node_path_namespaceObject["default"].posix.normalize(external_node_path_namespaceObject["default"].posix.join(prependPath, value));
+    return __WEBPACK_EXTERNAL_MODULE_node_path__["default"].posix.normalize(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].posix.join(prependPath, value));
 }
 class TSConfckParseError extends Error {
     /**
@@ -1046,12 +1120,12 @@ const DEFAULT_JSCONFIG_COMPILER_OPTIONS = {
 /**
  * @param {string} configFileName
  */ function isJSConfig(configFileName) {
-    return 'jsconfig.json' === external_node_path_namespaceObject["default"].basename(configFileName);
+    return 'jsconfig.json' === __WEBPACK_EXTERNAL_MODULE_node_path__["default"].basename(configFileName);
 }
 async function loadTsconfig(root, tsconfigPath = 'tsconfig.json') {
-    const tsconfigFileName = await find((0, external_node_path_namespaceObject.join)(root, tsconfigPath), {
+    const tsconfigFileName = await find((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(root, tsconfigPath), {
         root,
-        configName: (0, external_node_path_namespaceObject.basename)(tsconfigPath)
+        configName: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.basename)(tsconfigPath)
     });
     if (tsconfigFileName) {
         const { tsconfig } = await parse(tsconfigFileName);
@@ -1059,27 +1133,24 @@ async function loadTsconfig(root, tsconfigPath = 'tsconfig.json') {
     }
     return {};
 }
-/**
- * This function helps you to autocomplete configuration types.
- * It accepts a Rslib config object, or a function that returns a config.
- */ function defineConfig(config) {
+function defineConfig(config) {
     return config;
 }
-const findConfig = (basePath)=>DEFAULT_EXTENSIONS.map((ext)=>basePath + ext).find(external_node_fs_namespaceObject["default"].existsSync);
+const findConfig = (basePath)=>DEFAULT_CONFIG_EXTENSIONS.map((ext)=>basePath + ext).find(__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync);
 const resolveConfigPath = (root, customConfig)=>{
     if (customConfig) {
-        const customConfigPath = (0, external_node_path_namespaceObject.isAbsolute)(customConfig) ? customConfig : (0, external_node_path_namespaceObject.join)(root, customConfig);
-        if (external_node_fs_namespaceObject["default"].existsSync(customConfigPath)) return customConfigPath;
-        index_js_namespaceObject.logger.warn(`Cannot find config file: ${picocolors_index_js_namespaceObject["default"].dim(customConfigPath)}\n`);
+        const customConfigPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.isAbsolute)(customConfig) ? customConfig : (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(root, customConfig);
+        if (__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(customConfigPath)) return customConfigPath;
+        __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn(`Cannot find config file: ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__["default"].dim(customConfigPath)}\n`);
     }
-    const configFilePath = findConfig((0, external_node_path_namespaceObject.join)(root, DEFAULT_CONFIG_NAME));
+    const configFilePath = findConfig((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(root, DEFAULT_CONFIG_NAME));
     if (configFilePath) return configFilePath;
     throw new Error(`${DEFAULT_CONFIG_NAME} not found in ${root}`);
 };
 async function loadConfig({ cwd = process.cwd(), path, envMode }) {
     const configFilePath = resolveConfigPath(cwd, path);
-    const { content } = await (0, core_namespaceObject.loadConfig)({
-        cwd: (0, external_node_path_namespaceObject.dirname)(configFilePath),
+    const { content } = await (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.loadConfig)({
+        cwd: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(configFilePath),
         path: configFilePath,
         envMode
     });
@@ -1145,7 +1216,7 @@ const composeExternalsWarnConfig = (format, ...externalsArray)=>{
                     };
                     if (contextInfo.issuer && 'commonjs' === dependencyType) {
                         matchUserExternals(externals, request, _callback);
-                        if (externalized) index_js_namespaceObject.logger.warn(composeModuleImportWarn(request));
+                        if (externalized) __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn(composeModuleImportWarn(request));
                     }
                     callback();
                 }
@@ -1157,7 +1228,7 @@ const composeAutoExternalConfig = (options)=>{
     const { autoExternal, pkgJson, userExternals } = options;
     if (!autoExternal) return {};
     if (!pkgJson) {
-        index_js_namespaceObject.logger.warn('autoExternal configuration will not be applied due to read package.json failed');
+        __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn('autoExternal configuration will not be applied due to read package.json failed');
         return {};
     }
     const externalOptions = {
@@ -1230,30 +1301,30 @@ function composeBannerFooterConfig(banner, footer) {
     if (isEmptyObject(bannerConfig) && isEmptyObject(footerConfig)) return {};
     const plugins = [];
     if (!isEmptyObject(bannerConfig)) {
-        if (bannerConfig.js) plugins.push(new core_namespaceObject.rspack.BannerPlugin({
+        if (bannerConfig.js) plugins.push(new __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.BannerPlugin({
             banner: bannerConfig.js,
-            stage: core_namespaceObject.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
+            stage: __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
             raw: true,
             include: /\.(js|mjs|cjs)$/
         }));
-        if (bannerConfig.css) plugins.push(new core_namespaceObject.rspack.BannerPlugin({
+        if (bannerConfig.css) plugins.push(new __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.BannerPlugin({
             banner: bannerConfig.css,
-            stage: core_namespaceObject.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
+            stage: __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
             raw: true,
             include: /\.(css)$/
         }));
     }
     if (!isEmptyObject(footerConfig)) {
-        if (footerConfig.js) plugins.push(new core_namespaceObject.rspack.BannerPlugin({
+        if (footerConfig.js) plugins.push(new __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.BannerPlugin({
             banner: footerConfig.js,
-            stage: core_namespaceObject.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
+            stage: __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
             raw: true,
             footer: true,
             include: /\.(js|mjs|cjs)$/
         }));
-        if (footerConfig.css) plugins.push(new core_namespaceObject.rspack.BannerPlugin({
+        if (footerConfig.css) plugins.push(new __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.BannerPlugin({
             banner: footerConfig.css,
-            stage: core_namespaceObject.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
+            stage: __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
             raw: true,
             footer: true,
             include: /\.(css)$/
@@ -1278,7 +1349,7 @@ function composeDecoratorsConfig(compilerOptions, version) {
     };
 }
 async function createConstantRsbuildConfig() {
-    return (0, core_namespaceObject.defineConfig)({
+    return (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.defineConfig)({
         mode: 'production',
         dev: {
             progressBar: false
@@ -1362,8 +1433,18 @@ const composeFormatConfig = (format)=>{
             };
         case 'cjs':
             return {
+                plugins: [
+                    pluginCjsShim()
+                ],
                 tools: {
                     rspack: {
+                        module: {
+                            parser: {
+                                javascript: {
+                                    importMeta: false
+                                }
+                            }
+                        },
                         output: {
                             iife: false,
                             chunkFormat: 'commonjs',
@@ -1378,6 +1459,13 @@ const composeFormatConfig = (format)=>{
             return {
                 tools: {
                     rspack: {
+                        module: {
+                            parser: {
+                                javascript: {
+                                    importMeta: false
+                                }
+                            }
+                        },
                         output: {
                             library: {
                                 type: 'umd'
@@ -1390,7 +1478,7 @@ const composeFormatConfig = (format)=>{
             throw new Error(`Unsupported format: ${format}`);
     }
 };
-const composeModuleImportWarn = (request)=>`The externalized commonjs request ${picocolors_index_js_namespaceObject["default"].green(`"${request}"`)} will use ${picocolors_index_js_namespaceObject["default"].blue('"module"')} external type in ESM format. If you want to specify other external type, considering set the request and type with ${picocolors_index_js_namespaceObject["default"].blue('"output.externals"')}.`;
+const composeModuleImportWarn = (request)=>`The externalized commonjs request ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__["default"].green(`"${request}"`)} will use ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__["default"].blue('"module"')} external type in ESM format. If you want to specify other external type, considering set the request and type with ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__["default"].blue('"output.externals"')}.`;
 const composeExternalsConfig = (format, externals)=>{
     // TODO: Define the internal externals config in Rsbuild's externals instead
     // Rspack's externals as they will not be merged from different fields. All externals
@@ -1442,13 +1530,7 @@ const composeSyntaxConfig = (syntax, target)=>{
     if (syntax) return {
         tools: {
             rspack: (config)=>{
-                // TODO: Rspack should could resolve `browserslist:{query}` like webpack.
-                // https://webpack.js.org/configuration/target/#browserslist
-                // Using 'es5' as a temporary solution for compatibility.
-                config.target = [
-                    'es5'
-                ];
-                return config;
+                config.target = transformSyntaxToRspackTarget(syntax);
             }
         },
         output: {
@@ -1490,18 +1572,20 @@ const composeEntryConfig = async (entries, bundle, root)=>{
         ] : null;
         if (!entryFiles) throw new Error('Entry can only be a string or an array of strings for now');
         // Turn entries in array into each separate entry.
-        const resolvedEntryFiles = await (0, fast_glob_index_js_namespaceObject["default"])(entryFiles, {
+        const globEntryFiles = await (0, __WEBPACK_EXTERNAL_MODULE__compiled_fast_glob_index_js__["default"])(entryFiles, {
             cwd: root
         });
+        // Filter the glob resolved entry files based on the allowed extensions
+        const resolvedEntryFiles = globEntryFiles.filter((file)=>ENTRY_EXTENSIONS_PATTERN.test(file));
         if (0 === resolvedEntryFiles.length) throw new Error(`Cannot find ${resolvedEntryFiles}`);
         // Similar to `rootDir` in tsconfig and `outbase` in esbuild.
         const lcp = await calcLongestCommonPath(resolvedEntryFiles);
         // Using the longest common path of all non-declaration input files by default.
         const outBase = null === lcp ? root : lcp;
         for (const file of resolvedEntryFiles){
-            const { dir, name } = external_node_path_namespaceObject["default"].parse(external_node_path_namespaceObject["default"].relative(outBase, file));
+            const { dir, name } = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].parse(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].relative(outBase, file));
             // Entry filename contains nested path to preserve source directory structure.
-            const entryFileName = external_node_path_namespaceObject["default"].join(dir, name);
+            const entryFileName = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(dir, name);
             resolvedEntries[entryFileName] = file;
         }
     }
@@ -1527,7 +1611,13 @@ const composeBundleConfig = (jsExtension, bundle = true)=>{
                         // This may result in a change in semantics,
                         // user should use copy to keep origin file or use another separate entry to deal this
                         let request = data.request;
-                        if ('.' === request[0]) request = (0, external_node_path_namespaceObject.extname)(request) ? request.replace(/\.[^.]+$/, jsExtension) : `${request}${jsExtension}`;
+                        if ('.' === request[0]) {
+                            if ((0, __WEBPACK_EXTERNAL_MODULE_node_path__.extname)(request)) {
+                                if (!JS_EXTENSIONS_PATTERN.test(request)) // If it does not match jsExtensionsPattern, we should do nothing, eg: ./foo.png
+                                return callback();
+                                request = request.replace(/\.[^.]+$/, jsExtension);
+                            } else request = `${request}${jsExtension}`;
+                        }
                         return callback(null, request);
                     }
                     callback();
@@ -1562,7 +1652,12 @@ const composeTargetConfig = (target = 'web')=>{
                     rspack: {
                         target: [
                             'web'
-                        ]
+                        ],
+                        output: {
+                            chunkLoading: 'import',
+                            workerChunkLoading: 'import',
+                            wasmLoading: 'fetch'
+                        }
                     }
                 }
             };
@@ -1572,12 +1667,17 @@ const composeTargetConfig = (target = 'web')=>{
                     rspack: {
                         target: [
                             'node'
-                        ]
+                        ],
+                        // "__dirname" and "__filename" shims will automatically be enabled when `output.module` is `true`,
+                        // and leave them as-is in the rest of the cases.
+                        // { node: { __dirname: ..., __filename: ... } }
+                        output: {
+                            chunkLoading: 'require',
+                            workerChunkLoading: 'async-node',
+                            wasmLoading: 'async-node'
+                        }
                     }
                 },
-                // "__dirname" and "__filename" shims will automatically be enabled when `output.module` is `true`,
-                // and leave them as-is in the rest of the cases.
-                // { node: { __dirname: ..., __filename: ... } }
                 output: {
                     // When output.target is 'node', Node.js's built-in will be treated as externals of type `node-commonjs`.
                     // Simply override the built-in modules to make them external.
@@ -1615,7 +1715,7 @@ const composeExternalHelpersConfig = (externalHelpers, pkgJson)=>{
             ...Object.keys(pkgJson?.devDependencies ?? [])
         ];
         if (!deps.includes(SWC_HELPERS)) {
-            index_js_namespaceObject.logger.error(`${picocolors_index_js_namespaceObject["default"].green('externalHelpers')} is enabled, but the ${picocolors_index_js_namespaceObject["default"].blue(SWC_HELPERS)} dependency declaration was not found in package.json.`);
+            __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.error(`${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__["default"].green('externalHelpers')} is enabled, but the ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__["default"].blue(SWC_HELPERS)} dependency declaration was not found in package.json.`);
             process.exit(1);
         }
         defaultConfig = Object.assign(defaultConfig, {
@@ -1628,7 +1728,7 @@ const composeExternalHelpersConfig = (externalHelpers, pkgJson)=>{
     return defaultConfig;
 };
 async function composeLibRsbuildConfig(config, configPath) {
-    const rootPath = (0, external_node_path_namespaceObject.dirname)(configPath);
+    const rootPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(configPath);
     const pkgJson = readPackageJson(rootPath);
     const { compilerOptions } = await loadTsconfig(rootPath, config.source?.tsconfigPath);
     const { format, banner = {}, footer = {}, autoExtension = true, autoExternal = true, externalHelpers = false } = config;
@@ -1644,13 +1744,13 @@ async function composeLibRsbuildConfig(config, configPath) {
         pkgJson,
         userExternals: config.output?.externals
     });
-    const entryConfig = await composeEntryConfig(config.source?.entry, config.bundle, (0, external_node_path_namespaceObject.dirname)(configPath));
+    const entryConfig = await composeEntryConfig(config.source?.entry, config.bundle, (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(configPath));
     const dtsConfig = await composeDtsConfig(config, dtsExtension);
     const externalsWarnConfig = composeExternalsWarnConfig(format, autoExternalConfig?.output?.externals, externalsConfig?.output?.externals);
     const minifyConfig = composeMinifyConfig(config.output?.minify);
     const bannerFooterConfig = composeBannerFooterConfig(banner, footer);
     const decoratorsConfig = composeDecoratorsConfig(compilerOptions, config.source?.decorators?.version);
-    return (0, core_namespaceObject.mergeRsbuildConfig)(formatConfig, externalHelpersConfig, externalsWarnConfig, externalsConfig, autoExternalConfig, autoExtensionConfig, syntaxConfig, bundleConfig, targetConfig, entryConfig, minifyConfig, dtsConfig, bannerFooterConfig, decoratorsConfig);
+    return (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.mergeRsbuildConfig)(formatConfig, externalHelpersConfig, externalsWarnConfig, externalsConfig, autoExternalConfig, autoExtensionConfig, syntaxConfig, bundleConfig, targetConfig, entryConfig, minifyConfig, dtsConfig, bannerFooterConfig, decoratorsConfig);
 }
 async function composeCreateRsbuildConfig(rslibConfig, path) {
     const constantRsbuildConfig = await createConstantRsbuildConfig();
@@ -1658,7 +1758,7 @@ async function composeCreateRsbuildConfig(rslibConfig, path) {
     const { lib: libConfigsArray, ...sharedRsbuildConfig } = rslibConfig;
     if (!libConfigsArray) throw new Error(`Expect lib field to be an array, but got ${libConfigsArray}.`);
     const libConfigPromises = libConfigsArray.map(async (libConfig)=>{
-        const userConfig = (0, core_namespaceObject.mergeRsbuildConfig)(sharedRsbuildConfig, libConfig);
+        const userConfig = (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.mergeRsbuildConfig)(sharedRsbuildConfig, libConfig);
         // Merge the configuration of each environment based on the shared Rsbuild
         // configuration and Lib configuration in the settings.
         const libRsbuildConfig = await composeLibRsbuildConfig(userConfig, configPath);
@@ -1680,7 +1780,7 @@ async function composeCreateRsbuildConfig(rslibConfig, path) {
             // We should state in the document that the built-in configuration should not be changed optionally
             // In compose process of 2, we may read some config from 1, and reassemble the related config,
             // so before final mergeRsbuildConfig, we reset some specified fields
-            config: (0, core_namespaceObject.mergeRsbuildConfig)(constantRsbuildConfig, libRsbuildConfig, omit(userConfig, [
+            config: (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.mergeRsbuildConfig)(constantRsbuildConfig, libRsbuildConfig, omit(userConfig, [
                 'bundle',
                 'format',
                 'autoExtension',
@@ -1713,7 +1813,7 @@ async function initRsbuild(rslibConfig) {
         const currentFormatIndex = formatIndex[format]++;
         environments[1 === currentFormatCount ? format : `${format}${currentFormatIndex}`] = config;
     }
-    return (0, core_namespaceObject.createRsbuild)({
+    return (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.createRsbuild)({
         rsbuildConfig: {
             environments
         }
@@ -1730,9 +1830,9 @@ const applyCommonOptions = (command)=>{
     command.option('-c --config <config>', 'specify the configuration file, can be a relative or absolute path').option('--env-mode <mode>', 'specify the env mode to load the `.env.[mode]` file');
 };
 function runCli() {
-    commander_index_js_namespaceObject.program.name('rslib').usage('<command> [options]').version("0.0.6");
-    const buildCommand = commander_index_js_namespaceObject.program.command('build');
-    const inspectCommand = commander_index_js_namespaceObject.program.command('inspect');
+    __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.name('rslib').usage('<command> [options]').version("0.0.8");
+    const buildCommand = __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.command('build');
+    const inspectCommand = __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.command('inspect');
     [
         buildCommand,
         inspectCommand
@@ -1745,8 +1845,8 @@ function runCli() {
             });
             await build(rslibConfig, options);
         } catch (err) {
-            index_js_namespaceObject.logger.error('Failed to build.');
-            index_js_namespaceObject.logger.error(err);
+            __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.error('Failed to build.');
+            __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.error(err);
             process.exit(1);
         }
     });
@@ -1765,13 +1865,13 @@ function runCli() {
                 writeToDisk: true
             });
         } catch (err) {
-            index_js_namespaceObject.logger.error('Failed to inspect config.');
-            index_js_namespaceObject.logger.error(err);
+            __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.error('Failed to inspect config.');
+            __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.error(err);
             process.exit(1);
         }
     });
-    commander_index_js_namespaceObject.program.parse();
+    __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.parse();
 }
-const src_version = "0.0.6";
-var __webpack_exports__logger = index_js_namespaceObject.logger;
+const src_version = "0.0.8";
+var __webpack_exports__logger = __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger;
 export { build, defineConfig, loadConfig, prepareCli, runCli, src_version as version, __webpack_exports__logger as logger };

package/dist-types/constant.d.ts

@@ -1,3 +1,8 @@
 export declare const DEFAULT_CONFIG_NAME = "rslib.config";
-export declare const DEFAULT_EXTENSIONS: readonly [".js", ".ts", ".mjs", ".mts", ".cjs", ".cts"];
+export declare const DEFAULT_CONFIG_EXTENSIONS: readonly [".js", ".ts", ".mjs", ".mts", ".cjs", ".cts"];
 export declare const SWC_HELPERS = "@swc/helpers";
+export declare const JS_EXTENSIONS: string[];
+export declare const CSS_EXTENSIONS: string[];
+export declare const ENTRY_EXTENSIONS: string[];
+export declare const JS_EXTENSIONS_PATTERN: RegExp;
+export declare const ENTRY_EXTENSIONS_PATTERN: RegExp;

package/dist-types/plugins/cjsShim.d.ts

@@ -0,0 +1,2 @@
+import { type RsbuildPlugin } from '@rsbuild/core';
+export declare const pluginCjsShim: () => RsbuildPlugin;

package/dist-types/utils/syntax.d.ts

@@ -1,4 +1,4 @@
-import type { RsbuildConfig } from '@rsbuild/core';
+import type { RsbuildConfig, Rspack } from '@rsbuild/core';
 import type { FixedEcmaVersions, LatestEcmaVersions, RsbuildConfigOutputTarget, Syntax } from '../types/config';
 export declare const LATEST_TARGET_VERSIONS: Record<NonNullable<RsbuildConfigOutputTarget>, string[]>;
 /**
@@ -9,4 +9,5 @@ export declare const LATEST_TARGET_VERSIONS: Record<NonNullable<RsbuildConfigOut
  * TODO: align with Rsbuild, we may should align with SWC
  */
 export declare const ESX_TO_BROWSERSLIST: Record<FixedEcmaVersions, Record<string, string | string[]>> & Record<LatestEcmaVersions, (target: RsbuildConfigOutputTarget) => string[]>;
+export declare function transformSyntaxToRspackTarget(syntax: Syntax): Rspack.Configuration['target'];
 export declare function transformSyntaxToBrowserslist(syntax: Syntax, target?: NonNullable<RsbuildConfig['output']>['target']): NonNullable<NonNullable<RsbuildConfig['output']>['overrideBrowserslist']>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rslib/core",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "The Rspack-based library build tool.",
   "homepage": "https://lib.rsbuild.dev",
   "bugs": {
@@ -32,18 +32,18 @@
     "compiled"
   ],
   "dependencies": {
-    "@rsbuild/core": "1.0.3",
-    "rsbuild-plugin-dts": "0.0.6"
+    "@rsbuild/core": "1.0.7",
+    "rsbuild-plugin-dts": "0.0.8"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "commander": "^12.1.0",
     "fast-glob": "^3.3.2",
     "fs-extra": "^11.2.0",
-    "memfs": "^4.11.1",
+    "memfs": "^4.12.0",
     "picocolors": "1.1.0",
     "prebundle": "1.2.2",
-    "rslib": "npm:@rslib/core@0.0.5",
+    "rslib": "npm:@rslib/core@0.0.7",
     "rslog": "^1.2.3",
     "tsconfck": "3.1.3",
     "typescript": "^5.6.2",