@jbpark/live-editor 4.1.0 → 4.2.0

package/dist/ast-CMD20ykx.js

@@ -0,0 +1,1613 @@
+import { _ as __toESM, d as traverse, f as getJSXTagName, g as require_lib$1, h as require_lib$2, m as require_lib, p as nanoid } from "./document-C3eCRQlj.js";
+import { c as RESERVED_BINDING_PROPERTIES, n as CONFIG, r as DATA_ATTR, s as REGEX, t as BINDING_PROP } from "./constants-CKvdqZtO.js";
+import { n as registerEditorCache } from "./editor-caches-ClMvdcQF.js";
+import { t as createBoundedCache } from "./cache-B0-XcIxJ.js";
+import { z } from "zod";
+//#region src/utils/ast/types.ts
+var import_lib$1 = require_lib$1();
+var import_lib$2 = /* @__PURE__ */ __toESM(require_lib$2(), 1);
+const BINDING_TYPES = [
+	"array",
+	"object",
+	"string",
+	"number",
+	"boolean",
+	"color",
+	"jsx",
+	"richtext",
+	"date",
+	"url"
+];
+//#endregion
+//#region src/utils/ast/helpers.ts
+var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
+const generate = typeof import_lib.default === "function" ? import_lib.default : import_lib.default.default;
+const wrap = (code) => {
+	return `<>${code}</>`;
+};
+const unwrap = (generated) => {
+	return generated.replace(/^<>\s*/g, "").replace(/\s*<\/>\s*;?\s*$/g, "").trim();
+};
+const attrValue = ({ value, isStringLiteral }) => {
+	if (value === null) return null;
+	if (isStringLiteral) return import_lib$2.stringLiteral(value);
+	const trimmed = value.trim();
+	if (REGEX.NUMBER.test(trimmed)) return import_lib$2.jsxExpressionContainer(import_lib$2.numericLiteral(parseFloat(trimmed)));
+	if (REGEX.BOOLEAN_OR_NULL.test(trimmed)) {
+		const expr = (0, import_lib$1.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+		return import_lib$2.jsxExpressionContainer(expr);
+	}
+	try {
+		const expr = (0, import_lib$1.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+		return import_lib$2.jsxExpressionContainer(expr);
+	} catch {
+		return import_lib$2.stringLiteral(trimmed);
+	}
+};
+const generateCode = (node) => {
+	return generate(node, { jsescOption: { minimal: true } }).code;
+};
+//#endregion
+//#region src/utils/ast/value.ts
+const dedent = (str) => {
+	const lines = str.replace(/^\n/, "").replace(/\n\s*$/, "").split("\n");
+	const indent = lines.reduce((min, line) => {
+		if (!line.trim()) return min;
+		const match = line.match(/^(\s*)/);
+		return Math.min(min, match?.[1]?.length ?? 0);
+	}, Infinity);
+	return indent === Infinity ? str.trim() : lines.map((line) => line.slice(indent)).join("\n");
+};
+const unwrapExpression = (node) => {
+	let current = node;
+	while (import_lib$2.isTSAsExpression(current) || import_lib$2.isTSSatisfiesExpression(current) || import_lib$2.isTSNonNullExpression(current) || import_lib$2.isTSTypeAssertion(current) || import_lib$2.isParenthesizedExpression(current)) current = current.expression;
+	return current;
+};
+const isLosslesslyEvaluable = (node) => {
+	const value = unwrapExpression(node);
+	if (import_lib$2.isStringLiteral(value) || import_lib$2.isNumericLiteral(value) || import_lib$2.isBooleanLiteral(value) || import_lib$2.isNullLiteral(value)) return true;
+	if (import_lib$2.isUnaryExpression(value) && value.operator === "-" && import_lib$2.isNumericLiteral(value.argument)) return true;
+	if (import_lib$2.isTemplateLiteral(value)) return value.expressions.length === 0;
+	if (import_lib$2.isArrayExpression(value)) return value.elements.every((element) => element !== null && isLosslesslyEvaluable(element));
+	if (import_lib$2.isObjectExpression(value)) return value.properties.every((property) => import_lib$2.isObjectProperty(property) && !property.computed && (import_lib$2.isIdentifier(property.key) || import_lib$2.isStringLiteral(property.key) || import_lib$2.isNumericLiteral(property.key)) && isLosslesslyEvaluable(property.value));
+	return false;
+};
+const canLosslesslyEvaluateSource = (source) => {
+	try {
+		return isLosslesslyEvaluable((0, import_lib$1.parseExpression)(source, { plugins: ["jsx", "typescript"] }));
+	} catch {
+		return false;
+	}
+};
+const evaluateLiteral = (rawNode) => {
+	const node = unwrapExpression(rawNode);
+	if (import_lib$2.isStringLiteral(node)) return node.value;
+	if (import_lib$2.isNumericLiteral(node)) return node.value;
+	if (import_lib$2.isBooleanLiteral(node)) return node.value;
+	if (import_lib$2.isNullLiteral(node)) return null;
+	if (import_lib$2.isIdentifier(node) && node.name === "undefined") return;
+	if (import_lib$2.isUnaryExpression(node) && node.operator === "-" && import_lib$2.isNumericLiteral(node.argument)) return -node.argument.value;
+	if (import_lib$2.isTemplateLiteral(node) && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? "";
+	if (import_lib$2.isJSXElement(node) || import_lib$2.isJSXFragment(node)) return generateCode(node);
+	if (import_lib$2.isArrayExpression(node)) return node.elements.map((element) => element ? evaluateLiteral(element) : null);
+	if (import_lib$2.isObjectExpression(node)) {
+		const result = {};
+		for (const prop of node.properties) {
+			if (!import_lib$2.isObjectProperty(prop)) continue;
+			let key = null;
+			if (import_lib$2.isIdentifier(prop.key)) key = prop.key.name;
+			else if (import_lib$2.isStringLiteral(prop.key)) key = prop.key.value;
+			else if (import_lib$2.isNumericLiteral(prop.key)) key = String(prop.key.value);
+			if (key === null) continue;
+			result[key] = evaluateLiteral(prop.value);
+		}
+		return result;
+	}
+};
+const parseValue = (value) => {
+	if (typeof value !== "string") return value;
+	const trimmed = value.trim();
+	if (!trimmed) return value;
+	if (REGEX.NUMBER.test(trimmed)) return parseFloat(trimmed);
+	if (REGEX.BOOLEAN_OR_NULL.test(trimmed)) {
+		if (trimmed === "true") return true;
+		if (trimmed === "false") return false;
+		if (trimmed === "null") return null;
+		if (trimmed === "undefined") return;
+	}
+	if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+		try {
+			const ast = (0, import_lib$1.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+			if (import_lib$2.isObjectExpression(ast) || import_lib$2.isArrayExpression(ast)) return evaluateLiteral(ast);
+		} 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 setEditableValue = (value, path, next) => {
+	if (!path.length) return value;
+	const parsed = parseValue(value);
+	if (typeof parsed !== "object" || parsed === null) return value;
+	const root = Array.isArray(parsed) ? [...parsed] : { ...parsed };
+	let cursor = root;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = path[i];
+		const child = cursor[key];
+		if (typeof child !== "object" || child === null) return value;
+		const clonedChild = Array.isArray(child) ? [...child] : { ...child };
+		cursor[key] = clonedChild;
+		cursor = clonedChild;
+	}
+	const lastKey = path[path.length - 1];
+	if (!(lastKey in cursor)) return value;
+	cursor[lastKey] = next;
+	return JSON.stringify(root);
+};
+const extractNodeValue = (node) => {
+	if (import_lib$2.isBooleanLiteral(node)) return {
+		type: "boolean",
+		value: node.value
+	};
+	if (import_lib$2.isNumericLiteral(node)) return {
+		type: "number",
+		value: node.value
+	};
+	if (import_lib$2.isUnaryExpression(node) && node.operator === "-" && import_lib$2.isNumericLiteral(node.argument)) return {
+		type: "number",
+		value: -node.argument.value
+	};
+	if (import_lib$2.isStringLiteral(node)) return {
+		type: "string",
+		value: node.value
+	};
+	if (import_lib$2.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)
+		};
+		return {
+			type: "string",
+			value: generateCode(node)
+		};
+	}
+	if (import_lib$2.isNullLiteral(node)) return {
+		type: "null",
+		value: null
+	};
+	if (import_lib$2.isArrayExpression(node)) return {
+		type: "array",
+		value: generateCode(node)
+	};
+	if (import_lib$2.isObjectExpression(node)) return {
+		type: "object",
+		value: generateCode(node)
+	};
+	if (import_lib$2.isJSXElement(node) || import_lib$2.isJSXFragment(node)) return {
+		type: "string",
+		value: generateCode(node)
+	};
+	return {
+		type: "unknown",
+		value: null
+	};
+};
+const createNodeFromValue = (type, value) => {
+	switch (type) {
+		case "boolean": return import_lib$2.booleanLiteral(value === true);
+		case "number": return import_lib$2.numericLiteral(Number(value));
+		case "string": return import_lib$2.stringLiteral(String(value));
+		case "null": return import_lib$2.nullLiteral();
+		case "array":
+		case "object":
+		case "unknown": return null;
+		default: return null;
+	}
+};
+const valueToExpression = (value) => {
+	if (typeof value === "string") return import_lib$2.stringLiteral(value);
+	if (typeof value === "number") return value < 0 ? import_lib$2.unaryExpression("-", import_lib$2.numericLiteral(-value)) : import_lib$2.numericLiteral(value);
+	if (typeof value === "boolean") return import_lib$2.booleanLiteral(value);
+	if (value === null) return import_lib$2.nullLiteral();
+	if (Array.isArray(value)) return import_lib$2.arrayExpression(value.map((item) => valueToExpression(item) ?? import_lib$2.nullLiteral()));
+	if (typeof value === "object") {
+		const properties = [];
+		for (const [key, item] of Object.entries(value)) {
+			const expr = valueToExpression(item);
+			if (expr === null) continue;
+			properties.push(import_lib$2.objectProperty(import_lib$2.stringLiteral(key), expr));
+		}
+		return import_lib$2.objectExpression(properties);
+	}
+	return null;
+};
+const parseArrayExpression = (value) => {
+	try {
+		const ast = unwrapExpression((0, import_lib$1.parseExpression)(value, { plugins: ["jsx", "typescript"] }));
+		if (!import_lib$2.isArrayExpression(ast)) return null;
+		return ast;
+	} catch (error) {
+		console.error("❌ Array parsing error:", error);
+		return null;
+	}
+};
+const extractObjectProperties = (element) => {
+	const properties = {};
+	element.properties.forEach((prop) => {
+		if (import_lib$2.isObjectProperty(prop) && import_lib$2.isIdentifier(prop.key)) {
+			const key = prop.key.name;
+			if (key === "children" || import_lib$2.isJSXElement(prop.value) || import_lib$2.isJSXFragment(prop.value)) return;
+			const extracted = extractNodeValue(prop.value);
+			properties[key] = {
+				...extracted,
+				astNode: prop.value
+			};
+		}
+	});
+	return properties;
+};
+const arrayExpressionToCode = (elements) => {
+	const nextAst = import_lib$2.arrayExpression(elements);
+	return generateCode(nextAst);
+};
+//#endregion
+//#region src/utils/ast/binding.ts
+const bindingTypeSchema = z.enum(BINDING_TYPES);
+const bindingOptionSchema = z.object({
+	label: z.string(),
+	value: z.string()
+});
+const bindingWidgetSchema = z.object({
+	type: z.string().min(1),
+	step: z.number().optional(),
+	unit: z.string().optional()
+}).passthrough();
+const pick = (schema, value) => {
+	const parsed = schema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+};
+const sanitizeWidget = (value) => {
+	if (typeof value === "string") return value ? { type: value } : void 0;
+	return pick(bindingWidgetSchema, value);
+};
+const sanitizeOptions = (value) => {
+	if (!Array.isArray(value)) return;
+	const options = value.flatMap((option) => {
+		const parsed = pick(bindingOptionSchema, option);
+		return parsed ? [parsed] : [];
+	});
+	return options.length > 0 ? options : void 0;
+};
+const KNOWN_BINDING_KEYS = /* @__PURE__ */ new Set([
+	"label",
+	"property",
+	"type",
+	"widget",
+	"options",
+	"render",
+	"min",
+	"max",
+	"pattern",
+	"required"
+]);
+const isPlainObject = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const sanitizeField = (raw) => {
+	const metaEntries = Object.entries(raw).filter(([key]) => !KNOWN_BINDING_KEYS.has(key));
+	const field = {
+		label: pick(z.string(), raw.label),
+		property: pick(z.string(), raw.property),
+		type: pick(bindingTypeSchema, raw.type),
+		widget: sanitizeWidget(raw.widget),
+		options: sanitizeOptions(raw.options),
+		render: sanitizeRenderMap(raw.render),
+		min: pick(z.number(), raw.min),
+		max: pick(z.number(), raw.max),
+		pattern: pick(z.string(), raw.pattern),
+		required: pick(z.boolean(), raw.required),
+		meta: metaEntries.length > 0 ? Object.fromEntries(metaEntries) : void 0
+	};
+	return Object.fromEntries(Object.entries(field).filter(([, value]) => value !== void 0));
+};
+function sanitizeRenderMap(value) {
+	if (!isPlainObject(value)) return;
+	const map = {};
+	for (const [key, raw] of Object.entries(value)) {
+		if (!isPlainObject(raw)) continue;
+		if ("type" in raw) {
+			map[key] = {
+				type: void 0,
+				...sanitizeField(raw)
+			};
+			continue;
+		}
+		const nested = sanitizeRenderMap(raw);
+		if (nested) map[key] = nested;
+	}
+	return Object.keys(map).length > 0 ? map : void 0;
+}
+const buildBindingItems = (raw) => {
+	if (!Array.isArray(raw)) return [];
+	return raw.flatMap((rawItem) => {
+		if (!isPlainObject(rawItem)) return [];
+		const { label, property, ...field } = sanitizeField(rawItem);
+		if (label === void 0) return [];
+		if (property === void 0 && field.type !== "richtext") return [];
+		return [{
+			label,
+			property: property ?? BINDING_PROP.INNER_HTML,
+			...field
+		}];
+	});
+};
+const parseBinding = (bindingValue) => {
+	if (!bindingValue) return [];
+	const ast = parseArrayExpression(bindingValue);
+	if (!ast) return [];
+	return buildBindingItems(evaluateLiteral(ast));
+};
+const parseBindingExpression = (expression) => buildBindingItems(evaluateLiteral(expression));
+const getCurrentValue = (node, property) => {
+	switch (property) {
+		case BINDING_PROP.INNER_TEXT: return node.textContent || "";
+		case BINDING_PROP.INNER_HTML: {
+			const dsiAttr = node.attributes.find((a) => a.name === "dangerouslySetInnerHTML");
+			if (dsiAttr?.value) try {
+				const expr = (0, import_lib$1.parseExpression)(dsiAttr.value, { plugins: ["jsx", "typescript"] });
+				if (import_lib$2.isObjectExpression(expr)) {
+					const htmlProp = expr.properties.find((p) => import_lib$2.isObjectProperty(p) && import_lib$2.isIdentifier(p.key) && p.key.name === "__html");
+					if (htmlProp) {
+						if (import_lib$2.isStringLiteral(htmlProp.value)) return htmlProp.value.value;
+						if (import_lib$2.isTemplateLiteral(htmlProp.value) && htmlProp.value.expressions.length === 0) return htmlProp.value.quasis[0]?.value.cooked ?? htmlProp.value.quasis[0]?.value.raw ?? "";
+					}
+				}
+			} catch {}
+			return node.rawChildren || node.textContent || "";
+		}
+		case BINDING_PROP.CHILDREN: return JSON.stringify(node?.children || []);
+		default: return node.attributes.find((attr) => attr.name === property)?.value || "";
+	}
+};
+const STRING_VALUED_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"url",
+	"date",
+	"color",
+	"jsx",
+	"richtext"
+]);
+const getStructuredValue = (node, property, type) => {
+	switch (property) {
+		case BINDING_PROP.INNER_TEXT:
+		case BINDING_PROP.INNER_HTML: return getCurrentValue(node, property);
+		case BINDING_PROP.CHILDREN: return node.children ?? [];
+		default: {
+			const raw = getCurrentValue(node, property);
+			if (node.attributes.find((a) => a.name === property)?.isStringLiteral || type && STRING_VALUED_TYPES.has(type)) return raw;
+			return parseValue(raw);
+		}
+	}
+};
+const hasEditableBindings = (node) => {
+	const bindingAttr = node.dataAttributes.find((attr) => attr.name === DATA_ATTR.BINDING);
+	if (!bindingAttr?.value) return false;
+	return (node.bindings || parseBinding(bindingAttr.value)).length > 0;
+};
+const findEditableChildren = (node) => {
+	const editableChildren = [];
+	const traverse = (children) => {
+		if (!children) return;
+		for (const child of children) {
+			if (hasEditableBindings(child)) editableChildren.push(child);
+			traverse(child.children);
+		}
+	};
+	traverse(node.children);
+	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/patch.ts
+const hasOnlyLayoutNewlines = (content) => {
+	let index = 0;
+	while (index < content.length) {
+		const char = content[index];
+		if (char === "`" || char === "<") return false;
+		if (char === "\"" || char === "'") {
+			const next = skipStringLiteral(content, index);
+			if (next === -1) return false;
+			index = next;
+			continue;
+		}
+		if (char === "/") {
+			const following = content[index + 1];
+			if (following === "/") {
+				const lineEnd = content.indexOf("\n", index + 2);
+				index = lineEnd === -1 ? content.length : lineEnd;
+				continue;
+			}
+			if (following === "*") {
+				const commentEnd = content.indexOf("*/", index + 2);
+				if (commentEnd === -1) return false;
+				index = commentEnd + 2;
+				continue;
+			}
+			return false;
+		}
+		index++;
+	}
+	return true;
+};
+const skipStringLiteral = (content, start) => {
+	const quote = content[start];
+	for (let index = start + 1; index < content.length; index++) {
+		const char = content[index];
+		if (char === "\\") {
+			const escaped = content[index + 1];
+			if (escaped === "\n" || escaped === "\r") return -1;
+			index++;
+			continue;
+		}
+		if (char === quote) return index + 1;
+		if (char === "\n") return -1;
+	}
+	return -1;
+};
+const lineIndentAt = (source, offset) => {
+	const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
+	return /^[ \t]*/.exec(source.slice(lineStart, offset))?.[0] ?? "";
+};
+const lineTerminatorOf = (source) => {
+	return source.includes("\r\n") ? "\r\n" : "\n";
+};
+const applyEdits = (source, edits) => {
+	if (edits.length === 0) return source;
+	const ordered = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
+	for (const edit of ordered) if (!Number.isInteger(edit.start) || !Number.isInteger(edit.end) || edit.start < 0 || edit.end > source.length || edit.start > edit.end) throw new Error(`Invalid source edit [${edit.start}, ${edit.end}) for a source of length ${source.length}`);
+	for (let i = 1; i < ordered.length; i++) {
+		const previous = ordered[i - 1];
+		const current = ordered[i];
+		if (current.start < previous.end) throw new Error(`Overlapping source edits: [${previous.start}, ${previous.end}) and [${current.start}, ${current.end})`);
+	}
+	let result = "";
+	let cursor = 0;
+	const terminator = lineTerminatorOf(source);
+	for (const edit of ordered) {
+		const content = edit.indent && edit.content.includes("\n") && hasOnlyLayoutNewlines(edit.content) ? edit.content.replace(/\n/g, `${terminator}${lineIndentAt(source, edit.start)}`) : edit.content;
+		result += source.slice(cursor, edit.start) + content;
+		cursor = edit.end;
+	}
+	return result + source.slice(cursor);
+};
+//#endregion
+//#region src/utils/ast/array-source.ts
+const commaIn = (source, start, end) => {
+	let comma = null;
+	for (let at = start; at < end; at++) {
+		if (/\s/.test(source[at])) continue;
+		if (source.startsWith("/*", at)) {
+			const close = source.indexOf("*/", at + 2);
+			if (close < 0 || close + 2 > end) return null;
+			at = close + 1;
+		} else if (source.startsWith("//", at)) {
+			const newline = source.indexOf("\n", at + 2);
+			at = newline < 0 ? end : newline;
+		} else if (source[at] === "," && comma === null) comma = at;
+		else return null;
+	}
+	return comma;
+};
+const denseArraySource = (source) => {
+	const array = parseArrayExpression(source);
+	if (!array || array.elements.some((node) => !import_lib$2.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$2.isObjectExpression(element) ? "object" : "primitive";
+const parseItems = (code) => {
+	return elementsOf(code)?.flatMap((node, index) => import_lib$2.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$2.templateLiteral([import_lib$2.templateElement({
+			raw: toTemplateRaw(raw),
+			cooked: raw
+		}, true)], []);
+	}
+	if (renderLeaf?.type === "jsx" || import_lib$2.isJSXElement(current) || import_lib$2.isJSXFragment(current)) {
+		const trimmed = String(value).trim();
+		if (!trimmed.startsWith("<")) return import_lib$2.stringLiteral(trimmed);
+		try {
+			return (0, import_lib$1.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+		} catch {
+			return;
+		}
+	}
+	if (declaredType === "array" || declaredType === "object") {
+		if (typeof value === "string") try {
+			return (0, import_lib$1.parseExpression)(value, { plugins: ["jsx", "typescript"] });
+		} 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$2.isObjectExpression(element)) return null;
+	const target = element.properties.find((property) => import_lib$2.isObjectProperty(property) && import_lib$2.isIdentifier(property.key) && property.key.name === key);
+	if (!target) return null;
+	const declaredType = extractObjectProperties(element)[key]?.type ?? "string";
+	const nextValue = buildPropertyValue(value, declaredType, resolveRenderLeaf(render, key), target.value);
+	if (!nextValue) return null;
+	let serialized = typeof value === "string" && (declaredType === "array" || declaredType === "object" || import_lib$2.isJSXElement(nextValue) || import_lib$2.isJSXFragment(nextValue)) ? value.trim() : generateCode(nextValue);
+	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$2.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$2.traverseFast(element, (node) => {
+		if (!import_lib$2.isJSXOpeningElement(node)) return;
+		const ids = node.attributes.filter((attr) => import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name, { name: "data-id" }));
+		const attr = ids[0];
+		if (ids.length > 1 || attr && (!import_lib$2.isStringLiteral(attr.value) || node.attributes.slice(node.attributes.indexOf(attr) + 1).some((a) => import_lib$2.isJSXSpreadAttribute(a)))) {
+			unsupported = true;
+			return;
+		}
+		if (attr && import_lib$2.isStringLiteral(attr.value)) edits.push({
+			start: attr.value.start,
+			end: attr.value.end,
+			content: reserveId(generateId())
+		});
+	});
+	if (import_lib$2.isObjectExpression(element)) {
+		const keys = element.properties.filter((prop) => import_lib$2.isObjectProperty(prop) && !prop.computed && (import_lib$2.isIdentifier(prop.key, { name: "key" }) || import_lib$2.isStringLiteral(prop.key, { value: "key" })));
+		const key = keys[0];
+		if (keys.length > 1 || key && (!import_lib$2.isStringLiteral(key.value) || element.properties.slice(element.properties.indexOf(key) + 1).some((prop) => import_lib$2.isSpreadElement(prop) || "computed" in prop && prop.computed))) return null;
+		if (key && import_lib$2.isStringLiteral(key.value)) edits.push({
+			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$2.traverseFast(data.array, (node) => {
+		if (import_lib$2.isJSXAttribute(node) && import_lib$2.isJSXIdentifier(node.name, { name: "data-id" }) && import_lib$2.isStringLiteral(node.value)) usedIds.add(node.value.value);
+		else if (import_lib$2.isObjectProperty(node) && !node.computed && (import_lib$2.isIdentifier(node.key, { name: "key" }) || import_lib$2.isStringLiteral(node.key, { value: "key" })) && import_lib$2.isStringLiteral(node.value)) usedIds.add(node.value.value);
+	});
+	const copies = [...indices].sort((a, b) => a - b).map((index) => copyItem(code, data.elements[index], generateId, usedIds));
+	return copies.every((copy) => copy !== null) ? appendArraySource(code, data, copies) : null;
+};
+const appendArrayItem = (code, kind, generateId = () => nanoid(6)) => {
+	const index = denseArraySource(code)?.elements.findIndex((node) => kindOf(node) === kind) ?? -1;
+	return index < 0 ? null : duplicateArrayItems(code, /* @__PURE__ */ new Set([index]), generateId);
+};
+//#endregion
+//#region src/utils/ast/extract.ts
+const collectText = (children) => {
+	return children.filter((c) => import_lib$2.isJSXText(c)).map((c) => c.value.trim()).filter((v) => v.length).join(" ");
+};
+const parseJSXName = (tagName) => {
+	const parts = tagName.split(".");
+	if (parts.length === 1) return import_lib$2.jsxIdentifier(parts[0]);
+	let expr = import_lib$2.jsxIdentifier(parts[0]);
+	for (let i = 1; i < parts.length; i++) expr = import_lib$2.jsxMemberExpression(expr, import_lib$2.jsxIdentifier(parts[i]));
+	return expr;
+};
+const extractCache = createBoundedCache(CONFIG.CACHE_LIMIT);
+const extractAttributes = (attributes, source) => {
+	const allAttrs = [];
+	const dataAttrs = [];
+	for (const attr of attributes) {
+		if (!import_lib$2.isJSXAttribute(attr) || !import_lib$2.isJSXIdentifier(attr.name)) continue;
+		const name = attr.name.name;
+		let value = null;
+		let isStringLiteral = false;
+		if (attr.value) {
+			if (import_lib$2.isStringLiteral(attr.value)) {
+				value = attr.value.value;
+				isStringLiteral = true;
+			} else if (import_lib$2.isJSXExpressionContainer(attr.value)) try {
+				const expression = attr.value.expression;
+				const structural = import_lib$2.isArrayExpression(unwrapExpression(expression)) || import_lib$2.isObjectExpression(unwrapExpression(expression));
+				value = source && structural && expression.start != null && expression.end != null ? source.slice(expression.start, expression.end) : generateCode(expression);
+				isStringLiteral = false;
+			} catch {
+				value = null;
+			}
+		}
+		const entry = {
+			name,
+			value,
+			isStringLiteral
+		};
+		allAttrs.push(entry);
+		if (name.startsWith("data-")) dataAttrs.push(entry);
+	}
+	return {
+		allAttrs,
+		dataAttrs
+	};
+};
+const buildChildElements = (node) => {
+	const childElements = [];
+	if (node.textContent) childElements.push(import_lib$2.jsxText(node.textContent));
+	node.children?.forEach((child) => {
+		const childJSX = nodeToJSX(child);
+		if (childJSX) childElements.push(childJSX);
+	});
+	return childElements;
+};
+const nodeToJSX = (node) => {
+	try {
+		if (node.isFragment) {
+			const childElements = buildChildElements(node);
+			return import_lib$2.jsxFragment(import_lib$2.jsxOpeningFragment(), import_lib$2.jsxClosingFragment(), childElements);
+		}
+		if (node.tagName === "div" && node.dataAttributes.some((attr) => attr.name === "data-item")) {
+			if (node.children) return nodeToJSX(node.children[0]);
+			return null;
+		}
+		const attributes = node.attributes.map((attr) => {
+			const attrName = import_lib$2.jsxIdentifier(attr.name);
+			if (!attr.value) return import_lib$2.jsxAttribute(attrName, null);
+			return import_lib$2.jsxAttribute(attrName, attrValue(attr));
+		});
+		const elementName = parseJSXName(node.tagName);
+		const openingElement = import_lib$2.jsxOpeningElement(elementName, attributes);
+		const closingElement = import_lib$2.jsxClosingElement(elementName);
+		const children = buildChildElements(node);
+		return import_lib$2.jsxElement(openingElement, closingElement, children, false);
+	} catch (error) {
+		console.error("❌ DataAttrNode to JSX conversion error:", error);
+		return null;
+	}
+};
+const createWrapperNode = (textContent, children) => ({
+	tagName: "div",
+	id: nanoid(6),
+	attributes: [{
+		name: DATA_ATTR.ITEM,
+		value: "true"
+	}],
+	dataAttributes: [{
+		name: DATA_ATTR.ITEM,
+		value: "true"
+	}],
+	textContent,
+	children
+});
+const createFragmentNode = (textContent, children) => ({
+	tagName: "",
+	id: nanoid(6),
+	attributes: [],
+	dataAttributes: [],
+	textContent,
+	children,
+	isFragment: true
+});
+const processChildrenBinding = (jsxElement, processedNodes, shouldWrap = true, source) => {
+	const jsxChildren = jsxElement.children.filter((child) => import_lib$2.isJSXElement(child) || import_lib$2.isJSXFragment(child));
+	if (!jsxChildren.length) return;
+	const childrenNodes = [];
+	jsxChildren.forEach((child) => {
+		if (import_lib$2.isJSXElement(child)) {
+			const childResults = extractFromNode(child, processedNodes, source);
+			if (shouldWrap) {
+				const wrapperNode = createWrapperNode(collectText(child.children), childResults);
+				wrapperNode.source = source?.slice(child.start, child.end);
+				const dataId = childResults[0]?.dataAttributes.find((attr) => attr.name === DATA_ATTR.ID)?.value;
+				if (dataId) wrapperNode.id = `child:${dataId}`;
+				childrenNodes.push(wrapperNode);
+			} else childrenNodes.push(...childResults);
+		} else if (import_lib$2.isJSXFragment(child)) {
+			processedNodes?.add(child);
+			const fragmentChildren = [];
+			child.children.forEach((fragmentChild) => {
+				if (import_lib$2.isJSXElement(fragmentChild)) {
+					const childResults = extractFromNode(fragmentChild, processedNodes, source);
+					fragmentChildren.push(...childResults);
+				}
+			});
+			if (fragmentChildren.length) {
+				const fragmentNode = createFragmentNode(collectText(child.children), fragmentChildren);
+				fragmentNode.source = source?.slice(child.start, child.end);
+				childrenNodes.push(fragmentNode);
+			}
+		}
+	});
+	return childrenNodes.length ? childrenNodes : void 0;
+};
+const skipItemsChildren = (jsxElement, processedNodes, propertyName = "items") => {
+	const itemsAttr = jsxElement.openingElement.attributes.find((attr) => import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === propertyName);
+	if (!itemsAttr || !import_lib$2.isJSXAttribute(itemsAttr)) return;
+	if (itemsAttr.value && import_lib$2.isJSXExpressionContainer(itemsAttr.value) && import_lib$2.isArrayExpression(itemsAttr.value.expression)) itemsAttr.value.expression.elements.forEach((element) => {
+		if (import_lib$2.isObjectExpression(element)) element.properties.forEach((prop) => {
+			if (import_lib$2.isObjectProperty(prop) && import_lib$2.isIdentifier(prop.key) && import_lib$2.isJSXElement(prop.value)) markProcessedJSX(prop.value, processedNodes);
+		});
+	});
+};
+const markProcessedJSX = (node, processedNodes) => {
+	if (import_lib$2.isJSXElement(node) || import_lib$2.isJSXFragment(node)) {
+		processedNodes.add(node);
+		node.children.forEach((child) => markProcessedJSX(child, processedNodes));
+		return;
+	}
+	if (import_lib$2.isJSXExpressionContainer(node) || import_lib$2.isParenthesizedExpression(node)) markProcessedJSX(node.expression, processedNodes);
+};
+const getBindingExpression = (opening) => {
+	for (const attr of opening.attributes) if (import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.BINDING && attr.value && import_lib$2.isJSXExpressionContainer(attr.value)) {
+		const expression = unwrapExpression(attr.value.expression);
+		if (import_lib$2.isArrayExpression(expression)) return expression;
+	}
+	return null;
+};
+const readNodeBindingInfo = (node, source) => {
+	const opening = node.openingElement;
+	const tagName = getJSXTagName(opening);
+	const { allAttrs, dataAttrs } = extractAttributes(opening.attributes, source);
+	const bindingAttr = dataAttrs.find((attr) => attr.name === DATA_ATTR.BINDING);
+	const bindingExpr = getBindingExpression(opening);
+	const bindings = bindingExpr ? parseBindingExpression(bindingExpr) : bindingAttr?.value ? parseBinding(bindingAttr.value) : [];
+	const childrenBinding = bindings.find((b) => b.property === BINDING_PROP.CHILDREN);
+	const arrayBindings = bindings.filter((b) => b.property === BINDING_PROP.ITEMS || b.type === "array");
+	const innerHtmlBinding = bindings.find((b) => b.property === BINDING_PROP.INNER_HTML);
+	let rawChildren;
+	if (innerHtmlBinding && node.children.length > 0) rawChildren = node.children.map((child) => generateCode(child)).join("").trim();
+	return {
+		tagName,
+		allAttrs,
+		dataAttrs,
+		bindings,
+		childrenBinding,
+		arrayBindings,
+		rawChildren
+	};
+};
+const parseToNodes = (raw) => {
+	const wrapped = wrap(raw);
+	const ast = (0, import_lib$1.parse)(wrapped, {
+		sourceType: "module",
+		plugins: ["jsx", "typescript"],
+		errorRecovery: true
+	});
+	const results = [];
+	const processedNodes = /* @__PURE__ */ new WeakSet();
+	traverse(ast, { JSXElement(path) {
+		if (processedNodes.has(path.node)) return;
+		const { tagName, allAttrs, dataAttrs, bindings, childrenBinding, arrayBindings, rawChildren } = readNodeBindingInfo(path.node, wrapped);
+		if (!tagName || !dataAttrs.length) return;
+		let childrenNodes;
+		if (childrenBinding) childrenNodes = processChildrenBinding(path.node, processedNodes, true, wrapped);
+		for (const arrayBinding of arrayBindings) skipItemsChildren(path.node, processedNodes, arrayBinding.property);
+		results.push({
+			tagName,
+			attributes: allAttrs,
+			dataAttributes: dataAttrs,
+			textContent: collectText(path.node.children),
+			rawChildren,
+			children: childrenNodes,
+			bindings,
+			loc: path.node.loc ? {
+				start: {
+					line: path.node.loc.start.line,
+					column: path.node.loc.start.column
+				},
+				end: {
+					line: path.node.loc.end.line,
+					column: path.node.loc.end.column
+				}
+			} : void 0
+		});
+	} });
+	return results;
+};
+function extract(raw) {
+	if (extractCache.has(raw)) return extractCache.get(raw);
+	const results = parseToNodes(raw);
+	extractCache.set(raw, results);
+	return results;
+}
+function extractFromNode(node, processedNodes, source) {
+	processedNodes?.add(node);
+	const { tagName, allAttrs, dataAttrs, bindings, childrenBinding, rawChildren } = readNodeBindingInfo(node, source);
+	let childrenNodes;
+	if (childrenBinding) childrenNodes = processChildrenBinding(node, processedNodes, true, source);
+	if (!childrenNodes) childrenNodes = processChildrenBinding(node, processedNodes, false, source);
+	return [{
+		tagName,
+		attributes: allAttrs,
+		dataAttributes: dataAttrs,
+		textContent: collectText(node.children),
+		rawChildren,
+		children: childrenNodes,
+		bindings
+	}];
+}
+function clearExtractCache() {
+	extractCache.clear();
+}
+registerEditorCache(clearExtractCache);
+//#endregion
+//#region src/utils/ast/children.ts
+const modeledSignatures = (nodes) => nodes.map((node) => {
+	const jsx = nodeToJSX(node);
+	if (!jsx) throw new Error("Invalid child node");
+	return generateCode(jsx);
+});
+const getChildrenSignatures = (nodes) => {
+	const modeled = modeledSignatures(nodes);
+	return nodes.map((node, index) => JSON.stringify([node.source ?? null, modeled[index]]));
+};
+const indicesAreValid = (indices, count) => Array.isArray(indices) && new Set(indices).size === indices.length && indices.every((index) => Number.isInteger(index) && index >= 0 && index < count);
+const copySource = (source, usedIds) => {
+	const node = (0, import_lib$1.parseExpression)(source, { plugins: ["jsx", "typescript"] });
+	const edits = [];
+	const newId = () => {
+		let id = nanoid(12);
+		while (usedIds.has(id)) id = nanoid(12);
+		usedIds.add(id);
+		return id;
+	};
+	import_lib$2.traverseFast(node, (child) => {
+		if (!import_lib$2.isJSXOpeningElement(child)) return;
+		const ids = child.attributes.filter((attr) => import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name, { name: "data-id" }));
+		if (ids.length > 1) throw new Error("Duplicate data-id attributes");
+		const attr = ids[0];
+		if (attr && child.attributes.slice(child.attributes.indexOf(attr) + 1).some((attribute) => import_lib$2.isJSXSpreadAttribute(attribute))) throw new Error("A spread may override the copied data-id");
+		if (attr) {
+			const value = attr.value;
+			if (!import_lib$2.isStringLiteral(value) || value.start == null || value.end == null) throw new Error("Cannot copy a dynamic data-id");
+			edits.push({
+				start: value.start,
+				end: value.end,
+				content: JSON.stringify(newId())
+			});
+		} else {
+			const at = child.attributes.at(-1)?.end ?? child.name.end;
+			if (at == null) throw new Error("Missing opening element span");
+			edits.push({
+				start: at,
+				end: at,
+				content: ` data-id="${newId()}"`
+			});
+		}
+	});
+	return applyEdits(source, edits);
+};
+const editChildrenSource = (source, parent, input) => {
+	try {
+		if (!parent.closingElement || parent.start == null || parent.end == null) return null;
+		const value = typeof input === "string" ? JSON.parse(input) : input;
+		const children = parent.children.filter((child) => import_lib$2.isJSXElement(child) || import_lib$2.isJSXFragment(child));
+		const raw = children.map((child) => source.slice(child.start, child.end));
+		const models = extract(source.slice(parent.start, parent.end))[0]?.children ?? [];
+		if (models.length !== children.length) return null;
+		const signatures = modeledSignatures(models);
+		const replaceSlots = (next) => {
+			const edits = children.map((child, index) => ({
+				start: child.start,
+				end: child.end,
+				content: next[index] ?? ""
+			}));
+			if (next.length > children.length) {
+				const at = parent.closingElement.start;
+				edits.push({
+					start: at,
+					end: at,
+					content: next.slice(children.length).join("")
+				});
+			}
+			return edits;
+		};
+		if (Array.isArray(value)) {
+			const desired = modeledSignatures(value);
+			const lossless = raw.every((text, index) => generateCode((0, import_lib$1.parseExpression)(text, { plugins: ["jsx", "typescript"] })) === signatures[index]);
+			const consumed = /* @__PURE__ */ new Set();
+			const next = desired.map((signature, position) => {
+				const index = signatures.findIndex((candidate, i) => candidate === signature && !consumed.has(i) && (value[position].source === void 0 || value[position].source === raw[i]));
+				if (index >= 0) {
+					consumed.add(index);
+					return raw[index];
+				}
+				if (!lossless || value[position].source !== void 0 && !raw.includes(value[position].source)) throw new Error("Use children commands to copy or edit unsupported source");
+				return signature;
+			});
+			const countIds = (text) => {
+				const counts = /* @__PURE__ */ new Map();
+				import_lib$2.traverseFast((0, import_lib$1.parseExpression)(text, { plugins: ["jsx", "typescript"] }), (node) => {
+					if (import_lib$2.isJSXAttribute(node) && import_lib$2.isJSXIdentifier(node.name, { name: "data-id" }) && import_lib$2.isStringLiteral(node.value)) counts.set(node.value.value, (counts.get(node.value.value) ?? 0) + 1);
+				});
+				return counts;
+			};
+			const previousIds = countIds(source);
+			if ([...countIds(applyEdits(source, replaceSlots(next)))].some(([id, count]) => count > 1 && count > (previousIds.get(id) ?? 0))) return null;
+			return replaceSlots(next);
+		}
+		const request = value;
+		if (request?.kind !== "children-edit" || !Array.isArray(request.expected) || request.expected.length !== signatures.length || !getChildrenSignatures(models).every((signature, index) => signature === request.expected[index]) || !request.action) return null;
+		const { action } = request;
+		const usedIds = /* @__PURE__ */ new Set();
+		import_lib$2.traverseFast(parent, (node) => {
+			if (import_lib$2.isJSXAttribute(node) && import_lib$2.isJSXIdentifier(node.name, { name: "data-id" }) && import_lib$2.isStringLiteral(node.value)) usedIds.add(node.value.value);
+		});
+		switch (action.type) {
+			case "move": {
+				if (!indicesAreValid([action.from], raw.length) || !indicesAreValid([action.to], raw.length)) return null;
+				const next = [...raw];
+				const [moved] = next.splice(action.from, 1);
+				next.splice(action.to, 0, moved);
+				return replaceSlots(next);
+			}
+			case "move-selected":
+				if (!indicesAreValid(action.indices, raw.length) || !["up", "down"].includes(action.direction)) return null;
+				return replaceSlots(moveSelectedIndices(raw, new Set(action.indices), action.direction).items);
+			case "remove":
+				if (!indicesAreValid(action.indices, raw.length)) return null;
+				return action.indices.map((index) => ({
+					start: children[index].start,
+					end: children[index].end,
+					content: ""
+				}));
+			case "duplicate": {
+				if (!indicesAreValid(action.indices, raw.length)) return null;
+				const content = [...action.indices].sort((a, b) => a - b).map((index) => copySource(raw[index], usedIds)).join("");
+				const at = parent.closingElement.start;
+				return [{
+					start: at,
+					end: at,
+					content
+				}];
+			}
+			case "append": {
+				const content = copySource(raw[0] ?? "<div></div>", usedIds);
+				const at = parent.closingElement.start;
+				return [{
+					start: at,
+					end: at,
+					content
+				}];
+			}
+			default: return null;
+		}
+	} catch {
+		return null;
+	}
+};
+//#endregion
+//#region src/utils/ast/update.ts
+const childrenRange = (element) => {
+	const { openingElement, closingElement } = element;
+	if (!closingElement || openingElement.end == null || closingElement.start == null) return null;
+	return {
+		start: openingElement.end,
+		end: closingElement.start
+	};
+};
+const findAttribute = (opening, propertyName) => {
+	return opening.attributes.find((attr) => import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === propertyName);
+};
+const attributeInsertPoint = (opening) => {
+	return opening.attributes[opening.attributes.length - 1]?.end ?? opening.name.end ?? null;
+};
+const editInnerText = (source, element, value) => {
+	const range = childrenRange(element);
+	if (!range) return [];
+	const [only] = element.children;
+	if (element.children.length === 1 && import_lib$2.isJSXText(only) && only.start != null && only.end != null) {
+		const raw = source.slice(only.start, only.end);
+		if (raw.trim() !== "") {
+			const leading = raw.length - raw.trimStart().length;
+			const trailing = raw.length - raw.trimEnd().length;
+			return [{
+				start: only.start + leading,
+				end: only.end - trailing,
+				content: value
+			}];
+		}
+	}
+	const edits = [];
+	for (const child of element.children) if (import_lib$2.isJSXText(child) && child.start != null && child.end != null) edits.push({
+		start: child.start,
+		end: child.end,
+		content: ""
+	});
+	edits.push({
+		start: range.end,
+		end: range.end,
+		content: value
+	});
+	return edits;
+};
+const editInnerHTML = (element, value) => {
+	const range = childrenRange(element);
+	if (!range) return [];
+	return [{
+		start: range.start,
+		end: range.end,
+		content: value
+	}];
+};
+const editRichtext = (element, value) => {
+	const edits = [];
+	const range = childrenRange(element);
+	if (range && range.start !== range.end) edits.push({
+		start: range.start,
+		end: range.end,
+		content: ""
+	});
+	const opening = element.openingElement;
+	const attribute = import_lib$2.jsxAttribute(import_lib$2.jsxIdentifier("dangerouslySetInnerHTML"), import_lib$2.jsxExpressionContainer(import_lib$2.objectExpression([import_lib$2.objectProperty(import_lib$2.identifier("__html"), import_lib$2.stringLiteral(value))])));
+	const content = generateCode(attribute);
+	const existing = findAttribute(opening, "dangerouslySetInnerHTML");
+	if (existing && existing.start != null && existing.end != null) {
+		edits.push({
+			start: existing.start,
+			end: existing.end,
+			content,
+			indent: true
+		});
+		return edits;
+	}
+	const insertAt = attributeInsertPoint(opening);
+	if (insertAt == null) return null;
+	edits.push({
+		start: insertAt,
+		end: insertAt,
+		content: ` ${content}`,
+		indent: true
+	});
+	return edits;
+};
+const editJsxAttribute = (opening, propertyName, value) => {
+	const attribute = findAttribute(opening, propertyName);
+	if (!attribute) return null;
+	const content = `{${String(value).trim()}}`;
+	if (attribute.value?.start != null && attribute.value.end != null) return [{
+		start: attribute.value.start,
+		end: attribute.value.end,
+		content
+	}];
+	const insertAt = attribute.name.end;
+	if (insertAt == null) return null;
+	return [{
+		start: insertAt,
+		end: insertAt,
+		content: `=${content}`
+	}];
+};
+const holdsStructuralExpression = (value) => import_lib$2.isJSXExpressionContainer(value) && (import_lib$2.isArrayExpression(unwrapExpression(value.expression)) || import_lib$2.isObjectExpression(unwrapExpression(value.expression)));
+const structuralSource = (value) => {
+	try {
+		const expression = (0, import_lib$1.parseExpression)(value.trim(), { plugins: ["jsx", "typescript"] });
+		return import_lib$2.isArrayExpression(unwrapExpression(expression)) || import_lib$2.isObjectExpression(unwrapExpression(expression)) ? expression : null;
+	} catch {
+		return null;
+	}
+};
+const buildAttributeValue = (value, type, current) => {
+	if (type === "array" || type === "object") {
+		if (typeof value === "string") try {
+			return import_lib$2.jsxExpressionContainer((0, import_lib$1.parseExpression)(value.trim(), { plugins: ["jsx", "typescript"] }));
+		} catch {
+			return import_lib$2.stringLiteral(value);
+		}
+		const expr = valueToExpression(value);
+		return expr ? import_lib$2.jsxExpressionContainer(expr) : import_lib$2.stringLiteral("");
+	}
+	if (typeof value === "string") {
+		if (holdsStructuralExpression(current) && !(type && STRING_VALUED_TYPES.has(type))) {
+			const structural = structuralSource(value);
+			if (structural) return import_lib$2.jsxExpressionContainer(structural);
+		}
+		return import_lib$2.stringLiteral(value);
+	}
+	const expr = valueToExpression(value);
+	return expr ? import_lib$2.jsxExpressionContainer(expr) : import_lib$2.stringLiteral(String(value));
+};
+const editAttribute = (opening, propertyName, value, type) => {
+	const attribute = findAttribute(opening, propertyName);
+	if (!attribute || attribute.start == null || attribute.end == null) return null;
+	if (typeof value === "string" && (type === "array" || type === "object" || holdsStructuralExpression(attribute.value) && !(type && STRING_VALUED_TYPES.has(type)))) {
+		const expression = structuralSource(value);
+		if (expression && import_lib$2.isJSXExpressionContainer(attribute.value)) {
+			const text = value.trim();
+			const lineComment = expression.trailingComments?.some((comment) => comment.type === "CommentLine");
+			return [{
+				start: attribute.value.expression.start,
+				end: attribute.value.expression.end,
+				content: `${text}${lineComment ? "\n" : ""}`
+			}];
+		}
+	}
+	const content = generateCode(import_lib$2.jsxAttribute(attribute.name, buildAttributeValue(value, type, attribute.value)));
+	return [{
+		start: attribute.start,
+		end: attribute.end,
+		content,
+		indent: true
+	}];
+};
+const removeAttribute = (source, attribute) => {
+	if (attribute.start == null || attribute.end == null) return null;
+	let start = attribute.start;
+	while (start > 0 && /\s/.test(source[start - 1])) start -= 1;
+	return [{
+		start,
+		end: attribute.end,
+		content: ""
+	}];
+};
+const addAttribute = (source, opening, propertyName, value, type) => {
+	const insertAt = attributeInsertPoint(opening);
+	if (insertAt == null) return null;
+	const lastStart = opening.attributes[opening.attributes.length - 1]?.start;
+	const lineStart = lastStart == null ? -1 : source.lastIndexOf("\n", lastStart - 1) + 1;
+	return [{
+		start: insertAt,
+		end: insertAt,
+		content: `${lastStart != null && lineStart > 0 && /^\s*$/.test(source.slice(lineStart, lastStart)) ? "\n" : " "}${type === "jsx" ? `${propertyName}={${String(value).trim()}}` : generateCode(import_lib$2.jsxAttribute(import_lib$2.jsxIdentifier(propertyName), buildAttributeValue(value, type)))}`,
+		indent: true
+	}];
+};
+const canEditAttributeValue = (attribute, value, type) => {
+	if (!import_lib$2.isJSXExpressionContainer(attribute.value) || import_lib$2.isJSXEmptyExpression(attribute.value.expression) || isLosslesslyEvaluable(attribute.value.expression)) return true;
+	return typeof value === "string" && holdsStructuralExpression(attribute.value) && !(type && STRING_VALUED_TYPES.has(type)) && structuralSource(value) !== null;
+};
+const update = (code, dataId, label, value, property) => {
+	try {
+		const wrapped = wrap(code);
+		const ast = (0, import_lib$1.parse)(wrapped, {
+			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$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.ID && attr.value && import_lib$2.isStringLiteral(attr.value) && attr.value.value === dataId;
+			})) return;
+			const bindingAttr = opening.attributes.find((attr) => import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.BINDING);
+			if (!bindingAttr?.value) {
+				failure = {
+					reason: "no-binding",
+					dataId
+				};
+				return;
+			}
+			let bindingValue = "";
+			if (import_lib$2.isStringLiteral(bindingAttr.value)) bindingValue = bindingAttr.value.value;
+			else if (import_lib$2.isJSXExpressionContainer(bindingAttr.value)) try {
+				bindingValue = generateCode(bindingAttr.value.expression);
+			} catch (error) {
+				failure = {
+					reason: "parse-error",
+					error
+				};
+				return;
+			}
+			const matches = parseBinding(bindingValue).filter((binding) => property !== void 0 ? binding.property === property : binding.label === label);
+			if (matches.length === 0) {
+				failure = {
+					reason: "binding-not-declared",
+					dataId,
+					label,
+					property
+				};
+				return;
+			}
+			if (matches.length > 1) {
+				failure = {
+					reason: "duplicate-binding",
+					dataId,
+					label,
+					property,
+					count: matches.length
+				};
+				return;
+			}
+			const propertyBinding = matches[0];
+			const prop = propertyBinding.property;
+			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), () => ({
+						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;
+				}
+			}
+		} });
+		if (!changed) return {
+			code,
+			success: false,
+			failure: failure ?? {
+				reason: "element-not-found",
+				dataId
+			}
+		};
+		return {
+			code: unwrap(applyEdits(wrapped, edits)),
+			success: true
+		};
+	} catch (error) {
+		console.error("❌ Code update error:", error);
+		return {
+			code,
+			success: false,
+			failure: {
+				reason: "parse-error",
+				error
+			}
+		};
+	}
+};
+const updateAll = (raw, entries) => {
+	let current = raw;
+	for (const [index, entry] of entries.entries()) {
+		const result = update(current, entry.dataId, entry.label, entry.value, entry.property);
+		if (!result.success) return {
+			success: false,
+			code: raw,
+			failure: result.failure ?? {
+				reason: "element-not-found",
+				dataId: entry.dataId
+			},
+			index
+		};
+		current = result.code;
+	}
+	return {
+		success: true,
+		code: current
+	};
+};
+/**
+* @deprecated Not atomic: when an entry fails, the ones before and after it
+* are still applied, and the returned `code` carries them. Use `updateAll`,
+* which applies every entry or none. Will be removed in the next major.
+*/
+const bulkUpdate = (raw, entries) => {
+	let current = raw;
+	const failures = [];
+	for (const entry of entries) {
+		const result = update(current, entry.dataId, entry.label, entry.value, entry.property);
+		current = result.code;
+		if (!result.success && result.failure) failures.push(result.failure);
+	}
+	return failures.length > 0 ? {
+		code: current,
+		success: false,
+		failures
+	} : {
+		code: current,
+		success: true
+	};
+};
+//#endregion
+//#region src/utils/ast/tree.ts
+const replaceIds = (code, generateId = () => nanoid(6)) => {
+	return code.replace(new RegExp(`${DATA_ATTR.ID}="[^"]*"`, "g"), () => {
+		return `${DATA_ATTR.ID}="${generateId()}"`;
+	});
+};
+const fillIds = (code, generateId = () => nanoid(6)) => {
+	return code.replace(new RegExp(`${DATA_ATTR.ID}=""`, "g"), () => {
+		return `${DATA_ATTR.ID}="${generateId()}"`;
+	});
+};
+const clone = (element, generateId = () => nanoid(6)) => {
+	const cloned = import_lib$2.cloneNode(element, true);
+	const generatedCode = generateCode(cloned);
+	const code = replaceIds(generatedCode, generateId);
+	return (0, import_lib$1.parseExpression)(code, { plugins: ["jsx", "typescript"] });
+};
+//#endregion
+//#region src/utils/ast/validate.ts
+const VALID = { valid: true };
+const validateBindingValue = (binding, value) => {
+	if (value === "" || value === null || value === void 0) {
+		if (binding.required) return {
+			valid: false,
+			message: "This field is required."
+		};
+		return VALID;
+	}
+	if (typeof value === "number") {
+		if (binding.min !== void 0 && value < binding.min) return {
+			valid: false,
+			message: `Must be at least ${binding.min}.`
+		};
+		if (binding.max !== void 0 && value > binding.max) return {
+			valid: false,
+			message: `Must be at most ${binding.max}.`
+		};
+	}
+	if (typeof value === "string" && binding.pattern) {
+		let regex;
+		try {
+			regex = new RegExp(binding.pattern);
+		} catch {
+			return VALID;
+		}
+		if (!regex.test(value)) return {
+			valid: false,
+			message: "Value does not match the required format."
+		};
+	}
+	if (typeof value === "string" && binding.type === "url") try {
+		new URL(value);
+	} catch {
+		return {
+			valid: false,
+			message: "Must be a valid URL."
+		};
+	}
+	if (typeof value === "string" && binding.type === "date") {
+		if (Number.isNaN(Date.parse(value))) return {
+			valid: false,
+			message: "Must be a valid date."
+		};
+	}
+	return VALID;
+};
+//#endregion
+export { extractObjectProperties as A, getStructuredValue as C, canLosslesslyEvaluateSource as D, arrayExpressionToCode as E, generateCode as F, parseArrayExpression as M, parseValue as N, createNodeFromValue as O, setEditableValue as P, getCurrentValue as S, parseBindingExpression as T, updateArrayItemProperty as _, bulkUpdate as a, moveSelectedIndices as b, getChildrenSignatures as c, appendArrayItem as d, duplicateArrayItems as f, removeArrayItems as g, parseItems as h, replaceIds as i, flattenEditableValue as j, extractNodeValue as k, clearExtractCache as l, moveArrayItems as m, clone as n, update as o, moveArrayItem as p, fillIds as r, updateAll as s, validateBindingValue as t, extract as u, updateArrayItemValue as v, parseBinding as w, findEditableChildren as x, canStructurallyEditArray as y };
+
+//# sourceMappingURL=ast-CMD20ykx.js.map