@open-slide/core 1.0.4 → 1.0.5

package/dist/{config-CN7J0RDO.js → config-Bxtztw-H.js}

@@ -7,6 +7,9 @@ import { existsSync } from "node:fs";
 import tailwindcss from "@tailwindcss/vite";
 import react from "@vitejs/plugin-react";
 import { parse } from "@babel/parser";
+import * as t$1 from "@babel/types";
+import * as t from "@babel/types";
+import { isJSXElement, isJSXFragment } from "@babel/types";
 import fg from "fast-glob";
 import { loadConfigFromFile } from "vite";
 
@@ -21,28 +24,34 @@ const SKIP_KEYS = new Set([
 	"trailingComments",
 	"innerComments"
 ]);
-function walkJsx(ast, visit) {
+function walk(ast, visit, accept) {
 	let stopped = false;
-	const walk = (node) => {
+	const recurse = (node) => {
 		if (stopped || !node || typeof node !== "object") return;
 		if (Array.isArray(node)) {
-			for (const c of node) walk(c);
+			for (const c of node) recurse(c);
 			return;
 		}
 		const n = node;
 		if (typeof n.type !== "string") return;
-		if (n.type === "JSXElement" || n.type === "JSXFragment") {
-			if (visit(n) === "stop") {
-				stopped = true;
-				return;
-			}
+		if (accept(n) && visit(n) === "stop") {
+			stopped = true;
+			return;
 		}
 		for (const key of Object.keys(n)) {
 			if (SKIP_KEYS.has(key)) continue;
-			walk(n[key]);
+			recurse(n[key]);
 		}
 	};
-	walk(ast);
+	recurse(ast);
+}
+const isJsx = (n) => isJSXElement(n) || isJSXFragment(n);
+const acceptAll = () => true;
+function walkJsx(ast, visit) {
+	walk(ast, visit, isJsx);
+}
+function walkAll(ast, visit) {
+	walk(ast, visit, acceptAll);
 }
 
 //#endregion
@@ -126,54 +135,44 @@ function lineIndent(source, lineNumber) {
 function findJsxAncestors(ast, line, column) {
 	const hits = [];
 	walkJsx(ast, (n) => {
-		if (!n.loc) return;
+		if (!n.loc || !t$1.isJSXElement(n) && !t$1.isJSXFragment(n)) return;
 		const s = n.loc.start;
 		const e = n.loc.end;
 		const afterStart = line > s.line || line === s.line && column >= s.column;
 		const beforeEnd = line < e.line || line === e.line && column < e.column;
 		if (afterStart && beforeEnd) hits.push({
 			node: n,
-			size: n.end - n.start
+			size: (n.end ?? 0) - (n.start ?? 0)
 		});
 	});
 	hits.sort((a, b) => a.size - b.size);
 	return hits.map((h) => h.node);
 }
 function planInsertion(source, target) {
-	if (target.type === "JSXFragment") {
+	if (t$1.isJSXFragment(target)) {
 		const opening = target.openingFragment;
-		if (!opening) return null;
 		const startLine = target.loc?.start.line ?? 1;
 		return {
-			offset: opening.end,
+			offset: opening.end ?? 0,
 			indent: `${lineIndent(source, startLine)}  `
 		};
 	}
-	if (target.type === "JSXElement") {
+	if (t$1.isJSXElement(target)) {
 		const opening = target.openingElement;
-		if (!opening || opening.selfClosing) return null;
+		if (opening.selfClosing) return null;
 		const startLine = target.loc?.start.line ?? 1;
 		return {
-			offset: opening.end,
+			offset: opening.end ?? 0,
 			indent: `${lineIndent(source, startLine)}  `
 		};
 	}
 	return null;
 }
 function findInsertion(source, line, column) {
-	let ast;
-	try {
-		ast = parse(source, {
-			sourceType: "module",
-			plugins: ["typescript", "jsx"],
-			errorRecovery: true
-		});
-	} catch {
-		return null;
-	}
+	const ast = parseSource$1(source);
+	if (!ast) return null;
 	const col = column ?? 0;
 	const ancestors = findJsxAncestors(ast, line, col);
-	if (ancestors.length === 0) return null;
 	for (const node of ancestors) {
 		const plan = planInsertion(source, node);
 		if (plan) return plan;
@@ -196,19 +195,16 @@ function parseSource$1(source) {
 		return null;
 	}
 }
-function findInnermostJsxElement(source, line, column) {
-	const ast = parseSource$1(source);
-	if (!ast) return null;
+function findInnermostJsxElement(ast, line, column) {
 	const exact = findJsxByStart(ast, line, column);
 	if (exact) return exact;
-	const ancestors = findJsxAncestors(ast, line, column);
-	for (const n of ancestors) if (n.type === "JSXElement") return n;
+	for (const n of findJsxAncestors(ast, line, column)) if (t$1.isJSXElement(n)) return n;
 	return null;
 }
 function findJsxByStart(ast, line, column) {
 	let hit = null;
 	walkJsx(ast, (n) => {
-		if (n.type !== "JSXElement" || !n.loc) return;
+		if (!t$1.isJSXElement(n) || !n.loc) return;
 		const s = n.loc.start;
 		if (s.line === line && s.column === column) {
 			hit = n;
@@ -220,60 +216,56 @@ function findJsxByStart(ast, line, column) {
 function jsString$1(s) {
 	return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n")}'`;
 }
-function findStyleAttr(opening) {
-	const attrs = opening.attributes ?? [];
-	for (const attr of attrs) {
-		if (attr.type !== "JSXAttribute") continue;
-		const name = attr.name;
-		if (name?.type === "JSXIdentifier" && name.name === "style") return attr;
-	}
+function jsxAttrName(attr) {
+	return t$1.isJSXIdentifier(attr.name) ? attr.name.name : null;
+}
+function findJsxAttr(opening, name) {
+	for (const attr of opening.attributes) if (t$1.isJSXAttribute(attr) && jsxAttrName(attr) === name) return attr;
 	return null;
 }
 function buildStyleSplice(source, element, ops) {
 	const opening = element.openingElement;
-	if (!opening) return { error: "no opening element" };
-	const existing = findStyleAttr(opening);
+	const existing = findJsxAttr(opening, "style");
 	const style = new Map();
 	if (existing) {
 		const value = existing.value;
-		if (!value || value.type !== "JSXExpressionContainer") return { error: "style attribute has unsupported form" };
+		if (!value || !t$1.isJSXExpressionContainer(value)) return { error: "style attribute has unsupported form" };
 		const expr = value.expression;
-		if (expr.type !== "ObjectExpression") return { error: "style is not a literal object" };
-		const properties = expr.properties;
-		for (const prop of properties) {
-			if (prop.type !== "ObjectProperty") return { error: "style contains spread or method" };
-			const p = prop;
-			if (p.computed) return { error: "style has computed key" };
+		if (!t$1.isObjectExpression(expr)) return { error: "style is not a literal object" };
+		for (const prop of expr.properties) {
+			if (!t$1.isObjectProperty(prop)) return { error: "style contains spread or method" };
+			if (prop.computed) return { error: "style has computed key" };
 			let keyName = null;
-			if (p.key.type === "Identifier" && p.key.name) keyName = p.key.name;
-			else if (p.key.type === "StringLiteral" && typeof p.key.value === "string") keyName = p.key.value;
+			if (t$1.isIdentifier(prop.key)) keyName = prop.key.name;
+			else if (t$1.isStringLiteral(prop.key)) keyName = prop.key.value;
 			if (!keyName) return { error: "style has unsupported key" };
-			style.set(keyName, source.slice(p.value.start, p.value.end));
+			const v = prop.value;
+			if (typeof v.start !== "number" || typeof v.end !== "number") return { error: "style value missing source range" };
+			style.set(keyName, source.slice(v.start, v.end));
 		}
 	}
 	for (const op of ops) if (op.value === null) style.delete(op.key);
 	else style.set(op.key, jsString$1(op.value));
 	if (style.size === 0) {
 		if (!existing) return null;
-		let from = existing.start;
+		let from = existing.start ?? 0;
 		if (from > 0 && source[from - 1] === " ") from -= 1;
 		return {
 			from,
-			to: existing.end,
+			to: existing.end ?? 0,
 			text: ""
 		};
 	}
 	const propsText = Array.from(style.entries()).map(([k, v]) => `${k}: ${v}`).join(", ");
 	const newAttr = `style={{ ${propsText} }}`;
 	if (existing) return {
-		from: existing.start,
-		to: existing.end,
+		from: existing.start ?? 0,
+		to: existing.end ?? 0,
 		text: newAttr
 	};
-	const name = opening.name;
 	return {
-		from: name.end,
-		to: name.end,
+		from: opening.name.end ?? 0,
+		to: opening.name.end ?? 0,
 		text: ` ${newAttr}`
 	};
 }
@@ -281,57 +273,280 @@ function formatJsxText(value) {
 	if (/[{}<>]/.test(value) || /^\s|\s$/.test(value) || value === "") return `{${jsString$1(value)}}`;
 	return value;
 }
-function buildTextSplice(element, value) {
-	const children = element.children ?? [];
-	if (children.length === 0) return { error: "element has no children to edit" };
-	const meaningful = children.filter((c) => {
-		if (c.type === "JSXText") {
-			const v = c.value;
-			return v.trim() !== "";
-		}
+function meaningfulChildren(parent) {
+	return parent.children.filter((c) => {
+		if (t$1.isJSXText(c)) return c.value.trim() !== "";
 		return true;
 	});
-	if (meaningful.length !== 1) return { error: "element has complex children" };
+}
+function wrapSplice(parent, text) {
+	const first = parent.children[0];
+	const last = parent.children[parent.children.length - 1];
+	return {
+		from: first.start ?? 0,
+		to: last.end ?? 0,
+		text
+	};
+}
+function collectTextCandidates(element, out) {
+	const meaningful = meaningfulChildren(element);
+	const isSole = meaningful.length === 1;
+	for (const child of meaningful) if (t$1.isJSXText(child)) {
+		const current = child.value.trim();
+		if (!current) continue;
+		out.push({
+			current,
+			splice: (v) => isSole ? wrapSplice(element, formatJsxText(v)) : {
+				from: child.start ?? 0,
+				to: child.end ?? 0,
+				text: formatJsxText(v)
+			}
+		});
+	} else if (t$1.isJSXExpressionContainer(child)) {
+		const expr = child.expression;
+		if (t$1.isStringLiteral(expr) || t$1.isNumericLiteral(expr)) {
+			const current = String(expr.value);
+			out.push({
+				current,
+				splice: (v) => isSole ? wrapSplice(element, `{${jsString$1(v)}}`) : {
+					from: child.start ?? 0,
+					to: child.end ?? 0,
+					text: `{${jsString$1(v)}}`
+				}
+			});
+		}
+	} else if (t$1.isJSXElement(child) || t$1.isJSXFragment(child)) collectTextCandidates(child, out);
+}
+function propPassthroughName(element) {
+	const meaningful = meaningfulChildren(element);
+	if (meaningful.length !== 1) return null;
 	const child = meaningful[0];
-	if (child.type === "JSXText") {
-		const first = children[0];
-		const last = children[children.length - 1];
-		return {
-			from: first.start,
-			to: last.end,
-			text: formatJsxText(value)
-		};
+	if (!t$1.isJSXExpressionContainer(child)) return null;
+	return t$1.isIdentifier(child.expression) ? child.expression.name : null;
+}
+function findEnclosingComponent(ast, target) {
+	let best = null;
+	let bestSize = Number.POSITIVE_INFINITY;
+	const targetStart = target.start ?? 0;
+	const targetEnd = target.end ?? 0;
+	const consider = (name, fn) => {
+		if (!/^[A-Z]/.test(name)) return;
+		const fnStart = fn.start ?? 0;
+		const fnEnd = fn.end ?? 0;
+		if (fnStart > targetStart || fnEnd < targetEnd) return;
+		const size = fnEnd - fnStart;
+		if (size < bestSize) {
+			best = {
+				name,
+				fn
+			};
+			bestSize = size;
+		}
+	};
+	const visitDecl = (decl) => {
+		if (t$1.isFunctionDeclaration(decl) && decl.id) consider(decl.id.name, decl);
+		else if (t$1.isVariableDeclaration(decl)) for (const d of decl.declarations) {
+			if (!t$1.isVariableDeclarator(d) || !t$1.isIdentifier(d.id) || !d.init) continue;
+			if (t$1.isArrowFunctionExpression(d.init) || t$1.isFunctionExpression(d.init)) consider(d.id.name, d.init);
+		}
+	};
+	for (const decl of ast.program.body) {
+		visitDecl(decl);
+		if (t$1.isExportNamedDeclaration(decl) || t$1.isExportDefaultDeclaration(decl)) {
+			const inner = decl.declaration;
+			if (inner && (t$1.isStatement(inner) || t$1.isFunctionDeclaration(inner))) visitDecl(inner);
+		}
 	}
-	if (child.type === "JSXExpressionContainer") {
-		const expr = child.expression;
-		if (expr.type === "StringLiteral" || expr.type === "NumericLiteral") return {
-			from: child.start,
-			to: child.end,
-			text: `{${jsString$1(value)}}`
+	return best;
+}
+function componentDestructuresProp(fn, propName) {
+	if (fn.params.length === 0) return false;
+	let first = fn.params[0];
+	if (t$1.isAssignmentPattern(first)) first = first.left;
+	if (!t$1.isObjectPattern(first)) return false;
+	for (const prop of first.properties) {
+		if (!t$1.isObjectProperty(prop)) continue;
+		if (t$1.isIdentifier(prop.key) && prop.key.name === propName) return true;
+		if (t$1.isStringLiteral(prop.key) && prop.key.value === propName) return true;
+	}
+	return false;
+}
+function collectCallSiteCandidates(ast, componentName) {
+	const out = [];
+	walkJsx(ast, (n) => {
+		if (!t$1.isJSXElement(n)) return;
+		const elName = n.openingElement.name;
+		if (t$1.isJSXIdentifier(elName) && elName.name === componentName) collectTextCandidates(n, out);
+	});
+	return out;
+}
+function formatJsxAttrValue(value) {
+	if (/^[^"\\<>&{}\n\r]*$/.test(value)) return `"${value}"`;
+	return `{${jsString$1(value)}}`;
+}
+function spliceRange(node, text) {
+	return {
+		from: node.start ?? 0,
+		to: node.end ?? 0,
+		text
+	};
+}
+function collectPropCallSiteCandidates(ast, componentName, propName) {
+	const out = [];
+	walkJsx(ast, (n) => {
+		if (!t$1.isJSXElement(n)) return;
+		const elName = n.openingElement.name;
+		if (!t$1.isJSXIdentifier(elName) || elName.name !== componentName) return;
+		const attr = findJsxAttr(n.openingElement, propName);
+		if (!attr?.value) return;
+		const v = attr.value;
+		if (t$1.isStringLiteral(v)) out.push({
+			current: v.value,
+			splice: (s) => spliceRange(v, formatJsxAttrValue(s))
+		});
+		else if (t$1.isJSXExpressionContainer(v)) {
+			const expr = v.expression;
+			if (t$1.isStringLiteral(expr) || t$1.isNumericLiteral(expr)) out.push({
+				current: String(expr.value),
+				splice: (s) => spliceRange(v, formatJsxAttrValue(s))
+			});
+		}
+	});
+	return out;
+}
+function findEnclosingMapCallback(ast, target) {
+	let best = null;
+	const targetStart = target.start ?? 0;
+	const targetEnd = target.end ?? 0;
+	walkAll(ast, (node) => {
+		if (!t$1.isCallExpression(node)) return;
+		const callee = node.callee;
+		if (!t$1.isMemberExpression(callee) || callee.computed) return;
+		if (!t$1.isIdentifier(callee.property)) return;
+		if (callee.property.name !== "map" && callee.property.name !== "flatMap") return;
+		const fn = node.arguments[0];
+		if (!fn || !t$1.isArrowFunctionExpression(fn) && !t$1.isFunctionExpression(fn)) return;
+		const fnStart = fn.start ?? 0;
+		const fnEnd = fn.end ?? 0;
+		if (fnStart > targetStart || fnEnd < targetEnd) return;
+		if (!t$1.isExpression(callee.object)) return;
+		const size = fnEnd - fnStart;
+		if (!best || size < best.size) best = {
+			fn,
+			arrayArg: callee.object,
+			size
 		};
-		return { error: "element has dynamic expression child" };
+	});
+	if (!best) return null;
+	const found = best;
+	return {
+		fn: found.fn,
+		arrayArg: found.arrayArg
+	};
+}
+function resolveArrayLiteralElements(ast, expr) {
+	const dropHoles = (arr) => arr.elements.filter((e) => e != null);
+	if (t$1.isArrayExpression(expr)) return dropHoles(expr);
+	if (!t$1.isIdentifier(expr)) return null;
+	const name = expr.name;
+	const useStart = expr.start ?? 0;
+	let init = null;
+	walkAll(ast, (node) => {
+		if (!t$1.isVariableDeclarator(node)) return;
+		if (!t$1.isIdentifier(node.id) || node.id.name !== name) return;
+		if (!node.init || !t$1.isArrayExpression(node.init)) return;
+		if ((node.init.start ?? 0) > useStart) return;
+		init = node.init;
+	});
+	return init ? dropHoles(init) : null;
+}
+function findObjectProperty(obj, name) {
+	if (!t$1.isObjectExpression(obj)) return null;
+	for (const prop of obj.properties) {
+		if (!t$1.isObjectProperty(prop) || prop.computed) continue;
+		if (t$1.isIdentifier(prop.key) && prop.key.name === name) return prop;
+		if (t$1.isStringLiteral(prop.key) && prop.key.value === name) return prop;
+	}
+	return null;
+}
+function decodeMapPassthrough(element, callbackParam) {
+	const meaningful = meaningfulChildren(element);
+	if (meaningful.length !== 1) return null;
+	const child = meaningful[0];
+	if (!t$1.isJSXExpressionContainer(child)) return null;
+	const expr = child.expression;
+	if (t$1.isMemberExpression(expr)) {
+		if (expr.computed) return null;
+		if (!t$1.isIdentifier(expr.object) || !t$1.isIdentifier(expr.property)) return null;
+		if (!callbackParam || !t$1.isIdentifier(callbackParam)) return null;
+		if (callbackParam.name !== expr.object.name) return null;
+		return expr.property.name;
+	}
+	if (t$1.isIdentifier(expr)) {
+		const fieldName = expr.name;
+		if (!callbackParam || !t$1.isObjectPattern(callbackParam)) return null;
+		for (const prop of callbackParam.properties) {
+			if (!t$1.isObjectProperty(prop) || prop.computed) continue;
+			if (!t$1.isIdentifier(prop.key) || prop.key.name !== fieldName) continue;
+			return t$1.isIdentifier(prop.value) && prop.value.name === fieldName ? fieldName : null;
+		}
+	}
+	return null;
+}
+function collectArrayMapCandidates(ast, element) {
+	const ctx = findEnclosingMapCallback(ast, element);
+	if (!ctx) return [];
+	const fieldName = decodeMapPassthrough(element, ctx.fn.params[0]);
+	if (!fieldName) return [];
+	const elements = resolveArrayLiteralElements(ast, ctx.arrayArg);
+	if (!elements) return [];
+	const out = [];
+	for (const obj of elements) {
+		const prop = findObjectProperty(obj, fieldName);
+		if (!prop) continue;
+		const v = prop.value;
+		if (t$1.isStringLiteral(v)) out.push({
+			current: v.value,
+			splice: (s) => spliceRange(v, jsString$1(s))
+		});
+		else if (t$1.isNumericLiteral(v)) out.push({
+			current: String(v.value),
+			splice: (s) => spliceRange(v, jsString$1(s))
+		});
+	}
+	return out;
+}
+function buildTextSplice(ast, element, value, prevText) {
+	const candidates = [];
+	collectTextCandidates(element, candidates);
+	if (candidates.length === 0) {
+		const passthrough = propPassthroughName(element);
+		const enclosing = passthrough ? findEnclosingComponent(ast, element) : null;
+		if (passthrough === "children" && enclosing) candidates.push(...collectCallSiteCandidates(ast, enclosing.name));
+		else if (passthrough && enclosing && componentDestructuresProp(enclosing.fn, passthrough)) candidates.push(...collectPropCallSiteCandidates(ast, enclosing.name, passthrough));
 	}
-	return { error: "element has complex children" };
+	if (candidates.length === 0) candidates.push(...collectArrayMapCandidates(ast, element));
+	if (candidates.length === 0) return { error: "element has no editable text" };
+	if (candidates.length === 1) return candidates[0].splice(value);
+	if (prevText === void 0) return { error: "element has multiple text candidates; missing prevText" };
+	const norm = prevText.trim();
+	const matches = candidates.filter((c) => c.current === norm);
+	if (matches.length === 0) return { error: "no text candidate matches the current value" };
+	if (matches.length > 1) return { error: "multiple text candidates share the same value; cannot disambiguate" };
+	return matches[0].splice(value);
 }
 function findImports$1(ast) {
-	const body = ast.program?.body ?? [];
 	const out = [];
-	for (const node of body) {
-		if (node.type !== "ImportDeclaration") continue;
-		const src = node.source?.value;
-		if (typeof src !== "string") continue;
-		const specs = node.specifiers ?? [];
+	for (const node of ast.program.body) {
+		if (!t$1.isImportDeclaration(node)) continue;
 		let def = null;
-		for (const spec of specs) if (spec.type === "ImportDefaultSpecifier") {
-			const local = spec.local?.name;
-			if (typeof local === "string") {
-				def = local;
-				break;
-			}
+		for (const spec of node.specifiers) if (t$1.isImportDefaultSpecifier(spec)) {
+			def = spec.local.name;
+			break;
 		}
 		out.push({
 			node,
-			source: src,
+			source: node.source.value,
 			defaultIdent: def
 		});
 	}
@@ -341,11 +556,7 @@ function collectTopLevelIdentifiers(ast) {
 	const names = new Set();
 	for (const imp of findImports$1(ast)) {
 		if (imp.defaultIdent) names.add(imp.defaultIdent);
-		const specs = imp.node.specifiers ?? [];
-		for (const spec of specs) if (spec.type !== "ImportDefaultSpecifier") {
-			const local = spec.local?.name;
-			if (typeof local === "string") names.add(local);
-		}
+		for (const spec of imp.node.specifiers) if (!t$1.isImportDefaultSpecifier(spec)) names.add(spec.local.name);
 	}
 	return names;
 }
@@ -368,56 +579,43 @@ function safeAssetIdentifier(filename, taken) {
 	}
 	return candidate;
 }
-function findJsxAttr(opening, name) {
-	const attrs = opening.attributes ?? [];
-	for (const attr of attrs) {
-		if (attr.type !== "JSXAttribute") continue;
-		const n = attr.name;
-		if (n?.type === "JSXIdentifier" && n.name === name) return attr;
-	}
-	return null;
-}
-function planAssetAttr(ast, element, attr, assetPath) {
-	const opening = element.openingElement;
-	if (!opening) return { error: "no opening element" };
-	if (!attr || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(attr)) return { error: "invalid attribute name" };
-	if (!assetPath.startsWith("./assets/")) return { error: "asset path must start with ./assets/" };
+function planAssetImport(ast, assetPath) {
 	const imports = findImports$1(ast);
-	let identifier = null;
-	for (const imp of imports) if (imp.source === assetPath && imp.defaultIdent) {
-		identifier = imp.defaultIdent;
-		break;
-	}
-	let importSplice = null;
-	if (!identifier) {
-		const filename = assetPath.slice(assetPath.lastIndexOf("/") + 1);
-		const taken = collectTopLevelIdentifiers(ast);
-		identifier = safeAssetIdentifier(filename, taken);
-		const importStmt = `import ${identifier} from '${assetPath.replace(/'/g, "\\'")}';\n`;
-		const insertAt = imports.length > 0 ? imports[imports.length - 1].node.end : 0;
-		const prefix = imports.length > 0 ? "\n" : "";
-		importSplice = {
+	for (const imp of imports) if (imp.source === assetPath && imp.defaultIdent) return {
+		identifier: imp.defaultIdent,
+		importSplice: null
+	};
+	const filename = assetPath.slice(assetPath.lastIndexOf("/") + 1);
+	const identifier = safeAssetIdentifier(filename, collectTopLevelIdentifiers(ast));
+	const importStmt = `import ${identifier} from '${assetPath.replace(/'/g, "\\'")}';\n`;
+	const last = imports[imports.length - 1];
+	const insertAt = last ? last.node.end ?? 0 : 0;
+	const prefix = last ? "\n" : "";
+	return {
+		identifier,
+		importSplice: {
 			from: insertAt,
 			to: insertAt,
 			text: prefix + importStmt
-		};
-	}
+		}
+	};
+}
+function planAssetAttr(ast, element, attr, assetPath) {
+	if (!attr || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(attr)) return { error: "invalid attribute name" };
+	if (!assetPath.startsWith("./assets/")) return { error: "asset path must start with ./assets/" };
+	const { identifier, importSplice } = planAssetImport(ast, assetPath);
+	const opening = element.openingElement;
 	const newAttr = `${attr}={${identifier}}`;
 	const existing = findJsxAttr(opening, attr);
-	let attrSplice;
-	if (existing) attrSplice = {
-		from: existing.start,
-		to: existing.end,
+	const attrSplice = existing ? {
+		from: existing.start ?? 0,
+		to: existing.end ?? 0,
 		text: newAttr
+	} : {
+		from: opening.name.end ?? 0,
+		to: opening.name.end ?? 0,
+		text: ` ${newAttr}`
 	};
-	else {
-		const name = opening.name;
-		attrSplice = {
-			from: name.end,
-			to: name.end,
-			text: ` ${newAttr}`
-		};
-	}
 	return {
 		importSplice,
 		attrSplice
@@ -425,71 +623,36 @@ function planAssetAttr(ast, element, attr, assetPath) {
 }
 function readJsxStringAttr(opening, name) {
 	const attr = findJsxAttr(opening, name);
-	if (!attr) return null;
-	const value = attr.value ?? null;
-	if (!value) return null;
-	if (value.type === "StringLiteral") return value.value;
-	if (value.type === "JSXExpressionContainer") {
-		const expr = value.expression;
-		if (expr.type === "StringLiteral") return expr.value;
-	}
+	const v = attr?.value;
+	if (!v) return null;
+	if (t$1.isStringLiteral(v)) return v.value;
+	if (t$1.isJSXExpressionContainer(v) && t$1.isStringLiteral(v.expression)) return v.expression.value;
 	return null;
 }
 function readJsxNumberAttr(opening, name) {
 	const attr = findJsxAttr(opening, name);
-	if (!attr) return null;
-	const value = attr.value ?? null;
-	if (!value || value.type !== "JSXExpressionContainer") return null;
-	const expr = value.expression;
-	if (expr.type === "NumericLiteral") {
-		const n = expr.value;
-		return Number.isFinite(n) ? n : null;
-	}
-	return null;
+	const v = attr?.value;
+	if (!v || !t$1.isJSXExpressionContainer(v)) return null;
+	if (!t$1.isNumericLiteral(v.expression)) return null;
+	const n = v.expression.value;
+	return Number.isFinite(n) ? n : null;
 }
 function planReplacePlaceholder(ast, element, assetPath) {
 	const opening = element.openingElement;
-	if (!opening) return { error: "no opening element" };
-	const elName = opening.name;
-	if (elName?.type !== "JSXIdentifier" || elName.name !== "ImagePlaceholder") return { error: "not a placeholder" };
+	if (!t$1.isJSXIdentifier(opening.name) || opening.name.name !== "ImagePlaceholder") return { error: "not a placeholder" };
 	if (!assetPath.startsWith("./assets/")) return { error: "asset path must start with ./assets/" };
 	const hint = readJsxStringAttr(opening, "hint") ?? "";
 	const width = readJsxNumberAttr(opening, "width");
 	const height = readJsxNumberAttr(opening, "height");
-	const imports = findImports$1(ast);
-	let identifier = null;
-	for (const imp of imports) if (imp.source === assetPath && imp.defaultIdent) {
-		identifier = imp.defaultIdent;
-		break;
-	}
-	let importSplice = null;
-	if (!identifier) {
-		const filename = assetPath.slice(assetPath.lastIndexOf("/") + 1);
-		const taken = collectTopLevelIdentifiers(ast);
-		identifier = safeAssetIdentifier(filename, taken);
-		const importStmt = `import ${identifier} from '${assetPath.replace(/'/g, "\\'")}';\n`;
-		const insertAt = imports.length > 0 ? imports[imports.length - 1].node.end : 0;
-		const prefix = imports.length > 0 ? "\n" : "";
-		importSplice = {
-			from: insertAt,
-			to: insertAt,
-			text: prefix + importStmt
-		};
-	}
+	const { identifier, importSplice } = planAssetImport(ast, assetPath);
 	const styleParts = [];
 	if (width != null) styleParts.push(`width: ${width}`);
 	if (height != null) styleParts.push(`height: ${height}`);
 	styleParts.push(`objectFit: 'cover'`);
-	const styleAttr = ` style={{ ${styleParts.join(", ")} }}`;
-	const altAttr = ` alt=${jsString$1(hint)}`;
-	const replacement = `<img src={${identifier}}${altAttr}${styleAttr} />`;
+	const replacement = `<img src={${identifier}} alt=${jsString$1(hint)} style={{ ${styleParts.join(", ")} }} />`;
 	return {
 		importSplice,
-		elementSplice: {
-			from: element.start,
-			to: element.end,
-			text: replacement
-		}
+		elementSplice: spliceRange(element, replacement)
 	};
 }
 function applyEdit(source, line, column, ops) {
@@ -497,7 +660,13 @@ function applyEdit(source, line, column, ops) {
 		ok: true,
 		source
 	};
-	const element = findInnermostJsxElement(source, line, column);
+	const ast = parseSource$1(source);
+	if (!ast) return {
+		ok: false,
+		status: 422,
+		error: "could not parse source"
+	};
+	const element = findInnermostJsxElement(ast, line, column);
 	if (!element) return {
 		ok: false,
 		status: 422,
@@ -519,7 +688,7 @@ function applyEdit(source, line, column, ops) {
 	}
 	for (const op of ops) {
 		if (op.kind !== "set-text") continue;
-		const result = buildTextSplice(element, op.value);
+		const result = buildTextSplice(ast, element, op.value, op.prevText);
 		if ("error" in result) return {
 			ok: false,
 			status: 422,
@@ -530,12 +699,6 @@ function applyEdit(source, line, column, ops) {
 	const assetOps = ops.flatMap((op) => op.kind === "set-attr-asset" ? [op] : []);
 	const placeholderOps = ops.flatMap((op) => op.kind === "replace-placeholder-with-image" ? [op] : []);
 	if (assetOps.length > 0 || placeholderOps.length > 0) {
-		const ast = parseSource$1(source);
-		if (!ast) return {
-			ok: false,
-			status: 422,
-			error: "could not parse source"
-		};
 		const importSplices = [];
 		for (const op of assetOps) {
 			const plan = planAssetAttr(ast, element, op.attr, op.assetPath);
@@ -1703,19 +1866,11 @@ function filesPlugin(opts) {
 //#region src/vite/loc-tags-plugin.ts
 const FORWARDING_COMPONENTS = new Set(["ImagePlaceholder"]);
 function isTaggableJsxName(name) {
-	if (!name || typeof name !== "object") return false;
-	const n = name;
-	if (n.type !== "JSXIdentifier" || typeof n.name !== "string") return false;
-	return /^[a-z]/.test(n.name) || FORWARDING_COMPONENTS.has(n.name);
+	if (!t.isJSXIdentifier(name)) return false;
+	return /^[a-z]/.test(name.name) || FORWARDING_COMPONENTS.has(name.name);
 }
 function alreadyTagged(opening) {
-	const attrs = opening.attributes ?? [];
-	for (const attr of attrs) {
-		if (attr.type !== "JSXAttribute") continue;
-		const name = attr.name;
-		if (name?.type === "JSXIdentifier" && name.name === "data-slide-loc") return true;
-	}
-	return false;
+	return opening.attributes.some((attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === "data-slide-loc");
 }
 function injectLocTags(code) {
 	let ast;
@@ -1730,17 +1885,13 @@ function injectLocTags(code) {
 	}
 	const insertions = [];
 	walkJsx(ast, (node) => {
-		if (node.type !== "JSXElement") return;
+		if (!t.isJSXElement(node) || !node.loc) return;
 		const opening = node.openingElement;
-		if (!opening) return;
 		const name = opening.name;
-		if (!isTaggableJsxName(name)) return;
-		if (alreadyTagged(opening)) return;
-		const loc = node.loc;
-		if (!loc) return;
+		if (!isTaggableJsxName(name) || alreadyTagged(opening)) return;
 		insertions.push({
-			offset: name.end,
-			text: ` data-slide-loc="${loc.start.line}:${loc.start.column}"`
+			offset: name.end ?? 0,
+			text: ` data-slide-loc="${node.loc.start.line}:${node.loc.start.column}"`
 		});
 	});
 	if (insertions.length === 0) return null;
@@ -1953,6 +2104,7 @@ async function createViteConfig(opts) {
 	return {
 		root: APP_ROOT,
 		configFile: false,
+		envDir: userCwd,
 		plugins: [
 			locTagsPlugin({
 				userCwd,