@rslib/core 0.0.5 → 0.0.6

package/dist/index.js

@@ -1,6 +1,4 @@
-import * as __WEBPACK_EXTERNAL_MODULE_process__ from "process";
-import * as __WEBPACK_EXTERNAL_MODULE_os__ from "os";
-import * as __WEBPACK_EXTERNAL_MODULE_tty__ from "tty";
+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";
@@ -8,281 +6,12 @@ import * as __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__ from "../c
 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";
-var __webpack_modules__ = {
-    "rsbuild-plugin-dts": function(module) {
-        module.exports = import("rsbuild-plugin-dts");
-    }
-};
-/************************************************************************/ // The module cache
-var __webpack_module_cache__ = {};
-// The require function
-function __webpack_require__(moduleId) {
-    // Check if module is in cache
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    // Create a new module (and put it into the cache)
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    // Execute the module function
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    // Return the exports of the module
-    return module.exports;
-} /************************************************************************/ 
-var external_process_namespaceObject = __WEBPACK_EXTERNAL_MODULE_process__;
-var external_os_namespaceObject = __WEBPACK_EXTERNAL_MODULE_os__;
-var external_tty_namespaceObject = __WEBPACK_EXTERNAL_MODULE_tty__;
-// node_modules/.pnpm/supports-color@9.4.0/node_modules/supports-color/index.js
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : external_process_namespaceObject["default"].argv) {
-    const prefix = flag.startsWith("-") ? "" : 1 === flag.length ? "-" : "--";
-    const position = argv.indexOf(prefix + flag);
-    const terminatorPosition = argv.indexOf("--");
-    return -1 !== position && (-1 === terminatorPosition || position < terminatorPosition);
-}
-var { env } = external_process_namespaceObject["default"];
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
-else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
-function envForceColor() {
-    if ("FORCE_COLOR" in env) {
-        if ("true" === env.FORCE_COLOR) return 1;
-        if ("false" === env.FORCE_COLOR) return 0;
-        return 0 === env.FORCE_COLOR.length ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-    }
-}
-function translateLevel(level) {
-    if (0 === level) return false;
-    return {
-        level,
-        hasBasic: true,
-        has256: level >= 2,
-        has16m: level >= 3
-    };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-    const noFlagForceColor = envForceColor();
-    if (void 0 !== noFlagForceColor) flagForceColor = noFlagForceColor;
-    const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-    if (0 === forceColor) return 0;
-    if (sniffFlags) {
-        if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
-        if (hasFlag("color=256")) return 2;
-    }
-    if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
-    if (haveStream && !streamIsTTY && void 0 === forceColor) return 0;
-    const min = forceColor || 0;
-    if ("dumb" === env.TERM) return min;
-    if ("win32" === external_process_namespaceObject["default"].platform) {
-        const osRelease = external_os_namespaceObject["default"].release().split(".");
-        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
-        return 1;
-    }
-    if ("CI" in env) {
-        if ("GITHUB_ACTIONS" in env || "GITEA_ACTIONS" in env) return 3;
-        if ([
-            "TRAVIS",
-            "CIRCLECI",
-            "APPVEYOR",
-            "GITLAB_CI",
-            "BUILDKITE",
-            "DRONE"
-        ].some((sign)=>sign in env) || "codeship" === env.CI_NAME) return 1;
-        return min;
-    }
-    if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-    if ("truecolor" === env.COLORTERM) return 3;
-    if ("xterm-kitty" === env.TERM) return 3;
-    if ("TERM_PROGRAM" in env) {
-        const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-        switch(env.TERM_PROGRAM){
-            case "iTerm.app":
-                return version >= 3 ? 3 : 2;
-            case "Apple_Terminal":
-                return 2;
-        }
-    }
-    if (/-256(color)?$/i.test(env.TERM)) return 2;
-    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
-    if ("COLORTERM" in env) return 1;
-    return min;
-}
-function createSupportsColor(stream, options = {}) {
-    const level = _supportsColor(stream, {
-        streamIsTTY: stream && stream.isTTY,
-        ...options
-    });
-    return translateLevel(level);
-}
-var supportsColor = {
-    stdout: createSupportsColor({
-        isTTY: external_tty_namespaceObject["default"].isatty(1)
-    }),
-    stderr: createSupportsColor({
-        isTTY: external_tty_namespaceObject["default"].isatty(2)
-    })
-};
-var supports_color_default = supportsColor;
-// src/utils.ts
-var colorLevel = supports_color_default.stdout ? supports_color_default.stdout.level : 0;
-var errorStackRegExp = /at\s.*:\d+:\d+[\s\)]*$/;
-var anonymousErrorStackRegExp = /at\s.*\(<anonymous>\)$/;
-var isErrorStackMessage = (message)=>errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message);
-// src/color.ts
-var formatter = (open, close, replace = open)=>colorLevel >= 2 ? (input)=>{
-        let string = "" + input;
-        let index = string.indexOf(close, open.length);
-        return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-    } : String;
-var replaceClose = (string, close, replace, index)=>{
-    let start = string.substring(0, index) + replace;
-    let end = string.substring(index + close.length);
-    let nextIndex = end.indexOf(close);
-    return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
-};
-var bold = formatter("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m");
-var red = formatter("\x1B[31m", "\x1B[39m");
-var green = formatter("\x1B[32m", "\x1B[39m");
-var yellow = formatter("\x1B[33m", "\x1B[39m");
-var magenta = formatter("\x1B[35m", "\x1B[39m");
-var cyan = formatter("\x1B[36m", "\x1B[39m");
-var gray = formatter("\x1B[90m", "\x1B[39m");
-// src/gradient.ts
-var startColor = [
-    189,
-    255,
-    243
-];
-var endColor = [
-    74,
-    194,
-    154
-];
-var isWord = (char)=>!/[\s\n]/.test(char);
-var gradient = (message)=>{
-    if (colorLevel < 3) return 2 === colorLevel ? bold(cyan(message)) : message;
-    let chars = [
-        ...message
-    ];
-    let steps = chars.filter(isWord).length;
-    let r = startColor[0];
-    let g = startColor[1];
-    let b = startColor[2];
-    let rStep = (endColor[0] - r) / steps;
-    let gStep = (endColor[1] - g) / steps;
-    let bStep = (endColor[2] - b) / steps;
-    let output = "";
-    for (let char of chars){
-        if (isWord(char)) {
-            r += rStep;
-            g += gStep;
-            b += bStep;
-        }
-        output += `\x1B[38;2;${Math.round(r)};${Math.round(g)};${Math.round(b)}m${char}\x1B[39m`;
-    }
-    return bold(output);
-};
-// src/constants.ts
-var LOG_LEVEL = {
-    error: 0,
-    warn: 1,
-    info: 2,
-    log: 3,
-    verbose: 4
-};
-var LOG_TYPES = {
-    // Level error
-    error: {
-        label: "error",
-        level: "error",
-        color: red
-    },
-    // Level warn
-    warn: {
-        label: "warn",
-        level: "warn",
-        color: yellow
-    },
-    // Level info
-    info: {
-        label: "info",
-        level: "info",
-        color: cyan
-    },
-    start: {
-        label: "start",
-        level: "info",
-        color: cyan
-    },
-    ready: {
-        label: "ready",
-        level: "info",
-        color: green
-    },
-    success: {
-        label: "success",
-        level: "info",
-        color: green
-    },
-    // Level log
-    log: {
-        level: "log"
-    },
-    // Level debug
-    debug: {
-        label: "debug",
-        level: "verbose",
-        color: magenta
-    }
-};
-// src/createLogger.ts
-var createLogger = (options = {})=>{
-    let maxLevel = options.level || "log";
-    let log = (type, message, ...args)=>{
-        if (LOG_LEVEL[LOG_TYPES[type].level] > LOG_LEVEL[maxLevel]) return;
-        if (null == message) return console.log();
-        let logType = LOG_TYPES[type];
-        let label = "";
-        let text = "";
-        if ("label" in logType) {
-            label = (logType.label || "").padEnd(7);
-            label = bold(logType.color ? logType.color(label) : label);
-        }
-        if (message instanceof Error) {
-            if (message.stack) {
-                let [name, ...rest] = message.stack.split("\n");
-                if (name.startsWith("Error: ")) name = name.slice(7);
-                text = `${name}
-${gray(rest.join("\n"))}`;
-            } else text = message.message;
-        } else if ("error" === logType.level && "string" == typeof message) {
-            let lines = message.split("\n");
-            text = lines.map((line)=>isErrorStackMessage(line) ? gray(line) : line).join("\n");
-        } else text = `${message}`;
-        console.log(label.length ? `${label} ${text}` : text, ...args);
-    };
-    let logger2 = {
-        greet: (message)=>log("log", gradient(message))
-    };
-    Object.keys(LOG_TYPES).forEach((key)=>{
-        logger2[key] = (...args)=>log(key, ...args);
-    });
-    Object.defineProperty(logger2, "level", {
-        get: ()=>maxLevel,
-        set (val) {
-            maxLevel = val;
-        }
-    });
-    logger2.override = (customLogger)=>{
-        Object.assign(logger2, customLogger);
-    };
-    return logger2;
-};
-// src/index.ts
-var dist_logger = createLogger();
+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 index_js_namespaceObject = __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__;
+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
@@ -369,13 +98,13 @@ async function calcLongestCommonPath(absPaths) {
 const readPackageJson = (rootPath)=>{
     const pkgJsonPath = external_node_path_namespaceObject["default"].join(rootPath, './package.json');
     if (!external_node_fs_namespaceObject["default"].existsSync(pkgJsonPath)) {
-        dist_logger.warn(`package.json does not exist in the ${rootPath} directory`);
+        index_js_namespaceObject.logger.warn(`package.json does not exist in the ${rootPath} directory`);
         return;
     }
     try {
         return JSON.parse(external_node_fs_namespaceObject["default"].readFileSync(pkgJsonPath, 'utf8'));
     } catch (err) {
-        dist_logger.warn(`Failed to parse ${pkgJsonPath}, it might not be valid JSON`);
+        index_js_namespaceObject.logger.warn(`Failed to parse ${pkgJsonPath}, it might not be valid JSON`);
         return;
     }
 };
@@ -394,15 +123,22 @@ function omit(obj, keys) {
     }, {});
 }
 // setup the logger level
