@jbpark/live-editor 1.4.0 → 1.6.0

package/dist/ast-CXRFs1hO.mjs

@@ -0,0 +1,788 @@
+import { b as __toESM, c as createBoundedCache, d as require_lib$2, f as require_lib$1, h as DATA_ATTR, l as require_lib$3, m as CONFIG, p as BINDING_PROP, u as require_lib, v as REGEX } from "./document-BkOqiV4R.mjs";
+import { z } from "zod";
+import crypto from "crypto";
+
+//#region src/utils/ast/types.ts
+const BINDING_TYPES = [
+	"array",
+	"object",
+	"string",
+	"number",
+	"boolean",
+	"color",
+	"jsx",
+	"richtext",
+	"date",
+	"url",
+	"icon-picker",
+	"asset-picker"
+];
+
+//#endregion
+//#region src/utils/ast/helpers.ts
+var import_lib$1 = /* @__PURE__ */ __toESM(require_lib(), 1);
+var import_lib$2 = require_lib$1();
+var import_lib$3 = /* @__PURE__ */ __toESM(require_lib$2(), 1);
+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$3.stringLiteral(value);
+	const trimmed = value.trim();
+	if (REGEX.NUMBER.test(trimmed)) return import_lib$3.jsxExpressionContainer(import_lib$3.numericLiteral(parseFloat(trimmed)));
+	if (REGEX.BOOLEAN_OR_NULL.test(trimmed)) {
+		const expr = (0, import_lib$2.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+		return import_lib$3.jsxExpressionContainer(expr);
+	}
+	try {
+		const expr = (0, import_lib$2.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+		return import_lib$3.jsxExpressionContainer(expr);
+	} catch {
+		return import_lib$3.stringLiteral(trimmed);
+	}
+};
+const generateCode = (node) => {
+	return (0, import_lib$1.default)(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 evaluateLiteral = (node) => {
+	if (import_lib$3.isStringLiteral(node)) return node.value;
+	if (import_lib$3.isNumericLiteral(node)) return node.value;
+	if (import_lib$3.isBooleanLiteral(node)) return node.value;
+	if (import_lib$3.isNullLiteral(node)) return null;
+	if (import_lib$3.isIdentifier(node) && node.name === "undefined") return;
+	if (import_lib$3.isUnaryExpression(node) && node.operator === "-" && import_lib$3.isNumericLiteral(node.argument)) return -node.argument.value;
+	if (import_lib$3.isTemplateLiteral(node) && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? "";
+	if (import_lib$3.isJSXElement(node) || import_lib$3.isJSXFragment(node)) return generateCode(node);
+	if (import_lib$3.isArrayExpression(node)) return node.elements.map((element) => element ? evaluateLiteral(element) : null);
+	if (import_lib$3.isObjectExpression(node)) {
+		const result = {};
+		for (const prop of node.properties) {
+			if (!import_lib$3.isObjectProperty(prop)) continue;
+			let key = null;
+			if (import_lib$3.isIdentifier(prop.key)) key = prop.key.name;
+			else if (import_lib$3.isStringLiteral(prop.key)) key = prop.key.value;
+			else if (import_lib$3.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$2.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+			if (import_lib$3.isObjectExpression(ast) || import_lib$3.isArrayExpression(ast)) return evaluateLiteral(ast);
+		} catch {}
+		return value;
+	}
+	return value;
+};
+const extractNodeValue = (node) => {
+	if (import_lib$3.isBooleanLiteral(node)) return {
+		type: "boolean",
+		value: node.value
+	};
+	if (import_lib$3.isNumericLiteral(node)) return {
+		type: "number",
+		value: node.value
+	};
+	if (import_lib$3.isStringLiteral(node)) return {
+		type: "string",
+		value: node.value
+	};
+	if (import_lib$3.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$3.isNullLiteral(node)) return {
+		type: "null",
+		value: null
+	};
+	if (import_lib$3.isArrayExpression(node)) return {
+		type: "array",
+		value: generateCode(node)
+	};
+	if (import_lib$3.isObjectExpression(node)) return {
+		type: "object",
+		value: generateCode(node)
+	};
+	if (import_lib$3.isJSXElement(node) || import_lib$3.isJSXFragment(node)) return {
+		type: "string",
+		value: generateCode(node)
+	};
+	return {
+		type: "unknown",
+		value: null
+	};
+};
+const createNodeFromValue = (type, value) => {
+	switch (type) {
+		case "boolean": return import_lib$3.booleanLiteral(value === true);
+		case "number": return import_lib$3.numericLiteral(Number(value));
+		case "string": return import_lib$3.stringLiteral(String(value));
+		case "null": return import_lib$3.nullLiteral();
+		case "array":
+		case "object":
+		case "unknown": return null;
+		default: return null;
+	}
+};
+const parseArrayExpression = (value) => {
+	try {
+		const ast = (0, import_lib$2.parseExpression)(value, { plugins: ["jsx", "typescript"] });
+		if (!import_lib$3.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$3.isObjectProperty(prop) && import_lib$3.isIdentifier(prop.key)) {
+			const key = prop.key.name;
+			if (key === "children") return;
+			properties[key] = {
+				...extractNodeValue(prop.value),
+				astNode: prop.value
+			};
+		}
+	});
+	return properties;
+};
+const arrayExpressionToCode = (elements) => {
+	return generateCode(import_lib$3.arrayExpression(elements));
+};
+
+//#endregion
+//#region src/utils/ast/binding.ts
+const bindingTypeSchema = z.enum(BINDING_TYPES);
+const bindingOptionSchema = z.object({
+	label: z.string(),
+	value: z.string()
+});
+const bindingRenderLeafSchema = z.object({
+	type: bindingTypeSchema,
+	property: z.string().optional()
+});
+const rawBindingItemSchema = z.object({
+	label: z.string(),
+	property: z.string().optional(),
+	type: bindingTypeSchema.optional(),
+	options: z.array(bindingOptionSchema).optional(),
+	min: z.number().optional(),
+	max: z.number().optional(),
+	pattern: z.string().optional(),
+	required: z.boolean().optional()
+});
+const isPlainObject = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const sanitizeRenderMap = (value) => {
+	if (!isPlainObject(value)) return;
+	const map = {};
+	for (const [key, raw] of Object.entries(value)) {
+		if (!isPlainObject(raw)) continue;
+		if ("type" in raw) {
+			const leaf = bindingRenderLeafSchema.safeParse(raw);
+			if (leaf.success) {
+				const render = sanitizeRenderMap(raw.render);
+				map[key] = render ? {
+					...leaf.data,
+					render
+				} : leaf.data;
+			}
+			continue;
+		}
+		const nested = sanitizeRenderMap(raw);
+		if (nested) map[key] = nested;
+	}
+	return Object.keys(map).length > 0 ? map : void 0;
+};
+const parseBinding = (bindingValue) => {
+	if (!bindingValue) return [];
+	const ast = parseArrayExpression(bindingValue);
+	if (!ast) return [];
+	const raw = evaluateLiteral(ast);
+	if (!Array.isArray(raw)) return [];
+	const items = [];
+	for (const rawItem of raw) {
+		if (!isPlainObject(rawItem)) continue;
+		const sanitizedType = bindingTypeSchema.safeParse(rawItem.type);
+		const sanitizedOptions = Array.isArray(rawItem.options) ? rawItem.options.map((option) => {
+			const parsed = bindingOptionSchema.safeParse(option);
+			return parsed.success ? parsed.data : null;
+		}).filter((option) => option !== null) : void 0;
+		const parsed = rawBindingItemSchema.safeParse({
+			...rawItem,
+			type: sanitizedType.success ? sanitizedType.data : void 0,
+			options: sanitizedOptions?.length ? sanitizedOptions : void 0
+		});
+		if (!parsed.success) continue;
+		const { label, property, type, options, min, max, pattern, required } = parsed.data;
+		if (property === void 0 && type !== "richtext") continue;
+		const render = sanitizeRenderMap(rawItem.render);
+		items.push({
+			label,
+			property: property ?? BINDING_PROP.INNER_HTML,
+			...type !== void 0 && { type },
+			...options?.length && { options },
+			...render && { render },
+			...min !== void 0 && { min },
+			...max !== void 0 && { max },
+			...pattern !== void 0 && { pattern },
+			...required !== void 0 && { required }
+		});
+	}
+	return items;
+};
+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$2.parseExpression)(dsiAttr.value, { plugins: ["jsx", "typescript"] });
+				if (import_lib$3.isObjectExpression(expr)) {
+					const htmlProp = expr.properties.find((p) => import_lib$3.isObjectProperty(p) && import_lib$3.isIdentifier(p.key) && p.key.name === "__html");
+					if (htmlProp) {
+						if (import_lib$3.isStringLiteral(htmlProp.value)) return htmlProp.value.value;
+						if (import_lib$3.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 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 node_modules/.pnpm/nanoid@3.3.11/node_modules/nanoid/url-alphabet/index.js
+let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+//#endregion
+//#region node_modules/.pnpm/nanoid@3.3.11/node_modules/nanoid/index.js
+const POOL_SIZE_MULTIPLIER = 128;
+let pool, poolOffset;
+let fillPool = (bytes) => {
+	if (!pool || pool.length < bytes) {
+		pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+		crypto.randomFillSync(pool);
+		poolOffset = 0;
+	} else if (poolOffset + bytes > pool.length) {
+		crypto.randomFillSync(pool);
+		poolOffset = 0;
+	}
+	poolOffset += bytes;
+};
+let nanoid = (size = 21) => {
+	fillPool(size |= 0);
+	let id = "";
+	for (let i = poolOffset - size; i < poolOffset; i++) id += urlAlphabet[pool[i] & 63];
+	return id;
+};
+
+//#endregion
+//#region src/utils/ast/extract.ts
+var import_lib = /* @__PURE__ */ __toESM(require_lib$3(), 1);
+const collectText = (children) => {
+	return children.filter((c) => import_lib$3.isJSXText(c)).map((c) => c.value.trim()).filter((v) => v.length).join(" ");
+};
+const getTagName = (opening) => {
+	if (import_lib$3.isJSXIdentifier(opening.name)) return opening.name.name;
+	if (import_lib$3.isJSXMemberExpression(opening.name)) return resolveMemberName(opening.name);
+	return "";
+};
+const resolveMemberName = (expr) => {
+	const parts = [];
+	const collectMemberParts = (node) => {
+		if (import_lib$3.isJSXIdentifier(node)) parts.push(node.name);
+		else if (import_lib$3.isJSXMemberExpression(node)) {
+			collectMemberParts(node.object);
+			if (import_lib$3.isJSXIdentifier(node.property)) parts.push(node.property.name);
+		}
+	};
+	collectMemberParts(expr.object);
+	if (import_lib$3.isJSXIdentifier(expr.property)) parts.push(expr.property.name);
+	return parts.join(".");
+};
+const parseJSXName = (tagName) => {
+	const parts = tagName.split(".");
+	if (parts.length === 1) return import_lib$3.jsxIdentifier(parts[0]);
+	let expr = import_lib$3.jsxIdentifier(parts[0]);
+	for (let i = 1; i < parts.length; i++) expr = import_lib$3.jsxMemberExpression(expr, import_lib$3.jsxIdentifier(parts[i]));
+	return expr;
+};
+const extractCache = createBoundedCache(CONFIG.CACHE_LIMIT);
+const extractAttributes = (attributes) => {
+	const allAttrs = [];
+	const dataAttrs = [];
+	for (const attr of attributes) {
+		if (!import_lib$3.isJSXAttribute(attr) || !import_lib$3.isJSXIdentifier(attr.name)) continue;
+		const name = attr.name.name;
+		let value = null;
+		let isStringLiteral = false;
+		if (attr.value) {
+			if (import_lib$3.isStringLiteral(attr.value)) {
+				value = attr.value.value;
+				isStringLiteral = true;
+			} else if (import_lib$3.isJSXExpressionContainer(attr.value)) try {
+				value = generateCode(attr.value.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$3.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$3.jsxFragment(import_lib$3.jsxOpeningFragment(), import_lib$3.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$3.jsxIdentifier(attr.name);
+			if (!attr.value) return import_lib$3.jsxAttribute(attrName, null);
+			return import_lib$3.jsxAttribute(attrName, attrValue(attr));
+		});
+		const elementName = parseJSXName(node.tagName);
+		const openingElement = import_lib$3.jsxOpeningElement(elementName, attributes);
+		const closingElement = import_lib$3.jsxClosingElement(elementName);
+		const children = buildChildElements(node);
+		return import_lib$3.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) => {
+	const jsxChildren = jsxElement.children.filter((child) => import_lib$3.isJSXElement(child) || import_lib$3.isJSXFragment(child));
+	if (!jsxChildren.length) return;
+	const childrenNodes = [];
+	jsxChildren.forEach((child) => {
+		if (import_lib$3.isJSXElement(child)) {
+			const childResults = extractFromNode(child, processedNodes);
+			if (shouldWrap) {
+				const wrapperNode = createWrapperNode(collectText(child.children), childResults);
+				childrenNodes.push(wrapperNode);
+			} else childrenNodes.push(...childResults);
+		} else if (import_lib$3.isJSXFragment(child)) {
+			processedNodes?.add(child);
+			const fragmentChildren = [];
+			child.children.forEach((fragmentChild) => {
+				if (import_lib$3.isJSXElement(fragmentChild)) {
+					const childResults = extractFromNode(fragmentChild, processedNodes);
+					fragmentChildren.push(...childResults);
+				}
+			});
+			if (fragmentChildren.length) {
+				const fragmentNode = createFragmentNode(collectText(child.children), fragmentChildren);
+				childrenNodes.push(fragmentNode);
+			}
+		}
+	});
+	return childrenNodes.length ? childrenNodes : void 0;
+};
+const skipItemsChildren = (jsxElement, processedNodes, propertyName = "items") => {
+	const itemsAttr = jsxElement.openingElement.attributes.find((attr) => import_lib$3.isJSXAttribute(attr) && import_lib$3.isJSXIdentifier(attr.name) && attr.name.name === propertyName);
+	if (!itemsAttr || !import_lib$3.isJSXAttribute(itemsAttr)) return;
+	if (itemsAttr.value && import_lib$3.isJSXExpressionContainer(itemsAttr.value) && import_lib$3.isArrayExpression(itemsAttr.value.expression)) itemsAttr.value.expression.elements.forEach((element) => {
+		if (import_lib$3.isObjectExpression(element)) element.properties.forEach((prop) => {
+			if (import_lib$3.isObjectProperty(prop) && import_lib$3.isIdentifier(prop.key) && import_lib$3.isJSXElement(prop.value)) markProcessedJSX(prop.value, processedNodes);
+		});
+	});
+};
+const markProcessedJSX = (node, processedNodes) => {
+	if (import_lib$3.isJSXElement(node) || import_lib$3.isJSXFragment(node)) {
+		processedNodes.add(node);
+		node.children.forEach((child) => markProcessedJSX(child, processedNodes));
+		return;
+	}
+	if (import_lib$3.isJSXExpressionContainer(node) || import_lib$3.isParenthesizedExpression(node)) markProcessedJSX(node.expression, processedNodes);
+};
+const readNodeBindingInfo = (node) => {
+	const opening = node.openingElement;
+	const tagName = getTagName(opening);
+	const { allAttrs, dataAttrs } = extractAttributes(opening.attributes);
+	const bindingAttr = dataAttrs.find((attr) => attr.name === DATA_ATTR.BINDING);
+	const bindings = 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 ast = (0, import_lib$2.parse)(wrap(raw), {
+		sourceType: "module",
+		plugins: ["jsx", "typescript"],
+		errorRecovery: true
+	});
+	const results = [];
+	const processedNodes = /* @__PURE__ */ new WeakSet();
+	(0, import_lib.default)(ast, { JSXElement(path) {
+		if (processedNodes.has(path.node)) return;
+		const { tagName, allAttrs, dataAttrs, bindings, childrenBinding, arrayBindings, rawChildren } = readNodeBindingInfo(path.node);
+		if (!tagName || !dataAttrs.length) return;
+		let childrenNodes;
+		if (childrenBinding) childrenNodes = processChildrenBinding(path.node, processedNodes);
+		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) {
+	processedNodes?.add(node);
+	const { tagName, allAttrs, dataAttrs, bindings, childrenBinding, rawChildren } = readNodeBindingInfo(node);
+	let childrenNodes;
+	if (childrenBinding) childrenNodes = processChildrenBinding(node, processedNodes);
+	if (!childrenNodes) childrenNodes = processChildrenBinding(node, processedNodes, false);
+	return [{
+		tagName,
+		attributes: allAttrs,
+		dataAttributes: dataAttrs,
+		textContent: collectText(node.children),
+		rawChildren,
+		children: childrenNodes,
+		bindings
+	}];
+}
+function clearExtractCache() {
+	extractCache.clear();
+}
+
+//#endregion
+//#region src/utils/ast/update.ts
+const updateInnerText = (path, value) => {
+	const jsxChildren = path.node.children;
+	for (let i = jsxChildren.length - 1; i >= 0; i--) if (import_lib$3.isJSXText(jsxChildren[i])) jsxChildren.splice(i, 1);
+	jsxChildren.push(import_lib$3.jsxText(value));
+	return true;
+};
+const injectPlaceholder = (prefix, value, placeholders, { asRawContent = false } = {}) => {
+	const name = `__${prefix}_${nanoid(6)}__`;
+	const container = import_lib$3.jsxExpressionContainer(import_lib$3.identifier(name));
+	placeholders.set(asRawContent ? `{${name}}` : name, value);
+	return container;
+};
+const updateInnerHTML = (path, value, placeholders) => {
+	path.node.children = [injectPlaceholder("HTML", value, placeholders, { asRawContent: true })];
+	return true;
+};
+const updateChildren = (path, value) => {
+	try {
+		const childrenData = JSON.parse(value);
+		path.node.children.length = 0;
+		childrenData.forEach((childData) => {
+			const jsxElement = nodeToJSX(childData);
+			if (jsxElement) path.node.children.push(jsxElement);
+		});
+		return true;
+	} catch (error) {
+		console.error("❌ Children update error:", error);
+		return false;
+	}
+};
+const updateRichtext = (path, value) => {
+	path.node.children = [];
+	const opening = path.node.openingElement;
+	const htmlObject = import_lib$3.objectExpression([import_lib$3.objectProperty(import_lib$3.identifier("__html"), import_lib$3.stringLiteral(value))]);
+	const existingAttr = opening.attributes.find((a) => import_lib$3.isJSXAttribute(a) && import_lib$3.isJSXIdentifier(a.name) && a.name.name === "dangerouslySetInnerHTML");
+	if (existingAttr && import_lib$3.isJSXAttribute(existingAttr)) existingAttr.value = import_lib$3.jsxExpressionContainer(htmlObject);
+	else opening.attributes.push(import_lib$3.jsxAttribute(import_lib$3.jsxIdentifier("dangerouslySetInnerHTML"), import_lib$3.jsxExpressionContainer(htmlObject)));
+	return true;
+};
+const updateAttribute = (opening, propertyName, value) => {
+	const customAttr = opening.attributes.find((attr) => import_lib$3.isJSXAttribute(attr) && import_lib$3.isJSXIdentifier(attr.name) && attr.name.name === propertyName);
+	if (customAttr && import_lib$3.isJSXAttribute(customAttr)) {
+		const trimmed = value.trim();
+		customAttr.value = attrValue({
+			name: propertyName,
+			value,
+			isStringLiteral: !(trimmed.startsWith("[") || trimmed.startsWith("{") || REGEX.NUMBER.test(trimmed) || REGEX.BOOLEAN_OR_NULL.test(trimmed))
+		});
+		return true;
+	}
+	return false;
+};
+const update = (code, dataId, label, value) => {
+	try {
+		const ast = (0, import_lib$2.parse)(wrap(code), {
+			sourceType: "module",
+			plugins: ["jsx", "typescript"]
+		});
+		let changed = false;
+		const jsxPlaceholders = /* @__PURE__ */ new Map();
+		(0, import_lib.default)(ast, { JSXElement(path) {
+			const opening = path.node.openingElement;
+			if (!opening.attributes.find((attr) => {
+				return import_lib$3.isJSXAttribute(attr) && import_lib$3.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.ID && attr.value && import_lib$3.isStringLiteral(attr.value) && attr.value.value === dataId;
+			})) return;
+			const bindingAttr = opening.attributes.find((attr) => import_lib$3.isJSXAttribute(attr) && import_lib$3.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.BINDING);
+			if (!bindingAttr?.value) return;
+			let bindingValue = "";
+			if (import_lib$3.isStringLiteral(bindingAttr.value)) bindingValue = bindingAttr.value.value;
+			else if (import_lib$3.isJSXExpressionContainer(bindingAttr.value)) try {
+				bindingValue = generateCode(bindingAttr.value.expression);
+			} catch {
+				return;
+			}
+			const propertyBinding = parseBinding(bindingValue).find((binding) => binding.label === label);
+			if (!propertyBinding) return;
+			switch (propertyBinding.property) {
+				case BINDING_PROP.INNER_TEXT:
+					changed = updateInnerText(path, value);
+					break;
+				case BINDING_PROP.INNER_HTML:
+					if (propertyBinding.type === "richtext") changed = updateRichtext(path, value);
+					else changed = updateInnerHTML(path, value, jsxPlaceholders);
+					break;
+				case BINDING_PROP.CHILDREN:
+					changed = updateChildren(path, value);
+					break;
+				default:
+					if (propertyBinding.type === "jsx") {
+						const attr = opening.attributes.find((a) => import_lib$3.isJSXAttribute(a) && import_lib$3.isJSXIdentifier(a.name) && a.name.name === propertyBinding.property);
+						if (attr && import_lib$3.isJSXAttribute(attr)) {
+							attr.value = injectPlaceholder("JSX", value.trim(), jsxPlaceholders);
+							changed = true;
+						}
+					} else changed = updateAttribute(opening, propertyBinding.property, value);
+					break;
+			}
+		} });
+		if (!changed) return {
+			code,
+			success: false
+		};
+		let result = unwrap(generateCode(ast));
+		for (const [placeholder, original] of jsxPlaceholders) result = result.replace(placeholder, () => original);
+		return {
+			code: result,
+			success: true
+		};
+	} catch (error) {
+		console.error("❌ Code update error:", error);
+		return {
+			code,
+			success: false
+		};
+	}
+};
+const bulkUpdate = (raw, entries) => {
+	let current = raw;
+	let allSucceeded = true;
+	for (const entry of entries) {
+		const result = update(current, entry.dataId, entry.label, entry.value);
+		current = result.code;
+		allSucceeded = allSucceeded && result.success;
+	}
+	return {
+		code: current,
+		success: allSucceeded
+	};
+};
+
+//#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)) => {
+	return (0, import_lib$2.parseExpression)(replaceIds(generateCode(import_lib$3.cloneNode(element, true)), generateId), { 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 { parseArrayExpression as _, bulkUpdate as a, extract as c, getCurrentValue as d, parseBinding as f, extractObjectProperties as g, extractNodeValue as h, replaceIds as i, nanoid as l, createNodeFromValue as m, clone as n, update as o, arrayExpressionToCode as p, fillIds as r, clearExtractCache as s, validateBindingValue as t, findEditableChildren as u, parseValue as v, generateCode as y };
+//# sourceMappingURL=ast-CXRFs1hO.mjs.map