@jbpark/live-editor 4.6.0 → 5.0.0

package/dist/{items-B6OXxcLG.js → update-DNInQSM7.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-CGbe6bSV.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 { $ as jsxOpeningFragment, A as isJSXText, B as isTSSatisfiesExpression, C as isJSXElement, D as isJSXIdentifier, E as isJSXFragment, F as isParenthesizedExpression, G as jsxClosingElement, H as isTemplateLiteral, J as jsxExpressionContainer, K as jsxClosingFragment, L as isStringLiteral, M as isNumericLiteral, N as isObjectExpression, O as isJSXOpeningElement, P as isObjectProperty, Q as jsxOpeningElement, R as isTSAsExpression, S as isJSXAttribute, T as isJSXExpressionContainer, U as isUnaryExpression, V as isTSTypeAssertion, W as jsxAttribute, X as jsxIdentifier, Y as jsxFragment, Z as jsxMemberExpression, _ as identifier, at as stringLiteral, c as traverse, ct as traverseFast, d as applyEdits, dt as parseExpression, et as jsxText, f as getJSXTagName, g as booleanLiteral, h as arrayExpression, it as objectProperty, j as isNullLiteral, k as isJSXSpreadAttribute, lt as unaryExpression, m as generate, nt as numericLiteral, p as nanoid, q as jsxElement, rt as objectExpression, tt as nullLiteral, ut as parse, v as isArrayExpression, w as isJSXEmptyExpression, x as isIdentifier, y as isBooleanLiteral, z as isTSNonNullExpression } from "./document-DcwIEHRV.js";
+import { n as CONFIG, o as REGEX, r as DATA_ATTR, s as RESERVED_BINDING_PROPERTIES, t as BINDING_PROP } from "./constants-D-XKuEY2.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",
@@ -16,9 +14,40 @@ const BINDING_TYPES = [
 	"jsx",
 	"richtext",
 	"date",
-	"url"
+	"url",
+	"email",
+	"tel",
+	"time",
+	"datetime"
 ];
 //#endregion
+//#region src/utils/ast/helpers.ts
+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 stringLiteral(value);
+	const trimmed = value.trim();
+	if (REGEX.NUMBER.test(trimmed)) return jsxExpressionContainer(numericLiteral(parseFloat(trimmed)));
+	if (REGEX.BOOLEAN_OR_NULL.test(trimmed)) {
+		const expr = parseExpression(trimmed, { plugins: ["jsx", "typescript"] });
+		return jsxExpressionContainer(expr);
+	}
+	try {
+		const expr = parseExpression(trimmed, { plugins: ["jsx", "typescript"] });
+		return jsxExpressionContainer(expr);
+	} catch {
+		return 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");
@@ -31,44 +60,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,31 +117,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 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)
@@ -122,19 +151,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)
 	};
@@ -145,8 +174,8 @@ const extractNodeValue = (node) => {
 };
 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);