-if (process.env.DEBUG) dist_logger.level = 'verbose';
-function initNodeEnv() {}
+if (process.env.DEBUG) index_js_namespaceObject.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();
-    dist_logger.greet(`  Rslib v0.0.5\n`);
+    index_js_namespaceObject.logger.greet(`  Rslib v0.0.6\n`);
 }
 var commander_index_js_namespaceObject = __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__;
 var core_namespaceObject = __WEBPACK_EXTERNAL_MODULE__rsbuild_core__;
@@ -426,7 +162,7 @@ const getDefaultExtension = (options)=>{
         dtsExtension
     };
     if (!pkgJson) {
-        dist_logger.warn('autoExtension configuration will not be applied due to read package.json failed');
+        index_js_namespaceObject.logger.warn('autoExtension configuration will not be applied due to read package.json failed');
         return {
             jsExtension,
             dtsExtension
@@ -447,6 +183,30 @@ const getDefaultExtension = (options)=>{
         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;
+};
 /**
  * The esX to browserslist mapping is transformed from esbuild:
  * https://github.com/evanw/esbuild/blob/main/internal/compat/js_table.go
@@ -551,8 +311,8 @@ const getDefaultExtension = (options)=>{
         Opera: '62.0.0',
         Safari: '13.1.0'
     },
-    es2024: {},
-    esnext: {},
+    es2024: calcEsnextBrowserslistByTarget,
+    esnext: calcEsnextBrowserslistByTarget,
     es5: {
         Chrome: '5.0.0',
         Edge: '12.0.0',
@@ -564,13 +324,18 @@ const getDefaultExtension = (options)=>{
         Safari: '3.1.0'
     }
 };
-const transformSyntaxToBrowserslist = (syntax)=>{
+function transformSyntaxToBrowserslist(syntax, target) {
     const handleSyntaxItem = (syntaxItem)=>{
-        if ('string' == typeof syntaxItem && syntaxItem.toLowerCase().startsWith('es')) {
-            if (syntaxItem.toLowerCase() in ESX_TO_BROWSERSLIST) return Object.entries(ESX_TO_BROWSERSLIST[syntaxItem]).flatMap(([engine, version])=>{
-                if (Array.isArray(version)) return version;
-                return `${engine} >= ${version}`;
-            });
+        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 [
@@ -579,7 +344,721 @@ const transformSyntaxToBrowserslist = (syntax)=>{
     };
     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');
+/** @type {Map<string,RegExp>}*/ const PATTERN_REGEX_CACHE = new Map();
+const GLOB_ALL_PATTERN = "**/*";
+const TS_EXTENSIONS = [
+    '.ts',
+    '.tsx',
+    '.mts',
+    '.cts'
+];
+const JS_EXTENSIONS = [
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs'
+];
+const TSJS_EXTENSIONS = TS_EXTENSIONS.concat(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;
+/**
+ * @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' !== external_node_path_namespaceObject["default"].extname(filename)) return; // ignore files that are not json
+    const tsconfig = external_node_path_namespaceObject["default"].resolve(filename);
+    if (cache && (cache.hasParseResult(tsconfig) || cache.hasParseResult(filename))) return tsconfig;
+    return external_node_fs_namespaceObject.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, external_node_path_namespaceObject["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, external_node_path_namespaceObject["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 ? 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)));
+/**
+ *
+ * @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);
+    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');
+        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(external_node_path_namespaceObject["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 = external_node_path_namespaceObject["default"].dirname(external_node_path_namespaceObject["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);
+    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 = external_node_path_namespaceObject["default"].join(dir, options?.configName ?? 'tsconfig.json');
+    external_node_fs_namespaceObject["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);
+            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
+ */ external_node_path_namespaceObject["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;
+}
+var external_module_namespaceObject = __WEBPACK_EXTERNAL_MODULE_module__;
+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, external_node_path_namespaceObject["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 = external_node_fs_namespaceObject.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))
+        };
+    }).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('${') && !external_node_path_namespaceObject["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, external_module_namespaceObject.createRequire)(from);
+    let error;
+    try {
+        return req.resolve(extended);
+    } catch (e) {
+        error = e;
+    }
+    if ('.' !== extended[0] && !external_node_path_namespaceObject["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(external_node_path_namespaceObject["default"].relative(external_node_path_namespaceObject["default"].dirname(extending.tsconfigFile), external_node_path_namespaceObject["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 (external_node_path_namespaceObject["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));
+}
+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' === external_node_path_namespaceObject["default"].basename(configFileName);
+}
+async function loadTsconfig(root, tsconfigPath = 'tsconfig.json') {
+    const tsconfigFileName = await find((0, external_node_path_namespaceObject.join)(root, tsconfigPath), {
+        root,
+        configName: (0, external_node_path_namespaceObject.basename)(tsconfigPath)
+    });
+    if (tsconfigFileName) {
+        const { tsconfig } = await parse(tsconfigFileName);
+        return tsconfig;
+    }
+    return {};
+}
 /**
  * This function helps you to autocomplete configuration types.
  * It accepts a Rslib config object, or a function that returns a config.
@@ -591,7 +1070,7 @@ 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;
-        dist_logger.warn(`Cannot find config file: ${index_js_namespaceObject["default"].dim(customConfigPath)}\n`);
+        index_js_namespaceObject.logger.warn(`Cannot find config file: ${picocolors_index_js_namespaceObject["default"].dim(customConfigPath)}\n`);
     }
     const configFilePath = findConfig((0, external_node_path_namespaceObject.join)(root, DEFAULT_CONFIG_NAME));
     if (configFilePath) return configFilePath;
@@ -666,7 +1145,7 @@ const composeExternalsWarnConfig = (format, ...externalsArray)=>{
                     };
                     if (contextInfo.issuer && 'commonjs' === dependencyType) {
                         matchUserExternals(externals, request, _callback);
-                        if (externalized) dist_logger.warn(composeModuleImportWarn(request));
+                        if (externalized) index_js_namespaceObject.logger.warn(composeModuleImportWarn(request));
                     }
                     callback();
                 }
@@ -678,7 +1157,7 @@ const composeAutoExternalConfig = (options)=>{
     const { autoExternal, pkgJson, userExternals } = options;
     if (!autoExternal) return {};
     if (!pkgJson) {
-        dist_logger.warn('autoExternal configuration will not be applied due to read package.json failed');
+        index_js_namespaceObject.logger.warn('autoExternal configuration will not be applied due to read package.json failed');
         return {};
     }
     const externalOptions = {
@@ -788,6 +1267,16 @@ function composeBannerFooterConfig(banner, footer) {
         }
     };
 }
+function composeDecoratorsConfig(compilerOptions, version) {
+    if (version || !compilerOptions?.experimentalDecorators) return {};
+    return {
+        source: {
+            decorators: {
+                version: 'legacy'
+            }
+        }
+    };
+}
 async function createConstantRsbuildConfig() {
     return (0, core_namespaceObject.defineConfig)({
         mode: 'production',
@@ -901,7 +1390,7 @@ const composeFormatConfig = (format)=>{
             throw new Error(`Unsupported format: ${format}`);
     }
 };
-const composeModuleImportWarn = (request)=>`The externalized commonjs request ${index_js_namespaceObject["default"].green(`"${request}"`)} will use ${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 ${index_js_namespaceObject["default"].blue('"output.externals"')}.`;
+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 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
@@ -963,23 +1452,9 @@ const composeSyntaxConfig = (syntax, target)=>{
             }
         },
         output: {
-            overrideBrowserslist: transformSyntaxToBrowserslist(syntax)
+            overrideBrowserslist: transformSyntaxToBrowserslist(syntax, target)
         }
     };
-    // If `syntax` is not defined, Rslib will try to determine by the `target`, with the last version of the target.
-    const lastTargetVersions = {
-        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'
-        ]
-    };
     return {
         tools: {
             rspack: (config)=>{
@@ -990,10 +1465,8 @@ const composeSyntaxConfig = (syntax, target)=>{
             }
         },
         output: {
-            overrideBrowserslist: 'web' === target ? lastTargetVersions.web : 'node' === target ? lastTargetVersions.node : [
-                ...lastTargetVersions.node,
-                ...lastTargetVersions.web
-            ]
+            // 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)
         }
     };
 };
@@ -1066,7 +1539,7 @@ const composeBundleConfig = (jsExtension, bundle = true)=>{
 const composeDtsConfig = async (libConfig, dtsExtension)=>{
     const { dts, bundle, output, autoExternal, banner, footer } = libConfig;
     if (false === dts || void 0 === dts) return {};
-    const { pluginDts } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "rsbuild-plugin-dts"));
+    const { pluginDts } = await import("rsbuild-plugin-dts");
     return {
         plugins: [
             pluginDts({
@@ -1113,17 +1586,15 @@ const composeTargetConfig = (target = 'web')=>{
                     target: 'node'
                 }
             };
-        case 'neutral':
-            return {
-                tools: {
-                    rspack: {
-                        target: [
-                            'web',
-                            '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}`);
     }
@@ -1144,7 +1615,7 @@ const composeExternalHelpersConfig = (externalHelpers, pkgJson)=>{
             ...Object.keys(pkgJson?.devDependencies ?? [])
         ];
         if (!deps.includes(SWC_HELPERS)) {
-            dist_logger.error(`${index_js_namespaceObject["default"].green('externalHelpers')} is enabled, but the ${index_js_namespaceObject["default"].blue(SWC_HELPERS)} dependency declaration was not found in package.json.`);
+            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.`);
             process.exit(1);
         }
         defaultConfig = Object.assign(defaultConfig, {
@@ -1159,6 +1630,7 @@ const composeExternalHelpersConfig = (externalHelpers, pkgJson)=>{
 async function composeLibRsbuildConfig(config, configPath) {
     const rootPath = (0, external_node_path_namespaceObject.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);
     const externalHelpersConfig = composeExternalHelpersConfig(externalHelpers, pkgJson);
@@ -1177,7 +1649,8 @@ async function composeLibRsbuildConfig(config, configPath) {
     const externalsWarnConfig = composeExternalsWarnConfig(format, autoExternalConfig?.output?.externals, externalsConfig?.output?.externals);
     const minifyConfig = composeMinifyConfig(config.output?.minify);
     const bannerFooterConfig = composeBannerFooterConfig(banner, footer);
-    return (0, core_namespaceObject.mergeRsbuildConfig)(formatConfig, externalHelpersConfig, externalsWarnConfig, externalsConfig, autoExternalConfig, autoExtensionConfig, syntaxConfig, bundleConfig, targetConfig, entryConfig, minifyConfig, dtsConfig, bannerFooterConfig);
+    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);
 }
 async function composeCreateRsbuildConfig(rslibConfig, path) {
     const constantRsbuildConfig = await createConstantRsbuildConfig();
@@ -1257,7 +1730,7 @@ 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.5");
+    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');
     [
@@ -1272,8 +1745,8 @@ function runCli() {
             });
             await build(rslibConfig, options);
         } catch (err) {
-            dist_logger.error('Failed to build.');
-            dist_logger.error(err);
+            index_js_namespaceObject.logger.error('Failed to build.');
+            index_js_namespaceObject.logger.error(err);
             process.exit(1);
         }
     });
@@ -1292,12 +1765,13 @@ function runCli() {
                 writeToDisk: true
             });
         } catch (err) {
-            dist_logger.error('Failed to inspect config.');
-            dist_logger.error(err);
+            index_js_namespaceObject.logger.error('Failed to inspect config.');
+            index_js_namespaceObject.logger.error(err);
             process.exit(1);
         }
     });
     commander_index_js_namespaceObject.program.parse();
 }
-const src_version = "0.0.5";
-export { build, defineConfig, loadConfig, dist_logger as logger, prepareCli, runCli, src_version as version };
+const src_version = "0.0.6";
+var __webpack_exports__logger = index_js_namespaceObject.logger;
+export { build, defineConfig, loadConfig, prepareCli, runCli, src_version as version, __webpack_exports__logger as logger };