@rolldown/plugin-babel 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present, rolldown/plugins repository contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,203 @@
+# @rolldown/plugin-babel
+
+Rolldown plugin for transforming code with [Babel](https://babeljs.io/).
+
+## Install
+
+```bash
+npm install @rolldown/plugin-babel @babel/core
+```
+
+## Usage
+
+```js
+import babelPlugin from '@rolldown/plugin-babel'
+
+export default {
+  plugins: [
+    babelPlugin({
+      presets: [['@babel/preset-env', { targets: { chrome: '100' } }]],
+    }),
+  ],
+}
+```
+
+The plugin automatically configures Babel's parser for `.jsx`, `.ts`, and `.tsx` files.
+
+> **Note:** This plugin does not load Babel configuration files (e.g., `babel.config.js`, `.babelrc`). All Babel options must be passed directly through the plugin options.
+
+## Options
+
+### `include`
+
+- **Type:** `string | RegExp | (string | RegExp)[]`
+
+If specified, only files matching the pattern will be processed.
+
+### `exclude`
+
+- **Type:** `string | RegExp | (string | RegExp)[]`
+- **Default:** `/[\/\\]node_modules[\/\\]/`
+
+Files matching the pattern will be skipped.
+
+### `sourceMap`
+
+- **Type:** `boolean`
+- **Default:** `true`
+
+Set to `false` to skip source map generation for better performance.
+
+### `presets`
+
+- **Type:** `(babel.PresetItem | RolldownBabelPreset)[]`
+
+List of Babel presets to apply. Supports both standard Babel presets and Rolldown-enhanced presets with per-file filtering (see [Rolldown Babel Presets](#rolldown-babel-presets)).
+
+### `plugins`
+
+- **Type:** `babel.PluginItem[]`
+
+List of Babel plugins to apply.
+
+### `overrides`
+
+- **Type:** `InnerTransformOptions[]`
+
+Array of additional configurations that are merged into the current configuration. Use with Babel's `test`/`include`/`exclude` options to conditionally apply overrides.
+
+### Other Babel options
+
+The following [Babel options](https://babeljs.io/docs/options) are forwarded directly:
+
+`assumptions`, `auxiliaryCommentAfter`, `auxiliaryCommentBefore`, `comments`, `compact`, `cwd`, `generatorOpts`, `parserOpts`, `retainLines`, `shouldPrintComment`, `targets`, `wrapPluginVisitorMethod`
+
+## Rolldown Babel Presets
+
+Standard Babel presets are applied to every file. When a preset should only apply to certain files, wrap it in a `RolldownBabelPreset` with a `filter`. Use the `defineRolldownBabelPreset` helper for type checking:
+
+```js
+import babelPlugin, { defineRolldownBabelPreset } from '@rolldown/plugin-babel'
+
+const myReactPreset = defineRolldownBabelPreset({
+  preset: ['@babel/preset-react'],
+  rolldown: {
+    filter: {
+      id: /\.tsx?$/,
+      moduleType: ['tsx', 'jsx'],
+      code: /from ['"]react['"]/,
+    },
+  },
+})
+
+export default {
+  plugins: [
+    babelPlugin({
+      presets: [myReactPreset],
+    }),
+  ],
+}
+```
+
+### Filter dimensions
+
+All filter dimensions are optional. When multiple dimensions are specified, all must match for the preset to apply.
+
+#### `id`
+
+Match files by path. Accepts a string glob, RegExp, array, or `{ include, exclude }` object.
+
+```js
+{ id: /\.tsx$/ }
+{ id: '**/*.tsx' }
+{ id: [/\.tsx$/, /\.jsx$/] }
+{ id: { include: [/\.tsx$/], exclude: [/test\.tsx$/] } }
+```
+
+#### `moduleType`
+
+Match by Rolldown module type. Accepts a string array or `{ include }` object.
+
+```js
+{
+  moduleType: ['tsx', 'jsx']
+}
+{
+  moduleType: {
+    include: ['tsx']
+  }
+}
+```
+
+#### `code`
+
+Match by file content. Accepts a RegExp, array, or `{ include, exclude }` object.
+
+```js
+{ code: /import React/ }
+{ code: { include: [/import React/], exclude: [/\/\/ @no-transform/] } }
+```
+
+### `configResolvedHook`
+
+When used with Vite, a preset can define a `configResolvedHook` callback to conditionally enable or disable itself based on the resolved Vite config. The callback receives the `ResolvedConfig` and should return `false` to remove the preset.
+
+```js
+defineRolldownBabelPreset({
+  preset: ['@babel/preset-react'],
+  rolldown: {
+    filter: { id: /\.[jt]sx$/ },
+    configResolvedHook(config) {
+      // Only apply during production builds
+      return config.command === 'build'
+    },
+  },
+})
+```
+
+When running without Vite (pure Rolldown), `configResolvedHook` is ignored.
+
+### `applyToEnvironmentHook`
+
+When used with Vite, a preset can define an `applyToEnvironmentHook` callback to conditionally enable or disable itself based on the Vite environment. The callback receives the `PartialEnvironment` and should return `false` to remove the preset for that environment.
+
+```js
+defineRolldownBabelPreset({
+  preset: ['@babel/preset-react'],
+  rolldown: {
+    filter: { id: /\.[jt]sx$/ },
+    applyToEnvironmentHook(environment) {
+      // Only apply in the client environment
+      return environment.name === 'client'
+    },
+  },
+})
+```
+
+When running without Vite (pure Rolldown), `applyToEnvironmentHook` is ignored.
+
+### How preset filters work
+
+Preset filters operate at two levels:
+
+1. **Per-file filtering** — When Rolldown calls the transform hook, each preset's filter is checked against the current file. Presets whose filter doesn't match are skipped for that file.
+
+2. **Transform hook pre-filtering** — The plugin computes a union of all preset filters to tell Rolldown which files to send to the transform hook in the first place. This avoids calling into the plugin for files that no preset would match.
+
+You can mix standard Babel presets and Rolldown presets freely:
+
+```js
+babelPlugin({
+  presets: [
+    '@babel/preset-env', // applied to all files
+    {
+      preset: ['@babel/preset-react'],
+      rolldown: { filter: { id: /\.[jt]sx$/ } },
+    },
+  ],
+})
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,56 @@
+import * as babel from "@babel/core";
+import { GeneralHookFilter, ModuleTypeFilter, Plugin } from "rolldown";
+import { Plugin as Plugin$1, ResolvedConfig } from "vite";
+
+//#region src/rolldownPreset.d.ts
+type PartialEnvironment = Parameters<NonNullable<Plugin$1['applyToEnvironment']>>[0];
+type RolldownBabelPreset = {
+  preset: babel.PresetItem;
+  rolldown: {
+    filter?: {
+      id?: GeneralHookFilter;
+      moduleType?: ModuleTypeFilter;
+      code?: GeneralHookFilter;
+    };
+    applyToEnvironmentHook?: (environment: PartialEnvironment) => boolean;
+    configResolvedHook?: (config: ResolvedConfig) => boolean;
+  };
+};
+type RolldownBabelPresetItem = babel.PresetItem | RolldownBabelPreset;
+declare function defineRolldownBabelPreset(preset: RolldownBabelPreset): RolldownBabelPreset;
+//#endregion
+//#region src/options.d.ts
+interface InnerTransformOptions extends Pick<babel.InputOptions, 'assumptions' | 'auxiliaryCommentAfter' | 'auxiliaryCommentBefore' | 'exclude' | 'comments' | 'compact' | 'cwd' | 'generatorOpts' | 'include' | 'parserOpts' | 'plugins' | 'retainLines' | 'shouldPrintComment' | 'targets' | 'wrapPluginVisitorMethod'> {
+  /**
+   * List of presets (a set of plugins) to load and use
+   *
+   * Default: `[]`
+   */
+  presets?: RolldownBabelPresetItem[] | undefined;
+}
+interface PluginOptions extends Omit<InnerTransformOptions, 'include' | 'exclude'> {
+  /**
+   * If specified, only files matching the pattern will be processed by babel.
+   */
+  include?: InnerTransformOptions['include'];
+  /**
+   * If any of patterns match, babel will not process the file.
+   * @default `/[\/\\]node_modules[\/\\]/`
+   */
+  exclude?: InnerTransformOptions['exclude'];
+  /**
+   * If false, skips source map generation. This will improve performance.
+   * @default true
+   */
+  sourceMap?: boolean;
+  /**
+   * Allows users to provide an array of options that will be merged into the current configuration one at a time.
+   * This feature is best used alongside the "test"/"include"/"exclude" options to provide conditions for which an override should apply
+   */
+  overrides?: InnerTransformOptions[] | undefined;
+}
+//#endregion
+//#region src/index.d.ts
+declare function babelPlugin(rawOptions: PluginOptions): Promise<Plugin>;
+//#endregion
+export { type RolldownBabelPreset, babelPlugin as default, defineRolldownBabelPreset };

package/dist/index.mjs

@@ -0,0 +1,360 @@
+import picomatch from "picomatch";
+import * as babel from "@babel/core";
+
+//#region src/utils.ts
+function arrayify(value) {
+	return Array.isArray(value) ? value : [value];
+}
+function filterMap(array, predicate) {
+	const newArray = [];
+	for (const [index, item] of array.entries()) {
+		const result = predicate(item, index);
+		if (result) newArray.push(result.value);
+	}
+	return newArray;
+}
+
+//#endregion
+//#region src/rolldownPreset.ts
+function compilePattern(pattern) {
+	if (pattern instanceof RegExp) return (value) => pattern.test(value);
+	return picomatch(pattern);
+}
+function compilePatterns(patterns) {
+	const matchers = patterns.map(compilePattern);
+	return (value) => matchers.some((m) => m(value));
+}
+/**
+* Pre-compile a GeneralHookFilter into a single matcher function.
+* Returns undefined when the filter matches everything.
+*/
+function compileGeneralHookFilter(filter) {
+	if (filter == null) return void 0;
+	let include;
+	let exclude;
+	if (typeof filter === "string" || filter instanceof RegExp) include = [filter];
+	else if (Array.isArray(filter)) include = filter;
+	else {
+		include = filter.include != null ? arrayify(filter.include) : void 0;
+		exclude = filter.exclude != null ? arrayify(filter.exclude) : void 0;
+	}
+	const includeMatcher = include ? compilePatterns(include) : void 0;
+	const excludeMatcher = exclude ? compilePatterns(exclude) : void 0;
+	if (includeMatcher && excludeMatcher) return (value) => !excludeMatcher(value) && includeMatcher(value);
+	if (excludeMatcher) return (value) => !excludeMatcher(value);
+	return includeMatcher;
+}
+function compileModuleTypeFilter(filter) {
+	if (filter == null) return void 0;
+	const types = Array.isArray(filter) ? filter : filter.include ?? [];
+	if (types.length === 0) return void 0;
+	const typeSet = new Set(types);
+	return (value) => typeSet.has(value);
+}
+/**
+* Pre-compile a preset's filter into a single matcher function
+* that checks all dimensions (id, moduleType, code) at once.
+* Returns undefined when the filter matches everything.
+*/
+function compilePresetFilter(filter) {
+	if (!filter) return void 0;
+	const matchId = compileGeneralHookFilter(filter.id);
+	const matchModuleType = compileModuleTypeFilter(filter.moduleType);
+	const matchCode = compileGeneralHookFilter(filter.code);
+	if (!matchId && !matchModuleType && !matchCode) return void 0;
+	return (ctx) => (!matchId || matchId(ctx.id)) && (!matchModuleType || matchModuleType(ctx.moduleType)) && (!matchCode || matchCode(ctx.code));
+}
+function defineRolldownBabelPreset(preset) {
+	return preset;
+}
+function convertToBabelPresetItem(ctx, preset, compiledFilter) {
+	if (typeof preset !== "object" || !("rolldown" in preset)) return { value: preset };
+	if (compiledFilter && !compiledFilter(ctx)) return void 0;
+	return { value: preset.preset };
+}
+
+//#endregion
+//#region src/options.ts
+function resolveOptions(options) {
+	return {
+		...options,
+		exclude: options.exclude ?? [/[/\\]node_modules[/\\]/],
+		sourceMap: options.sourceMap ?? true
+	};
+}
+function compilePresetFilters(presets) {
+	return presets.map((preset) => typeof preset === "object" && "rolldown" in preset ? compilePresetFilter(preset.rolldown.filter) : void 0);
+}
+function filterPresetArrayWithEnvironment(presets, environment) {
+	return presets.filter((preset) => {
+		if (typeof preset !== "object" || !("rolldown" in preset)) return true;
+		if (!preset.rolldown.applyToEnvironmentHook) return true;
+		return preset.rolldown.applyToEnvironmentHook(environment);
+	});
+}
+function filterPresetsWithEnvironment(options, environment) {
+	return {
+		...options,
+		presets: options.presets ? filterPresetArrayWithEnvironment(options.presets, environment) : void 0,
+		overrides: options.overrides?.map((override) => override.presets ? {
+			...override,
+			presets: filterPresetArrayWithEnvironment(override.presets, environment)
+		} : override)
+	};
+}
+function filterPresetArray(presets, config) {
+	return presets.filter((preset) => {
+		if (typeof preset !== "object" || !("rolldown" in preset)) return true;
+		if (!preset.rolldown.configResolvedHook) return true;
+		return preset.rolldown.configResolvedHook(config);
+	});
+}
+function filterPresetsWithConfigResolved(options, config) {
+	return {
+		...options,
+		presets: options.presets ? filterPresetArray(options.presets, config) : void 0,
+		overrides: options.overrides?.map((override) => override.presets ? {
+			...override,
+			presets: filterPresetArray(override.presets, config)
+		} : override)
+	};
+}
+/**
+* Pre-compile all preset filters and return a function that
+* converts options to babel options for a given context.
+*/
+function createBabelOptionsConverter(options) {
+	const presetFilters = options.presets ? compilePresetFilters(options.presets) : void 0;
+	const overridePresetFilters = options.overrides?.map((override) => override.presets ? compilePresetFilters(override.presets) : void 0);
+	return function(ctx) {
+		return {
+			...options,
+			presets: options.presets ? filterMap(options.presets, (preset, i) => convertToBabelPresetItem(ctx, preset, presetFilters[i])) : void 0,
+			overrides: options.overrides?.map((override, i) => override.presets ? {
+				...override,
+				presets: filterMap(override.presets, (preset, j) => convertToBabelPresetItem(ctx, preset, overridePresetFilters[i][j]))
+			} : override)
+		};
+	};
+}
+
+//#endregion
+//#region src/filter.ts
+/**
+* Extract string/RegExp values from babel's ConfigApplicableTest,
+* filtering out function entries which HookFilter can't represent.
+* If any function entry is present, returns undefined because the
+* function could match anything we can't predict at the HookFilter level.
+*/
+function extractStringOrRegExp(test) {
+	if (test === void 0) return void 0;
+	const items = arrayify(test);
+	const result = [];
+	for (const item of items) {
+		if (typeof item === "function") return;
+		result.push(item);
+	}
+	return result.length > 0 ? result : void 0;
+}
+/**
+* Normalize a GeneralHookFilter into { include?, exclude? } form.
+*/
+function normalizeGeneralHookFilter(filter) {
+	if (filter == null) return {};
+	if (typeof filter === "string" || filter instanceof RegExp) return { include: [filter] };
+	if (Array.isArray(filter)) return { include: filter };
+	return {
+		include: filter.include != null ? arrayify(filter.include) : void 0,
+		exclude: filter.exclude != null ? arrayify(filter.exclude) : void 0
+	};
+}
+function isRolldownBabelPreset(preset) {
+	return typeof preset === "object" && preset !== null && "rolldown" in preset;
+}
+function normalizeModuleTypeFilter(filter) {
+	if (Array.isArray(filter)) return filter;
+	return filter.include ?? [];
+}
+function patternKey(pattern) {
+	return typeof pattern === "string" ? `s:${pattern}` : `r:${pattern.source}:${pattern.flags}`;
+}
+/**
+* Compute the intersection of arrays by key.
+* An item is kept only if it appears in every array.
+* If any array is undefined, the intersection is empty.
+*/
+function intersectArrays(arrays, keyFn) {
+	if (arrays.length === 0) return [];
+	const defined = arrays.filter((a) => a != null);
+	if (defined.length < arrays.length) return [];
+	let result = new Map(defined[0].map((p) => [keyFn(p), p]));
+	for (let i = 1; i < defined.length; i++) {
+		const keys = new Set(defined[i].map((p) => keyFn(p)));
+		for (const key of result.keys()) if (!keys.has(key)) result.delete(key);
+	}
+	return [...result.values()];
+}
+function concatArrays(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	return [...a, ...b];
+}
+/**
+* Union filter values from multiple presets for a single dimension.
+* Includes are unioned (OR). Excludes are intersected (only items in ALL presets are kept).
+*
+* @param rawFilters  Per-preset filter values. undefined = no filter (matches everything).
+* @param normalize   Converts a raw filter into { include?, exclude? } arrays.
+* @param keyFn       Serializes an item for intersection comparison.
+*/
+function unionFilters(rawFilters, normalize, keyFn) {
+	let matchAll = false;
+	const includes = [];
+	const excludeArrays = [];
+	for (const raw of rawFilters) {
+		if (raw === void 0) {
+			matchAll = true;
+			excludeArrays.push(void 0);
+			continue;
+		}
+		const n = normalize(raw);
+		if (!matchAll) if (n.include) includes.push(...n.include);
+		else matchAll = true;
+		excludeArrays.push(n.exclude);
+	}
+	return {
+		includes: matchAll ? void 0 : includes.length > 0 ? includes : void 0,
+		excludes: intersectArrays(excludeArrays, keyFn)
+	};
+}
+/**
+* Build the transform hook filter by intersecting a baseFilter (from user
+* include/exclude options) with a presetFilter (union of all RolldownBabelPreset
+* filters).
+*
+* - baseFilter constrains by id only (include/exclude from user options).
+* - presetFilter constrains by id, moduleType, and code. Includes are unioned
+*   across presets (OR), excludes are intersected (only patterns in ALL presets).
+* - The result uses user includes when present, otherwise falls back to preset
+*   includes. Excludes are combined from both (excluded by either → excluded).
+* - If the user has explicit plugins, presetFilter is skipped (plugins can match
+*   any file). Same if any preset is a plain babel preset without rolldown filters.
+*/
+function calculateTransformFilter(options) {
+	const userInclude = extractStringOrRegExp(options.include);
+	const userExclude = extractStringOrRegExp(options.exclude);
+	const baseFilter = { id: {
+		include: userInclude,
+		exclude: userExclude
+	} };
+	if (options.plugins && options.plugins.length > 0) return baseFilter;
+	const presets = options.presets;
+	if (!presets || presets.length === 0) return baseFilter;
+	for (const preset of presets) if (!isRolldownBabelPreset(preset) || !preset.rolldown.filter) return baseFilter;
+	const filters = presets.map((p) => p.rolldown.filter);
+	const idUnion = unionFilters(filters.map((f) => f.id), normalizeGeneralHookFilter, patternKey);
+	const moduleTypeUnion = unionFilters(filters.map((f) => f.moduleType), (f) => {
+		const types = normalizeModuleTypeFilter(f);
+		return { include: types.length > 0 ? types : void 0 };
+	}, (s) => s);
+	const codeUnion = unionFilters(filters.map((f) => f.code), normalizeGeneralHookFilter, patternKey);
+	const finalFilter = {};
+	const finalFilterIdInclude = userInclude ?? idUnion.includes;
+	const finalFilterIdExclude = concatArrays(userExclude, idUnion.excludes.length > 0 ? idUnion.excludes : void 0);
+	if (finalFilterIdInclude || finalFilterIdExclude) finalFilter.id = {
+		include: finalFilterIdInclude,
+		exclude: finalFilterIdExclude
+	};
+	if (moduleTypeUnion.includes) finalFilter.moduleType = moduleTypeUnion.includes;
+	if (codeUnion.includes) {
+		const finalFilterCodeExclude = codeUnion.excludes.length > 0 ? codeUnion.excludes : void 0;
+		if (finalFilterCodeExclude) finalFilter.code = {
+			include: codeUnion.includes,
+			exclude: finalFilterCodeExclude
+		};
+		else finalFilter.code = codeUnion.includes;
+	}
+	return finalFilter;
+}
+/**
+* Calculate the filters to apply to the plugin
+*/
+function calculatePluginFilters(options) {
+	return { transformFilter: calculateTransformFilter(options) };
+}
+
+//#endregion
+//#region src/index.ts
+async function babelPlugin(rawOptions) {
+	let configFilteredOptions;
+	const envState = /* @__PURE__ */ new Map();
+	const plugin = {
+		name: "@rolldown/plugin-babel",
+		configResolved(config) {
+			configFilteredOptions = filterPresetsWithConfigResolved(rawOptions, config);
+			const resolved = resolveOptions(configFilteredOptions);
+			plugin.transform.filter = calculatePluginFilters(resolved).transformFilter;
+		},
+		applyToEnvironment(environment) {
+			const envOptions = filterPresetsWithEnvironment(configFilteredOptions, environment);
+			if (!envOptions.presets?.length && !envOptions.plugins?.length && !envOptions.overrides?.some((o) => o.presets?.length || o.plugins?.length)) return false;
+			const resolved = resolveOptions(envOptions);
+			envState.set(environment.name, createBabelOptionsConverter(resolved));
+			return true;
+		},
+		outputOptions() {
+			if (this.meta.viteVersion) return;
+			const resolved = resolveOptions(rawOptions);
+			envState.set(void 0, createBabelOptionsConverter(resolved));
+			plugin.transform.filter = calculatePluginFilters(resolved).transformFilter;
+		},
+		transform: {
+			filter: void 0,
+			async handler(code, id, opts) {
+				const convertToBabelOptions = envState.get(this.environment?.name);
+				if (!convertToBabelOptions) return;
+				const babelOptions = convertToBabelOptions({
+					id,
+					moduleType: opts?.moduleType ?? "js",
+					code
+				});
+				const loadedOptions = await babel.loadOptionsAsync({
+					...babelOptions,
+					babelrc: false,
+					configFile: false,
+					parserOpts: {
+						sourceType: "module",
+						allowAwaitOutsideFunction: true,
+						...babelOptions.parserOpts
+					},
+					overrides: [
+						{
+							test: "**/*.jsx",
+							parserOpts: { plugins: ["jsx"] }
+						},
+						{
+							test: "**/*.ts",
+							parserOpts: { plugins: ["typescript"] }
+						},
+						{
+							test: "**/*.tsx",
+							parserOpts: { plugins: ["typescript", "jsx"] }
+						},
+						...babelOptions.overrides ?? []
+					],
+					filename: id
+				});
+				if (!loadedOptions || loadedOptions.plugins.length === 0) return;
+				const result = await babel.transformAsync(code, loadedOptions);
+				if (result) return {
+					code: result.code ?? void 0,
+					map: result.map
+				};
+			}
+		}
+	};
+	return plugin;
+}
+
+//#endregion
+export { babelPlugin as default, defineRolldownBabelPreset };

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@rolldown/plugin-babel",
+  "version": "0.1.0",
+  "description": "Rolldown plugin for Babel",
+  "keywords": [
+    "babel",
+    "plugin",
+    "rolldown",
+    "rolldown-plugin"
+  ],
+  "homepage": "https://github.com/rolldown/plugins/tree/main/packages/babel#readme",
+  "bugs": {
+    "url": "https://github.com/rolldown/plugins/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rolldown/plugins.git",
+    "directory": "packages/babel"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": "./dist/index.mjs",
+  "dependencies": {
+    "picomatch": "^4.0.3"
+  },
+  "devDependencies": {
+    "@babel/core": "^8.0.0-rc.1",
+    "@types/node": "^22.19.11",
+    "@types/picomatch": "^4.0.2",
+    "rolldown": "1.0.0-rc.5",
+    "vite": "^8.0.0-beta.15"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.29.0 || ^8.0.0-rc.1",
+    "rolldown": "^1.0.0-rc.5",
+    "vite": "^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22.12.0 || ^24.0.0"
+  },
+  "compatiblePackages": {
+    "schemaVersion": 1,
+    "rollup": {
+      "type": "incompatible",
+      "reason": "Uses Rolldown-specific APIs"
+    }
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "test": "vitest --project babel"
+  }
+}