@@ -156,9 +185,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,
@@ -171,6 +200,8 @@ const extractObjectProperties = (element) => {
 //#endregion
 //#region src/utils/ast/binding.ts
 const bindingTypeSchema = z.enum(BINDING_TYPES);
+const countSchema = z.number().int().nonnegative();
+const dateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2})?$/);
 const bindingOptionSchema = z.object({
 	label: z.string(),
 	value: z.string()
@@ -206,7 +237,16 @@ const KNOWN_BINDING_KEYS = /* @__PURE__ */ new Set([
 	"min",
 	"max",
 	"pattern",
-	"required"
+	"patternMessage",
+	"required",
+	"minLength",
+	"maxLength",
+	"step",
+	"minItems",
+	"maxItems",
+	"minDate",
+	"maxDate",
+	"protocols"
 ]);
 const isPlainObject = (value) => {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -223,7 +263,16 @@ const sanitizeField = (raw) => {
 		min: pick(z.number(), raw.min),
 		max: pick(z.number(), raw.max),
 		pattern: pick(z.string(), raw.pattern),
+		patternMessage: pick(z.string(), raw.patternMessage),
 		required: pick(z.boolean(), raw.required),
+		minLength: pick(countSchema, raw.minLength),
+		maxLength: pick(countSchema, raw.maxLength),
+		step: pick(z.number().positive(), raw.step),
+		minItems: pick(countSchema, raw.minItems),
+		maxItems: pick(countSchema, raw.maxItems),
+		minDate: pick(dateSchema, raw.minDate),
+		maxDate: pick(dateSchema, raw.maxDate),
+		protocols: pick(z.array(z.string().min(1)), raw.protocols),
 		meta: metaEntries.length > 0 ? Object.fromEntries(metaEntries) : void 0
 	};
 	return Object.fromEntries(Object.entries(field).filter(([, value]) => value !== void 0));
@@ -329,12 +378,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 {}
@@ -347,7 +396,11 @@ const getCurrentValue = (node, property) => {
 const STRING_VALUED_TYPES = /* @__PURE__ */ new Set([
 	"string",
 	"url",
+	"email",
+	"tel",
 	"date",
+	"time",
+	"datetime",
 	"color",
 	"jsx",
 	"richtext"
@@ -383,15 +436,42 @@ const findEditableChildren = (node) => {
 	return editableChildren;
 };
 //#endregion
+//#region src/utils/selection.ts
+const removeIndices = (items, indices) => {
+	return items.filter((_, index) => !indices.has(index));
+};
+/**
+* Shifts every selected index up/down by one step as a block, preserving
+* relative order — scattered selections stop moving individually once they
+* hit an unselected neighbor, so the whole group slides together instead of
+* items passing through each other.
+*/
+const moveSelectedIndices = (items, indices, direction) => {
+	const next = [...items];
+	const nextIndices = new Set(indices);
+	const ordered = [...indices].sort((a, b) => direction === "up" ? a - b : b - a);
+	for (const index of ordered) {
+		const target = direction === "up" ? index - 1 : index + 1;
+		if (target < 0 || target >= next.length || nextIndices.has(target)) continue;
+		[next[index], next[target]] = [next[target], next[index]];
+		nextIndices.delete(index);
+		nextIndices.add(target);
+	}
+	return {
+		items: next,
+		indices: nextIndices
+	};
+};
+//#endregion
 //#region src/utils/ast/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);
@@ -415,19 +495,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;
 			}
@@ -435,7 +515,7 @@ const extractAttributes = (attributes, source) => {
 		const entry = {
 			name,
 			value,
-			isStringLiteral
+			isStringLiteral: isStringLiteral$1
 		};
 		allAttrs.push(entry);
 		if (name.startsWith("data-")) dataAttrs.push(entry);
@@ -447,7 +527,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);
@@ -458,22 +538,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;
@@ -503,11 +583,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);
@@ -516,11 +596,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);
 				}
@@ -535,26 +615,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;
 };
@@ -583,7 +663,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
@@ -648,106 +728,6 @@ function clearExtractCache() {
 }
 registerEditorCache(clearExtractCache);
 //#endregion
-//#region src/utils/selection.ts
-const removeIndices = (items, indices) => {
-	return items.filter((_, index) => !indices.has(index));
-};
-/**
-* Shifts every selected index up/down by one step as a block, preserving
-* relative order — scattered selections stop moving individually once they
-* hit an unselected neighbor, so the whole group slides together instead of
-* items passing through each other.
-*/
-const moveSelectedIndices = (items, indices, direction) => {
-	const next = [...items];
-	const nextIndices = new Set(indices);
-	const ordered = [...indices].sort((a, b) => direction === "up" ? a - b : b - a);
-	for (const index of ordered) {
-		const target = direction === "up" ? index - 1 : index + 1;
-		if (target < 0 || target >= next.length || nextIndices.has(target)) continue;
-		[next[index], next[target]] = [next[target], next[index]];
-		nextIndices.delete(index);
-		nextIndices.add(target);
-	}
-	return {
-		items: next,
-		indices: nextIndices
-	};
-};
-//#endregion
-//#region src/utils/ast/patch.ts
-const hasOnlyLayoutNewlines = (content) => {
-	let index = 0;
-	while (index < content.length) {
-		const char = content[index];
-		if (char === "`" || char === "<") return false;
-		if (char === "\"" || char === "'") {
-			const next = skipStringLiteral(content, index);
-			if (next === -1) return false;
-			index = next;
-			continue;
-		}
-		if (char === "/") {
-			const following = content[index + 1];
-			if (following === "/") {
-				const lineEnd = content.indexOf("\n", index + 2);
-				index = lineEnd === -1 ? content.length : lineEnd;
-				continue;
-			}
-			if (following === "*") {
-				const commentEnd = content.indexOf("*/", index + 2);
-				if (commentEnd === -1) return false;
-				index = commentEnd + 2;
-				continue;
-			}
-			return false;
-		}
-		index++;
-	}
-	return true;
-};
-const skipStringLiteral = (content, start) => {
-	const quote = content[start];
-	for (let index = start + 1; index < content.length; index++) {
-		const char = content[index];
-		if (char === "\\") {
-			const escaped = content[index + 1];
-			if (escaped === "\n" || escaped === "\r") return -1;
-			index++;
-			continue;
-		}
-		if (char === quote) return index + 1;
-		if (char === "\n") return -1;
-	}
-	return -1;
-};
-const lineIndentAt = (source, offset) => {
-	const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
-	return /^[ \t]*/.exec(source.slice(lineStart, offset))?.[0] ?? "";
-};
-const lineTerminatorOf = (source) => {
-	return source.includes("\r\n") ? "\r\n" : "\n";
-};
-const applyEdits = (source, edits) => {
-	if (edits.length === 0) return source;
-	const ordered = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
-	for (const edit of ordered) if (!Number.isInteger(edit.start) || !Number.isInteger(edit.end) || edit.start < 0 || edit.end > source.length || edit.start > edit.end) throw new Error(`Invalid source edit [${edit.start}, ${edit.end}) for a source of length ${source.length}`);
-	for (let i = 1; i < ordered.length; i++) {
-		const previous = ordered[i - 1];
-		const current = ordered[i];
-		if (current.start < previous.end) throw new Error(`Overlapping source edits: [${previous.start}, ${previous.end}) and [${current.start}, ${current.end})`);
-	}
-	let result = "";
-	let cursor = 0;
-	const terminator = lineTerminatorOf(source);
-	for (const edit of ordered) {
-		const content = edit.indent && edit.content.includes("\n") && hasOnlyLayoutNewlines(edit.content) ? edit.content.replace(/\n/g, `${terminator}${lineIndentAt(source, edit.start)}`) : edit.content;
-		result += source.slice(cursor, edit.start) + content;
-		cursor = edit.end;
-	}
-	return result + source.slice(cursor);
-};
-//#endregion
 //#region src/utils/ast/children.ts
 const modeledSignatures = (nodes) => nodes.map((node) => {
 	const jsx = nodeToJSX(node);
@@ -760,7 +740,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);
@@ -768,15 +748,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,
@@ -794,11 +774,29 @@ const copySource = (source, usedIds) => {
 	});
 	return applyEdits(source, edits);
 };
