@rslib/core 0.0.0-next-20240927040621

package/dist/index.js

@@ -0,0 +1,1894 @@
+import * as __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__ from "../compiled/rslog/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises__ from "node:fs/promises";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__ from "../compiled/picocolors/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__ from "../compiled/commander/index.js";
+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";
+/**
+ * Node.js built-in modules.
+ * Copied from https://github.com/webpack/webpack/blob/dd44b206a9c50f4b4cb4d134e1a0bd0387b159a3/lib/node/NodeTargetPlugin.js#L12-L72
+ */ const nodeBuiltInModules = [
+    'assert',
+    'assert/strict',
+    'async_hooks',
+    'buffer',
+    'child_process',
+    'cluster',
+    'console',
+    'constants',
+    'crypto',
+    'dgram',
+    'diagnostics_channel',
+    'dns',
+    'dns/promises',
+    'domain',
+    'events',
+    'fs',
+    'fs/promises',
+    'http',
+    'http2',
+    'https',
+    'inspector',
+    'inspector/promises',
+    'module',
+    'net',
+    'os',
+    'path',
+    'path/posix',
+    'path/win32',
+    'perf_hooks',
+    'process',
+    'punycode',
+    'querystring',
+    'readline',
+    'readline/promises',
+    'repl',
+    'stream',
+    'stream/consumers',
+    'stream/promises',
+    'stream/web',
+    'string_decoder',
+    'sys',
+    'timers',
+    'timers/promises',
+    'tls',
+    'trace_events',
+    'tty',
+    'url',
+    'util',
+    'util/types',
+    'v8',
+    'vm',
+    'wasi',
+    'worker_threads',
+    'zlib',
+    /^node:/,
+    // cspell:word pnpapi
+    // Yarn PnP adds pnpapi as "builtin"
+    'pnpapi'
+];
+async function calcLongestCommonPath(absPaths) {
+    if (0 === absPaths.length) return null;
+    // we support two cases
+    // 1. /packages-a/src/index.ts
+    // 2. D:/packages-a/src/index.ts
+    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++){
+        const currentPath = splitPaths[i];
+        const minLength = Math.min(lcaFragments.length, currentPath.length);
+        let j = 0;
+        while(j < minLength && lcaFragments[j] === currentPath[j])j++;
+        lcaFragments = lcaFragments.slice(0, j);
+    }
+    let lca = lcaFragments.length > 0 ? lcaFragments.join(sep) : sep;
+    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 = __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(__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].readFileSync(pkgJsonPath, 'utf8'));
+    } catch (err) {
+        __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn(`Failed to parse ${pkgJsonPath}, it might not be valid JSON`);
+        return;
+    }
+};
+const isObject = (obj)=>'[object Object]' === Object.prototype.toString.call(obj);
+const isEmptyObject = (obj)=>0 === Object.keys(obj).length;
+function pick(obj, keys) {
+    return keys.reduce((ret, key)=>{
+        if (void 0 !== obj[key]) ret[key] = obj[key];
+        return ret;
+    }, {});
+}
+function omit(obj, keys) {
+    return Object.keys(obj).reduce((ret, key)=>{
+        if (!keys.includes(key)) ret[key] = obj[key];
+        return ret;
+    }, {});
+}
+// setup the logger level
+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] ?? '';
+        process.env.NODE_ENV = [
+            'build'
+        ].includes(command) ? 'production' : 'development';
+    }
+}
+function prepareCli() {
+    initNodeEnv();
+    // Print a blank line to keep the greet log nice.
+    // 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();
+    __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.greet(`  Rslib v0.0.7\n`);
+}
+const DEFAULT_CONFIG_NAME = 'rslib.config';
+const DEFAULT_CONFIG_EXTENSIONS = [
+    '.js',
+    '.ts',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.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';
+    let dtsExtension = '.d.ts';
+    if (!autoExtension) return {
+        jsExtension,
+        dtsExtension
+    };
+    if (!pkgJson) {
+        __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn('autoExtension configuration will not be applied due to read package.json failed');
+        return {
+            jsExtension,
+            dtsExtension
+        };
+    }
+    const isModule = 'module' === pkgJson.type;
+    if (isModule && 'cjs' === format) {
+        jsExtension = '.cjs';
+        dtsExtension = '.d.cts';
+    }
+    if (!isModule && 'esm' === format) {
+        jsExtension = '.mjs';
+        dtsExtension = '.d.mts';
+    }
+    return {
+        jsExtension,
+        dtsExtension,
+        isModule
+    };
+};
+const LATEST_TARGET_VERSIONS = {
+    node: [
+        'last 1 node versions'
+    ],
+    web: [
+        'last 1 Chrome versions',
+        'last 1 Firefox versions',
+        'last 1 Edge versions',
+        'last 1 Safari versions',
+        'last 1 ios_saf versions',
+        'not dead'
+    ],
+    get 'web-worker' () {
+        return LATEST_TARGET_VERSIONS.web;
+    }
+};
+const calcEsnextBrowserslistByTarget = (target)=>{
+    if (!target) return [
+        ...LATEST_TARGET_VERSIONS.node,
+        ...LATEST_TARGET_VERSIONS.web
+    ];
+    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
+ * It does not completely align with the browserslist query of Rsbuild now:
+ * https://github.com/rspack-contrib/browserslist-to-es-version
+ * TODO: align with Rsbuild, we may should align with SWC
+ */ const ESX_TO_BROWSERSLIST = {
+    es6: {
+        Chrome: '63.0.0',
+        Edge: '79.0.0',
+        Firefox: '67.0.0',
+        iOS: '13.0.0',
+        Node: [
+            'node > 12.20.0 and node < 13.0.0',
+            'node > 13.2.0'
+        ],
+        Opera: '50.0.0',
+        Safari: '13.0.0'
+    },
+    es2015: {
+        Chrome: '63.0.0',
+        Edge: '79.0.0',
+        Firefox: '67.0.0',
+        iOS: '13.0.0',
+        Node: '10.0.0',
+        Opera: '50.0.0',
+        Safari: '13.0.0'
+    },
+    es2016: {
+        Chrome: '52.0.0',
+        Edge: '14.0.0',
+        Firefox: '52.0.0',
+        iOS: '10.3.0',
+        Node: '7.0.0',
+        Opera: '39.0.0',
+        Safari: '10.1.0'
+    },
+    es2017: {
+        Chrome: '55.0.0',
+        Edge: '15.0.0',
+        Firefox: '52.0.0',
+        iOS: '11.0.0',
+        Node: '7.6.0',
+        Opera: '42.0.0',
+        Safari: '11.0.0'
+    },
+    es2018: {
+        Chrome: '64.0.0',
+        Edge: '79.0.0',
+        Firefox: '78.0.0',
+        iOS: '16.4.0',
+        Node: [
+            'node > 18.20.0 and node < 19.0.0',
+            'node > 20.12.0 and node < 21.0.0',
+            'node > 21.3.0'
+        ],
+        Opera: '51.0.0',
+        Safari: '16.4.0'
+    },
+    es2019: {
+        Chrome: '66.0.0',
+        Edge: '79.0.0',
+        Firefox: '58.0.0',
+        iOS: '11.3.0',
+        Node: '10.0.0',
+        Opera: '53.0.0',
+        Safari: '11.1.0'
+    },
+    es2020: {
+        Chrome: '91.0.0',
+        Edge: '91.0.0',
+        Firefox: '80.0.0',
+        iOS: '14.5.0',
+        Node: '16.1.0',
+        Opera: '77.0.0',
+        Safari: '14.1.0'
+    },
+    es2021: {
+        Chrome: '85.0.0',
+        Edge: '85.0.0',
+        Firefox: '79.0.0',
+        iOS: '14.0.0',
+        Node: '15.0.0',
+        Opera: '71.0.0',
+        Safari: '14.0.0'
+    },
+    es2022: {
+        Chrome: '91.0.0',
+        Edge: '94.0.0',
+        Firefox: '93.0.0',
+        iOS: '16.4.0',
+        Node: '16.11.0',
+        Opera: '80.0.0',
+        Safari: '16.4.0'
+    },
+    es2023: {
+        Chrome: '74.0.0',
+        Edge: '79.0.0',
+        Firefox: '67.0.0',
+        iOS: '13.4.0',
+        Node: '12.5.0',
+        Opera: '62.0.0',
+        Safari: '13.1.0'
+    },
+    es2024: calcEsnextBrowserslistByTarget,
+    esnext: calcEsnextBrowserslistByTarget,
+    es5: {
+        Chrome: '5.0.0',
+        Edge: '12.0.0',
+        Firefox: '2.0.0',
+        ie: '9.0.0',
+        iOS: '6.0.0',
+        Node: '0.4.0',
+        Opera: '10.10.0',
+        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();
+        if (normalizedSyntaxItem.startsWith('es')) {
+            if (normalizedSyntaxItem in ESX_TO_BROWSERSLIST) {
+                const browserslistItem = ESX_TO_BROWSERSLIST[normalizedSyntaxItem];
+                if ('function' == typeof browserslistItem) return browserslistItem(target);
+                return Object.entries(browserslistItem).flatMap(([engine, version])=>{
+                    if (Array.isArray(version)) return version;
+                    return `${engine} >= ${version}`;
+                });
+            }
+            throw new Error(`Unsupported ES version: ${syntaxItem}`);
+        }
+        return [
+            syntaxItem
+        ];
+    };
+    if (Array.isArray(syntax)) return syntax.flatMap(handleSyntaxItem);
+    return handleSyntaxItem(syntax);
+}
+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 = [
+    '.ts',
+    '.tsx',
+    '.mts',
+    '.cts'
+];
+const util_JS_EXTENSIONS = [
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs'
+];
+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 = __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>}}
+ */ function util_makePromise() {
+    let resolve, reject;
+    const promise = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        promise,
+        resolve,
+        reject
+    };
+}
+/**
+ * @param {string} filename
+ * @param {import('./cache.js').TSConfckCache} [cache]
+ * @returns {Promise<string|void>}
+ */ async function util_resolveTSConfigJson(filename, cache) {
+    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 __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.`);
+    });
+}
+/**
+ *
+ * @param {string} dir an absolute directory path
+ * @returns {boolean}  if dir path includes a node_modules segment
+ */ const util_isInNodeModules = IS_POSIX ? (dir)=>dir.includes('/node_modules/') : (dir)=>dir.match(/[/\\]node_modules[/\\]/);
+/**
+ * convert posix separator to native separator
+ *
+ * eg.
+ * windows: C:/foo/bar -> c:\foo\bar
+ * linux: /foo/bar -> /foo/bar
+ *
+ * @param {string} filename with posix separators
+ * @returns {string} filename with native separators
+ */ 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
+ *
+ * eg.
+ * windows: C:\foo\bar -> c:/foo/bar
+ * linux: /foo/bar -> /foo/bar
+ *
+ * @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, __WEBPACK_EXTERNAL_MODULE_node_path__["default"].posix.sep);
+/**
+ * converts params to native separator, resolves path and converts native back to posix
+ *
+ * needed on windows to handle posix paths in tsconfig
+ *
+ * @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 ? __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 = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(result.tsconfigFile);
+    return result.tsconfig.references.map((ref)=>{
+        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);
+    });
+}
+/**
+ * @param {string} filename
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @returns {import('./public.d.ts').TSConfckParseResult}
+ */ function util_resolveSolutionTSConfig(filename, result) {
+    const allowJs = result.tsconfig.compilerOptions?.allowJs;
+    const extensions = allowJs ? TSJS_EXTENSIONS : TS_EXTENSIONS;
+    if (result.referenced && extensions.some((ext)=>filename.endsWith(ext)) && !util_isIncluded(filename, result)) {
+        const solutionTSConfig = result.referenced.find((referenced)=>util_isIncluded(filename, referenced));
+        if (solutionTSConfig) return solutionTSConfig;
+    }
+    return result;
+}
+/**
+ *
+ * @param {string} filename
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @returns {boolean}
+ */ function util_isIncluded(filename, result) {
+    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;
+    const allowJs = result.tsconfig.compilerOptions?.allowJs;
+    const isIncluded = isGlobMatch(absoluteFilename, dir, result.tsconfig.include || (result.tsconfig.files ? [] : [
+        GLOB_ALL_PATTERN
+    ]), allowJs);
+    if (isIncluded) {
+        const isExcluded = isGlobMatch(absoluteFilename, dir, result.tsconfig.exclude || [], allowJs);
+        return !isExcluded;
+    }
+    return false;
+}
+/**
+ * test filenames agains glob patterns in tsconfig
+ *
+ * @param filename {string} posix style abolute path to filename to test
+ * @param dir {string} posix style absolute path to directory of tsconfig containing patterns
+ * @param patterns {string[]} glob patterns to match against
+ * @param allowJs {boolean} allowJs setting in tsconfig to include js extensions in checks
+ * @returns {boolean} true when at least one pattern matches filename
+ */ function isGlobMatch(filename, dir, patterns, allowJs) {
+    const extensions = allowJs ? TSJS_EXTENSIONS : TS_EXTENSIONS;
+    return patterns.some((pattern)=>{
+        // filename must end with part of pattern that comes after last wildcard
+        let lastWildcardIndex = pattern.length;
+        let hasWildcard = false;
+        for(let i = pattern.length - 1; i > -1; i--)if ('*' === pattern[i] || '?' === pattern[i]) {
+            lastWildcardIndex = i;
+            hasWildcard = true;
+            break;
+        }
+        // if pattern does not end with wildcard, filename must end with pattern after last wildcard
+        if (lastWildcardIndex < pattern.length - 1 && !filename.endsWith(pattern.slice(lastWildcardIndex + 1))) return false;
+        // if pattern ends with *, filename must end with a default extension
+        if (pattern.endsWith('*') && !extensions.some((ext)=>filename.endsWith(ext))) return false;
+        // for **/* , filename must start with the dir
+        if (pattern === GLOB_ALL_PATTERN) return filename.startsWith(`${dir}/`);
+        const resolvedPattern = resolve2posix(dir, pattern);
+        // filename must start with part of pattern that comes before first wildcard
+        let firstWildcardIndex = -1;
+        for(let i = 0; i < resolvedPattern.length; i++)if ('*' === resolvedPattern[i] || '?' === resolvedPattern[i]) {
+            firstWildcardIndex = i;
+            hasWildcard = true;
+            break;
+        }
+        if (firstWildcardIndex > 1 && !filename.startsWith(resolvedPattern.slice(0, firstWildcardIndex - 1))) return false;
+        // if no wildcard in pattern, filename must be equal to resolved pattern
+        if (!hasWildcard) return filename === resolvedPattern;
+        // complex pattern, use regex to check it
+        if (PATTERN_REGEX_CACHE.has(resolvedPattern)) return PATTERN_REGEX_CACHE.get(resolvedPattern).test(filename);
+        const regex = pattern2regex(resolvedPattern, allowJs);
+        PATTERN_REGEX_CACHE.set(resolvedPattern, regex);
+        return regex.test(filename);
+    });
+}
+/**
+ * @param {string} resolvedPattern
+ * @param {boolean} allowJs
+ * @returns {RegExp}
+ */ function pattern2regex(resolvedPattern, allowJs) {
+    let regexStr = '^';
+    for(let i = 0; i < resolvedPattern.length; i++){
+        const char = resolvedPattern[i];
+        if ('?' === char) {
+            regexStr += '[^\\/]';
+            continue;
+        }
+        if ('*' === char) {
+            if ('*' === resolvedPattern[i + 1] && '/' === resolvedPattern[i + 2]) {
+                i += 2;
+                regexStr += '(?:[^\\/]*\\/)*'; // zero or more path segments
+                continue;
+            }
+            regexStr += '[^\\/]*';
+            continue;
+        }
+        if ('/.+^${}()|[]\\'.includes(char)) regexStr += "\\";
+        regexStr += char;
+    }
+    // add known file endings if pattern ends on *
+    if (resolvedPattern.endsWith('*')) regexStr += allowJs ? TSJS_EXTENSIONS_RE_GROUP : TS_EXTENSIONS_RE_GROUP;
+    regexStr += '$';
+    return new RegExp(regexStr);
+}
+/**
+ * replace tokens like ${configDir}
+ * @param {any} tsconfig
+ * @param {string} configDir
+ * @returns {any}
+ */ function util_replaceTokens(tsconfig, configDir) {
+    return JSON.parse(JSON.stringify(tsconfig)// replace ${configDir}
+    .replaceAll(/"\${configDir}/g, `"${util_native2posix(configDir)}`));
+}
+/**
+ * find the closest tsconfig.json file
+ *
+ * @param {string} filename - path to file to find tsconfig for (absolute or relative to cwd)
+ * @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 = __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 && !__WEBPACK_EXTERNAL_MODULE_node_path__["default"].isAbsolute(options.root)) options.root = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].resolve(options.root);
+    findUp(dir, {
+        promise,
+        resolve,
+        reject
+    }, options);
+    return promise;
+}
+/**
+ *
+ * @param {string} dir
+ * @param {{promise:Promise<string|null>,resolve:(result:string|null)=>void,reject:(err:any)=>void}} madePromise
+ * @param {import('./public.d.ts').TSConfckFindOptions} [options] - options
+ */ function findUp(dir, { resolve, reject, promise }, options) {
+    const { cache, root, configName } = options ?? {};
+    if (cache) {
+        if (cache.hasConfigPath(dir, configName)) {
+            let cached;
+            try {
+                cached = cache.getConfigPath(dir, configName);
+            } catch (e) {
+                reject(e);
+                return;
+            }
+            if (cached?.then) cached.then(resolve).catch(reject);
+            else resolve(cached);
+        } else cache.setConfigPath(dir, promise, configName);
+    }
+    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 = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(dir)) === dir) resolve(null);
+            else findUp(parent, {
+                promise,
+                resolve,
+                reject
+            }, options);
+        }
+    });
+}
+/**
+ * @typedef WalkState
+ * @interface
+ * @property {string[]} files - files
+ * @property {number} calls - number of ongoing calls
+ * @property {(dir: string)=>boolean} skip - function to skip dirs
+ * @property {boolean} err - error flag
+ * @property {string[]} configNames - config file names
+ */ __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
+ https://github.com/sindresorhus/strip-bom/blob/v5.0.0/index.js
+ licensed under MIT, see ../LICENSE
+*/ /**
+ * convert content of tsconfig.json to regular json
+ *
+ * @param {string} tsconfigJson - content of tsconfig.json
+ * @returns {string} content as regular json, comments and dangling commas have been replaced with whitespace
+ */ function toJson(tsconfigJson) {
+    const stripped = stripDanglingComma(stripJsonComments(stripBom(tsconfigJson)));
+    if ('' === stripped.trim()) // only whitespace left after stripping, return empty object so that JSON.parse still works
+    return '{}';
+    return stripped;
+}
+/**
+ * replace dangling commas from pseudo-json string with single space
+ * implementation heavily inspired by strip-json-comments
+ *
+ * @param {string} pseudoJson
+ * @returns {string}
+ */ function stripDanglingComma(pseudoJson) {
+    let insideString = false;
+    let offset = 0;
+    let result = '';
+    let danglingCommaPos = null;
+    for(let i = 0; i < pseudoJson.length; i++){
+        const currentCharacter = pseudoJson[i];
+        if ('"' === currentCharacter) {
+            const escaped = isEscaped(pseudoJson, i);
+            if (!escaped) insideString = !insideString;
+        }
+        if (insideString) {
+            danglingCommaPos = null;
+            continue;
+        }
+        if (',' === currentCharacter) {
+            danglingCommaPos = i;
+            continue;
+        }
+        if (danglingCommaPos) {
+            if ('}' === currentCharacter || ']' === currentCharacter) {
+                result += pseudoJson.slice(offset, danglingCommaPos) + ' ';
+                offset = danglingCommaPos + 1;
+                danglingCommaPos = null;
+            } else if (!currentCharacter.match(/\s/)) danglingCommaPos = null;
+        }
+    }
+    return result + pseudoJson.substring(offset);
+}
+// start strip-json-comments
+/**
+ *
+ * @param {string} jsonString
+ * @param {number} quotePosition
+ * @returns {boolean}
+ */ function isEscaped(jsonString, quotePosition) {
+    let index = quotePosition - 1;
+    let backslashCount = 0;
+    while('\\' === jsonString[index]){
+        index -= 1;
+        backslashCount += 1;
+    }
+    return Boolean(backslashCount % 2);
+}
+/**
+ *
+ * @param {string} string
+ * @param {number?} start
+ * @param {number?} end
+ */ function strip(string, start, end) {
+    return string.slice(start, end).replace(/\S/g, ' ');
+}
+const singleComment = Symbol('singleComment');
+const multiComment = Symbol('multiComment');
+/**
+ * @param {string} jsonString
+ * @returns {string}
+ */ function stripJsonComments(jsonString) {
+    let isInsideString = false;
+    /** @type {false | symbol} */ let isInsideComment = false;
+    let offset = 0;
+    let result = '';
+    for(let index = 0; index < jsonString.length; index++){
+        const currentCharacter = jsonString[index];
+        const nextCharacter = jsonString[index + 1];
+        if (!isInsideComment && '"' === currentCharacter) {
+            const escaped = isEscaped(jsonString, index);
+            if (!escaped) isInsideString = !isInsideString;
+        }
+        if (!isInsideString) if (isInsideComment || currentCharacter + nextCharacter !== '//') {
+            if (isInsideComment === singleComment && currentCharacter + nextCharacter === '\r\n') {
+                index++;
+                isInsideComment = false;
+                result += strip(jsonString, offset, index);
+                offset = index;
+            } else if (isInsideComment === singleComment && '\n' === currentCharacter) {
+                isInsideComment = false;
+                result += strip(jsonString, offset, index);
+                offset = index;
+            } else if (isInsideComment || currentCharacter + nextCharacter !== '/*') {
+                if (isInsideComment === multiComment && currentCharacter + nextCharacter === '*/') {
+                    index++;
+                    isInsideComment = false;
+                    result += strip(jsonString, offset, index + 1);
+                    offset = index + 1;
+                }
+            } else {
+                result += jsonString.slice(offset, index);
+                offset = index;
+                isInsideComment = multiComment;
+                index++;
+            }
+        } else {
+            result += jsonString.slice(offset, index);
+            offset = index;
+            isInsideComment = singleComment;
+            index++;
+        }
+    }
+    return result + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+}
+// end strip-json-comments
+// start strip-bom
+/**
+ * @param {string} string
+ * @returns {string}
+ */ function stripBom(string) {
+    // Catches EFBBBF (UTF-8 BOM) because the buffer-to-string
+    // conversion translates it to FEFF (UTF-16 BOM).
+    if (0xfeff === string.charCodeAt(0)) return string.slice(1);
+    return string;
+}
+const not_found_result = {
+    tsconfigFile: null,
+    tsconfig: {}
+};
+/**
+ * parse the closest tsconfig.json file
+ *
+ * @param {string} filename - path to a tsconfig .json or a source file or directory (absolute or relative to cwd)
+ * @param {import('./public.d.ts').TSConfckParseOptions} [options] - options
+ * @returns {Promise<import('./public.d.ts').TSConfckParseResult>}
+ * @throws {TSConfckParseError}
+ */ async function parse(filename, options) {
+    /** @type {import('./cache.js').TSConfckCache} */ const cache = options?.cache;
+    if (cache?.hasParseResult(filename)) return getParsedDeep(filename, cache, options);
+    const { resolve, reject, /** @type {Promise<import('./public.d.ts').TSConfckParseResult>}*/ promise } = util_makePromise();
+    cache?.setParseResult(filename, promise, true);
+    try {
+        let tsconfigFile = await util_resolveTSConfigJson(filename, cache) || await find(filename, options);
+        if (!tsconfigFile) {
+            resolve(not_found_result);
+            return promise;
+        }
+        let result;
+        if (filename !== tsconfigFile && cache?.hasParseResult(tsconfigFile)) result = await getParsedDeep(tsconfigFile, cache, options);
+        else {
+            result = await parseFile(tsconfigFile, cache, filename === tsconfigFile);
+            await Promise.all([
+                parseExtends(result, cache),
+                parseReferences(result, options)
+            ]);
+        }
+        result.tsconfig = util_replaceTokens(result.tsconfig, __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(tsconfigFile));
+        resolve(util_resolveSolutionTSConfig(filename, result));
+    } catch (e) {
+        reject(e);
+    }
+    return promise;
+}
+/**
+ * ensure extends and references are parsed
+ *
+ * @param {string} filename - cached file
+ * @param {import('./cache.js').TSConfckCache} cache - cache
+ * @param {import('./public.d.ts').TSConfckParseOptions} options - options
+ */ async function getParsedDeep(filename, cache, options) {
+    const result = await cache.getParseResult(filename);
+    if (result.tsconfig.extends && !result.extended || result.tsconfig.references && !result.referenced) {
+        const promise = Promise.all([
+            parseExtends(result, cache),
+            parseReferences(result, options)
+        ]).then(()=>result);
+        cache.setParseResult(filename, promise, true);
+        return promise;
+    }
+    return result;
+}
+/**
+ *
+ * @param {string} tsconfigFile - path to tsconfig file
+ * @param {import('./cache.js').TSConfckCache} [cache] - cache
+ * @param {boolean} [skipCache] - skip cache
+ * @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 = __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, __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(tsconfigFile))
+        };
+    }).catch((e)=>{
+        throw new TSConfckParseError(`parsing ${tsconfigFile} failed: ${e}`, 'PARSE_FILE', tsconfigFile, e);
+    });
+    if (!skipCache && (!cache?.hasParseResult(tsconfigFile) || !cache.getParseResult(tsconfigFile)._isRootFile_)) cache?.setParseResult(tsconfigFile, promise);
+    return promise;
+}
+/**
+ * normalize to match the output of ts.parseJsonConfigFileContent
+ *
+ * @param {any} tsconfig - typescript tsconfig output
+ * @param {string} dir - directory
+ */ function normalizeTSConfig(tsconfig, dir) {
+    // set baseUrl to absolute path
+    const baseUrl = tsconfig.compilerOptions?.baseUrl;
+    if (baseUrl && !baseUrl.startsWith('${') && !__WEBPACK_EXTERNAL_MODULE_node_path__["default"].isAbsolute(baseUrl)) tsconfig.compilerOptions.baseUrl = resolve2posix(dir, baseUrl);
+    return tsconfig;
+}
+/**
+ *
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @param {import('./public.d.ts').TSConfckParseOptions} [options]
+ * @returns {Promise<void>}
+ */ async function parseReferences(result, options) {
+    if (!result.tsconfig.references) return;
+    const referencedFiles = util_resolveReferencedTSConfigFiles(result, options);
+    const referenced = await Promise.all(referencedFiles.map((file)=>parseFile(file, options?.cache)));
+    await Promise.all(referenced.map((ref)=>parseExtends(ref, options?.cache)));
+    referenced.forEach((ref)=>{
+        ref.solution = result;
+    });
+    result.referenced = referenced;
+}
+/**
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @param {import('./cache.js').TSConfckCache}[cache]
+ * @returns {Promise<void>}
+ */ async function parseExtends(result, cache) {
+    if (!result.tsconfig.extends) return;
+    // use result as first element in extended
+    // but dereference tsconfig so that mergeExtended can modify the original without affecting extended[0]
+    /** @type {import('./public.d.ts').TSConfckParseResult[]} */ const extended = [
+        {
+            tsconfigFile: result.tsconfigFile,
+            tsconfig: JSON.parse(JSON.stringify(result.tsconfig))
+        }
+    ];
+    // flatten extends graph into extended
+    let pos = 0;
+    /** @type {string[]} */ const extendsPath = [];
+    let currentBranchDepth = 0;
+    while(pos < extended.length){
+        const extending = extended[pos];
+        extendsPath.push(extending.tsconfigFile);
+        if (extending.tsconfig.extends) {
+            // keep following this branch
+            currentBranchDepth += 1;
+            /** @type {string[]} */ let resolvedExtends;
+            // reverse because typescript 5.0 treats ['a','b','c'] as c extends b extends a
+            resolvedExtends = Array.isArray(extending.tsconfig.extends) ? extending.tsconfig.extends.reverse().map((ex)=>resolveExtends(ex, extending.tsconfigFile)) : [
+                resolveExtends(extending.tsconfig.extends, extending.tsconfigFile)
+            ];
+            const circularExtends = resolvedExtends.find((tsconfigFile)=>extendsPath.includes(tsconfigFile));
+            if (circularExtends) {
+                const circle = extendsPath.concat([
+                    circularExtends
+                ]).join(' -> ');
+                throw new TSConfckParseError(`Circular dependency in "extends": ${circle}`, 'EXTENDS_CIRCULAR', result.tsconfigFile);
+            }
+            // add new extends to the list directly after current
+            extended.splice(pos + 1, 0, ...await Promise.all(resolvedExtends.map((file)=>parseFile(file, cache))));
+        } else {
+            // reached a leaf, backtrack to the last branching point and continue
+            extendsPath.splice(-currentBranchDepth);
+            currentBranchDepth = 0;
+        }
+        pos += 1;
+    }
+    result.extended = extended;
+    // skip first as it is the original config
+    for (const ext of result.extended.slice(1))extendTSConfig(result, ext);
+}
+/**
+ *
+ * @param {string} extended
+ * @param {string} from
+ * @returns {string}
+ */ function resolveExtends(extended, from) {
+    if ('..' === extended) // see #149
+    extended = '../tsconfig.json';
+    const req = (0, __WEBPACK_EXTERNAL_MODULE_module__.createRequire)(from);
+    let error;
+    try {
+        return req.resolve(extended);
+    } catch (e) {
+        error = e;
+    }
+    if ('.' !== extended[0] && !__WEBPACK_EXTERNAL_MODULE_node_path__["default"].isAbsolute(extended)) try {
+        return req.resolve(`${extended}/tsconfig.json`);
+    } catch (e) {
+        error = e;
+    }
+    throw new TSConfckParseError(`failed to resolve "extends":"${extended}" in ${from}`, 'EXTENDS_RESOLVE', from, error);
+}
+// references, extends and custom keys are not carried over
+const EXTENDABLE_KEYS = [
+    'compilerOptions',
+    'files',
+    'include',
+    'exclude',
+    'watchOptions',
+    'compileOnSave',
+    'typeAcquisition',
+    'buildOptions'
+];
+/**
+ *
+ * @param {import('./public.d.ts').TSConfckParseResult} extending
+ * @param {import('./public.d.ts').TSConfckParseResult} extended
+ * @returns void
+ */ function extendTSConfig(extending, extended) {
+    const extendingConfig = extending.tsconfig;
+    const extendedConfig = extended.tsconfig;
+    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)){
+            if (!Object.prototype.hasOwnProperty.call(extendingConfig.compilerOptions, option)) extendingConfig.compilerOptions[option] = rebaseRelative(option, extendedConfig.compilerOptions[option], relativePath);
+        }
+    } else if (void 0 === extendingConfig[key]) {
+        if ('watchOptions' === key) {
+            extendingConfig.watchOptions = {};
+            for (const option of Object.keys(extendedConfig.watchOptions))extendingConfig.watchOptions[option] = rebaseRelative(option, extendedConfig.watchOptions[option], relativePath);
+        } else extendingConfig[key] = rebaseRelative(key, extendedConfig[key], relativePath);
+    }
+}
+const REBASE_KEYS = [
+    // root
+    'files',
+    'include',
+    'exclude',
+    // compilerOptions
+    'baseUrl',
+    'rootDir',
+    'rootDirs',
+    'typeRoots',
+    'outDir',
+    'outFile',
+    'declarationDir',
+    // watchOptions
+    'excludeDirectories',
+    'excludeFiles'
+];
+/** @typedef {string | string[]} PathValue */ /**
+ *
+ * @param {string} key
+ * @param {PathValue} value
+ * @param {string} prependPath
+ * @returns {PathValue}
+ */ function rebaseRelative(key, value, prependPath) {
+    if (!REBASE_KEYS.includes(key)) return value;
+    if (Array.isArray(value)) return value.map((x)=>rebasePath(x, prependPath));
+    return rebasePath(value, prependPath);
+}
+/**
+ *
+ * @param {string} value
+ * @param {string} prependPath
+ * @returns {string}
+ */ function rebasePath(value, prependPath) {
+    if (__WEBPACK_EXTERNAL_MODULE_node_path__["default"].isAbsolute(value) || value.startsWith('${configDir}')) return value;
+    // relative paths use posix syntax in tsconfig
+    return __WEBPACK_EXTERNAL_MODULE_node_path__["default"].posix.normalize(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].posix.join(prependPath, value));
+}
+class TSConfckParseError extends Error {
+    /**
+	 * error code
+	 * @type {string}
+	 */ code;
+    /**
+	 * error cause
+	 * @type { Error | undefined}
+	 */ cause;
+    /**
+	 * absolute path of tsconfig file where the error happened
+	 * @type {string}
+	 */ tsconfigFile;
+    /**
+	 *
+	 * @param {string} message - error message
+	 * @param {string} code - error code
+	 * @param {string} tsconfigFile - path to tsconfig file
+	 * @param {Error?} cause - cause of this error
+	 */ constructor(message, code, tsconfigFile, cause){
+        super(message);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, TSConfckParseError.prototype);
+        this.name = TSConfckParseError.name;
+        this.code = code;
+        this.cause = cause;
+        this.tsconfigFile = tsconfigFile;
+    }
+}
+/**
+ *
+ * @param {any} tsconfig
+ * @param {string} tsconfigFile
+ */ function applyDefaults(tsconfig, tsconfigFile) {
+    if (isJSConfig(tsconfigFile)) tsconfig.compilerOptions = {
+        ...DEFAULT_JSCONFIG_COMPILER_OPTIONS,
+        ...tsconfig.compilerOptions
+    };
+}
+const DEFAULT_JSCONFIG_COMPILER_OPTIONS = {
+    allowJs: true,
+    maxNodeModuleJsDepth: 2,
+    allowSyntheticDefaultImports: true,
+    skipLibCheck: true,
+    noEmit: true
+};
+/**
+ * @param {string} configFileName
+ */ function isJSConfig(configFileName) {
+    return 'jsconfig.json' === __WEBPACK_EXTERNAL_MODULE_node_path__["default"].basename(configFileName);
+}
+async function loadTsconfig(root, tsconfigPath = 'tsconfig.json') {
+    const tsconfigFileName = await find((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(root, tsconfigPath), {
+        root,
+        configName: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.basename)(tsconfigPath)
+    });
+    if (tsconfigFileName) {
+        const { tsconfig } = await parse(tsconfigFileName);
+        return tsconfig;
+    }
+    return {};
+}
+function defineConfig(config) {
+    return config;
+}
+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, __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, __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, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.loadConfig)({
+        cwd: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(configFilePath),
+        path: configFilePath,
+        envMode
+    });
+    return content;
+}
+const composeExternalsWarnConfig = (format, ...externalsArray)=>{
+    if ('esm' !== format) return {};
+    const externals = [];
+    for (const e of externalsArray.filter(Boolean))if (Array.isArray(e)) externals.push(...e);
+    else // @ts-ignore
+    externals.push(e);
+    // Match logic is derived from https://github.com/webpack/webpack/blob/94aba382eccf3de1004d235045d4462918dfdbb7/lib/ExternalModuleFactoryPlugin.js#L166-L293.
+    const matchUserExternals = (externals, request, callback)=>{
+        if ('string' == typeof externals) {
+            if (externals === request) {
+                callback(true);
+                return;
+            }
+        } else if (Array.isArray(externals)) {
+            let i = 0;
+            const next = ()=>{
+                let asyncFlag;
+                const handleExternalsAndCallback = (matched)=>{
+                    if (!matched) {
+                        if (asyncFlag) {
+                            asyncFlag = false;
+                            return;
+                        }
+                        return next();
+                    }
+                    callback(matched);
+                };
+                do {
+                    asyncFlag = true;
+                    if (i >= externals.length) return callback();
+                    matchUserExternals(externals[i++], request, handleExternalsAndCallback);
+                }while (!asyncFlag);
+                asyncFlag = false;
+            };
+            next();
+            return;
+        } else if (externals instanceof RegExp) {
+            if (externals.test(request)) {
+                callback(true);
+                return;
+            }
+        } else if ('function' == typeof externals) ;
+        else if ('object' == typeof externals) {
+            if (Object.prototype.hasOwnProperty.call(externals, request)) {
+                callback(true);
+                return;
+            }
+        }
+        callback();
+    };
+    return {
+        output: {
+            externals: [
+                ({ request, dependencyType, contextInfo }, callback)=>{
+                    let externalized = false;
+                    const _callback = (matched)=>{
+                        if (matched) externalized = true;
+                    };
+                    if (contextInfo.issuer && 'commonjs' === dependencyType) {
+                        matchUserExternals(externals, request, _callback);
+                        if (externalized) __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn(composeModuleImportWarn(request));
+                    }
+                    callback();
+                }
+            ]
+        }
+    };
+};
+const composeAutoExternalConfig = (options)=>{
+    const { autoExternal, pkgJson, userExternals } = options;
+    if (!autoExternal) return {};
+    if (!pkgJson) {
+        __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn('autoExternal configuration will not be applied due to read package.json failed');
+        return {};
+    }
+    const externalOptions = {
+        dependencies: true,
+        peerDependencies: true,
+        devDependencies: false,
+        ...true === autoExternal ? {} : autoExternal
+    };
+    // User externals configuration has higher priority than autoExternal
+    // eg: autoExternal: ['react'], user: output: { externals: { react: 'react-1' } }
+    // Only handle the case where the externals type is object, string / string[] does not need to be processed, other types are too complex.
+    const userExternalKeys = userExternals && isObject(userExternals) ? Object.keys(userExternals) : [];
+    const externals = [
+        'dependencies',
+        'peerDependencies',
+        'devDependencies'
+    ].reduce((prev, type)=>{
+        if (externalOptions[type]) return pkgJson[type] ? prev.concat(Object.keys(pkgJson[type])) : prev;
+        return prev;
+    }, []).filter((name)=>!userExternalKeys.includes(name));
+    const uniqueExternals = Array.from(new Set(externals));
+    return externals.length ? {
+        output: {
+            externals: [
+                // Exclude dependencies, e.g. `react`, `react/jsx-runtime`
+                ...uniqueExternals.map((dep)=>new RegExp(`^${dep}($|\\/|\\\\)`)),
+                ...uniqueExternals
+            ]
+        }
+    } : {};
+};
+function composeMinifyConfig(minify) {
+    if (void 0 !== minify) // User's minify configuration will be merged afterwards.
+    return {};
+    // When minify is not specified, Rslib will use a sane default for minify options.
+    // The default options will only perform dead code elimination and unused code elimination.
+    return {
+        output: {
+            minify: {
+                js: true,
+                css: false,
+                jsOptions: {
+                    minimizerOptions: {
+                        mangle: false,
+                        minify: false,
+                        compress: {
+                            defaults: false,
+                            unused: true,
+                            dead_code: true,
+                            toplevel: true
+                        },
+                        format: {
+                            comments: 'all'
+                        }
+                    }
+                }
+            }
+        }
+    };
+}
+function composeBannerFooterConfig(banner, footer) {
+    const bannerConfig = pick(banner, [
+        'js',
+        'css'
+    ]);
+    const footerConfig = pick(footer, [
+        'js',
+        'css'
+    ]);
+    if (isEmptyObject(bannerConfig) && isEmptyObject(footerConfig)) return {};
+    const plugins = [];
+    if (!isEmptyObject(bannerConfig)) {
+        if (bannerConfig.js) plugins.push(new __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.BannerPlugin({
+            banner: bannerConfig.js,
+            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 __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.BannerPlugin({
+            banner: bannerConfig.css,
+            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 __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.BannerPlugin({
+            banner: footerConfig.js,
+            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 __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.BannerPlugin({
+            banner: footerConfig.css,
+            stage: __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
+            raw: true,
+            footer: true,
+            include: /\.(css)$/
+        }));
+    }
+    return {
+        tools: {
+            rspack: {
+                plugins
+            }
+        }
+    };
+}
+function composeDecoratorsConfig(compilerOptions, version) {
+    if (version || !compilerOptions?.experimentalDecorators) return {};
+    return {
+        source: {
+            decorators: {
+                version: 'legacy'
+            }
+        }
+    };
+}
+async function createConstantRsbuildConfig() {
+    return (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.defineConfig)({
+        mode: 'production',
+        dev: {
+            progressBar: false
+        },
+        tools: {
+            htmlPlugin: false,
+            rspack: {
+                optimization: {
+                    moduleIds: 'named',
+                    nodeEnv: false
+                },
+                experiments: {
+                    rspackFuture: {
+                        bundlerInfo: {
+                            force: false
+                        }
+                    }
+                },
+                // TypeScript-specific behavior: if the extension is ".js" or ".jsx", try replacing it with ".ts" or ".tsx"
+                // see https://github.com/web-infra-dev/rslib/issues/41
+                resolve: {
+                    extensionAlias: {
+                        '.js': [
+                            '.ts',
+                            '.tsx',
+                            '.js',
+                            '.jsx'
+                        ],
+                        '.jsx': [
+                            '.tsx',
+                            '.jsx'
+                        ],
+                        '.mjs': [
+                            '.mts',
+                            '.mjs'
+                        ],
+                        '.cjs': [
+                            '.cts',
+                            '.cjs'
+                        ]
+                    }
+                }
+            }
+        },
+        output: {
+            filenameHash: false,
+            distPath: {
+                js: './'
+            }
+        }
+    });
+}
+const composeFormatConfig = (format, pkgJson)=>{
+    switch(format){
+        case 'esm':
+            return {
+                tools: {
+                    rspack: {
+                        output: {
+                            module: true,
+                            chunkFormat: 'module',
+                            library: {
+                                type: 'modern-module'
+                            }
+                        },
+                        module: {
+                            parser: {
+                                javascript: {
+                                    importMeta: false
+                                }
+                            }
+                        },
+                        optimization: {
+                            concatenateModules: true
+                        },
+                        experiments: {
+                            outputModule: true
+                        }
+                    }
+                }
+            };
+        case 'cjs':
+            return {
+                plugins: [
+                    pluginCjsShim()
+                ],
+                tools: {
+                    rspack: {
+                        module: {
+                            parser: {
+                                javascript: {
+                                    importMeta: false
+                                }
+                            }
+                        },
+                        output: {
+                            iife: false,
+                            chunkFormat: 'commonjs',
+                            library: {
+                                type: 'commonjs'
+                            }
+                        }
+                    }
+                }
+            };
+        case 'umd':
+            return {
+                tools: {
+                    rspack: {
+                        module: {
+                            parser: {
+                                javascript: {
+                                    importMeta: false
+                                }
+                            }
+                        },
+                        output: {
+                            library: {
+                                type: 'umd'
+                            }
+                        }
+                    }
+                }
+            };
+        case 'mf':
+            return {
+                tools: {
+                    rspack: {
+                        output: {
+                            uniqueName: pkgJson.name
+                        }
+                    }
+                }
+            };
+        default:
+            throw new Error(`Unsupported format: ${format}`);
+    }
+};
+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
+    // should to be unified and merged together in the future.
+    const externalsTypeMap = {
+        esm: 'module-import',
+        cjs: 'commonjs',
+        umd: 'umd'
+    };
+    switch(format){
+        case 'esm':
+        case 'cjs':
+        case 'umd':
+            return {
+                output: externals ? {
+                    externals
+                } : {},
+                tools: {
+                    rspack: {
+                        externalsType: externalsTypeMap[format]
+                    }
+                }
+            };
+        case 'mf':
+            return {
+                output: externals ? {
+                    externals
+                } : {}
+            };
+        default:
+            throw new Error(`Unsupported format: ${format}`);
+    }
+};
+const composeAutoExtensionConfig = (config, autoExtension, pkgJson)=>{
+    const { jsExtension, dtsExtension } = getDefaultExtension({
+        format: config.format,
+        pkgJson,
+        autoExtension
+    });
+    return {
+        config: {
+            output: {
+                filename: {
+                    js: `[name]${jsExtension}`,
+                    ...config.output?.filename
+                }
+            }
+        },
+        jsExtension,
+        dtsExtension
+    };
+};
+const composeSyntaxConfig = (syntax, target)=>{
+    // Defaults to ESNext, Rslib will assume all of the latest JavaScript and CSS features are supported.
+    if (syntax) return {
+        tools: {
+            rspack: (config)=>{
+                config.target = transformSyntaxToRspackTarget(syntax);
+            }
+        },
+        output: {
+            overrideBrowserslist: transformSyntaxToBrowserslist(syntax, target)
+        }
+    };
+    return {
+        tools: {
+            rspack: (config)=>{
+                config.target = [
+                    'es2022'
+                ];
+                return config;
+            }
+        },
+        output: {
+            // If `syntax` is not defined, Rslib will try to determine by the `target`, with the last version of the target.
+            overrideBrowserslist: ESX_TO_BROWSERSLIST.esnext(target)
+        }
+    };
+};
+const composeEntryConfig = async (entries, bundle, root)=>{
+    if (!entries) return {};
+    if (false !== bundle) return {
+        source: {
+            entry: entries
+        }
+    };
+    // In bundleless mode, resolve glob patterns and convert them to entry object.
+    const resolvedEntries = {};
+    for (const key of Object.keys(entries)){
+        const entry = entries[key];
+        // Entries in bundleless mode could be:
+        // 1. A string of glob pattern: { entry: { index: 'src/*.ts' } }
+        // 2. An array of glob patterns: { entry: { index: ['src/*.ts', 'src/*.tsx'] } }
+        // Not supported for now: entry description object
+        const entryFiles = Array.isArray(entry) ? entry : 'string' == typeof entry ? [
+            entry
+        ] : 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 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 } = __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 = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(dir, name);
+            resolvedEntries[entryFileName] = file;
+        }
+    }
+    return {
+        source: {
+            entry: resolvedEntries
+        }
+    };
+};
+const composeBundleConfig = (jsExtension, bundle = true)=>{
+    if (bundle) return {};
+    return {
+        output: {
+            externals: [
+                (data, callback)=>{
+                    // Issuer is not empty string when the module is imported by another module.
+                    // Prevent from externalizing entry modules here.
+                    if (data.contextInfo.issuer) {
+                        // Node.js ECMAScript module loader does no extension searching.
+                        // Add a file extension according to autoExtension config
+                        // when data.request is a relative path and do not have an extension.
+                        // If data.request already have an extension, we replace it with new extension
+                        // 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]) {
+                            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();
+                }
+            ]
+        }
+    };
+};
+const composeDtsConfig = async (libConfig, dtsExtension)=>{
+    const { dts, bundle, output, autoExternal, banner, footer } = libConfig;
+    if (false === dts || void 0 === dts) return {};
+    const { pluginDts } = await import("rsbuild-plugin-dts");
+    return {
+        plugins: [
+            pluginDts({
+                bundle: dts?.bundle ?? bundle,
+                distPath: dts?.distPath ?? output?.distPath?.root ?? './dist',
+                abortOnError: dts?.abortOnError ?? true,
+                dtsExtension,
+                autoExternal,
+                banner: banner?.dts,
+                footer: footer?.dts
+            })
+        ]
+    };
+};
+const composeTargetConfig = (target = 'web')=>{
+    switch(target){
+        case 'web':
+            return {
+                tools: {
+                    rspack: {
+                        target: [
+                            'web'
+                        ],
+                        output: {
+                            chunkLoading: 'import',
+                            workerChunkLoading: 'import',
+                            wasmLoading: 'fetch'
+                        }
+                    }
+                }
+            };
+        case 'node':
+            return {
+                tools: {
+                    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'
+                        }
+                    }
+                },
+                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.
+                    // https://github.com/webpack/webpack/blob/dd44b206a9c50f4b4cb4d134e1a0bd0387b159a3/lib/node/NodeTargetPlugin.js#L81
+                    externals: nodeBuiltInModules,
+                    target: 'node'
+                }
+            };
+        // TODO: Support `neutral` target, however Rsbuild don't list it as an option in the target field.
+        // case 'neutral':
+        //   return {
+        //     tools: {
+        //       rspack: {
+        //         target: ['web', 'node'],
+        //       },
+        //     },
+        //   };
+        default:
+            throw new Error(`Unsupported platform: ${target}`);
+    }
+};
+const composeExternalHelpersConfig = (externalHelpers, pkgJson)=>{
+    let defaultConfig = {
+        tools: {
+            swc: {
+                jsc: {
+                    externalHelpers: false
+                }
+            }
+        }
+    };
+    if (externalHelpers) {
+        const deps = [
+            ...Object.keys(pkgJson?.dependencies ?? []),
+            ...Object.keys(pkgJson?.devDependencies ?? [])
+        ];
+        if (!deps.includes(SWC_HELPERS)) {
+            __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, {
+            output: {
+                externals: new RegExp(`^${SWC_HELPERS}($|\\/|\\\\)`)
+            }
+        });
+        defaultConfig.tools.swc.jsc.externalHelpers = true;
+    }
+    return defaultConfig;
+};
+async function composeLibRsbuildConfig(config, 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;
+    const formatConfig = composeFormatConfig(format, pkgJson);
+    const externalHelpersConfig = composeExternalHelpersConfig(externalHelpers, pkgJson);
+    const externalsConfig = composeExternalsConfig(format, config.output?.externals);
+    const { config: autoExtensionConfig, jsExtension, dtsExtension } = composeAutoExtensionConfig(config, autoExtension, pkgJson);
+    const bundleConfig = composeBundleConfig(jsExtension, config.bundle);
+    const targetConfig = composeTargetConfig(config.output?.target);
+    const syntaxConfig = composeSyntaxConfig(config?.syntax, config.output?.target);
+    const autoExternalConfig = composeAutoExternalConfig({
+        autoExternal,
+        pkgJson,
+        userExternals: config.output?.externals
+    });
+    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, __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();
+    const configPath = path ?? rslibConfig._privateMeta?.configFilePath;
+    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, __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);
+        // Reset certain fields because they will be completely overridden by the upcoming merge.
+        // We don't want to retain them in the final configuration.
+        // The reset process should occur after merging the library configuration.
+        userConfig.source ??= {};
+        userConfig.source.entry = {};
+        // Already manually sort and merge the externals configuration.
+        userConfig.output ??= {};
+        delete userConfig.output.externals;
+        return {
+            format: libConfig.format,
+            // The merge order represents the priority of the configuration
+            // The priorities from high to low are as follows:
+            // 1 - userConfig: users can configure any Rsbuild and Rspack config
+            // 2 - libRsbuildConfig: the configuration that we compose from Rslib unique config and userConfig from 1
+            // 3 - constantRsbuildConfig: the built-in best practice Rsbuild configuration we provide in Rslib
+            // 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, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.mergeRsbuildConfig)(constantRsbuildConfig, libRsbuildConfig, omit(userConfig, [
+                'bundle',
+                'format',
+                'autoExtension',
+                'autoExternal',
+                'syntax',
+                'externalHelpers',
+                'banner',
+                'footer',
+                'dts'
+            ]))
+        };
+    });
+    const composedRsbuildConfig = await Promise.all(libConfigPromises);
+    return composedRsbuildConfig;
+}
+async function initRsbuild(rslibConfig) {
+    const rsbuildConfigObject = await composeCreateRsbuildConfig(rslibConfig);
+    const environments = {};
+    const formatCount = rsbuildConfigObject.reduce((acc, { format })=>{
+        acc[format] = (acc[format] ?? 0) + 1;
+        return acc;
+    }, {});
+    const formatIndex = {
+        esm: 0,
+        cjs: 0,
+        umd: 0,
+        mf: 0
+    };
+    for (const { format, config } of rsbuildConfigObject){
+        const currentFormatCount = formatCount[format];
+        const currentFormatIndex = formatIndex[format]++;
+        environments[1 === currentFormatCount ? format : `${format}${currentFormatIndex}`] = config;
+    }
+    return (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.createRsbuild)({
+        rsbuildConfig: {
+            environments
+        }
+    });
+}
+async function build(config, options) {
+    const rsbuildInstance = await initRsbuild(config);
+    await rsbuildInstance.build({
+        watch: options?.watch
+    });
+    return rsbuildInstance;
+}
+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() {
+    __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.name('rslib').usage('<command> [options]').version("0.0.7");
+    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
+    ].forEach(applyCommonOptions);
+    buildCommand.option('-w --watch', 'turn on watch mode, watch for changes and rebuild').description('build the library for production').action(async (options)=>{
+        try {
+            const rslibConfig = await loadConfig({
+                path: options.config,
+                envMode: options.envMode
+            });
+            await build(rslibConfig, options);
+        } catch (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);
+        }
+    });
+    inspectCommand.description('inspect the Rslib / Rsbuild / Rspack configs').option('--env <env>', 'specify env mode', 'development').option('--output <output>', 'specify inspect content output path', './').option('--verbose', 'show full function definitions in output').action(async (options)=>{
+        try {
+            // TODO: inspect should output Rslib's config
+            const rslibConfig = await loadConfig({
+                path: options.config,
+                envMode: options.envMode
+            });
+            const rsbuildInstance = await initRsbuild(rslibConfig);
+            await rsbuildInstance.inspectConfig({
+                mode: options.mode,
+                verbose: options.verbose,
+                outputPath: options.output,
+                writeToDisk: true
+            });
+        } catch (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);
+        }
+    });
+    __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.parse();
+}
+const src_version = "0.0.7";
+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 };