create-yoya-ui 0.2.0 → 0.2.2

package/templates/admin/node_modules/rolldown/dist/filter-index.mjs

@@ -0,0 +1,376 @@
+import { r as isPromiseLike, t as arraify } from "./shared/misc-DOSKtd97.mjs";
+//#region ../../node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/filter-B_mD-HGz.mjs
+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);
+}
+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;
+	}
+	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.`);
+	}
+}
+/**
+* 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 '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;
+}
+/**
+* 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]
+				};
+		}
+	});
+	return plugin;
+}
+/**
+* A helper function to add plugin hook filters to a plugin or an array of plugins.
+*
+* @example
+* ```ts
+* import yaml from '@rollup/plugin-yaml';
+* import { defineConfig } from 'rolldown';
+* import { withFilter } from 'rolldown/filter';
+*
+* export default defineConfig({
+*   plugins: [
+*     // Run the transform hook of the `yaml` plugin
+*     // only for modules which end in `.yaml`
+*     withFilter(
+*       yaml({}),
+*       { transform: { id: /\.yaml$/ } },
+*     ),
+*   ],
+* });
+* ```
+*
+* @category Config
+*/
+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/templates/admin/node_modules/rolldown/dist/get-log-filter.d.mts

@@ -0,0 +1,3 @@
+import { a as RolldownLog } from "./shared/logging-xuHO4mAy.mjs";
+import { n as getLogFilter, t as GetLogFilter } from "./shared/get-log-filter-AjBknEEO.mjs";
+export { GetLogFilter, type RolldownLog, type RolldownLog as RollupLog, getLogFilter as default };

package/templates/admin/node_modules/rolldown/dist/get-log-filter.mjs

@@ -0,0 +1,68 @@
+//#region src/get-log-filter.ts
+/**
+* A helper function to generate log filters using the same syntax as the CLI.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'rolldown';
+* import { getLogFilter } from 'rolldown/getLogFilter';
+*
+* const logFilter = getLogFilter(['code:FOO', 'code:BAR']);
+*
+* export default defineConfig({
+* 	input: 'main.js',
+* 	onLog(level, log, handler) {
+* 		if (logFilter(log)) {
+* 			handler(level, log);
+* 		}
+* 	}
+* });
+* ```
+*
+* @category Config
+*/
+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]);
+};
+//#endregion
+export { getLogFilter as default };

package/templates/admin/node_modules/rolldown/dist/index.d.mts

