@rslib/core 0.0.4 → 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,368 +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 (cachedModule !== undefined) {
-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;
-
-}
-
-/************************************************************************/
-
-;// CONCATENATED MODULE: external "process"
-
-var external_process_namespaceObject = __WEBPACK_EXTERNAL_MODULE_process__;
-
-;// CONCATENATED MODULE: external "os"
-
-var external_os_namespaceObject = __WEBPACK_EXTERNAL_MODULE_os__;
-
-;// CONCATENATED MODULE: external "tty"
-
-var external_tty_namespaceObject = __WEBPACK_EXTERNAL_MODULE_tty__;
-
-;// CONCATENATED MODULE: ../../node_modules/.pnpm/rslog@1.2.2/node_modules/rslog/dist/index.mjs
-// 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("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || 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 (env.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env.FORCE_COLOR === "false") {
-      return 0;
-    }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-  }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
-  }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== void 0) {
-    flagForceColor = noFlagForceColor;
-  }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    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 && forceColor === void 0) {
-    return 0;
-  }
-  const min = forceColor || 0;
-  if (env.TERM === "dumb") {
-    return min;
-  }
-  if (external_process_namespaceObject["default"].platform === "win32") {
-    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) || env.CI_NAME === "codeship") {
-      return 1;
-    }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-  }
-  if (env.COLORTERM === "truecolor") {
-    return 3;
-  }
-  if (env.TERM === "xterm-kitty") {
-    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 = /^\s*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 colorLevel === 2 ? 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 (message === void 0 || message === null) {
-      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 (logType.level === "error" && typeof message === "string") {
-      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();
-
-
-;// CONCATENATED MODULE: external "node:fs"
-
+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__;
-
-;// CONCATENATED MODULE: external "node:fs/promises"
-
 var promises_namespaceObject = __WEBPACK_EXTERNAL_MODULE_node_fs_promises__;
-
-;// CONCATENATED MODULE: external "node:path"
-
 var external_node_path_namespaceObject = __WEBPACK_EXTERNAL_MODULE_node_path__;
-
-;// CONCATENATED MODULE: external "../compiled/picocolors/index.js"
-
-var index_js_namespaceObject = __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__;
-
-;// CONCATENATED MODULE: ./src/utils/helper.ts
-
-
-
-
-
+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
@@ -434,9 +76,7 @@ var index_js_namespaceObject = __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_in
     'pnpapi'
 ];
 async function calcLongestCommonPath(absPaths) {
-    if (absPaths.length === 0) {
-        return null;
-    }
+    if (0 === absPaths.length) return null;
     // we support two cases
     // 1. /packages-a/src/index.ts
     // 2. D:/packages-a/src/index.ts
@@ -447,119 +87,62 @@ async function calcLongestCommonPath(absPaths) {
         const currentPath = splitPaths[i];
         const minLength = Math.min(lcaFragments.length, currentPath.length);
         let j = 0;
-        while(j < minLength && lcaFragments[j] === currentPath[j]){
-            j++;
-        }
+        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 promises_namespaceObject["default"].stat(lca);
-    if (stats?.isFile()) {
-        lca = external_node_path_namespaceObject["default"].dirname(lca);
-    }
+    if (stats?.isFile()) lca = external_node_path_namespaceObject["default"].dirname(lca);
     return lca;
 }
 const readPackageJson = (rootPath)=>{
     const pkgJsonPath = external_node_path_namespaceObject["default"].join(rootPath, './package.json');
     if (!external_node_fs_namespaceObject["default"].existsSync(pkgJsonPath)) {
-        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;
     }
 };
-const isObject = (obj)=>Object.prototype.toString.call(obj) === '[object Object]';
-function omitDeep(obj, keys) {
-    if (typeof obj === 'string' || typeof obj !== 'object' || obj === null) return obj;
-    if (Array.isArray(obj)) {
-        return obj.map((item)=>omitDeep(item, keys));
-    }
-    const clone = {};
-    for(const property in obj){
-        if (keys.includes(property)) {
-            continue;
-        }
-        const value = obj[property];
-        if (value && typeof value === 'object') {
-            clone[property] = omitDeep(value, keys);
-        } else {
-            clone[property] = value;
-        }
-    }
-    return clone;
-}
-
-
-;// CONCATENATED MODULE: ./src/utils/logger.ts
-
-
-// setup the logger level
-if (process.env.DEBUG) {
-    dist_logger.level = 'verbose';
+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;
+    }, {});
 }
-const isDebug = ()=>{
-    if (!process.env.DEBUG) {
-        return false;
-    }
-    logger.level = 'verbose';
-    // support `process.env.DEBUG` in e2e
-    const values = process.env.DEBUG.toLocaleLowerCase().split(',');
-    return [
-        'rslib',
-        'rsbuild',
-        'builder',
-        '*'
-    ].some((key)=>values.includes(key));
-};
-function getTime() {
-    const now = new Date();
-    const hours = String(now.getHours()).padStart(2, '0');
-    const minutes = String(now.getMinutes()).padStart(2, '0');
-    const seconds = String(now.getSeconds()).padStart(2, '0');
-    return `${hours}:${minutes}:${seconds}`;
+function omit(obj, keys) {
+    return Object.keys(obj).reduce((ret, key)=>{
+        if (!keys.includes(key)) ret[key] = obj[key];
+        return ret;
+    }, {});
 }
-const debug = (message)=>{
-    if (isDebug()) {
-        const result = typeof message === 'string' ? message : message();
-        const time = color.gray(`${getTime()}`);
-        logger.debug(`${time} ${result}`);
-    }
-};
-
-
-;// CONCATENATED MODULE: ./src/cli/prepare.ts
-
+// setup the logger level
+if (process.env.DEBUG) index_js_namespaceObject.logger.level = 'verbose';
 function initNodeEnv() {
-    if (false) {}
+    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 v${"0.0.4"}`}\n`);
+    if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) console.log();
+    index_js_namespaceObject.logger.greet(`  Rslib v0.0.6\n`);
 }
