@jbpark/live-editor 1.11.0 → 1.13.0

package/dist/{ast-C0FNDLFQ.mjs → ast-Dq1EfxA5.js}

@@ -1,8 +1,8 @@
-import { d as require_lib, f as require_lib$2, g as DATA_ATTR, h as CONFIG, l as createBoundedCache, m as BINDING_PROP, p as require_lib$1, u as require_lib$3, x as __toESM, y as REGEX } from "./document-CBw2uF_P.mjs";
+import { d as require_lib, f as require_lib$2, g as DATA_ATTR, h as CONFIG, l as traverse, m as BINDING_PROP, p as require_lib$1, u as createBoundedCache, x as __toESM, y as REGEX } from "./document-CSIscFpL.js";
 import { z } from "zod";
-import crypto from "crypto";
-
 //#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",
@@ -17,12 +17,10 @@ const BINDING_TYPES = [
 	"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);
+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}</>`;
 };
@@ -31,24 +29,23 @@ const unwrap = (generated) => {
 };
 const attrValue = ({ value, isStringLiteral }) => {
 	if (value === null) return null;
-	if (isStringLiteral) return import_lib$3.stringLiteral(value);
+	if (isStringLiteral) return import_lib$2.stringLiteral(value);
 	const trimmed = value.trim();
-	if (REGEX.NUMBER.test(trimmed)) return import_lib$3.jsxExpressionContainer(import_lib$3.numericLiteral(parseFloat(trimmed)));
+	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$2.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
-		return import_lib$3.jsxExpressionContainer(expr);
+		const expr = (0, import_lib$1.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+		return import_lib$2.jsxExpressionContainer(expr);
 	}
 	try {
-		const expr = (0, import_lib$2.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
-		return import_lib$3.jsxExpressionContainer(expr);
+		const expr = (0, import_lib$1.parseExpression)(trimmed, { plugins: ["jsx", "typescript"] });
+		return import_lib$2.jsxExpressionContainer(expr);
 	} catch {
-		return import_lib$3.stringLiteral(trimmed);
+		return import_lib$2.stringLiteral(trimmed);
 	}
 };
 const generateCode = (node) => {
-	return (0, import_lib$1.default)(node, { jsescOption: { minimal: true } }).code;
+	return generate(node, { jsescOption: { minimal: true } }).code;
 };
-
 //#endregion
 //#region src/utils/ast/value.ts
 const dedent = (str) => {
@@ -61,23 +58,23 @@ const dedent = (str) => {
 	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)) {
+	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$3.isObjectProperty(prop)) continue;
+			if (!import_lib$2.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 (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);
 		}
@@ -97,31 +94,31 @@ const parseValue = (value) => {
 	}
 	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);
+			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 extractNodeValue = (node) => {
-	if (import_lib$3.isBooleanLiteral(node)) return {
+	if (import_lib$2.isBooleanLiteral(node)) return {
 		type: "boolean",
 		value: node.value
 	};
-	if (import_lib$3.isNumericLiteral(node)) return {
+	if (import_lib$2.isNumericLiteral(node)) return {
 		type: "number",
 		value: node.value
 	};
-	if (import_lib$3.isUnaryExpression(node) && node.operator === "-" && import_lib$3.isNumericLiteral(node.argument)) return {
+	if (import_lib$2.isUnaryExpression(node) && node.operator === "-" && import_lib$2.isNumericLiteral(node.argument)) return {
 		type: "number",
 		value: -node.argument.value
 	};
-	if (import_lib$3.isStringLiteral(node)) return {
+	if (import_lib$2.isStringLiteral(node)) return {
 		type: "string",
 		value: node.value
 	};
-	if (import_lib$3.isTemplateLiteral(node)) {
+	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)
@@ -131,19 +128,19 @@ const extractNodeValue = (node) => {
 			value: generateCode(node)
 		};
 	}
-	if (import_lib$3.isNullLiteral(node)) return {
+	if (import_lib$2.isNullLiteral(node)) return {
 		type: "null",
 		value: null
 	};
-	if (import_lib$3.isArrayExpression(node)) return {
+	if (import_lib$2.isArrayExpression(node)) return {
 		type: "array",
 		value: generateCode(node)
 	};
-	if (import_lib$3.isObjectExpression(node)) return {
+	if (import_lib$2.isObjectExpression(node)) return {
 		type: "object",
 		value: generateCode(node)
 	};
-	if (import_lib$3.isJSXElement(node) || import_lib$3.isJSXFragment(node)) return {
+	if (import_lib$2.isJSXElement(node) || import_lib$2.isJSXFragment(node)) return {
 		type: "string",
 		value: generateCode(node)
 	};
@@ -154,10 +151,10 @@ const extractNodeValue = (node) => {
 };
 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 "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;
@@ -166,8 +163,8 @@ const createNodeFromValue = (type, value) => {
 };
 const parseArrayExpression = (value) => {
 	try {
-		const ast = (0, import_lib$2.parseExpression)(value, { plugins: ["jsx", "typescript"] });
-		if (!import_lib$3.isArrayExpression(ast)) return null;
+		const ast = (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);
@@ -177,11 +174,12 @@ const parseArrayExpression = (value) => {
 const extractObjectProperties = (element) => {
 	const properties = {};
 	element.properties.forEach((prop) => {
-		if (import_lib$3.isObjectProperty(prop) && import_lib$3.isIdentifier(prop.key)) {
+		if (import_lib$2.isObjectProperty(prop) && import_lib$2.isIdentifier(prop.key)) {
 			const key = prop.key.name;
 			if (key === "children") return;
+			const extracted = extractNodeValue(prop.value);
 			properties[key] = {
-				...extractNodeValue(prop.value),
+				...extracted,
 				astNode: prop.value
 			};
 		}
@@ -189,9 +187,9 @@ const extractObjectProperties = (element) => {
 	return properties;
 };
 const arrayExpressionToCode = (elements) => {
-	return generateCode(import_lib$3.arrayExpression(elements));
+	const nextAst = import_lib$2.arrayExpression(elements);
+	return generateCode(nextAst);
 };
-
 //#endregion
 //#region src/utils/ast/binding.ts
 const bindingTypeSchema = z.enum(BINDING_TYPES);
@@ -280,12 +278,12 @@ const getCurrentValue = (node, property) => {
 		case BINDING_PROP.INNER_HTML: {
 			const dsiAttr = node.attributes.find((a) => a.name === "dangerouslySetInnerHTML");
 			if (dsiAttr?.value) try {
-				const expr = (0, import_lib$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");
+				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$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 ?? "";
+						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 {}
@@ -312,62 +310,44 @@ const findEditableChildren = (node) => {
 	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];
+//#region node_modules/.pnpm/nanoid@3.3.18/node_modules/nanoid/index.browser.js
+let nanoid = (size = 21) => crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+	byte &= 63;
+	if (byte < 36) id += byte.toString(36);
+	else if (byte < 62) id += (byte - 26).toString(36).toUpperCase();
+	else if (byte > 62) id += "-";
+	else id += "_";
 	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(" ");
+	return children.filter((c) => import_lib$2.isJSXText(c)).map((c) => c.value.trim()).filter((v) => v.length).join(" ");
 };
 const getTagName = (opening) => {
-	if (import_lib$3.isJSXIdentifier(opening.name)) return opening.name.name;
-	if (import_lib$3.isJSXMemberExpression(opening.name)) return resolveMemberName(opening.name);
+	if (import_lib$2.isJSXIdentifier(opening.name)) return opening.name.name;
+	if (import_lib$2.isJSXMemberExpression(opening.name)) return resolveMemberName(opening.name);
 	return "";
 };
 const resolveMemberName = (expr) => {
 	const parts = [];
 	const collectMemberParts = (node) => {
-		if (import_lib$3.isJSXIdentifier(node)) parts.push(node.name);
-		else if (import_lib$3.isJSXMemberExpression(node)) {
+		if (import_lib$2.isJSXIdentifier(node)) parts.push(node.name);
+		else if (import_lib$2.isJSXMemberExpression(node)) {
 			collectMemberParts(node.object);
-			if (import_lib$3.isJSXIdentifier(node.property)) parts.push(node.property.name);
+			if (import_lib$2.isJSXIdentifier(node.property)) parts.push(node.property.name);
 		}
 	};
 	collectMemberParts(expr.object);
-	if (import_lib$3.isJSXIdentifier(expr.property)) parts.push(expr.property.name);
+	if (import_lib$2.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]));
+	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);
@@ -375,15 +355,15 @@ 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;
+		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$3.isStringLiteral(attr.value)) {
+			if (import_lib$2.isStringLiteral(attr.value)) {
 				value = attr.value.value;
 				isStringLiteral = true;
-			} else if (import_lib$3.isJSXExpressionContainer(attr.value)) try {
+			} else if (import_lib$2.isJSXExpressionContainer(attr.value)) try {
 				value = generateCode(attr.value.expression);
 				isStringLiteral = false;
 			} catch {
@@ -405,7 +385,7 @@ const extractAttributes = (attributes) => {
 };
 const buildChildElements = (node) => {
 	const childElements = [];
-	if (node.textContent) childElements.push(import_lib$3.jsxText(node.textContent));
+	if (node.textContent) childElements.push(import_lib$2.jsxText(node.textContent));
 	node.children?.forEach((child) => {
 		const childJSX = nodeToJSX(child);
 		if (childJSX) childElements.push(childJSX);
@@ -416,22 +396,22 @@ 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);
+			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$3.jsxIdentifier(attr.name);
-			if (!attr.value) return import_lib$3.jsxAttribute(attrName, null);
-			return import_lib$3.jsxAttribute(attrName, attrValue(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$3.jsxOpeningElement(elementName, attributes);
-		const closingElement = import_lib$3.jsxClosingElement(elementName);
+		const openingElement = import_lib$2.jsxOpeningElement(elementName, attributes);
+		const closingElement = import_lib$2.jsxClosingElement(elementName);
 		const children = buildChildElements(node);
-		return import_lib$3.jsxElement(openingElement, closingElement, children, false);
+		return import_lib$2.jsxElement(openingElement, closingElement, children, false);
 	} catch (error) {
 		console.error("❌ DataAttrNode to JSX conversion error:", error);
 		return null;
@@ -461,21 +441,21 @@ const createFragmentNode = (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));
+	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$3.isJSXElement(child)) {
+		if (import_lib$2.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)) {
+		} else if (import_lib$2.isJSXFragment(child)) {
 			processedNodes?.add(child);
 			const fragmentChildren = [];
 			child.children.forEach((fragmentChild) => {
-				if (import_lib$3.isJSXElement(fragmentChild)) {
+				if (import_lib$2.isJSXElement(fragmentChild)) {
 					const childResults = extractFromNode(fragmentChild, processedNodes);
 					fragmentChildren.push(...childResults);
 				}
@@ -489,21 +469,21 @@ const processChildrenBinding = (jsxElement, processedNodes, shouldWrap = true) =
 	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 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$3.isJSXElement(node) || import_lib$3.isJSXFragment(node)) {
+	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$3.isJSXExpressionContainer(node) || import_lib$3.isParenthesizedExpression(node)) markProcessedJSX(node.expression, processedNodes);
+	if (import_lib$2.isJSXExpressionContainer(node) || import_lib$2.isParenthesizedExpression(node)) markProcessedJSX(node.expression, processedNodes);
 };
 const readNodeBindingInfo = (node) => {
 	const opening = node.openingElement;
@@ -527,14 +507,15 @@ const readNodeBindingInfo = (node) => {
 	};
 };
 const parseToNodes = (raw) => {
-	const ast = (0, import_lib$2.parse)(wrap(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();
-	(0, import_lib.default)(ast, { JSXElement(path) {
+	traverse(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;
@@ -588,18 +569,17 @@ function extractFromNode(node, processedNodes) {
 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));
+	for (let i = jsxChildren.length - 1; i >= 0; i--) if (import_lib$2.isJSXText(jsxChildren[i])) jsxChildren.splice(i, 1);
+	jsxChildren.push(import_lib$2.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));
+	const container = import_lib$2.jsxExpressionContainer(import_lib$2.identifier(name));
 	placeholders.set(asRawContent ? `{${name}}` : name, value);
 	return container;
 };
@@ -624,20 +604,21 @@ const updateChildren = (path, value) => {
 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)));
+	const htmlObject = import_lib$2.objectExpression([import_lib$2.objectProperty(import_lib$2.identifier("__html"), import_lib$2.stringLiteral(value))]);
+	const existingAttr = opening.attributes.find((a) => import_lib$2.isJSXAttribute(a) && import_lib$2.isJSXIdentifier(a.name) && a.name.name === "dangerouslySetInnerHTML");
+	if (existingAttr && import_lib$2.isJSXAttribute(existingAttr)) existingAttr.value = import_lib$2.jsxExpressionContainer(htmlObject);
+	else opening.attributes.push(import_lib$2.jsxAttribute(import_lib$2.jsxIdentifier("dangerouslySetInnerHTML"), import_lib$2.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 customAttr = opening.attributes.find((attr) => import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === propertyName);
+	if (customAttr && import_lib$2.isJSXAttribute(customAttr)) {
 		const trimmed = value.trim();
+		const isExpression = trimmed.startsWith("[") || trimmed.startsWith("{") || REGEX.NUMBER.test(trimmed) || REGEX.BOOLEAN_OR_NULL.test(trimmed);
 		customAttr.value = attrValue({
 			name: propertyName,
 			value,
-			isStringLiteral: !(trimmed.startsWith("[") || trimmed.startsWith("{") || REGEX.NUMBER.test(trimmed) || REGEX.BOOLEAN_OR_NULL.test(trimmed))
+			isStringLiteral: !isExpression
 		});
 		return true;
 	}
@@ -645,22 +626,23 @@ const updateAttribute = (opening, propertyName, value) => {
 };
 const update = (code, dataId, label, value) => {
 	try {
-		const ast = (0, import_lib$2.parse)(wrap(code), {
+		const wrapped = wrap(code);
+		const ast = (0, import_lib$1.parse)(wrapped, {
 			sourceType: "module",
 			plugins: ["jsx", "typescript"]
 		});
 		let changed = false;
 		const jsxPlaceholders = /* @__PURE__ */ new Map();
-		(0, import_lib.default)(ast, { JSXElement(path) {
+		traverse(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 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$3.isJSXAttribute(attr) && import_lib$3.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.BINDING);
+			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) return;
 			let bindingValue = "";
-			if (import_lib$3.isStringLiteral(bindingAttr.value)) bindingValue = bindingAttr.value.value;
-			else if (import_lib$3.isJSXExpressionContainer(bindingAttr.value)) try {
+			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 {
 				return;
@@ -678,15 +660,13 @@ const update = (code, dataId, label, value) => {
 				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;
+				default: if (propertyBinding.type === "jsx") {
+					const attr = opening.attributes.find((a) => import_lib$2.isJSXAttribute(a) && import_lib$2.isJSXIdentifier(a.name) && a.name.name === propertyBinding.property);
+					if (attr && import_lib$2.isJSXAttribute(attr)) {
+						attr.value = injectPlaceholder("JSX", value.trim(), jsxPlaceholders);
+						changed = true;
+					}
+				} else changed = updateAttribute(opening, propertyBinding.property, value);
 			}
 		} });
 		if (!changed) return {
@@ -720,7 +700,6 @@ const bulkUpdate = (raw, entries) => {
 		success: allSucceeded
 	};
 };
-
 //#endregion
 //#region src/utils/ast/tree.ts
 const replaceIds = (code, generateId = () => nanoid(6)) => {
@@ -734,9 +713,11 @@ const fillIds = (code, generateId = () => nanoid(6)) => {
 	});
 };
 const clone = (element, generateId = () => nanoid(6)) => {
-	return (0, import_lib$2.parseExpression)(replaceIds(generateCode(import_lib$3.cloneNode(element, true)), generateId), { plugins: ["jsx", "typescript"] });
+	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 };
@@ -786,7 +767,7 @@ const validateBindingValue = (binding, value) => {
 	}
 	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-C0FNDLFQ.mjs.map
+
+//# sourceMappingURL=ast-Dq1EfxA5.js.map