@rollipop/rolldown 0.0.0-beta.0

package/dist/filter-index.mjs

@@ -0,0 +1,369 @@
+import { n as isPromiseLike, t as arraify } from "./shared/misc-DpjTMcQQ.mjs";
+
+//#region ../pluginutils/dist/utils.js
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+function extractQueryWithoutFragment(url) {
+	const questionMarkIndex = url.indexOf("?");
+	if (questionMarkIndex === -1) return "";
+	const fragmentIndex = url.indexOf("#", questionMarkIndex);
+	if (fragmentIndex === -1) return url.substring(questionMarkIndex);
+	else return url.substring(questionMarkIndex, fragmentIndex);
+}
+
+//#endregion
+//#region ../pluginutils/dist/filter/composable-filters.js
+var And = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`And` expects at least one operand");
+		this.args = args;
+		this.kind = "and";
+	}
+};
+var Or = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`Or` expects at least one operand");
+		this.args = args;
+		this.kind = "or";
+	}
+};
+var Not = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "not";
+	}
+};
+var Id = class {
+	kind;
+	pattern;
+	params;
+	constructor(pattern, params) {
+		this.pattern = pattern;
+		this.kind = "id";
+		this.params = params ?? { cleanUrl: false };
+	}
+};
+var ImporterId = class {
+	kind;
+	pattern;
+	params;
+	constructor(pattern, params) {
+		this.pattern = pattern;
+		this.kind = "importerId";
+		this.params = params ?? { cleanUrl: false };
+	}
+};
+var ModuleType = class {
+	kind;
+	pattern;
+	constructor(pattern) {
+		this.pattern = pattern;
+		this.kind = "moduleType";
+	}
+};
+var Code = class {
+	kind;
+	pattern;
+	constructor(expr) {
+		this.pattern = expr;
+		this.kind = "code";
+	}
+};
+var Query = class {
+	kind;
+	key;
+	pattern;
+	constructor(key, pattern) {
+		this.pattern = pattern;
+		this.key = key;
+		this.kind = "query";
+	}
+};
+var Include = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "include";
+	}
+};
+var Exclude = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "exclude";
+	}
+};
+function and(...args) {
+	return new And(...args);
+}
+function or(...args) {
+	return new Or(...args);
+}
+function not(expr) {
+	return new Not(expr);
+}
+function id(pattern, params) {
+	return new Id(pattern, params);
+}
+function importerId(pattern, params) {
+	return new ImporterId(pattern, params);
+}
+function moduleType(pattern) {
+	return new ModuleType(pattern);
+}
+function code(pattern) {
+	return new Code(pattern);
+}
+function query(key, pattern) {
+	return new Query(key, pattern);
+}
+function include(expr) {
+	return new Include(expr);
+}
+function exclude(expr) {
+	return new Exclude(expr);
+}
+/**
+* convert a queryObject to FilterExpression like
+* ```js
+*   and(query(k1, v1), query(k2, v2))
+* ```
+* @param queryFilterObject The query filter object needs to be matched.
+* @returns a `And` FilterExpression
+*/
+function queries(queryFilter) {
+	return and(...Object.entries(queryFilter).map(([key, value]) => {
+		return new Query(key, value);
+	}));
+}
+function interpreter(exprs, code, id, moduleType, importerId) {
+	let arr = [];
+	if (Array.isArray(exprs)) arr = exprs;
+	else arr = [exprs];
+	return interpreterImpl(arr, code, id, moduleType, importerId);
+}
+function interpreterImpl(expr, code, id, moduleType, importerId, ctx = {}) {
+	let hasInclude = false;
+	for (const e of expr) switch (e.kind) {
+		case "include":
+			hasInclude = true;
+			if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) return true;
+			break;
+		case "exclude":
+			if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) return false;
+			break;
+	}
+	return !hasInclude;
+}
+function exprInterpreter(expr, code, id, moduleType, importerId, ctx = {}) {
+	switch (expr.kind) {
+		case "and": return expr.args.every((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
+		case "or": return expr.args.some((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
+		case "not": return !exprInterpreter(expr.expr, code, id, moduleType, importerId, ctx);
+		case "id": {
+			if (id === void 0) throw new Error("`id` is required for `id` expression");
+			let idToMatch = id;
+			if (expr.params.cleanUrl) idToMatch = cleanUrl(idToMatch);
+			return typeof expr.pattern === "string" ? idToMatch === expr.pattern : expr.pattern.test(idToMatch);
+		}
+		case "importerId": {
+			if (importerId === void 0) return false;
+			let importerIdToMatch = importerId;
+			if (expr.params.cleanUrl) importerIdToMatch = cleanUrl(importerIdToMatch);
+			return typeof expr.pattern === "string" ? importerIdToMatch === expr.pattern : expr.pattern.test(importerIdToMatch);
+		}
+		case "moduleType":
+			if (moduleType === void 0) throw new Error("`moduleType` is required for `moduleType` expression");
+			return moduleType === expr.pattern;
+		case "code":
+			if (code === void 0) throw new Error("`code` is required for `code` expression");
+			return typeof expr.pattern === "string" ? code.includes(expr.pattern) : expr.pattern.test(code);
+		case "query": {
+			if (id === void 0) throw new Error("`id` is required for `Query` expression");
+			if (!ctx.urlSearchParamsCache) {
+				let queryString = extractQueryWithoutFragment(id);
+				ctx.urlSearchParamsCache = new URLSearchParams(queryString);
+			}
+			let urlParams = ctx.urlSearchParamsCache;
+			if (typeof expr.pattern === "boolean") if (expr.pattern) return urlParams.has(expr.key);
+			else return !urlParams.has(expr.key);
+			else if (typeof expr.pattern === "string") return urlParams.get(expr.key) === expr.pattern;
+			else return expr.pattern.test(urlParams.get(expr.key) ?? "");
+		}
+		default: throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`);
+	}
+}
+
+//#endregion
+//#region ../pluginutils/dist/filter/filter-vite-plugins.js
+/**
+* Filters out Vite plugins that have `apply: 'serve'` set.
+*
+* Since Rolldown operates in build mode, plugins marked with `apply: 'serve'`
+* are intended only for Vite's dev server and should be excluded from the build process.
+*
+* @param plugins - Array of plugins (can include nested arrays)
+* @returns Filtered array with serve-only plugins removed
+*
+* @example
+* ```ts
+* import { defineConfig } from '@rollipop/rolldown';
+* import { filterVitePlugins } from '@rolldown/pluginutils';
+* import viteReact from '@vitejs/plugin-react';
+*
+* export default defineConfig({
+*   plugins: filterVitePlugins([
+*     viteReact(),
+*     {
+*       name: 'dev-only',
+*       apply: 'serve', // This will be filtered out
+*       // ...
+*     }
+*   ])
+* });
+* ```
+*/
+function filterVitePlugins(plugins) {
+	if (!plugins) return [];
+	const pluginArray = Array.isArray(plugins) ? plugins : [plugins];
+	const result = [];
+	for (const plugin of pluginArray) {
+		if (!plugin) continue;
+		if (Array.isArray(plugin)) {
+			result.push(...filterVitePlugins(plugin));
+			continue;
+		}
+		const pluginWithApply = plugin;
+		if ("apply" in pluginWithApply) {
+			const applyValue = pluginWithApply.apply;
+			if (typeof applyValue === "function") try {
+				if (applyValue({}, {
+					command: "build",
+					mode: "production"
+				})) result.push(plugin);
+			} catch {
+				result.push(plugin);
+			}
+			else if (applyValue === "serve") continue;
+			else result.push(plugin);
+		} else result.push(plugin);
+	}
+	return result;
+}
+
+//#endregion
+//#region ../pluginutils/dist/filter/simple-filters.js
+/**
+* Constructs a RegExp that matches the exact string specified.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*
+* @example
+* ```ts
+* import { exactRegex } from '@rolldown/pluginutils';
+* const plugin = {
+*   name: 'plugin',
+*   resolveId: {
+*     filter: { id: exactRegex('foo') },
+*     handler(id) {} // will only be called for `foo`
+*   }
+* }
+* ```
+*/
+function exactRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}$`, flags);
+}
+/**
+* Constructs a RegExp that matches a value that has the specified prefix.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*
+* @example
+* ```ts
+* import { prefixRegex } from '@rolldown/pluginutils';
+* const plugin = {
+*   name: 'plugin',
+*   resolveId: {
+*     filter: { id: prefixRegex('foo') },
+*     handler(id) {} // will only be called for IDs starting with `foo`
+*   }
+* }
+* ```
+*/
+function prefixRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}`, flags);
+}
+const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+	return str.replace(escapeRegexRE, "\\$&");
+}
+function makeIdFiltersToMatchWithQuery(input) {
+	if (!Array.isArray(input)) return makeIdFilterToMatchWithQuery(input);
+	return input.map((i) => makeIdFilterToMatchWithQuery(i));
+}
+function makeIdFilterToMatchWithQuery(input) {
+	if (typeof input === "string") return `${input}{?*,}`;
+	return makeRegexIdFilterToMatchWithQuery(input);
+}
+function makeRegexIdFilterToMatchWithQuery(input) {
+	return new RegExp(input.source.replace(/(?<!\\)\$/g, "(?:\\?.*)?$"), input.flags);
+}
+
+//#endregion
+//#region src/plugin/with-filter.ts
+function withFilterImpl(pluginOption, filterObjectList) {
+	if (isPromiseLike(pluginOption)) return pluginOption.then((p) => withFilter(p, filterObjectList));
+	if (pluginOption == false || pluginOption == null) return pluginOption;
+	if (Array.isArray(pluginOption)) return pluginOption.map((p) => withFilter(p, filterObjectList));
+	let plugin = pluginOption;
+	let filterObjectIndex = findMatchedFilterObject(plugin.name, filterObjectList);
+	if (filterObjectIndex === -1) return plugin;
+	let filterObject = filterObjectList[filterObjectIndex];
+	Object.keys(plugin).forEach((key) => {
+		switch (key) {
+			case "transform":
+			case "resolveId":
+			case "load":
+				if (!plugin[key]) return;
+				if (typeof plugin[key] === "object") plugin[key].filter = filterObject[key] ?? plugin[key].filter;
+				else plugin[key] = {
+					handler: plugin[key],
+					filter: filterObject[key]
+				};
+				break;
+			default: break;
+		}
+	});
+	return plugin;
+}
+function withFilter(pluginOption, filterObject) {
+	return withFilterImpl(pluginOption, arraify(filterObject));
+}
+function findMatchedFilterObject(pluginName, overrideFilterObjectList) {
+	if (overrideFilterObjectList.length === 1 && overrideFilterObjectList[0].pluginNamePattern === void 0) return 0;
+	for (let i = 0; i < overrideFilterObjectList.length; i++) for (let j = 0; j < (overrideFilterObjectList[i].pluginNamePattern ?? []).length; j++) {
+		let pattern = overrideFilterObjectList[i].pluginNamePattern[j];
+		if (typeof pattern === "string" && pattern === pluginName) return i;
+		else if (pattern instanceof RegExp && pattern.test(pluginName)) return i;
+	}
+	return -1;
+}
+
+//#endregion
+export { and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query, withFilter };

package/dist/get-log-filter.d.mts

@@ -0,0 +1,7 @@
+import { a as RollupLog } from "./shared/logging-DsnCZi19.mjs";
+
+//#region src/get-log-filter.d.ts
+type GetLogFilter = (filters: string[]) => (log: RollupLog) => boolean;
+declare const getLogFilter: GetLogFilter;
+//#endregion
+export { GetLogFilter, type RollupLog, getLogFilter as default };

package/dist/get-log-filter.mjs

@@ -0,0 +1,48 @@
+//#region src/get-log-filter.ts
+const getLogFilter = (filters) => {
+	if (filters.length === 0) return () => true;
+	const normalizedFilters = filters.map((filter) => filter.split("&").map((subFilter) => {
+		const inverted = subFilter.startsWith("!");
+		if (inverted) subFilter = subFilter.slice(1);
+		const [key, ...value] = subFilter.split(":");
+		return {
+			inverted,
+			key: key.split("."),
+			parts: value.join(":").split("*")
+		};
+	}));
+	return (log) => {
+		nextIntersectedFilter: for (const intersectedFilters of normalizedFilters) {
+			for (const { inverted, key, parts } of intersectedFilters) {
+				const isFilterSatisfied = testFilter(log, key, parts);
+				if (inverted ? isFilterSatisfied : !isFilterSatisfied) continue nextIntersectedFilter;
+			}
+			return true;
+		}
+		return false;
+	};
+};
+const testFilter = (log, key, parts) => {
+	let rawValue = log;
+	for (let index = 0; index < key.length; index++) {
+		if (!rawValue) return false;
+		const part = key[index];
+		if (!(part in rawValue)) return false;
+		rawValue = rawValue[part];
+	}
+	let value = typeof rawValue === "object" ? JSON.stringify(rawValue) : String(rawValue);
+	if (parts.length === 1) return value === parts[0];
+	if (!value.startsWith(parts[0])) return false;
+	const lastPartIndex = parts.length - 1;
+	for (let index = 1; index < lastPartIndex; index++) {
+		const part = parts[index];
+		const position = value.indexOf(part);
+		if (position === -1) return false;
+		value = value.slice(position + part.length);
+	}
+	return value.endsWith(parts[lastPartIndex]);
+};
+var get_log_filter_default = getLogFilter;
+
+//#endregion
+export { get_log_filter_default as default };

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+import { a as RollupLog, i as RollupError, n as LogLevelOption, o as RollupLogWithString, r as LogOrStringHandler, t as LogLevel } from "./shared/logging-DsnCZi19.mjs";
+import { V as PreRenderedChunk, s as BindingMagicString } from "./shared/binding-kAegJ1Bj.mjs";
+import { $ as RolldownFileStats, A as TransformResult, B as EmittedFile, C as Plugin, Ct as GlobalsFunction, D as RolldownPlugin, Dt as PreRenderedAsset, E as ResolvedId, Et as OutputOptions, F as SourceMapInput, Ft as RolldownOutput, H as GetModuleInfo, I as OutputBundle, It as SourceMap, J as GeneralHookFilter, K as MinimalPluginContext, L as TreeshakingOptions, Mt as OutputChunk, N as VERSION, Nt as RenderedChunk, O as RolldownPluginOption, P as ExistingRawSourceMap, Pt as RenderedModule, Q as RolldownDirectoryEntry, R as TransformPluginContext, Rt as ModuleInfo, S as PartialResolvedId, St as GeneratedCodePreset, T as ResolveIdResult, Tt as ModuleFormat, U as PluginContext, V as EmittedPrebuiltChunk, W as DefineParallelPluginResult, X as ModuleTypeFilter, Y as HookFilter, Z as BufferEncoding, _ as LoadResult, _t as AdvancedChunksGroup, a as ExternalOption, at as ChecksOptions, b as ObjectHook, bt as CodeSplittingGroup, c as InputOptions, ct as watch, d as WatcherOptions, dt as WatchOptions, et as RolldownFsModule, f as AsyncPluginHooks, ft as rolldown, g as ImportKind, gt as AddonFunction, h as HookFilterExtension, ht as build, i as RolldownOptions, it as TransformOptions, jt as OutputAsset, k as SourceDescription, kt as PartialNull, l as ModuleTypes, lt as RolldownWatcher, m as FunctionPluginHooks, mt as BuildOptions, n as RolldownOptionsFunction, nt as NormalizedOutputOptions, o as ExternalOptionFunction, ot as LoggingFunction, p as CustomPluginOptions, pt as RolldownBuild, q as PluginContextMeta, r as defineConfig, rt as NormalizedInputOptions, s as InputOption, st as WarningHandlerWithDefault, t as ConfigExport, tt as InternalModuleFormat, u as OptimizationOptions, ut as RolldownWatcherEvent, v as ModuleOptions, vt as ChunkFileNamesFunction, w as ResolveIdExtraOptions, wt as MinifyOptions, x as ParallelPluginHooks, xt as GeneratedCodeOptions, y as ModuleType, yt as ChunkingContext, z as EmittedAsset, zt as SourcemapIgnoreListOption } from "./shared/define-config-DJ1-iIdx.mjs";
+export { AddonFunction, AdvancedChunksGroup, AsyncPluginHooks, BindingMagicString, BufferEncoding, BuildOptions, ChecksOptions, ChunkFileNamesFunction, ChunkingContext, CodeSplittingGroup, ConfigExport, CustomPluginOptions, DefineParallelPluginResult, EmittedAsset, EmittedFile, EmittedPrebuiltChunk, ExistingRawSourceMap, ExternalOption, ExternalOptionFunction, FunctionPluginHooks, GeneralHookFilter, GeneratedCodeOptions, GeneratedCodePreset, GetModuleInfo, GlobalsFunction, HookFilter, HookFilterExtension, ImportKind, InputOption, InputOptions, InternalModuleFormat, LoadResult, LogLevel, LogLevelOption, LogOrStringHandler, LoggingFunction, MinifyOptions, MinimalPluginContext, ModuleFormat, ModuleInfo, ModuleOptions, ModuleType, ModuleTypeFilter, ModuleTypes, NormalizedInputOptions, NormalizedOutputOptions, ObjectHook, OptimizationOptions, OutputAsset, OutputBundle, OutputChunk, OutputOptions, ParallelPluginHooks, PartialNull, PartialResolvedId, Plugin, PluginContext, PluginContextMeta, PreRenderedAsset, PreRenderedChunk, RenderedChunk, RenderedModule, ResolveIdExtraOptions, ResolveIdResult, ResolvedId, RolldownBuild, RolldownDirectoryEntry, RolldownFileStats, RolldownFsModule, RolldownOptions, RolldownOptionsFunction, RolldownOutput, RolldownPlugin, RolldownPluginOption, RolldownWatcher, RolldownWatcherEvent, RollupError, RollupLog, RollupLogWithString, SourceDescription, SourceMap, SourceMapInput, SourcemapIgnoreListOption, TransformOptions, TransformPluginContext, TransformResult, TreeshakingOptions, VERSION, WarningHandlerWithDefault, WatchOptions, WatcherOptions, build, defineConfig, rolldown, watch };

package/dist/index.mjs

@@ -0,0 +1,38 @@
+import { n as __toESM, t as require_binding } from "./shared/binding-DmMMxMk0.mjs";
+import { n as onExit, t as watch } from "./shared/watch-BSdMzY6q.mjs";
+import { y as VERSION } from "./shared/normalize-string-or-regex-DbTZ9prS.mjs";
+import "./shared/rolldown-build-viDZfkdI.mjs";
+import "./shared/bindingify-input-options-D0BAGfk2.mjs";
+import "./shared/parse-ast-index-BuuhACPk.mjs";
+import { t as rolldown } from "./shared/rolldown-il0-nWH9.mjs";
+import { t as defineConfig } from "./shared/define-config-BF4P-Pum.mjs";
+import { isMainThread } from "node:worker_threads";
+
+//#region src/setup.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+if (isMainThread) {
+	const subscriberGuard = (0, import_binding.initTraceSubscriber)();
+	onExit(() => {
+		subscriberGuard?.close();
+	});
+}
+
+//#endregion
+//#region src/api/build.ts
+async function build(options) {
+	if (Array.isArray(options)) return Promise.all(options.map((opts) => build(opts)));
+	else {
+		const { output, write = true, ...inputOptions } = options;
+		const build = await rolldown(inputOptions);
+		try {
+			if (write) return await build.write(output);
+			else return await build.generate(output);
+		} finally {
+			await build.close();
+		}
+	}
+}
+
+//#endregion
+var BindingMagicString = import_binding.BindingMagicString;
+export { BindingMagicString, VERSION, build, defineConfig, rolldown, watch };

package/dist/parallel-plugin-worker.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/parallel-plugin-worker.mjs

@@ -0,0 +1,32 @@
+import { n as __toESM, t as require_binding } from "./shared/binding-DmMMxMk0.mjs";
+import "./shared/normalize-string-or-regex-DbTZ9prS.mjs";
+import { n as PluginContextData, r as bindingifyPlugin } from "./shared/bindingify-input-options-D0BAGfk2.mjs";
+import "./shared/parse-ast-index-BuuhACPk.mjs";
+import { parentPort, workerData } from "node:worker_threads";
+
+//#region src/parallel-plugin-worker.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+const { registryId, pluginInfos, threadNumber } = workerData;
+(async () => {
+	try {
+		(0, import_binding.registerPlugins)(registryId, await Promise.all(pluginInfos.map(async (pluginInfo) => {
+			const definePluginImpl = (await import(pluginInfo.fileUrl)).default;
+			const plugin = await definePluginImpl(pluginInfo.options, { threadNumber });
+			return {
+				index: pluginInfo.index,
+				plugin: bindingifyPlugin(plugin, {}, {}, new PluginContextData(() => {}, {}, []), [], () => {}, "info", false)
+			};
+		})));
+		parentPort.postMessage({ type: "success" });
+	} catch (error) {
+		parentPort.postMessage({
+			type: "error",
+			error
+		});
+	} finally {
+		parentPort.unref();
+	}
+})();
+
+//#endregion
+export {  };

package/dist/parallel-plugin.d.mts

@@ -0,0 +1,14 @@
+import "./shared/binding-kAegJ1Bj.mjs";
+import { C as Plugin, Ot as MaybePromise } from "./shared/define-config-DJ1-iIdx.mjs";
+
+//#region src/plugin/parallel-plugin-implementation.d.ts
+type ParallelPluginImplementation = Plugin;
+type Context = {
+  /**
+  * Thread number
+  */
+  threadNumber: number;
+};
+declare function defineParallelPluginImplementation<Options>(plugin: (Options: Options, context: Context) => MaybePromise<ParallelPluginImplementation>): (Options: Options, context: Context) => MaybePromise<ParallelPluginImplementation>;
+//#endregion
+export { type Context, type ParallelPluginImplementation, defineParallelPluginImplementation };

package/dist/parallel-plugin.mjs

@@ -0,0 +1,7 @@
+//#region src/plugin/parallel-plugin-implementation.ts
+function defineParallelPluginImplementation(plugin) {
+	return plugin;
+}
+
+//#endregion
+export { defineParallelPluginImplementation };

package/dist/parse-ast-index.d.mts

@@ -0,0 +1,8 @@
+import { B as ParserOptions, z as ParseResult } from "./shared/binding-kAegJ1Bj.mjs";
+import { Program } from "@oxc-project/types";
+
+//#region src/parse-ast-index.d.ts
+declare function parseAst(sourceText: string, options?: ParserOptions | null, filename?: string): Program;
+declare function parseAstAsync(sourceText: string, options?: ParserOptions | null, filename?: string): Promise<Program>;
+//#endregion
+export { type ParseResult, type ParserOptions, parseAst, parseAstAsync };

package/dist/parse-ast-index.mjs

@@ -0,0 +1,4 @@
+import "./shared/binding-DmMMxMk0.mjs";
+import { n as parseAstAsync, t as parseAst } from "./shared/parse-ast-index-BuuhACPk.mjs";
+
+export { parseAst, parseAstAsync };

package/dist/plugins-index.d.mts

@@ -0,0 +1,31 @@
+import { u as BindingReplacePluginConfig } from "./shared/binding-kAegJ1Bj.mjs";
+import { M as BuiltinPlugin } from "./shared/define-config-DJ1-iIdx.mjs";
+import { t as esmExternalRequirePlugin } from "./shared/constructors-F44lhsH3.mjs";
+
+//#region src/builtin-plugin/replace-plugin.d.ts
+
+/**
+* Replaces targeted strings in files while bundling.
+*
+* @example
+* // Basic usage
+* ```js
+* replacePlugin({
+*   'process.env.NODE_ENV': JSON.stringify('production'),
+*    __buildVersion: 15
+* })
+* ```
+* @example
+* // With options
+* ```js
+* replacePlugin({
+*   'process.env.NODE_ENV': JSON.stringify('production'),
+*   __buildVersion: 15
+* }, {
+*   preventAssignment: false,
+* })
+* ```
+*/
+declare function replacePlugin(values?: BindingReplacePluginConfig["values"], options?: Omit<BindingReplacePluginConfig, "values">): BuiltinPlugin;
+//#endregion
+export { esmExternalRequirePlugin, replacePlugin };

package/dist/plugins-index.mjs

@@ -0,0 +1,40 @@
+import "./shared/binding-DmMMxMk0.mjs";
+import { n as BuiltinPlugin, s as makeBuiltinPluginCallable } from "./shared/normalize-string-or-regex-DbTZ9prS.mjs";
+import { t as esmExternalRequirePlugin } from "./shared/constructors-Rl_oLd2F.mjs";
+
+//#region src/builtin-plugin/replace-plugin.ts
+/**
+* Replaces targeted strings in files while bundling.
+*
+* @example
+* // Basic usage
+* ```js
+* replacePlugin({
+*   'process.env.NODE_ENV': JSON.stringify('production'),
+*    __buildVersion: 15
+* })
+* ```
+* @example
+* // With options
+* ```js
+* replacePlugin({
+*   'process.env.NODE_ENV': JSON.stringify('production'),
+*   __buildVersion: 15
+* }, {
+*   preventAssignment: false,
+* })
+* ```
+*/
+function replacePlugin(values = {}, options = {}) {
+	Object.keys(values).forEach((key) => {
+		const value = values[key];
+		if (typeof value !== "string") values[key] = String(value);
+	});
+	return makeBuiltinPluginCallable(new BuiltinPlugin("builtin:replace", {
+		...options,
+		values
+	}));
+}
+
+//#endregion
+export { esmExternalRequirePlugin, replacePlugin };