-
-;// CONCATENATED MODULE: external "../compiled/commander/index.js"
-
 var commander_index_js_namespaceObject = __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__;
-
-;// CONCATENATED MODULE: external "@rsbuild/core"
-
 var core_namespaceObject = __WEBPACK_EXTERNAL_MODULE__rsbuild_core__;
-
-;// CONCATENATED MODULE: external "../compiled/fast-glob/index.js"
-
 var fast_glob_index_js_namespaceObject = __WEBPACK_EXTERNAL_MODULE__compiled_fast_glob_index_js__;
-
-;// CONCATENATED MODULE: ./src/constant.ts
 const DEFAULT_CONFIG_NAME = 'rslib.config';
 const DEFAULT_EXTENSIONS = [
     '.js',
@@ -569,32 +152,28 @@ const DEFAULT_EXTENSIONS = [
     '.cjs',
     '.cts'
 ];
-
-;// CONCATENATED MODULE: ./src/utils/extension.ts
-
+const SWC_HELPERS = '@swc/helpers';
 const getDefaultExtension = (options)=>{
     const { format, pkgJson, autoExtension } = options;
     let jsExtension = '.js';
     let dtsExtension = '.d.ts';
-    if (!autoExtension) {
-        return {
-            jsExtension,
-            dtsExtension
-        };
-    }
+    if (!autoExtension) return {
+        jsExtension,
+        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
         };
     }
-    const isModule = pkgJson.type === 'module';
-    if (isModule && format === 'cjs') {
+    const isModule = 'module' === pkgJson.type;
+    if (isModule && 'cjs' === format) {
         jsExtension = '.cjs';
         dtsExtension = '.d.cts';
     }
-    if (!isModule && format === 'esm') {
+    if (!isModule && 'esm' === format) {
         jsExtension = '.mjs';
         dtsExtension = '.d.mts';
     }
@@ -604,8 +183,30 @@ const getDefaultExtension = (options)=>{
         isModule
     };
 };
-
-;// CONCATENATED MODULE: ./src/utils/syntax.ts
+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
@@ -710,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',
@@ -723,84 +324,776 @@ const getDefaultExtension = (options)=>{
         Safari: '3.1.0'
     }
 };
-const transformSyntaxToBrowserslist = (syntax)=>{
-    // only single esX is allowed
-    if (typeof syntax === 'string' && syntax.toLowerCase().startsWith('es')) {
-        if (syntax.toLowerCase() in ESX_TO_BROWSERSLIST) {
-            return Object.entries(ESX_TO_BROWSERSLIST[syntax]).flatMap(([engine, version])=>{
-                if (Array.isArray(version)) {
-                    return version;
+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('\\' + 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;
                 }
-                return `${engine} >= ${version}`;
-            });
+            } 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);
         }
-        throw new Error(`Unsupported ES version: ${syntax}`);
+    } 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);
     }