+const insertChildren = (source, parent, last, copies) => {
+	const closing = parent.closingElement.start;
+	if (last?.start != null && last.end != null) {
+		const lineStart = source.lastIndexOf("\n", last.start - 1) + 1;
+		const indent = source.slice(lineStart, last.start);
+		const after = /^[ \t]*(\r?\n)/.exec(source.slice(last.end, closing));
+		if (after && /^[ \t]*$/.test(indent)) return {
+			start: last.end,
+			end: last.end,
+			content: copies.map((copy) => `${after[1]}${indent}${copy}`).join("")
+		};
+	}
+	return {
+		start: closing,
+		end: closing,
+		content: copies.join("")
+	};
+};
 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;
@@ -809,19 +807,12 @@ const editChildrenSource = (source, parent, input, options) => {
 				end: child.end,
 				content: next[index] ?? ""
 			}));
-			if (next.length > children.length) {
-				const at = parent.closingElement.start;
-				edits.push({
-					start: at,
-					end: at,
-					content: next.slice(children.length).join("")
-				});
-			}
+			if (next.length > children.length) edits.push(insertChildren(source, parent, children.at(-1), next.slice(children.length)));
 			return edits;
 		};
 		if (Array.isArray(value)) {
 			const desired = modeledSignatures(value);
-			const lossless = raw.every((text, index) => generateCode((0, import_lib.parseExpression)(text, { plugins: ["jsx", "typescript"] })) === signatures[index]);
+			const 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]));
@@ -834,8 +825,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;
 			};
