@vizejs/vite-plugin-musea 0.429.1 → 0.430.1

package/dist/utils-DeMLVlNS.mjs

@@ -0,0 +1,628 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+//#region src/with-defaults.ts
+/**
+* Parsing helpers for extracting prop defaults from a Vue SFC `<script setup>`
+* block. Defaults are read only from `withDefaults(defineProps(...), { ... })`
+* so unrelated local identifiers are never treated as prop defaults.
+*/
+function extractWithDefaults(scriptContent) {
+	const defaults = /* @__PURE__ */ new Map();
+	let searchIndex = 0;
+	while (searchIndex < scriptContent.length) {
+		const calleeIndex = scriptContent.indexOf("withDefaults", searchIndex);
+		if (calleeIndex === -1) break;
+		searchIndex = calleeIndex + 12;
+		if (!isIdentifierBoundary(scriptContent[calleeIndex - 1])) continue;
+		if (!isIdentifierBoundary(scriptContent[searchIndex])) continue;
+		const parenIndex = skipWhitespace(scriptContent, searchIndex);
+		if (scriptContent[parenIndex] !== "(") continue;
+		const endParen = findMatching(scriptContent, parenIndex, "(", ")");
+		if (endParen === -1) continue;
+		const defaultsArg = splitTopLevel(scriptContent.slice(parenIndex + 1, endParen))[1]?.trim();
+		if (!defaultsArg?.startsWith("{")) continue;
+		const objectStart = scriptContent.indexOf(defaultsArg, parenIndex + 1);
+		const objectEnd = findMatching(scriptContent, objectStart, "{", "}");
+		if (objectEnd === -1) continue;
+		for (const [name, value] of objectProperties(scriptContent.slice(objectStart + 1, objectEnd))) defaults.set(name, value);
+	}
+	return defaults;
+}
+function objectProperties(objectBody) {
+	const properties = [];
+	for (const item of splitTopLevel(objectBody)) {
+		const colonIndex = topLevelColon(item);
+		if (colonIndex === -1) continue;
+		const rawKey = item.slice(0, colonIndex).trim();
+		const key = rawKey.match(/^[$A-Z_a-z][$\w]*$/)?.[0] ?? rawKey.match(/^["']([^"']+)["']$/)?.[1];
+		if (!key) continue;
+		const value = item.slice(colonIndex + 1).trim();
+		if (value) properties.push([key, value]);
+	}
+	return properties;
+}
+function splitTopLevel(source) {
+	const parts = [];
+	let start = 0;
+	let round = 0;
+	let curly = 0;
+	let square = 0;
+	let quote = null;
+	let escaped = false;
+	for (let index = 0; index < source.length; index++) {
+		const char = source[index];
+		if (quote) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === "(") round++;
+		else if (char === ")") round--;
+		else if (char === "{") curly++;
+		else if (char === "}") curly--;
+		else if (char === "[") square++;
+		else if (char === "]") square--;
+		else if (char === "," && round === 0 && curly === 0 && square === 0) {
+			parts.push(source.slice(start, index).trim());
+			start = index + 1;
+		}
+	}
+	const tail = source.slice(start).trim();
+	if (tail) parts.push(tail);
+	return parts;
+}
+function topLevelColon(source) {
+	let round = 0;
+	let curly = 0;
+	let square = 0;
+	let quote = null;
+	let escaped = false;
+	for (let index = 0; index < source.length; index++) {
+		const char = source[index];
+		if (quote) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === "(") round++;
+		else if (char === ")") round--;
+		else if (char === "{") curly++;
+		else if (char === "}") curly--;
+		else if (char === "[") square++;
+		else if (char === "]") square--;
+		else if (char === ":" && round === 0 && curly === 0 && square === 0) return index;
+	}
+	return -1;
+}
+function findMatching(source, start, open, close) {
+	let depth = 0;
+	let quote = null;
+	let escaped = false;
+	for (let index = start; index < source.length; index++) {
+		const char = source[index];
+		if (quote) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === open) depth++;
+		if (char === close) {
+			depth--;
+			if (depth === 0) return index;
+		}
+	}
+	return -1;
+}
+function skipWhitespace(source, index) {
+	while (index < source.length && /\s/.test(source[index])) index++;
+	return index;
+}
+function isIdentifierBoundary(char) {
+	return char === void 0 || !/[$\w]/.test(char);
+}
+//#endregion
+//#region src/native-loader.ts
+/**
+* Native binding loader for @vizejs/native.
+*
+* Provides lazy-loading of the native Rust-based parser and a JS fallback
+* for SFC analysis when the native `analyzeSfc` function is unavailable.
+*/
+let native = null;
+function loadNative() {
+	if (native) return native;
+	const require = createRequire(import.meta.url);
+	try {
+		native = require("@vizejs/native");
+		return native;
+	} catch (e) {
+		throw new Error(`Failed to load @vizejs/native. Make sure it's installed and built:\n${String(e)}`);
+	}
+}
+/**
+* JS-based fallback for SFC analysis when native `analyzeSfc` is not available.
+* Uses regex parsing to extract props and emits from Vue SFC source.
+*/
+function analyzeSfcFallback(source, _options) {
+	try {
+		const props = [];
+		const emits = [];
+		const scriptSetupMatch = source.match(/<script\s+[^>]*setup[^>]*>([\s\S]*?)<\/script>/);
+		if (!scriptSetupMatch) {
+			if (!source.match(/<script[^>]*>([\s\S]*?)<\/script>/)) return {
+				props: [],
+				emits: []
+			};
+		}
+		const scriptContent = scriptSetupMatch?.[1] || "";
+		const propsMatch = scriptContent.match(/defineProps\s*<\s*\{([\s\S]*?)\}>\s*\(/);
+		const propsMatch2 = scriptContent.match(/defineProps\s*<\s*\{([\s\S]*?)\}>/);
+		const propsBody = propsMatch?.[1] || propsMatch2?.[1];
+		const withDefaults = extractWithDefaults(scriptContent);
+		if (propsBody) {
+			const lines = propsBody.split("\n");
+			let i = 0;
+			while (i < lines.length) {
+				const line = lines[i].trim();
+				if (line.startsWith("/**") || line.startsWith("*") || line.startsWith("*/")) {
+					i++;
+					continue;
+				}
+				const propMatch = line.match(/^(\w+)(\?)?:\s*(.+?)(?:;?\s*)$/);
+				if (propMatch) {
+					const name = propMatch[1];
+					const optional = !!propMatch[2];
+					let type = propMatch[3].replace(/;$/, "").trim();
+					const defaultValue = withDefaults.get(name);
+					props.push({
+						name,
+						type,
+						required: !optional && defaultValue === void 0,
+						...defaultValue !== void 0 ? { default_value: defaultValue } : {}
+					});
+				}
+				i++;
+			}
+		}
+		const emitsMatch = scriptContent.match(/defineEmits\s*<\s*\{([\s\S]*?)\}>/);
+		if (emitsMatch) {
+			const emitsBody = emitsMatch[1];
+			const emitRegex = /(\w+)\s*:/g;
+			let match;
+			while ((match = emitRegex.exec(emitsBody)) !== null) emits.push(match[1]);
+		}
+		return {
+			props,
+			emits
+		};
+	} catch {
+		return {
+			props: [],
+			emits: []
+		};
+	}
+}
+//#endregion
+//#region src/http-error.ts
+var HttpError = class extends Error {
+	status;
+	constructor(message, status) {
+		super(message);
+		this.name = "HttpError";
+		this.status = status;
+	}
+};
+//#endregion
+//#region src/trusted-path.ts
+function realpathNearest(targetPath) {
+	let current = path.resolve(targetPath);
+	const missingParts = [];
+	while (true) try {
+		const real = fs.realpathSync.native(current);
+		return missingParts.length > 0 ? path.join(real, ...missingParts.reverse()) : real;
+	} catch {
+		const parent = path.dirname(current);
+		if (parent === current) return path.resolve(targetPath);
+		missingParts.push(path.basename(current));
+		current = parent;
+	}
+}
+function isResolvedPathInside(parentDir, candidatePath) {
+	const parent = path.resolve(parentDir);
+	const candidate = path.resolve(candidatePath);
+	const relative = path.relative(parent, candidate);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function isPathInsideAny(parentDirs, candidatePath) {
+	const candidate = realpathNearest(candidatePath);
+	return parentDirs.some((parentDir) => isResolvedPathInside(realpathNearest(parentDir), candidate));
+}
+/**
+* True when `candidatePath` stays inside the project, or inside an extra root
+* that was configured to live outside the project.
+*
+* Extra roots whose lexical path is still inside the project are not trusted
+* after realpath — a planted `src` → `/etc` symlink must not widen the
+* readable boundary.
+*/
+function isTrustedSourcePath(projectRoot, extraLexicalRoots, candidatePath) {
+	const lexicalProject = path.resolve(projectRoot);
+	const realProject = realpathNearest(projectRoot);
+	const realCandidate = realpathNearest(candidatePath);
+	if (isResolvedPathInside(realProject, realCandidate)) return true;
+	for (const lexicalRoot of extraLexicalRoots) {
+		const resolvedLexical = path.resolve(lexicalRoot);
+		if (isResolvedPathInside(lexicalProject, resolvedLexical)) continue;
+		if (isResolvedPathInside(realpathNearest(resolvedLexical), realCandidate)) return true;
+	}
+	return false;
+}
+function resolveTrustedSourcePath(projectRoot, extraLexicalRoots, candidatePath, label = "path") {
+	if (candidatePath.includes("\0")) throw new HttpError(`${label} contains an invalid character`, 400);
+	const resolved = path.isAbsolute(candidatePath) ? path.resolve(candidatePath) : path.resolve(path.resolve(projectRoot), candidatePath);
+	if (!isTrustedSourcePath(projectRoot, extraLexicalRoots, resolved)) throw new HttpError(`${label} escapes the allowed directory`, 400);
+	return resolved;
+}
+function resolveInside(parentDir, candidatePath, label = "path") {
+	return resolveInsideAny([parentDir], candidatePath, label);
+}
+function resolveInsideAny(parentDirs, candidatePath, label = "path") {
+	if (candidatePath.includes("\0")) throw new HttpError(`${label} contains an invalid character`, 400);
+	if (parentDirs.length === 0) throw new HttpError(`No allowed directories configured for ${label}`, 500);
+	const parent = path.resolve(parentDirs[0] ?? ".");
+	const resolved = path.isAbsolute(candidatePath) ? path.resolve(candidatePath) : path.resolve(parent, candidatePath);
+	if (!isPathInsideAny(parentDirs, resolved)) throw new HttpError(`${label} escapes the allowed directory`, 400);
+	return resolved;
+}
+function resolveUrlPathInside(parentDir, requestUrl, label = "path") {
+	let pathname = decodeUrlComponent(requestUrl.split(/[?#]/, 1)[0] || "/", label);
+	pathname = pathname.replaceAll("\\", "/");
+	if (pathname.split("/").includes("..")) throw new HttpError(`${label} must not contain parent directory segments`, 400);
+	return resolveInside(parentDir, `.${pathname}`, label);
+}
+function decodeUrlComponent(value, label = "path") {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		throw new HttpError(`${label} is not valid URL encoding`, 400);
+	}
+}
+function hasSuffix(candidatePath, suffix) {
+	return realpathNearest(candidatePath).toLowerCase().endsWith(suffix);
+}
+/**
+* True when the realpath still looks like a Vue SFC. A planted
+* `Evil.vue` → `.env` symlink must not be treated as component source.
+*/
+function isVueSourcePath(candidatePath) {
+	return hasSuffix(candidatePath, ".vue");
+}
+function assertVueSourcePath(candidatePath, label = "path") {
+	if (!isVueSourcePath(candidatePath)) throw new HttpError(`${label} must be a .vue file`, 400);
+}
+/** Accept Vue SFCs and script modules while validating the resolved realpath. */
+function assertComponentSourcePath(candidatePath, label = "path") {
+	const realPath = realpathNearest(candidatePath).toLowerCase();
+	if (!/\.(?:vue|ts|tsx|js|jsx)$/.test(realPath)) throw new HttpError(`${label} must be a .vue, .ts, .tsx, .js, or .jsx file`, 400);
+}
+function isArtVueSourcePath(candidatePath) {
+	return hasSuffix(candidatePath, ".art.vue");
+}
+function assertArtVueSourcePath(candidatePath, label = "art path") {
+	if (!isArtVueSourcePath(candidatePath)) throw new HttpError(`${label} must be a .art.vue file`, 400);
+}
+//#endregion
+//#region src/security.ts
+const DEFAULT_API_BODY_LIMIT_BYTES = 1024 * 1024;
+function createDevSessionToken() {
+	return randomBytes(32).toString("base64url");
+}
+function collectRequestBody(req, limit = DEFAULT_API_BODY_LIMIT_BYTES) {
+	return new Promise((resolve, reject) => {
+		let body = "";
+		let size = 0;
+		let completed = false;
+		req.on("data", (chunk) => {
+			if (completed) return;
+			const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+			size += buffer.byteLength;
+			if (size > limit) {
+				completed = true;
+				reject(new HttpError(`Request body exceeds ${limit} bytes`, 413));
+				return;
+			}
+			body += buffer.toString("utf-8");
+		});
+		req.on("end", () => {
+			if (!completed) {
+				completed = true;
+				resolve(body);
+			}
+		});
+		req.on("error", (error) => {
+			if (!completed) {
+				completed = true;
+				reject(error);
+			}
+		});
+	});
+}
+function parseJsonBody(body) {
+	try {
+		return JSON.parse(body);
+	} catch (error) {
+		if (error instanceof SyntaxError) throw new HttpError("Malformed JSON body", 400);
+		throw error;
+	}
+}
+function isLoopbackAddress(address) {
+	const value = address.trim().toLowerCase().replace(/^\[|\]$/g, "");
+	if (value === "localhost" || value === "::1") return true;
+	if (value.startsWith("::ffff:") || value.startsWith(":ffff:")) return isLoopbackAddress(value.slice(value.indexOf("ffff:") + 5));
+	const parts = value.split(".");
+	if (parts.length !== 4 || parts[0] !== "127") return false;
+	return parts.every((part, index) => {
+		if (index === 0) return true;
+		const octet = Number(part);
+		return Number.isInteger(octet) && octet >= 0 && octet <= 255;
+	});
+}
+function isLoopbackRequest(req) {
+	const remote = req.socket?.remoteAddress;
+	if (!remote) return false;
+	return isLoopbackAddress(remote);
+}
+function validateDevApiRequest(req, sessionToken) {
+	const originError = validateOrigin(req);
+	if (originError) return originError;
+	if (!isUnsafeMethod(req.method)) return null;
+	if (!isLoopbackRequest(req)) return new HttpError("Musea write APIs are limited to loopback clients", 403);
+	if (!hasValidSessionToken(req, sessionToken)) return new HttpError("Invalid Musea dev session token", 403);
+	if (!isJsonRequest(req)) return new HttpError("Content-Type must be application/json", 415);
+	return null;
+}
+function serializeScriptValue(value) {
+	return (JSON.stringify(value) ?? "undefined").replace(/[<>&\u2028\u2029]/g, (char) => {
+		switch (char) {
+			case "<": return "\\u003C";
+			case ">": return "\\u003E";
+			case "&": return "\\u0026";
+			case "\u2028": return "\\u2028";
+			case "\u2029": return "\\u2029";
+			default: return char;
+		}
+	});
+}
+function isUnsafeMethod(method) {
+	return method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE";
+}
+function isJsonRequest(req) {
+	return getHeader(req, "content-type")?.split(";")[0]?.trim().toLowerCase() === "application/json";
+}
+function validateOrigin(req) {
+	if (getHeader(req, "sec-fetch-site") === "cross-site") return new HttpError("Cross-origin Musea API requests are not allowed", 403);
+	const origin = getHeader(req, "origin");
+	if (!origin) return null;
+	const host = getHeader(req, "host");
+	if (!host) return new HttpError("Missing Host header", 400);
+	try {
+		if (new URL(origin).host !== host) return new HttpError("Cross-origin Musea API requests are not allowed", 403);
+	} catch {
+		return new HttpError("Invalid Origin header", 400);
+	}
+	return null;
+}
+function hasValidSessionToken(req, expectedToken) {
+	const actualToken = getHeader(req, "x-musea-session");
+	if (!actualToken) return false;
+	const actual = Buffer.from(actualToken);
+	const expected = Buffer.from(expectedToken);
+	return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+function getHeader(req, name) {
+	const value = req.headers[name];
+	if (Array.isArray(value)) return value[0];
+	return value;
+}
+//#endregion
+//#region src/theme-config.ts
+/**
+* Build the theme config object from plugin options for runtime injection.
+*/
+function buildThemeConfig(theme) {
+	if (!theme) return void 0;
+	if (typeof theme === "string") return { default: theme };
+	const themes = Array.isArray(theme) ? theme : [theme];
+	const custom = {};
+	for (const t of themes) custom[t.name] = {
+		base: t.base,
+		colors: t.colors
+	};
+	return {
+		default: themes[0].name,
+		custom
+	};
+}
+//#endregion
+//#region src/utils.ts
+/**
+* Shared utility functions for the Musea Vite plugin.
+*/
+function normalizeGlobPath(filepath) {
+	return filepath.split(path.sep).join("/");
+}
+function matchesPattern(file, pattern, root) {
+	const normalizedPattern = normalizeGlobPath(pattern);
+	return matchGlob(path.isAbsolute(pattern) ? path.resolve(file) : path.relative(root, file), normalizedPattern);
+}
+function shouldProcess(file, include, exclude, root) {
+	for (const pattern of exclude) if (matchesPattern(file, pattern, root)) return false;
+	for (const pattern of include) if (matchesPattern(file, pattern, root)) return true;
+	return false;
+}
+function matchGlob(filepath, pattern) {
+	const normalizedFilepath = normalizeGlobPath(filepath);
+	const normalizedPattern = normalizeGlobPath(pattern);
+	const PLACEHOLDER = "<<GLOBSTAR>>";
+	const SEGMENT_PLACEHOLDER = "<<GLOBSTAR_SEGMENT>>";
+	const regex = normalizedPattern.replaceAll("**/", SEGMENT_PLACEHOLDER).replaceAll("**", PLACEHOLDER).replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, "[^/]*").replaceAll(SEGMENT_PLACEHOLDER, "(?:.*/)?").replaceAll(PLACEHOLDER, ".*");
+	return new RegExp(`^${regex}$`).test(normalizedFilepath);
+}
+async function readGitignoreDirectoryNames(bases) {
+	const names = /* @__PURE__ */ new Set();
+	for (const base of bases) {
+		let text = "";
+		try {
+			text = await fs.promises.readFile(path.join(base, ".gitignore"), "utf8");
+		} catch {
+			continue;
+		}
+		for (const line of text.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("!")) continue;
+			const cleaned = trimmed.replace(/^\//, "").replace(/\/$/, "");
+			if (!cleaned || cleaned.includes("*") || cleaned.includes("/")) continue;
+			names.add(cleaned);
+		}
+	}
+	return names;
+}
+async function shouldSkipScanDirectory(name, fullPath, scanRoots, ignoredDirNames) {
+	if (scanRoots.some((scanRoot) => path.resolve(scanRoot) === path.resolve(fullPath))) return false;
+	if (name.startsWith(".") || ignoredDirNames.has(name)) return true;
+	try {
+		await fs.promises.lstat(path.join(fullPath, ".git"));
+		return true;
+	} catch {
+		return false;
+	}
+}
+function resolveScanRoot(root, pattern) {
+	const absolutePattern = path.isAbsolute(pattern) ? pattern : path.resolve(root, pattern);
+	const normalizedPattern = normalizeGlobPath(absolutePattern);
+	const globIndex = normalizedPattern.search(/[*[{]/);
+	if (globIndex === -1) return path.dirname(absolutePattern);
+	const staticPrefix = normalizedPattern.slice(0, globIndex);
+	if (!staticPrefix) return root;
+	if (staticPrefix.endsWith("/")) return path.resolve(staticPrefix.slice(0, -1));
+	return path.resolve(path.dirname(staticPrefix));
+}
+function resolveScanRoots(root, include) {
+	const roots = /* @__PURE__ */ new Set();
+	for (const pattern of include) roots.add(resolveScanRoot(root, pattern));
+	if (roots.size === 0) roots.add(root);
+	return [...roots];
+}
+async function scanArtFiles(root, include, exclude, scanInlineArt = false) {
+	const files = /* @__PURE__ */ new Set();
+	const scanRoots = resolveScanRoots(root, include);
+	const visitedDirs = /* @__PURE__ */ new Set();
+	const ignoredDirNames = await readGitignoreDirectoryNames([root, ...scanRoots]);
+	async function scan(dir) {
+		const resolvedDir = path.resolve(dir);
+		if (visitedDirs.has(resolvedDir)) return;
+		visitedDirs.add(resolvedDir);
+		let entries;
+		try {
+			entries = await fs.promises.readdir(resolvedDir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const fullPath = path.join(resolvedDir, entry.name);
+			let excluded = false;
+			for (const pattern of exclude) if (matchesPattern(fullPath, pattern, root) || matchGlob(entry.name, pattern)) {
+				excluded = true;
+				break;
+			}
+			if (excluded) continue;
+			if (entry.isSymbolicLink()) continue;
+			if (entry.isDirectory()) {
+				if (await shouldSkipScanDirectory(entry.name, fullPath, scanRoots, ignoredDirNames)) continue;
+				await scan(fullPath);
+			} else if (entry.isFile() && entry.name.endsWith(".art.vue")) {
+				if (shouldProcess(fullPath, include, exclude, root) && isTrustedSourcePath(root, scanRoots, fullPath)) files.add(fullPath);
+			} else if (scanInlineArt && entry.isFile() && entry.name.endsWith(".vue") && !entry.name.endsWith(".art.vue")) {
+				if (!isTrustedSourcePath(root, scanRoots, fullPath)) continue;
+				if ((await fs.promises.readFile(fullPath, "utf-8")).includes("<art")) files.add(fullPath);
+			}
+		}
+	}
+	for (const scanRoot of scanRoots) await scan(scanRoot);
+	return [...files];
+}
+async function generateStorybookFiles(artFiles, root, outDir) {
+	const binding = loadNative();
+	const outputDir = path.resolve(root, outDir);
+	await fs.promises.mkdir(outputDir, { recursive: true });
+	for (const [filePath, art] of artFiles) try {
+		const source = await fs.promises.readFile(filePath, "utf-8");
+		const csf = binding.artToCsf(source, { filename: filePath });
+		const outputPath = path.join(outputDir, csf.filename);
+		const code = rewriteStorybookScriptImports(rewriteStorybookComponentImport(csf.code, art, filePath, outputPath), filePath, outputPath);
+		await fs.promises.writeFile(outputPath, code, "utf-8");
+		console.log(`[musea] Generated: ${path.relative(root, outputPath)}`);
+	} catch (e) {
+		console.error(`[musea] Failed to generate CSF for ${filePath}:`, e);
+	}
+}
+function rewriteStorybookComponentImport(code, art, artPath, outputPath) {
+	const component = art.isInline && art.componentPath ? art.componentPath : art.metadata.component;
+	if (!component || isBareImport(component)) return code;
+	const resolvedComponent = path.isAbsolute(component) ? component : path.resolve(path.dirname(artPath), component);
+	let relativeComponent = normalizeGlobPath(path.relative(path.dirname(outputPath), resolvedComponent));
+	if (!relativeComponent.startsWith(".")) relativeComponent = `./${relativeComponent}`;
+	return code.replace(/import\s+(__museaComponent)\s+from\s+(['"])([^'"]+)\2;/, `import $1 from $2${relativeComponent}$2;`);
+}
+function isBareImport(source) {
+	return !source.startsWith(".") && !path.isAbsolute(source);
+}
+/**
+* Rewrite relative import specifiers in the generated Storybook CSF file so that
+* imports lifted verbatim from the art file's `<script setup>` resolve against
+* the generated file's location instead of the original art file's directory.
+*
+* The `__museaComponent` import is already rebased by
+* `rewriteStorybookComponentImport` and is skipped here.
+*/
+function rewriteStorybookScriptImports(code, artPath, outputPath) {
+	const artDir = path.dirname(artPath);
+	const outDir = path.dirname(outputPath);
+	return code.replace(/(import\s+(?:[\s\S]*?)\s+from\s+)(['"])([^'"]+)\2(\s*;?)/g, (match, head, quote, specifier, tail) => {
+		if (!specifier.startsWith(".")) return match;
+		if (/\b__museaComponent\b/.test(head)) return match;
+		const resolved = path.resolve(artDir, specifier);
+		let rebased = normalizeGlobPath(path.relative(outDir, resolved));
+		if (!rebased.startsWith(".")) rebased = `./${rebased}`;
+		return `${head}${quote}${rebased}${quote}${tail}`;
+	});
+}
+function toPascalCase(str) {
+	const pascal = str.normalize("NFKD").replace(/[^\p{L}\p{N}]+/gu, " ").trim().split(/\s+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+	if (!pascal) return "Variant";
+	return /^[\p{L}_$]/u.test(pascal) ? pascal : `Variant${pascal}`;
+}
+function escapeHtml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+}
+//#endregion
+export { resolveUrlPathInside as C, loadNative as E, resolveTrustedSourcePath as S, analyzeSfcFallback as T, assertVueSourcePath as _, scanArtFiles as a, resolveInside as b, buildThemeConfig as c, createDevSessionToken as d, parseJsonBody as f, assertComponentSourcePath as g, assertArtVueSourcePath as h, resolveScanRoots as i, DEFAULT_API_BODY_LIMIT_BYTES as l, validateDevApiRequest as m, generateStorybookFiles as n, shouldProcess as o, serializeScriptValue as p, matchGlob as r, toPascalCase as s, escapeHtml as t, collectRequestBody as u, decodeUrlComponent as v, HttpError as w, resolveInsideAny as x, isVueSourcePath as y };
+
+//# sourceMappingURL=utils-DeMLVlNS.mjs.map