sculpted 0.0.0 → 0.1.0

package/dist/patcher-BAw2kF1Q.mjs

@@ -0,0 +1,2594 @@
+import "./protocol-BJm-xGHP.mjs";
+import { parseModule } from "@tsrx/core";
+import ts from "typescript";
+import { resolve } from "node:path";
+//#region src/sourceSyntax.ts
+function parseWithSourceParserAdapter(adapter, options) {
+	return resolveSourceParserAdapter(options.filePath, adapter).parse(options);
+}
+function parsePandaSource(adapter, options) {
+	const parsed = parseWithSourceParserAdapter(adapter, options);
+	if (parsed.kind === "typescript") return {
+		astKind: "typescript",
+		languageId: parsed.languageId,
+		filePath: options.filePath,
+		sourceText: options.sourceText,
+		root: parsed.sourceFile,
+		ops: typescriptPandaAstAdapter
+	};
+	const ops = createEstreePandaAstAdapter(parsed.program);
+	return {
+		astKind: "estree",
+		languageId: parsed.languageId,
+		filePath: options.filePath,
+		sourceText: options.sourceText,
+		root: parsed.program,
+		ops
+	};
+}
+function resolveSourceParserAdapter(filePath, adapter) {
+	return [tsxSourceParserAdapter, ...Array.isArray(adapter) ? adapter : adapter ? [adapter] : []].find((item) => item.isSupportedFile(filePath)) ?? tsxSourceParserAdapter;
+}
+const tsxSourceParserAdapter = {
+	languageId: "tsx",
+	kind: "typescript",
+	isSupportedFile(filePath) {
+		return /\.(?:[cm]?tsx?|[cm]?jsx)$/.test(filePath);
+	},
+	parse(options) {
+		return {
+			kind: "typescript",
+			languageId: "tsx",
+			sourceFile: ts.createSourceFile(options.filePath, options.sourceText, ts.ScriptTarget.Latest, true, scriptKindForFile(options.filePath))
+		};
+	}
+};
+const tsxSourceSyntaxAdapter = tsxSourceParserAdapter;
+const tsrxSourceParserAdapter = {
+	languageId: "tsrx",
+	kind: "estree",
+	isSupportedFile(filePath) {
+		return filePath.endsWith(".tsrx");
+	},
+	parse(options) {
+		const comments = [];
+		return {
+			kind: "estree",
+			languageId: "tsrx",
+			program: parseModule(options.sourceText, options.filePath, {
+				collect: true,
+				comments
+			}),
+			comments
+		};
+	}
+};
+function scriptKindForFile(filePath) {
+	if (/\.[cm]?tsx$/.test(filePath)) return ts.ScriptKind.TSX;
+	if (/\.[cm]?jsx$/.test(filePath)) return ts.ScriptKind.JSX;
+	return ts.ScriptKind.TS;
+}
+const typescriptPandaAstAdapter = {
+	astKind: "typescript",
+	walk(root, visit) {
+		const walkNode = (node, parent) => {
+			visit(node, parent);
+			ts.forEachChild(node, (child) => walkNode(child, node));
+		};
+		walkNode(root, void 0);
+	},
+	topLevelStatements(root) {
+		return [...root.statements];
+	},
+	isImportDeclaration(node) {
+		return ts.isImportDeclaration(node);
+	},
+	getImportSource(node) {
+		return ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : void 0;
+	},
+	getNamedImportBindings(node) {
+		if (!ts.isImportDeclaration(node)) return [];
+		const namedBindings = node.importClause?.namedBindings;
+		if (!namedBindings || !ts.isNamedImports(namedBindings)) return [];
+		return namedBindings.elements.map((element) => ({
+			imported: element.propertyName?.text ?? element.name.text,
+			local: element.name.text
+		}));
+	},
+	isCallExpression(node) {
+		return ts.isCallExpression(node);
+	},
+	getCallCalleeIdentifier(node) {
+		return ts.isCallExpression(node) && ts.isIdentifier(node.expression) ? node.expression.text : void 0;
+	},
+	getCallArguments(node) {
+		return ts.isCallExpression(node) ? [...node.arguments] : [];
+	},
+	isObjectExpression(node) {
+		return ts.isObjectLiteralExpression(node);
+	},
+	getObjectProperties(node) {
+		return ts.isObjectLiteralExpression(node) ? [...node.properties] : [];
+	},
+	isPlainProperty(node) {
+		return ts.isPropertyAssignment(node);
+	},
+	isSpreadProperty(node) {
+		return ts.isSpreadAssignment(node);
+	},
+	getPropertyName(node) {
+		if (!ts.isPropertyAssignment(node)) return void 0;
+		const name = node.name;
+		if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+	},
+	getPropertyValue(node) {
+		return ts.isPropertyAssignment(node) ? node.initializer : void 0;
+	},
+	getLiteralValue(node) {
+		if (!ts.isExpression(node)) return void 0;
+		return literalJsonValue(node);
+	},
+	isIdentifier(node) {
+		return ts.isIdentifier(node);
+	},
+	getRange(node) {
+		return {
+			start: node.getStart(),
+			end: node.getEnd()
+		};
+	},
+	getLocation(node) {
+		const sourceFile = node.getSourceFile();
+		const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+		const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+		return {
+			start: {
+				line: start.line + 1,
+				column: start.character + 1
+			},
+			end: {
+				line: end.line + 1,
+				column: end.character + 1
+			}
+		};
+	},
+	findObjectExpressionAtRange(root, range) {
+		let result;
+		this.walk(root, (node) => {
+			if (result === void 0 && ts.isObjectLiteralExpression(node) && node.getStart(root) === range.start && node.getEnd() === range.end) result = node;
+		});
+		return result;
+	},
+	getParent(_root, node) {
+		return node.parent;
+	},
+	nodeContains(root, target) {
+		let found = false;
+		const visit = (node) => {
+			if (found) return;
+			if (node === target) {
+				found = true;
+				return;
+			}
+			ts.forEachChild(node, visit);
+		};
+		visit(root);
+		return found;
+	},
+	getVariableDeclaratorName(node) {
+		if (!ts.isVariableDeclaration(node)) return void 0;
+		return ts.isIdentifier(node.name) ? node.name.text : void 0;
+	},
+	getVariableDeclaratorInitializer(node) {
+		return ts.isVariableDeclaration(node) ? node.initializer : void 0;
+	},
+	isVariableDeclaratorInitializer(node, child) {
+		return ts.isVariableDeclaration(node) && node.initializer === child;
+	},
+	getPropertyOwnerName(node) {
+		return ts.isPropertyAssignment(node) ? this.getPropertyName(node) : void 0;
+	},
+	isPropertyValue(node, child) {
+		return ts.isPropertyAssignment(node) && node.initializer === child;
+	},
+	isJsxBoundary(node) {
+		return ts.isJsxExpression(node) || ts.isJsxAttribute(node);
+	},
+	firstImportEnd(root) {
+		let position = 0;
+		for (const statement of root.statements) {
+			if (!ts.isImportDeclaration(statement)) break;
+			position = statement.getEnd();
+		}
+		return position;
+	},
+	isPatchableLiteral(node) {
+		return ts.isExpression(node) && literalJsonValue(node) !== void 0;
+	}
+};
+function literalJsonValue(node) {
+	if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+	if (ts.isNumericLiteral(node)) return Number(node.text);
+	if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand)) return -Number(node.operand.text);
+	if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+	if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+	if (node.kind === ts.SyntaxKind.NullKeyword) return null;
+}
+function createEstreePandaAstAdapter(root) {
+	const parents = /* @__PURE__ */ new Map();
+	const childrenOf = (node) => {
+		const children = [];
+		for (const [key, value] of Object.entries(node)) {
+			if (key === "loc" || key === "metadata" || key === "comments" || key === "leadingComments" || key === "trailingComments") continue;
+			if (isEstreeNode(value)) children.push(value);
+			else if (Array.isArray(value)) {
+				for (const item of value) if (isEstreeNode(item)) children.push(item);
+			}
+		}
+		return children;
+	};
+	const walkedForParents = /* @__PURE__ */ new Set();
+	const walkNode = (node, parent) => {
+		if (walkedForParents.has(node)) return;
+		walkedForParents.add(node);
+		parents.set(node, parent);
+		for (const child of childrenOf(node)) walkNode(child, node);
+	};
+	walkNode(root, void 0);
+	return {
+		astKind: "estree",
+		walk(nextRoot, visit) {
+			const seen = /* @__PURE__ */ new Set();
+			const visitNode = (node, parent) => {
+				if (seen.has(node)) return;
+				seen.add(node);
+				visit(node, parent);
+				for (const child of childrenOf(node)) visitNode(child, node);
+			};
+			visitNode(nextRoot, void 0);
+		},
+		topLevelStatements(nextRoot) {
+			return Array.isArray(nextRoot.body) ? nextRoot.body.filter(isEstreeNode) : [];
+		},
+		isImportDeclaration(node) {
+			return node.type === "ImportDeclaration";
+		},
+		getImportSource(node) {
+			if (node.type !== "ImportDeclaration") return void 0;
+			const source = node.source;
+			return isEstreeNode(source) && typeof source.value === "string" ? source.value : void 0;
+		},
+		getNamedImportBindings(node) {
+			if (node.type !== "ImportDeclaration" || !Array.isArray(node.specifiers)) return [];
+			return node.specifiers.filter(isEstreeNode).flatMap((specifier) => {
+				if (specifier.type !== "ImportSpecifier") return [];
+				const imported = specifier.imported;
+				const local = specifier.local;
+				if (!isEstreeNode(imported) || !isEstreeNode(local)) return [];
+				const importedName = identifierOrLiteralName(imported);
+				const localName = identifierOrLiteralName(local);
+				return importedName && localName ? [{
+					imported: importedName,
+					local: localName
+				}] : [];
+			});
+		},
+		isCallExpression(node) {
+			return node.type === "CallExpression";
+		},
+		getCallCalleeIdentifier(node) {
+			if (node.type !== "CallExpression" || !isEstreeNode(node.callee)) return void 0;
+			return node.callee.type === "Identifier" && typeof node.callee.name === "string" ? node.callee.name : void 0;
+		},
+		getCallArguments(node) {
+			return node.type === "CallExpression" && Array.isArray(node.arguments) ? node.arguments.filter(isEstreeNode) : [];
+		},
+		isObjectExpression(node) {
+			return node.type === "ObjectExpression";
+		},
+		getObjectProperties(node) {
+			return node.type === "ObjectExpression" && Array.isArray(node.properties) ? node.properties.filter(isEstreeNode) : [];
+		},
+		isPlainProperty(node) {
+			return node.type === "Property" && node.kind === "init" && node.method !== true;
+		},
+		isSpreadProperty(node) {
+			return node.type === "SpreadElement" || node.type === "SpreadProperty";
+		},
+		getPropertyName(node) {
+			if (node.type !== "Property" || node.computed === true || !isEstreeNode(node.key)) return;
+			return identifierOrLiteralName(node.key);
+		},
+		getPropertyValue(node) {
+			return node.type === "Property" && isEstreeNode(node.value) ? node.value : void 0;
+		},
+		getLiteralValue(node) {
+			if (node.type === "Literal") return isJsonLiteral(node.value) ? node.value : void 0;
+			if (node.type === "UnaryExpression" && node.operator === "-" && isEstreeNode(node.argument) && node.argument.type === "Literal" && typeof node.argument.value === "number") return -node.argument.value;
+		},
+		isIdentifier(node) {
+			return node.type === "Identifier";
+		},
+		getRange(node) {
+			return {
+				start: numericPosition(node.start),
+				end: numericPosition(node.end)
+			};
+		},
+		getLocation(node) {
+			const loc = node.loc;
+			if (!loc) return {
+				start: {
+					line: 1,
+					column: 1
+				},
+				end: {
+					line: 1,
+					column: 1
+				}
+			};
+			return {
+				start: {
+					line: loc.start.line,
+					column: loc.start.column + 1
+				},
+				end: {
+					line: loc.end.line,
+					column: loc.end.column + 1
+				}
+			};
+		},
+		findObjectExpressionAtRange(nextRoot, range) {
+			let result;
+			this.walk(nextRoot, (node) => {
+				if (result === void 0 && node.type === "ObjectExpression" && numericPosition(node.start) === range.start && numericPosition(node.end) === range.end) result = node;
+			});
+			return result;
+		},
+		getParent(_root, node) {
+			return parents.get(node);
+		},
+		nodeContains(nextRoot, target) {
+			let found = false;
+			this.walk(nextRoot, (node) => {
+				if (node === target) found = true;
+			});
+			return found;
+		},
+		getVariableDeclaratorName(node) {
+			if (node.type !== "VariableDeclarator" || !isEstreeNode(node.id)) return void 0;
+			return node.id.type === "Identifier" && typeof node.id.name === "string" ? node.id.name : void 0;
+		},
+		getVariableDeclaratorInitializer(node) {
+			return node.type === "VariableDeclarator" && isEstreeNode(node.init) ? node.init : void 0;
+		},
+		isVariableDeclaratorInitializer(node, child) {
+			return node.type === "VariableDeclarator" && node.init === child;
+		},
+		getPropertyOwnerName(node) {
+			return node.type === "Property" ? this.getPropertyName(node) : void 0;
+		},
+		isPropertyValue(node, child) {
+			return node.type === "Property" && node.value === child;
+		},
+		isJsxBoundary(node) {
+			return node.type === "JSXExpressionContainer" || node.type === "Attribute";
+		},
+		firstImportEnd(nextRoot) {
+			let position = 0;
+			for (const statement of this.topLevelStatements(nextRoot)) {
+				if (statement.type !== "ImportDeclaration") break;
+				position = numericPosition(statement.end);
+			}
+			return position;
+		},
+		isPatchableLiteral(node) {
+			return this.getLiteralValue(node) !== void 0;
+		}
+	};
+}
+function isEstreeNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function identifierOrLiteralName(node) {
+	if (node.type === "Identifier" && typeof node.name === "string") return node.name;
+	if (node.type === "Literal") {
+		if (typeof node.value === "string") return node.value;
+		if (typeof node.value === "number") return String(node.value);
+	}
+}
+function isJsonLiteral(value) {
+	return value === null || [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value);
+}
+function numericPosition(value) {
+	return typeof value === "number" ? value : 0;
+}
+//#endregion
+//#region src/analyzer/pandaCssAnalyzer.ts
+const DEFAULT_CSS_IMPORT_SOURCES$1 = [
+	"../styled-system/css",
+	"@/styled-system/css",
+	"styled-system/css"
+];
+function analyzePandaCssSource(options) {
+	const source = parsePandaSource(options.sourceSyntax, {
+		filePath: options.filePath,
+		sourceText: options.sourceText
+	});
+	const cssImportSources = new Set(options.cssImportSources ?? DEFAULT_CSS_IMPORT_SOURCES$1);
+	const cssNames = /* @__PURE__ */ new Set();
+	for (const statement of source.ops.topLevelStatements(source.root)) {
+		if (!source.ops.isImportDeclaration(statement)) continue;
+		const importSource = source.ops.getImportSource(statement);
+		if (!importSource || !cssImportSources.has(importSource)) continue;
+		for (const binding of source.ops.getNamedImportBindings(statement)) if (binding.imported === "css") cssNames.add(binding.local);
+	}
+	if (cssNames.size === 0) return { entries: [] };
+	const entries = [];
+	let ordinal = 0;
+	source.ops.walk(source.root, (node) => {
+		const callee = source.ops.getCallCalleeIdentifier(node);
+		if (source.ops.isCallExpression(node) && callee && cssNames.has(callee)) entries.push(createEntry(source, options, node, ordinal++));
+	});
+	return { entries };
+}
+function createEntry(source, options, call, ordinal) {
+	const file = toRelativeProjectPath$1(options.filePath, options.projectRoot);
+	const callStart = source.ops.getRange(call).start;
+	const callPosition = positionAt(source.sourceText, callStart);
+	const id = `${file}:${callPosition.line}:${callPosition.column}#${ordinal}`;
+	const firstArg = source.ops.getCallArguments(call)[0];
+	if (!firstArg) return unsupportedEntry(source, options, call, id, "unsupported-source-shape", "css() has no style object");
+	if (!source.ops.isObjectExpression(firstArg)) return unsupportedEntry(source, options, call, id, source.ops.isIdentifier(firstArg) ? "variable-reference" : "dynamic-expression", "css() argument is not a local object literal");
+	const extracted = extractStyleObject(source, firstArg);
+	if (!extracted.ok) return unsupportedEntry(source, options, call, id, extracted.reason, extracted.description);
+	const range = source.ops.getRange(firstArg);
+	const name = cssSourceName(source, call);
+	return {
+		protocolVersion: 1,
+		id,
+		kind: "panda-css",
+		file,
+		absoluteFile: normalizePath$5(options.filePath),
+		range,
+		loc: source.ops.getLocation(firstArg),
+		sourceHash: hashSource(options.sourceText.slice(range.start, range.end)),
+		...name ? { name } : {},
+		confidence: "high",
+		reason: "static local css() object literal",
+		callee: source.ops.getCallCalleeIdentifier(call) ?? "css",
+		styleObject: extracted.styleObject,
+		dynamic: false
+	};
+}
+function cssSourceName(source, call) {
+	let current = call;
+	while (true) {
+		const parent = source.ops.getParent(source.root, current);
+		if (!parent) return void 0;
+		if (source.ops.isJsxBoundary(parent)) return;
+		if (source.ops.isPropertyValue(parent, current)) return source.ops.getPropertyOwnerName(parent);
+		if (source.ops.isVariableDeclaratorInitializer(parent, current)) return source.ops.getVariableDeclaratorName(parent);
+		const propertyName = source.ops.getPropertyOwnerName(parent);
+		const propertyValue = source.ops.getPropertyValue(parent);
+		if (propertyName && propertyValue && source.ops.nodeContains(propertyValue, call)) return propertyName;
+		const variableName = source.ops.getVariableDeclaratorName(parent);
+		const initializer = source.ops.getVariableDeclaratorInitializer(parent);
+		if (variableName && initializer && source.ops.nodeContains(initializer, call)) return variableName;
+		current = parent;
+	}
+}
+function unsupportedEntry(source, options, call, id, reason, description) {
+	const file = toRelativeProjectPath$1(options.filePath, options.projectRoot);
+	const range = source.ops.getRange(call);
+	return {
+		protocolVersion: 1,
+		id,
+		kind: "dynamic",
+		file,
+		absoluteFile: normalizePath$5(options.filePath),
+		range,
+		loc: source.ops.getLocation(call),
+		sourceHash: hashSource(options.sourceText.slice(range.start, range.end)),
+		confidence: "low",
+		reason: description,
+		dynamic: true,
+		unsupportedReason: reason
+	};
+}
+function extractStyleObject(source, objectNode) {
+	const styleObject = {};
+	for (const property of source.ops.getObjectProperties(objectNode)) {
+		if (source.ops.isSpreadProperty(property)) return {
+			ok: false,
+			reason: "spread-value",
+			description: "Object spread can change which style keys exist at runtime"
+		};
+		if (!source.ops.isPlainProperty(property)) return {
+			ok: false,
+			reason: "unsupported-source-shape",
+			description: "Only plain property assignments are supported in css() objects"
+		};
+		const name = source.ops.getPropertyName(property);
+		if (name === void 0) return {
+			ok: false,
+			reason: "unsupported-source-shape",
+			description: "Computed style property names are not safe to map to source paths"
+		};
+		const propertyValue = source.ops.getPropertyValue(property);
+		if (!propertyValue) return {
+			ok: false,
+			reason: "unsupported-source-shape",
+			description: "Style property has no value that can be patched"
+		};
+		const value = extractStyleValue(source, propertyValue);
+		if (!value.ok) return value;
+		styleObject[name] = value.value;
+	}
+	return {
+		ok: true,
+		styleObject
+	};
+}
+function extractStyleValue(source, node) {
+	if (source.ops.isObjectExpression(node)) {
+		const object = extractStyleObject(source, node);
+		if (!object.ok) return object;
+		return {
+			ok: true,
+			value: object.styleObject
+		};
+	}
+	const literal = source.ops.getLiteralValue(node);
+	if (literal !== void 0) return {
+		ok: true,
+		value: {
+			kind: "literal",
+			value: literal,
+			range: source.ops.getRange(node),
+			loc: source.ops.getLocation(node)
+		}
+	};
+	return {
+		ok: false,
+		reason: source.ops.isIdentifier(node) ? "variable-reference" : "dynamic-expression",
+		description: "Style value is not a literal that can be patched without evaluating user code"
+	};
+}
+function positionAt(sourceText, position) {
+	let line = 1;
+	let lineStart = 0;
+	for (let index = 0; index < position; index += 1) if (sourceText.charCodeAt(index) === 10) {
+		line += 1;
+		lineStart = index + 1;
+	}
+	return {
+		line,
+		column: position - lineStart + 1
+	};
+}
+function toRelativeProjectPath$1(filePath, projectRoot) {
+	const file = normalizePath$5(filePath);
+	if (!projectRoot) return file;
+	const root = normalizePath$5(projectRoot).replace(/\/$/, "");
+	if (file === root) return file.split("/").at(-1) ?? file;
+	if (file.startsWith(`${root}/`)) return file.slice(root.length + 1);
+	return file;
+}
+function normalizePath$5(path) {
+	return path.replace(/\\/g, "/");
+}
+function hashSource(source) {
+	let hash = 5381;
+	for (let index = 0; index < source.length; index += 1) hash = hash * 33 ^ source.charCodeAt(index);
+	return (hash >>> 0).toString(16);
+}
+//#endregion
+//#region src/patcher/inlineCssSourcePatcher.ts
+const DEFAULT_INLINE_CSS_IMPORT_SOURCES = [
+	"../styled-system/css",
+	"@/styled-system/css",
+	"styled-system/css"
+];
+function createInlineCssSourcePatch(options) {
+	const { request, sourceText } = options;
+	const parsed = parseJsxSource(request.jsxSource);
+	if (!parsed.ok) return failure$3(request.editId, parsed.code, parsed.message, parsed.details);
+	const normalizedFile = normalizePath$4(options.filePath);
+	if (normalizedFile !== normalizePath$4(`${options.projectRoot.replace(/\/$/, "")}/${parsed.file}`)) return failure$3(request.editId, "stale-source", "JSX source location points to a different file.", {
+		filePath: normalizedFile,
+		jsxSource: request.jsxSource
+	});
+	let source;
+	try {
+		source = parsePandaSource(options.sourceSyntax, {
+			filePath: options.filePath,
+			sourceText
+		});
+	} catch (error) {
+		return failure$3(request.editId, "parse-error", "Source could not be parsed for writeback.", { message: error instanceof Error ? error.message : String(error) });
+	}
+	if (source.astKind !== "typescript") return failure$3(request.editId, "unsupported-source-shape", "Inline Panda source creation is not supported for ESTree-backed source yet.");
+	const sourceFile = source.root;
+	const position = positionForLineColumn$1(sourceFile, parsed.line, parsed.column);
+	if (position === void 0) return failure$3(request.editId, "stale-source", "JSX source location is outside the file.");
+	const element = findJsxElementAtStart$1(sourceFile, position);
+	if (!element) return failure$3(request.editId, "stale-source", "JSX source location no longer points to a JSX element.");
+	const existingImport = findCssImportBinding$1(sourceFile, options.cssImportSources);
+	const cssLocalName = existingImport?.localName ?? availableCssLocalName(sourceFile);
+	const replacements = [];
+	const attributeReplacement = inlineCssAttributeReplacement(sourceFile, sourceText, element, cssLocalName, existingImport?.localName);
+	if (!attributeReplacement.ok) return failure$3(request.editId, attributeReplacement.code, attributeReplacement.message, attributeReplacement.details);
+	replacements.push(attributeReplacement.replacement);
+	if (!existingImport) replacements.push({
+		range: {
+			start: importInsertionPosition$2(sourceFile),
+			end: importInsertionPosition$2(sourceFile)
+		},
+		text: cssImportText$1(cssLocalName, options.cssImportSources)
+	});
+	const nextSource = applyReplacements$3(sourceText, replacements);
+	const file = parsed.file;
+	return {
+		ok: true,
+		editId: request.editId,
+		file,
+		diff: focusedDiff$3(file, sourceText, nextSource, replacements),
+		nextSource,
+		written: false
+	};
+}
+function inlineCssAttributeReplacement(sourceFile, sourceText, element, cssLocalName, existingCssLocalName) {
+	let classAttribute;
+	for (const property of element.attributes.properties) {
+		if (!ts.isJsxAttribute(property) || !ts.isIdentifier(property.name)) continue;
+		if (property.name.text !== "class" && property.name.text !== "className") continue;
+		classAttribute = property;
+		const expression = property.initializer && jsxAttributeExpression$2(property.initializer);
+		if (expression && existingCssLocalName && containsInlineCssCall(sourceFile, expression, existingCssLocalName)) return {
+			ok: false,
+			code: "unsupported-operation",
+			message: "This JSX element already has an inline css() source."
+		};
+		break;
+	}
+	if (!classAttribute) {
+		const insertPosition = element.getEnd() - (ts.isJsxSelfClosingElement(element) ? 2 : 1);
+		return {
+			ok: true,
+			replacement: {
+				range: {
+					start: insertPosition,
+					end: insertPosition
+				},
+				text: ` class={${cssLocalName}({})}`
+			}
+		};
+	}
+	if (!ts.isIdentifier(classAttribute.name)) return {
+		ok: false,
+		code: "unsupported-source-shape",
+		message: "Namespaced JSX class attributes cannot receive inline css() sources."
+	};
+	const attributeName = classAttribute.name.text;
+	const inlineCssCall = `${cssLocalName}({})`;
+	if (!classAttribute.initializer) return {
+		ok: true,
+		replacement: {
+			range: {
+				start: classAttribute.getStart(sourceFile),
+				end: classAttribute.getEnd()
+			},
+			text: `${attributeName}={${inlineCssCall}}`
+		}
+	};
+	if (ts.isStringLiteral(classAttribute.initializer)) return {
+		ok: true,
+		replacement: {
+			range: {
+				start: classAttribute.getStart(sourceFile),
+				end: classAttribute.getEnd()
+			},
+			text: `${attributeName}={\`${escapeTemplateText$1(classAttribute.initializer.text)} \${${inlineCssCall}}\`}`
+		}
+	};
+	const expression = jsxAttributeExpression$2(classAttribute.initializer);
+	if (!expression) return {
+		ok: false,
+		code: "unsupported-source-shape",
+		message: "Only string and expression class attributes can receive inline css() sources."
+	};
+	const expressionText = sourceText.slice(expression.getStart(sourceFile), expression.getEnd());
+	return {
+		ok: true,
+		replacement: {
+			range: {
+				start: classAttribute.getStart(sourceFile),
+				end: classAttribute.getEnd()
+			},
+			text: `${attributeName}={[${expressionText}, ${inlineCssCall}].filter(Boolean).join(' ')}`
+		}
+	};
+}
+function jsxAttributeExpression$2(initializer) {
+	if (ts.isJsxExpression(initializer)) return initializer.expression;
+}
+function findJsxElementAtStart$1(sourceFile, position) {
+	let result;
+	const visit = (node) => {
+		if (result) return;
+		if ((ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) && node.getStart(sourceFile) === position) {
+			result = node;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return result;
+}
+function containsInlineCssCall(sourceFile, expression, cssLocalName) {
+	let found = false;
+	const visit = (node) => {
+		if (found) return;
+		if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === cssLocalName && ts.isObjectLiteralExpression(node.arguments[0])) {
+			found = true;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(expression);
+	return found;
+}
+function findCssImportBinding$1(sourceFile, cssImportSources) {
+	const importSources = new Set(cssImportSources ?? DEFAULT_INLINE_CSS_IMPORT_SOURCES);
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement)) continue;
+		if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		if (!importSources.has(statement.moduleSpecifier.text)) continue;
+		const namedBindings = statement.importClause?.namedBindings;
+		if (!namedBindings || !ts.isNamedImports(namedBindings)) continue;
+		for (const element of namedBindings.elements) if ((element.propertyName?.text ?? element.name.text) === "css") return {
+			localName: element.name.text,
+			moduleSpecifier: statement.moduleSpecifier.text
+		};
+	}
+}
+function availableCssLocalName(sourceFile) {
+	const identifiers = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (ts.isIdentifier(node)) identifiers.add(node.text);
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return identifiers.has("css") ? "pandaCss" : "css";
+}
+function cssImportText$1(cssLocalName, cssImportSources) {
+	const moduleSpecifier = cssImportSources?.[0] ?? DEFAULT_INLINE_CSS_IMPORT_SOURCES[0];
+	return `import { ${cssLocalName === "css" ? "css" : `css as ${cssLocalName}`} } from '${moduleSpecifier}'\n`;
+}
+function importInsertionPosition$2(sourceFile) {
+	let position = 0;
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement)) break;
+		position = statement.getEnd();
+	}
+	return position === 0 ? 0 : position + 1;
+}
+function parseJsxSource(source) {
+	const match = /^(.*):(\d+):(\d+)$/.exec(source.trim());
+	const file = match?.[1]?.trim();
+	const line = match?.[2] ? Number.parseInt(match[2], 10) : void 0;
+	const column = match?.[3] ? Number.parseInt(match[3], 10) : void 0;
+	if (!match || !file || line === void 0 || column === void 0 || line < 1 || column < 1) return {
+		ok: false,
+		code: "invalid-edit",
+		message: "Inline source creation requires a JSX source path with line and column.",
+		details: { source }
+	};
+	return {
+		ok: true,
+		file,
+		line,
+		column
+	};
+}
+function positionForLineColumn$1(sourceFile, line, column) {
+	const lineStart = sourceFile.getLineStarts()[line - 1];
+	if (lineStart === void 0) return void 0;
+	const position = lineStart + column - 1;
+	return position <= sourceFile.text.length ? position : void 0;
+}
+function escapeTemplateText$1(value) {
+	return value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+function applyReplacements$3(sourceText, replacements) {
+	let nextSource = sourceText;
+	for (const replacement of [...replacements].sort((left, right) => right.range.start - left.range.start)) nextSource = `${nextSource.slice(0, replacement.range.start)}${replacement.text}${nextSource.slice(replacement.range.end)}`;
+	return nextSource;
+}
+function focusedDiff$3(file, sourceText, nextSource, replacements) {
+	const firstStart = Math.min(...replacements.map((replacement) => replacement.range.start));
+	const lastEnd = Math.max(...replacements.map((replacement) => replacement.range.end));
+	const oldStartLine = lineNumberAt$3(sourceText, firstStart);
+	const oldEndLine = lineNumberAt$3(sourceText, lastEnd);
+	const contextStartLine = Math.max(1, oldStartLine - 2);
+	const contextEndLine = oldEndLine + 2;
+	const oldLines = sourceText.split("\n");
+	const newLines = nextSource.split("\n");
+	const oldSlice = oldLines.slice(contextStartLine - 1, contextEndLine);
+	const newSlice = newLines.slice(contextStartLine - 1, contextEndLine + (newLines.length - oldLines.length));
+	return [
+		`--- a/${file}`,
+		`+++ b/${file}`,
+		`@@ -${contextStartLine},${oldSlice.length} +${contextStartLine},${newSlice.length} @@`,
+		...oldSlice.map((line) => `-${line}`),
+		...newSlice.map((line) => `+${line}`)
+	].join("\n");
+}
+function lineNumberAt$3(sourceText, position) {
+	let line = 1;
+	for (let index = 0; index < position; index += 1) if (sourceText.charCodeAt(index) === 10) line += 1;
+	return line;
+}
+function normalizePath$4(path) {
+	return path.replace(/\\/g, "/");
+}
+function failure$3(editId, code, message, details) {
+	return {
+		ok: false,
+		editId,
+		written: false,
+		error: {
+			code,
+			message,
+			details
+		}
+	};
+}
+//#endregion
+//#region src/patcher/staticCssPatcher.ts
+function createStaticCssPatch(options) {
+	const { manifest, request, sourceText } = options;
+	const collected = collectPatchReplacements({
+		manifest,
+		request,
+		sourceText,
+		filePath: options.filePath,
+		styledSystemPackageName: options.styledSystemPackageName,
+		sourceSyntax: options.sourceSyntax
+	});
+	if (!collected.ok) return collected;
+	const overlap = findOverlappingReplacement(collected.replacements);
+	if (overlap) return failure$2(request.editId, "ambiguous-target", "Multiple edits target overlapping source ranges.", { ranges: overlap });
+	const nextSource = applyReplacements$2(sourceText, collected.replacements);
+	return {
+		ok: true,
+		editId: request.editId,
+		file: collected.entry.file,
+		diff: focusedDiff$2(collected.entry.file, sourceText, nextSource, collected.replacements),
+		nextSource,
+		written: false
+	};
+}
+function createStaticCssBatchPatch(options) {
+	const { requests, sourceText } = options;
+	const firstRequest = requests[0];
+	if (!firstRequest) return failure$2("", "invalid-edit", "Batch patch requires at least one style edit request.");
+	const collectedPatches = requests.map((request) => ({
+		request,
+		patch: collectPatchReplacements({
+			...options,
+			request
+		})
+	}));
+	const failurePatch = collectedPatches.find((item) => !item.patch.ok);
+	if (failurePatch && !failurePatch.patch.ok) return failurePatch.patch;
+	const successfulPatches = collectedPatches.map((item) => item.patch);
+	const replacements = dedupeIdenticalReplacements(successfulPatches.flatMap((patch) => patch.replacements));
+	const overlap = findOverlappingReplacement(replacements);
+	if (overlap) return failure$2(firstRequest.editId, "ambiguous-target", "Multiple edits target overlapping source ranges.", { ranges: overlap });
+	const nextSource = applyReplacements$2(sourceText, replacements);
+	const file = successfulPatches[0]?.entry.file ?? "";
+	return {
+		ok: true,
+		editId: requests.map((request) => request.editId).join(" "),
+		file,
+		diff: focusedDiff$2(file, sourceText, nextSource, replacements),
+		nextSource,
+		written: false
+	};
+}
+function collectPatchReplacements(options) {
+	const { manifest, request, sourceText } = options;
+	const entry = manifest.entries.find((item) => item.id === request.editId);
+	if (!entry) return failure$2(request.editId, "manifest-entry-not-found", "No manifest entry exists for edit id.");
+	if (request.kind !== "panda-css" || entry.kind !== "panda-css") return failure$2(request.editId, "unsupported-source-shape", "Only Panda css() entries can be patched.");
+	const fileFailure = validateProjectFile$1(manifest, entry, options.filePath);
+	if (fileFailure) return failure$2(request.editId, fileFailure.code, fileFailure.message, fileFailure.details);
+	if (!entry.range) return failure$2(request.editId, "unsupported-source-shape", "Manifest entry has no source range.");
+	if (!entry.sourceHash || hashSource(sourceText.slice(entry.range.start, entry.range.end)) !== entry.sourceHash) return failure$2(request.editId, "stale-source", "Source text no longer matches the manifest entry hash.");
+	if (request.options?.expectedSourceHash && request.options.expectedSourceHash !== entry.sourceHash) return failure$2(request.editId, "stale-source", "Edit request was prepared against a different source hash.", {
+		expectedSourceHash: request.options.expectedSourceHash,
+		actualSourceHash: entry.sourceHash
+	});
+	let source;
+	try {
+		source = parsePandaSource(options.sourceSyntax, {
+			filePath: entry.absoluteFile ?? entry.file,
+			sourceText
+		});
+	} catch (error) {
+		return failure$2(request.editId, "parse-error", "Source could not be parsed for writeback.", { message: error instanceof Error ? error.message : String(error) });
+	}
+	const objectNode = source.ops.findObjectExpressionAtRange(source.root, entry.range);
+	if (!objectNode) return failure$2(request.editId, "stale-source", "Manifest range no longer points to a css() object literal.");
+	const parentCall = source.ops.getParent(source.root, objectNode);
+	if (!parentCall || !source.ops.isCallExpression(parentCall) || source.ops.getCallCalleeIdentifier(parentCall) !== entry.callee) return failure$2(request.editId, "stale-source", "Manifest range no longer belongs to the expected css() call.");
+	const replacements = [];
+	const sourceFile = source.astKind === "typescript" ? source.root : void 0;
+	const tokenVarImportLocalName = sourceFile && options.styledSystemPackageName ? tokenImportLocalName(sourceFile, options.styledSystemPackageName) : void 0;
+	for (const edit of request.edits) {
+		if (edit.op === "rename" || edit.op === "replace-object") return failure$2(request.editId, "unsupported-operation", `Unsupported edit operation: ${edit.op}.`);
+		const editFailure = validateStyleEdit(edit);
+		if (editFailure) return failure$2(request.editId, editFailure.code, editFailure.message, editFailure.details);
+		const replacement = replacementForEdit(source, objectNode, edit, sourceText, {
+			path: edit.path,
+			tokenVarImportLocalName
+		});
+		if (!replacement.ok) return failure$2(request.editId, replacement.code, replacement.message, replacement.details);
+		replacements.push(replacement);
+	}
+	if (sourceFile && tokenVarImportLocalName && replacements.some((replacement) => replacement.text.includes(`${tokenVarImportLocalName}.var(`))) {
+		const tokenImport = tokenVarImportReplacement(sourceFile, options.styledSystemPackageName, tokenVarImportLocalName);
+		if (tokenImport) replacements.push(tokenImport);
+	}
+	if (sourceFile && source.astKind === "typescript" && rootObjectWillBeEmptyAfterEdits(objectNode, request.edits)) {
+		const inlineCleanup = inlineEmptyCssCleanupReplacement(objectNode, sourceFile, sourceText);
+		if (inlineCleanup) return {
+			ok: true,
+			entry,
+			replacements: [inlineCleanup]
+		};
+	}
+	return {
+		ok: true,
+		entry,
+		replacements
+	};
+}
+function validateProjectFile$1(manifest, entry, filePath) {
+	const root = normalizePath$3(manifest.projectRoot).replace(/\/$/, "");
+	if (!root) return {
+		code: "path-outside-project",
+		message: "Manifest project root is empty."
+	};
+	const absoluteFile = normalizePath$3(entry.absoluteFile ?? `${root}/${entry.file}`);
+	if (absoluteFile !== root && !absoluteFile.startsWith(`${root}/`)) return {
+		code: "path-outside-project",
+		message: "Manifest entry points outside the project root.",
+		details: {
+			file: absoluteFile,
+			projectRoot: root
+		}
+	};
+	if (filePath && normalizePath$3(filePath) !== absoluteFile) return {
+		code: "stale-source",
+		message: "Provided source file does not match the manifest entry file.",
+		details: {
+			filePath: normalizePath$3(filePath),
+			manifestFile: absoluteFile
+		}
+	};
+}
+function validateStyleEdit(edit) {
+	if (edit.path.length === 0 || edit.path.some((part) => part.length === 0)) return {
+		code: "invalid-path",
+		message: `${edit.op} edits require a non-empty style path.`,
+		details: { path: [...edit.path] }
+	};
+	if (edit.op === "set" && !isJsonPrimitive$1(edit.value)) return {
+		code: "unsupported-operation",
+		message: "Patching only supports literal primitive values.",
+		details: { path: [...edit.path] }
+	};
+}
+function replacementForEdit(source, objectNode, edit, sourceText, literalContext) {
+	let current = objectNode;
+	const { path } = edit;
+	for (let index = 0; index < path.length; index += 1) {
+		const part = path[index];
+		const located = locateProperty$1(source, current, part);
+		if (!located.ok) {
+			if (source.astKind === "typescript" && edit.op === "set" && located.reason.code === "invalid-path") {
+				if (!isJsonPrimitive$1(edit.value)) return {
+					ok: false,
+					code: "unsupported-operation",
+					message: "Patching only supports literal primitive values.",
+					details: { path: [...edit.path] }
+				};
+				return insertionForMissingNestedProperty(current, path.slice(index), edit.value, source.root, sourceText, literalContext);
+			}
+			return {
+				ok: false,
+				...located.reason
+			};
+		}
+		const initializer = source.ops.getPropertyValue(located.property);
+		if (!initializer) return {
+			ok: false,
+			code: "unsupported-source-shape",
+			message: "Target property has no patchable value.",
+			details: { path: [...path] }
+		};
+		if (index === path.length - 1) {
+			if (edit.op === "delete") {
+				if (source.astKind !== "typescript") return {
+					ok: false,
+					code: "unsupported-operation",
+					message: "Delete edits are not supported for ESTree-backed source yet.",
+					details: { path: [...path] }
+				};
+				return {
+					ok: true,
+					range: deletionRangeForProperty(current, located.property, source.root, sourceText),
+					text: ""
+				};
+			}
+			if (!source.ops.isPatchableLiteral(initializer)) return {
+				ok: false,
+				code: "unsupported-source-shape",
+				message: "Target path is not an existing literal value.",
+				details: { path: [...path] }
+			};
+			if (!isJsonPrimitive$1(edit.value)) return {
+				ok: false,
+				code: "unsupported-operation",
+				message: "Patching only supports literal primitive values.",
+				details: { path: [...edit.path] }
+			};
+			return {
+				ok: true,
+				range: source.ops.getRange(initializer),
+				text: literalSource$1(edit.value, literalContext)
+			};
+		}
+		if (!source.ops.isObjectExpression(initializer)) return {
+			ok: false,
+			code: "invalid-path",
+			message: "Target path descends through a non-object value.",
+			details: { path: path.slice(0, index + 1) }
+		};
+		current = initializer;
+	}
+	return {
+		ok: false,
+		code: "invalid-path",
+		message: `${edit.op} edits require a non-empty style path.`
+	};
+}
+function insertionForMissingNestedProperty(objectNode, path, value, sourceFile, sourceText, literalContext) {
+	const propertyName = path[0];
+	if (!propertyName) return {
+		ok: false,
+		code: "invalid-path",
+		message: "Missing nested property insertion requires a non-empty path."
+	};
+	return insertionForMissingProperty$1(objectNode, propertyName, nestedStyleObjectSource(path.slice(1), value, literalContext), sourceFile, sourceText, literalContext);
+}
+function insertionForMissingProperty$1(objectNode, propertyName, value, sourceFile, sourceText, literalContext) {
+	const closeBrace = objectNode.getEnd() - 1;
+	const multiline = sourceText.slice(objectNode.getStart(sourceFile), objectNode.getEnd()).includes("\n");
+	const property = `${propertyNameSource$1(propertyName)}: ${valueSource(value, {
+		...literalContext,
+		path: [...literalContext.path.slice(0, -1), propertyName]
+	})}`;
+	if (objectNode.properties.length === 0) {
+		if (!multiline) return {
+			ok: true,
+			range: {
+				start: closeBrace,
+				end: closeBrace
+			},
+			text: property
+		};
+		const parentIndent = indentationBefore$1(sourceText, objectNode.getStart(sourceFile));
+		const childIndent = `${parentIndent}  `;
+		return {
+			ok: true,
+			range: {
+				start: closeBrace,
+				end: closeBrace
+			},
+			text: `\n${childIndent}${property},\n${parentIndent}`
+		};
+	}
+	const lastProperty = objectNode.properties[objectNode.properties.length - 1];
+	const trailingComma = commaAfterNode$1(lastProperty, objectNode, sourceText);
+	if (!multiline) {
+		const insertAt = trailingComma ?? lastProperty.getEnd();
+		return {
+			ok: true,
+			range: {
+				start: insertAt,
+				end: insertAt
+			},
+			text: trailingComma === void 0 ? `, ${property}` : ` ${property}`
+		};
+	}
+	const childIndent = indentationBefore$1(sourceText, lastProperty.getStart(sourceFile));
+	if (trailingComma !== void 0) return {
+		ok: true,
+		range: {
+			start: trailingComma + 1,
+			end: trailingComma + 1
+		},
+		text: `\n${childIndent}${property},`
+	};
+	return {
+		ok: true,
+		range: {
+			start: lastProperty.getEnd(),
+			end: lastProperty.getEnd()
+		},
+		text: `,\n${childIndent}${property}`
+	};
+}
+function nestedStyleObjectSource(path, value, literalContext) {
+	if (path.length === 0) return {
+		kind: "raw-source",
+		text: literalSource$1(value, literalContext)
+	};
+	const [propertyName, ...rest] = path;
+	return {
+		kind: "raw-source",
+		text: `{ ${propertyNameSource$1(propertyName)}: ${nestedStyleObjectSource(rest, value, {
+			...literalContext,
+			path: [...literalContext.path.slice(0, -rest.length - 1), propertyName]
+		}).text} }`
+	};
+}
+function valueSource(value, context) {
+	if (isRawSourceValue(value)) return value.text;
+	return literalSource$1(value, context);
+}
+function isRawSourceValue(value) {
+	return typeof value === "object" && value !== null && "kind" in value && value.kind === "raw-source";
+}
+function commaAfterNode$1(node, objectNode, sourceText) {
+	for (let index = node.getEnd(); index < objectNode.getEnd() - 1; index += 1) {
+		const char = sourceText[index];
+		if (char === ",") return index;
+		if (!isWhitespace$1(char)) return void 0;
+	}
+}
+function isWhitespace$1(char) {
+	return char === " " || char === "	" || char === "\n" || char === "\r";
+}
+function indentationBefore$1(sourceText, position) {
+	const lineStart = sourceText.lastIndexOf("\n", position - 1) + 1;
+	return sourceText.slice(lineStart, position).match(/^[ \t]*/)?.[0] ?? "";
+}
+function propertyNameSource$1(propertyName) {
+	return /^[$A-Z_a-z][$\w]*$/.test(propertyName) ? propertyName : JSON.stringify(propertyName);
+}
+function propertyNameText$2(name) {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+}
+function deletionRangeForProperty(objectNode, property, sourceFile, sourceText) {
+	const properties = objectNode.properties;
+	const index = properties.findIndex((item) => item === property);
+	const next = properties[index + 1];
+	if (next) return {
+		start: property.getStart(sourceFile),
+		end: next.getStart(sourceFile)
+	};
+	const trailingComma = commaAfterNode$1(property, objectNode, sourceText);
+	const previous = properties[index - 1];
+	if (previous) return {
+		start: previous.getEnd(),
+		end: trailingComma === void 0 ? property.getEnd() : trailingComma + 1
+	};
+	return {
+		start: property.getStart(sourceFile),
+		end: trailingComma === void 0 ? property.getEnd() : trailingComma + 1
+	};
+}
+function rootObjectWillBeEmptyAfterEdits(objectNode, edits) {
+	if (objectNode.properties.length === 0) return true;
+	if (edits.some((edit) => edit.op !== "delete" || edit.path.length !== 1)) return false;
+	const deleted = new Set(edits.flatMap((edit) => edit.op === "delete" && edit.path.length === 1 ? [edit.path[0]] : []));
+	for (const property of objectNode.properties) {
+		if (!ts.isPropertyAssignment(property)) return false;
+		const name = propertyNameText$2(property.name);
+		if (name === void 0 || !deleted.has(name)) return false;
+	}
+	return true;
+}
+function inlineEmptyCssCleanupReplacement(objectNode, sourceFile, sourceText) {
+	const call = objectNode.parent;
+	if (!ts.isCallExpression(call)) return void 0;
+	const classAttribute = jsxClassAttributeAncestor(call);
+	if (!classAttribute || !ts.isIdentifier(classAttribute.name)) return void 0;
+	const expression = classAttribute.initializer && jsxAttributeExpression$1(classAttribute.initializer);
+	if (!expression) return removeJsxAttributeReplacement(classAttribute);
+	if (unwrapParentheses(expression) === call) return removeJsxAttributeReplacement(classAttribute);
+	const generatedArray = generatedClassJoinArray(expression);
+	if (!generatedArray) return void 0;
+	const keptElements = generatedArray.elements.filter((element) => unwrapParentheses(element) !== call);
+	if (keptElements.length === generatedArray.elements.length) return void 0;
+	if (keptElements.length === 0) return removeJsxAttributeReplacement(classAttribute);
+	const attributeName = classAttribute.name.text;
+	if (keptElements.length === 1) {
+		const keptText = sourceText.slice(keptElements[0].getStart(sourceFile), keptElements[0].getEnd());
+		return {
+			range: {
+				start: classAttribute.getStart(sourceFile),
+				end: classAttribute.getEnd()
+			},
+			text: `${attributeName}={${keptText}}`
+		};
+	}
+	const joinedText = keptElements.map((element) => sourceText.slice(element.getStart(sourceFile), element.getEnd())).join(", ");
+	return {
+		range: {
+			start: classAttribute.getStart(sourceFile),
+			end: classAttribute.getEnd()
+		},
+		text: `${attributeName}={[${joinedText}].filter(Boolean).join(' ')}`
+	};
+}
+function jsxClassAttributeAncestor(node) {
+	let current = node;
+	while (current) {
+		if (ts.isJsxAttribute(current) && ts.isIdentifier(current.name) && (current.name.text === "class" || current.name.text === "className")) return current;
+		current = current.parent;
+	}
+}
+function jsxAttributeExpression$1(initializer) {
+	if (ts.isJsxExpression(initializer)) return initializer.expression;
+}
+function removeJsxAttributeReplacement(attribute) {
+	return {
+		range: {
+			start: attribute.getFullStart(),
+			end: attribute.getEnd()
+		},
+		text: ""
+	};
+}
+function generatedClassJoinArray(expression) {
+	const joinCall = unwrapParentheses(expression);
+	if (!ts.isCallExpression(joinCall)) return void 0;
+	if (!ts.isPropertyAccessExpression(joinCall.expression)) return void 0;
+	if (joinCall.expression.name.text !== "join") return void 0;
+	const filterCall = unwrapParentheses(joinCall.expression.expression);
+	if (!ts.isCallExpression(filterCall)) return void 0;
+	if (!ts.isPropertyAccessExpression(filterCall.expression)) return void 0;
+	if (filterCall.expression.name.text !== "filter") return void 0;
+	const array = unwrapParentheses(filterCall.expression.expression);
+	return ts.isArrayLiteralExpression(array) ? array : void 0;
+}
+function unwrapParentheses(expression) {
+	let current = expression;
+	while (ts.isParenthesizedExpression(current)) current = current.expression;
+	return current;
+}
+function locateProperty$1(source, objectNode, propertyName) {
+	const matches = [];
+	for (const property of source.ops.getObjectProperties(objectNode)) {
+		if (source.ops.isSpreadProperty(property)) return {
+			ok: false,
+			reason: {
+				code: "unsupported-source-shape",
+				message: "Object spread can change which style keys exist at runtime."
+			}
+		};
+		if (!source.ops.isPlainProperty(property)) return {
+			ok: false,
+			reason: {
+				code: "unsupported-source-shape",
+				message: "Only plain property assignments can be patched."
+			}
+		};
+		const name = source.ops.getPropertyName(property);
+		if (name === void 0) return {
+			ok: false,
+			reason: {
+				code: "unsupported-source-shape",
+				message: "Computed property names are not safe to patch."
+			}
+		};
+		if (name === propertyName) matches.push(property);
+	}
+	if (matches.length > 1) return {
+		ok: false,
+		reason: {
+			code: "ambiguous-target",
+			message: "Style object contains duplicate keys for the requested path.",
+			details: { property: propertyName }
+		}
+	};
+	const property = matches[0];
+	if (!property) return {
+		ok: false,
+		reason: {
+			code: "invalid-path",
+			message: "Style object does not contain the requested path.",
+			details: { property: propertyName }
+		}
+	};
+	return {
+		ok: true,
+		property
+	};
+}
+function isJsonPrimitive$1(value) {
+	return value === null || [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value);
+}
+function literalSource$1(value, context) {
+	if (typeof value === "string") {
+		const complexTokenSource = complexTokenValueSource(value, context);
+		if (complexTokenSource) return complexTokenSource;
+		return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+	}
+	if (typeof value === "number") return Number.isFinite(value) ? String(value) : "null";
+	if (typeof value === "boolean") return value ? "true" : "false";
+	return "null";
+}
+function complexTokenValueSource(value, context) {
+	const property = context?.path.at(-1);
+	if (property !== "border" && property !== "outline") return void 0;
+	const parts = value.trim().split(/\s+/);
+	if (parts.length < 2) return void 0;
+	const colorToken = parts.at(-1);
+	if (!colorToken || !looksLikeColorTokenPath(colorToken)) return void 0;
+	const tokenPath = colorToken.startsWith("colors.") ? colorToken : `colors.${colorToken}`;
+	const prefix = parts.slice(0, -1).join(" ");
+	if (!context?.tokenVarImportLocalName) return `'${escapeSingleQuotedString(`${prefix} token(${tokenPath})`)}'`;
+	return `\`${escapeTemplateText(`${prefix} `)}\${${context.tokenVarImportLocalName}.var(${JSON.stringify(tokenPath)})}\``;
+}
+function looksLikeColorTokenPath(value) {
+	return /^(?:colors\.)?[A-Za-z_][\w-]*(?:\.[A-Za-z0-9_][\w-]*)+$/.test(value);
+}
+function escapeSingleQuotedString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function escapeTemplateText(value) {
+	return value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+function tokenImportLocalName(sourceFile, styledSystemPackageName) {
+	const moduleSpecifier = `${styledSystemPackageName}/tokens`;
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement)) continue;
+		if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		if (statement.moduleSpecifier.text !== moduleSpecifier) continue;
+		const namedBindings = statement.importClause?.namedBindings;
+		if (!namedBindings || !ts.isNamedImports(namedBindings)) return void 0;
+		for (const element of namedBindings.elements) if ((element.propertyName?.text ?? element.name.text) === "token") return element.name.text;
+	}
+	return tokenIdentifierAvailable(sourceFile) ? "token" : void 0;
+}
+function tokenIdentifierAvailable(sourceFile) {
+	let available = true;
+	const visit = (node) => {
+		if (!available) return;
+		if (ts.isIdentifier(node) && node.text === "token") {
+			available = false;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return available;
+}
+function tokenVarImportReplacement(sourceFile, styledSystemPackageName, localName) {
+	const moduleSpecifier = `${styledSystemPackageName}/tokens`;
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement)) continue;
+		if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		if (statement.moduleSpecifier.text !== moduleSpecifier) continue;
+		const namedBindings = statement.importClause?.namedBindings;
+		if (!namedBindings || !ts.isNamedImports(namedBindings)) return void 0;
+		if (namedBindings.elements.some((element) => (element.propertyName?.text ?? element.name.text) === "token")) return;
+		const insertAt = namedBindings.elements.end;
+		return {
+			range: {
+				start: insertAt,
+				end: insertAt
+			},
+			text: `, token${localName === "token" ? "" : ` as ${localName}`}`
+		};
+	}
+	const insertAt = importInsertionPosition$1(sourceFile);
+	return {
+		range: {
+			start: insertAt,
+			end: insertAt
+		},
+		text: `import { token${localName === "token" ? "" : ` as ${localName}`} } from '${moduleSpecifier}'\n`
+	};
+}
+function importInsertionPosition$1(sourceFile) {
+	let position = 0;
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement)) break;
+		position = statement.getEnd();
+	}
+	return position === 0 ? 0 : position + 1;
+}
+function findOverlappingReplacement(replacements) {
+	const sorted = [...replacements].sort((left, right) => left.range.start - right.range.start);
+	for (let index = 1; index < sorted.length; index += 1) if (sorted[index - 1].range.end > sorted[index].range.start) return [sorted[index - 1].range, sorted[index].range];
+}
+function dedupeIdenticalReplacements(replacements) {
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const replacement of replacements) {
+		const key = `${replacement.range.start}:${replacement.range.end}:${replacement.text}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		deduped.push(replacement);
+	}
+	return deduped;
+}
+function applyReplacements$2(sourceText, replacements) {
+	let nextSource = sourceText;
+	for (const replacement of [...replacements].sort((left, right) => right.range.start - left.range.start)) nextSource = `${nextSource.slice(0, replacement.range.start)}${replacement.text}${nextSource.slice(replacement.range.end)}`;
+	return nextSource;
+}
+function focusedDiff$2(file, sourceText, nextSource, replacements) {
+	const firstStart = Math.min(...replacements.map((replacement) => replacement.range.start));
+	const lastEnd = Math.max(...replacements.map((replacement) => replacement.range.end));
+	const oldStartLine = lineNumberAt$2(sourceText, firstStart);
+	const oldEndLine = lineNumberAt$2(sourceText, lastEnd);
+	const contextStartLine = Math.max(1, oldStartLine - 2);
+	const contextEndLine = oldEndLine + 2;
+	const oldLines = sourceText.split("\n");
+	const newLines = nextSource.split("\n");
+	const oldSlice = oldLines.slice(contextStartLine - 1, contextEndLine);
+	const newSlice = newLines.slice(contextStartLine - 1, contextEndLine + (newLines.length - oldLines.length));
+	return [
+		`--- a/${file}`,
+		`+++ b/${file}`,
+		`@@ -${contextStartLine},${oldSlice.length} +${contextStartLine},${newSlice.length} @@`,
+		...oldSlice.map((line) => `-${line}`),
+		...newSlice.map((line) => `+${line}`)
+	].join("\n");
+}
+function lineNumberAt$2(sourceText, position) {
+	let line = 1;
+	for (let index = 0; index < position; index += 1) if (sourceText.charCodeAt(index) === 10) line += 1;
+	return line;
+}
+function normalizePath$3(path) {
+	return path.replace(/\\/g, "/");
+}
+function failure$2(editId, code, message, details) {
+	return {
+		ok: false,
+		editId,
+		written: false,
+		error: {
+			code,
+			message,
+			details
+		}
+	};
+}
+//#endregion
+//#region src/vite/pathSafety.ts
+function trustedTokenSourceFilePath(projectRoot, tokenSource) {
+	const root = normalizePath$2(projectRoot).replace(/\/$/, "");
+	const file = normalizePath$2(tokenSource.absoluteFile ?? `${root}/${tokenSource.file}`);
+	if (!root || file !== root && !file.startsWith(`${root}/`)) return {
+		ok: false,
+		code: "path-outside-project",
+		message: "Token source points outside the project root.",
+		details: {
+			file,
+			projectRoot: root
+		}
+	};
+	return {
+		ok: true,
+		file
+	};
+}
+function trustedManifestFilePath(manifest, entry) {
+	const root = normalizePath$2(manifest.projectRoot).replace(/\/$/, "");
+	const file = normalizePath$2(entry.absoluteFile ?? `${root}/${entry.file}`);
+	if (!root || file !== root && !file.startsWith(`${root}/`)) return {
+		ok: false,
+		code: "path-outside-project",
+		message: "Manifest entry points outside the project root.",
+		details: {
+			file,
+			projectRoot: root
+		}
+	};
+	return {
+		ok: true,
+		file
+	};
+}
+function safeProjectSourcePath(projectRoot, filePath) {
+	const root = normalizePath$2(projectRoot).replace(/\/$/, "");
+	const file = normalizePath$2(resolve(root, filePath)).replace(/\/$/, "");
+	if (!root || file === root || !file.startsWith(`${root}/`)) return {
+		ok: false,
+		code: "path-outside-project",
+		message: "Source path is outside the project root.",
+		details: {
+			file,
+			projectRoot: root
+		}
+	};
+	return {
+		ok: true,
+		file
+	};
+}
+function stripViteQuery(id) {
+	return id.split("?")[0] ?? id;
+}
+function toRelativeProjectPath(filePath, projectRoot) {
+	if (!projectRoot) return filePath;
+	const root = normalizePath$2(projectRoot).replace(/\/$/, "");
+	if (filePath === root) return filePath.split("/").at(-1) ?? filePath;
+	if (filePath.startsWith(`${root}/`)) return filePath.slice(root.length + 1);
+	return filePath;
+}
+function normalizePath$2(path) {
+	return path.replace(/\\/g, "/");
+}
+//#endregion
+//#region src/patcher/styleModulePatcher.ts
+const DEFAULT_CSS_IMPORT_SOURCES = [
+	"../styled-system/css",
+	"@/styled-system/css",
+	"styled-system/css"
+];
+function componentStyleModulePaths(options) {
+	const parsed = parseSourceRef(options.componentSource, "Component style list requires a component source path with line and column.");
+	if (!parsed.ok) return parsed;
+	const root = normalizePath$1(options.projectRoot).replace(/\/$/, "");
+	const componentFile = normalizePath$1(resolve(root, parsed.file));
+	if (!root || componentFile !== root && !componentFile.startsWith(`${root}/`)) return {
+		ok: false,
+		code: "path-outside-project",
+		message: "Component source path is outside the project root.",
+		details: {
+			componentSource: options.componentSource,
+			projectRoot: root
+		}
+	};
+	const extensionMatch = /\.(tsx|jsx|ts|js)$/.exec(componentFile);
+	if (!extensionMatch) return {
+		ok: false,
+		code: "unsupported-source-shape",
+		message: "Component style lists are only supported for TS/TSX/JS/JSX component modules.",
+		details: { componentSource: options.componentSource }
+	};
+	const componentBase = componentFile.slice(0, -extensionMatch[0].length);
+	const styleFile = `${componentBase}.style.ts`;
+	return {
+		ok: true,
+		paths: {
+			componentFile,
+			styleFile,
+			styleFileRelative: toRelativeProjectPath(styleFile, options.projectRoot),
+			importPath: `./${componentBase.split("/").at(-1) ?? "styles"}.style`
+		}
+	};
+}
+function readComponentStyleModule(options) {
+	const paths = componentStyleModulePaths(options);
+	if (!paths.ok) return {
+		ok: false,
+		error: {
+			code: paths.code,
+			message: paths.message,
+			details: paths.details
+		}
+	};
+	if (options.sourceText === void 0) return {
+		ok: true,
+		componentFile: toRelativeProjectPath(paths.paths.componentFile, options.projectRoot),
+		styleFile: paths.paths.styleFileRelative,
+		importPath: paths.paths.importPath,
+		exists: false,
+		sources: []
+	};
+	const parsed = parseStyleModuleSource({
+		projectRoot: options.projectRoot,
+		filePath: paths.paths.styleFile,
+		sourceText: options.sourceText,
+		cssImportSources: options.cssImportSources
+	});
+	if (!parsed.ok) return {
+		ok: false,
+		error: {
+			code: parsed.code,
+			message: parsed.message,
+			details: parsed.details
+		}
+	};
+	return {
+		ok: true,
+		componentFile: toRelativeProjectPath(paths.paths.componentFile, options.projectRoot),
+		styleFile: paths.paths.styleFileRelative,
+		importPath: paths.paths.importPath,
+		exists: true,
+		sources: parsed.sources
+	};
+}
+function createStyleModuleSourcePatch(options) {
+	const nameFailure = validateStyleSourceName(options.request.name);
+	if (nameFailure) return failure$1(options.request.editId, nameFailure.code, nameFailure.message);
+	const initialStyleObject = styleObjectTextForSourceCreateEdits(options.request.edits);
+	if (!initialStyleObject.ok) return failure$1(options.request.editId, initialStyleObject.code, initialStyleObject.message);
+	if (options.sourceText === void 0) {
+		const cssLocalName = "css";
+		const nextSource = [
+			cssImportText(cssLocalName, options.cssImportSources),
+			"",
+			"export default {",
+			`  ${options.request.name}: ${cssLocalName}(${initialStyleObject.text}),`,
+			"}",
+			""
+		].join("\n");
+		const file = toRelativeProjectPath(options.filePath, options.projectRoot);
+		return {
+			ok: true,
+			editId: options.request.editId,
+			file,
+			diff: nextFileDiff(file, nextSource),
+			nextSource,
+			written: false
+		};
+	}
+	const sourceFile = ts.createSourceFile(options.filePath, options.sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const exportObject = findDefaultExportObject(sourceFile);
+	if (!exportObject) return failure$1(options.request.editId, "unsupported-source-shape", "Style module sources require a direct export default { ... } object.");
+	if (objectHasProperty(exportObject, options.request.name)) return failure$1(options.request.editId, "invalid-edit", "A style source with that name already exists.");
+	const cssImport = findCssImportBinding(sourceFile, options.cssImportSources);
+	const cssLocalName = cssImport?.localName ?? "css";
+	const replacements = [{
+		range: {
+			start: exportObject.getEnd() - 1,
+			end: exportObject.getEnd() - 1
+		},
+		text: `${exportObject.properties.length === 0 ? "\n" : ""}  ${options.request.name}: ${cssLocalName}(${initialStyleObject.text}),\n`
+	}];
+	if (!cssImport) replacements.push({
+		range: {
+			start: importInsertionPosition(sourceFile),
+			end: importInsertionPosition(sourceFile)
+		},
+		text: cssImportText(cssLocalName, options.cssImportSources)
+	});
+	const nextSource = applyReplacements$1(options.sourceText, replacements);
+	const file = toRelativeProjectPath(options.filePath, options.projectRoot);
+	return {
+		ok: true,
+		editId: options.request.editId,
+		file,
+		diff: focusedDiff$1(file, options.sourceText, nextSource, replacements),
+		nextSource,
+		written: false
+	};
+}
+function createStyleModuleAttachPatch(options) {
+	const nameFailure = validateStyleSourceName(options.request.name);
+	if (nameFailure) return failure$1(options.request.editId, nameFailure.code, nameFailure.message);
+	const parsed = parseSourceRef(options.request.jsxSource, "Style source attachment requires a JSX source path with line and column.");
+	if (!parsed.ok) return failure$1(options.request.editId, parsed.code, parsed.message, parsed.details);
+	const normalizedFile = normalizePath$1(options.filePath);
+	if (normalizedFile !== normalizePath$1(`${options.projectRoot.replace(/\/$/, "")}/${parsed.file}`)) return failure$1(options.request.editId, "stale-source", "JSX source location points to a different file.", {
+		filePath: normalizedFile,
+		jsxSource: options.request.jsxSource
+	});
+	const paths = componentStyleModulePaths({
+		projectRoot: options.projectRoot,
+		componentSource: options.request.componentSource
+	});
+	if (!paths.ok) return failure$1(options.request.editId, paths.code, paths.message, paths.details);
+	const sourceFile = ts.createSourceFile(options.filePath, options.sourceText, ts.ScriptTarget.Latest, true, options.filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+	const position = positionForLineColumn(sourceFile, parsed.line, parsed.column);
+	if (position === void 0) return failure$1(options.request.editId, "stale-source", "JSX source location is outside the file.");
+	const element = findJsxElementAtStart(sourceFile, position);
+	if (!element) return failure$1(options.request.editId, "stale-source", "JSX source location no longer points to a JSX element.");
+	const importState = stylesImportState(sourceFile, paths.paths.importPath);
+	if (!importState.ok) return failure$1(options.request.editId, importState.code, importState.message, importState.details);
+	const classReplacement = styleModuleAttributeReplacement(sourceFile, options.sourceText, element, options.request.name, options.styledSystemPackageName);
+	if (!classReplacement.ok) return failure$1(options.request.editId, classReplacement.code, classReplacement.message, classReplacement.details);
+	const replacements = [classReplacement.replacement, ...classReplacement.imports];
+	if (!importState.exists) replacements.push({
+		range: {
+			start: importInsertionPosition(sourceFile),
+			end: importInsertionPosition(sourceFile)
+		},
+		text: `import styles from '${paths.paths.importPath}'\n`
+	});
+	const nextSource = applyReplacements$1(options.sourceText, replacements);
+	const file = toRelativeProjectPath(options.filePath, options.projectRoot);
+	return {
+		ok: true,
+		editId: options.request.editId,
+		file,
+		diff: focusedDiff$1(file, options.sourceText, nextSource, replacements),
+		nextSource,
+		written: false
+	};
+}
+function createStyleModuleDetachPatch(options) {
+	const nameFailure = validateStyleSourceName(options.request.name);
+	if (nameFailure) return failure$1(options.request.editId, nameFailure.code, nameFailure.message);
+	const parsed = parseSourceRef(options.request.jsxSource, "Style source removal requires a JSX source path with line and column.");
+	if (!parsed.ok) return failure$1(options.request.editId, parsed.code, parsed.message, parsed.details);
+	const normalizedFile = normalizePath$1(options.filePath);
+	if (normalizedFile !== normalizePath$1(`${options.projectRoot.replace(/\/$/, "")}/${parsed.file}`)) return failure$1(options.request.editId, "stale-source", "JSX source location points to a different file.", {
+		filePath: normalizedFile,
+		jsxSource: options.request.jsxSource
+	});
+	const sourceFile = ts.createSourceFile(options.filePath, options.sourceText, ts.ScriptTarget.Latest, true, options.filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+	const position = positionForLineColumn(sourceFile, parsed.line, parsed.column);
+	if (position === void 0) return failure$1(options.request.editId, "stale-source", "JSX source location is outside the file.");
+	const element = findJsxElementAtStart(sourceFile, position);
+	if (!element) return failure$1(options.request.editId, "stale-source", "JSX source location no longer points to a JSX element.");
+	const replacement = styleModuleAttributeDetachReplacement(sourceFile, options.sourceText, element, options.request.name);
+	if (!replacement) return failure$1(options.request.editId, "unsupported-operation", "The selected style source could not be removed from this class expression.");
+	const nextSource = applyReplacements$1(options.sourceText, [replacement]);
+	const file = toRelativeProjectPath(options.filePath, options.projectRoot);
+	return {
+		ok: true,
+		editId: options.request.editId,
+		file,
+		diff: focusedDiff$1(file, options.sourceText, nextSource, [replacement]),
+		nextSource,
+		written: false
+	};
+}
+function parseStyleModuleSource(options) {
+	const exportObject = findDefaultExportObject(ts.createSourceFile(options.filePath, options.sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS));
+	if (!exportObject) return {
+		ok: false,
+		code: "unsupported-source-shape",
+		message: "Style module sources require a direct export default { ... } object."
+	};
+	const analysis = analyzePandaCssSource({
+		projectRoot: options.projectRoot,
+		filePath: options.filePath,
+		sourceText: options.sourceText,
+		cssImportSources: options.cssImportSources
+	});
+	const entryByName = new Map(analysis.entries.map((entry) => [entry.name, entry]));
+	return {
+		ok: true,
+		sources: exportObject.properties.flatMap((property) => {
+			if (!ts.isPropertyAssignment(property)) return [];
+			const name = propertyNameText$1(property.name);
+			if (!name) return [];
+			if (!ts.isCallExpression(property.initializer)) return [];
+			if (!ts.isObjectLiteralExpression(property.initializer.arguments[0])) return [];
+			const entry = entryByName.get(name);
+			return [{
+				name,
+				editId: entry?.id,
+				file: toRelativeProjectPath(options.filePath, options.projectRoot),
+				sourceHash: entry?.sourceHash,
+				...entry?.kind === "panda-css" ? { styleObject: entry.styleObject } : {}
+			}];
+		})
+	};
+}
+function findDefaultExportObject(sourceFile) {
+	for (const statement of sourceFile.statements) {
+		if (!ts.isExportAssignment(statement) || statement.isExportEquals) continue;
+		if (ts.isObjectLiteralExpression(statement.expression)) return statement.expression;
+	}
+}
+function objectHasProperty(objectNode, name) {
+	return objectNode.properties.some((property) => {
+		if (!ts.isPropertyAssignment(property)) return false;
+		return propertyNameText$1(property.name) === name;
+	});
+}
+function styleObjectTextForSourceCreateEdits(edits) {
+	if (!edits || edits.length === 0) return {
+		ok: true,
+		text: "{}"
+	};
+	const properties = [];
+	for (const edit of edits) {
+		if (edit.op !== "set") return {
+			ok: false,
+			code: "invalid-edit",
+			message: "New style sources only support setting initial properties."
+		};
+		if (edit.path.length !== 1) return {
+			ok: false,
+			code: "unsupported-operation",
+			message: "New style sources only support top-level initial properties."
+		};
+		const property = edit.path[0];
+		if (!property || !/^[A-Za-z_$][\w$]*$/.test(property)) return {
+			ok: false,
+			code: "invalid-edit",
+			message: "New style source property names must be valid identifiers."
+		};
+		properties.push(`${property}: ${JSON.stringify(edit.value)}`);
+	}
+	return {
+		ok: true,
+		text: `{ ${properties.join(", ")} }`
+	};
+}
+function propertyNameText$1(name) {
+	if (ts.isIdentifier(name)) return name.text;
+	if (ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+}
+function styleModuleAttributeReplacement(sourceFile, sourceText, element, name, styledSystemPackageName) {
+	let classAttribute;
+	for (const property of element.attributes.properties) {
+		if (!ts.isJsxAttribute(property) || !ts.isIdentifier(property.name)) continue;
+		if (property.name.text !== "class" && property.name.text !== "className") continue;
+		classAttribute = property;
+		break;
+	}
+	const styleReference = `styles.${name}`;
+	if (!classAttribute) {
+		const insertPosition = element.getEnd() - (ts.isJsxSelfClosingElement(element) ? 2 : 1);
+		return {
+			ok: true,
+			replacement: {
+				range: {
+					start: insertPosition,
+					end: insertPosition
+				},
+				text: ` class={${styleReference}}`
+			},
+			imports: []
+		};
+	}
+	const attributeName = ts.isIdentifier(classAttribute.name) ? classAttribute.name.text : "class";
+	if (!classAttribute.initializer) return {
+		ok: true,
+		replacement: {
+			range: {
+				start: classAttribute.getStart(sourceFile),
+				end: classAttribute.getEnd()
+			},
+			text: `${attributeName}={${styleReference}}`
+		},
+		imports: []
+	};
+	const cx = cxImportState(sourceFile, sourceText, styledSystemPackageName);
+	if (!cx.ok) return cx;
+	if (ts.isStringLiteral(classAttribute.initializer)) return {
+		ok: true,
+		replacement: {
+			range: {
+				start: classAttribute.getStart(sourceFile),
+				end: classAttribute.getEnd()
+			},
+			text: `${attributeName}={${cx.localName}(${JSON.stringify(classAttribute.initializer.text)}, ${styleReference})}`
+		},
+		imports: cx.imports
+	};
+	const expression = jsxAttributeExpression(classAttribute.initializer);
+	if (!expression) return {
+		ok: true,
+		replacement: {
+			range: {
+				start: classAttribute.getStart(sourceFile),
+				end: classAttribute.getEnd()
+			},
+			text: `${attributeName}={${styleReference}}`
+		},
+		imports: []
+	};
+	const expressionText = sourceText.slice(expression.getStart(sourceFile), expression.getEnd());
+	const cxArgs = cxCallArguments(sourceFile, sourceText, expression, cx.localName, styleReference);
+	return {
+		ok: true,
+		replacement: {
+			range: {
+				start: classAttribute.getStart(sourceFile),
+				end: classAttribute.getEnd()
+			},
+			text: `${attributeName}={${cx.localName}(${cxArgs ?? `${expressionText}, ${styleReference}`})}`
+		},
+		imports: cx.imports
+	};
+}
+function styleModuleAttributeDetachReplacement(sourceFile, sourceText, element, name) {
+	let classAttribute;
+	for (const property of element.attributes.properties) {
+		if (!ts.isJsxAttribute(property) || !ts.isIdentifier(property.name)) continue;
+		if (property.name.text !== "class" && property.name.text !== "className") continue;
+		classAttribute = property;
+		break;
+	}
+	if (!classAttribute?.initializer) return void 0;
+	const expression = jsxAttributeExpression(classAttribute.initializer);
+	if (!expression) return void 0;
+	const styleReference = `styles.${name}`;
+	const attributeName = ts.isIdentifier(classAttribute.name) ? classAttribute.name.text : "class";
+	const replacementText = classExpressionAfterStyleReferenceRemoval(sourceFile, sourceText, expression, styleReference);
+	if (replacementText === void 0) return void 0;
+	return {
+		range: {
+			start: classAttribute.getStart(sourceFile),
+			end: classAttribute.getEnd()
+		},
+		text: replacementText === "" ? "" : `${attributeName}={${replacementText}}`
+	};
+}
+function cxImportState(sourceFile, sourceText, styledSystemPackageName) {
+	const moduleSpecifier = `${styledSystemPackageName ?? "styled-system"}/css`;
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement)) continue;
+		if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		if (statement.moduleSpecifier.text !== moduleSpecifier) continue;
+		const namedBindings = statement.importClause?.namedBindings;
+		if (!namedBindings || !ts.isNamedImports(namedBindings)) return {
+			ok: false,
+			code: "unsupported-operation",
+			message: "The styled-system css import must use named imports before cx can be added.",
+			details: { moduleSpecifier }
+		};
+		for (const element of namedBindings.elements) if ((element.propertyName?.text ?? element.name.text) === "cx") return {
+			ok: true,
+			localName: element.name.text,
+			imports: []
+		};
+		return {
+			ok: true,
+			localName: "cx",
+			imports: [{
+				range: {
+					start: namedBindings.elements.end,
+					end: namedBindings.elements.end
+				},
+				text: `${namedBindings.elements.length === 0 ? "" : ","} cx`
+			}]
+		};
+	}
+	if (identifierExists(sourceFile, "cx")) return {
+		ok: false,
+		code: "unsupported-operation",
+		message: "The component module already uses the cx name.",
+		details: { moduleSpecifier }
+	};
+	return {
+		ok: true,
+		localName: "cx",
+		imports: [{
+			range: {
+				start: importInsertionPosition(sourceFile),
+				end: importInsertionPosition(sourceFile)
+			},
+			text: `import { cx } from '${moduleSpecifier}'\n`
+		}]
+	};
+}
+function cxCallArguments(sourceFile, sourceText, expression, cxLocalName, styleReference) {
+	if (!ts.isCallExpression(expression)) return void 0;
+	if (!ts.isIdentifier(expression.expression) || expression.expression.text !== cxLocalName) return;
+	return [...expression.arguments.map((argument) => sourceTextForNode(sourceFile, sourceText, argument)), styleReference].join(", ");
+}
+function identifierExists(sourceFile, name) {
+	let exists = false;
+	const visit = (node) => {
+		if (exists) return;
+		if (ts.isIdentifier(node) && node.text === name) {
+			exists = true;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return exists;
+}
+function classExpressionAfterStyleReferenceRemoval(sourceFile, sourceText, expression, styleReference) {
+	if (sourceTextForNode(sourceFile, sourceText, expression) === styleReference) return "";
+	if (ts.isCallExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "cx") {
+		const remaining = expression.arguments.filter((argument) => sourceTextForNode(sourceFile, sourceText, argument) !== styleReference);
+		if (remaining.length === expression.arguments.length) return void 0;
+		if (remaining.length === 0) return "";
+		if (remaining.length === 1) return sourceTextForNode(sourceFile, sourceText, remaining[0]);
+		const remainingText = remaining.map((argument) => sourceTextForNode(sourceFile, sourceText, argument)).join(", ");
+		return `${expression.expression.text}(${remainingText})`;
+	}
+	const array = ts.isArrayLiteralExpression(expression) ? expression : arrayLiteralFromClassJoinExpression(expression);
+	if (!array || !ts.isArrayLiteralExpression(array)) return void 0;
+	const remaining = array.elements.filter((element) => sourceTextForNode(sourceFile, sourceText, element) !== styleReference);
+	if (remaining.length === array.elements.length) return void 0;
+	if (remaining.length === 0) return "";
+	if (remaining.length === 1) return sourceTextForNode(sourceFile, sourceText, remaining[0]);
+	return `[${remaining.map((element) => sourceTextForNode(sourceFile, sourceText, element)).join(", ")}].filter(Boolean).join(' ')`;
+}
+function arrayLiteralFromClassJoinExpression(expression) {
+	if (!ts.isCallExpression(expression)) return void 0;
+	if (!ts.isPropertyAccessExpression(expression.expression)) return void 0;
+	if (expression.expression.name.text !== "join") return void 0;
+	const filterCall = expression.expression.expression;
+	if (!ts.isCallExpression(filterCall)) return void 0;
+	if (!ts.isPropertyAccessExpression(filterCall.expression)) return void 0;
+	if (filterCall.expression.name.text !== "filter") return void 0;
+	if (!ts.isIdentifier(filterCall.arguments[0]) || filterCall.arguments[0].text !== "Boolean") return;
+	const array = filterCall.expression.expression;
+	return ts.isArrayLiteralExpression(array) ? array : void 0;
+}
+function sourceTextForNode(sourceFile, sourceText, node) {
+	return sourceText.slice(node.getStart(sourceFile), node.getEnd());
+}
+function stylesImportState(sourceFile, importPath) {
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement)) continue;
+		const defaultImport = statement.importClause?.name;
+		if (!defaultImport || defaultImport.text !== "styles") continue;
+		if (ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === importPath) return {
+			ok: true,
+			exists: true
+		};
+		return {
+			ok: false,
+			code: "unsupported-operation",
+			message: "The component module already uses the styles import name for another module.",
+			details: { importPath }
+		};
+	}
+	let hasStylesIdentifier = false;
+	const visit = (node) => {
+		if (hasStylesIdentifier) return;
+		if (ts.isIdentifier(node) && node.text === "styles") {
+			hasStylesIdentifier = true;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	if (hasStylesIdentifier) return {
+		ok: false,
+		code: "unsupported-operation",
+		message: "The component module already uses the styles name.",
+		details: { importPath }
+	};
+	return {
+		ok: true,
+		exists: false
+	};
+}
+function findCssImportBinding(sourceFile, cssImportSources) {
+	const importSources = new Set(cssImportSources ?? DEFAULT_CSS_IMPORT_SOURCES);
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement)) continue;
+		if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		if (!importSources.has(statement.moduleSpecifier.text)) continue;
+		const namedBindings = statement.importClause?.namedBindings;
+		if (!namedBindings || !ts.isNamedImports(namedBindings)) continue;
+		for (const element of namedBindings.elements) if ((element.propertyName?.text ?? element.name.text) === "css") return { localName: element.name.text };
+	}
+}
+function jsxAttributeExpression(initializer) {
+	if (ts.isJsxExpression(initializer)) return initializer.expression;
+}
+function findJsxElementAtStart(sourceFile, position) {
+	let result;
+	const visit = (node) => {
+		if (result) return;
+		if ((ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) && node.getStart(sourceFile) === position) {
+			result = node;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return result;
+}
+function importInsertionPosition(sourceFile) {
+	let position = 0;
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement)) break;
+		position = statement.getEnd();
+	}
+	return position === 0 ? 0 : position + 1;
+}
+function cssImportText(cssLocalName, cssImportSources) {
+	const moduleSpecifier = cssImportSources?.[0] ?? DEFAULT_CSS_IMPORT_SOURCES[0];
+	return `import { ${cssLocalName === "css" ? "css" : `css as ${cssLocalName}`} } from '${moduleSpecifier}'\n`;
+}
+function parseSourceRef(source, message) {
+	const match = /^(.*):(\d+):(\d+)$/.exec(source.trim());
+	const file = match?.[1]?.trim();
+	const line = match?.[2] ? Number.parseInt(match[2], 10) : void 0;
+	const column = match?.[3] ? Number.parseInt(match[3], 10) : void 0;
+	if (!match || !file || line === void 0 || column === void 0 || line < 1 || column < 1) return {
+		ok: false,
+		code: "invalid-edit",
+		message,
+		details: { source }
+	};
+	return {
+		ok: true,
+		file,
+		line,
+		column
+	};
+}
+function positionForLineColumn(sourceFile, line, column) {
+	const lineStart = sourceFile.getLineStarts()[line - 1];
+	if (lineStart === void 0) return void 0;
+	const position = lineStart + column - 1;
+	return position <= sourceFile.text.length ? position : void 0;
+}
+function validateStyleSourceName(name) {
+	if (/^[A-Za-z_$][\w$]*$/.test(name)) return void 0;
+	return {
+		code: "invalid-edit",
+		message: "Style source names must be valid JavaScript identifiers."
+	};
+}
+function applyReplacements$1(sourceText, replacements) {
+	let nextSource = sourceText;
+	for (const replacement of [...replacements].sort((left, right) => right.range.start - left.range.start)) nextSource = `${nextSource.slice(0, replacement.range.start)}${replacement.text}${nextSource.slice(replacement.range.end)}`;
+	return nextSource;
+}
+function nextFileDiff(file, nextSource) {
+	return [
+		`--- /dev/null`,
+		`+++ b/${file}`,
+		...nextSource.split("\n").map((line) => `+${line}`)
+	].join("\n");
+}
+function focusedDiff$1(file, sourceText, nextSource, replacements) {
+	const firstStart = Math.min(...replacements.map((replacement) => replacement.range.start));
+	const lastEnd = Math.max(...replacements.map((replacement) => replacement.range.end));
+	const oldStartLine = lineNumberAt$1(sourceText, firstStart);
+	const oldEndLine = lineNumberAt$1(sourceText, lastEnd);
+	const contextStartLine = Math.max(1, oldStartLine - 2);
+	const contextEndLine = oldEndLine + 2;
+	const oldLines = sourceText.split("\n");
+	const newLines = nextSource.split("\n");
+	const oldSlice = oldLines.slice(contextStartLine - 1, contextEndLine);
+	const newSlice = newLines.slice(contextStartLine - 1, contextEndLine + (newLines.length - oldLines.length));
+	return [
+		`--- a/${file}`,
+		`+++ b/${file}`,
+		`@@ -${contextStartLine},${oldSlice.length} +${contextStartLine},${newSlice.length} @@`,
+		...oldSlice.map((line) => `-${line}`),
+		...newSlice.map((line) => `+${line}`)
+	].join("\n");
+}
+function lineNumberAt$1(sourceText, position) {
+	let line = 1;
+	for (let index = 0; index < position; index += 1) if (sourceText.charCodeAt(index) === 10) line += 1;
+	return line;
+}
+function normalizePath$1(path) {
+	return path.replace(/\\/g, "/");
+}
+function failure$1(editId, code, message, details) {
+	return {
+		ok: false,
+		editId,
+		written: false,
+		error: {
+			code,
+			message,
+			details
+		}
+	};
+}
+//#endregion
+//#region src/patcher/tokenConfigPatcher.ts
+function createTokenConfigPatch(options) {
+	const { request, sourceText, tokenSource } = options;
+	const validation = validateTokenPatchRequest(options);
+	if (validation) return failure(request.editId, validation.code, validation.message, validation.details);
+	const range = tokenSource.range ?? rangeFromTokenSourceId(tokenSource.id);
+	if (!range) return failure(request.editId, "unsupported-source-shape", "Token source target does not include a source range.");
+	if (hashSource(sourceText.slice(range.start, range.end)) !== tokenSource.sourceHash) return failure(request.editId, "stale-source", "Source text no longer matches the token source hash.");
+	if (request.options?.expectedSourceHash && request.options.expectedSourceHash !== tokenSource.sourceHash) return failure(request.editId, "stale-source", "Edit request was prepared against a different token source hash.", {
+		expectedSourceHash: request.options.expectedSourceHash,
+		actualSourceHash: tokenSource.sourceHash
+	});
+	const sourceFile = ts.createSourceFile(tokenSource.absoluteFile ?? tokenSource.file, sourceText, ts.ScriptTarget.Latest, true, tokenSource.file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+	const objectNode = findObjectLiteralAtRange(sourceFile, range);
+	if (!objectNode) return failure(request.editId, "stale-source", "Token source range no longer points to an object literal.");
+	const safety = tokenObjectWriteSafety(objectNode);
+	if (!safety.writable) return failure(request.editId, "unsupported-source-shape", safety.reason);
+	const replacement = replacementForTokenPath(objectNode, request, sourceFile, sourceText);
+	if (!replacement.ok) return failure(request.editId, replacement.reason.code, replacement.reason.message, replacement.reason.details);
+	const nextSource = applyReplacements(sourceText, [replacement.replacement]);
+	return {
+		ok: true,
+		editId: request.editId,
+		file: tokenSource.file,
+		diff: focusedDiff(tokenSource.file, sourceText, nextSource, [replacement.replacement]),
+		nextSource,
+		written: false
+	};
+}
+function validateTokenPatchRequest(options) {
+	const { projectRoot, request, tokenSource } = options;
+	if (request.kind !== "panda-token-config") return {
+		code: "unsupported-operation",
+		message: "Only Panda token config edits can be patched."
+	};
+	if (request.sourceTargetId !== tokenSource.id) return {
+		code: "manifest-entry-not-found",
+		message: "Token edit request does not match the provided token source target.",
+		details: { sourceTargetId: request.sourceTargetId }
+	};
+	if (!tokenSource.writable || !tokenSource.writableSections.includes(request.section)) return {
+		code: "unsupported-source-shape",
+		message: tokenSource.readonlyReason ?? "Token source is not writable."
+	};
+	if (request.path.length === 0 || request.path.some((part) => part.length === 0)) return {
+		code: "invalid-path",
+		message: "Token edits require a non-empty token path.",
+		details: { path: [...request.path] }
+	};
+	if (!isJsonPrimitive(request.value)) return {
+		code: "unsupported-operation",
+		message: "Token config patching only supports literal primitive values.",
+		details: { path: [...request.path] }
+	};
+	return validateProjectFile(projectRoot, tokenSource, options.filePath);
+}
+function validateProjectFile(projectRoot, tokenSource, filePath) {
+	const root = normalizePath(projectRoot).replace(/\/$/, "");
+	if (!root) return {
+		code: "path-outside-project",
+		message: "Project root is empty."
+	};
+	const absoluteFile = normalizePath(tokenSource.absoluteFile ?? `${root}/${tokenSource.file}`);
+	if (absoluteFile !== root && !absoluteFile.startsWith(`${root}/`)) return {
+		code: "path-outside-project",
+		message: "Token source points outside the project root.",
+		details: {
+			file: absoluteFile,
+			projectRoot: root
+		}
+	};
+	if (filePath && normalizePath(filePath) !== absoluteFile) return {
+		code: "stale-source",
+		message: "Provided source file does not match the token source file.",
+		details: {
+			filePath: normalizePath(filePath),
+			tokenSourceFile: absoluteFile
+		}
+	};
+}
+function replacementForTokenPath(objectNode, request, sourceFile, sourceText) {
+	let current = objectNode;
+	const { path } = request;
+	for (let index = 0; index < path.length; index += 1) {
+		const part = path[index];
+		const located = locateProperty(current, part);
+		if (!located.ok) {
+			if (located.reason.code === "invalid-path") return {
+				ok: true,
+				replacement: insertionForMissingTokenPath(current, path.slice(index), request.value, sourceFile, sourceText)
+			};
+			return {
+				ok: false,
+				reason: located.reason
+			};
+		}
+		const initializer = located.property.initializer;
+		const tokenObject = objectLiteralExpression(initializer);
+		if (!tokenObject) return {
+			ok: false,
+			reason: {
+				code: "unsupported-source-shape",
+				message: "Token path descends through a non-object value.",
+				details: { path: path.slice(0, index + 1) }
+			}
+		};
+		if (index === path.length - 1) {
+			const valueProperty = locateProperty(tokenObject, "value");
+			if (!valueProperty.ok) return {
+				ok: true,
+				replacement: insertionForMissingProperty(tokenObject, "value", literalSource(request.value), sourceFile, sourceText)
+			};
+			const valueInitializer = valueProperty.property.initializer;
+			if (!isPatchableLiteral(valueInitializer)) return {
+				ok: false,
+				reason: {
+					code: "unsupported-source-shape",
+					message: "Existing token value is not a literal primitive.",
+					details: { path: [...path] }
+				}
+			};
+			return {
+				ok: true,
+				replacement: {
+					range: {
+						start: valueInitializer.getStart(sourceFile),
+						end: valueInitializer.getEnd()
+					},
+					text: literalSource(request.value)
+				}
+			};
+		}
+		if (locateProperty(tokenObject, "value").ok) return {
+			ok: false,
+			reason: {
+				code: "invalid-path",
+				message: "Token path descends through an existing token leaf.",
+				details: { path: path.slice(0, index + 1) }
+			}
+		};
+		current = tokenObject;
+	}
+	return {
+		ok: false,
+		reason: {
+			code: "invalid-path",
+			message: "Token edits require a non-empty token path."
+		}
+	};
+}
+function insertionForMissingTokenPath(objectNode, missingPath, value, sourceFile, sourceText) {
+	const multiline = sourceText.slice(objectNode.getStart(sourceFile), objectNode.getEnd()).includes("\n");
+	const fallbackChildIndent = `${indentationBefore(sourceText, objectNode.getStart(sourceFile))}  `;
+	const lastProperty = objectNode.properties[objectNode.properties.length - 1];
+	return insertionForMissingProperty(objectNode, tokenBranchSource(missingPath, value, multiline, lastProperty ? indentationBefore(sourceText, lastProperty.getStart(sourceFile)) : fallbackChildIndent), void 0, sourceFile, sourceText);
+}
+function insertionForMissingProperty(objectNode, propertyNameOrSource, valueSource, sourceFile, sourceText) {
+	const closeBrace = objectNode.getEnd() - 1;
+	const multiline = sourceText.slice(objectNode.getStart(sourceFile), objectNode.getEnd()).includes("\n");
+	const property = valueSource ? `${propertyNameSource(propertyNameOrSource)}: ${valueSource}` : propertyNameOrSource;
+	if (objectNode.properties.length === 0) {
+		if (!multiline) return {
+			range: {
+				start: closeBrace,
+				end: closeBrace
+			},
+			text: property
+		};
+		const parentIndent = indentationBefore(sourceText, objectNode.getStart(sourceFile));
+		const childIndent = `${parentIndent}  `;
+		return {
+			range: {
+				start: closeBrace,
+				end: closeBrace
+			},
+			text: `\n${childIndent}${property},\n${parentIndent}`
+		};
+	}
+	const lastProperty = objectNode.properties[objectNode.properties.length - 1];
+	const trailingComma = commaAfterNode(lastProperty, objectNode, sourceText);
+	if (!multiline) {
+		const insertAt = trailingComma ?? lastProperty.getEnd();
+		return {
+			range: {
+				start: insertAt,
+				end: insertAt
+			},
+			text: trailingComma === void 0 ? `, ${property}` : ` ${property}`
+		};
+	}
+	const childIndent = indentationBefore(sourceText, lastProperty.getStart(sourceFile));
+	if (trailingComma !== void 0) return {
+		range: {
+			start: trailingComma + 1,
+			end: trailingComma + 1
+		},
+		text: `\n${childIndent}${property},`
+	};
+	return {
+		range: {
+			start: lastProperty.getEnd(),
+			end: lastProperty.getEnd()
+		},
+		text: `,\n${childIndent}${property}`
+	};
+}
+function tokenBranchSource(path, value, multiline, indent) {
+	const [first, ...rest] = path;
+	if (!first) return "";
+	if (rest.length === 0) return `${propertyNameSource(first)}: { value: ${literalSource(value)} }`;
+	if (!multiline) return `${propertyNameSource(first)}: { ${tokenBranchSource(rest, value, false, indent)} }`;
+	const childIndent = `${indent}  `;
+	const nested = tokenBranchSource(rest, value, true, childIndent);
+	return `${propertyNameSource(first)}: {\n${childIndent}${nested},\n${indent}}`;
+}
+function findObjectLiteralAtRange(sourceFile, range) {
+	let result;
+	const visit = (node) => {
+		if (ts.isObjectLiteralExpression(node) && node.getStart(sourceFile) === range.start && node.getEnd() === range.end) {
+			result = node;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return result;
+}
+function tokenObjectWriteSafety(object) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const property of object.properties) {
+		if (!ts.isPropertyAssignment(property)) return {
+			writable: false,
+			reason: "Token object contains a spread, shorthand, method, or accessor."
+		};
+		const key = propertyNameText(property.name);
+		if (!key) return {
+			writable: false,
+			reason: "Token object contains a computed key."
+		};
+		if (keys.has(key)) return {
+			writable: false,
+			reason: "Token object contains duplicate keys."
+		};
+		keys.add(key);
+		const valueObject = objectLiteralExpression(property.initializer);
+		if (!valueObject) return {
+			writable: false,
+			reason: "Token object contains a non-object token branch."
+		};
+		if (!objectProperty(valueObject, "value")) {
+			const nestedSafety = tokenObjectWriteSafety(valueObject);
+			if (!nestedSafety.writable) return nestedSafety;
+		}
+	}
+	return { writable: true };
+}
+function locateProperty(objectNode, propertyName) {
+	const matches = [];
+	for (const property of objectNode.properties) {
+		if (!ts.isPropertyAssignment(property)) return {
+			ok: false,
+			reason: {
+				code: "unsupported-source-shape",
+				message: "Only plain property assignments can be patched."
+			}
+		};
+		const name = propertyNameText(property.name);
+		if (name === void 0) return {
+			ok: false,
+			reason: {
+				code: "unsupported-source-shape",
+				message: "Computed property names are not safe to patch."
+			}
+		};
+		if (name === propertyName) matches.push(property);
+	}
+	if (matches.length > 1) return {
+		ok: false,
+		reason: {
+			code: "ambiguous-target",
+			message: "Token source contains duplicate keys for the requested path.",
+			details: { property: propertyName }
+		}
+	};
+	const property = matches[0];
+	if (!property) return {
+		ok: false,
+		reason: {
+			code: "invalid-path",
+			message: "Token source does not contain the requested path.",
+			details: { property: propertyName }
+		}
+	};
+	return {
+		ok: true,
+		property
+	};
+}
+function objectProperty(objectNode, propertyName) {
+	for (const property of objectNode.properties) {
+		if (!ts.isPropertyAssignment(property)) continue;
+		if (propertyNameText(property.name) === propertyName) return property.initializer;
+	}
+}
+function objectLiteralExpression(expression) {
+	if (ts.isObjectLiteralExpression(expression)) return expression;
+	if (ts.isSatisfiesExpression(expression) || ts.isAsExpression(expression)) return objectLiteralExpression(expression.expression);
+}
+function propertyNameText(name) {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+}
+function isPatchableLiteral(node) {
+	return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || ts.isNumericLiteral(node) || node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword || ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand);
+}
+function isJsonPrimitive(value) {
+	return value === null || [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value);
+}
+function literalSource(value) {
+	if (typeof value === "string") return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+	if (typeof value === "number") return Number.isFinite(value) ? String(value) : "null";
+	if (typeof value === "boolean") return value ? "true" : "false";
+	return "null";
+}
+function propertyNameSource(propertyName) {
+	if (/^\d+$/.test(propertyName)) return propertyName;
+	return /^[$A-Z_a-z][$\w]*$/.test(propertyName) ? propertyName : JSON.stringify(propertyName);
+}
+function commaAfterNode(node, objectNode, sourceText) {
+	for (let index = node.getEnd(); index < objectNode.getEnd() - 1; index += 1) {
+		const char = sourceText[index];
+		if (char === ",") return index;
+		if (!isWhitespace(char)) return void 0;
+	}
+}
+function isWhitespace(char) {
+	return char === " " || char === "	" || char === "\n" || char === "\r";
+}
+function indentationBefore(sourceText, position) {
+	const lineStart = sourceText.lastIndexOf("\n", position - 1) + 1;
+	return sourceText.slice(lineStart, position).match(/^[ \t]*/)?.[0] ?? "";
+}
+function rangeFromTokenSourceId(id) {
+	const parts = id.split("#");
+	const start = Number(parts[parts.length - 2]);
+	const end = Number(parts[parts.length - 1]);
+	if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start) return;
+	return {
+		start,
+		end
+	};
+}
+function applyReplacements(sourceText, replacements) {
+	let nextSource = sourceText;
+	for (const replacement of [...replacements].sort((left, right) => right.range.start - left.range.start)) nextSource = `${nextSource.slice(0, replacement.range.start)}${replacement.text}${nextSource.slice(replacement.range.end)}`;
+	return nextSource;
+}
+function focusedDiff(file, sourceText, nextSource, replacements) {
+	const firstStart = Math.min(...replacements.map((replacement) => replacement.range.start));
+	const lastEnd = Math.max(...replacements.map((replacement) => replacement.range.end));
+	const oldStartLine = lineNumberAt(sourceText, firstStart);
+	const oldEndLine = lineNumberAt(sourceText, lastEnd);
+	const contextStartLine = Math.max(1, oldStartLine - 2);
+	const contextEndLine = oldEndLine + 2;
+	const oldLines = sourceText.split("\n");
+	const newLines = nextSource.split("\n");
+	const oldSlice = oldLines.slice(contextStartLine - 1, contextEndLine);
+	const newSlice = newLines.slice(contextStartLine - 1, contextEndLine + (newLines.length - oldLines.length));
+	return [
+		`--- a/${file}`,
+		`+++ b/${file}`,
+		`@@ -${contextStartLine},${oldSlice.length} +${contextStartLine},${newSlice.length} @@`,
+		...oldSlice.map((line) => `-${line}`),
+		...newSlice.map((line) => `+${line}`)
+	].join("\n");
+}
+function lineNumberAt(sourceText, position) {
+	let line = 1;
+	for (let index = 0; index < position; index += 1) if (sourceText.charCodeAt(index) === 10) line += 1;
+	return line;
+}
+function normalizePath(path) {
+	return path.replace(/\\/g, "/");
+}
+function failure(editId, code, message, details) {
+	return {
+		ok: false,
+		editId,
+		written: false,
+		error: {
+			code,
+			message,
+			details
+		}
+	};
+}
+//#endregion
+export { tsxSourceParserAdapter as C, tsrxSourceParserAdapter as S, typescriptPandaAstAdapter as T, hashSource as _, createStyleModuleSourcePatch as a, parseWithSourceParserAdapter as b, safeProjectSourcePath as c, trustedManifestFilePath as d, trustedTokenSourceFilePath as f, analyzePandaCssSource as g, createInlineCssSourcePatch as h, createStyleModuleDetachPatch as i, stripViteQuery as l, createStaticCssPatch as m, componentStyleModulePaths as n, readComponentStyleModule as o, createStaticCssBatchPatch as p, createStyleModuleAttachPatch as r, normalizePath$2 as s, createTokenConfigPatch as t, toRelativeProjectPath as u, createEstreePandaAstAdapter as v, tsxSourceSyntaxAdapter as w, resolveSourceParserAdapter as x, parsePandaSource as y };