-    // inline browserslist query
-    if (Array.isArray(syntax)) {
-        return syntax;
+}
+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;
     }
-    throw new Error(`Unsupported syntax: ${syntax}`);
+}
+/**
+ *
+ * @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
 };
-
-;// CONCATENATED MODULE: ./src/config.ts
-
-
-
-
-
-
-
-
-
+/**
+ * @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.
  */ function defineConfig(config) {
     return config;
 }
-const findConfig = (basePath)=>{
-    return DEFAULT_EXTENSIONS.map((ext)=>basePath + ext).find(external_node_fs_namespaceObject["default"].existsSync);
-};
+const findConfig = (basePath)=>DEFAULT_EXTENSIONS.map((ext)=>basePath + ext).find(external_node_fs_namespaceObject["default"].existsSync);
 const resolveConfigPath = (root, customConfig)=>{
     if (customConfig) {
-        const customConfigPath = (0,external_node_path_namespaceObject.isAbsolute)(customConfig) ? customConfig : (0,external_node_path_namespaceObject.join)(root, customConfig);
-        if (external_node_fs_namespaceObject["default"].existsSync(customConfigPath)) {
-            return customConfigPath;
-        }
-        dist_logger.warn(`Cannot find config file: ${index_js_namespaceObject["default"].dim(customConfigPath)}\n`);
-    }
-    const configFilePath = findConfig((0,external_node_path_namespaceObject.join)(root, DEFAULT_CONFIG_NAME));
-    if (configFilePath) {
-        return configFilePath;
+        const customConfigPath = (0, external_node_path_namespaceObject.isAbsolute)(customConfig) ? customConfig : (0, external_node_path_namespaceObject.join)(root, customConfig);
+        if (external_node_fs_namespaceObject["default"].existsSync(customConfigPath)) return customConfigPath;
+        index_js_namespaceObject.logger.warn(`Cannot find config file: ${picocolors_index_js_namespaceObject["default"].dim(customConfigPath)}\n`);
     }
+    const configFilePath = findConfig((0, external_node_path_namespaceObject.join)(root, DEFAULT_CONFIG_NAME));
+    if (configFilePath) return configFilePath;
     throw new Error(`${DEFAULT_CONFIG_NAME} not found in ${root}`);
 };
 async function loadConfig({ cwd = process.cwd(), path, envMode }) {
     const configFilePath = resolveConfigPath(cwd, path);
-    const { content } = await (0,core_namespaceObject.loadConfig)({
-        cwd: (0,external_node_path_namespaceObject.dirname)(configFilePath),
+    const { content } = await (0, core_namespaceObject.loadConfig)({
+        cwd: (0, external_node_path_namespaceObject.dirname)(configFilePath),
         path: configFilePath,
         envMode
     });
     return content;
 }
 const composeExternalsWarnConfig = (format, ...externalsArray)=>{
-    if (format !== 'esm') {
-        return {};
-    }
+    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);
-        }
-    }
+    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 (typeof externals === 'string') {
+        if ('string' == typeof externals) {
             if (externals === request) {
                 callback(true);
                 return;
@@ -821,9 +1114,7 @@ const composeExternalsWarnConfig = (format, ...externalsArray)=>{
                 };
                 do {
                     asyncFlag = true;
-                    if (i >= externals.length) {
-                        return callback();
-                    }
+                    if (i >= externals.length) return callback();
                     matchUserExternals(externals[i++], request, handleExternalsAndCallback);
                 }while (!asyncFlag);
                 asyncFlag = false;
@@ -835,8 +1126,8 @@ const composeExternalsWarnConfig = (format, ...externalsArray)=>{
                 callback(true);
                 return;
             }
-        } else if (typeof externals === 'function') {} else // TODO: Support function
-        if (typeof externals === 'object') {
+        } else if ('function' == typeof externals) ;
+        else if ('object' == typeof externals) {
             if (Object.prototype.hasOwnProperty.call(externals, request)) {
                 callback(true);
                 return;
@@ -850,15 +1141,11 @@ const composeExternalsWarnConfig = (format, ...externalsArray)=>{
                 ({ request, dependencyType, contextInfo }, callback)=>{
                     let externalized = false;
                     const _callback = (matched)=>{
-                        if (matched) {
-                            externalized = true;
-                        }
+                        if (matched) externalized = true;
                     };
-                    if (contextInfo.issuer && dependencyType === 'commonjs') {
+                    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();
                 }
@@ -868,18 +1155,16 @@ const composeExternalsWarnConfig = (format, ...externalsArray)=>{
 };
 const composeAutoExternalConfig = (options)=>{
     const { autoExternal, pkgJson, userExternals } = options;
-    if (!autoExternal) {
-        return {};
-    }
+    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 = {
         dependencies: true,
         peerDependencies: true,
         devDependencies: false,
-        ...autoExternal === true ? {} : autoExternal
+        ...true === autoExternal ? {} : autoExternal
     };
     // User externals configuration has higher priority than autoExternal
     // eg: autoExternal: ['react'], user: output: { externals: { react: 'react-1' } }
@@ -890,9 +1175,7 @@ const composeAutoExternalConfig = (options)=>{
         'peerDependencies',
         'devDependencies'
     ].reduce((prev, type)=>{
-        if (externalOptions[type]) {
-            return pkgJson[type] ? prev.concat(Object.keys(pkgJson[type])) : prev;
-        }
+        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));
@@ -906,8 +1189,96 @@ const composeAutoExternalConfig = (options)=>{
         }
     } : {};
 };
+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 core_namespaceObject.rspack.BannerPlugin({
+            banner: bannerConfig.js,
+            stage: core_namespaceObject.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
+            raw: true,
+            include: /\.(js|mjs|cjs)$/
+        }));
+        if (bannerConfig.css) plugins.push(new core_namespaceObject.rspack.BannerPlugin({
+            banner: bannerConfig.css,
+            stage: core_namespaceObject.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
+            raw: true,
+            include: /\.(css)$/
+        }));
+    }
+    if (!isEmptyObject(footerConfig)) {
+        if (footerConfig.js) plugins.push(new core_namespaceObject.rspack.BannerPlugin({
+            banner: footerConfig.js,
+            stage: core_namespaceObject.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE + 1,
+            raw: true,
+            footer: true,
+            include: /\.(js|mjs|cjs)$/
+        }));
+        if (footerConfig.css) plugins.push(new core_namespaceObject.rspack.BannerPlugin({
+            banner: footerConfig.css,
+            stage: core_namespaceObject.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,core_namespaceObject.defineConfig)({
+    return (0, core_namespaceObject.defineConfig)({
         mode: 'production',
         dev: {
             progressBar: false
@@ -916,7 +1287,8 @@ async function createConstantRsbuildConfig() {
             htmlPlugin: false,
             rspack: {
                 optimization: {
-                    moduleIds: 'named'
+                    moduleIds: 'named',
+                    nodeEnv: false
                 },
                 experiments: {
                     rspackFuture: {
@@ -953,25 +1325,6 @@ async function createConstantRsbuildConfig() {
         },
         output: {
             filenameHash: false,
-            minify: {
-                js: true,
-                css: false,
-                jsOptions: {
-                    minimizerOptions: {
-                        mangle: false,
-                        minify: false,
-                        compress: {
-                            defaults: false,
-                            unused: true,
-                            dead_code: true,
-                            toplevel: true
-                        },
-                        format: {
-                            comments: 'all'
-                        }
-                    }
-                }
-            },
             distPath: {
                 js: './'
             }
@@ -1037,9 +1390,7 @@ const composeFormatConfig = (format)=>{
             throw new Error(`Unsupported format: ${format}`);
     }
 };
-const composeModuleImportWarn = (request)=>{
-    return `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
@@ -1088,37 +1439,21 @@ const composeAutoExtensionConfig = (config, autoExtension, pkgJson)=>{
 };
 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)=>{
-                    // TODO: Rspack should could resolve `browserslist:{query}` like webpack.
-                    // https://webpack.js.org/configuration/target/#browserslist
-                    // Using 'es5' as a temporary solution for compatibility.
-                    config.target = [
-                        'es5'
-                    ];
-                    return config;
-                }
-            },
-            output: {
-                overrideBrowserslist: transformSyntaxToBrowserslist(syntax)
+    if (syntax) return {
+        tools: {
+            rspack: (config)=>{
+                // TODO: Rspack should could resolve `browserslist:{query}` like webpack.
+                // https://webpack.js.org/configuration/target/#browserslist
+                // Using 'es5' as a temporary solution for compatibility.
+                config.target = [
+                    'es5'
+                ];
+                return config;
             }
-        };
-    }
-    // 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'
-        ]
+        },
+        output: {
+            overrideBrowserslist: transformSyntaxToBrowserslist(syntax, target)
+        }
     };
     return {
         tools: {
@@ -1130,24 +1465,18 @@ const composeSyntaxConfig = (syntax, target)=>{
             }
         },
         output: {
-            overrideBrowserslist: target === 'web' ? lastTargetVersions.web : target === 'node' ? 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)
         }
     };
 };
 const composeEntryConfig = async (entries, bundle, root)=>{
-    if (!entries) {
-        return {};
-    }
-    if (bundle !== false) {
-        return {
-            source: {
-                entry: entries
-            }
-        };
-    }
+    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)){
@@ -1156,23 +1485,19 @@ const composeEntryConfig = async (entries, bundle, root)=>{
         // 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 : typeof entry === 'string' ? [
+        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');
-        }
+        if (!entryFiles) throw new Error('Entry can only be a string or an array of strings for now');
         // Turn entries in array into each separate entry.
-        const resolvedEntryFiles = await (0,fast_glob_index_js_namespaceObject["default"])(entryFiles, {
+        const resolvedEntryFiles = await (0, fast_glob_index_js_namespaceObject["default"])(entryFiles, {
             cwd: root
         });
-        if (resolvedEntryFiles.length === 0) {
-            throw new Error(`Cannot find ${resolvedEntryFiles}`);
-        }
+        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 = lcp === null ? root : lcp;
+        const outBase = null === lcp ? root : lcp;
         for (const file of resolvedEntryFiles){
             const { dir, name } = external_node_path_namespaceObject["default"].parse(external_node_path_namespaceObject["default"].relative(outBase, file));
             // Entry filename contains nested path to preserve source directory structure.
@@ -1202,9 +1527,7 @@ const composeBundleConfig = (jsExtension, bundle = true)=>{
                         // This may result in a change in semantics,
                         // user should use copy to keep origin file or use another separate entry to deal this
                         let request = data.request;
-                        if (request[0] === '.') {
-                            request = (0,external_node_path_namespaceObject.extname)(request) ? request.replace(/\.[^.]+$/, jsExtension) : `${request}${jsExtension}`;
-                        }
+                        if ('.' === request[0]) request = (0, external_node_path_namespaceObject.extname)(request) ? request.replace(/\.[^.]+$/, jsExtension) : `${request}${jsExtension}`;
                         return callback(null, request);
                     }
                     callback();
@@ -1214,9 +1537,9 @@ const composeBundleConfig = (jsExtension, bundle = true)=>{
     };
 };
 const composeDtsConfig = async (libConfig, dtsExtension)=>{
-    const { dts, bundle, output, autoExternal } = libConfig;
-    if (dts === false || dts === undefined) return {};
-    const { pluginDts } = await Promise.resolve(/* import() */ ).then(__webpack_require__.bind(__webpack_require__, "rsbuild-plugin-dts"));
+    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({
@@ -1224,7 +1547,9 @@ const composeDtsConfig = async (libConfig, dtsExtension)=>{
                 distPath: dts?.distPath ?? output?.distPath?.root ?? './dist',
                 abortOnError: dts?.abortOnError ?? true,
                 dtsExtension,
-                autoExternal
+                autoExternal,
+                banner: banner?.dts,
+                footer: footer?.dts
             })
         ]
     };
@@ -1261,51 +1586,79 @@ 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}`);
     }
 };
+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)) {
+            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, {
+            output: {
+                externals: new RegExp(`^${SWC_HELPERS}($|\\/|\\\\)`)
+            }
+        });
+        defaultConfig.tools.swc.jsc.externalHelpers = true;
+    }
+    return defaultConfig;
+};
 async function composeLibRsbuildConfig(config, configPath) {
-    const rootPath = (0,external_node_path_namespaceObject.dirname)(configPath);
+    const rootPath = (0, external_node_path_namespaceObject.dirname)(configPath);
     const pkgJson = readPackageJson(rootPath);
-    const { format, autoExtension = true, autoExternal = true } = config;
+    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);
     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.output?.syntax, 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,external_node_path_namespaceObject.dirname)(configPath));
+    const entryConfig = await composeEntryConfig(config.source?.entry, config.bundle, (0, external_node_path_namespaceObject.dirname)(configPath));
     const dtsConfig = await composeDtsConfig(config, dtsExtension);
     const externalsWarnConfig = composeExternalsWarnConfig(format, autoExternalConfig?.output?.externals, externalsConfig?.output?.externals);
-    return (0,core_namespaceObject.mergeRsbuildConfig)(formatConfig, // externalsWarnConfig should before other externals config
-    externalsWarnConfig, externalsConfig, autoExternalConfig, autoExtensionConfig, syntaxConfig, bundleConfig, targetConfig, entryConfig, dtsConfig);
+    const minifyConfig = composeMinifyConfig(config.output?.minify);
+    const bannerFooterConfig = composeBannerFooterConfig(banner, footer);
+    const decoratorsConfig = composeDecoratorsConfig(compilerOptions, config.source?.decorators?.version);
+    return (0, core_namespaceObject.mergeRsbuildConfig)(formatConfig, externalHelpersConfig, externalsWarnConfig, externalsConfig, autoExternalConfig, autoExtensionConfig, syntaxConfig, bundleConfig, targetConfig, entryConfig, minifyConfig, dtsConfig, bannerFooterConfig, decoratorsConfig);
 }
 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}.`);
-    }
+    if (!libConfigsArray) throw new Error(`Expect lib field to be an array, but got ${libConfigsArray}.`);
     const libConfigPromises = libConfigsArray.map(async (libConfig)=>{
-        const userConfig = (0,core_namespaceObject.mergeRsbuildConfig)(sharedRsbuildConfig, libConfig);
+        const userConfig = (0, core_namespaceObject.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);
@@ -1327,12 +1680,15 @@ async function composeCreateRsbuildConfig(rslibConfig, path) {
             // We should state in the document that the built-in configuration should not be changed optionally
             // In compose process of 2, we may read some config from 1, and reassemble the related config,
             // so before final mergeRsbuildConfig, we reset some specified fields
-            config: (0,core_namespaceObject.mergeRsbuildConfig)(constantRsbuildConfig, libRsbuildConfig, omitDeep(userConfig, [
+            config: (0, core_namespaceObject.mergeRsbuildConfig)(constantRsbuildConfig, libRsbuildConfig, omit(userConfig, [
                 'bundle',
                 'format',
                 'autoExtension',
                 'autoExternal',
                 'syntax',
+                'externalHelpers',
+                'banner',
+                'footer',
                 'dts'
             ]))
         };
@@ -1355,17 +1711,14 @@ async function initRsbuild(rslibConfig) {
     for (const { format, config } of rsbuildConfigObject){
         const currentFormatCount = formatCount[format];
         const currentFormatIndex = formatIndex[format]++;
-        environments[currentFormatCount === 1 ? format : `${format}${currentFormatIndex}`] = config;
+        environments[1 === currentFormatCount ? format : `${format}${currentFormatIndex}`] = config;
     }
-    return (0,core_namespaceObject.createRsbuild)({
+    return (0, core_namespaceObject.createRsbuild)({
         rsbuildConfig: {
             environments
         }
     });
 }
-
-;// CONCATENATED MODULE: ./src/build.ts
-
 async function build(config, options) {
     const rsbuildInstance = await initRsbuild(config);
     await rsbuildInstance.build({
@@ -1373,17 +1726,11 @@ async function build(config, options) {
     });
     return rsbuildInstance;
 }
-
-;// CONCATENATED MODULE: ./src/cli/commands.ts
-
-
-
-
 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.4");
+    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');
     [
@@ -1398,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);
         }
     });
@@ -1418,20 +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();
 }
-
-;// CONCATENATED MODULE: ./src/index.ts
-
-
-
-
-
-const src_version = "0.0.4";
-
-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 };