@@ -0,0 +1,4 @@
+import { a as RolldownLog, i as RolldownError, n as LogLevelOption, o as RolldownLogWithString, r as LogOrStringHandler, t as LogLevel } from "./shared/logging-xuHO4mAy.mjs";
+import { U as PreRenderedChunk } from "./shared/binding-Og__jmUi.mjs";
+import { A as ResolvedId, At as ChunkFileNamesFunction, B as ExistingRawSourceMap, Bt as MinifyOptions, C as ParallelPluginHooks, Ct as RolldownBuild, D as ResolveFileUrlArgs, Dt as AdvancedChunksGroup, E as PluginMeta, Et as AddonFunction, Ft as CommentsOptions, G as EmittedAsset, Gt as PartialNull, H as OutputBundle, Ht as OutputOptions, It as GeneratedCodeOptions, J as EmittedPrebuiltChunk, Jt as OutputChunk, K as EmittedChunk, L as RUNTIME_MODULE_ID, Lt as GeneratedCodePreset, M as RolldownPluginOption, Mt as CodeSplittingGroup, N as SourceDescription, Nt as CodeSplittingNameFunction, O as ResolveIdExtraOptions, Ot as AdvancedChunksOptions, P as TransformResult, Pt as CodeSplittingOptions, Q as DefineParallelPluginResult, Qt as SourceMap, R as VERSION, Rt as GlobalsFunction, S as ObjectHook, St as rolldown, T as Plugin, Tt as build, U as TreeshakingOptions, Ut as PreRenderedAsset, V as SourceMapInput, Vt as ModuleFormat, W as TransformPluginContext, X as PluginContext, Xt as RenderedModule, Y as GetModuleInfo, Yt as RenderedChunk, Z as PluginContextResolveOptions, Zt as RolldownOutput, _ as HookFilterExtension, _t as watch, a as ChunkOptimizationOptions, at as BufferEncoding, b as ModuleOptions, bt as RolldownWatcherWatcherEventMap, c as InputOption, ct as RolldownFsModule, d as OptimizationOptions, dt as NormalizedInputOptions, en as ModuleInfo, et as MinimalPluginContext, f as WatcherFileWatcherOptions, ft as TransformOptions, g as FunctionPluginHooks, gt as RolldownMagicString, h as CustomPluginOptions, ht as WarningHandlerWithDefault, i as RolldownOptions, it as ModuleTypeFilter, j as RolldownPlugin, jt as ChunkingContext, k as ResolveIdResult, kt as BuiltinModuleTag, l as InputOptions, lt as InternalModuleFormat, m as AsyncPluginHooks, mt as LoggingFunction, n as RolldownOptionsFunction, nt as GeneralHookFilter, o as ExternalOption, ot as RolldownDirectoryEntry, p as WatcherOptions, pt as ChecksOptions, q as EmittedFile, qt as OutputAsset, r as defineConfig, rt as HookFilter, s as ExternalOptionFunction, st as RolldownFileStats, t as ConfigExport, tn as SourcemapIgnoreListOption, tt as PluginContextMeta, u as ModuleTypes, ut as NormalizedOutputOptions, v as ImportKind, vt as RolldownWatcher, w as PartialResolvedId, wt as BuildOptions, x as ModuleType, xt as WatchOptions, y as LoadResult, yt as RolldownWatcherEvent, z as BundleError, zt as ManglePropertiesOptions } from "./shared/define-config-Nbz-lniw.mjs";
+export { type AddonFunction, type AdvancedChunksGroup, type AdvancedChunksOptions, type AsyncPluginHooks, type BufferEncoding, type BuildOptions, type BuiltinModuleTag, type BundleError, type ChecksOptions, type ChunkFileNamesFunction, type ChunkOptimizationOptions, type ChunkingContext, type CodeSplittingGroup, type CodeSplittingNameFunction, type CodeSplittingOptions, type CommentsOptions, type ConfigExport, type CustomPluginOptions, type DefineParallelPluginResult, type EmittedAsset, type EmittedChunk, type EmittedFile, type EmittedPrebuiltChunk, type ExistingRawSourceMap, type ExternalOption, type ExternalOptionFunction, type FunctionPluginHooks, type GeneralHookFilter, type GeneratedCodeOptions, type GeneratedCodePreset, type GetModuleInfo, type GlobalsFunction, type HookFilter, type HookFilterExtension, type ImportKind, type InputOption, type InputOptions, type InternalModuleFormat, type LoadResult, type LogLevel, type LogLevelOption, type LogOrStringHandler, type LoggingFunction, type ManglePropertiesOptions, type MinifyOptions, type MinimalPluginContext, type ModuleFormat, type ModuleInfo, type ModuleOptions, type ModuleType, type ModuleTypeFilter, type ModuleTypes, type NormalizedInputOptions, type NormalizedOutputOptions, type ObjectHook, type OptimizationOptions, type OutputAsset, type OutputBundle, type OutputChunk, type OutputOptions, type ParallelPluginHooks, type PartialNull, type PartialResolvedId, type Plugin, type PluginContext, type PluginContextMeta, type PluginContextResolveOptions, type PluginMeta, type PreRenderedAsset, type PreRenderedChunk, RUNTIME_MODULE_ID, type RenderedChunk, type RenderedModule, type ResolveFileUrlArgs, type ResolveIdExtraOptions, type ResolveIdResult, type ResolvedId, type RolldownBuild, type RolldownDirectoryEntry, type RolldownError, type RolldownError as RollupError, type RolldownFileStats, type RolldownFsModule, type RolldownLog, type RolldownLog as RollupLog, type RolldownLogWithString, type RolldownLogWithString as RollupLogWithString, RolldownMagicString, type RolldownOptions, type RolldownOptionsFunction, type RolldownOutput, type RolldownPlugin, type RolldownPluginOption, type RolldownWatcher, type RolldownWatcherEvent, type RolldownWatcherWatcherEventMap, type SourceDescription, type SourceMap, type SourceMapInput, type SourcemapIgnoreListOption, type TransformOptions, type TransformPluginContext, type TransformResult, type TreeshakingOptions, VERSION, type WarningHandlerWithDefault, type WatchOptions, type WatcherFileWatcherOptions, type WatcherOptions, build, defineConfig, rolldown, watch };

package/templates/admin/node_modules/rolldown/dist/index.mjs

@@ -0,0 +1,56 @@
+import { n as __toESM, t as require_binding } from "./shared/binding-CtPG-2KR.mjs";
+import { n as onExit, t as watch } from "./shared/watch-UbzgabQn.mjs";
+import { T as VERSION, s as RolldownMagicString } from "./shared/bindingify-input-options-4JJxbZl2.mjs";
+import { t as rolldown } from "./shared/rolldown-C9Hfg50O.mjs";
+import { t as defineConfig } from "./shared/define-config-Demdg3_4.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/constants/index.ts
+/**
+* Runtime helper module ID
+*/
+const RUNTIME_MODULE_ID = "\0rolldown/runtime.js";
+//#endregion
+//#region src/api/build.ts
+/**
+* The API similar to esbuild's `build` function.
+*
+* @example
+* ```js
+* import { build } from 'rolldown';
+*
+* const result = await build({
+*   input: 'src/main.js',
+*   output: {
+*     file: 'bundle.js',
+*   },
+* });
+* console.log(result);
+* ```
+*
+* @experimental
+* @category Programmatic APIs
+*/
+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
+export { RUNTIME_MODULE_ID, RolldownMagicString, VERSION, build, defineConfig, rolldown, watch };