@@ -847,8 +838,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": {
@@ -870,22 +861,12 @@ const editChildrenSource = (source, parent, input, options) => {
 				}));
 			case "duplicate": {
 				if (!indicesAreValid(action.indices, raw.length)) return null;
-				const content = [...action.indices].sort((a, b) => a - b).map((index) => copySource(raw[index], usedIds)).join("");
-				const at = parent.closingElement.start;
-				return [{
-					start: at,
-					end: at,
-					content
-				}];
+				const copies = [...action.indices].sort((a, b) => a - b).map((index) => copySource(raw[index], usedIds));
+				return [insertChildren(source, parent, children.at(-1), copies)];
 			}
 			case "append": {
-				const content = copySource(raw[0] ?? "<div></div>", usedIds);
-				const at = parent.closingElement.start;
-				return [{
-					start: at,
-					end: at,
-					content
-				}];
+				const copy = copySource(raw[0] ?? "<div></div>", usedIds);
+				return [insertChildren(source, parent, children.at(-1), [copy])];
 			}
 			default: return null;
 		}
@@ -897,10 +878,10 @@ const editChildrenSource = (source, parent, input, options) => {
 //#region src/utils/ast/value-expression.ts
 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 "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;
@@ -908,26 +889,22 @@ const createNodeFromValue = (type, value) => {
 	}
 };
 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 === "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(import_lib$1.objectProperty(import_lib$1.stringLiteral(key), expr));
+			properties.push(objectProperty(stringLiteral(key), expr));
 		}
-		return import_lib$1.objectExpression(properties);
+		return objectExpression(properties);
 	}
 	return null;
 };
-const arrayExpressionToCode = (elements) => {
-	const nextAst = import_lib$1.arrayExpression(elements);
-	return generateCode(nextAst);
-};
 //#endregion
 //#region src/utils/ast/edit-source.ts
 const childrenRange = (element) => {
@@ -939,29 +916,33 @@ 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;
 };
+const escapeJsxText = (value) => value.replace(/&(?=#?[A-Za-z0-9]+;)/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\{/g, "&#123;").replace(/\}/g, "&#125;");
 const editInnerText = (source, element, value) => {
 	const range = childrenRange(element);
 	if (!range) return [];
+	const text = escapeJsxText(value);
 	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;
-			const trailing = raw.length - raw.trimEnd().length;
+			const leadingSpace = raw.slice(0, raw.length - raw.trimStart().length);
+			const trailingSpace = raw.slice(raw.trimEnd().length);
+			const leading = /[\r\n]/.test(leadingSpace) ? leadingSpace.length : 0;
+			const trailing = /[\r\n]/.test(trailingSpace) ? trailingSpace.length : 0;
 			return [{
 				start: only.start + leading,
 				end: only.end - trailing,
-				content: value
+				content: text
 			}];
 		}
 	}
 	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: ""
@@ -969,7 +950,7 @@ const editInnerText = (source, element, value) => {
 	edits.push({
 		start: range.end,
 		end: range.end,
-		content: value
+		content: text
 	});
 	return edits;
 };
@@ -991,7 +972,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) {
@@ -1030,41 +1011,54 @@ 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;
 	}
 };
