@vvi/rollup-external 1.1.2

package/CHANGELOG.md

@@ -0,0 +1,89 @@
+# 更新日志
+
+## 1.1.2 (2026-2-1)
+
+第二参数维护：现在该参数可以是单个字符串或字符串数组，以适应不同的使用需求
+
+## 1.1.1 (2026-1-18)
+
+### 🔧 修复
+
+- 将 "packages.json" 文件中的 `peerDependencies` 也算 `dependencies` 依赖，不需要再显式排除
+
+### ✨ 添加
+
+- 使用第二参数 `true`，打印信息（嗯，貌似没什么用的功能）
+
+## v1.1.0 (2025-12-29)
+
+- 依赖维护
+
+## v1.0.11 (2025-8-12)
+
+- 修复已知问题，该问题导致在 windows 上无法正确排除打包系统文件
+
+## v1.0.10 (2025-7-30)
+
+## v1.0.9 (2025-7-19)
+
+- 更新文档
+
+## v1.0.8 (2025-6-22)
+
+- 更新文档
+
+## v1.0.7 (2025-6-20)
+
+- 更新文档
+
+## v1.0.6 (2025-6-13)
+
+- 优化了参数校验更改后造成的无依赖时校验错误
+
+## v1.0.5 (2025-6-10)
+
+- 么事。这次是阿其那
+
+## v1.0.4 (2025-6-10)
+
+- 么事，修复个贤王
+
+## v1.0.3 (2025-6-10)
+
+- 参数的校验
+
+## v1.0.2 (2025-6-5)
+
+- 需要添加的依赖或排除的依赖添加了执行自动添加到剪切版
+
+## v1.0.1 (2025-6-3)
+
+- 更新文档
+
+## v1.0.0 （5 🈷️ 25 日 2025 年）
+
+- 就是闲的
+
+## v0.1.2 （5 🈷️ 11 日 2025 年）
+
+- 更新文档
+
+## v0.1.1 （5 🈷️ 8 日 2025 年）
+
+- 更新文档
+
+## v0.1.0 （5 🈷️ 3 日 2025 年）
+
+- 嗯，优化了逻辑
+
+## v0.0.2 （5 🈷️ 3 日 2025 年）
+
+- 修复文档
+
+## v0.0.1 （5 🈷️ 3 日 2025 年）
+
+- 修复上一个版本的导出错误
+
+## 0.0.0 (5 月 3 2025 年)
+
+- 初始化项目

package/LICENSE

@@ -0,0 +1,16 @@
+# MIT License
+    
+Copyright ©️ <2025> <MrMudBean>
+
+Permission to use, copy, modify, and/or distribute this software for any  
+purpose with or without fee is hereby granted, provided that the above  
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES  
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF  
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR  
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES  
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN  
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF  
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ 

package/README.md