package/templates/admin/node_modules/rolldown/dist/parallel-plugin-worker.d.mts

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

package/templates/admin/node_modules/rolldown/dist/parallel-plugin-worker.mjs

@@ -0,0 +1,29 @@
+import { n as __toESM, t as require_binding } from "./shared/binding-CtPG-2KR.mjs";
+import { c as PluginContextData, n as bindingifyPlugin } from "./shared/bindingify-input-options-4JJxbZl2.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 {
+		const plugins = 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, void 0)
+			};
+		}));
+		(0, import_binding.registerPlugins)(registryId, plugins);
+		parentPort.postMessage({ type: "success" });
+	} catch (error) {
+		parentPort.postMessage({
+			type: "error",
+			error
+		});
+	} finally {
+		parentPort.unref();
+	}
+})();
+//#endregion
+export {};

package/templates/admin/node_modules/rolldown/dist/parallel-plugin.d.mts

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

package/templates/admin/node_modules/rolldown/dist/parallel-plugin.mjs

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

package/templates/admin/node_modules/rolldown/dist/parse-ast-index.d.mts

@@ -0,0 +1,30 @@
+import { H as ParserOptions$1, V as ParseResult$1 } from "./shared/binding-Og__jmUi.mjs";
+import { Program } from "@oxc-project/types";
+//#region src/parse-ast-index.d.ts
+/**
+ * @hidden
+ */
+export type ParseResult = ParseResult$1;
+/**
+ * @hidden
+ */
+export type ParserOptions = ParserOptions$1;
+/**
+ * Parse code synchronously and return the AST.
+ *
+ * This function is similar to Rollup's `parseAst` function.
+ * Prefer using {@linkcode parseSync} instead of this function as it has more information in the return value.
+ *
+ * @category Utilities
+ */
+export declare function parseAst(sourceText: string, options?: ParserOptions | null, filename?: string): Program;
+/**
+ * Parse code asynchronously and return the AST.
+ *
+ * This function is similar to Rollup's `parseAstAsync` function.
+ * Prefer using {@linkcode parseAsync} instead of this function as it has more information in the return value.
+ *
+ * @category Utilities
+ */
+export declare function parseAstAsync(sourceText: string, options?: ParserOptions | null, filename?: string): Promise<Program>;
+//#endregion

package/templates/admin/node_modules/rolldown/dist/parse-ast-index.mjs

@@ -0,0 +1,60 @@
+import { c as logParseError, d as getCodeFrame, n as error, t as augmentCodeLocation, u as locate } from "./shared/logs-DmYCAKcW.mjs";
+import { n as parseSync, t as parse } from "./shared/parse-D0g29RgN.mjs";
+//#region src/parse-ast-index.ts
+function wrap(result, filename, sourceText) {
+	if (result.errors.length > 0) return normalizeParseError(filename, sourceText, result.errors);
+	return result.program;
+}
+function normalizeParseError(filename, sourceText, errors) {
+	let message = `Parse failed with ${errors.length} error${errors.length < 2 ? "" : "s"}:\n`;
+	const pos = errors[0]?.labels?.[0]?.start;
+	for (let i = 0; i < errors.length; i++) {
+		if (i >= 5) {
+			message += "\n...";
+			break;
+		}
+		const e = errors[i];
+		message += e.message + "\n" + e.labels.map((label) => {
+			const location = locate(sourceText, label.start, { offsetLine: 1 });
+			if (!location) return;
+			return getCodeFrame(sourceText, location.line, location.column);
+		}).filter(Boolean).join("\n");
+	}
+	const log = logParseError(message, filename, pos);
+	if (pos !== void 0 && filename) augmentCodeLocation(log, pos, sourceText, filename);
+	return error(log);
+}
+const defaultParserOptions = {
+	lang: "js",
+	preserveParens: false
+};
+/**
+* Parse code synchronously and return the AST.
+*
+* This function is similar to Rollup's `parseAst` function.
+* Prefer using {@linkcode parseSync} instead of this function as it has more information in the return value.
+*
+* @category Utilities
+*/
+function parseAst(sourceText, options, filename) {
+	return wrap(parseSync(filename ?? "file.js", sourceText, {
+		...defaultParserOptions,
+		...options
+	}), filename, sourceText);
+}
+/**
+* Parse code asynchronously and return the AST.
+*
+* This function is similar to Rollup's `parseAstAsync` function.
+* Prefer using {@linkcode parseAsync} instead of this function as it has more information in the return value.
+*
+* @category Utilities
+*/
+async function parseAstAsync(sourceText, options, filename) {
+	return wrap(await parse(filename ?? "file.js", sourceText, {
+		...defaultParserOptions,
+		...options
+	}), filename, sourceText);
+}
+//#endregion
+export { parseAst, parseAstAsync };