@samva/markup 0.8.0 → 0.10.0

package/dist/edit.js

@@ -0,0 +1,947 @@
+import { n as isObject } from "./guards-eV1qLbf2.js";
+import { d as completeJsxSourceLocation, u as JSX_SOURCE_LOCATION_PROP } from "./jsx-runtime-CBlexoeR.js";
+import { t as buildLineMap } from "./diagnostic-model-DJtqbETd.js";
+import { c as WHATSAPP_HEADER_TYPES, n as introducedProfileErrors, o as SMS_CATEGORIES, s as WHATSAPP_CATEGORIES, t as checkStaticProfile } from "./profile-pWGtWZXF.js";
+import { parse } from "@babel/parser";
+//#region src/source-edit.ts
+const node = (value) => isObject(value) && "type" in value && typeof value.type === "string" && "start" in value && typeof value.start === "number" && "end" in value && typeof value.end === "number";
+const children = (value) => Array.isArray(value) ? value.filter(node) : [];
+const walk$1 = (value, visit, parent = null) => {
+	if (Array.isArray(value)) {
+		for (const item of value) walk$1(item, visit, parent);
+		return;
+	}
+	if (!node(value)) return;
+	visit(value, parent);
+	for (const [key, child] of Object.entries(value)) if (key !== "loc" && key !== "extra" && key !== "comments") walk$1(child, visit, value);
+};
+const parsed = (source) => {
+	try {
+		const result = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"]
+		});
+		return node(result) ? result : null;
+	} catch {
+		return null;
+	}
+};
+const binding = (value) => value.type === "Identifier" || value.type === "MemberExpression" && value.computed === false && node(value.object) && binding(value.object);
+/** JSX trims each line of text and joins the non-empty lines with one space. */
+const collapseJsxText = (value) => value.split(/\r\n|\n|\r|\u2028|\u2029/).map((line) => line.trim()).filter((line) => line !== "").join(" ");
+const property = (name, value, source, syntax) => {
+	const expression = value.type === "JSXExpressionContainer" && node(value.expression) ? value.expression : value;
+	const literal = expression.type === "StringLiteral" || expression.type === "NumericLiteral" || expression.type === "BooleanLiteral" || expression.type === "JSXText";
+	const raw = source.slice(expression.start, expression.end);
+	const inset = expression.type === "JSXText" ? {
+		start: expression.start + (raw.length - raw.trimStart().length),
+		end: expression.end - (raw.length - raw.trimEnd().length)
+	} : {
+		start: value.start,
+		end: value.end
+	};
+	return {
+		name,
+		literalType: expression.type === "NumericLiteral" ? "number" : expression.type === "BooleanLiteral" ? "boolean" : "string",
+		kind: literal ? "literal" : binding(expression) ? "binding" : "computed",
+		value: literal && expression.type === "JSXText" && typeof expression.value === "string" ? collapseJsxText(expression.value) : literal && (typeof expression.value === "string" || typeof expression.value === "number" || typeof expression.value === "boolean") ? String(expression.value) : source.slice(expression.start, expression.end),
+		start: inset.start,
+		end: inset.end,
+		syntax
+	};
+};
+/** The JSX elements directly before and after `element` in its parent's child list. */
+const siblingsOf = (element, parent, source) => {
+	if (parent?.type !== "JSXElement" && parent?.type !== "JSXFragment") return {
+		previous: null,
+		next: null
+	};
+	const list = children(parent.children).filter((child) => child.type !== "JSXText" || source.slice(child.start, child.end).trim() !== "");
+	const index = list.findIndex((child) => child.start === element.start);
+	const range = (child) => child?.type === "JSXElement" ? {
+		start: child.start,
+		end: child.end
+	} : null;
+	return {
+		previous: range(list[index - 1]),
+		next: range(list[index + 1])
+	};
+};
+/** Resolve a renderer origin against the unchanged authored entry, never against HTML offsets. */
+const inspectSourceElement = (source, file, origin) => {
+	if (file !== origin.fileName) return null;
+	const tree = parsed(source);
+	if (tree === null) return null;
+	const lines = buildLineMap(source);
+	const lineStart = lines[origin.lineNumber - 1];
+	if (lineStart === void 0 || !Number.isInteger(origin.columnNumber) || origin.columnNumber < 1) return null;
+	const offset = lineStart + origin.columnNumber - 1;
+	if (offset >= (lines[origin.lineNumber] ?? source.length)) return null;
+	let found = null;
+	walk$1(tree, (element, parent) => {
+		if (element.type !== "JSXElement" || element.start !== offset || !node(element.openingElement)) return;
+		const opening = element.openingElement;
+		const properties = [];
+		for (const attribute of children(opening.attributes)) if (attribute.type === "JSXAttribute" && node(attribute.name) && typeof attribute.name.name === "string" && node(attribute.value)) {
+			const value = attribute.value;
+			const expression = value.type === "JSXExpressionContainer" && node(value.expression) ? value.expression : null;
+			if (attribute.name.name === "style" && expression?.type === "ObjectExpression" && !children(expression.properties).some((member) => member.type === "SpreadElement")) for (const member of children(expression.properties)) {
+				if (member.type !== "ObjectProperty" || member.computed === true || !node(member.key) || !node(member.value)) continue;
+				const key = member.key.type === "Identifier" ? member.key.name : member.key.value;
+				if (typeof key === "string") properties.push(property(`style.${key}`, member.value, source, "value"));
+			}
+			else properties.push(property(attribute.name.name, value, source, "attribute"));
+		}
+		const meaningful = children(element.children).filter((child) => child.type !== "JSXText" || source.slice(child.start, child.end).trim() !== "");
+		if (meaningful.length === 1 && meaningful[0] !== void 0 && meaningful[0].type !== "JSXElement" && meaningful[0].type !== "JSXFragment") properties.unshift(property("children", meaningful[0], source, "child"));
+		else if (meaningful.length > 1) {
+			const texts = meaningful.flatMap((child, index) => child.type === "JSXText" ? [property(`text.${index}`, child, source, "child")] : []);
+			properties.unshift(...texts);
+		}
+		found = {
+			start: element.start,
+			end: element.end,
+			contentStart: opening.selfClosing === true ? null : opening.end,
+			contentEnd: node(element.closingElement) ? element.closingElement.start : null,
+			tag: node(opening.name) ? source.slice(opening.name.start, opening.name.end) : "element",
+			properties,
+			attributeInsertion: (() => {
+				const last = children(opening.attributes).at(-1);
+				if (last !== void 0) return last.end;
+				return node(opening.name) ? opening.name.end : opening.end - 1;
+			})(),
+			hasSpread: children(opening.attributes).some((attribute) => attribute.type === "JSXSpreadAttribute"),
+			structural: parent?.type === "JSXElement" || parent?.type === "JSXFragment",
+			...siblingsOf(element, parent, source)
+		};
+	});
+	return found;
+};
+const PLAIN_JSX_TEXT = /^[^\s{}<>&](?:[^{}<>&\r\n\u2028\u2029]*[^\s{}<>&])?$/;
+/** Literal controls cannot overwrite a binding or computed expression. */
+const literalReplacement = (source, field, value) => {
+	if (field.kind !== "literal") return null;
+	if (field.literalType === "number" && (value.trim() === "" || !Number.isFinite(Number(value)))) return null;
+	if (field.literalType === "boolean" && value !== "true" && value !== "false") return null;
+	const literal = field.literalType === "string" ? JSON.stringify(value) : field.literalType === "number" ? String(Number(value)) : value;
+	const before = source.slice(field.start, field.end);
+	const plainText = field.syntax === "child" && !before.startsWith("{") && PLAIN_JSX_TEXT.test(value);
+	return {
+		start: field.start,
+		end: field.end,
+		before,
+		after: plainText ? value : field.syntax === "child" || field.syntax === "attribute" && field.literalType !== "string" ? `{${literal}}` : literal
+	};
+};
+/** Explicit expression changes are proposals: callers show before/after and require Apply. */
+const expressionReplacement = (source, field, expression) => ({
+	start: field.start,
+	end: field.end,
+	before: source.slice(field.start, field.end),
+	after: field.syntax === "value" ? expression : `{${expression}}`
+});
+const profileRefusal = (source, result, guard) => {
+	const file = guard.file ?? guard.entry;
+	const project = (content) => ({
+		...guard.files,
+		[file]: content
+	});
+	const introduced = introducedProfileErrors(checkStaticProfile(project(source), guard.entry), checkStaticProfile(project(result), guard.entry));
+	const first = introduced[0];
+	if (first === void 0) return null;
+	const more = introduced.length > 1 ? ` (and ${introduced.length - 1} more)` : "";
+	return `This change leaves the static profile: ${first.message}${first.fix === void 0 ? "" : ` ${first.fix}`}${more}`;
+};
+/** Apply exact, nonoverlapping edits and refuse syntax damage without changing the original. */
+const applySourceReplacements = (source, edits, options = {}) => {
+	const sorted = [...edits].sort((a, b) => b.start - a.start);
+	let boundary = source.length;
+	let result = source;
+	for (const edit of sorted) {
+		if (edit.start < 0 || edit.end < edit.start || edit.end > boundary || source.slice(edit.start, edit.end) !== edit.before) return {
+			ok: false,
+			reason: "Source changed at this target. Select it again before applying the edit."
+		};
+		result = result.slice(0, edit.start) + edit.after + result.slice(edit.end);
+		boundary = edit.start;
+	}
+	if (parsed(result) === null) return {
+		ok: false,
+		reason: "This change is not valid TSX. Review it in Source."
+	};
+	if (options.profile !== void 0 && result !== source) {
+		const refusal = profileRefusal(source, result, options.profile);
+		if (refusal !== null) return {
+			ok: false,
+			reason: refusal
+		};
+	}
+	return {
+		ok: true,
+		source: result
+	};
+};
+const indentation = (source, offset) => {
+	const lineStart = Math.max(source.lastIndexOf("\n", offset - 1), source.lastIndexOf("\r", offset - 1));
+	const lead = source.slice(lineStart + 1, offset);
+	return /^[ \t]*$/.test(lead) ? lead : null;
+};
+/** The whole lines an element alone occupies, so removing it leaves no blank line behind. */
+const ownLines = (source, element) => {
+	if (indentation(source, element.start) === null) return element;
+	const trailing = /^[ \t]*(\r\n|\n|\r)/.exec(source.slice(element.end));
+	if (trailing === null) return element;
+	return {
+		start: element.start - (indentation(source, element.start) ?? "").length,
+		end: element.end + trailing[0].length
+	};
+};
+/** Structural edits name a whole authored block; loop iterations are never source nodes. */
+const structuralReplacements = (source, element, operation) => {
+	if (operation.kind === "insert") {
+		if (element.contentEnd === null) return null;
+		return [{
+			start: element.contentEnd,
+			end: element.contentEnd,
+			before: "",
+			after: operation.tsx
+		}];
+	}
+	if (!element.structural) return null;
+	const text = source.slice(element.start, element.end);
+	if (operation.kind === "duplicate") {
+		const indent = indentation(source, element.start);
+		return [{
+			start: element.end,
+			end: element.end,
+			before: "",
+			after: indent === null ? text : `\n${indent}${text}`
+		}];
+	}
+	if (operation.kind === "reorder") {
+		const neighbour = operation.direction === "before" ? element.previous : element.next;
+		if (neighbour === null) return null;
+		return [{
+			start: neighbour.start,
+			end: neighbour.end,
+			before: source.slice(neighbour.start, neighbour.end),
+			after: text
+		}, {
+			start: element.start,
+			end: element.end,
+			before: text,
+			after: source.slice(neighbour.start, neighbour.end)
+		}];
+	}
+	const removal = ownLines(source, element);
+	const removed = {
+		start: removal.start,
+		end: removal.end,
+		before: source.slice(removal.start, removal.end),
+		after: ""
+	};
+	if (operation.kind === "delete") return [removed];
+	const destination = operation.destination.contentEnd;
+	if (destination === null || destination >= element.start && destination <= element.end) return null;
+	return [removed, {
+		start: destination,
+		end: destination,
+		before: "",
+		after: text
+	}];
+};
+/** The object literal a top-level `const name = { ... }` holds. */
+const topLevelObject = (tree, name) => {
+	const program = tree.program;
+	if (!node(program)) return null;
+	for (const item of children(program.body)) {
+		const declaration = item.type === "ExportNamedDeclaration" && node(item.declaration) ? item.declaration : item;
+		if (declaration.type !== "VariableDeclaration") continue;
+		for (const declarator of children(declaration.declarations)) if (node(declarator.id) && declarator.id.name === name && node(declarator.init) && declarator.init.type === "ObjectExpression") return declarator.init;
+	}
+	return null;
+};
+/** Declared fixture values are separate source targets from body bindings and literals. */
+const inspectSourceFixtures = (source) => {
+	const tree = parsed(source);
+	if (tree === null) return [];
+	const found = [];
+	walk$1(tree, (call) => {
+		if (call.type !== "CallExpression" || !node(call.callee) || call.callee.type !== "Identifier" || call.callee.name !== "defineTemplate") return;
+		const definition = children(call.arguments)[0];
+		if (definition?.type !== "ObjectExpression") return;
+		const fixtures = children(definition.properties).find((field) => field.type === "ObjectProperty" && node(field.key) && field.key.name === "fixtures" && field.computed !== true);
+		if (fixtures === void 0 || !node(fixtures.value) || fixtures.value.type !== "ObjectExpression") return;
+		for (const field of children(fixtures.value.properties)) {
+			if (field.type !== "ObjectProperty" || field.computed === true || !node(field.key) || !node(field.value)) continue;
+			const name = field.key.type === "Identifier" ? field.key.name : field.key.value;
+			const value = field.value.type === "Identifier" && typeof field.value.name === "string" ? topLevelObject(tree, field.value.name) ?? field.value : field.value;
+			if (typeof name === "string") found.push({
+				name,
+				start: value.start,
+				end: value.end,
+				source: source.slice(value.start, value.end)
+			});
+		}
+	});
+	return found;
+};
+const tokens = (value) => value.split(/\s+/).filter((item) => item !== "");
+/**
+* Edit an element's class list where it is written. A literal `className` is replaced, extended or
+* trimmed in place; a missing one is added; one that is a condition or any other expression is
+* refused, because rewriting it would discard the choice the author encoded.
+*/
+const classNameEdit = (source, element, operation) => {
+	const field = element.properties.find((item) => item.name === "className");
+	const next = (current) => {
+		if (operation.kind === "set") return tokens(operation.value).join(" ");
+		const wanted = tokens(operation.tokens);
+		return operation.kind === "add" ? [...current, ...wanted.filter((item) => !current.includes(item))].join(" ") : current.filter((item) => !wanted.includes(item)).join(" ");
+	};
+	if (field === void 0) {
+		if (element.hasSpread) return {
+			ok: false,
+			reason: "A spread attribute can supply className here, so a class list cannot be added safely. Edit it in Source."
+		};
+		if (operation.kind === "remove") return {
+			ok: true,
+			edits: []
+		};
+		const value = next([]);
+		if (value === "") return {
+			ok: true,
+			edits: []
+		};
+		return {
+			ok: true,
+			edits: [{
+				start: element.attributeInsertion,
+				end: element.attributeInsertion,
+				before: "",
+				after: ` className=${JSON.stringify(value)}`
+			}]
+		};
+	}
+	if (field.kind !== "literal" || field.literalType !== "string") return {
+		ok: false,
+		reason: `className is ${field.kind === "binding" ? "bound to" : "computed from"} \`${field.value}\`, so editing it would discard that choice. Change the literal classes inside it in Source.`
+	};
+	const value = next(tokens(field.value));
+	return {
+		ok: true,
+		edits: [{
+			start: field.start,
+			end: field.end,
+			before: source.slice(field.start, field.end),
+			after: JSON.stringify(value)
+		}]
+	};
+};
+//#endregion
+//#region src/channel-edit.ts
+const isNode = (value) => isObject(value) && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+const nodeList = (value) => Array.isArray(value) ? value.filter(isNode) : [];
+const nodeOf = (parent, key) => {
+	const value = parent[key];
+	return isNode(value) ? value : null;
+};
+const parseSource = (source) => {
+	try {
+		const result = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"]
+		});
+		return isNode(result) ? result : null;
+	} catch {
+		return null;
+	}
+};
+const walk = (value, visit) => {
+	if (Array.isArray(value)) {
+		for (const item of value) walk(item, visit);
+		return;
+	}
+	if (!isNode(value)) return;
+	if (visit(value) === false) return;
+	for (const [key, child] of Object.entries(value)) if (key !== "loc" && key !== "extra" && key !== "comments") walk(child, visit);
+};
+const jsxName = (name) => {
+	if (name === null) return "";
+	if (name.type === "JSXIdentifier") return typeof name.name === "string" ? name.name : "";
+	if (name.type === "JSXMemberExpression") return `${jsxName(nodeOf(name, "object"))}.${jsxName(nodeOf(name, "property"))}`;
+	return "";
+};
+const elementOf = (node) => {
+	if (node.type !== "JSXElement") return null;
+	const opening = nodeOf(node, "openingElement");
+	if (opening === null) return null;
+	const closing = nodeOf(node, "closingElement");
+	return {
+		node,
+		opening,
+		closing,
+		tag: jsxName(nodeOf(opening, "name")),
+		children: nodeList(node.children),
+		attributes: nodeList(opening.attributes),
+		selfClosing: opening.selfClosing === true,
+		contentStart: opening.end,
+		contentEnd: closing === null ? opening.end : closing.start
+	};
+};
+const returnedElement = (fn) => {
+	const body = nodeOf(fn, "body");
+	if (body === null) return null;
+	if (body.type === "JSXElement") return body;
+	if (body.type !== "BlockStatement") return null;
+	const statements = nodeList(body.body).filter((statement) => statement.type !== "EmptyStatement");
+	const only = statements.length === 1 ? statements[0] : void 0;
+	const argument = only?.type === "ReturnStatement" && only !== void 0 ? nodeOf(only, "argument") : null;
+	return argument !== null && argument.type === "JSXElement" ? argument : null;
+};
+const propertyName = (property) => {
+	if (property.computed === true) return null;
+	const key = nodeOf(property, "key");
+	if (key === null) return null;
+	if (key.type === "Identifier") return typeof key.name === "string" ? key.name : null;
+	return key.type === "StringLiteral" && typeof key.value === "string" ? key.value : null;
+};
+/** The function behind `defineTemplate({ [channel]: … })`, when it is written in place. */
+const channelFunction = (tree, channel) => {
+	let found = null;
+	walk(tree, (call) => {
+		if (found !== null) return false;
+		if (call.type !== "CallExpression") return;
+		const callee = nodeOf(call, "callee");
+		if (callee?.type !== "Identifier" || callee.name !== "defineTemplate") return;
+		const definition = nodeList(call.arguments)[0];
+		if (definition?.type !== "ObjectExpression") return false;
+		for (const property of nodeList(definition.properties)) {
+			if (propertyName(property) !== channel) continue;
+			const fn = property.type === "ObjectMethod" ? property : property.type === "ObjectProperty" ? nodeOf(property, "value") : null;
+			if (fn === null || fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression" && fn.type !== "ObjectMethod") return false;
+			const returned = returnedElement(fn);
+			const root = returned === null ? null : elementOf(returned);
+			if (root !== null) found = {
+				root,
+				parameter: nodeList(fn.params)[0] ?? null
+			};
+			return false;
+		}
+		return false;
+	});
+	return found;
+};
+/** The name an import binds a component to, or the component's own name when nothing is imported. */
+const importedAs = (tree, specifier, imported) => {
+	let local = imported;
+	walk(tree, (node) => {
+		if (node.type !== "ImportDeclaration") return;
+		if (nodeOf(node, "source")?.value !== specifier) return false;
+		for (const item of nodeList(node.specifiers)) {
+			const name = nodeOf(item, "imported");
+			const alias = nodeOf(item, "local");
+			if (item.type === "ImportSpecifier" && (name?.name === imported || name?.value === imported)) local = typeof alias?.name === "string" ? alias.name : imported;
+		}
+		return false;
+	});
+	return local;
+};
+/** JSX text as the compiler reads it: lines are trimmed and joined, blank lines dropped. */
+const jsxTextValue = (value) => {
+	const lines = value.split(/\r\n|\n|\r/);
+	let lastNonEmpty = 0;
+	lines.forEach((line, index) => {
+		if (/[^ \t]/.test(line)) lastNonEmpty = index;
+	});
+	let result = "";
+	lines.forEach((line, index) => {
+		let trimmed = line.replace(/\t/g, " ");
+		if (index !== 0) trimmed = trimmed.replace(/^ +/, "");
+		if (index !== lines.length - 1) trimmed = trimmed.replace(/ +$/, "");
+		if (trimmed === "") return;
+		result += index === lastNonEmpty ? trimmed : `${trimmed} `;
+	});
+	return result;
+};
+/** The value of a container that holds only a string, or null for any other expression. */
+const stringContainerValue = (container) => {
+	const expression = nodeOf(container, "expression");
+	if (expression === null) return null;
+	if (expression.type === "StringLiteral" && typeof expression.value === "string") return expression.value;
+	if (expression.type === "TemplateLiteral" && nodeList(expression.expressions).length === 0) {
+		const cooked = nodeList(expression.quasis)[0]?.value;
+		return isObject(cooked) && typeof cooked.cooked === "string" ? cooked.cooked : null;
+	}
+	return null;
+};
+const summarize = (source, node) => {
+	const text = source.slice(node.start, node.end).replace(/\s+/g, " ").trim();
+	return text.length > 60 ? `${text.slice(0, 59)}…` : text;
+};
+/**
+* The editable text and locked expressions of an element's children, in order. Text is a segment
+* between locked children, so a text segment exists (possibly empty) before, between and after
+* them.
+*/
+const segmentsOf = (source, element) => {
+	const segments = [];
+	let start = element.contentStart;
+	let text = "";
+	const flush = (end) => {
+		segments.push({
+			kind: "text",
+			text,
+			start,
+			end
+		});
+		text = "";
+	};
+	for (const child of element.children) {
+		if (child.type === "JSXText") {
+			text += jsxTextValue(typeof child.value === "string" ? child.value : "");
+			continue;
+		}
+		if (child.type === "JSXExpressionContainer") {
+			const value = stringContainerValue(child);
+			if (value !== null) {
+				text += value;
+				continue;
+			}
+		}
+		flush(child.start);
+		segments.push({
+			kind: "locked",
+			summary: summarize(source, child),
+			start: child.start,
+			end: child.end
+		});
+		start = child.end;
+	}
+	flush(element.contentEnd);
+	return segments;
+};
+const isSafeRun = (char) => !/[{}<>&\r\n\t]/.test(char);
+/**
+* JSX for the given text. Characters JSX text cannot carry, and whitespace at an edge the
+* compiler would trim, are written as string expressions; the rest stays plain text.
+*/
+const encodeText = (text, trimStart, trimEnd) => {
+	const chars = [...text];
+	const unsafe = chars.map((char) => !isSafeRun(char));
+	if (trimStart) for (let i = 0; i < chars.length && /\s/.test(chars[i]); i++) unsafe[i] = true;
+	if (trimEnd) for (let i = chars.length - 1; i >= 0 && /\s/.test(chars[i]); i--) unsafe[i] = true;
+	let result = "";
+	let run = "";
+	let runUnsafe = false;
+	const flush = () => {
+		if (run === "") return;
+		result += runUnsafe ? `{${JSON.stringify(run)}}` : run;
+		run = "";
+	};
+	chars.forEach((char, index) => {
+		if (run !== "" && unsafe[index] !== runUnsafe) flush();
+		runUnsafe = unsafe[index];
+		run += char;
+	});
+	flush();
+	return result;
+};
+/** Write `text` over the gap at `segment`, keeping the newlines and indentation around it. */
+const writeText = (source, element, segments, index, text) => {
+	const segment = segments[index];
+	if (segment?.kind !== "text") return {
+		ok: false,
+		reason: "That part of the body is locked."
+	};
+	if (segment.text === text) return {
+		ok: true,
+		edits: []
+	};
+	if (element.selfClosing) {
+		const opening = element.opening;
+		let start = opening.end - 2;
+		while (start > opening.start && /\s/.test(source[start - 1])) start--;
+		return {
+			ok: true,
+			edits: [{
+				start,
+				end: opening.end,
+				before: source.slice(start, opening.end),
+				after: `>${encodeText(text, false, false)}</${element.tag}>`
+			}]
+		};
+	}
+	const raw = source.slice(segment.start, segment.end);
+	const leading = /^\s*/.exec(raw)?.[0] ?? "";
+	const prefix = /[\r\n]/.test(leading) ? leading : "";
+	const rest = raw.slice(prefix.length);
+	const trailing = /\s*$/.exec(rest)?.[0] ?? "";
+	const suffix = /[\r\n]/.test(trailing) ? trailing : "";
+	const start = segment.start + prefix.length;
+	const end = segment.end - suffix.length;
+	return {
+		ok: true,
+		edits: [{
+			start,
+			end,
+			before: source.slice(start, end),
+			after: encodeText(text, prefix !== "", suffix !== "")
+		}]
+	};
+};
+const attributeNamed = (element, name) => element.attributes.find((attribute) => attribute.type === "JSXAttribute" && jsxName(nodeOf(attribute, "name")) === name) ?? null;
+const attributeState = (source, element, name) => {
+	const attribute = attributeNamed(element, name);
+	if (attribute === null) return { kind: "absent" };
+	const value = nodeOf(attribute, "value");
+	if (value?.type === "StringLiteral" && typeof value.value === "string") return {
+		kind: "literal",
+		value: value.value
+	};
+	if (value?.type === "JSXExpressionContainer") {
+		const literal = stringContainerValue(value);
+		if (literal !== null) return {
+			kind: "literal",
+			value: literal
+		};
+	}
+	return {
+		kind: "expression",
+		source: summarize(source, value ?? attribute)
+	};
+};
+const encodeAttribute = (value) => /["&\\\r\n]/.test(value) ? `{${JSON.stringify(value)}}` : `"${value}"`;
+const replacement = (source, start, end, after) => ({
+	start,
+	end,
+	before: source.slice(start, end),
+	after
+});
+/** Set, add or remove one string attribute of an element. */
+const setAttribute = (source, element, name, value) => {
+	const attribute = attributeNamed(element, name);
+	if (attribute === null) {
+		if (value === void 0) return {
+			ok: true,
+			edits: []
+		};
+		const anchor = element.attributes.at(-1)?.end ?? nodeOf(element.opening, "name")?.end ?? element.opening.end;
+		return {
+			ok: true,
+			edits: [replacement(source, anchor, anchor, ` ${name}=${encodeAttribute(value)}`)]
+		};
+	}
+	if (attributeState(source, element, name).kind === "expression") return {
+		ok: false,
+		reason: `\`${name}\` reads the input. Edit it in Source.`
+	};
+	if (value === void 0) {
+		let start = attribute.start;
+		while (start > element.opening.start && /\s/.test(source[start - 1])) start--;
+		return {
+			ok: true,
+			edits: [replacement(source, start, attribute.end, "")]
+		};
+	}
+	const literal = nodeOf(attribute, "value");
+	return {
+		ok: true,
+		edits: literal === null ? [replacement(source, attribute.end, attribute.end, `=${encodeAttribute(value)}`)] : [replacement(source, literal.start, literal.end, encodeAttribute(value))]
+	};
+};
+const INDENT = "  ";
+/** The indentation of the line `position` is on, when only whitespace precedes it there. */
+const ownLineIndent = (source, position) => {
+	const lineStart = source.lastIndexOf("\n", position - 1) + 1;
+	const lead = source.slice(lineStart, position);
+	return /^[ \t]*$/.test(lead) ? lead : null;
+};
+/** Remove a child, and its line when it is alone on one. */
+const removeChild = (source, node) => {
+	const indent = ownLineIndent(source, node.start);
+	const after = /^[ \t]*(\r?\n)/.exec(source.slice(node.end));
+	if (indent === null || after === null) return replacement(source, node.start, node.end, "");
+	const start = node.start - indent.length;
+	return replacement(source, start, node.end + after[0].length, "");
+};
+/** Insert markup on its own line before or after a sibling, or inline when the sibling is not alone. */
+const insertBeside = (source, sibling, side, text) => {
+	const indent = ownLineIndent(source, sibling.start);
+	if (side === "before") return replacement(source, sibling.start, sibling.start, indent === null ? text : `${text}\n${indent}`);
+	return replacement(source, sibling.end, sibling.end, indent === null ? text : `\n${indent}${text}`);
+};
+/** The input fields read by the expressions inside `root`, as dotted paths. */
+const variablesOf = (source, root, parameter) => {
+	const names = /* @__PURE__ */ new Set();
+	const scan = (text) => {
+		if (parameter?.type === "Identifier" && typeof parameter.name === "string") {
+			const pattern = new RegExp(`\\b${parameter.name}((?:\\??\\.[A-Za-z_$][\\w$]*)+)`, "g");
+			for (const match of text.matchAll(pattern)) names.add(match[1].replace(/\?/g, "").slice(1));
+		} else if (parameter?.type === "ObjectPattern") for (const property of nodeList(parameter.properties)) {
+			const key = nodeOf(property, "key");
+			if (key?.type === "Identifier" && typeof key.name === "string") {
+				if (new RegExp(`\\b${key.name}\\b`).test(text)) names.add(key.name);
+			}
+		}
+	};
+	walk(root.node, (node) => {
+		if (node.type === "JSXExpressionContainer" && stringContainerValue(node) === null) scan(source.slice(node.start, node.end));
+	});
+	return [...names].sort();
+};
+const smsChannel = (source) => {
+	const tree = parseSource(source);
+	if (tree === null) return null;
+	const channel = channelFunction(tree, "sms");
+	if (channel === null || channel.root.tag !== importedAs(tree, "@samva/markup/sms", "Sms")) return null;
+	return {
+		...channel,
+		tree
+	};
+};
+/** The form model of the template's SMS body, or null when it is not a `<Sms>` written in place. */
+const readSmsChannel = (source) => {
+	const channel = smsChannel(source);
+	if (channel === null) return null;
+	return {
+		category: attributeState(source, channel.root, "category"),
+		segments: segmentsOf(source, channel.root),
+		variables: variablesOf(source, channel.root, channel.parameter)
+	};
+};
+/** The source replacements that apply one form change to the SMS body. */
+const editSmsChannel = (source, edit) => {
+	const channel = smsChannel(source);
+	if (channel === null) return {
+		ok: false,
+		reason: "The SMS body is not editable here."
+	};
+	if (edit.kind === "category") {
+		if (edit.value !== void 0 && !SMS_CATEGORIES.includes(edit.value)) return {
+			ok: false,
+			reason: `\`${edit.value}\` is not an SMS category.`
+		};
+		return setAttribute(source, channel.root, "category", edit.value);
+	}
+	return writeText(source, channel.root, segmentsOf(source, channel.root), edit.segment, edit.text);
+};
+const BUTTON_TAGS = {
+	"quick-reply": "QuickReplyButton",
+	url: "UrlButton",
+	phone: "PhoneButton",
+	"copy-code": "CopyCodeButton"
+};
+const BUTTON_DEFAULTS = {
+	"quick-reply": "Reply",
+	url: "Visit site",
+	phone: "Call us",
+	"copy-code": "CODE"
+};
+const kindOfTag = (tag, local) => {
+	if (!tag.startsWith(`${local}.`)) return null;
+	const part = tag.slice(local.length + 1);
+	return Object.keys(BUTTON_TAGS).find((kind) => BUTTON_TAGS[kind] === part) ?? null;
+};
+const whatsappChannel = (source) => {
+	const tree = parseSource(source);
+	if (tree === null) return null;
+	const channel = channelFunction(tree, "whatsapp");
+	const local = importedAs(tree, "@samva/markup/whatsapp", "WhatsApp");
+	if (channel === null || channel.root.tag !== local) return null;
+	const part = (name) => {
+		for (const child of channel.root.children) {
+			const element = elementOf(child);
+			if (element?.tag === `${local}.${name}`) return element;
+		}
+		return null;
+	};
+	return {
+		...channel,
+		local,
+		header: part("Header"),
+		body: part("Body"),
+		footer: part("Footer"),
+		buttons: part("Buttons")
+	};
+};
+const buttonRows = (source, channel) => {
+	if (channel.buttons === null) return [];
+	const rows = [];
+	for (const child of channel.buttons.children) {
+		if (child.type === "JSXText" && jsxTextValue(String(child.value ?? "")) === "") continue;
+		const element = elementOf(child);
+		const kind = element === null ? null : kindOfTag(element.tag, channel.local);
+		if (element === null || kind === null) {
+			rows.push({
+				row: {
+					kind: "locked",
+					summary: summarize(source, child)
+				},
+				node: child
+			});
+			continue;
+		}
+		const segments = segmentsOf(source, element);
+		const label = segments[0];
+		rows.push({
+			node: child,
+			row: segments.length === 1 && label?.kind === "text" ? {
+				kind: "editable",
+				type: kind,
+				text: label.text,
+				url: attributeState(source, element, "url"),
+				phone: attributeState(source, element, "phone")
+			} : {
+				kind: "locked",
+				summary: summarize(source, child)
+			}
+		});
+	}
+	return rows;
+};
+/** The form model of the template's WhatsApp body, or null when it is not a `<WhatsApp>` written in place. */
+const readWhatsAppChannel = (source) => {
+	const channel = whatsappChannel(source);
+	if (channel === null || channel.body === null) return null;
+	const { root } = channel;
+	return {
+		name: attributeState(source, root, "name"),
+		language: attributeState(source, root, "language"),
+		category: attributeState(source, root, "category"),
+		header: channel.header === null ? null : segmentsOf(source, channel.header),
+		headerType: channel.header === null ? { kind: "absent" } : attributeState(source, channel.header, "type"),
+		body: segmentsOf(source, channel.body),
+		footer: channel.footer === null ? null : segmentsOf(source, channel.footer),
+		buttons: buttonRows(source, channel).map(({ row }) => row),
+		variables: variablesOf(source, root, channel.parameter)
+	};
+};
+const buttonMarkup = (local, type, text, attributes) => {
+	const tag = `${local}.${BUTTON_TAGS[type]}`;
+	return `<${tag}${type === "url" && attributes.url !== void 0 ? ` url=${encodeAttribute(attributes.url)}` : type === "phone" && attributes.phone !== void 0 ? ` phone=${encodeAttribute(attributes.phone)}` : ""}>${encodeText(text, false, false)}</${tag}>`;
+};
+const newButton = (local, type) => buttonMarkup(local, type, BUTTON_DEFAULTS[type], {
+	url: "https://example.com",
+	phone: "+15555550100"
+});
+const editPart = (source, channel, part, index, text) => {
+	const element = channel[part];
+	if (element === null) {
+		if (part === "body" || text === "" || index !== 0) return {
+			ok: true,
+			edits: []
+		};
+		const tag = `${channel.local}.${part === "header" ? "Header" : "Footer"}`;
+		const markup = `<${tag}>${encodeText(text, false, false)}</${tag}>`;
+		const anchor = part === "header" ? channel.body.node : channel.buttons?.node ?? channel.body.node;
+		return {
+			ok: true,
+			edits: [insertBeside(source, anchor, part === "header" ? "before" : "after", markup)]
+		};
+	}
+	const segments = segmentsOf(source, element);
+	if (part !== "body" && text === "" && segments.length === 1) return {
+		ok: true,
+		edits: [removeChild(source, element.node)]
+	};
+	return writeText(source, element, segments, index, text);
+};
+/** The source replacements that apply one form change to the WhatsApp body. */
+const editWhatsAppChannel = (source, edit) => {
+	const channel = whatsappChannel(source);
+	if (channel === null || channel.body === null) return {
+		ok: false,
+		reason: "The WhatsApp body is not editable here."
+	};
+	const { root, local } = channel;
+	switch (edit.kind) {
+		case "attribute": {
+			if (edit.name === "category" && !WHATSAPP_CATEGORIES.includes(edit.value ?? "")) return {
+				ok: false,
+				reason: "Choose a WhatsApp category."
+			};
+			const value = edit.name === "name" && edit.value === "" ? void 0 : edit.value ?? "";
+			return setAttribute(source, root, edit.name, value);
+		}
+		case "headerType":
+			if (channel.header === null) return {
+				ok: false,
+				reason: "Add the header text before choosing its type."
+			};
+			if (!WHATSAPP_HEADER_TYPES.includes(edit.value)) return {
+				ok: false,
+				reason: `\`${edit.value}\` is not a header type.`
+			};
+			return setAttribute(source, channel.header, "type", edit.value === "text" ? void 0 : edit.value);
+		case "text": return editPart(source, channel, edit.part, edit.segment, edit.text);
+		case "buttonAdd": {
+			const button = newButton(local, edit.type);
+			const buttons = channel.buttons;
+			if (buttons === null) {
+				const anchor = channel.footer ?? channel.body;
+				const tag = `${local}.Buttons`;
+				const indent = ownLineIndent(source, anchor.node.start);
+				const markup = indent === null ? `<${tag}>${button}</${tag}>` : `<${tag}>\n${indent}${INDENT}${button}\n${indent}</${tag}>`;
+				return {
+					ok: true,
+					edits: [insertBeside(source, anchor.node, "after", markup)]
+				};
+			}
+			if (buttons.selfClosing) {
+				const tag = `${local}.Buttons`;
+				const indent = ownLineIndent(source, buttons.node.start);
+				const markup = indent === null ? `<${tag}>${button}</${tag}>` : `<${tag}>\n${indent}${INDENT}${button}\n${indent}</${tag}>`;
+				return {
+					ok: true,
+					edits: [replacement(source, buttons.node.start, buttons.node.end, markup)]
+				};
+			}
+			const last = buttons.children.findLast((child) => child.type !== "JSXText" || jsxTextValue(String(child.value ?? "")) !== "");
+			if (last !== void 0) return {
+				ok: true,
+				edits: [insertBeside(source, last, "after", button)]
+			};
+			const indent = ownLineIndent(source, buttons.node.start);
+			return {
+				ok: true,
+				edits: [replacement(source, buttons.contentStart, buttons.contentEnd, indent === null ? button : `\n${indent}${INDENT}${button}\n${indent}`)]
+			};
+		}
+	}
+	const rows = buttonRows(source, channel);
+	const target = rows[edit.button];
+	if (target === void 0 || channel.buttons === null) return {
+		ok: false,
+		reason: "That button no longer exists."
+	};
+	if (edit.kind === "buttonRemove") return {
+		ok: true,
+		edits: [removeChild(source, rows.length === 1 ? channel.buttons.node : target.node)]
+	};
+	const element = elementOf(target.node);
+	if (target.row.kind === "locked" || element === null) return {
+		ok: false,
+		reason: "That button is locked. Edit it in Source."
+	};
+	switch (edit.kind) {
+		case "buttonText": return writeText(source, element, segmentsOf(source, element), 0, edit.text);
+		case "buttonAttribute": return setAttribute(source, element, edit.name, edit.value);
+		default: {
+			const { row } = target;
+			const keep = (state) => state.kind === "literal" ? state.value : void 0;
+			const markup = buttonMarkup(local, edit.type, row.text, {
+				url: keep(row.url) ?? "https://example.com",
+				phone: keep(row.phone) ?? "+15555550100"
+			});
+			return {
+				ok: true,
+				edits: [replacement(source, target.node.start, target.node.end, markup)]
+			};
+		}
+	}
+};
+//#endregion
+export { JSX_SOURCE_LOCATION_PROP, applySourceReplacements, classNameEdit, completeJsxSourceLocation, editSmsChannel, editWhatsAppChannel, expressionReplacement, inspectSourceElement, inspectSourceFixtures, literalReplacement, readSmsChannel, readWhatsAppChannel, structuralReplacements };
+
+//# sourceMappingURL=edit.js.map