@jbpark/live-editor 3.2.0 → 4.0.0

package/dist/ast-CZwpVrJv.js

@@ -0,0 +1,851 @@
+import { C as unwrap, I as nanoid, K as __toESM, L as require_lib, P as traverse, R as require_lib$1, S as generateCode, V as DATA_ATTR, _ as parseArrayExpression, b as unwrapExpression, c as parseBinding, f as createNodeFromValue, g as isLosslesslyEvaluable, i as STRING_VALUED_TYPES, m as extractObjectProperties, n as extract, p as extractNodeValue, r as nodeToJSX, v as parseValue, w as wrap, x as valueToExpression, z as BINDING_PROP } from "./extract-abHYmNsu.js";
+//#region src/utils/selection.ts
+var import_lib = require_lib$1();
+var import_lib$1 = /* @__PURE__ */ __toESM(require_lib(), 1);
+const removeIndices = (items, indices) => {
+	return items.filter((_, index) => !indices.has(index));
+};
+/**
+* Shifts every selected index up/down by one step as a block, preserving
+* relative order — scattered selections stop moving individually once they
+* hit an unselected neighbor, so the whole group slides together instead of
+* items passing through each other.
+*/
+const moveSelectedIndices = (items, indices, direction) => {
+	const next = [...items];
+	const nextIndices = new Set(indices);
+	const ordered = [...indices].sort((a, b) => direction === "up" ? a - b : b - a);
+	for (const index of ordered) {
+		const target = direction === "up" ? index - 1 : index + 1;
+		if (target < 0 || target >= next.length || nextIndices.has(target)) continue;
+		[next[index], next[target]] = [next[target], next[index]];
+		nextIndices.delete(index);
+		nextIndices.add(target);
+	}
+	return {
+		items: next,
+		indices: nextIndices
+	};
+};
+//#endregion
+//#region src/utils/ast/patch.ts
+const hasOnlyLayoutNewlines = (content) => {
+	let index = 0;
+	while (index < content.length) {
+		const char = content[index];
+		if (char === "`" || char === "<") return false;
+		if (char === "\"" || char === "'") {
+			const next = skipStringLiteral(content, index);
+			if (next === -1) return false;
+			index = next;
+			continue;
+		}
+		if (char === "/") {
+			const following = content[index + 1];
+			if (following === "/") {
+				const lineEnd = content.indexOf("\n", index + 2);
+				index = lineEnd === -1 ? content.length : lineEnd;
+				continue;
+			}
+			if (following === "*") {
+				const commentEnd = content.indexOf("*/", index + 2);
+				if (commentEnd === -1) return false;
+				index = commentEnd + 2;
+				continue;
+			}
+			return false;
+		}
+		index++;
+	}
+	return true;
+};
+const skipStringLiteral = (content, start) => {
+	const quote = content[start];
+	for (let index = start + 1; index < content.length; index++) {
+		const char = content[index];
+		if (char === "\\") {
+			const escaped = content[index + 1];
+			if (escaped === "\n" || escaped === "\r") return -1;
+			index++;
+			continue;
+		}
+		if (char === quote) return index + 1;
+		if (char === "\n") return -1;
+	}
+	return -1;
+};
+const lineIndentAt = (source, offset) => {
+	const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
+	return /^[ \t]*/.exec(source.slice(lineStart, offset))?.[0] ?? "";
+};
+const lineTerminatorOf = (source) => {
+	return source.includes("\r\n") ? "\r\n" : "\n";
+};
+const applyEdits = (source, edits) => {
+	if (edits.length === 0) return source;
+	const ordered = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
+	for (const edit of ordered) if (!Number.isInteger(edit.start) || !Number.isInteger(edit.end) || edit.start < 0 || edit.end > source.length || edit.start > edit.end) throw new Error(`Invalid source edit [${edit.start}, ${edit.end}) for a source of length ${source.length}`);
+	for (let i = 1; i < ordered.length; i++) {
+		const previous = ordered[i - 1];
+		const current = ordered[i];
+		if (current.start < previous.end) throw new Error(`Overlapping source edits: [${previous.start}, ${previous.end}) and [${current.start}, ${current.end})`);
+	}
+	let result = "";
+	let cursor = 0;
+	const terminator = lineTerminatorOf(source);
+	for (const edit of ordered) {
+		const content = edit.indent && edit.content.includes("\n") && hasOnlyLayoutNewlines(edit.content) ? edit.content.replace(/\n/g, `${terminator}${lineIndentAt(source, edit.start)}`) : edit.content;
+		result += source.slice(cursor, edit.start) + content;
+		cursor = edit.end;
+	}
+	return result + source.slice(cursor);
+};
+//#endregion
+//#region src/utils/ast/array-source.ts
+const commaIn = (source, start, end) => {
+	let comma = null;
+	for (let at = start; at < end; at++) {
+		if (/\s/.test(source[at])) continue;
+		if (source.startsWith("/*", at)) {
+			const close = source.indexOf("*/", at + 2);
+			if (close < 0 || close + 2 > end) return null;
+			at = close + 1;
+		} else if (source.startsWith("//", at)) {
+			const newline = source.indexOf("\n", at + 2);
+			at = newline < 0 ? end : newline;
+		} else if (source[at] === "," && comma === null) comma = at;
+		else return null;
+	}
+	return comma;
+};
+const denseArraySource = (source) => {
+	const array = parseArrayExpression(source);
+	if (!array || array.elements.some((node) => !import_lib$1.isExpression(node) || node.extra?.parenthesized)) return null;
+	const elements = array.elements;
+	const commas = elements.slice(0, -1).map((node, index) => commaIn(source, node.end, elements[index + 1].start));
+	if (commas.some((comma) => comma === null)) return null;
+	const last = elements.at(-1);
+	return {
+		array,
+		elements,
+		commas,
+		trailing: last ? commaIn(source, last.end, array.end - 1) : null
+	};
+};
+const canStructurallyEditArray = (source) => denseArraySource(source) !== null;
+const validArrayIndices = (indices, length) => [...indices].every((index) => Number.isInteger(index) && index >= 0 && index < length);
+const reorderArraySource = (source, elements, next) => applyEdits(source, elements.map((node, index) => ({
+	start: node.start,
+	end: node.end,
+	content: source.slice(next[index].start, next[index].end)
+})));
+const removeArraySource = (source, data, indices) => {
+	const edits = [];
+	const removedCommas = /* @__PURE__ */ new Set();
+	const { elements, commas, trailing } = data;
+	for (let index = 0; index < elements.length; index++) {
+		if (!indices.has(index)) continue;
+		const start = index;
+		while (index + 1 < elements.length && indices.has(index + 1)) index++;
+		for (let current = start; current <= index; current++) {
+			const node = elements[current];
+			edits.push({
+				start: node.start,
+				end: node.end,
+				content: ""
+			});
+			if (current < elements.length - 1) removedCommas.add(commas[current]);
+		}
+		if (index === elements.length - 1) {
+			if (trailing !== null) removedCommas.add(trailing);
+			else if (start > 0) removedCommas.add(commas[start - 1]);
+		}
+	}
+	for (const comma of removedCommas) edits.push({
+		start: comma,
+		end: comma + 1,
+		content: ""
+	});
+	return applyEdits(source, edits);
+};
+const appendArraySource = (source, data, copies) => {
+	const last = data.elements.at(-1);
+	if (!last || copies.length === 0) return source;
+	return applyEdits(source, [{
+		start: last.end,
+		end: last.end,
+		content: `, ${copies.join(", ")}`
+	}]);
+};
+//#endregion
+//#region src/utils/ast/items.ts
+const elementsOf = (code) => parseArrayExpression(code)?.elements ?? null;
+const kindOf = (element) => import_lib$1.isObjectExpression(element) ? "object" : "primitive";
+const parseItems = (code) => {
+	return elementsOf(code)?.flatMap((node, index) => import_lib$1.isExpression(node) ? [{
+		index,
+		kind: kindOf(node),
+		node
+	}] : []) ?? null;
+};
+const resolveRenderLeaf = (render, key) => {
+	const leaf = render?.[key];
+	return leaf && "type" in leaf ? leaf : null;
+};
+const toTemplateRaw = (value) => {
+	return value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${").replace(/\r/g, "\\r");
+};
+const buildPropertyValue = (value, declaredType, renderLeaf, current) => {
+	if (renderLeaf?.property === BINDING_PROP.INNER_HTML) {
+		const raw = String(value);
+		return import_lib$1.templateLiteral([import_lib$1.templateElement({
+			raw: toTemplateRaw(raw),
+			cooked: raw
+		}, true)], []);
+	}
+	if (renderLeaf?.type === "jsx" || import_lib$1.isJSXElement(current) || import_lib$1.isJSXFragment(current)) {
+		const trimmed = String(value).trim();
+		if (!trimmed.startsWith("<")) return import_lib$1.stringLiteral(trimmed);
+		try {
+			return (0, import_lib.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+		} catch {
+			return;
+		}
+	}
+	if (declaredType === "array" || declaredType === "object") {
+		if (typeof value === "string") try {
+			return (0, import_lib.parseExpression)(value, { plugins: ["jsx", "typescript"] });
+		} catch {
+			return;
+		}
+		if (!isLosslesslyEvaluable(current)) return;
+		return valueToExpression(value) ?? void 0;
+	}
+	return createNodeFromValue(declaredType, parseValue(value)) ?? void 0;
+};
+const updateArrayItemProperty = (code, index, key, value, render) => {
+	const elements = elementsOf(code);
+	const element = elements?.[index];
+	if (!elements || !import_lib$1.isObjectExpression(element)) return null;
+	const target = element.properties.find((property) => import_lib$1.isObjectProperty(property) && import_lib$1.isIdentifier(property.key) && property.key.name === key);
+	if (!target) return null;
+	const declaredType = extractObjectProperties(element)[key]?.type ?? "string";
+	const nextValue = buildPropertyValue(value, declaredType, resolveRenderLeaf(render, key), target.value);
+	if (!nextValue) return null;
+	let serialized = typeof value === "string" && (declaredType === "array" || declaredType === "object" || import_lib$1.isJSXElement(nextValue) || import_lib$1.isJSXFragment(nextValue)) ? value.trim() : generateCode(nextValue);
+	if (nextValue.trailingComments?.some((comment) => comment.type === "CommentLine")) serialized += "\n";
+	const content = target.shorthand ? `${key}: ${serialized}` : serialized;
+	return applyEdits(code, [{
+		start: target.value.start,
+		end: target.value.end,
+		content
+	}]);
+};
+const updateArrayItemValue = (code, index, value) => {
+	const elements = elementsOf(code);
+	const element = elements?.[index];
+	if (!elements || !import_lib$1.isExpression(element)) return null;
+	const nextValue = createNodeFromValue(extractNodeValue(element).type, parseValue(value));
+	if (!nextValue) return null;
+	return applyEdits(code, [{
+		start: element.start,
+		end: element.end,
+		content: generateCode(nextValue)
+	}]);
+};
+const moveArrayItem = (code, from, to) => {
+	const data = denseArraySource(code);
+	if (!data || !validArrayIndices([from], data.elements.length) || !Number.isInteger(to)) return null;
+	const next = [...data.elements];
+	const [moved] = next.splice(from, 1);
+	next.splice(to, 0, moved);
+	return reorderArraySource(code, data.elements, next);
+};
+const moveArrayItems = (code, indices, direction) => {
+	const data = denseArraySource(code);
+	if (!data || !validArrayIndices(indices, data.elements.length) || !["up", "down"].includes(direction)) return null;
+	const next = moveSelectedIndices(data.elements, indices, direction);
+	return {
+		code: reorderArraySource(code, data.elements, next.items),
+		indices: next.indices
+	};
+};
+const removeArrayItems = (code, indices, kind) => {
+	const data = denseArraySource(code);
+	if (!data || !validArrayIndices(indices, data.elements.length)) return null;
+	const remaining = removeIndices(data.elements, indices);
+	if (!(kind === void 0 ? remaining : remaining.filter((node) => kindOf(node) === kind)).length) return null;
+	return removeArraySource(code, data, indices);
+};
+const copyItem = (code, element, generateId, usedIds) => {
+	const edits = [];
+	let unsupported = false;
+	const reserveId = (id) => {
+		if (usedIds.has(id)) unsupported = true;
+		usedIds.add(id);
+		return JSON.stringify(id);
+	};
+	import_lib$1.traverseFast(element, (node) => {
+		if (!import_lib$1.isJSXOpeningElement(node)) return;
+		const ids = node.attributes.filter((attr) => import_lib$1.isJSXAttribute(attr) && import_lib$1.isJSXIdentifier(attr.name, { name: "data-id" }));
+		const attr = ids[0];
+		if (ids.length > 1 || attr && (!import_lib$1.isStringLiteral(attr.value) || node.attributes.slice(node.attributes.indexOf(attr) + 1).some((a) => import_lib$1.isJSXSpreadAttribute(a)))) {
+			unsupported = true;
+			return;
+		}
+		if (attr && import_lib$1.isStringLiteral(attr.value)) edits.push({
+			start: attr.value.start,
+			end: attr.value.end,
+			content: reserveId(generateId())
+		});
+	});
+	if (import_lib$1.isObjectExpression(element)) {
+		const keys = element.properties.filter((prop) => import_lib$1.isObjectProperty(prop) && !prop.computed && (import_lib$1.isIdentifier(prop.key, { name: "key" }) || import_lib$1.isStringLiteral(prop.key, { value: "key" })));
+		const key = keys[0];
+		if (keys.length > 1 || key && (!import_lib$1.isStringLiteral(key.value) || element.properties.slice(element.properties.indexOf(key) + 1).some((prop) => import_lib$1.isSpreadElement(prop) || "computed" in prop && prop.computed))) return null;
+		if (key && import_lib$1.isStringLiteral(key.value)) edits.push({
+			start: key.value.start,
+			end: key.value.end,
+			content: reserveId(`${key.value.value}-${generateId()}`)
+		});
+	}
+	if (unsupported) return null;
+	return applyEdits(code.slice(element.start, element.end), edits.map((edit) => ({
+		...edit,
+		start: edit.start - element.start,
+		end: edit.end - element.start
+	})));
+};
+const duplicateArrayItems = (code, indices, generateId = () => nanoid(6)) => {
+	const data = denseArraySource(code);
+	if (!data || !indices.size || !validArrayIndices(indices, data.elements.length)) return null;
+	const usedIds = /* @__PURE__ */ new Set();
+	import_lib$1.traverseFast(data.array, (node) => {
+		if (import_lib$1.isJSXAttribute(node) && import_lib$1.isJSXIdentifier(node.name, { name: "data-id" }) && import_lib$1.isStringLiteral(node.value)) usedIds.add(node.value.value);
+		else if (import_lib$1.isObjectProperty(node) && !node.computed && (import_lib$1.isIdentifier(node.key, { name: "key" }) || import_lib$1.isStringLiteral(node.key, { value: "key" })) && import_lib$1.isStringLiteral(node.value)) usedIds.add(node.value.value);
+	});
+	const copies = [...indices].sort((a, b) => a - b).map((index) => copyItem(code, data.elements[index], generateId, usedIds));
+	return copies.every((copy) => copy !== null) ? appendArraySource(code, data, copies) : null;
+};
+const appendArrayItem = (code, kind, generateId = () => nanoid(6)) => {
+	const index = denseArraySource(code)?.elements.findIndex((node) => kindOf(node) === kind) ?? -1;
+	return index < 0 ? null : duplicateArrayItems(code, /* @__PURE__ */ new Set([index]), generateId);
+};
+//#endregion
+//#region src/utils/ast/children.ts
+const modeledSignatures = (nodes) => nodes.map((node) => {
+	const jsx = nodeToJSX(node);
+	if (!jsx) throw new Error("Invalid child node");
+	return generateCode(jsx);
+});
+const getChildrenSignatures = (nodes) => {
+	const modeled = modeledSignatures(nodes);
+	return nodes.map((node, index) => JSON.stringify([node.source ?? null, modeled[index]]));
+};
+const indicesAreValid = (indices, count) => Array.isArray(indices) && new Set(indices).size === indices.length && indices.every((index) => Number.isInteger(index) && index >= 0 && index < count);
+const copySource = (source, usedIds) => {
+	const node = (0, import_lib.parseExpression)(source, { plugins: ["jsx", "typescript"] });
+	const edits = [];
+	const newId = () => {
+		let id = nanoid(12);
+		while (usedIds.has(id)) id = nanoid(12);
+		usedIds.add(id);
+		return id;
+	};
+	import_lib$1.traverseFast(node, (child) => {
+		if (!import_lib$1.isJSXOpeningElement(child)) return;
+		const ids = child.attributes.filter((attr) => import_lib$1.isJSXAttribute(attr) && import_lib$1.isJSXIdentifier(attr.name, { name: "data-id" }));
+		if (ids.length > 1) throw new Error("Duplicate data-id attributes");
+		const attr = ids[0];
+		if (attr && child.attributes.slice(child.attributes.indexOf(attr) + 1).some((attribute) => import_lib$1.isJSXSpreadAttribute(attribute))) throw new Error("A spread may override the copied data-id");
+		if (attr) {
+			const value = attr.value;
+			if (!import_lib$1.isStringLiteral(value) || value.start == null || value.end == null) throw new Error("Cannot copy a dynamic data-id");
+			edits.push({
+				start: value.start,
+				end: value.end,
+				content: JSON.stringify(newId())
+			});
+		} else {
+			const at = child.attributes.at(-1)?.end ?? child.name.end;
+			if (at == null) throw new Error("Missing opening element span");
+			edits.push({
+				start: at,
+				end: at,
+				content: ` data-id="${newId()}"`
+			});
+		}
+	});
+	return applyEdits(source, edits);
+};
+const editChildrenSource = (source, parent, input) => {
+	try {
+		if (!parent.closingElement || parent.start == null || parent.end == null) return null;
+		const value = typeof input === "string" ? JSON.parse(input) : input;
+		const children = parent.children.filter((child) => import_lib$1.isJSXElement(child) || import_lib$1.isJSXFragment(child));
+		const raw = children.map((child) => source.slice(child.start, child.end));
+		const models = extract(source.slice(parent.start, parent.end))[0]?.children ?? [];
+		if (models.length !== children.length) return null;
+		const signatures = modeledSignatures(models);
+		const replaceSlots = (next) => {
+			const edits = children.map((child, index) => ({
+				start: child.start,
+				end: child.end,
+				content: next[index] ?? ""
+			}));
+			if (next.length > children.length) {
+				const at = parent.closingElement.start;
+				edits.push({
+					start: at,
+					end: at,
+					content: next.slice(children.length).join("")
+				});
+			}
+			return edits;
+		};
+		if (Array.isArray(value)) {
+			const desired = modeledSignatures(value);
+			const lossless = raw.every((text, index) => generateCode((0, import_lib.parseExpression)(text, { plugins: ["jsx", "typescript"] })) === signatures[index]);
+			const consumed = /* @__PURE__ */ new Set();
+			const next = desired.map((signature, position) => {
+				const index = signatures.findIndex((candidate, i) => candidate === signature && !consumed.has(i) && (value[position].source === void 0 || value[position].source === raw[i]));
+				if (index >= 0) {
+					consumed.add(index);
+					return raw[index];
+				}
+				if (!lossless || value[position].source !== void 0 && !raw.includes(value[position].source)) throw new Error("Use children commands to copy or edit unsupported source");
+				return signature;
+			});
+			const countIds = (text) => {
+				const counts = /* @__PURE__ */ new Map();
+				import_lib$1.traverseFast((0, import_lib.parseExpression)(text, { plugins: ["jsx", "typescript"] }), (node) => {
+					if (import_lib$1.isJSXAttribute(node) && import_lib$1.isJSXIdentifier(node.name, { name: "data-id" }) && import_lib$1.isStringLiteral(node.value)) counts.set(node.value.value, (counts.get(node.value.value) ?? 0) + 1);
+				});
+				return counts;
+			};
+			const previousIds = countIds(source);
+			if ([...countIds(applyEdits(source, replaceSlots(next)))].some(([id, count]) => count > 1 && count > (previousIds.get(id) ?? 0))) return null;
+			return replaceSlots(next);
+		}
+		const request = value;
+		if (request?.kind !== "children-edit" || !Array.isArray(request.expected) || request.expected.length !== signatures.length || !getChildrenSignatures(models).every((signature, index) => signature === request.expected[index]) || !request.action) return null;
+		const { action } = request;
+		const usedIds = /* @__PURE__ */ new Set();
+		import_lib$1.traverseFast(parent, (node) => {
+			if (import_lib$1.isJSXAttribute(node) && import_lib$1.isJSXIdentifier(node.name, { name: "data-id" }) && import_lib$1.isStringLiteral(node.value)) usedIds.add(node.value.value);
+		});
+		switch (action.type) {
+			case "move": {
+				if (!indicesAreValid([action.from], raw.length) || !indicesAreValid([action.to], raw.length)) return null;
+				const next = [...raw];
+				const [moved] = next.splice(action.from, 1);
+				next.splice(action.to, 0, moved);
+				return replaceSlots(next);
+			}
+			case "move-selected":
+				if (!indicesAreValid(action.indices, raw.length) || !["up", "down"].includes(action.direction)) return null;
+				return replaceSlots(moveSelectedIndices(raw, new Set(action.indices), action.direction).items);
+			case "remove":
+				if (!indicesAreValid(action.indices, raw.length)) return null;
+				return action.indices.map((index) => ({
+					start: children[index].start,
+					end: children[index].end,
+					content: ""
+				}));
+			case "duplicate": {
+				if (!indicesAreValid(action.indices, raw.length)) return null;
+				const content = [...action.indices].sort((a, b) => a - b).map((index) => copySource(raw[index], usedIds)).join("");
+				const at = parent.closingElement.start;
+				return [{
+					start: at,
+					end: at,
+					content
+				}];
+			}
+			case "append": {
+				const content = copySource(raw[0] ?? "<div></div>", usedIds);
+				const at = parent.closingElement.start;
+				return [{
+					start: at,
+					end: at,
+					content
+				}];
+			}
+			default: return null;
+		}
+	} catch {
+		return null;
+	}
+};
+//#endregion
+//#region src/utils/ast/update.ts
+const childrenRange = (element) => {
+	const { openingElement, closingElement } = element;
+	if (!closingElement || openingElement.end == null || closingElement.start == null) return null;
+	return {
+		start: openingElement.end,
+		end: closingElement.start
+	};
+};
+const findAttribute = (opening, propertyName) => {
+	return opening.attributes.find((attr) => import_lib$1.isJSXAttribute(attr) && import_lib$1.isJSXIdentifier(attr.name) && attr.name.name === propertyName);
+};
+const attributeInsertPoint = (opening) => {
+	return opening.attributes[opening.attributes.length - 1]?.end ?? opening.name.end ?? null;
+};
+const editInnerText = (source, element, value) => {
+	const range = childrenRange(element);
+	if (!range) return [];
+	const [only] = element.children;
+	if (element.children.length === 1 && import_lib$1.isJSXText(only) && only.start != null && only.end != null) {
+		const raw = source.slice(only.start, only.end);
+		if (raw.trim() !== "") {
+			const leading = raw.length - raw.trimStart().length;
+			const trailing = raw.length - raw.trimEnd().length;
+			return [{
+				start: only.start + leading,
+				end: only.end - trailing,
+				content: value
+			}];
+		}
+	}
+	const edits = [];
+	for (const child of element.children) if (import_lib$1.isJSXText(child) && child.start != null && child.end != null) edits.push({
+		start: child.start,
+		end: child.end,
+		content: ""
+	});
+	edits.push({
+		start: range.end,
+		end: range.end,
+		content: value
+	});
+	return edits;
+};
+const editInnerHTML = (element, value) => {
+	const range = childrenRange(element);
+	if (!range) return [];
+	return [{
+		start: range.start,
+		end: range.end,
+		content: value
+	}];
+};
+const editRichtext = (element, value) => {
+	const edits = [];
+	const range = childrenRange(element);
+	if (range && range.start !== range.end) edits.push({
+		start: range.start,
+		end: range.end,
+		content: ""
+	});
+	const opening = element.openingElement;
+	const attribute = import_lib$1.jsxAttribute(import_lib$1.jsxIdentifier("dangerouslySetInnerHTML"), import_lib$1.jsxExpressionContainer(import_lib$1.objectExpression([import_lib$1.objectProperty(import_lib$1.identifier("__html"), import_lib$1.stringLiteral(value))])));
+	const content = generateCode(attribute);
+	const existing = findAttribute(opening, "dangerouslySetInnerHTML");
+	if (existing && existing.start != null && existing.end != null) {
+		edits.push({
+			start: existing.start,
+			end: existing.end,
+			content,
+			indent: true
+		});
+		return edits;
+	}
+	const insertAt = attributeInsertPoint(opening);
+	if (insertAt == null) return null;
+	edits.push({
+		start: insertAt,
+		end: insertAt,
+		content: ` ${content}`,
+		indent: true
+	});
+	return edits;
+};
+const editJsxAttribute = (opening, propertyName, value) => {
+	const attribute = findAttribute(opening, propertyName);
+	if (!attribute) return null;
+	const content = `{${String(value).trim()}}`;
+	if (attribute.value?.start != null && attribute.value.end != null) return [{
+		start: attribute.value.start,
+		end: attribute.value.end,
+		content
+	}];
+	const insertAt = attribute.name.end;
+	if (insertAt == null) return null;
+	return [{
+		start: insertAt,
+		end: insertAt,
+		content: `=${content}`
+	}];
+};
+const holdsStructuralExpression = (value) => import_lib$1.isJSXExpressionContainer(value) && (import_lib$1.isArrayExpression(unwrapExpression(value.expression)) || import_lib$1.isObjectExpression(unwrapExpression(value.expression)));
+const structuralSource = (value) => {
+	try {
+		const expression = (0, import_lib.parseExpression)(value.trim(), { plugins: ["jsx", "typescript"] });
+		return import_lib$1.isArrayExpression(unwrapExpression(expression)) || import_lib$1.isObjectExpression(unwrapExpression(expression)) ? expression : null;
+	} catch {
+		return null;
+	}
+};
+const buildAttributeValue = (value, type, current) => {
+	if (type === "array" || type === "object") {
+		if (typeof value === "string") try {
+			return import_lib$1.jsxExpressionContainer((0, import_lib.parseExpression)(value.trim(), { plugins: ["jsx", "typescript"] }));
+		} catch {
+			return import_lib$1.stringLiteral(value);
+		}
+		const expr = valueToExpression(value);
+		return expr ? import_lib$1.jsxExpressionContainer(expr) : import_lib$1.stringLiteral("");
+	}
+	if (typeof value === "string") {
+		if (holdsStructuralExpression(current) && !(type && STRING_VALUED_TYPES.has(type))) {
+			const structural = structuralSource(value);
+			if (structural) return import_lib$1.jsxExpressionContainer(structural);
+		}
+		return import_lib$1.stringLiteral(value);
+	}
+	const expr = valueToExpression(value);
+	return expr ? import_lib$1.jsxExpressionContainer(expr) : import_lib$1.stringLiteral(String(value));
+};
+const editAttribute = (opening, propertyName, value, type) => {
+	const attribute = findAttribute(opening, propertyName);
+	if (!attribute || attribute.start == null || attribute.end == null) return null;
+	if (typeof value === "string" && (type === "array" || type === "object" || holdsStructuralExpression(attribute.value) && !(type && STRING_VALUED_TYPES.has(type)))) {
+		const expression = structuralSource(value);
+		if (expression && import_lib$1.isJSXExpressionContainer(attribute.value)) {
+			const text = value.trim();
+			const lineComment = expression.trailingComments?.some((comment) => comment.type === "CommentLine");
+			return [{
+				start: attribute.value.expression.start,
+				end: attribute.value.expression.end,
+				content: `${text}${lineComment ? "\n" : ""}`
+			}];
+		}
+	}
+	const content = generateCode(import_lib$1.jsxAttribute(attribute.name, buildAttributeValue(value, type, attribute.value)));
+	return [{
+		start: attribute.start,
+		end: attribute.end,
+		content,
+		indent: true
+	}];
+};
+const canEditAttributeValue = (attribute, value, type) => {
+	if (!import_lib$1.isJSXExpressionContainer(attribute.value) || import_lib$1.isJSXEmptyExpression(attribute.value.expression) || isLosslesslyEvaluable(attribute.value.expression)) return true;
+	return typeof value === "string" && holdsStructuralExpression(attribute.value) && !(type && STRING_VALUED_TYPES.has(type)) && structuralSource(value) !== null;
+};
+const update = (code, dataId, label, value, property) => {
+	try {
+		const wrapped = wrap(code);
+		const ast = (0, import_lib.parse)(wrapped, {
+			sourceType: "module",
+			plugins: ["jsx", "typescript"]
+		});
+		let changed = false;
+		let failure;
+		const edits = [];
+		const collect = (result, onNull) => {
+			if (!result) {
+				failure = onNull();
+				return;
+			}
+			edits.push(...result);
+			changed = true;
+		};
+		traverse(ast, { JSXElement(path) {
+			const opening = path.node.openingElement;
+			if (!opening.attributes.find((attr) => {
+				return import_lib$1.isJSXAttribute(attr) && import_lib$1.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.ID && attr.value && import_lib$1.isStringLiteral(attr.value) && attr.value.value === dataId;
+			})) return;
+			const bindingAttr = opening.attributes.find((attr) => import_lib$1.isJSXAttribute(attr) && import_lib$1.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.BINDING);
+			if (!bindingAttr?.value) {
+				failure = {
+					reason: "no-binding",
+					dataId
+				};
+				return;
+			}
+			let bindingValue = "";
+			if (import_lib$1.isStringLiteral(bindingAttr.value)) bindingValue = bindingAttr.value.value;
+			else if (import_lib$1.isJSXExpressionContainer(bindingAttr.value)) try {
+				bindingValue = generateCode(bindingAttr.value.expression);
+			} catch (error) {
+				failure = {
+					reason: "parse-error",
+					error
+				};
+				return;
+			}
+			const matches = parseBinding(bindingValue).filter((binding) => property !== void 0 ? binding.property === property : binding.label === label);
+			if (matches.length === 0) {
+				failure = {
+					reason: "binding-not-declared",
+					dataId,
+					label,
+					property
+				};
+				return;
+			}
+			if (matches.length > 1) {
+				failure = {
+					reason: "duplicate-binding",
+					dataId,
+					label,
+					property,
+					count: matches.length
+				};
+				return;
+			}
+			const propertyBinding = matches[0];
+			const prop = propertyBinding.property;
+			switch (prop) {
+				case BINDING_PROP.INNER_TEXT:
+					collect(editInnerText(wrapped, path.node, String(value)), () => ({
+						reason: "parse-error",
+						error: /* @__PURE__ */ new Error(`could not update "${prop}"`)
+					}));
+					break;
+				case BINDING_PROP.INNER_HTML:
+					collect(propertyBinding.type === "richtext" ? editRichtext(path.node, String(value)) : editInnerHTML(path.node, String(value)), () => ({
+						reason: "parse-error",
+						error: /* @__PURE__ */ new Error(`could not update "${prop}"`)
+					}));
+					break;
+				case BINDING_PROP.CHILDREN:
+					collect(editChildrenSource(wrapped, path.node, value), () => ({
+						reason: "parse-error",
+						error: /* @__PURE__ */ new Error("Unsupported or stale children edit; source was preserved")
+					}));
+					break;
+				default: {
+					const attribute = findAttribute(opening, prop);
+					if (attribute && propertyBinding.type !== "jsx" && !canEditAttributeValue(attribute, value, propertyBinding.type)) {
+						failure = {
+							reason: "unsupported-syntax",
+							dataId,
+							property: prop
+						};
+						break;
+					}
+					collect(propertyBinding.type === "jsx" ? editJsxAttribute(opening, prop, value) : editAttribute(opening, prop, value, propertyBinding.type), () => ({
+						reason: "attribute-not-found",
+						dataId,
+						property: prop
+					}));
+					break;
+				}
+			}
+		} });
+		if (!changed) return {
+			code,
+			success: false,
+			failure: failure ?? {
+				reason: "element-not-found",
+				dataId
+			}
+		};
+		return {
+			code: unwrap(applyEdits(wrapped, edits)),
+			success: true
+		};
+	} catch (error) {
+		console.error("❌ Code update error:", error);
+		return {
+			code,
+			success: false,
+			failure: {
+				reason: "parse-error",
+				error
+			}
+		};
+	}
+};
+const bulkUpdate = (raw, entries) => {
+	let current = raw;
+	const failures = [];
+	for (const entry of entries) {
+		const result = update(current, entry.dataId, entry.label, entry.value, entry.property);
+		current = result.code;
+		if (!result.success && result.failure) failures.push(result.failure);
+	}
+	return failures.length > 0 ? {
+		code: current,
+		success: false,
+		failures
+	} : {
+		code: current,
+		success: true
+	};
+};
+//#endregion
+//#region src/utils/ast/tree.ts
+const replaceIds = (code, generateId = () => nanoid(6)) => {
+	return code.replace(new RegExp(`${DATA_ATTR.ID}="[^"]*"`, "g"), () => {
+		return `${DATA_ATTR.ID}="${generateId()}"`;
+	});
+};
+const fillIds = (code, generateId = () => nanoid(6)) => {
+	return code.replace(new RegExp(`${DATA_ATTR.ID}=""`, "g"), () => {
+		return `${DATA_ATTR.ID}="${generateId()}"`;
+	});
+};
+const clone = (element, generateId = () => nanoid(6)) => {
+	const cloned = import_lib$1.cloneNode(element, true);
+	const generatedCode = generateCode(cloned);
+	const code = replaceIds(generatedCode, generateId);
+	return (0, import_lib.parseExpression)(code, { plugins: ["jsx", "typescript"] });
+};
+//#endregion
+//#region src/utils/ast/validate.ts
+const VALID = { valid: true };
+const validateBindingValue = (binding, value) => {
+	if (value === "" || value === null || value === void 0) {
+		if (binding.required) return {
+			valid: false,
+			message: "This field is required."
+		};
+		return VALID;
+	}
+	if (typeof value === "number") {
+		if (binding.min !== void 0 && value < binding.min) return {
+			valid: false,
+			message: `Must be at least ${binding.min}.`
+		};
+		if (binding.max !== void 0 && value > binding.max) return {
+			valid: false,
+			message: `Must be at most ${binding.max}.`
+		};
+	}
+	if (typeof value === "string" && binding.pattern) {
+		let regex;
+		try {
+			regex = new RegExp(binding.pattern);
+		} catch {
+			return VALID;
+		}
+		if (!regex.test(value)) return {
+			valid: false,
+			message: "Value does not match the required format."
+		};
+	}
+	if (typeof value === "string" && binding.type === "url") try {
+		new URL(value);
+	} catch {
+		return {
+			valid: false,
+			message: "Must be a valid URL."
+		};
+	}
+	if (typeof value === "string" && binding.type === "date") {
+		if (Number.isNaN(Date.parse(value))) return {
+			valid: false,
+			message: "Must be a valid date."
+		};
+	}
+	return VALID;
+};
+//#endregion
+export { moveSelectedIndices as _, bulkUpdate as a, appendArrayItem as c, moveArrayItems as d, parseItems as f, canStructurallyEditArray as g, updateArrayItemValue as h, replaceIds as i, duplicateArrayItems as l, updateArrayItemProperty as m, clone as n, update as o, removeArrayItems as p, fillIds as r, getChildrenSignatures as s, validateBindingValue as t, moveArrayItem as u };
+
+//# sourceMappingURL=ast-CZwpVrJv.js.map