@@ -0,0 +1,56 @@
+# @vvi/rollup-external
+
+[![version](<https://img.shields.io/npm/v/@vvi/rollup-external.svg?logo=npm&logoColor=rgb(0,0,0)&label=版本号&labelColor=rgb(73,73,228)&color=rgb(0,0,0)>)](https://www.npmjs.com/package/@vvi/rollup-external) [![issues 提交](<https://img.shields.io/badge/issues-提交-rgb(255,0,63)?logo=github>)](https://github.com/MrMudBean/rollup-external/issues)
+
+ 一个简单的 rollup 构建打包时的排除外部依赖的函数（多用于构建 npm 库包）
+
+因为我在构建新的 npm 库包时，常因不仔细导致包
+
+## 安装
+
+```bash
+npm install  --save-dev @vvi/rollup-external
+```
+
+## 使用
+
+在 `rollup.config.js` 文件中配置：
+
+```js
+.... 其他引用
+import { external } from '@vvi/rollup-external';
+.... 其他代码逻辑
+
+export default {
+  ... 其他配置,
+  external: external({
+    // 默认排除 package.json 中 dependencies 的依赖
+    // 排除 `node:`、`a-`、`color-pen` 、`@qqi`开头的依赖
+    exclude: ["node:", "a-" ,"color-pen", "@qqi/"],
+    // 忽略 `node:` 开头的包在 package.json 中未声明的 dependencies 的依赖
+    // 未配置改项，若项目中包含 `node:`
+    ignore: ["node:"],
+    // 一定要包含的依赖，将被打包入打包文件夹内
+    //  或是使用 `src/` 等路径，则报错 “依赖未被排除，打包关闭”
+    include: ['@qqi/copy-text','src/utils', 'src/dog']
+  }),
+  ... 其他配置,
+
+}
+
+```
+
+- 默认读取 `package.json` 中的 `dependencies` 和 `peerDependencies` 的依赖项作为 `exclude` 的值，即改值一般无需配置
+- `include` 使用的全量对比，且优先级要远远高于 `exclude` 和 `ignore` 的配置，若在 `dependencies` 中配置了某依赖却又想将该依赖包含在打包文件内时可使用 `include`（但是需注意包会包含于 'node_modules' 文件夹下，保证 files 字段包含该项）
+- `ignore` 用于忽略那些不包含于 'package.json' 的 `dependencies` 中却需要被排除的依赖，如 `node:`、`src/` 等路径的依赖。校验时以输入的字符串的 `startWith` 判断
+- 可直接不使用参数，如果仅是想排除 'package.json' 文件中 `dependencies` 配置依赖 （怎么感觉有一股翻译腔）
+
+### 第二参数
+
+第二参数可控制在使用时在控制台展示简易日志。
+
+第二参数可接受的类型
+
+- `boolean` ： 为 `true` 将为每一个引入打印简易日志
+- `string` ： 将使用 `id.includes(str)` 的方式判定是否打印该条简易日志
+- `string[]` ：将为数组中的每一项使用 `id.includes(str)` 判定

package/cjs/index.js

@@ -0,0 +1,195 @@
+'use strict';
+
+var copyText = require('@vvi/copy-text');
+var node = require('@vvi/node');
+var is = require('@vvi/is');
+var pen$1 = require('@vvi/pen');
+
+/**  一个展示 🖊️  */
+const pen = pen$1.bgRedPen.blink.bold.yellow;
+/**
+ * ## 依赖配置
+ *
+ * - `include` 包含的包（想打包入结果的包）。优先级最高（譬如：src/ 这种需要 rollup 处理的）
+ * - `ignore`  在排除的包却不需要在 dependencies 中的包，如: `node:stream` 等
+ * - `exclude`  排除且在依赖项中的包（在构建发布后，不会因为依赖项缺失而导致包版本失效）
+ *
+ * 注： `exclude` 是使用完全（<span style="color:#ff0;">Object.is()</span>）匹配模式
+ *
+ * @param options 配置项参数
+ * @param options.exclude 排除项，该项将默认包含 "package.json" 文件中的 `dependencies` 及 `peerDependencies` 的依赖包（包在忽略时使用 `Object.is` 比较）
+ * @param options.ignore 忽略项，该项与 `exclude` 类似，但是
+ * @param options.include
+ * @param logInfo 第二参数，可传入 `boolean`、`string`、`string[]` 类型，用户查看简单日志
+ *        - 当传入为 `true` 时，所有的引入项都将打印日志
+ *        - 当传入为单个字符串时，会打印包含该字符串的引入的日志（模糊匹配）
+ *        - 当传入为字符串数组时，会分别打印包含对应字符串的引入的日志（模糊匹配）
+ *
+ */
+function external(options, 
+/** 打印消息 */
+logInfo = false) {
+    /** 是否打印消息 */
+    let logGlobal = false;
+    if (is.isString(logInfo))
+        logInfo = [logInfo];
+    if (logInfo === true || (is.isArray(logInfo) && logInfo.length > 0)) {
+        logGlobal = true;
+    }
+    const { exclude, ignore, include: _include } = parseParameter(options);
+    const cwd = process.cwd();
+    if (logGlobal) {
+        console.log('当前的工作路径：', pen$1.reversedPen(cwd));
+    }
+    /**
+     * ## 当前的状态值
+     *
+     * 该状态是值依赖是否将被排除
+     *
+     * - false 当前依赖被包含 （返回值为 `false` ）
+     * - true 当前依赖被（返回值为  `true` ）
+     */
+    const currentState = {};
+    /**
+     * # 装进到返回值中
+     */
+    const putPocket = ({ id, message, isLog }, res) => {
+        if (isLog) {
+            console.log(message);
+        }
+        currentState[id] = res;
+        beforeEnd(isLog);
+        return res;
+    };
+    /** 当前设定 */
+    const packageContent = node.getPackageJsonSync();
+    if (is.isNull(packageContent) || !packageContent?.content?.name)
+        throw new RangeError('package.json 文件不存在');
+    const packInfo = packageContent.content;
+    /**  已配置的依赖  */
+    const dependencies = Object.keys({
+        ...(packInfo.dependencies || {}),
+        ...(packInfo.peerDependencies || {}),
+    });
+    /** 包含于的依赖包的数组 */
+    const includeArray = _include.map((currentValue) => {
+        return currentValue.concat('/');
+    });
+    const ignorePkg = is.isEmptyArray(ignore)
+        ? dependencies
+        : [...ignore, ...dependencies];
+    /** 配置需要不打包进生产包的包名配置 （这就保证了 excludedRegExp 非空 ） */
+    const excludedPkg = is.isEmptyArray(exclude) ? ['node:'] : exclude;
+    /** 排除的依赖项的正则，仅检测是否包含为头 */
+    const excludedRegExp = new RegExp('^'.concat([...ignorePkg, ...excludedPkg].join('|^')));
+    if (logGlobal) {
+        console.log('排除的包', excludedPkg);
+        console.log('执行校验的数组', excludedRegExp);
+        console.log('执行包含包', _include);
+        console.log('执行包含的包子内容', includeArray);
+    }
+    const beforeEnd = (isLog) => isLog && (console.log(), console.groupEnd());
+    /**
+     * 实际执行的文件
+     */
+    return (id, parentId, isHandle) => {
+        /** 是否可打印 */
+        const isLog = logInfo === true ||
+            (is.isArray(logInfo) && logInfo.some(e => id?.includes(e)));
+        if (isLog) {
+            console.log();
+            console.groupCollapsed('本次检测的 id：', pen$1.magentaPen(id));
+            console.log('当前提供的 id 是否为文件', node.fileExist(node.pathJoin(cwd, id)) ? '✅' : '❌');
+            console.log(`该 id（${pen$1.cyanPen(id)}）是否为文件：${node.fileExist(node.pathJoin(cwd, id)) ? '✅' : '❌'}`);
+            parentId &&
+                console.log(`该 id（${pen$1.cyanPen(id)}）调用父级：${pen$1.brightYellowPen(parentId)}`);
+            console.log(`该 id（${pen$1.cyanPen(id)}）是否已处理：${pen$1.bgBlackPen(isHandle)}`);
+        }
+        /** 有父级设定的值 */
+        if (parentId && is.isBoolean(currentState[parentId])) {
+            const res = currentState[parentId];
+            return putPocket({
+                id,
+                message: `跟随父级 「${parentId}」 的设定值 {${res}}`,
+                isLog,
+            }, res);
+        }
+        if (id.startsWith(cwd) && node.fileExist(id)) {
+            return putPocket({ id, message: '是存在的绝对路径的文件', isLog }, false);
+        }
+        else if (node.fileExist(node.pathJoin(cwd, id))) {
+            return putPocket({ id, message: '是存在的相对路径的文件', isLog }, false);
+        }
+        if (_include.includes(id) || includeArray.some(e => id.startsWith(e))) {
+            // 包存在于 included 中，直接交给 rollup 处理
+            return putPocket({
+                id,
+                message: `${pen$1.cyanPen(id)} 被显式声明打（进）包`,
+                isLog,
+            }, false);
+        }
+        // 重制识别位置
+        excludedRegExp.lastIndex = 0;
+        /**  是否在设定排除之外（包含要忽略的包）  */
+        const result = excludedRegExp.test(id);
+        /// 保证排除的包纯在于
+        if (is.isTrue(result)) {
+            if (
+            // 检测到了包名存在于配置中
+            is.isFalse(dependencies.includes(id)) &&
+                ignorePkg.every(e => !id.startsWith(e))) {
+                const msg = `${pen(id)} ${copy(id)} 依赖被排除打包却未在 package.json 中配置`;
+                if (isLog) {
+                    console.error(msg);
+                }
+                node._p(msg);
+                process.exit(1);
+            }
+        }
+        // 包不存在于配置中，但是却是非本地包
+        else if (/^[^./]/g.test(id)) {
+            const msg = `${pen(id)}  ${copy(id)}  依赖未被排除，打包关闭`;
+            if (isLog) {
+                console.error(msg);
+            }
+            node._p(msg);
+            process.exit(1);
+        }
+        return putPocket({ id, message: '', isLog }, result);
+    };
+}
+/**
+ *  复制
+ * @param str 待赋复制的文本
+ */
+function copy(str) {
+    str = node.isWindows ? str.replace(/[\\]/gm, '\\\\') : str;
+    return copyText.copyTextToClipboard(str) === str ? pen$1.hexPen('#666') `已复制` : '';
+}
+/**
+ * 校验是否是字符串数组并返回格式化后标准的数组
+ * @param arr 待转化的数组
+ */
+function isStrArr(arr) {
+    if (!is.isArray(arr))
+        return [];
+    if (is.isString(arr))
+        return [arr];
+    return arr.filter(e => is.isString(e) && !is.isBusinessEmptyString(e));
+}
+/**
+ * 解析参数
+ * @param options 参数项
+ * @param options.exclude 排除项
+ * @param options.ignore 忽略项
+ * @param options.include 包含项
+ */
+function parseParameter(options) {
+    return {
+        exclude: isStrArr(options?.exclude),
+        ignore: isStrArr(options?.ignore),
+        include: isStrArr(options?.include),
+    };
+}
+
+exports.external = external;

package/es/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ## 依赖配置
+ *
+ * - `include` 包含的包（想打包入结果的包）。优先级最高（譬如：src/ 这种需要 rollup 处理的）
+ * - `ignore`  在排除的包却不需要在 dependencies 中的包，如: `node:stream` 等
+ * - `exclude`  排除且在依赖项中的包（在构建发布后，不会因为依赖项缺失而导致包版本失效）
+ *
+ * 注： `exclude` 是使用完全（<span style="color:#ff0;">Object.is()</span>）匹配模式
+ *
+ * @param options 配置项参数
+ * @param options.exclude 排除项，该项将默认包含 "package.json" 文件中的 `dependencies` 及 `peerDependencies` 的依赖包（包在忽略时使用 `Object.is` 比较）
+ * @param options.ignore 忽略项，该项与 `exclude` 类似，但是
+ * @param options.include
+ * @param logInfo 第二参数，可传入 `boolean`、`string`、`string[]` 类型，用户查看简单日志
+ *        - 当传入为 `true` 时，所有的引入项都将打印日志
+ *        - 当传入为单个字符串时，会打印包含该字符串的引入的日志（模糊匹配）
+ *        - 当传入为字符串数组时，会分别打印包含对应字符串的引入的日志（模糊匹配）
+ *
+ */
+export declare function external(options?: {
+    /**  排除且在依赖项中的包（在构建发布后，不会因为依赖项缺失而导致包版本失效）  */
+    exclude?: string[] | string;
+    /**  在排除的包却不需要在 dependencies  中的包，如： node:stream 等  */
+    ignore?: string[] | string;
+    /**
+     * 包含的包（打包入结果的包）。优先级最高（譬如：src/ 这种需要 rollup 处理的）。
+     *
+     * 但是该项不像 ignore 和 exclude 是 `startsWith` 匹配，该项是完整权等匹配  */
+    include?: string[] | string;
+}, 
+/** 打印消息 */
+logInfo?: boolean | string | string[]): (id: string, parentId: string | undefined, isHandle: boolean) => boolean;

package/es/index.js

@@ -0,0 +1,193 @@
+import { copyTextToClipboard } from '@vvi/copy-text';
+import { getPackageJsonSync, fileExist, pathJoin, _p, isWindows } from '@vvi/node';
+import { isString, isArray, isNull, isEmptyArray, isBoolean, isTrue, isFalse, isBusinessEmptyString } from '@vvi/is';
+import { bgRedPen, reversedPen, magentaPen, cyanPen, brightYellowPen, bgBlackPen, hexPen } from '@vvi/pen';
+
+/**  一个展示 🖊️  */
+const pen = bgRedPen.blink.bold.yellow;
+/**
+ * ## 依赖配置
+ *
+ * - `include` 包含的包（想打包入结果的包）。优先级最高（譬如：src/ 这种需要 rollup 处理的）
+ * - `ignore`  在排除的包却不需要在 dependencies 中的包，如: `node:stream` 等
+ * - `exclude`  排除且在依赖项中的包（在构建发布后，不会因为依赖项缺失而导致包版本失效）
+ *
+ * 注： `exclude` 是使用完全（<span style="color:#ff0;">Object.is()</span>）匹配模式
+ *
+ * @param options 配置项参数
+ * @param options.exclude 排除项，该项将默认包含 "package.json" 文件中的 `dependencies` 及 `peerDependencies` 的依赖包（包在忽略时使用 `Object.is` 比较）
+ * @param options.ignore 忽略项，该项与 `exclude` 类似，但是
+ * @param options.include
+ * @param logInfo 第二参数，可传入 `boolean`、`string`、`string[]` 类型，用户查看简单日志
+ *        - 当传入为 `true` 时，所有的引入项都将打印日志
+ *        - 当传入为单个字符串时，会打印包含该字符串的引入的日志（模糊匹配）
+ *        - 当传入为字符串数组时，会分别打印包含对应字符串的引入的日志（模糊匹配）
+ *
+ */
+function external(options, 
+/** 打印消息 */
+logInfo = false) {
+    /** 是否打印消息 */
+    let logGlobal = false;
+    if (isString(logInfo))
+        logInfo = [logInfo];
+    if (logInfo === true || (isArray(logInfo) && logInfo.length > 0)) {
+        logGlobal = true;
+    }
+    const { exclude, ignore, include: _include } = parseParameter(options);
+    const cwd = process.cwd();
+    if (logGlobal) {
+        console.log('当前的工作路径：', reversedPen(cwd));
+    }
+    /**
+     * ## 当前的状态值
+     *
+     * 该状态是值依赖是否将被排除
+     *
+     * - false 当前依赖被包含 （返回值为 `false` ）
+     * - true 当前依赖被（返回值为  `true` ）
+     */
+    const currentState = {};
+    /**
+     * # 装进到返回值中
+     */
+    const putPocket = ({ id, message, isLog }, res) => {
+        if (isLog) {
+            console.log(message);
+        }
+        currentState[id] = res;
+        beforeEnd(isLog);
+        return res;
+    };
+    /** 当前设定 */
+    const packageContent = getPackageJsonSync();
+    if (isNull(packageContent) || !packageContent?.content?.name)
+        throw new RangeError('package.json 文件不存在');
+    const packInfo = packageContent.content;
+    /**  已配置的依赖  */
+    const dependencies = Object.keys({
+        ...(packInfo.dependencies || {}),
+        ...(packInfo.peerDependencies || {}),
+    });
+    /** 包含于的依赖包的数组 */
+    const includeArray = _include.map((currentValue) => {
+        return currentValue.concat('/');
+    });
+    const ignorePkg = isEmptyArray(ignore)
+        ? dependencies
+        : [...ignore, ...dependencies];
+    /** 配置需要不打包进生产包的包名配置 （这就保证了 excludedRegExp 非空 ） */
+    const excludedPkg = isEmptyArray(exclude) ? ['node:'] : exclude;
+    /** 排除的依赖项的正则，仅检测是否包含为头 */
+    const excludedRegExp = new RegExp('^'.concat([...ignorePkg, ...excludedPkg].join('|^')));
+    if (logGlobal) {
+        console.log('排除的包', excludedPkg);
+        console.log('执行校验的数组', excludedRegExp);
+        console.log('执行包含包', _include);
+        console.log('执行包含的包子内容', includeArray);
+    }
+    const beforeEnd = (isLog) => isLog && (console.log(), console.groupEnd());
+    /**
+     * 实际执行的文件
+     */
+    return (id, parentId, isHandle) => {
+        /** 是否可打印 */
+        const isLog = logInfo === true ||
+            (isArray(logInfo) && logInfo.some(e => id?.includes(e)));
+        if (isLog) {
+            console.log();
+            console.groupCollapsed('本次检测的 id：', magentaPen(id));
+            console.log('当前提供的 id 是否为文件', fileExist(pathJoin(cwd, id)) ? '✅' : '❌');
+            console.log(`该 id（${cyanPen(id)}）是否为文件：${fileExist(pathJoin(cwd, id)) ? '✅' : '❌'}`);
+            parentId &&
+                console.log(`该 id（${cyanPen(id)}）调用父级：${brightYellowPen(parentId)}`);
+            console.log(`该 id（${cyanPen(id)}）是否已处理：${bgBlackPen(isHandle)}`);
+        }
+        /** 有父级设定的值 */
+        if (parentId && isBoolean(currentState[parentId])) {
+            const res = currentState[parentId];
+            return putPocket({
+                id,
+                message: `跟随父级 「${parentId}」 的设定值 {${res}}`,
+                isLog,
+            }, res);
+        }
+        if (id.startsWith(cwd) && fileExist(id)) {
+            return putPocket({ id, message: '是存在的绝对路径的文件', isLog }, false);
+        }
+        else if (fileExist(pathJoin(cwd, id))) {
+            return putPocket({ id, message: '是存在的相对路径的文件', isLog }, false);
+        }
+        if (_include.includes(id) || includeArray.some(e => id.startsWith(e))) {
+            // 包存在于 included 中，直接交给 rollup 处理
+            return putPocket({
+                id,
+                message: `${cyanPen(id)} 被显式声明打（进）包`,
+                isLog,
+            }, false);
+        }
+        // 重制识别位置
+        excludedRegExp.lastIndex = 0;
+        /**  是否在设定排除之外（包含要忽略的包）  */
+        const result = excludedRegExp.test(id);
+        /// 保证排除的包纯在于
+        if (isTrue(result)) {
+            if (
+            // 检测到了包名存在于配置中
+            isFalse(dependencies.includes(id)) &&
+                ignorePkg.every(e => !id.startsWith(e))) {
+                const msg = `${pen(id)} ${copy(id)} 依赖被排除打包却未在 package.json 中配置`;
+                if (isLog) {
+                    console.error(msg);
+                }
+                _p(msg);
+                process.exit(1);
+            }
+        }
+        // 包不存在于配置中，但是却是非本地包
+        else if (/^[^./]/g.test(id)) {
+            const msg = `${pen(id)}  ${copy(id)}  依赖未被排除，打包关闭`;
+            if (isLog) {
+                console.error(msg);
+            }
+            _p(msg);
+            process.exit(1);
+        }
+        return putPocket({ id, message: '', isLog }, result);
+    };
+}
+/**
+ *  复制
+ * @param str 待赋复制的文本
+ */
+function copy(str) {
+    str = isWindows ? str.replace(/[\\]/gm, '\\\\') : str;
+    return copyTextToClipboard(str) === str ? hexPen('#666') `已复制` : '';
+}
+/**
+ * 校验是否是字符串数组并返回格式化后标准的数组
+ * @param arr 待转化的数组
+ */
+function isStrArr(arr) {
+    if (!isArray(arr))
+        return [];
+    if (isString(arr))
+        return [arr];
+    return arr.filter(e => isString(e) && !isBusinessEmptyString(e));
+}
+/**
+ * 解析参数
+ * @param options 参数项
+ * @param options.exclude 排除项
+ * @param options.ignore 忽略项
+ * @param options.include 包含项
+ */
+function parseParameter(options) {
+    return {
+        exclude: isStrArr(options?.exclude),
+        ignore: isStrArr(options?.ignore),
+        include: isStrArr(options?.include),
+    };
+}
+
+export { external };

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@vvi/rollup-external",
+  "version": "1.1.2",
+  "type": "module",
+  "main": "cjs/index.js",
+  "module": "es/index.js",
+  "types": "es/index.d.ts",
+  "author": {
+    "name": "泥豆君",
+    "email": "Mr.MudBean@outlook.com",
+    "url": "https://mudbean.cn"
+  },
+  "description": "用于 rollup 打包 📦 时排除异己的工具 🔧",
+  "sideEffects": false,
+  "license": "MIT",
+  "files": [
+    "cjs",
+    "es",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "default": "./es/index.js",
+        "types": "./es/index.d.ts"
+      },
+      "require": {
+        "default": "./cjs/index.js",
+        "types": "./es/index.d.ts"
+      }
+    }
+  },
+  "keywords": [
+    "rollup-external",
+    "mudbean",
+    "vvi"
+  ],
+  "homepage": "https://npm.lmssee.com/rollup-external",
+  "dependencies": {
+    "@vvi/copy-text": "^1.1.1",
+    "@vvi/is": "^2.0.5",
+    "@vvi/log": "^1.1.5",
+    "@vvi/node": "^4.4.3",
+    "@vvi/pen": "^3.0.2"
+  },
+  "bugs": {
+    "url": "https://github.com/MrMudBean/rollup-external/issues",
+    "email": "Mr.MudBean@outlook.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MrMudBean/rollup-external.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "browserslist": [
+    "node>=18.0.0"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}