@jbpark/live-editor 4.1.1 → 4.3.0

package/dist/{ast-jab6hQrT.js → ast-BFbDWO-l.js}

@@ -1,11 +1,11 @@
-import { d as nanoid, f as require_lib, h as __toESM, m as require_lib$1, p as require_lib$2, u as traverse } from "./document-C5Dypv4_.js";
-import { n as CONFIG, o as REGEX, r as DATA_ATTR, t as BINDING_PROP } from "./constants-BD3FZKWE.js";
+import { C as require_lib, S as require_lib$1, _ as nanoid, b as unwrap, d as traverse, g as getJSXTagName, v as attrValue, w as __toESM, x as wrap, y as generateCode } from "./document-cEEdFERz.js";
+import { c as RESERVED_BINDING_PROPERTIES, n as CONFIG, r as DATA_ATTR, s as REGEX, t as BINDING_PROP } from "./constants-CKvdqZtO.js";
 import { n as registerEditorCache } from "./editor-caches-ClMvdcQF.js";
 import { t as createBoundedCache } from "./cache-B0-XcIxJ.js";
 import { z } from "zod";
 //#region src/utils/ast/types.ts
-var import_lib$1 = require_lib$1();
-var import_lib$2 = /* @__PURE__ */ __toESM(require_lib$2(), 1);
+var import_lib = require_lib();
+var import_lib$1 = /* @__PURE__ */ __toESM(require_lib$1(), 1);
 const BINDING_TYPES = [
 	"array",
 	"object",
@@ -19,35 +19,6 @@ const BINDING_TYPES = [
 	"url"
 ];
 //#endregion
-//#region src/utils/ast/helpers.ts
-var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
-const generate = typeof import_lib.default === "function" ? import_lib.default : import_lib.default.default;
-const wrap = (code) => {
-	return `<>${code}</>`;
-};
-const unwrap = (generated) => {
-	return generated.replace(/^<>\s*/g, "").replace(/\s*<\/>\s*;?\s*$/g, "").trim();
-};
-const attrValue = ({ value, isStringLiteral }) => {
-	if (value === null) return null;
-	if (isStringLiteral) return import_lib$2.stringLiteral(value);
-	const trimmed = value.trim();
-	if (REGEX.NUMBER.test(trimmed)) return import_lib$2.jsxExpressionContainer(import_lib$2.numericLiteral(parseFloat(trimmed)));
-	if (REGEX.BOOLEAN_OR_NULL.test(trimmed)) {
-		const expr = (0, import_lib$1.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
-		return import_lib$2.jsxExpressionContainer(expr);
-	}
-	try {
-		const expr = (0, import_lib$1.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
-		return import_lib$2.jsxExpressionContainer(expr);
-	} catch {
-		return import_lib$2.stringLiteral(trimmed);
-	}
-};
-const generateCode = (node) => {
-	return generate(node, { jsescOption: { minimal: true } }).code;
-};
-//#endregion
 //#region src/utils/ast/value.ts
 const dedent = (str) => {
 	const lines = str.replace(/^\n/, "").replace(/\n\s*$/, "").split("\n");
@@ -60,44 +31,44 @@ const dedent = (str) => {
 };
 const unwrapExpression = (node) => {
 	let current = node;
-	while (import_lib$2.isTSAsExpression(current) || import_lib$2.isTSSatisfiesExpression(current) || import_lib$2.isTSNonNullExpression(current) || import_lib$2.isTSTypeAssertion(current) || import_lib$2.isParenthesizedExpression(current)) current = current.expression;
+	while (import_lib$1.isTSAsExpression(current) || import_lib$1.isTSSatisfiesExpression(current) || import_lib$1.isTSNonNullExpression(current) || import_lib$1.isTSTypeAssertion(current) || import_lib$1.isParenthesizedExpression(current)) current = current.expression;
 	return current;
 };
 const isLosslesslyEvaluable = (node) => {
 	const value = unwrapExpression(node);
-	if (import_lib$2.isStringLiteral(value) || import_lib$2.isNumericLiteral(value) || import_lib$2.isBooleanLiteral(value) || import_lib$2.isNullLiteral(value)) return true;
-	if (import_lib$2.isUnaryExpression(value) && value.operator === "-" && import_lib$2.isNumericLiteral(value.argument)) return true;
-	if (import_lib$2.isTemplateLiteral(value)) return value.expressions.length === 0;
-	if (import_lib$2.isArrayExpression(value)) return value.elements.every((element) => element !== null && isLosslesslyEvaluable(element));
-	if (import_lib$2.isObjectExpression(value)) return value.properties.every((property) => import_lib$2.isObjectProperty(property) && !property.computed && (import_lib$2.isIdentifier(property.key) || import_lib$2.isStringLiteral(property.key) || import_lib$2.isNumericLiteral(property.key)) && isLosslesslyEvaluable(property.value));
+	if (import_lib$1.isStringLiteral(value) || import_lib$1.isNumericLiteral(value) || import_lib$1.isBooleanLiteral(value) || import_lib$1.isNullLiteral(value)) return true;
+	if (import_lib$1.isUnaryExpression(value) && value.operator === "-" && import_lib$1.isNumericLiteral(value.argument)) return true;
+	if (import_lib$1.isTemplateLiteral(value)) return value.expressions.length === 0;
+	if (import_lib$1.isArrayExpression(value)) return value.elements.every((element) => element !== null && isLosslesslyEvaluable(element));
+	if (import_lib$1.isObjectExpression(value)) return value.properties.every((property) => import_lib$1.isObjectProperty(property) && !property.computed && (import_lib$1.isIdentifier(property.key) || import_lib$1.isStringLiteral(property.key) || import_lib$1.isNumericLiteral(property.key)) && isLosslesslyEvaluable(property.value));
 	return false;
 };
 const canLosslesslyEvaluateSource = (source) => {
 	try {
-		return isLosslesslyEvaluable((0, import_lib$1.parseExpression)(source, { plugins: ["jsx", "typescript"] }));
+		return isLosslesslyEvaluable((0, import_lib.parseExpression)(source, { plugins: ["jsx", "typescript"] }));
 	} catch {
 		return false;
 	}
 };
 const evaluateLiteral = (rawNode) => {
 	const node = unwrapExpression(rawNode);
-	if (import_lib$2.isStringLiteral(node)) return node.value;
-	if (import_lib$2.isNumericLiteral(node)) return node.value;
-	if (import_lib$2.isBooleanLiteral(node)) return node.value;
-	if (import_lib$2.isNullLiteral(node)) return null;
-	if (import_lib$2.isIdentifier(node) && node.name === "undefined") return;
-	if (import_lib$2.isUnaryExpression(node) && node.operator === "-" && import_lib$2.isNumericLiteral(node.argument)) return -node.argument.value;
-	if (import_lib$2.isTemplateLiteral(node) && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? "";
-	if (import_lib$2.isJSXElement(node) || import_lib$2.isJSXFragment(node)) return generateCode(node);
-	if (import_lib$2.isArrayExpression(node)) return node.elements.map((element) => element ? evaluateLiteral(element) : null);
-	if (import_lib$2.isObjectExpression(node)) {
+	if (import_lib$1.isStringLiteral(node)) return node.value;
+	if (import_lib$1.isNumericLiteral(node)) return node.value;
+	if (import_lib$1.isBooleanLiteral(node)) return node.value;
+	if (import_lib$1.isNullLiteral(node)) return null;
+	if (import_lib$1.isIdentifier(node) && node.name === "undefined") return;
+	if (import_lib$1.isUnaryExpression(node) && node.operator === "-" && import_lib$1.isNumericLiteral(node.argument)) return -node.argument.value;
+	if (import_lib$1.isTemplateLiteral(node) && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? "";
+	if (import_lib$1.isJSXElement(node) || import_lib$1.isJSXFragment(node)) return generateCode(node);
+	if (import_lib$1.isArrayExpression(node)) return node.elements.map((element) => element ? evaluateLiteral(element) : null);
+	if (import_lib$1.isObjectExpression(node)) {
 		const result = {};
 		for (const prop of node.properties) {
-			if (!import_lib$2.isObjectProperty(prop)) continue;
+			if (!import_lib$1.isObjectProperty(prop)) continue;
 			let key = null;
-			if (import_lib$2.isIdentifier(prop.key)) key = prop.key.name;
-			else if (import_lib$2.isStringLiteral(prop.key)) key = prop.key.value;
-			else if (import_lib$2.isNumericLiteral(prop.key)) key = String(prop.key.value);
+			if (import_lib$1.isIdentifier(prop.key)) key = prop.key.name;
+			else if (import_lib$1.isStringLiteral(prop.key)) key = prop.key.value;
+			else if (import_lib$1.isNumericLiteral(prop.key)) key = String(prop.key.value);
 			if (key === null) continue;
 			result[key] = evaluateLiteral(prop.value);
 		}
@@ -117,8 +88,8 @@ const parseValue = (value) => {
 	}
 	if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
 		try {
-			const ast = (0, import_lib$1.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
-			if (import_lib$2.isObjectExpression(ast) || import_lib$2.isArrayExpression(ast)) return evaluateLiteral(ast);
+			const ast = (0, import_lib.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+			if (import_lib$1.isObjectExpression(ast) || import_lib$1.isArrayExpression(ast)) return evaluateLiteral(ast);
 		} catch {}
 		return value;
 	}
@@ -148,43 +119,80 @@ const flattenEditableValue = (value) => {
 	walk(parsed, [], 0);
 	return entries.length ? entries : null;
 };
+const findEditableLeaf = (root, path) => {
+	let node = unwrapExpression(root);
+	for (const segment of path) {
+		if (import_lib$1.isArrayExpression(node)) {
+			if (typeof segment !== "number") return null;
+			const elements = node.elements.slice(0, segment + 1);
+			const element = node.elements[segment];
+			if (!element || elements.some((item) => import_lib$1.isSpreadElement(item))) return null;
+			node = unwrapExpression(element);
+			continue;
+		}
+		if (import_lib$1.isObjectExpression(node)) {
+			const key = String(segment);
+			const matches = (property) => import_lib$1.isObjectProperty(property) && !property.computed && (import_lib$1.isIdentifier(property.key) && property.key.name === key || import_lib$1.isStringLiteral(property.key) && property.key.value === key || import_lib$1.isNumericLiteral(property.key) && String(property.key.value) === key);
+			let index = node.properties.length - 1;
+			while (index >= 0 && !matches(node.properties[index])) index--;
+			const property = node.properties[index];
+			if (!property || !import_lib$1.isObjectProperty(property) || node.properties.slice(index + 1).some((item) => import_lib$1.isSpreadElement(item))) return null;
+			node = unwrapExpression(property.value);
+			continue;
+		}
+		return null;
+	}
+	return node;
+};
+const isEditableLeaf = (node) => import_lib$1.isStringLiteral(node) || import_lib$1.isNumericLiteral(node) || import_lib$1.isBooleanLiteral(node) || import_lib$1.isUnaryExpression(node) && node.operator === "-" && import_lib$1.isNumericLiteral(node.argument) || import_lib$1.isTemplateLiteral(node) && node.expressions.length === 0 || import_lib$1.isJSXElement(node) || import_lib$1.isJSXFragment(node);
+const quoteString = (text, quote) => {
+	if (quote === "`") return `\`${text.replace(/[\\`]|\$\{/g, (match) => `\\${match}`)}\``;
+	const escaped = JSON.stringify(text).slice(1, -1);
+	return quote === "\"" ? `"${escaped}"` : `'${escaped.replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
+};
+const isJSXSource = (text) => {
+	try {
+		const expression = (0, import_lib.parseExpression)(text, { plugins: ["jsx"] });
+		return import_lib$1.isJSXElement(expression) || import_lib$1.isJSXFragment(expression);
+	} catch {
+		return false;
+	}
+};
+const leafSource = (value, leaf, next) => {
+	if (typeof next !== "string") return String(next);
+	if ((import_lib$1.isJSXElement(leaf) || import_lib$1.isJSXFragment(leaf)) && isJSXSource(next)) return next.trim();
+	const quote = import_lib$1.isStringLiteral(leaf) || import_lib$1.isTemplateLiteral(leaf) ? value[leaf.start] : "'";
+	return quoteString(next, quote);
+};
 const setEditableValue = (value, path, next) => {
 	if (!path.length) return value;
-	const parsed = parseValue(value);
-	if (typeof parsed !== "object" || parsed === null) return value;
-	const root = Array.isArray(parsed) ? [...parsed] : { ...parsed };
-	let cursor = root;
-	for (let i = 0; i < path.length - 1; i++) {
-		const key = path[i];
-		const child = cursor[key];
-		if (typeof child !== "object" || child === null) return value;
-		const clonedChild = Array.isArray(child) ? [...child] : { ...child };
-		cursor[key] = clonedChild;
-		cursor = clonedChild;
+	let leaf;
+	try {
+		leaf = findEditableLeaf((0, import_lib.parseExpression)(value, { plugins: ["jsx", "typescript"] }), path);
+	} catch {
+		return value;
 	}
-	const lastKey = path[path.length - 1];
-	if (!(lastKey in cursor)) return value;
-	cursor[lastKey] = next;
-	return JSON.stringify(root);
+	if (!leaf || !isEditableLeaf(leaf) || leaf.start == null || leaf.end == null) return value;
+	return `${value.slice(0, leaf.start)}${leafSource(value, leaf, next)}${value.slice(leaf.end)}`;
 };
 const extractNodeValue = (node) => {
-	if (import_lib$2.isBooleanLiteral(node)) return {
+	if (import_lib$1.isBooleanLiteral(node)) return {
 		type: "boolean",
 		value: node.value
 	};
-	if (import_lib$2.isNumericLiteral(node)) return {
+	if (import_lib$1.isNumericLiteral(node)) return {
 		type: "number",
 		value: node.value
 	};
-	if (import_lib$2.isUnaryExpression(node) && node.operator === "-" && import_lib$2.isNumericLiteral(node.argument)) return {
+	if (import_lib$1.isUnaryExpression(node) && node.operator === "-" && import_lib$1.isNumericLiteral(node.argument)) return {
 		type: "number",
 		value: -node.argument.value
 	};
-	if (import_lib$2.isStringLiteral(node)) return {
+	if (import_lib$1.isStringLiteral(node)) return {
 		type: "string",
 		value: node.value
 	};
-	if (import_lib$2.isTemplateLiteral(node)) {
+	if (import_lib$1.isTemplateLiteral(node)) {
 		if (node.expressions.length === 0 && node.quasis.length === 1) return {
 			type: "string",
 			value: dedent(node.quasis[0].value.cooked ?? node.quasis[0].value.raw)
@@ -194,19 +202,19 @@ const extractNodeValue = (node) => {
 			value: generateCode(node)
 		};
 	}
-	if (import_lib$2.isNullLiteral(node)) return {
+	if (import_lib$1.isNullLiteral(node)) return {
 		type: "null",
 		value: null
 	};
-	if (import_lib$2.isArrayExpression(node)) return {
+	if (import_lib$1.isArrayExpression(node)) return {
 		type: "array",
 		value: generateCode(node)
 	};
-	if (import_lib$2.isObjectExpression(node)) return {
+	if (import_lib$1.isObjectExpression(node)) return {
 		type: "object",
 		value: generateCode(node)
 	};
-	if (import_lib$2.isJSXElement(node) || import_lib$2.isJSXFragment(node)) return {
+	if (import_lib$1.isJSXElement(node) || import_lib$1.isJSXFragment(node)) return {
 		type: "string",
 		value: generateCode(node)
 	};
@@ -217,10 +225,10 @@ const extractNodeValue = (node) => {
 };
 const createNodeFromValue = (type, value) => {
 	switch (type) {
-		case "boolean": return import_lib$2.booleanLiteral(value === true);
-		case "number": return import_lib$2.numericLiteral(Number(value));
-		case "string": return import_lib$2.stringLiteral(String(value));
-		case "null": return import_lib$2.nullLiteral();
+		case "boolean": return import_lib$1.booleanLiteral(value === true);
+		case "number": return import_lib$1.numericLiteral(Number(value));
+		case "string": return import_lib$1.stringLiteral(String(value));
+		case "null": return import_lib$1.nullLiteral();
 		case "array":
 		case "object":
 		case "unknown": return null;
@@ -228,26 +236,26 @@ const createNodeFromValue = (type, value) => {
 	}
 };
 const valueToExpression = (value) => {
-	if (typeof value === "string") return import_lib$2.stringLiteral(value);
-	if (typeof value === "number") return value < 0 ? import_lib$2.unaryExpression("-", import_lib$2.numericLiteral(-value)) : import_lib$2.numericLiteral(value);
-	if (typeof value === "boolean") return import_lib$2.booleanLiteral(value);
-	if (value === null) return import_lib$2.nullLiteral();
-	if (Array.isArray(value)) return import_lib$2.arrayExpression(value.map((item) => valueToExpression(item) ?? import_lib$2.nullLiteral()));
+	if (typeof value === "string") return import_lib$1.stringLiteral(value);
+	if (typeof value === "number") return value < 0 ? import_lib$1.unaryExpression("-", import_lib$1.numericLiteral(-value)) : import_lib$1.numericLiteral(value);
+	if (typeof value === "boolean") return import_lib$1.booleanLiteral(value);
+	if (value === null) return import_lib$1.nullLiteral();
+	if (Array.isArray(value)) return import_lib$1.arrayExpression(value.map((item) => valueToExpression(item) ?? import_lib$1.nullLiteral()));
 	if (typeof value === "object") {
 		const properties = [];
 		for (const [key, item] of Object.entries(value)) {
 			const expr = valueToExpression(item);
 			if (expr === null) continue;
-			properties.push(import_lib$2.objectProperty(import_lib$2.stringLiteral(key), expr));
+			properties.push(import_lib$1.objectProperty(import_lib$1.stringLiteral(key), expr));
 		}
-		return import_lib$2.objectExpression(properties);
+		return import_lib$1.objectExpression(properties);
 	}
 	return null;
 };
 const parseArrayExpression = (value) => {
 	try {
-		const ast = unwrapExpression((0, import_lib$1.parseExpression)(value, { plugins: ["jsx", "typescript"] }));
-		if (!import_lib$2.isArrayExpression(ast)) return null;
+		const ast = unwrapExpression((0, import_lib.parseExpression)(value, { plugins: ["jsx", "typescript"] }));
+		if (!import_lib$1.isArrayExpression(ast)) return null;
 		return ast;
 	} catch (error) {
 		console.error("❌ Array parsing error:", error);
@@ -257,9 +265,9 @@ const parseArrayExpression = (value) => {
 const extractObjectProperties = (element) => {
 	const properties = {};
 	element.properties.forEach((prop) => {
-		if (import_lib$2.isObjectProperty(prop) && import_lib$2.isIdentifier(prop.key)) {
+		if (import_lib$1.isObjectProperty(prop) && import_lib$1.isIdentifier(prop.key)) {
 			const key = prop.key.name;
-			if (key === "children" || import_lib$2.isJSXElement(prop.value) || import_lib$2.isJSXFragment(prop.value)) return;
+			if (key === "children" || import_lib$1.isJSXElement(prop.value) || import_lib$1.isJSXFragment(prop.value)) return;
 			const extracted = extractNodeValue(prop.value);
 			properties[key] = {
 				...extracted,
@@ -270,7 +278,7 @@ const extractObjectProperties = (element) => {
 	return properties;
 };
 const arrayExpressionToCode = (elements) => {
-	const nextAst = import_lib$2.arrayExpression(elements);
+	const nextAst = import_lib$1.arrayExpression(elements);
 	return generateCode(nextAst);
 };
 //#endregion
@@ -377,12 +385,12 @@ const getCurrentValue = (node, property) => {
 		case BINDING_PROP.INNER_HTML: {
 			const dsiAttr = node.attributes.find((a) => a.name === "dangerouslySetInnerHTML");
 			if (dsiAttr?.value) try {
-				const expr = (0, import_lib$1.parseExpression)(dsiAttr.value, { plugins: ["jsx", "typescript"] });
-				if (import_lib$2.isObjectExpression(expr)) {
-					const htmlProp = expr.properties.find((p) => import_lib$2.isObjectProperty(p) && import_lib$2.isIdentifier(p.key) && p.key.name === "__html");
+				const expr = (0, import_lib.parseExpression)(dsiAttr.value, { plugins: ["jsx", "typescript"] });
+				if (import_lib$1.isObjectExpression(expr)) {
+					const htmlProp = expr.properties.find((p) => import_lib$1.isObjectProperty(p) && import_lib$1.isIdentifier(p.key) && p.key.name === "__html");
 					if (htmlProp) {
-						if (import_lib$2.isStringLiteral(htmlProp.value)) return htmlProp.value.value;
-						if (import_lib$2.isTemplateLiteral(htmlProp.value) && htmlProp.value.expressions.length === 0) return htmlProp.value.quasis[0]?.value.cooked ?? htmlProp.value.quasis[0]?.value.raw ?? "";
+						if (import_lib$1.isStringLiteral(htmlProp.value)) return htmlProp.value.value;
+						if (import_lib$1.isTemplateLiteral(htmlProp.value) && htmlProp.value.expressions.length === 0) return htmlProp.value.quasis[0]?.value.cooked ?? htmlProp.value.quasis[0]?.value.raw ?? "";
 					}
 				}
 			} catch {}
@@ -549,7 +557,7 @@ const commaIn = (source, start, end) => {
 };
 const denseArraySource = (source) => {
 	const array = parseArrayExpression(source);
-	if (!array || array.elements.some((node) => !import_lib$2.isExpression(node) || node.extra?.parenthesized)) return null;
+	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;
@@ -609,9 +617,9 @@ const appendArraySource = (source, data, copies) => {
 //#endregion
 //#region src/utils/ast/items.ts
 const elementsOf = (code) => parseArrayExpression(code)?.elements ?? null;
-const kindOf = (element) => import_lib$2.isObjectExpression(element) ? "object" : "primitive";
+const kindOf = (element) => import_lib$1.isObjectExpression(element) ? "object" : "primitive";
 const parseItems = (code) => {
-	return elementsOf(code)?.flatMap((node, index) => import_lib$2.isExpression(node) ? [{
+	return elementsOf(code)?.flatMap((node, index) => import_lib$1.isExpression(node) ? [{
 		index,
 		kind: kindOf(node),
 		node
@@ -627,23 +635,23 @@ const toTemplateRaw = (value) => {
 const buildPropertyValue = (value, declaredType, renderLeaf, current) => {
 	if (renderLeaf?.property === BINDING_PROP.INNER_HTML) {
 		const raw = String(value);
-		return import_lib$2.templateLiteral([import_lib$2.templateElement({
+		return import_lib$1.templateLiteral([import_lib$1.templateElement({
 			raw: toTemplateRaw(raw),
 			cooked: raw
 		}, true)], []);
 	}
-	if (renderLeaf?.type === "jsx" || import_lib$2.isJSXElement(current) || import_lib$2.isJSXFragment(current)) {
+	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$2.stringLiteral(trimmed);
+		if (!trimmed.startsWith("<")) return import_lib$1.stringLiteral(trimmed);
 		try {
-			return (0, import_lib$1.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+			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$1.parseExpression)(value, { plugins: ["jsx", "typescript"] });
+			return (0, import_lib.parseExpression)(value, { plugins: ["jsx", "typescript"] });
 		} catch {
 			return;
 		}
@@ -655,13 +663,13 @@ const buildPropertyValue = (value, declaredType, renderLeaf, current) => {
 const updateArrayItemProperty = (code, index, key, value, render) => {
 	const elements = elementsOf(code);
 	const element = elements?.[index];
-	if (!elements || !import_lib$2.isObjectExpression(element)) return null;
-	const target = element.properties.find((property) => import_lib$2.isObjectProperty(property) && import_lib$2.isIdentifier(property.key) && property.key.name === key);
+	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$2.isJSXElement(nextValue) || import_lib$2.isJSXFragment(nextValue)) ? value.trim() : generateCode(nextValue);
+	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, [{
@@ -673,7 +681,7 @@ const updateArrayItemProperty = (code, index, key, value, render) => {
 const updateArrayItemValue = (code, index, value) => {
 	const elements = elementsOf(code);
 	const element = elements?.[index];
-	if (!elements || !import_lib$2.isExpression(element)) return null;
+	if (!elements || !import_lib$1.isExpression(element)) return null;
 	const nextValue = createNodeFromValue(extractNodeValue(element).type, parseValue(value));
 	if (!nextValue) return null;
 	return applyEdits(code, [{
@@ -714,25 +722,25 @@ const copyItem = (code, element, generateId, usedIds) => {
 		usedIds.add(id);
 		return JSON.stringify(id);
 	};
-	import_lib$2.traverseFast(element, (node) => {
-		if (!import_lib$2.isJSXOpeningElement(node)) return;
-		const ids = node.attributes.filter((attr) => import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name, { name: "data-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$2.isStringLiteral(attr.value) || node.attributes.slice(node.attributes.indexOf(attr) + 1).some((a) => import_lib$2.isJSXSpreadAttribute(a)))) {
+		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$2.isStringLiteral(attr.value)) edits.push({
+		if (attr && import_lib$1.isStringLiteral(attr.value)) edits.push({
 			start: attr.value.start,
 			end: attr.value.end,
 			content: reserveId(generateId())
 		});
 	});
-	if (import_lib$2.isObjectExpression(element)) {
-		const keys = element.properties.filter((prop) => import_lib$2.isObjectProperty(prop) && !prop.computed && (import_lib$2.isIdentifier(prop.key, { name: "key" }) || import_lib$2.isStringLiteral(prop.key, { value: "key" })));
+	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$2.isStringLiteral(key.value) || element.properties.slice(element.properties.indexOf(key) + 1).some((prop) => import_lib$2.isSpreadElement(prop) || "computed" in prop && prop.computed))) return null;
-		if (key && import_lib$2.isStringLiteral(key.value)) edits.push({
+		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()}`)
@@ -749,9 +757,9 @@ 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$2.traverseFast(data.array, (node) => {
-		if (import_lib$2.isJSXAttribute(node) && import_lib$2.isJSXIdentifier(node.name, { name: "data-id" }) && import_lib$2.isStringLiteral(node.value)) usedIds.add(node.value.value);
-		else if (import_lib$2.isObjectProperty(node) && !node.computed && (import_lib$2.isIdentifier(node.key, { name: "key" }) || import_lib$2.isStringLiteral(node.key, { value: "key" })) && import_lib$2.isStringLiteral(node.value)) usedIds.add(node.value.value);
+	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;
@@ -763,31 +771,13 @@ const appendArrayItem = (code, kind, generateId = () => nanoid(6)) => {
 //#endregion
 //#region src/utils/ast/extract.ts
 const collectText = (children) => {
-	return children.filter((c) => import_lib$2.isJSXText(c)).map((c) => c.value.trim()).filter((v) => v.length).join(" ");
-};
-const getTagName = (opening) => {
-	if (import_lib$2.isJSXIdentifier(opening.name)) return opening.name.name;
-	if (import_lib$2.isJSXMemberExpression(opening.name)) return resolveMemberName(opening.name);
-	return "";
-};
-const resolveMemberName = (expr) => {
-	const parts = [];
-	const collectMemberParts = (node) => {
-		if (import_lib$2.isJSXIdentifier(node)) parts.push(node.name);
-		else if (import_lib$2.isJSXMemberExpression(node)) {
-			collectMemberParts(node.object);
-			if (import_lib$2.isJSXIdentifier(node.property)) parts.push(node.property.name);
-		}
-	};
-	collectMemberParts(expr.object);
-	if (import_lib$2.isJSXIdentifier(expr.property)) parts.push(expr.property.name);
-	return parts.join(".");
+	return children.filter((c) => import_lib$1.isJSXText(c)).map((c) => c.value.trim()).filter((v) => v.length).join(" ");
 };
 const parseJSXName = (tagName) => {
 	const parts = tagName.split(".");
-	if (parts.length === 1) return import_lib$2.jsxIdentifier(parts[0]);
-	let expr = import_lib$2.jsxIdentifier(parts[0]);
-	for (let i = 1; i < parts.length; i++) expr = import_lib$2.jsxMemberExpression(expr, import_lib$2.jsxIdentifier(parts[i]));
+	if (parts.length === 1) return import_lib$1.jsxIdentifier(parts[0]);
+	let expr = import_lib$1.jsxIdentifier(parts[0]);
+	for (let i = 1; i < parts.length; i++) expr = import_lib$1.jsxMemberExpression(expr, import_lib$1.jsxIdentifier(parts[i]));
 	return expr;
 };
 const extractCache = createBoundedCache(CONFIG.CACHE_LIMIT);
@@ -795,17 +785,17 @@ const extractAttributes = (attributes, source) => {
 	const allAttrs = [];
 	const dataAttrs = [];
 	for (const attr of attributes) {
-		if (!import_lib$2.isJSXAttribute(attr) || !import_lib$2.isJSXIdentifier(attr.name)) continue;
+		if (!import_lib$1.isJSXAttribute(attr) || !import_lib$1.isJSXIdentifier(attr.name)) continue;
 		const name = attr.name.name;
 		let value = null;
 		let isStringLiteral = false;
 		if (attr.value) {
-			if (import_lib$2.isStringLiteral(attr.value)) {
+			if (import_lib$1.isStringLiteral(attr.value)) {
 				value = attr.value.value;
 				isStringLiteral = true;
-			} else if (import_lib$2.isJSXExpressionContainer(attr.value)) try {
+			} else if (import_lib$1.isJSXExpressionContainer(attr.value)) try {
 				const expression = attr.value.expression;
-				const structural = import_lib$2.isArrayExpression(unwrapExpression(expression)) || import_lib$2.isObjectExpression(unwrapExpression(expression));
+				const structural = import_lib$1.isArrayExpression(unwrapExpression(expression)) || import_lib$1.isObjectExpression(unwrapExpression(expression));
 				value = source && structural && expression.start != null && expression.end != null ? source.slice(expression.start, expression.end) : generateCode(expression);
 				isStringLiteral = false;
 			} catch {
@@ -827,7 +817,7 @@ const extractAttributes = (attributes, source) => {
 };
 const buildChildElements = (node) => {
 	const childElements = [];
-	if (node.textContent) childElements.push(import_lib$2.jsxText(node.textContent));
+	if (node.textContent) childElements.push(import_lib$1.jsxText(node.textContent));
 	node.children?.forEach((child) => {
 		const childJSX = nodeToJSX(child);
 		if (childJSX) childElements.push(childJSX);
@@ -838,22 +828,22 @@ const nodeToJSX = (node) => {
 	try {
 		if (node.isFragment) {
 			const childElements = buildChildElements(node);
-			return import_lib$2.jsxFragment(import_lib$2.jsxOpeningFragment(), import_lib$2.jsxClosingFragment(), childElements);
+			return import_lib$1.jsxFragment(import_lib$1.jsxOpeningFragment(), import_lib$1.jsxClosingFragment(), childElements);
 		}
 		if (node.tagName === "div" && node.dataAttributes.some((attr) => attr.name === "data-item")) {
 			if (node.children) return nodeToJSX(node.children[0]);
 			return null;
 		}
 		const attributes = node.attributes.map((attr) => {
-			const attrName = import_lib$2.jsxIdentifier(attr.name);
-			if (!attr.value) return import_lib$2.jsxAttribute(attrName, null);
-			return import_lib$2.jsxAttribute(attrName, attrValue(attr));
+			const attrName = import_lib$1.jsxIdentifier(attr.name);
+			if (!attr.value) return import_lib$1.jsxAttribute(attrName, null);
+			return import_lib$1.jsxAttribute(attrName, attrValue(attr));
 		});
 		const elementName = parseJSXName(node.tagName);
-		const openingElement = import_lib$2.jsxOpeningElement(elementName, attributes);
-		const closingElement = import_lib$2.jsxClosingElement(elementName);
+		const openingElement = import_lib$1.jsxOpeningElement(elementName, attributes);
+		const closingElement = import_lib$1.jsxClosingElement(elementName);
 		const children = buildChildElements(node);
-		return import_lib$2.jsxElement(openingElement, closingElement, children, false);
+		return import_lib$1.jsxElement(openingElement, closingElement, children, false);
 	} catch (error) {
 		console.error("❌ DataAttrNode to JSX conversion error:", error);
 		return null;
@@ -883,11 +873,11 @@ const createFragmentNode = (textContent, children) => ({
 	isFragment: true
 });
 const processChildrenBinding = (jsxElement, processedNodes, shouldWrap = true, source) => {
-	const jsxChildren = jsxElement.children.filter((child) => import_lib$2.isJSXElement(child) || import_lib$2.isJSXFragment(child));
+	const jsxChildren = jsxElement.children.filter((child) => import_lib$1.isJSXElement(child) || import_lib$1.isJSXFragment(child));
 	if (!jsxChildren.length) return;
 	const childrenNodes = [];
 	jsxChildren.forEach((child) => {
-		if (import_lib$2.isJSXElement(child)) {
+		if (import_lib$1.isJSXElement(child)) {
 			const childResults = extractFromNode(child, processedNodes, source);
 			if (shouldWrap) {
 				const wrapperNode = createWrapperNode(collectText(child.children), childResults);
@@ -896,11 +886,11 @@ const processChildrenBinding = (jsxElement, processedNodes, shouldWrap = true, s
 				if (dataId) wrapperNode.id = `child:${dataId}`;
 				childrenNodes.push(wrapperNode);
 			} else childrenNodes.push(...childResults);
-		} else if (import_lib$2.isJSXFragment(child)) {
+		} else if (import_lib$1.isJSXFragment(child)) {
 			processedNodes?.add(child);
 			const fragmentChildren = [];
 			child.children.forEach((fragmentChild) => {
-				if (import_lib$2.isJSXElement(fragmentChild)) {
+				if (import_lib$1.isJSXElement(fragmentChild)) {
 					const childResults = extractFromNode(fragmentChild, processedNodes, source);
 					fragmentChildren.push(...childResults);
 				}
@@ -915,32 +905,32 @@ const processChildrenBinding = (jsxElement, processedNodes, shouldWrap = true, s
 	return childrenNodes.length ? childrenNodes : void 0;
 };
 const skipItemsChildren = (jsxElement, processedNodes, propertyName = "items") => {
-	const itemsAttr = jsxElement.openingElement.attributes.find((attr) => import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === propertyName);
-	if (!itemsAttr || !import_lib$2.isJSXAttribute(itemsAttr)) return;
-	if (itemsAttr.value && import_lib$2.isJSXExpressionContainer(itemsAttr.value) && import_lib$2.isArrayExpression(itemsAttr.value.expression)) itemsAttr.value.expression.elements.forEach((element) => {
-		if (import_lib$2.isObjectExpression(element)) element.properties.forEach((prop) => {
-			if (import_lib$2.isObjectProperty(prop) && import_lib$2.isIdentifier(prop.key) && import_lib$2.isJSXElement(prop.value)) markProcessedJSX(prop.value, processedNodes);
+	const itemsAttr = jsxElement.openingElement.attributes.find((attr) => import_lib$1.isJSXAttribute(attr) && import_lib$1.isJSXIdentifier(attr.name) && attr.name.name === propertyName);
+	if (!itemsAttr || !import_lib$1.isJSXAttribute(itemsAttr)) return;
+	if (itemsAttr.value && import_lib$1.isJSXExpressionContainer(itemsAttr.value) && import_lib$1.isArrayExpression(itemsAttr.value.expression)) itemsAttr.value.expression.elements.forEach((element) => {
+		if (import_lib$1.isObjectExpression(element)) element.properties.forEach((prop) => {
+			if (import_lib$1.isObjectProperty(prop) && import_lib$1.isIdentifier(prop.key) && import_lib$1.isJSXElement(prop.value)) markProcessedJSX(prop.value, processedNodes);
 		});
 	});
 };
 const markProcessedJSX = (node, processedNodes) => {
-	if (import_lib$2.isJSXElement(node) || import_lib$2.isJSXFragment(node)) {
+	if (import_lib$1.isJSXElement(node) || import_lib$1.isJSXFragment(node)) {
 		processedNodes.add(node);
 		node.children.forEach((child) => markProcessedJSX(child, processedNodes));
 		return;
 	}
-	if (import_lib$2.isJSXExpressionContainer(node) || import_lib$2.isParenthesizedExpression(node)) markProcessedJSX(node.expression, processedNodes);
+	if (import_lib$1.isJSXExpressionContainer(node) || import_lib$1.isParenthesizedExpression(node)) markProcessedJSX(node.expression, processedNodes);
 };
 const getBindingExpression = (opening) => {
-	for (const attr of opening.attributes) if (import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.BINDING && attr.value && import_lib$2.isJSXExpressionContainer(attr.value)) {
+	for (const attr of opening.attributes) if (import_lib$1.isJSXAttribute(attr) && import_lib$1.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.BINDING && attr.value && import_lib$1.isJSXExpressionContainer(attr.value)) {
 		const expression = unwrapExpression(attr.value.expression);
-		if (import_lib$2.isArrayExpression(expression)) return expression;
+		if (import_lib$1.isArrayExpression(expression)) return expression;
 	}
 	return null;
 };
 const readNodeBindingInfo = (node, source) => {
 	const opening = node.openingElement;
-	const tagName = getTagName(opening);
+	const tagName = getJSXTagName(opening);
 	const { allAttrs, dataAttrs } = extractAttributes(opening.attributes, source);
 	const bindingAttr = dataAttrs.find((attr) => attr.name === DATA_ATTR.BINDING);
 	const bindingExpr = getBindingExpression(opening);
@@ -962,7 +952,7 @@ const readNodeBindingInfo = (node, source) => {
 };
 const parseToNodes = (raw) => {
 	const wrapped = wrap(raw);
-	const ast = (0, import_lib$1.parse)(wrapped, {
+	const ast = (0, import_lib.parse)(wrapped, {
 		sourceType: "module",
 		plugins: ["jsx", "typescript"],
 		errorRecovery: true
@@ -1037,7 +1027,7 @@ const getChildrenSignatures = (nodes) => {
 };
 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$1.parseExpression)(source, { plugins: ["jsx", "typescript"] });
+	const node = (0, import_lib.parseExpression)(source, { plugins: ["jsx", "typescript"] });
 	const edits = [];
 	const newId = () => {
 		let id = nanoid(12);
@@ -1045,15 +1035,15 @@ const copySource = (source, usedIds) => {
 		usedIds.add(id);
 		return id;
 	};
-	import_lib$2.traverseFast(node, (child) => {
-		if (!import_lib$2.isJSXOpeningElement(child)) return;
-		const ids = child.attributes.filter((attr) => import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name, { name: "data-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$2.isJSXSpreadAttribute(attribute))) throw new Error("A spread may override the copied data-id");
+		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$2.isStringLiteral(value) || value.start == null || value.end == null) throw new Error("Cannot copy a dynamic data-id");
+			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,
@@ -1075,7 +1065,7 @@ 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$2.isJSXElement(child) || import_lib$2.isJSXFragment(child));
+		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;
@@ -1098,7 +1088,7 @@ const editChildrenSource = (source, parent, input) => {
 		};
 		if (Array.isArray(value)) {
 			const desired = modeledSignatures(value);
-			const lossless = raw.every((text, index) => generateCode((0, import_lib$1.parseExpression)(text, { plugins: ["jsx", "typescript"] })) === signatures[index]);
+			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]));
@@ -1111,8 +1101,8 @@ const editChildrenSource = (source, parent, input) => {
 			});
 			const countIds = (text) => {
 				const counts = /* @__PURE__ */ new Map();
-				import_lib$2.traverseFast((0, import_lib$1.parseExpression)(text, { plugins: ["jsx", "typescript"] }), (node) => {
-					if (import_lib$2.isJSXAttribute(node) && import_lib$2.isJSXIdentifier(node.name, { name: "data-id" }) && import_lib$2.isStringLiteral(node.value)) counts.set(node.value.value, (counts.get(node.value.value) ?? 0) + 1);
+				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;
 			};
@@ -1124,8 +1114,8 @@ const editChildrenSource = (source, parent, input) => {
 		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$2.traverseFast(parent, (node) => {
-			if (import_lib$2.isJSXAttribute(node) && import_lib$2.isJSXIdentifier(node.name, { name: "data-id" }) && import_lib$2.isStringLiteral(node.value)) usedIds.add(node.value.value);
+		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": {
@@ -1181,7 +1171,7 @@ const childrenRange = (element) => {
 	};
 };
 const findAttribute = (opening, propertyName) => {
-	return opening.attributes.find((attr) => import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === 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;
@@ -1190,7 +1180,7 @@ const editInnerText = (source, element, value) => {
 	const range = childrenRange(element);
 	if (!range) return [];
 	const [only] = element.children;
-	if (element.children.length === 1 && import_lib$2.isJSXText(only) && only.start != null && only.end != null) {
+	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;
@@ -1203,7 +1193,7 @@ const editInnerText = (source, element, value) => {
 		}
 	}
 	const edits = [];
-	for (const child of element.children) if (import_lib$2.isJSXText(child) && child.start != null && child.end != null) edits.push({
+	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: ""
@@ -1233,7 +1223,7 @@ const editRichtext = (element, value) => {
 		content: ""
 	});
 	const opening = element.openingElement;
-	const attribute = import_lib$2.jsxAttribute(import_lib$2.jsxIdentifier("dangerouslySetInnerHTML"), import_lib$2.jsxExpressionContainer(import_lib$2.objectExpression([import_lib$2.objectProperty(import_lib$2.identifier("__html"), import_lib$2.stringLiteral(value))])));
+	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) {
@@ -1272,11 +1262,11 @@ const editJsxAttribute = (opening, propertyName, value) => {
 		content: `=${content}`
 	}];
 };
-const holdsStructuralExpression = (value) => import_lib$2.isJSXExpressionContainer(value) && (import_lib$2.isArrayExpression(unwrapExpression(value.expression)) || import_lib$2.isObjectExpression(unwrapExpression(value.expression)));
+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$1.parseExpression)(value.trim(), { plugins: ["jsx", "typescript"] });
-		return import_lib$2.isArrayExpression(unwrapExpression(expression)) || import_lib$2.isObjectExpression(unwrapExpression(expression)) ? expression : null;
+		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;
 	}
@@ -1284,29 +1274,29 @@ const structuralSource = (value) => {
 const buildAttributeValue = (value, type, current) => {
 	if (type === "array" || type === "object") {
 		if (typeof value === "string") try {
-			return import_lib$2.jsxExpressionContainer((0, import_lib$1.parseExpression)(value.trim(), { plugins: ["jsx", "typescript"] }));
+			return import_lib$1.jsxExpressionContainer((0, import_lib.parseExpression)(value.trim(), { plugins: ["jsx", "typescript"] }));
 		} catch {
-			return import_lib$2.stringLiteral(value);
+			return import_lib$1.stringLiteral(value);
 		}
 		const expr = valueToExpression(value);
-		return expr ? import_lib$2.jsxExpressionContainer(expr) : import_lib$2.stringLiteral("");
+		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$2.jsxExpressionContainer(structural);
+			if (structural) return import_lib$1.jsxExpressionContainer(structural);
 		}
-		return import_lib$2.stringLiteral(value);
+		return import_lib$1.stringLiteral(value);
 	}
 	const expr = valueToExpression(value);
-	return expr ? import_lib$2.jsxExpressionContainer(expr) : import_lib$2.stringLiteral(String(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$2.isJSXExpressionContainer(attribute.value)) {
+		if (expression && import_lib$1.isJSXExpressionContainer(attribute.value)) {
 			const text = value.trim();
 			const lineComment = expression.trailingComments?.some((comment) => comment.type === "CommentLine");
 			return [{
@@ -1316,7 +1306,7 @@ const editAttribute = (opening, propertyName, value, type) => {
 			}];
 		}
 	}
-	const content = generateCode(import_lib$2.jsxAttribute(attribute.name, buildAttributeValue(value, type, attribute.value)));
+	const content = generateCode(import_lib$1.jsxAttribute(attribute.name, buildAttributeValue(value, type, attribute.value)));
 	return [{
 		start: attribute.start,
 		end: attribute.end,
@@ -1324,14 +1314,36 @@ const editAttribute = (opening, propertyName, value, type) => {
 		indent: true
 	}];
 };
+const removeAttribute = (source, attribute) => {
+	if (attribute.start == null || attribute.end == null) return null;
+	let start = attribute.start;
+	while (start > 0 && /\s/.test(source[start - 1])) start -= 1;
+	return [{
+		start,
+		end: attribute.end,
+		content: ""
+	}];
+};
+const addAttribute = (source, opening, propertyName, value, type) => {
+	const insertAt = attributeInsertPoint(opening);
+	if (insertAt == null) return null;
+	const lastStart = opening.attributes[opening.attributes.length - 1]?.start;
+	const lineStart = lastStart == null ? -1 : source.lastIndexOf("\n", lastStart - 1) + 1;
+	return [{
+		start: insertAt,
+		end: insertAt,
+		content: `${lastStart != null && lineStart > 0 && /^\s*$/.test(source.slice(lineStart, lastStart)) ? "\n" : " "}${type === "jsx" ? `${propertyName}={${String(value).trim()}}` : generateCode(import_lib$1.jsxAttribute(import_lib$1.jsxIdentifier(propertyName), buildAttributeValue(value, type)))}`,
+		indent: true
+	}];
+};
 const canEditAttributeValue = (attribute, value, type) => {
-	if (!import_lib$2.isJSXExpressionContainer(attribute.value) || import_lib$2.isJSXEmptyExpression(attribute.value.expression) || isLosslesslyEvaluable(attribute.value.expression)) return true;
+	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$1.parse)(wrapped, {
+		const ast = (0, import_lib.parse)(wrapped, {
 			sourceType: "module",
 			plugins: ["jsx", "typescript"]
 		});
@@ -1349,9 +1361,9 @@ const update = (code, dataId, label, value, property) => {
 		traverse(ast, { JSXElement(path) {
 			const opening = path.node.openingElement;
 			if (!opening.attributes.find((attr) => {
-				return import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.ID && attr.value && import_lib$2.isStringLiteral(attr.value) && attr.value.value === dataId;
+				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$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.BINDING);
+			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",
@@ -1360,8 +1372,8 @@ const update = (code, dataId, label, value, property) => {
 				return;
 			}
 			let bindingValue = "";
-			if (import_lib$2.isStringLiteral(bindingAttr.value)) bindingValue = bindingAttr.value.value;
-			else if (import_lib$2.isJSXExpressionContainer(bindingAttr.value)) try {
+			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 = {
@@ -1392,20 +1404,45 @@ const update = (code, dataId, label, value, property) => {
 			}
 			const propertyBinding = matches[0];
 			const prop = propertyBinding.property;
+			if (RESERVED_BINDING_PROPERTIES.includes(prop)) {
+				failure = {
+					reason: "reserved-property",
+					dataId,
+					property: prop
+				};
+				return;
+			}
+			const unset = value === void 0;
+			if (unset && propertyBinding.required) {
+				failure = {
+					reason: "required-property",
+					dataId,
+					property: prop
+				};
+				return;
+			}
 			switch (prop) {
 				case BINDING_PROP.INNER_TEXT:
-					collect(editInnerText(wrapped, path.node, String(value)), () => ({
+					collect(editInnerText(wrapped, path.node, unset ? "" : 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)), () => ({
+					collect(propertyBinding.type === "richtext" ? editRichtext(path.node, unset ? "" : String(value)) : editInnerHTML(path.node, unset ? "" : String(value)), () => ({
 						reason: "parse-error",
 						error: /* @__PURE__ */ new Error(`could not update "${prop}"`)
 					}));
 					break;
 				case BINDING_PROP.CHILDREN:
+					if (unset) {
+						failure = {
+							reason: "unsupported-syntax",
+							dataId,
+							property: prop
+						};
+						break;
+					}
 					collect(editChildrenSource(wrapped, path.node, value), () => ({
 						reason: "parse-error",
 						error: /* @__PURE__ */ new Error("Unsupported or stale children edit; source was preserved")
@@ -1413,6 +1450,21 @@ const update = (code, dataId, label, value, property) => {
 					break;
 				default: {
 					const attribute = findAttribute(opening, prop);
+					if (unset) {
+						collect(attribute ? removeAttribute(wrapped, attribute) : [], () => ({
+							reason: "parse-error",
+							error: /* @__PURE__ */ new Error(`could not remove "${prop}"`)
+						}));
+						break;
+					}
+					if (!attribute) {
+						collect(value === "" ? [] : addAttribute(wrapped, opening, prop, value, propertyBinding.type), () => ({
+							reason: "attribute-not-found",
+							dataId,
+							property: prop
+						}));
+						break;
+					}
 					if (attribute && propertyBinding.type !== "jsx" && !canEditAttributeValue(attribute, value, propertyBinding.type)) {
 						failure = {
 							reason: "unsupported-syntax",
@@ -1454,6 +1506,31 @@ const update = (code, dataId, label, value, property) => {
 		};
 	}
 };
+const updateAll = (raw, entries) => {
+	let current = raw;
+	for (const [index, entry] of entries.entries()) {
+		const result = update(current, entry.dataId, entry.label, entry.value, entry.property);
+		if (!result.success) return {
+			success: false,
+			code: raw,
+			failure: result.failure ?? {
+				reason: "element-not-found",
+				dataId: entry.dataId
+			},
+			index
+		};
+		current = result.code;
+	}
+	return {
+		success: true,
+		code: current
+	};
+};
+/**
+* @deprecated Not atomic: when an entry fails, the ones before and after it
+* are still applied, and the returned `code` carries them. Use `updateAll`,
+* which applies every entry or none. Will be removed in the next major.
+*/
 const bulkUpdate = (raw, entries) => {
 	let current = raw;
 	const failures = [];
@@ -1472,24 +1549,6 @@ const bulkUpdate = (raw, entries) => {
 	};
 };
 //#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$2.cloneNode(element, true);
-	const generatedCode = generateCode(cloned);
-	const code = replaceIds(generatedCode, generateId);
-	return (0, import_lib$1.parseExpression)(code, { plugins: ["jsx", "typescript"] });
-};
-//#endregion
 //#region src/utils/ast/validate.ts
 const VALID = { valid: true };
 const validateBindingValue = (binding, value) => {
@@ -1539,6 +1598,6 @@ const validateBindingValue = (binding, value) => {
 	return VALID;
 };
 //#endregion
-export { flattenEditableValue as A, parseBinding as C, createNodeFromValue as D, canLosslesslyEvaluateSource as E, parseValue as M, setEditableValue as N, extractNodeValue as O, generateCode as P, getStructuredValue as S, arrayExpressionToCode as T, updateArrayItemValue as _, bulkUpdate as a, findEditableChildren as b, clearExtractCache as c, duplicateArrayItems as d, moveArrayItem as f, updateArrayItemProperty as g, removeArrayItems as h, replaceIds as i, parseArrayExpression as j, extractObjectProperties as k, extract as l, parseItems as m, clone as n, update as o, moveArrayItems as p, fillIds as r, getChildrenSignatures as s, validateBindingValue as t, appendArrayItem as u, canStructurallyEditArray as v, parseBindingExpression as w, getCurrentValue as x, moveSelectedIndices as y };
+export { parseValue as A, arrayExpressionToCode as C, extractObjectProperties as D, extractNodeValue as E, flattenEditableValue as O, parseBindingExpression as S, createNodeFromValue as T, moveSelectedIndices as _, getChildrenSignatures as a, getStructuredValue as b, appendArrayItem as c, moveArrayItems as d, parseItems as f, canStructurallyEditArray as g, updateArrayItemValue as h, updateAll as i, setEditableValue as j, parseArrayExpression as k, duplicateArrayItems as l, updateArrayItemProperty as m, bulkUpdate as n, clearExtractCache as o, removeArrayItems as p, update as r, extract as s, validateBindingValue as t, moveArrayItem as u, findEditableChildren as v, canLosslesslyEvaluateSource as w, parseBinding as x, getCurrentValue as y };
 
-//# sourceMappingURL=ast-jab6hQrT.js.map
+//# sourceMappingURL=ast-BFbDWO-l.js.map