@jbpark/live-editor 4.5.0 → 4.6.1

package/dist/{items-DdrwGxJw.js → items-BXXtMUNI.js}

@@ -1,11 +1,9 @@
-import { C as require_lib, S as require_lib$1, _ as generateCode, b as getJSXTagName, d as traverse, g as attrValue, v as unwrap, w as __toESM, x as nanoid, y as wrap } from "./document-DGHTfrda.js";
-import { c as RESERVED_BINDING_PROPERTIES, n as CONFIG, r as DATA_ATTR, s as REGEX, t as BINDING_PROP } from "./constants-h1JAgOeW.js";
+import { $ as jsxClosingFragment, A as isJSXElement, B as isObjectExpression, C as booleanLiteral, D as isExpression, E as isBooleanLiteral, F as isJSXOpeningElement, G as isTSAsExpression, H as isParenthesizedExpression, I as isJSXSpreadAttribute, J as isTSTypeAssertion, K as isTSNonNullExpression, L as isJSXText, M as isJSXExpressionContainer, N as isJSXFragment, O as isIdentifier, P as isJSXIdentifier, Q as jsxClosingElement, R as isNullLiteral, S as arrayExpression, T as isArrayExpression, U as isSpreadElement, V as isObjectProperty, W as isStringLiteral, X as isUnaryExpression, Y as isTemplateLiteral, Z as jsxAttribute, _ as generateCode, _t as parse, at as jsxOpeningElement, b as getJSXTagName, ct as nullLiteral, d as traverse, dt as objectProperty, et as jsxElement, ft as stringLiteral, g as attrValue, gt as unaryExpression, ht as traverseFast, it as jsxMemberExpression, j as isJSXEmptyExpression, k as isJSXAttribute, lt as numericLiteral, mt as templateLiteral, nt as jsxFragment, ot as jsxOpeningFragment, pt as templateElement, q as isTSSatisfiesExpression, rt as jsxIdentifier, st as jsxText, tt as jsxExpressionContainer, ut as objectExpression, v as unwrap, vt as parseExpression, w as identifier, x as nanoid, y as wrap, z as isNumericLiteral } from "./document-CHO215iP.js";
+import { c as RESERVED_BINDING_PROPERTIES, n as CONFIG, r as DATA_ATTR, s as REGEX, t as BINDING_PROP } from "./constants-DU17Tdwo.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 = require_lib();
-var import_lib$1 = /* @__PURE__ */ __toESM(require_lib$1(), 1);
 const BINDING_TYPES = [
 	"array",
 	"object",
@@ -31,44 +29,44 @@ const dedent = (str) => {
 };
 const unwrapExpression = (node) => {
 	let current = node;
-	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;
+	while (isTSAsExpression(current) || isTSSatisfiesExpression(current) || isTSNonNullExpression(current) || isTSTypeAssertion(current) || isParenthesizedExpression(current)) current = current.expression;
 	return current;
 };
 const isLosslesslyEvaluable = (node) => {
 	const value = unwrapExpression(node);
-	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));
+	if (isStringLiteral(value) || isNumericLiteral(value) || isBooleanLiteral(value) || isNullLiteral(value)) return true;
+	if (isUnaryExpression(value) && value.operator === "-" && isNumericLiteral(value.argument)) return true;
+	if (isTemplateLiteral(value)) return value.expressions.length === 0;
+	if (isArrayExpression(value)) return value.elements.every((element) => element !== null && isLosslesslyEvaluable(element));
+	if (isObjectExpression(value)) return value.properties.every((property) => isObjectProperty(property) && !property.computed && (isIdentifier(property.key) || isStringLiteral(property.key) || isNumericLiteral(property.key)) && isLosslesslyEvaluable(property.value));
 	return false;
 };
 const canLosslesslyEvaluateSource = (source) => {
 	try {
-		return isLosslesslyEvaluable((0, import_lib.parseExpression)(source, { plugins: ["jsx", "typescript"] }));
+		return isLosslesslyEvaluable(parseExpression(source, { plugins: ["jsx", "typescript"] }));
 	} catch {
 		return false;
 	}
 };
 const evaluateLiteral = (rawNode) => {
 	const node = unwrapExpression(rawNode);
-	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)) {
+	if (isStringLiteral(node)) return node.value;
+	if (isNumericLiteral(node)) return node.value;
+	if (isBooleanLiteral(node)) return node.value;
+	if (isNullLiteral(node)) return null;
+	if (isIdentifier(node) && node.name === "undefined") return;
+	if (isUnaryExpression(node) && node.operator === "-" && isNumericLiteral(node.argument)) return -node.argument.value;
+	if (isTemplateLiteral(node) && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? "";
+	if (isJSXElement(node) || isJSXFragment(node)) return generateCode(node);
+	if (isArrayExpression(node)) return node.elements.map((element) => element ? evaluateLiteral(element) : null);
+	if (isObjectExpression(node)) {
 		const result = {};
 		for (const prop of node.properties) {
-			if (!import_lib$1.isObjectProperty(prop)) continue;
+			if (!isObjectProperty(prop)) continue;
 			let key = null;
-			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 (isIdentifier(prop.key)) key = prop.key.name;
+			else if (isStringLiteral(prop.key)) key = prop.key.value;
+			else if (isNumericLiteral(prop.key)) key = String(prop.key.value);
 			if (key === null) continue;
 			result[key] = evaluateLiteral(prop.value);
 		}
@@ -88,111 +86,31 @@ const parseValue = (value) => {
 	}
 	if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
 		try {
-			const ast = (0, import_lib.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
-			if (import_lib$1.isObjectExpression(ast) || import_lib$1.isArrayExpression(ast)) return evaluateLiteral(ast);
+			const ast = parseExpression(trimmed, { plugins: ["jsx", "typescript"] });
+			if (isObjectExpression(ast) || isArrayExpression(ast)) return evaluateLiteral(ast);
 		} catch {}
 		return value;
 	}
 	return value;
 };
-const MAX_FLATTEN_DEPTH = 20;
-const isEditablePrimitive = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-const flattenEditableValue = (value) => {
-	const parsed = parseValue(value);
-	if (typeof parsed !== "object" || parsed === null || Object.keys(parsed).length === 0) return null;
-	const entries = [];
-	const walk = (node, path, depth) => {
-		if (depth > MAX_FLATTEN_DEPTH) return;
-		if (isEditablePrimitive(node)) {
-			entries.push({
-				path,
-				value: node
-			});
-			return;
-		}
-		if (Array.isArray(node)) {
-			node.forEach((item, index) => walk(item, [...path, index], depth + 1));
-			return;
-		}
-		if (typeof node === "object" && node !== null) Object.entries(node).forEach(([key, item]) => walk(item, [...path, key], depth + 1));
-	};
-	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;
-	let leaf;
-	try {
-		leaf = findEditableLeaf((0, import_lib.parseExpression)(value, { plugins: ["jsx", "typescript"] }), path);
-	} catch {
-		return value;
-	}
-	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$1.isBooleanLiteral(node)) return {
+	if (isBooleanLiteral(node)) return {
 		type: "boolean",
 		value: node.value
 	};
-	if (import_lib$1.isNumericLiteral(node)) return {
+	if (isNumericLiteral(node)) return {
 		type: "number",
 		value: node.value
 	};
-	if (import_lib$1.isUnaryExpression(node) && node.operator === "-" && import_lib$1.isNumericLiteral(node.argument)) return {
+	if (isUnaryExpression(node) && node.operator === "-" && isNumericLiteral(node.argument)) return {
 		type: "number",
 		value: -node.argument.value
 	};
-	if (import_lib$1.isStringLiteral(node)) return {
+	if (isStringLiteral(node)) return {
 		type: "string",
 		value: node.value
 	};
-	if (import_lib$1.isTemplateLiteral(node)) {
+	if (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)
@@ -202,19 +120,19 @@ const extractNodeValue = (node) => {
 			value: generateCode(node)
 		};
 	}
-	if (import_lib$1.isNullLiteral(node)) return {
+	if (isNullLiteral(node)) return {
 		type: "null",
 		value: null
 	};
-	if (import_lib$1.isArrayExpression(node)) return {
+	if (isArrayExpression(node)) return {
 		type: "array",
 		value: generateCode(node)
 	};
-	if (import_lib$1.isObjectExpression(node)) return {
+	if (isObjectExpression(node)) return {
 		type: "object",
 		value: generateCode(node)
 	};
-	if (import_lib$1.isJSXElement(node) || import_lib$1.isJSXFragment(node)) return {
+	if (isJSXElement(node) || isJSXFragment(node)) return {
 		type: "string",
 		value: generateCode(node)
 	};
@@ -223,39 +141,10 @@ const extractNodeValue = (node) => {
 		value: null
 	};
 };
-const createNodeFromValue = (type, value) => {
-	switch (type) {
-		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;
-		default: return null;
-	}
-};
-const valueToExpression = (value) => {
-	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$1.objectProperty(import_lib$1.stringLiteral(key), expr));
-		}
-		return import_lib$1.objectExpression(properties);
-	}
-	return null;
-};
 const parseArrayExpression = (value) => {
 	try {
-		const ast = unwrapExpression((0, import_lib.parseExpression)(value, { plugins: ["jsx", "typescript"] }));
-		if (!import_lib$1.isArrayExpression(ast)) return null;
+		const ast = unwrapExpression(parseExpression(value, { plugins: ["jsx", "typescript"] }));
+		if (!isArrayExpression(ast)) return null;
 		return ast;
 	} catch (error) {
 		console.error("❌ Array parsing error:", error);
@@ -265,9 +154,9 @@ const parseArrayExpression = (value) => {
 const extractObjectProperties = (element) => {
 	const properties = {};
 	element.properties.forEach((prop) => {
-		if (import_lib$1.isObjectProperty(prop) && import_lib$1.isIdentifier(prop.key)) {
+		if (isObjectProperty(prop) && isIdentifier(prop.key)) {
 			const key = prop.key.name;
-			if (key === "children" || import_lib$1.isJSXElement(prop.value) || import_lib$1.isJSXFragment(prop.value)) return;
+			if (key === "children" || isJSXElement(prop.value) || isJSXFragment(prop.value)) return;
 			const extracted = extractNodeValue(prop.value);
 			properties[key] = {
 				...extracted,
@@ -277,10 +166,6 @@ const extractObjectProperties = (element) => {
 	});
 	return properties;
 };
-const arrayExpressionToCode = (elements) => {
-	const nextAst = import_lib$1.arrayExpression(elements);
-	return generateCode(nextAst);
-};
 //#endregion
 //#region src/utils/ast/binding.ts
 const bindingTypeSchema = z.enum(BINDING_TYPES);
@@ -442,12 +327,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.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");
+				const expr = parseExpression(dsiAttr.value, { plugins: ["jsx", "typescript"] });
+				if (isObjectExpression(expr)) {
+					const htmlProp = expr.properties.find((p) => isObjectProperty(p) && isIdentifier(p.key) && p.key.name === "__html");
 					if (htmlProp) {
-						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 ?? "";
+						if (isStringLiteral(htmlProp.value)) return htmlProp.value.value;
+						if (isTemplateLiteral(htmlProp.value) && htmlProp.value.expressions.length === 0) return htmlProp.value.quasis[0]?.value.cooked ?? htmlProp.value.quasis[0]?.value.raw ?? "";
 					}
 				}
 			} catch {}
@@ -498,13 +383,13 @@ const findEditableChildren = (node) => {
 //#endregion
 //#region src/utils/ast/extract.ts
 const collectText = (children) => {
-	return children.filter((c) => import_lib$1.isJSXText(c)).map((c) => c.value.trim()).filter((v) => v.length).join(" ");
+	return children.filter((c) => 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$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]));
+	if (parts.length === 1) return jsxIdentifier(parts[0]);
+	let expr = jsxIdentifier(parts[0]);
+	for (let i = 1; i < parts.length; i++) expr = jsxMemberExpression(expr, jsxIdentifier(parts[i]));
 	return expr;
 };
 const extractCache = createBoundedCache(CONFIG.CACHE_LIMIT);
@@ -528,19 +413,19 @@ const extractAttributes = (attributes, source) => {
 	const allAttrs = [];
 	const dataAttrs = [];
 	for (const attr of attributes) {
-		if (!import_lib$1.isJSXAttribute(attr) || !import_lib$1.isJSXIdentifier(attr.name)) continue;
+		if (!isJSXAttribute(attr) || !isJSXIdentifier(attr.name)) continue;
 		const name = attr.name.name;
 		let value = null;
-		let isStringLiteral = false;
+		let isStringLiteral$1 = false;
 		if (attr.value) {
-			if (import_lib$1.isStringLiteral(attr.value)) {
+			if (isStringLiteral(attr.value)) {
 				value = attr.value.value;
-				isStringLiteral = true;
-			} else if (import_lib$1.isJSXExpressionContainer(attr.value)) try {
+				isStringLiteral$1 = true;
+			} else if (isJSXExpressionContainer(attr.value)) try {
 				const expression = attr.value.expression;
-				const structural = import_lib$1.isArrayExpression(unwrapExpression(expression)) || import_lib$1.isObjectExpression(unwrapExpression(expression));
+				const structural = isArrayExpression(unwrapExpression(expression)) || isObjectExpression(unwrapExpression(expression));
 				value = source && structural && expression.start != null && expression.end != null ? source.slice(expression.start, expression.end) : generateCode(expression);
-				isStringLiteral = false;
+				isStringLiteral$1 = false;
 			} catch {
 				value = null;
 			}
@@ -548,7 +433,7 @@ const extractAttributes = (attributes, source) => {
 		const entry = {
 			name,
 			value,
-			isStringLiteral
+			isStringLiteral: isStringLiteral$1
 		};
 		allAttrs.push(entry);
 		if (name.startsWith("data-")) dataAttrs.push(entry);
@@ -560,7 +445,7 @@ const extractAttributes = (attributes, source) => {
 };
 const buildChildElements = (node) => {
 	const childElements = [];
-	if (node.textContent) childElements.push(import_lib$1.jsxText(node.textContent));
+	if (node.textContent) childElements.push(jsxText(node.textContent));
 	node.children?.forEach((child) => {
 		const childJSX = nodeToJSX(child);
 		if (childJSX) childElements.push(childJSX);
@@ -571,22 +456,22 @@ const nodeToJSX = (node) => {
 	try {
 		if (node.isFragment) {
 			const childElements = buildChildElements(node);
-			return import_lib$1.jsxFragment(import_lib$1.jsxOpeningFragment(), import_lib$1.jsxClosingFragment(), childElements);
+			return jsxFragment(jsxOpeningFragment(), 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$1.jsxIdentifier(attr.name);
-			if (!attr.value) return import_lib$1.jsxAttribute(attrName, null);
-			return import_lib$1.jsxAttribute(attrName, attrValue(attr));
+			const attrName = jsxIdentifier(attr.name);
+			if (!attr.value) return jsxAttribute(attrName, null);
+			return jsxAttribute(attrName, attrValue(attr));
 		});
 		const elementName = parseJSXName(node.tagName);
-		const openingElement = import_lib$1.jsxOpeningElement(elementName, attributes);
-		const closingElement = import_lib$1.jsxClosingElement(elementName);
+		const openingElement = jsxOpeningElement(elementName, attributes);
+		const closingElement = jsxClosingElement(elementName);
 		const children = buildChildElements(node);
-		return import_lib$1.jsxElement(openingElement, closingElement, children, false);
+		return jsxElement(openingElement, closingElement, children);
 	} catch (error) {
 		console.error("❌ DataAttrNode to JSX conversion error:", error);
 		return null;
@@ -616,11 +501,11 @@ const createFragmentNode = (textContent, children) => ({
 	isFragment: true
 });
 const processChildrenBinding = (jsxElement, processedNodes, shouldWrap = true, source, options) => {
-	const jsxChildren = jsxElement.children.filter((child) => import_lib$1.isJSXElement(child) || import_lib$1.isJSXFragment(child));
+	const jsxChildren = jsxElement.children.filter((child) => isJSXElement(child) || isJSXFragment(child));
 	if (!jsxChildren.length) return;
 	const childrenNodes = [];
 	jsxChildren.forEach((child) => {
-		if (import_lib$1.isJSXElement(child)) {
+		if (isJSXElement(child)) {
 			const childResults = extractFromNode(child, processedNodes, source, options);
 			if (shouldWrap) {
 				const wrapperNode = createWrapperNode(collectText(child.children), childResults);
@@ -629,11 +514,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$1.isJSXFragment(child)) {
+		} else if (isJSXFragment(child)) {
 			processedNodes?.add(child);
 			const fragmentChildren = [];
 			child.children.forEach((fragmentChild) => {
-				if (import_lib$1.isJSXElement(fragmentChild)) {
+				if (isJSXElement(fragmentChild)) {
 					const childResults = extractFromNode(fragmentChild, processedNodes, source, options);
 					fragmentChildren.push(...childResults);
 				}
@@ -648,26 +533,26 @@ 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$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 itemsAttr = jsxElement.openingElement.attributes.find((attr) => isJSXAttribute(attr) && isJSXIdentifier(attr.name) && attr.name.name === propertyName);
+	if (!itemsAttr || !isJSXAttribute(itemsAttr)) return;
+	if (itemsAttr.value && isJSXExpressionContainer(itemsAttr.value) && isArrayExpression(itemsAttr.value.expression)) itemsAttr.value.expression.elements.forEach((element) => {
+		if (isObjectExpression(element)) element.properties.forEach((prop) => {
+			if (isObjectProperty(prop) && isIdentifier(prop.key) && isJSXElement(prop.value)) markProcessedJSX(prop.value, processedNodes);
 		});
 	});
 };
 const markProcessedJSX = (node, processedNodes) => {
-	if (import_lib$1.isJSXElement(node) || import_lib$1.isJSXFragment(node)) {
+	if (isJSXElement(node) || isJSXFragment(node)) {
 		processedNodes.add(node);
 		node.children.forEach((child) => markProcessedJSX(child, processedNodes));
 		return;
 	}
-	if (import_lib$1.isJSXExpressionContainer(node) || import_lib$1.isParenthesizedExpression(node)) markProcessedJSX(node.expression, processedNodes);
+	if (isJSXExpressionContainer(node) || isParenthesizedExpression(node)) markProcessedJSX(node.expression, processedNodes);
 };
 const getBindingExpression = (opening) => {
-	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)) {
+	for (const attr of opening.attributes) if (isJSXAttribute(attr) && isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.BINDING && attr.value && isJSXExpressionContainer(attr.value)) {
 		const expression = unwrapExpression(attr.value.expression);
-		if (import_lib$1.isArrayExpression(expression)) return expression;
+		if (isArrayExpression(expression)) return expression;
 	}
 	return null;
 };
@@ -696,7 +581,7 @@ const readNodeBindingInfo = (node, source, options) => {
 };
 const parseToNodes = (raw, options) => {
 	const wrapped = wrap(raw);
-	const ast = (0, import_lib.parse)(wrapped, {
+	const ast = parse(wrapped, {
 		sourceType: "module",
 		plugins: ["jsx", "typescript"],
 		errorRecovery: true
@@ -873,7 +758,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.parseExpression)(source, { plugins: ["jsx", "typescript"] });
+	const node = parseExpression(source, { plugins: ["jsx", "typescript"] });
 	const edits = [];
 	const newId = () => {
 		let id = nanoid(12);
@@ -881,15 +766,15 @@ const copySource = (source, usedIds) => {
 		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" }));
+	traverseFast(node, (child) => {
+		if (!isJSXOpeningElement(child)) return;
+		const ids = child.attributes.filter((attr) => isJSXAttribute(attr) && 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 && child.attributes.slice(child.attributes.indexOf(attr) + 1).some((attribute) => 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");
+			if (!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,
@@ -911,7 +796,7 @@ const editChildrenSource = (source, parent, input, options) => {
 	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 children = parent.children.filter((child) => isJSXElement(child) || isJSXFragment(child));
 		const raw = children.map((child) => source.slice(child.start, child.end));
 		const models = extract(source.slice(parent.start, parent.end), options)[0]?.children ?? [];
 		if (models.length !== children.length) return null;
@@ -934,7 +819,7 @@ const editChildrenSource = (source, parent, input, options) => {
 		};
 		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 lossless = raw.every((text, index) => generateCode(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]));
@@ -947,8 +832,8 @@ const editChildrenSource = (source, parent, input, options) => {
 			});
 			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);
+				traverseFast(parseExpression(text, { plugins: ["jsx", "typescript"] }), (node) => {
+					if (isJSXAttribute(node) && isJSXIdentifier(node.name, { name: "data-id" }) && isStringLiteral(node.value)) counts.set(node.value.value, (counts.get(node.value.value) ?? 0) + 1);
 				});
 				return counts;
 			};
@@ -960,8 +845,8 @@ const editChildrenSource = (source, parent, input, options) => {
 		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);
+		traverseFast(parent, (node) => {
+			if (isJSXAttribute(node) && isJSXIdentifier(node.name, { name: "data-id" }) && isStringLiteral(node.value)) usedIds.add(node.value.value);
 		});
 		switch (action.type) {
 			case "move": {
@@ -1007,7 +892,42 @@ const editChildrenSource = (source, parent, input, options) => {
 	}
 };
 //#endregion
-//#region src/utils/ast/update.ts
+//#region src/utils/ast/value-expression.ts
+const createNodeFromValue = (type, value) => {
+	switch (type) {
+		case "boolean": return booleanLiteral(value === true);
+		case "number": return numericLiteral(Number(value));
+		case "string": return stringLiteral(String(value));
+		case "null": return nullLiteral();
+		case "array":
+		case "object":
+		case "unknown": return null;
+		default: return null;
+	}
+};
+const valueToExpression = (value) => {
+	if (typeof value === "string") return stringLiteral(value);
+	if (typeof value === "number") return value < 0 ? unaryExpression("-", numericLiteral(-value)) : numericLiteral(value);
+	if (typeof value === "boolean") return booleanLiteral(value);
+	if (value === null) return nullLiteral();
+	if (Array.isArray(value)) return arrayExpression(value.map((item) => valueToExpression(item) ?? 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(objectProperty(stringLiteral(key), expr));
+		}
+		return objectExpression(properties);
+	}
+	return null;
+};
+const arrayExpressionToCode = (elements) => {
+	const nextAst = arrayExpression(elements);
+	return generateCode(nextAst);
+};
+//#endregion
+//#region src/utils/ast/edit-source.ts
 const childrenRange = (element) => {
 	const { openingElement, closingElement } = element;
 	if (!closingElement || openingElement.end == null || closingElement.start == null) return null;
@@ -1017,7 +937,7 @@ const childrenRange = (element) => {
 	};
 };
 const findAttribute = (opening, propertyName) => {
-	return opening.attributes.find((attr) => import_lib$1.isJSXAttribute(attr) && import_lib$1.isJSXIdentifier(attr.name) && attr.name.name === propertyName);
+	return opening.attributes.find((attr) => isJSXAttribute(attr) && isJSXIdentifier(attr.name) && attr.name.name === propertyName);
 };
 const attributeInsertPoint = (opening) => {
 	return opening.attributes[opening.attributes.length - 1]?.end ?? opening.name.end ?? null;
@@ -1026,7 +946,7 @@ 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) {
+	if (element.children.length === 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;
@@ -1039,7 +959,7 @@ const editInnerText = (source, element, value) => {
 		}
 	}
 	const edits = [];
-	for (const child of element.children) if (import_lib$1.isJSXText(child) && child.start != null && child.end != null) edits.push({
+	for (const child of element.children) if (isJSXText(child) && child.start != null && child.end != null) edits.push({
 		start: child.start,
 		end: child.end,
 		content: ""
@@ -1069,7 +989,7 @@ const editRichtext = (element, value) => {
 		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 attribute = jsxAttribute(jsxIdentifier("dangerouslySetInnerHTML"), jsxExpressionContainer(objectExpression([objectProperty(identifier("__html"), stringLiteral(value))])));
 	const content = generateCode(attribute);
 	const existing = findAttribute(opening, "dangerouslySetInnerHTML");
 	if (existing && existing.start != null && existing.end != null) {
@@ -1108,11 +1028,11 @@ const editJsxAttribute = (opening, propertyName, value) => {
 		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 holdsStructuralExpression = (value) => isJSXExpressionContainer(value) && (isArrayExpression(unwrapExpression(value.expression)) || 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;
+		const expression = parseExpression(value.trim(), { plugins: ["jsx", "typescript"] });
+		return isArrayExpression(unwrapExpression(expression)) || isObjectExpression(unwrapExpression(expression)) ? expression : null;
 	} catch {
 		return null;
 	}
@@ -1120,29 +1040,29 @@ const structuralSource = (value) => {
 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"] }));
+			return jsxExpressionContainer(parseExpression(value.trim(), { plugins: ["jsx", "typescript"] }));
 		} catch {
-			return import_lib$1.stringLiteral(value);
+			return stringLiteral(value);
 		}
 		const expr = valueToExpression(value);
-		return expr ? import_lib$1.jsxExpressionContainer(expr) : import_lib$1.stringLiteral("");
+		return expr ? jsxExpressionContainer(expr) : 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);
+			if (structural) return jsxExpressionContainer(structural);
 		}
-		return import_lib$1.stringLiteral(value);
+		return stringLiteral(value);
 	}
 	const expr = valueToExpression(value);
-	return expr ? import_lib$1.jsxExpressionContainer(expr) : import_lib$1.stringLiteral(String(value));
+	return expr ? jsxExpressionContainer(expr) : 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)) {
+		if (expression && isJSXExpressionContainer(attribute.value)) {
 			const text = value.trim();
 			const lineComment = expression.trailingComments?.some((comment) => comment.type === "CommentLine");
 			return [{
@@ -1152,7 +1072,7 @@ const editAttribute = (opening, propertyName, value, type) => {
 			}];
 		}
 	}
-	const content = generateCode(import_lib$1.jsxAttribute(attribute.name, buildAttributeValue(value, type, attribute.value)));
+	const content = generateCode(jsxAttribute(attribute.name, buildAttributeValue(value, type, attribute.value)));
 	return [{
 		start: attribute.start,
 		end: attribute.end,
@@ -1178,168 +1098,165 @@ const addAttribute = (source, opening, propertyName, value, type) => {
 	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)))}`,
+		content: `${lastStart != null && lineStart > 0 && /^\s*$/.test(source.slice(lineStart, lastStart)) ? "\n" : " "}${type === "jsx" ? `${propertyName}={${String(value).trim()}}` : generateCode(jsxAttribute(jsxIdentifier(propertyName), buildAttributeValue(value, type)))}`,
 		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;
+	if (!isJSXExpressionContainer(attribute.value) || 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;
 };
+//#endregion
+//#region src/utils/ast/update.ts
+const hasDataId = (opening, dataId) => opening.attributes.some((attr) => isJSXAttribute(attr) && isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.ID && attr.value && isStringLiteral(attr.value) && attr.value.value === dataId);
+const findJSXAttribute = (opening, name) => opening.attributes.find((attr) => isJSXAttribute(attr) && isJSXIdentifier(attr.name) && attr.name.name === name);
+const findBinding = (opening, { dataId, label, property, options }) => {
+	const bindingAttr = findJSXAttribute(opening, DATA_ATTR.BINDING);
+	if (bindingAttr && !bindingAttr.value) return { failure: {
+		reason: "no-binding",
+		dataId
+	} };
+	let own;
+	if (bindingAttr?.value) {
+		let bindingValue = "";
+		if (isStringLiteral(bindingAttr.value)) bindingValue = bindingAttr.value.value;
+		else if (isJSXExpressionContainer(bindingAttr.value)) try {
+			bindingValue = generateCode(bindingAttr.value.expression);
+		} catch (error) {
+			return { failure: {
+				reason: "parse-error",
+				error
+			} };
+		}
+		own = parseBinding(bindingValue);
+	}
+	const keyAttr = findJSXAttribute(opening, DATA_ATTR.BINDING_KEY);
+	const bindings = resolveBindings(own, keyAttr && (keyAttr.value && isStringLiteral(keyAttr.value) ? keyAttr.value.value : null), getJSXTagName(opening), options);
+	if (!own && bindings.length === 0) return { failure: {
+		reason: "no-binding",
+		dataId
+	} };
+	const matches = bindings.filter((binding) => property !== void 0 ? binding.property === property : binding.label === label);
+	if (matches.length === 0) return { failure: {
+		reason: "binding-not-declared",
+		dataId,
+		label,
+		property
+	} };
+	if (matches.length > 1) return { failure: {
+		reason: "duplicate-binding",
+		dataId,
+		label,
+		property,
+		count: matches.length
+	} };
+	return { binding: matches[0] };
+};
+const checkEdit = (binding, { dataId, value }) => {
+	const property = binding.property;
+	if (RESERVED_BINDING_PROPERTIES.includes(property)) return {
+		reason: "reserved-property",
+		dataId,
+		property
+	};
+	if (value === void 0 && binding.required) return {
+		reason: "required-property",
+		dataId,
+		property
+	};
+};
+const toElementEdit = (result, onNull) => result ? { edits: result } : { failure: onNull() };
+const editProperty = (source, element, binding, { dataId, value, options }) => {
+	const opening = element.openingElement;
+	const prop = binding.property;
+	const unset = value === void 0;
+	const couldNotUpdate = () => ({
+		reason: "parse-error",
+		error: /* @__PURE__ */ new Error(`could not update "${prop}"`)
+	});
+	const contentWithoutSlot = !unset && String(value) !== "" && !childrenRange(element);
+	switch (prop) {
+		case BINDING_PROP.INNER_TEXT:
+			if (contentWithoutSlot) return { failure: {
+				reason: "self-closing",
+				dataId,
+				property: prop
+			} };
+			return toElementEdit(editInnerText(source, element, unset ? "" : String(value)), couldNotUpdate);
+		case BINDING_PROP.INNER_HTML:
+			if (contentWithoutSlot && binding.type !== "richtext") return { failure: {
+				reason: "self-closing",
+				dataId,
+				property: prop
+			} };
+			return toElementEdit(binding.type === "richtext" ? editRichtext(element, unset ? "" : String(value)) : editInnerHTML(element, unset ? "" : String(value)), couldNotUpdate);
+		case BINDING_PROP.CHILDREN:
+			if (unset) return { failure: {
+				reason: "unsupported-syntax",
+				dataId,
+				property: prop
+			} };
+			return toElementEdit(editChildrenSource(source, element, value, options), () => ({
+				reason: "parse-error",
+				error: /* @__PURE__ */ new Error("Unsupported or stale children edit; source was preserved")
+			}));
+		default: {
+			const attribute = findAttribute(opening, prop);
+			if (unset) return toElementEdit(attribute ? removeAttribute(source, attribute) : [], () => ({
+				reason: "parse-error",
+				error: /* @__PURE__ */ new Error(`could not remove "${prop}"`)
+			}));
+			if (!attribute) return toElementEdit(value === "" ? [] : addAttribute(source, opening, prop, value, binding.type), () => ({
+				reason: "attribute-not-found",
+				dataId,
+				property: prop
+			}));
+			if (binding.type !== "jsx" && !canEditAttributeValue(attribute, value, binding.type)) return { failure: {
+				reason: "unsupported-syntax",
+				dataId,
+				property: prop
+			} };
+			return toElementEdit(binding.type === "jsx" ? editJsxAttribute(opening, prop, value) : editAttribute(opening, prop, value, binding.type), () => ({
+				reason: "attribute-not-found",
+				dataId,
+				property: prop
+			}));
+		}
+	}
+};
+const editElement = (source, element, request) => {
+	const found = findBinding(element.openingElement, request);
+	if ("failure" in found) return found;
+	const refused = checkEdit(found.binding, request);
+	if (refused) return { failure: refused };
+	return editProperty(source, element, found.binding, request);
+};
 const update = (code, dataId, label, value, property, options = {}) => {
+	const request = {
+		dataId,
+		label,
+		value,
+		property,
+		options
+	};
 	try {
 		const wrapped = wrap(code);
-		const ast = (0, import_lib.parse)(wrapped, {
+		const ast = 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 && !bindingAttr.value) {
-				failure = {
-					reason: "no-binding",
-					dataId
-				};
+			if (!hasDataId(path.node.openingElement, dataId)) return;
+			const result = editElement(wrapped, path.node, request);
+			if ("failure" in result) {
+				failure = result.failure;
 				return;
 			}
-			let own;
-			if (bindingAttr?.value) {
-				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;
-				}
-				own = parseBinding(bindingValue);
-			}
-			const keyAttr = opening.attributes.find((attr) => import_lib$1.isJSXAttribute(attr) && import_lib$1.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.BINDING_KEY);
-			const bindings = resolveBindings(own, keyAttr && (keyAttr.value && import_lib$1.isStringLiteral(keyAttr.value) ? keyAttr.value.value : null), getJSXTagName(opening), options);
-			if (!own && bindings.length === 0) {
-				failure = {
-					reason: "no-binding",
-					dataId
-				};
-				return;
-			}
-			const matches = bindings.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;
-			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, 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, 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, options), () => ({
-						reason: "parse-error",
-						error: /* @__PURE__ */ new Error("Unsupported or stale children edit; source was preserved")
-					}));
-					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",
-							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;
-				}
-			}
+			edits.push(...result.edits);
+			changed = true;
 		} });
 		if (!changed) return {
 			code,
@@ -1427,7 +1344,7 @@ const commaIn = (source, start, end) => {
 };
 const denseArraySource = (source) => {
 	const array = parseArrayExpression(source);
-	if (!array || array.elements.some((node) => !import_lib$1.isExpression(node) || node.extra?.parenthesized)) return null;
+	if (!array || array.elements.some((node) => !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;
@@ -1487,9 +1404,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$1.isObjectExpression(element) ? "object" : "primitive";
+const kindOf = (element) => isObjectExpression(element) ? "object" : "primitive";
 const parseItems = (code) => {
-	return elementsOf(code)?.flatMap((node, index) => import_lib$1.isExpression(node) ? [{
+	return elementsOf(code)?.flatMap((node, index) => isExpression(node) ? [{
 		index,
 		kind: kindOf(node),
 		node
@@ -1505,23 +1422,23 @@ const toTemplateRaw = (value) => {
 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({
+		return templateLiteral([templateElement({
 			raw: toTemplateRaw(raw),
 			cooked: raw
 		}, true)], []);
 	}
-	if (renderLeaf?.type === "jsx" || import_lib$1.isJSXElement(current) || import_lib$1.isJSXFragment(current)) {
+	if (renderLeaf?.type === "jsx" || isJSXElement(current) || isJSXFragment(current)) {
 		const trimmed = String(value).trim();
-		if (!trimmed.startsWith("<")) return import_lib$1.stringLiteral(trimmed);
+		if (!trimmed.startsWith("<")) return stringLiteral(trimmed);
 		try {
-			return (0, import_lib.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+			return 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"] });
+			return parseExpression(value, { plugins: ["jsx", "typescript"] });
 		} catch {
 			return;
 		}
@@ -1533,13 +1450,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$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 (!elements || !isObjectExpression(element)) return null;
+	const target = element.properties.find((property) => isObjectProperty(property) && 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);
+	let serialized = typeof value === "string" && (declaredType === "array" || declaredType === "object" || isJSXElement(nextValue) || 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, [{
@@ -1551,7 +1468,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$1.isExpression(element)) return null;
+	if (!elements || !isExpression(element)) return null;
 	const nextValue = createNodeFromValue(extractNodeValue(element).type, parseValue(value));
 	if (!nextValue) return null;
 	return applyEdits(code, [{
@@ -1592,25 +1509,25 @@ const copyItem = (code, element, generateId, usedIds) => {
 		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" }));
+	traverseFast(element, (node) => {
+		if (!isJSXOpeningElement(node)) return;
+		const ids = node.attributes.filter((attr) => isJSXAttribute(attr) && 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)))) {
+		if (ids.length > 1 || attr && (!isStringLiteral(attr.value) || node.attributes.slice(node.attributes.indexOf(attr) + 1).some((a) => isJSXSpreadAttribute(a)))) {
 			unsupported = true;
 			return;
 		}
-		if (attr && import_lib$1.isStringLiteral(attr.value)) edits.push({
+		if (attr && 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" })));
+	if (isObjectExpression(element)) {
+		const keys = element.properties.filter((prop) => isObjectProperty(prop) && !prop.computed && (isIdentifier(prop.key, { name: "key" }) || 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({
+		if (keys.length > 1 || key && (!isStringLiteral(key.value) || element.properties.slice(element.properties.indexOf(key) + 1).some((prop) => isSpreadElement(prop) || "computed" in prop && prop.computed))) return null;
+		if (key && isStringLiteral(key.value)) edits.push({
 			start: key.value.start,
 			end: key.value.end,
 			content: reserveId(`${key.value.value}-${generateId()}`)
@@ -1627,9 +1544,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$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);
+	traverseFast(data.array, (node) => {
+		if (isJSXAttribute(node) && isJSXIdentifier(node.name, { name: "data-id" }) && isStringLiteral(node.value)) usedIds.add(node.value.value);
+		else if (isObjectProperty(node) && !node.computed && (isIdentifier(node.key, { name: "key" }) || isStringLiteral(node.key, { value: "key" })) && 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;
@@ -1639,6 +1556,6 @@ const appendArrayItem = (code, kind, generateId = () => nanoid(6)) => {
 	return index < 0 ? null : duplicateArrayItems(code, /* @__PURE__ */ new Set([index]), generateId);
 };
 //#endregion
-export { extractNodeValue as A, parseBinding as C, arrayExpressionToCode as D, resolveBindings as E, setEditableValue as F, flattenEditableValue as M, parseArrayExpression as N, canLosslesslyEvaluateSource as O, parseValue as P, isComponentTagName as S, readNodeBindings as T, findEditableChildren as _, parseItems as a, getRegistryBindings as b, updateArrayItemValue as c, update as d, updateAll as f, extract as g, clearExtractCache as h, moveArrayItems as i, extractObjectProperties as j, createNodeFromValue as k, canStructurallyEditArray as l, moveSelectedIndices as m, duplicateArrayItems as n, removeArrayItems as o, getChildrenSignatures as p, moveArrayItem as r, updateArrayItemProperty as s, appendArrayItem as t, bulkUpdate as u, getCurrentValue as v, parseBindingExpression as w, getStructuredValue as x, getKeyBindings as y };
+export { extractNodeValue as A, getStructuredValue as C, readNodeBindings as D, parseBindingExpression as E, parseArrayExpression as M, parseValue as N, resolveBindings as O, unwrapExpression as P, getRegistryBindings as S, parseBinding as T, clearExtractCache as _, parseItems as a, getCurrentValue as b, updateArrayItemValue as c, update as d, updateAll as f, moveSelectedIndices as g, getChildrenSignatures as h, moveArrayItems as i, extractObjectProperties as j, canLosslesslyEvaluateSource as k, canStructurallyEditArray as l, createNodeFromValue as m, duplicateArrayItems as n, removeArrayItems as o, arrayExpressionToCode as p, moveArrayItem as r, updateArrayItemProperty as s, appendArrayItem as t, bulkUpdate as u, extract as v, isComponentTagName as w, getKeyBindings as x, findEditableChildren as y };
 
-//# sourceMappingURL=items-DdrwGxJw.js.map
+//# sourceMappingURL=items-BXXtMUNI.js.map