create-yoya-ui 0.2.0 → 0.2.2

package/templates/admin/node_modules/rolldown/dist/shared/normalize-string-or-regex-DWz4it3p.mjs

@@ -0,0 +1,68 @@
+import { n as __toESM, t as require_binding } from "./binding-CtPG-2KR.mjs";
+import { l as logPluginError, n as error } from "./logs-DmYCAKcW.mjs";
+//#region src/builtin-plugin/utils.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+var BuiltinPlugin = class {
+	name;
+	_options;
+	/** Vite-specific option to control plugin ordering */
+	enforce;
+	constructor(name, _options) {
+		this.name = name;
+		this._options = _options;
+	}
+};
+function makeBuiltinPluginCallable(plugin) {
+	let callablePlugin = new import_binding.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
+	const wrappedPlugin = plugin;
+	for (const key in callablePlugin) {
+		const wrappedHook = async function(...args) {
+			try {
+				return await callablePlugin[key](...args);
+			} catch (e) {
+				if (e instanceof Error && !e.stack?.includes("at ")) Error.captureStackTrace(e, wrappedPlugin[key]);
+				return error(logPluginError(e, plugin.name, {
+					hook: key,
+					id: key === "transform" ? args[2] : void 0
+				}));
+			}
+		};
+		const order = callablePlugin.getOrder(key);
+		if (order == void 0) wrappedPlugin[key] = wrappedHook;
+		else wrappedPlugin[key] = {
+			handler: wrappedHook,
+			order
+		};
+	}
+	return wrappedPlugin;
+}
+function bindingifyBuiltInPlugin(plugin) {
+	return {
+		__name: plugin.name,
+		options: plugin._options
+	};
+}
+function bindingifyManifestPlugin(plugin, pluginContextData) {
+	const { isOutputOptionsForLegacyChunks, ...options } = plugin._options;
+	return {
+		__name: plugin.name,
+		options: {
+			...options,
+			isLegacy: isOutputOptionsForLegacyChunks ? (opts) => {
+				return isOutputOptionsForLegacyChunks(pluginContextData.getOutputOptions(opts));
+			} : void 0
+		}
+	};
+}
+//#endregion
+//#region src/utils/normalize-string-or-regex.ts
+function normalizedStringOrRegex(pattern) {
+	if (!pattern) return;
+	if (!isReadonlyArray(pattern)) return [pattern];
+	return pattern;
+}
+function isReadonlyArray(input) {
+	return Array.isArray(input);
+}
+//#endregion
+export { makeBuiltinPluginCallable as a, bindingifyManifestPlugin as i, BuiltinPlugin as n, bindingifyBuiltInPlugin as r, normalizedStringOrRegex as t };

package/templates/admin/node_modules/rolldown/dist/shared/parse-D0g29RgN.mjs

@@ -0,0 +1,74 @@
+import { n as __toESM, t as require_binding } from "./binding-CtPG-2KR.mjs";
+//#region ../../node_modules/.pnpm/oxc-parser@0.147.0/node_modules/oxc-parser/src-js/wrap.js
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+function wrap(result) {
+	let program, module, comments, errors;
+	return {
+		get program() {
+			if (!program) program = jsonParseAst(result.program);
+			return program;
+		},
+		get module() {
+			if (!module) module = result.module;
+			return module;
+		},
+		get comments() {
+			if (!comments) comments = result.comments;
+			return comments;
+		},
+		get errors() {
+			if (!errors) errors = result.errors;
+			return errors;
+		}
+	};
+}
+function jsonParseAst(programJson) {
+	const { node: program, fixes } = JSON.parse(programJson);
+	for (const fixPath of fixes) applyFix(program, fixPath);
+	return program;
+}
+function applyFix(program, fixPath) {
+	let node = program;
+	for (const key of fixPath) node = node[key];
+	if (node.bigint) node.value = BigInt(node.bigint);
+	else try {
+		node.value = RegExp(node.regex.pattern, node.regex.flags);
+	} catch {}
+}
+//#endregion
+//#region src/utils/parse.ts
+/**
+* Parse JS/TS source asynchronously on a separate thread.
+*
+* Note that not all of the workload can happen on a separate thread.
+* Parsing on Rust side does happen in a separate thread, but deserialization of the AST to JS objects
+* has to happen on current thread. This synchronous deserialization work typically outweighs
+* the asynchronous parsing by a factor of between 3 and 20.
+*
+* i.e. the majority of the workload cannot be parallelized by using this method.
+*
+* Generally {@linkcode parseSync} is preferable to use as it does not have the overhead of spawning a thread.
+* If you need to parallelize parsing multiple files, it is recommended to use worker threads.
+*
+* @category Utilities
+*/
+async function parse(filename, sourceText, options) {
+	return wrap(await (0, import_binding.parse)(filename, sourceText, options));
+}
+/**
+* Parse JS/TS source synchronously on current thread.
+*
+* This is generally preferable over {@linkcode parse} (async) as it does not have the overhead
+* of spawning a thread, and the majority of the workload cannot be parallelized anyway
+* (see {@linkcode parse} documentation for details).
+*
+* If you need to parallelize parsing multiple files, it is recommended to use worker threads
+* with {@linkcode parseSync} rather than using {@linkcode parse}.
+*
+* @category Utilities
+*/
+function parseSync(filename, sourceText, options) {
+	return wrap((0, import_binding.parseSync)(filename, sourceText, options));
+}
+//#endregion
+export { parseSync as n, parse as t };