@rslib/core 0.0.0 → 0.0.2

package/dist/main.js

@@ -0,0 +1,1238 @@
+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_node_fs__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises__ from "node:fs/promises";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__ from "../compiled/picocolors/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__ from "../compiled/commander/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_core__ from "@rsbuild/core";
+import * as __WEBPACK_EXTERNAL_MODULE__compiled_fast_glob_index_js__ from "../compiled/fast-glob/index.js";
+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"
+
+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
+
+
+
+
+
+/**
+ * Node.js built-in modules.
+ * Copied from https://github.com/webpack/webpack/blob/dd44b206a9c50f4b4cb4d134e1a0bd0387b159a3/lib/node/NodeTargetPlugin.js#L12-L72
+ */ const nodeBuiltInModules = [
+    'assert',
+    'assert/strict',
+    'async_hooks',
+    'buffer',
+    'child_process',
+    'cluster',
+    'console',
+    'constants',
+    'crypto',
+    'dgram',
+    'diagnostics_channel',
+    'dns',
+    'dns/promises',
+    'domain',
+    'events',
+    'fs',
+    'fs/promises',
+    'http',
+    'http2',
+    'https',
+    'inspector',
+    'inspector/promises',
+    'module',
+    'net',
+    'os',
+    'path',
+    'path/posix',
+    'path/win32',
+    'perf_hooks',
+    'process',
+    'punycode',
+    'querystring',
+    'readline',
+    'readline/promises',
+    'repl',
+    'stream',
+    'stream/consumers',
+    'stream/promises',
+    'stream/web',
+    'string_decoder',
+    'sys',
+    'timers',
+    'timers/promises',
+    'tls',
+    'trace_events',
+    'tty',
+    'url',
+    'util',
+    'util/types',
+    'v8',
+    'vm',
+    'wasi',
+    'worker_threads',
+    'zlib',
+    /^node:/,
+    // cspell:word pnpapi
+    // Yarn PnP adds pnpapi as "builtin"
+    'pnpapi'
+];
+async function calcLongestCommonPath(absPaths) {
+    if (absPaths.length === 0) {
+        return null;
+    }
+    // we support two cases
+    // 1. /packages-a/src/index.ts
+    // 2. D:/packages-a/src/index.ts
+    const sep = external_node_path_namespaceObject["default"].posix.sep;
+    const splitPaths = absPaths.map((p)=>p.split(sep));
+    let lcaFragments = splitPaths[0];
+    for(let i = 1; i < splitPaths.length; i++){
+        const currentPath = splitPaths[i];
+        const minLength = Math.min(lcaFragments.length, currentPath.length);
+        let j = 0;
+        while(j < minLength && lcaFragments[j] === currentPath[j]){
+            j++;
+        }
+        lcaFragments = lcaFragments.slice(0, j);
+    }
+    let lca = lcaFragments.length > 0 ? lcaFragments.join(sep) : sep;
+    const stats = await promises_namespaceObject["default"].stat(lca);
+    if (stats?.isFile()) {
+        lca = external_node_path_namespaceObject["default"].dirname(lca);
+    }
+    return lca;
+}
+const readPackageJson = (rootPath)=>{
+    const pkgJsonPath = external_node_path_namespaceObject["default"].resolve(rootPath, './package.json');
+    if (!external_node_fs_namespaceObject["default"].existsSync(pkgJsonPath)) {
+        dist_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`);
+        return;
+    }
+};
+const isObject = (obj)=>Object.prototype.toString.call(obj) === '[object Object]';
+
+
+;// CONCATENATED MODULE: ./src/utils/logger.ts
+
+
+// setup the logger level
+if (process.env.DEBUG) {
+    dist_logger.level = 'verbose';
+}
+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}`;
+}
+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
+
+function initNodeEnv() {
+    if (false) {}
+}
+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.2"}`}\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',
+    '.ts',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+
+;// CONCATENATED MODULE: ./src/utils/extension.ts
+
+const getDefaultExtension = (options)=>{
+    const { format, pkgJson, autoExtension } = options;
+    let jsExtension = '.js';
+    let dtsExtension = '.d.ts';
+    if (!autoExtension) {
+        return {
+            jsExtension,
+            dtsExtension
+        };
+    }
+    if (!pkgJson) {
+        dist_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') {
+        jsExtension = '.cjs';
+        dtsExtension = '.d.cts';
+    }
+    if (!isModule && format === 'esm') {
+        jsExtension = '.mjs';
+        dtsExtension = '.d.mts';
+    }
+    return {
+        jsExtension,
+        dtsExtension,
+        isModule
+    };
+};
+
+;// CONCATENATED MODULE: ./src/utils/syntax.ts
+/**
+ * The esX to browserslist mapping is transformed from esbuild:
+ * https://github.com/evanw/esbuild/blob/main/internal/compat/js_table.go
+ * It does not completely align with the browserslist query of Rsbuild now:
+ * https://github.com/rspack-contrib/browserslist-to-es-version
+ * TODO: align with Rsbuild, we may should align with SWC
+ */ const ESX_TO_BROWSERSLIST = {
+    es6: {
+        Chrome: '63.0.0',
+        Edge: '79.0.0',
+        Firefox: '67.0.0',
+        iOS: '13.0.0',
+        Node: [
+            'node > 12.20.0 and node < 13.0.0',
+            'node > 13.2.0'
+        ],
+        Opera: '50.0.0',
+        Safari: '13.0.0'
+    },
+    es2015: {
+        Chrome: '63.0.0',
+        Edge: '79.0.0',
+        Firefox: '67.0.0',
+        iOS: '13.0.0',
+        Node: '10.0.0',
+        Opera: '50.0.0',
+        Safari: '13.0.0'
+    },
+    es2016: {
+        Chrome: '52.0.0',
+        Edge: '14.0.0',
+        Firefox: '52.0.0',
+        iOS: '10.3.0',
+        Node: '7.0.0',
+        Opera: '39.0.0',
+        Safari: '10.1.0'
+    },
+    es2017: {
+        Chrome: '55.0.0',
+        Edge: '15.0.0',
+        Firefox: '52.0.0',
+        iOS: '11.0.0',
+        Node: '7.6.0',
+        Opera: '42.0.0',
+        Safari: '11.0.0'
+    },
+    es2018: {
+        Chrome: '64.0.0',
+        Edge: '79.0.0',
+        Firefox: '78.0.0',
+        iOS: '16.4.0',
+        Node: [
+            'node > 18.20.0 and node < 19.0.0',
+            'node > 20.12.0 and node < 21.0.0',
+            'node > 21.3.0'
+        ],
+        Opera: '51.0.0',
+        Safari: '16.4.0'
+    },
+    es2019: {
+        Chrome: '66.0.0',
+        Edge: '79.0.0',
+        Firefox: '58.0.0',
+        iOS: '11.3.0',
+        Node: '10.0.0',
+        Opera: '53.0.0',
+        Safari: '11.1.0'
+    },
+    es2020: {
+        Chrome: '91.0.0',
+        Edge: '91.0.0',
+        Firefox: '80.0.0',
+        iOS: '14.5.0',
+        Node: '16.1.0',
+        Opera: '77.0.0',
+        Safari: '14.1.0'
+    },
+    es2021: {
+        Chrome: '85.0.0',
+        Edge: '85.0.0',
+        Firefox: '79.0.0',
+        iOS: '14.0.0',
+        Node: '15.0.0',
+        Opera: '71.0.0',
+        Safari: '14.0.0'
+    },
+    es2022: {
+        Chrome: '91.0.0',
+        Edge: '94.0.0',
+        Firefox: '93.0.0',
+        iOS: '16.4.0',
+        Node: '16.11.0',
+        Opera: '80.0.0',
+        Safari: '16.4.0'
+    },
+    es2023: {
+        Chrome: '74.0.0',
+        Edge: '79.0.0',
+        Firefox: '67.0.0',
+        iOS: '13.4.0',
+        Node: '12.5.0',
+        Opera: '62.0.0',
+        Safari: '13.1.0'
+    },
+    es2024: {},
+    esnext: {},
+    es5: {
+        Chrome: '5.0.0',
+        Edge: '12.0.0',
+        Firefox: '2.0.0',
+        ie: '9.0.0',
+        iOS: '6.0.0',
+        Node: '0.4.0',
+        Opera: '10.10.0',
+        Safari: '3.1.0'
+    }
+};
+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;
+                }
+                return `${engine} >= ${version}`;
+            });
+        }
+        throw new Error(`Unsupported ES version: ${syntax}`);
+    }
+    // inline browserslist query
+    if (Array.isArray(syntax)) {
+        return syntax;
+    }
+    throw new Error(`Unsupported syntax: ${syntax}`);
+};
+
+;// CONCATENATED MODULE: ./src/config.ts
+
+
+
+
+
+
+
+
+
+/**
+ * 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 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;
+    }
+    return undefined;
+};
+async function loadConfig(customConfig, envMode) {
+    const root = process.cwd();
+    const configFilePath = resolveConfigPath(root, customConfig);
+    const { content } = await (0,core_namespaceObject.loadConfig)({
+        cwd: (0,external_node_path_namespaceObject.dirname)(configFilePath),
+        path: configFilePath,
+        envMode
+    });
+    return content;
+}
+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');
+        return {};
+    }
+    const externalOptions = {
+        dependencies: true,
+        peerDependencies: true,
+        devDependencies: false,
+        ...autoExternal === true ? {} : autoExternal
+    };
+    // User externals configuration has higher priority than autoExternal
+    // eg: autoExternal: ['react'], user: output: { externals: { react: 'react-1' } }
+    // Only handle the case where the externals type is object, string / string[] does not need to be processed, other types are too complex.
+    const userExternalKeys = userExternals && isObject(userExternals) ? Object.keys(userExternals) : [];
+    const externals = [
+        'dependencies',
+        'peerDependencies',
+        'devDependencies'
+    ].reduce((prev, type)=>{
+        if (externalOptions[type]) {
+            return pkgJson[type] ? prev.concat(Object.keys(pkgJson[type])) : prev;
+        }
+        return prev;
+    }, []).filter((name)=>!userExternalKeys.includes(name));
+    const uniqueExternals = Array.from(new Set(externals));
+    return externals.length ? {
+        output: {
+            externals: [
+                // Exclude dependencies, e.g. `react`, `react/jsx-runtime`
+                ...uniqueExternals.map((dep)=>new RegExp(`^${dep}($|\\/|\\\\)`)),
+                ...uniqueExternals
+            ]
+        }
+    } : {};
+};
+async function createInternalRsbuildConfig() {
+    return (0,core_namespaceObject.defineConfig)({
+        mode: 'production',
+        dev: {
+            progressBar: false
+        },
+        tools: {
+            htmlPlugin: false,
+            rspack: {
+                optimization: {
+                    moduleIds: 'named'
+                },
+                experiments: {
+                    rspackFuture: {
+                        bundlerInfo: {
+                            force: false
+                        }
+                    }
+                }
+            }
+        },
+        output: {
+            filenameHash: false,
+            // TODO: easy to development at the moment
+            minify: false,
+            distPath: {
+                js: './'
+            }
+        }
+    });
+}
+const composeFormatConfig = (format)=>{
+    switch(format){
+        case 'esm':
+            return {
+                tools: {
+                    rspack: {
+                        externalsType: 'module-import',
+                        output: {
+                            module: true,
+                            chunkFormat: 'module',
+                            library: {
+                                type: 'modern-module'
+                            }
+                        },
+                        module: {
+                            parser: {
+                                javascript: {
+                                    importMeta: false
+                                }
+                            }
+                        },
+                        optimization: {
+                            concatenateModules: true
+                        },
+                        experiments: {
+                            outputModule: true
+                        }
+                    }
+                }
+            };
+        case 'cjs':
+            return {
+                tools: {
+                    rspack: {
+                        externalsType: 'commonjs',
+                        output: {
+                            iife: false,
+                            chunkFormat: 'commonjs',
+                            library: {
+                                type: 'commonjs'
+                            }
+                        }
+                    }
+                }
+            };
+        case 'umd':
+            return {
+                tools: {
+                    rspack: {
+                        externalsType: 'umd',
+                        output: {
+                            library: {
+                                type: 'umd'
+                            }
+                        }
+                    }
+                }
+            };
+        default:
+            throw new Error(`Unsupported format: ${format}`);
+    }
+};
+const composeAutoExtensionConfig = (format, autoExtension, pkgJson)=>{
+    const { jsExtension, dtsExtension } = getDefaultExtension({
+        format,
+        pkgJson,
+        autoExtension
+    });
+    return {
+        config: {
+            output: {
+                filename: {
+                    js: `[name]${jsExtension}`
+                }
+            }
+        },
+        jsExtension,
+        dtsExtension
+    };
+};
+const composeSyntaxConfig = (syntax, target)=>{
+    // Defaults to ESNext, Rslib will assume all of the latest JavaScript and CSS features are supported.
+    if (syntax) {
+        return {
+            tools: {
+                rspack: (config)=>{
+                    // 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` 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)=>{
+                config.target = [
+                    'es2022'
+                ];
+                return config;
+            }
+        },
+        output: {
+            overrideBrowserslist: target === 'web' ? lastTargetVersions.web : target === 'node' ? lastTargetVersions.node : [
+                ...lastTargetVersions.node,
+                ...lastTargetVersions.web
+            ]
+        }
+    };
+};
+const composeEntryConfig = async (entries, bundle, root)=>{
+    if (!entries) {
+        return {};
+    }
+    if (bundle !== false) {
+        return {
+            source: {
+                entry: entries
+            }
+        };
+    }
+    // In bundleless mode, resolve glob patterns and convert them to entry object.
+    const resolvedEntries = {};
+    for (const key of Object.keys(entries)){
+        const entry = entries[key];
+        // Entries in bundleless mode could be:
+        // 1. A string of glob pattern: { entry: { main: 'src/*.ts' } }
+        // 2. An array of glob patterns: { entry: { main: ['src/*.ts', 'src/*.tsx'] } }
+        // Not supported for now: entry description object
+        const entryFiles = Array.isArray(entry) ? entry : typeof entry === 'string' ? [
+            entry
+        ] : null;
+        if (!entryFiles) {
+            throw new Error('Entry can only be a string or an array of strings for now');
+        }
+        // Turn entries in array into each separate entry.
+        const resolvedEntryFiles = await (0,fast_glob_index_js_namespaceObject["default"])(entryFiles, {
+            cwd: root
+        });
+        if (resolvedEntryFiles.length === 0) {
+            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;
+        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.
+            const entryFileName = external_node_path_namespaceObject["default"].join(dir, name);
+            resolvedEntries[entryFileName] = file;
+        }
+    }
+    return {
+        source: {
+            entry: resolvedEntries
+        }
+    };
+};
+const composeBundleConfig = (jsExtension, bundle = true)=>{
+    if (bundle) return {};
+    return {
+        output: {
+            externals: [
+                (data, callback)=>{
+                    // Issuer is not empty string when the module is imported by another module.
+                    // Prevent from externalizing entry modules here.
+                    if (data.contextInfo.issuer) {
+                        // Node.js ECMAScript module loader does no extension searching.
+                        // So we add a file extension here when data.request is a relative path
+                        return callback(null, data.request[0] === '.' ? `${data.request}${jsExtension}` : data.request);
+                    }
+                    callback();
+                }
+            ]
+        }
+    };
+};
+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"));
+    return {
+        plugins: [
+            pluginDts({
+                bundle: dts?.bundle ?? bundle,
+                distPath: dts?.distPath ?? output?.distPath?.root ?? './dist',
+                abortOnError: dts?.abortOnError ?? true,
+                dtsExtension,
+                autoExternal
+            })
+        ]
+    };
+};
+const composeTargetConfig = (target = 'web')=>{
+    switch(target){
+        case 'web':
+            return {
+                tools: {
+                    rspack: {
+                        target: [
+                            'web'
+                        ]
+                    }
+                }
+            };
+        case 'node':
+            return {
+                tools: {
+                    rspack: {
+                        target: [
+                            'node'
+                        ]
+                    }
+                },
+                // "__dirname" and "__filename" shims will automatically be enabled when `output.module` is `true`,
+                // and leave them as-is in the rest of the cases.
+                // { node: { __dirname: ..., __filename: ... } }
+                output: {
+                    // When output.target is 'node', Node.js's built-in will be treated as externals of type `node-commonjs`.
+                    // Simply override the built-in modules to make them external.
+                    // https://github.com/webpack/webpack/blob/dd44b206a9c50f4b4cb4d134e1a0bd0387b159a3/lib/node/NodeTargetPlugin.js#L81
+                    externals: nodeBuiltInModules,
+                    target: 'node'
+                }
+            };
+        case 'neutral':
+            return {
+                tools: {
+                    rspack: {
+                        target: [
+                            'web',
+                            'node'
+                        ]
+                    }
+                }
+            };
+        default:
+            throw new Error(`Unsupported platform: ${target}`);
+    }
+};
+async function composeLibRsbuildConfig(libConfig, rsbuildConfig, configPath) {
+    const config = (0,core_namespaceObject.mergeRsbuildConfig)(rsbuildConfig, libConfig);
+    const rootPath = (0,external_node_path_namespaceObject.dirname)(configPath);
+    const pkgJson = readPackageJson(rootPath);
+    const { format, autoExtension = true, autoExternal = true } = config;
+    const formatConfig = composeFormatConfig(format);
+    const { config: autoExtensionConfig, jsExtension, dtsExtension } = composeAutoExtensionConfig(format, autoExtension, pkgJson);
+    const bundleConfig = composeBundleConfig(jsExtension, config.bundle);
+    const targetConfig = composeTargetConfig(config.output?.target);
+    const syntaxConfig = composeSyntaxConfig(config.output?.syntax, config.output?.target);
+    const autoExternalConfig = composeAutoExternalConfig({
+        autoExternal,
+        pkgJson,
+        userExternals: rsbuildConfig.output?.externals
+    });
+    const entryConfig = await composeEntryConfig(config.source?.entry, config.bundle, (0,external_node_path_namespaceObject.dirname)(configPath));
+    const dtsConfig = await composeDtsConfig(config, dtsExtension);
+    return (0,core_namespaceObject.mergeRsbuildConfig)(formatConfig, autoExtensionConfig, autoExternalConfig, syntaxConfig, bundleConfig, targetConfig, entryConfig, dtsConfig);
+}
+async function composeCreateRsbuildConfig(rslibConfig, path) {
+    const internalRsbuildConfig = await createInternalRsbuildConfig();
+    const configPath = path ?? rslibConfig._privateMeta?.configFilePath;
+    const { lib: libConfigsArray, ...sharedRsbuildConfig } = rslibConfig;
+    if (!libConfigsArray) {
+        throw new Error(`Expect lib field to be an array, but got ${libConfigsArray}.`);
+    }
+    const libConfigPromises = libConfigsArray.map(async (libConfig)=>{
+        const { format, ...overrideRsbuildConfig } = libConfig;
+        const baseRsbuildConfig = (0,core_namespaceObject.mergeRsbuildConfig)(sharedRsbuildConfig, overrideRsbuildConfig);
+        // Merge the configuration of each environment based on the shared Rsbuild
+        // configuration and Lib configuration in the settings.
+        const libRsbuildConfig = await composeLibRsbuildConfig(libConfig, baseRsbuildConfig, configPath);
+        // Reset certain fields because they will be completely overridden by the upcoming merge.
+        // We don't want to retain them in the final configuration.
+        // The reset process should occur after merging the library configuration.
+        baseRsbuildConfig.source ??= {};
+        baseRsbuildConfig.source.entry = {};
+        return {
+            format: format,
+            config: (0,core_namespaceObject.mergeRsbuildConfig)(baseRsbuildConfig, libRsbuildConfig, // Merge order matters, keep `internalRsbuildConfig` at the last position
+            // to ensure that the internal config is not overridden by user's config.
+            internalRsbuildConfig)
+        };
+    });
+    const composedRsbuildConfig = await Promise.all(libConfigPromises);
+    return composedRsbuildConfig;
+}
+async function initRsbuild(rslibConfig) {
+    const rsbuildConfigObject = await composeCreateRsbuildConfig(rslibConfig);
+    const environments = {};
+    const formatCount = rsbuildConfigObject.reduce((acc, { format })=>{
+        acc[format] = (acc[format] ?? 0) + 1;
+        return acc;
+    }, {});
+    const formatIndex = {
+        esm: 0,
+        cjs: 0,
+        umd: 0
+    };
+    for (const { format, config } of rsbuildConfigObject){
+        const currentFormatCount = formatCount[format];
+        const currentFormatIndex = formatIndex[format]++;
+        environments[currentFormatCount === 1 ? format : `${format}${currentFormatIndex}`] = config;
+    }
+    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({
+        watch: options?.watch
+    });
+    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.2");
+    const buildCommand = commander_index_js_namespaceObject.program.command('build');
+    const inspectCommand = commander_index_js_namespaceObject.program.command('inspect');
+    [
+        buildCommand,
+        inspectCommand
+    ].forEach(applyCommonOptions);
+    buildCommand.option('-w --watch', 'turn on watch mode, watch for changes and rebuild').description('build the library for production').action(async (options)=>{
+        try {
+            const rslibConfig = await loadConfig(options.config, options.envMode);
+            await build(rslibConfig, options);
+        } catch (err) {
+            dist_logger.error('Failed to build.');
+            dist_logger.error(err);
+            process.exit(1);
+        }
+    });
+    inspectCommand.description('inspect the Rslib / Rsbuild / Rspack configs').option('--env <env>', 'specify env mode', 'development').option('--output <output>', 'specify inspect content output path', './').option('--verbose', 'show full function definitions in output').action(async (options)=>{
+        try {
+            // TODO: inspect should output Rslib's config
+            const rslibConfig = await loadConfig(options.config, options.envMode);
+            const rsbuildInstance = await initRsbuild(rslibConfig);
+            await rsbuildInstance.inspectConfig({
+                mode: options.mode,
+                verbose: options.verbose,
+                outputPath: options.output,
+                writeToDisk: true
+            });
+        } catch (err) {
+            dist_logger.error('Failed to inspect config.');
+            dist_logger.error(err);
+            process.exit(1);
+        }
+    });
+    commander_index_js_namespaceObject.program.parse();
+}
+
+;// CONCATENATED MODULE: ./src/index.ts
+
+
+
+
+
+const src_version = "0.0.2";
+
+export { build, defineConfig, loadConfig, dist_logger as logger, prepareCli, runCli, src_version as version };