+const hasControlCharacter = (value) => Array.from(value).some((char) => char.charCodeAt(0) < 32);
+const jsxStringValue = (value) => {
+	if (hasControlCharacter(value)) return jsxExpressionContainer(stringLiteral(value));
+	const quote = value.includes("\"") && !value.includes("'") ? "'" : "\"";
+	const text = value.replace(/&(?=#?[A-Za-z0-9]+;)/g, "&amp;");
+	const escaped = quote === "\"" ? text.replace(/"/g, "&quot;") : text;
+	const literal = stringLiteral(value);
+	literal.extra = {
+		raw: `${quote}${escaped}${quote}`,
+		rawValue: value
+	};
+	return literal;
+};
 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 jsxStringValue(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 jsxStringValue(value);
 	}
 	const expr = valueToExpression(value);
-	return expr ? import_lib$1.jsxExpressionContainer(expr) : import_lib$1.stringLiteral(String(value));
+	return expr ? jsxExpressionContainer(expr) : jsxStringValue(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 [{
@@ -1074,7 +1068,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,
@@ -1082,8 +1076,16 @@ const editAttribute = (opening, propertyName, value, type) => {
 		indent: true
 	}];
 };
+const TRAILING_COMMENTS = /^[ \t]*(?:\/\*[^\r\n]*?\*\/[ \t]*)*(?:\/\/[^\r\n]*)?\r?\n/;
 const removeAttribute = (source, attribute) => {
 	if (attribute.start == null || attribute.end == null) return null;
+	const lineStart = source.lastIndexOf("\n", attribute.start - 1) + 1;
+	const rest = TRAILING_COMMENTS.exec(source.slice(attribute.end));
+	if (/^[ \t]*$/.test(source.slice(lineStart, attribute.start)) && rest) return [{
+		start: lineStart,
+		end: attribute.end + rest[0].length,
+		content: ""
+	}];
 	let start = attribute.start;
 	while (start > 0 && /\s/.test(source[start - 1])) start -= 1;
 	return [{
@@ -1100,18 +1102,18 @@ 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) => 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);
-const findJSXAttribute = (opening, name) => opening.attributes.find((attr) => import_lib$1.isJSXAttribute(attr) && import_lib$1.isJSXIdentifier(attr.name) && attr.name.name === name);
+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: {
@@ -1121,8 +1123,8 @@ const findBinding = (opening, { dataId, label, property, options }) => {
 	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 {
+		if (isStringLiteral(bindingAttr.value)) bindingValue = bindingAttr.value.value;
+		else if (isJSXExpressionContainer(bindingAttr.value)) try {
 			bindingValue = generateCode(bindingAttr.value.expression);
 		} catch (error) {
 			return { failure: {
@@ -1133,7 +1135,7 @@ const findBinding = (opening, { dataId, label, property, options }) => {
 		own = parseBinding(bindingValue);
 	}
 	const keyAttr = findJSXAttribute(opening, DATA_ATTR.BINDING_KEY);
-	const bindings = resolveBindings(own, keyAttr && (keyAttr.value && import_lib$1.isStringLiteral(keyAttr.value) ? keyAttr.value.value : null), getJSXTagName(opening), options);
+	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
@@ -1243,7 +1245,7 @@ const update = (code, 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"]
 		});
@@ -1304,260 +1306,7 @@ const updateAll = (raw, entries, options = {}) => {
 		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 = [];
-	for (const entry of entries) {
-		const result = update(current, entry.dataId, entry.label, entry.value, entry.property);
-		current = result.code;
-		if (!result.success && result.failure) failures.push(result.failure);
-	}
-	return failures.length > 0 ? {
-		code: current,
-		success: false,
-		failures
-	} : {
-		code: current,
-		success: true
-	};
-};
-//#endregion
-//#region src/utils/ast/array-source.ts
-const commaIn = (source, start, end) => {
-	let comma = null;
-	for (let at = start; at < end; at++) {
-		if (/\s/.test(source[at])) continue;
-		if (source.startsWith("/*", at)) {
-			const close = source.indexOf("*/", at + 2);
-			if (close < 0 || close + 2 > end) return null;
-			at = close + 1;
-		} else if (source.startsWith("//", at)) {
-			const newline = source.indexOf("\n", at + 2);
-			at = newline < 0 ? end : newline;
-		} else if (source[at] === "," && comma === null) comma = at;
-		else return null;
-	}
-	return comma;
-};
-const denseArraySource = (source) => {
-	const array = parseArrayExpression(source);
-	if (!array || array.elements.some((node) => !import_lib$1.isExpression(node) || node.extra?.parenthesized)) return null;
-	const elements = array.elements;
-	const commas = elements.slice(0, -1).map((node, index) => commaIn(source, node.end, elements[index + 1].start));
-	if (commas.some((comma) => comma === null)) return null;
-	const last = elements.at(-1);
-	return {
-		array,
-		elements,
-		commas,
-		trailing: last ? commaIn(source, last.end, array.end - 1) : null
-	};
-};
-const canStructurallyEditArray = (source) => denseArraySource(source) !== null;
-const validArrayIndices = (indices, length) => [...indices].every((index) => Number.isInteger(index) && index >= 0 && index < length);
-const reorderArraySource = (source, elements, next) => applyEdits(source, elements.map((node, index) => ({
-	start: node.start,
-	end: node.end,
-	content: source.slice(next[index].start, next[index].end)
-})));
-const removeArraySource = (source, data, indices) => {
-	const edits = [];
-	const removedCommas = /* @__PURE__ */ new Set();
-	const { elements, commas, trailing } = data;
-	for (let index = 0; index < elements.length; index++) {
-		if (!indices.has(index)) continue;
-		const start = index;
-		while (index + 1 < elements.length && indices.has(index + 1)) index++;
-		for (let current = start; current <= index; current++) {
-			const node = elements[current];
-			edits.push({
-				start: node.start,
-				end: node.end,
-				content: ""
-			});
-			if (current < elements.length - 1) removedCommas.add(commas[current]);
-		}
-		if (index === elements.length - 1) {
-			if (trailing !== null) removedCommas.add(trailing);
-			else if (start > 0) removedCommas.add(commas[start - 1]);
-		}
-	}
-	for (const comma of removedCommas) edits.push({
-		start: comma,
-		end: comma + 1,
-		content: ""
-	});
-	return applyEdits(source, edits);
-};
-const appendArraySource = (source, data, copies) => {
-	const last = data.elements.at(-1);
-	if (!last || copies.length === 0) return source;
-	return applyEdits(source, [{
-		start: last.end,
-		end: last.end,
-		content: `, ${copies.join(", ")}`
-	}]);
-};
-//#endregion
-//#region src/utils/ast/items.ts
-const elementsOf = (code) => parseArrayExpression(code)?.elements ?? null;
-const kindOf = (element) => import_lib$1.isObjectExpression(element) ? "object" : "primitive";
-const parseItems = (code) => {
-	return elementsOf(code)?.flatMap((node, index) => import_lib$1.isExpression(node) ? [{
-		index,
-		kind: kindOf(node),
-		node
-	}] : []) ?? null;
-};
-const resolveRenderLeaf = (render, key) => {
-	const leaf = render?.[key];
-	return leaf && "type" in leaf ? leaf : null;
-};
-const toTemplateRaw = (value) => {
-	return value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${").replace(/\r/g, "\\r");
-};
-const buildPropertyValue = (value, declaredType, renderLeaf, current) => {
-	if (renderLeaf?.property === BINDING_PROP.INNER_HTML) {
-		const raw = String(value);
-		return import_lib$1.templateLiteral([import_lib$1.templateElement({
-			raw: toTemplateRaw(raw),
-			cooked: raw
-		}, true)], []);
-	}
-	if (renderLeaf?.type === "jsx" || import_lib$1.isJSXElement(current) || import_lib$1.isJSXFragment(current)) {
-		const trimmed = String(value).trim();
-		if (!trimmed.startsWith("<")) return import_lib$1.stringLiteral(trimmed);
-		try {
-			return (0, import_lib.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
-		} catch {
-			return;
-		}
-	}
-	if (declaredType === "array" || declaredType === "object") {
-		if (typeof value === "string") try {
-			return (0, import_lib.parseExpression)(value, { plugins: ["jsx", "typescript"] });
-		} catch {
-			return;
-		}
-		if (!isLosslesslyEvaluable(current)) return;
-		return valueToExpression(value) ?? void 0;
-	}
-	return createNodeFromValue(declaredType, parseValue(value)) ?? void 0;
-};
-const updateArrayItemProperty = (code, index, key, value, render) => {
-	const elements = elementsOf(code);
-	const element = elements?.[index];
-	if (!elements || !import_lib$1.isObjectExpression(element)) return null;
-	const target = element.properties.find((property) => import_lib$1.isObjectProperty(property) && import_lib$1.isIdentifier(property.key) && property.key.name === key);
-	if (!target) return null;
-	const declaredType = extractObjectProperties(element)[key]?.type ?? "string";
-	const nextValue = buildPropertyValue(value, declaredType, resolveRenderLeaf(render, key), target.value);
-	if (!nextValue) return null;
-	let serialized = typeof value === "string" && (declaredType === "array" || declaredType === "object" || import_lib$1.isJSXElement(nextValue) || import_lib$1.isJSXFragment(nextValue)) ? value.trim() : generateCode(nextValue);
-	if (nextValue.trailingComments?.some((comment) => comment.type === "CommentLine")) serialized += "\n";
-	const content = target.shorthand ? `${key}: ${serialized}` : serialized;
-	return applyEdits(code, [{
-		start: target.value.start,
-		end: target.value.end,
-		content
-	}]);
-};
-const updateArrayItemValue = (code, index, value) => {
-	const elements = elementsOf(code);
-	const element = elements?.[index];
-	if (!elements || !import_lib$1.isExpression(element)) return null;
-	const nextValue = createNodeFromValue(extractNodeValue(element).type, parseValue(value));
-	if (!nextValue) return null;
-	return applyEdits(code, [{
-		start: element.start,
-		end: element.end,
-		content: generateCode(nextValue)
-	}]);
-};
-const moveArrayItem = (code, from, to) => {
-	const data = denseArraySource(code);
-	if (!data || !validArrayIndices([from], data.elements.length) || !Number.isInteger(to)) return null;
-	const next = [...data.elements];
-	const [moved] = next.splice(from, 1);
-	next.splice(to, 0, moved);
-	return reorderArraySource(code, data.elements, next);
-};
-const moveArrayItems = (code, indices, direction) => {
-	const data = denseArraySource(code);
-	if (!data || !validArrayIndices(indices, data.elements.length) || !["up", "down"].includes(direction)) return null;
-	const next = moveSelectedIndices(data.elements, indices, direction);
-	return {
-		code: reorderArraySource(code, data.elements, next.items),
-		indices: next.indices
-	};
-};
-const removeArrayItems = (code, indices, kind) => {
-	const data = denseArraySource(code);
-	if (!data || !validArrayIndices(indices, data.elements.length)) return null;
-	const remaining = removeIndices(data.elements, indices);
-	if (!(kind === void 0 ? remaining : remaining.filter((node) => kindOf(node) === kind)).length) return null;
-	return removeArraySource(code, data, indices);
-};
-const copyItem = (code, element, generateId, usedIds) => {
-	const edits = [];
-	let unsupported = false;
-	const reserveId = (id) => {
-		if (usedIds.has(id)) unsupported = true;
-		usedIds.add(id);
-		return JSON.stringify(id);
-	};
-	import_lib$1.traverseFast(element, (node) => {
-		if (!import_lib$1.isJSXOpeningElement(node)) return;
-		const ids = node.attributes.filter((attr) => import_lib$1.isJSXAttribute(attr) && import_lib$1.isJSXIdentifier(attr.name, { name: "data-id" }));
-		const attr = ids[0];
-		if (ids.length > 1 || attr && (!import_lib$1.isStringLiteral(attr.value) || node.attributes.slice(node.attributes.indexOf(attr) + 1).some((a) => import_lib$1.isJSXSpreadAttribute(a)))) {
-			unsupported = true;
-			return;
-		}
-		if (attr && import_lib$1.isStringLiteral(attr.value)) edits.push({
-			start: attr.value.start,
-			end: attr.value.end,
-			content: reserveId(generateId())
-		});
-	});
-	if (import_lib$1.isObjectExpression(element)) {
-		const keys = element.properties.filter((prop) => import_lib$1.isObjectProperty(prop) && !prop.computed && (import_lib$1.isIdentifier(prop.key, { name: "key" }) || import_lib$1.isStringLiteral(prop.key, { value: "key" })));
-		const key = keys[0];
-		if (keys.length > 1 || key && (!import_lib$1.isStringLiteral(key.value) || element.properties.slice(element.properties.indexOf(key) + 1).some((prop) => import_lib$1.isSpreadElement(prop) || "computed" in prop && prop.computed))) return null;
-		if (key && import_lib$1.isStringLiteral(key.value)) edits.push({
-			start: key.value.start,
-			end: key.value.end,
-			content: reserveId(`${key.value.value}-${generateId()}`)
-		});
-	}
-	if (unsupported) return null;
-	return applyEdits(code.slice(element.start, element.end), edits.map((edit) => ({
-		...edit,
-		start: edit.start - element.start,
-		end: edit.end - element.start
-	})));
-};
-const duplicateArrayItems = (code, indices, generateId = () => nanoid(6)) => {
-	const data = denseArraySource(code);
-	if (!data || !indices.size || !validArrayIndices(indices, data.elements.length)) return null;
-	const usedIds = /* @__PURE__ */ new Set();
-	import_lib$1.traverseFast(data.array, (node) => {
-		if (import_lib$1.isJSXAttribute(node) && import_lib$1.isJSXIdentifier(node.name, { name: "data-id" }) && import_lib$1.isStringLiteral(node.value)) usedIds.add(node.value.value);
-		else if (import_lib$1.isObjectProperty(node) && !node.computed && (import_lib$1.isIdentifier(node.key, { name: "key" }) || import_lib$1.isStringLiteral(node.key, { value: "key" })) && import_lib$1.isStringLiteral(node.value)) usedIds.add(node.value.value);
-	});
-	const copies = [...indices].sort((a, b) => a - b).map((index) => copyItem(code, data.elements[index], generateId, usedIds));
-	return copies.every((copy) => copy !== null) ? appendArraySource(code, data, copies) : null;
-};
-const appendArrayItem = (code, kind, generateId = () => nanoid(6)) => {
-	const index = denseArraySource(code)?.elements.findIndex((node) => kindOf(node) === kind) ?? -1;
-	return index < 0 ? null : duplicateArrayItems(code, /* @__PURE__ */ new Set([index]), generateId);
-};
 //#endregion
-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 };
+export { parseArrayExpression as _, getChildrenSignatures as a, generateCode as b, removeIndices as c, getStructuredValue as d, readNodeBindings as f, isLosslesslyEvaluable as g, extractObjectProperties as h, valueToExpression as i, findEditableChildren as l, extractNodeValue as m, updateAll as n, extract as o, canLosslesslyEvaluateSource as p, createNodeFromValue as r, moveSelectedIndices as s, update as t, getCurrentValue as u, parseValue as v, unwrapExpression as y };
 
-//# sourceMappingURL=items-B6OXxcLG.js.map
+//# sourceMappingURL=update-DNInQSM7.js.map