@samva/markup 0.1.0

package/dist/parser.js

@@ -0,0 +1,821 @@
+import { SmlParseError } from "./diagnostics.js";
+import { parsePredicate, printPredicate } from "./predicate.js";
+import { CHANNEL_BY_ROOT_TAG, ROOT_TAGS, SML_TAGS, isRootTag } from "./ast.js";
+import { TokenKind, createLexer } from "./lexer.js";
+import { Result } from "effect";
+//#region src/parser.ts
+const SMS_CATEGORIES = [
+	"transactional",
+	"promotional",
+	"service_implicit"
+];
+const WHATSAPP_CATEGORIES = [
+	"marketing",
+	"utility",
+	"authentication",
+	"service"
+];
+const WHATSAPP_HEADER_TYPES = [
+	"text",
+	"image",
+	"video",
+	"document"
+];
+const WHATSAPP_BUTTON_TYPES = [
+	"quick-reply",
+	"url",
+	"phone",
+	"copy-code"
+];
+/**
+* Background-image attributes on the email block containers (Section/Container).
+* A URL is an ATTRIBUTE, not a class token: a URL inside the closed class
+* grammar is hostile (escaping, cache eviction, no caniemail slug), so it rides
+* the attribute channel like `src`/`href`. The compiler emits email-safe
+* background CSS from these (escaped `url(...)` + an Outlook `background` cell
+* attribute); Outlook for Windows renders no CSS background image, so
+* `checks` warns via `css-background-image`. Position/size are ignored by the
+* compiler when no `backgroundImage` is set.
+*/
+const BACKGROUND_ATTRIBUTES = {
+	backgroundImage: { type: "string" },
+	backgroundPosition: {
+		type: "string",
+		values: [
+			"center",
+			"top",
+			"bottom"
+		]
+	},
+	backgroundSize: {
+		type: "string",
+		values: [
+			"cover",
+			"contain",
+			"auto"
+		]
+	}
+};
+/**
+* The email language surface as data: per-tag attributes
+* (type/required/bounds) and content model. Public API — typed TSX components
+* and the reference-docs generator derive from this table, so it cannot drift
+* from the parser.
+*/
+const EMAIL_TAG_SPECS = {
+	Email: {
+		attributes: {
+			lang: { type: "string" },
+			dir: { type: "string" },
+			width: {
+				type: "number",
+				min: 1,
+				max: 1e4
+			},
+			class: { type: "string" }
+		},
+		content: "email"
+	},
+	Subject: {
+		attributes: {},
+		content: "preview"
+	},
+	Preview: {
+		attributes: {},
+		content: "preview"
+	},
+	Container: {
+		attributes: {
+			class: { type: "string" },
+			...BACKGROUND_ATTRIBUTES
+		},
+		content: "block"
+	},
+	Section: {
+		attributes: {
+			class: { type: "string" },
+			...BACKGROUND_ATTRIBUTES
+		},
+		content: "block"
+	},
+	Row: {
+		attributes: { class: { type: "string" } },
+		content: "columns"
+	},
+	Column: {
+		attributes: {
+			class: { type: "string" },
+			width: { type: "string" },
+			valign: {
+				type: "string",
+				values: [
+					"top",
+					"middle",
+					"bottom"
+				]
+			}
+		},
+		content: "block"
+	},
+	Heading: {
+		attributes: {
+			level: {
+				type: "number",
+				min: 1,
+				max: 6
+			},
+			class: { type: "string" }
+		},
+		content: "inline"
+	},
+	Text: {
+		attributes: { class: { type: "string" } },
+		content: "inline"
+	},
+	Button: {
+		attributes: {
+			href: {
+				type: "string",
+				required: true
+			},
+			class: { type: "string" }
+		},
+		content: "inline-nolink"
+	},
+	Image: {
+		attributes: {
+			src: {
+				type: "string",
+				required: true
+			},
+			alt: { type: "string" },
+			width: {
+				type: "number",
+				min: 0,
+				max: 1e4
+			},
+			height: {
+				type: "number",
+				min: 0,
+				max: 1e4
+			},
+			class: { type: "string" }
+		},
+		content: "image"
+	},
+	Source: {
+		attributes: {
+			scheme: {
+				type: "string",
+				required: true,
+				values: ["dark"]
+			},
+			src: {
+				type: "string",
+				required: true
+			}
+		},
+		content: "void"
+	},
+	Divider: {
+		attributes: { class: { type: "string" } },
+		content: "void"
+	},
+	Spacer: {
+		attributes: { height: {
+			type: "number",
+			required: true,
+			min: 1,
+			max: 2e3
+		} },
+		content: "void"
+	},
+	List: {
+		attributes: {
+			type: {
+				type: "string",
+				values: ["unordered", "ordered"]
+			},
+			class: { type: "string" }
+		},
+		content: "list"
+	},
+	ListItem: {
+		attributes: { class: { type: "string" } },
+		content: "inline"
+	},
+	If: {
+		attributes: { test: {
+			type: "string",
+			required: true
+		} },
+		content: "if"
+	},
+	Else: {
+		attributes: {},
+		content: "block"
+	},
+	a: {
+		attributes: {
+			href: {
+				type: "string",
+				required: true
+			},
+			class: { type: "string" }
+		},
+		content: "inline-nolink"
+	},
+	strong: {
+		attributes: {},
+		content: "inline-nolink"
+	},
+	em: {
+		attributes: {},
+		content: "inline-nolink"
+	}
+};
+/**
+* The sms language surface: a raw verbatim text body with `{{vars}}` and
+* send-time conditionals — no layout tags, no classes, no theming.
+*/
+const SMS_TAG_SPECS = {
+	Sms: {
+		attributes: { category: {
+			type: "string",
+			values: SMS_CATEGORIES
+		} },
+		content: "verbatim"
+	},
+	If: {
+		attributes: { test: {
+			type: "string",
+			required: true
+		} },
+		content: "verbatim-if"
+	},
+	Else: {
+		attributes: {},
+		content: "verbatim"
+	}
+};
+/**
+* The whatsapp language surface: Meta's template anatomy IS the closed
+* grammar — Header? Body Footer? Buttons?, verbatim text slots, no classes.
+* Root attributes carry authoring intent (name defaults from the template
+* slug, language from the variant locale — defaulting happens at the API
+* layer; the language just carries the attributes).
+*/
+const WHATSAPP_TAG_SPECS = {
+	WhatsApp: {
+		attributes: {
+			name: { type: "string" },
+			language: { type: "string" },
+			category: {
+				type: "string",
+				required: true,
+				values: WHATSAPP_CATEGORIES
+			}
+		},
+		content: "whatsapp"
+	},
+	Header: {
+		attributes: { type: {
+			type: "string",
+			values: WHATSAPP_HEADER_TYPES
+		} },
+		content: "verbatim"
+	},
+	Body: {
+		attributes: {},
+		content: "verbatim"
+	},
+	Footer: {
+		attributes: {},
+		content: "verbatim"
+	},
+	Buttons: {
+		attributes: {},
+		content: "buttons"
+	},
+	Button: {
+		attributes: {
+			type: {
+				type: "string",
+				required: true,
+				values: WHATSAPP_BUTTON_TYPES
+			},
+			url: { type: "string" },
+			phone: { type: "string" }
+		},
+		content: "verbatim"
+	},
+	If: {
+		attributes: { test: {
+			type: "string",
+			required: true
+		} },
+		content: "verbatim-if"
+	},
+	Else: {
+		attributes: {},
+		content: "verbatim"
+	}
+};
+/** Per-channel tag tables — the root tag picks one for the whole document. */
+const CHANNEL_TAG_SPECS = {
+	email: EMAIL_TAG_SPECS,
+	sms: SMS_TAG_SPECS,
+	whatsapp: WHATSAPP_TAG_SPECS
+};
+/**
+* Editor-only attributes accepted on every email block-level tag on top of the
+* tag's own spec. The compiler ignores both, so neither ever reaches HTML:
+* `label` renames a node in the layout navigator; `hidden="true"` drops it from
+* the compiled artifact while it stays in the source. Email-only — sms/whatsapp
+* compile has no strip pass, so their tags keep their own specs verbatim.
+*/
+const UNIVERSAL_ATTRIBUTES = {
+	label: { type: "string" },
+	hidden: {
+		type: "string",
+		values: ["true"]
+	}
+};
+/** Email tags a user manipulates as layers — the ones the universal attributes attach to. */
+const UNIVERSAL_ATTRIBUTE_TAGS = /* @__PURE__ */ new Set([
+	"Container",
+	"Section",
+	"Row",
+	"Column",
+	"Heading",
+	"Text",
+	"Button",
+	"Image",
+	"Divider",
+	"Spacer",
+	"List",
+	"ListItem",
+	"If",
+	"Else"
+]);
+const universalAttributeSpec = (name) => Object.hasOwn(UNIVERSAL_ATTRIBUTES, name) ? UNIVERSAL_ATTRIBUTES[name] : void 0;
+const BLOCK_CHILDREN = [
+	"Container",
+	"Section",
+	"Row",
+	"Heading",
+	"Text",
+	"Button",
+	"Image",
+	"Divider",
+	"Spacer",
+	"List",
+	"If"
+];
+const EMAIL_ENVELOPE_CHILDREN = ["Subject", "Preview"];
+/** Tags a content model admits as direct children (public alongside the spec tables). */
+const allowedChildren = (model) => {
+	switch (model) {
+		case "email": return [...EMAIL_ENVELOPE_CHILDREN, ...BLOCK_CHILDREN];
+		case "block": return BLOCK_CHILDREN;
+		case "columns": return ["Column"];
+		case "list": return ["ListItem"];
+		case "image": return ["Source"];
+		case "if": return [...BLOCK_CHILDREN, "Else"];
+		case "inline": return [
+			"strong",
+			"em",
+			"a"
+		];
+		case "inline-nolink": return ["strong", "em"];
+		case "whatsapp": return [
+			"Header",
+			"Body",
+			"Footer",
+			"Buttons"
+		];
+		case "buttons": return ["Button"];
+		case "verbatim": return ["If"];
+		case "verbatim-if": return ["If", "Else"];
+		case "preview":
+		case "void": return [];
+	}
+};
+const isInlineModel = (model) => model === "inline" || model === "inline-nolink" || model === "preview";
+const isVerbatimModel = (model) => model === "verbatim" || model === "verbatim-if";
+/** Models whose direct children may be text / interpolations. */
+const admitsText = (model) => isInlineModel(model) || isVerbatimModel(model);
+const listTags = (tags) => tags.map((tag) => `<${tag}>`).join(", ");
+/** Wrapper tag suggested when a loose child isn't allowed directly under its model. */
+const WRAPPER_TAG_BY_MODEL = {
+	list: "ListItem",
+	whatsapp: "Body",
+	buttons: "Button"
+};
+const parseSml = (source) => {
+	const lexer = createLexer(source);
+	let diagnostic;
+	let channel = null;
+	let specs = EMAIL_TAG_SPECS;
+	const fail = (code, message, span) => {
+		diagnostic ??= {
+			code,
+			message,
+			span
+		};
+		return null;
+	};
+	const failToken = (token) => {
+		const error = token.error ?? {
+			code: "unexpected-token",
+			message: `unexpected ${JSON.stringify(lexer.getText(token))}`
+		};
+		return fail(error.code, error.message, {
+			start: token.start,
+			end: token.end
+		});
+	};
+	const parseAttributeValue = (tag, name, spec, nameToken) => {
+		const nameSpan = {
+			start: nameToken.start,
+			end: nameToken.end
+		};
+		if (lexer.scanTagToken().kind !== TokenKind.Equals) return fail("missing-attribute-value", `attribute "${name}" needs a value — write ${name}=${spec.type === "number" ? `{${spec.min ?? 1}}` : "\"...\""}`, nameSpan);
+		const valueToken = lexer.scanTagToken();
+		if (valueToken.kind === TokenKind.Unknown) return failToken(valueToken);
+		if (valueToken.kind === TokenKind.Identifier || valueToken.kind === TokenKind.Number) {
+			const raw = lexer.getText(valueToken);
+			const suggestion = spec.type === "number" ? `${name}={${raw}}` : `${name}="${raw}"`;
+			return fail("unquoted-attribute", `attribute values must be quoted — write ${suggestion}`, {
+				start: valueToken.start,
+				end: valueToken.end
+			});
+		}
+		if (valueToken.kind === TokenKind.OpenBrace) {
+			const numberToken = lexer.scanTagToken();
+			if (numberToken.kind !== TokenKind.Number) return fail("invalid-attribute-value", `expected a number inside braces — write ${name}={16}`, {
+				start: numberToken.start,
+				end: numberToken.end
+			});
+			const closeToken = lexer.scanTagToken();
+			if (closeToken.kind !== TokenKind.CloseBrace) return fail("invalid-attribute-value", `missing } after ${name}={${lexer.getText(numberToken)}`, {
+				start: closeToken.start,
+				end: closeToken.end
+			});
+			if (spec.type !== "number") return fail("invalid-attribute-value", `"${name}" on <${tag}> is a string attribute — write ${name}="..."`, {
+				start: valueToken.start,
+				end: closeToken.end
+			});
+			return {
+				value: {
+					kind: "number",
+					value: Number.parseInt(lexer.getText(numberToken), 10)
+				},
+				valueSpan: {
+					start: numberToken.start,
+					end: numberToken.end
+				}
+			};
+		}
+		if (valueToken.kind !== TokenKind.String) return fail("missing-attribute-value", `attribute "${name}" needs a value — write ${name}=${spec.type === "number" ? "{16}" : "\"...\""}`, {
+			start: valueToken.start,
+			end: valueToken.end
+		});
+		const raw = lexer.getStringValue(valueToken);
+		const valueSpan = {
+			start: valueToken.start + 1,
+			end: valueToken.end - 1
+		};
+		if (spec.type === "number") {
+			if (!/^\d+$/.test(raw)) return fail("invalid-attribute-value", `"${name}" on <${tag}> must be a number — write ${name}={16}`, valueSpan);
+			return {
+				value: {
+					kind: "number",
+					value: Number.parseInt(raw, 10)
+				},
+				valueSpan
+			};
+		}
+		if (spec.values !== void 0 && !spec.values.includes(raw)) return fail("invalid-attribute-value", `"${name}" on <${tag}> must be one of ${spec.values.map((value) => `"${value}"`).join(", ")}`, valueSpan);
+		return {
+			value: {
+				kind: "string",
+				value: raw
+			},
+			valueSpan
+		};
+	};
+	const validateNumberBounds = (tag, name, spec, attribute) => {
+		if (attribute.value.kind !== "number") return true;
+		const { value } = attribute.value;
+		if (spec.min !== void 0 && value < spec.min) {
+			fail("invalid-attribute-value", `"${name}" on <${tag}> must be at least ${spec.min}`, attribute.valueSpan);
+			return false;
+		}
+		if (spec.max !== void 0 && value > spec.max) {
+			fail("invalid-attribute-value", `"${name}" on <${tag}> must be at most ${spec.max}`, attribute.valueSpan);
+			return false;
+		}
+		return true;
+	};
+	/** Called with the `<` already consumed; `lessThanToken` is that token. */
+	const parseElement = (lessThanToken) => {
+		const tagToken = lexer.scanTagToken();
+		if (tagToken.kind !== TokenKind.Identifier) {
+			if (tagToken.kind === TokenKind.Unknown) return failToken(tagToken);
+			return fail("unknown-tag", "expected a tag name after <", {
+				start: tagToken.start,
+				end: tagToken.end
+			});
+		}
+		const tagName = lexer.getText(tagToken);
+		if (channel === null) {
+			if (!isRootTag(tagName)) return fail("invalid-root", `the document root must be ${ROOT_TAGS.map((root) => `<${root}>`).join(", ")} — the root tag declares the channel`, {
+				start: tagToken.start,
+				end: tagToken.end
+			});
+			channel = CHANNEL_BY_ROOT_TAG[tagName];
+			specs = CHANNEL_TAG_SPECS[channel];
+		}
+		const tag = SML_TAGS.find((candidate) => candidate === tagName);
+		const spec = tag === void 0 ? void 0 : specs[tag];
+		if (tag === void 0 || spec === void 0) {
+			const channelTags = Object.keys(specs);
+			const suggestion = channelTags.find((candidate) => candidate.toLowerCase() === tagName.toLowerCase());
+			const hint = suggestion !== void 0 ? `did you mean <${suggestion}>?` : tag !== void 0 ? `<${tag}> is not part of ${channel} documents; ${channel} tags are ${listTags(channelTags)}` : `${channel} tags are ${listTags(channelTags)}`;
+			return fail("unknown-tag", `unknown tag <${tagName}> — ${hint}`, {
+				start: tagToken.start,
+				end: tagToken.end
+			});
+		}
+		const element = {
+			kind: "element",
+			id: "",
+			tag,
+			attributes: [],
+			children: [],
+			span: {
+				start: lessThanToken.start,
+				end: lessThanToken.end
+			}
+		};
+		let selfClosing = false;
+		for (;;) {
+			const token = lexer.scanTagToken();
+			if (token.kind === TokenKind.Identifier) {
+				const name = lexer.getText(token);
+				const universal = channel === "email" && UNIVERSAL_ATTRIBUTE_TAGS.has(tag);
+				const attributeSpec = spec.attributes[name] ?? (universal ? universalAttributeSpec(name) : void 0);
+				if (attributeSpec === void 0) {
+					const known = [...Object.keys(spec.attributes), ...universal ? Object.keys(UNIVERSAL_ATTRIBUTES) : []];
+					const hint = known.length === 0 ? `<${tag}> takes no attributes` : `<${tag}> accepts ${known.map((k) => `"${k}"`).join(", ")}`;
+					return fail("unknown-attribute", `unknown attribute "${name}" on <${tag}> — ${hint}`, {
+						start: token.start,
+						end: token.end
+					});
+				}
+				if (element.attributes.some((attribute) => attribute.name === name)) return fail("duplicate-attribute", `duplicate attribute "${name}" on <${tag}> — remove one`, {
+					start: token.start,
+					end: token.end
+				});
+				const parsed = parseAttributeValue(tag, name, attributeSpec, token);
+				if (parsed === null) return null;
+				const attribute = {
+					name,
+					value: parsed.value,
+					span: {
+						start: token.start,
+						end: parsed.valueSpan.end + 1
+					},
+					valueSpan: parsed.valueSpan
+				};
+				if (!validateNumberBounds(tag, name, attributeSpec, attribute)) return null;
+				element.attributes.push(attribute);
+				continue;
+			}
+			if (token.kind === TokenKind.SlashGreaterThan) {
+				selfClosing = true;
+				element.span.end = token.end;
+				break;
+			}
+			if (token.kind === TokenKind.GreaterThan) {
+				element.span.end = token.end;
+				break;
+			}
+			if (token.kind === TokenKind.EndOfFile) return fail("unclosed-tag", `unclosed <${tag}> — add </${tag}>`, {
+				start: lessThanToken.start,
+				end: tagToken.end
+			});
+			return failToken(token);
+		}
+		for (const [name, attributeSpec] of Object.entries(spec.attributes)) if (attributeSpec.required === true && !element.attributes.some((a) => a.name === name)) {
+			const example = attributeSpec.type === "number" ? `${name}={16}` : tag === "If" ? `test="plan == 'pro'"` : `${name}="..."`;
+			return fail("missing-attribute", `<${tag}> requires the "${name}" attribute — add ${example}`, {
+				start: lessThanToken.start,
+				end: element.span.end
+			});
+		}
+		if (tag === "If") {
+			const testIndex = element.attributes.findIndex((attribute) => attribute.name === "test");
+			const testAttribute = element.attributes[testIndex];
+			if (testAttribute.value.kind === "string") {
+				const parsed = parsePredicate(testAttribute.value.value, testAttribute.valueSpan.start);
+				if (Result.isFailure(parsed)) {
+					const first = parsed.failure[0];
+					return fail(first.code, first.message, first.span);
+				}
+				element.attributes[testIndex] = {
+					...testAttribute,
+					value: {
+						kind: "string",
+						value: printPredicate(parsed.success)
+					}
+				};
+			}
+		}
+		if (spec.content === "void" && !selfClosing) return fail("void-needs-self-close", `<${tag}> is self-closing — write <${tag} ... />`, {
+			start: lessThanToken.start,
+			end: element.span.end
+		});
+		if (selfClosing) {
+			if (spec.content === "whatsapp") return fail("whatsapp-missing-body", "<WhatsApp> requires a <Body> component — add <Body>...</Body>", element.span);
+			return element;
+		}
+		const model = spec.content;
+		for (;;) {
+			const token = lexer.scanTextToken();
+			if (token.kind === TokenKind.EndOfFile) return fail("unclosed-tag", `unclosed <${tag}> — add </${tag}>`, {
+				start: lessThanToken.start,
+				end: tagToken.end
+			});
+			if (token.kind === TokenKind.Unknown) return failToken(token);
+			const looseChildMessage = (label) => {
+				if (model === "image") return `${label} is not allowed directly inside <${tag}> — <${tag}> may contain only ${listTags(allowedChildren(model))}`;
+				const wrapper = WRAPPER_TAG_BY_MODEL[model] ?? "Text";
+				return `${label} is not allowed directly inside <${tag}> — wrap it in <${wrapper}>`;
+			};
+			const afterElse = model === "verbatim-if" && element.children.some((existing) => existing.kind === "element" && existing.tag === "Else");
+			if (token.kind === TokenKind.Text) {
+				const value = lexer.getTextValue(token);
+				if (admitsText(model)) {
+					if (afterElse) return fail("else-not-last", "content after <Else> — move it inside <Else> or above it", {
+						start: token.start,
+						end: token.end
+					});
+					element.children.push({
+						kind: "text",
+						id: "",
+						value,
+						span: {
+							start: token.start,
+							end: token.end
+						}
+					});
+				} else if (value.trim().length > 0) return fail("invalid-child", looseChildMessage("text"), {
+					start: token.start,
+					end: token.end
+				});
+				continue;
+			}
+			if (token.kind === TokenKind.Interpolation) {
+				if (!admitsText(model)) return fail("invalid-child", looseChildMessage(`{{${token.name}}}`), {
+					start: token.start,
+					end: token.end
+				});
+				if (afterElse) return fail("else-not-last", "content after <Else> — move it inside <Else> or above it", {
+					start: token.start,
+					end: token.end
+				});
+				element.children.push({
+					kind: "interpolation",
+					id: "",
+					name: token.name,
+					syntax: token.syntax,
+					span: {
+						start: token.start,
+						end: token.end
+					}
+				});
+				continue;
+			}
+			if (token.kind === TokenKind.LessThanSlash) {
+				const closeName = lexer.scanTagToken();
+				if (closeName.kind !== TokenKind.Identifier || lexer.getText(closeName) !== tag) {
+					const found = closeName.kind === TokenKind.Identifier ? `</${lexer.getText(closeName)}>` : "</>";
+					return fail("mismatched-close-tag", `expected </${tag}> but found ${found} — close <${tag}> first`, {
+						start: token.start,
+						end: closeName.end
+					});
+				}
+				const closeEnd = lexer.scanTagToken();
+				if (closeEnd.kind !== TokenKind.GreaterThan) return fail("mismatched-close-tag", `expected > to finish </${tag}>`, {
+					start: closeEnd.start,
+					end: closeEnd.end
+				});
+				element.span.end = closeEnd.end;
+				break;
+			}
+			const allowed = allowedChildren(model);
+			const child = parseElement(token);
+			if (child === null) return null;
+			if (!allowed.includes(child.tag)) {
+				const message = child.tag === "Else" ? `<Else> is only valid as the last child of <If> — wrap this branch in <If>` : isInlineModel(model) ? child.tag === "a" ? `<a> is not allowed inside <${tag}> — links cannot nest inside links or buttons` : `<${child.tag}> is not allowed inside <${tag}> — only text, {{variables}}${allowed.length > 0 ? `, and ${listTags(allowed)}` : ""} may appear here` : `<${child.tag}> is not allowed inside <${tag}> — <${tag}> may contain only ${listTags(allowed)}`;
+				return fail("invalid-child", message, child.span);
+			}
+			if (model === "email" && EMAIL_ENVELOPE_CHILDREN.includes(child.tag)) {
+				if (element.children.some((existing) => existing.kind === "element" && existing.tag === child.tag)) return fail(`${child.tag.toLowerCase()}-duplicate`, `<Email> allows at most one <${child.tag}> — merge them`, child.span);
+				if (element.children.some((existing) => existing.kind === "element" && !EMAIL_ENVELOPE_CHILDREN.includes(existing.tag))) return fail(`${child.tag.toLowerCase()}-position`, `<${child.tag}> must appear before the body blocks in <Email> — move it above the other blocks`, child.span);
+			}
+			if ((model === "if" || model === "verbatim-if") && element.children.some((existing) => existing.kind === "element" && existing.tag === "Else")) return fail(child.tag === "Else" ? "duplicate-else" : "else-not-last", child.tag === "Else" ? "only one <Else> is allowed inside <If> — merge the branches" : `<Else> must be the last child of <If> — move <${child.tag}> above it`, child.span);
+			if (model === "whatsapp") {
+				const rank = {
+					Header: 0,
+					Body: 1,
+					Footer: 2,
+					Buttons: 3
+				};
+				const childRank = rank[child.tag];
+				for (const existing of element.children) {
+					if (existing.kind !== "element") continue;
+					if (existing.tag === child.tag) return fail("whatsapp-duplicate-component", `<WhatsApp> allows at most one <${child.tag}> — merge them`, child.span);
+					if (rank[existing.tag] > childRank) return fail("whatsapp-component-order", `<${child.tag}> must come before <${existing.tag}> — WhatsApp components are Header?, Body, Footer?, Buttons? in that order`, child.span);
+				}
+			}
+			if (model === "image") {
+				const scheme = child.attributes.find((attribute) => attribute.name === "scheme");
+				if (scheme?.value.kind === "string" && element.children.some((existing) => existing.kind === "element" && existing.tag === "Source" && existing.attributes.some((attribute) => attribute.name === "scheme" && attribute.value.kind === "string" && attribute.value.value === scheme.value.value))) return fail("duplicate-source", `<Image> allows one <Source scheme="${scheme.value.value}">; remove the duplicate`, child.span);
+			}
+			element.children.push(child);
+		}
+		if (model === "whatsapp") {
+			if (!element.children.some((child) => child.kind === "element" && child.tag === "Body")) return fail("whatsapp-missing-body", "<WhatsApp> requires a <Body> component — add <Body>...</Body>", element.span);
+		}
+		if (isInlineModel(model)) normalizeInlineChildren(element);
+		return element;
+	};
+	const skipBlankText = () => {
+		for (;;) {
+			const token = lexer.scanTextToken();
+			if (token.kind === TokenKind.Text && lexer.getTextValue(token).trim().length === 0) continue;
+			return token;
+		}
+	};
+	const first = skipBlankText();
+	if (first.kind === TokenKind.Unknown) failToken(first);
+	else if (first.kind !== TokenKind.LessThan) fail("invalid-root", `the document must start with a channel root element: ${ROOT_TAGS.map((root) => `<${root}>`).join(", ")}`, {
+		start: first.start,
+		end: first.end
+	});
+	let root = null;
+	if (diagnostic === void 0) root = parseElement(first);
+	if (root !== null) {
+		const trailing = skipBlankText();
+		if (trailing.kind !== TokenKind.EndOfFile) {
+			fail("multiple-roots", `content after </${root.tag}> — a document has exactly one root element`, {
+				start: trailing.start,
+				end: trailing.end
+			});
+			root = null;
+		}
+	}
+	if (root === null || diagnostic !== void 0) return Result.fail(new SmlParseError({ diagnostics: [diagnostic ?? {
+		code: "parse-failed",
+		message: "parse failed",
+		span: {
+			start: 0,
+			end: 0
+		}
+	}] }));
+	assignNodeIds(root);
+	return Result.succeed({
+		kind: "document",
+		root
+	});
+};
+/**
+* Canonical inline whitespace: collapse runs to a single space, trim at the
+* element boundary, drop text nodes that end up empty. Makes parse ∘ print a
+* fixpoint — the printer emits exactly these values.
+*/
+const normalizeInlineChildren = (element) => {
+	for (const child of element.children) if (child.kind === "text") child.value = child.value.replace(/\s+/g, " ");
+	const firstChild = element.children[0];
+	if (firstChild?.kind === "text") firstChild.value = firstChild.value.replace(/^ /, "");
+	const lastChild = element.children[element.children.length - 1];
+	if (lastChild?.kind === "text") lastChild.value = lastChild.value.replace(/ $/, "");
+	element.children = element.children.filter((child) => child.kind !== "text" || child.value.length > 0);
+};
+/** Stable ids in document order — identical source ⇒ identical ids. */
+const assignNodeIds = (root) => {
+	let next = 0;
+	const visit = (node) => {
+		node.id = `n${next}`;
+		next++;
+		if (node.kind === "element") for (const child of node.children) visit(child);
+	};
+	visit(root);
+};
+//#endregion
+export { CHANNEL_TAG_SPECS, EMAIL_TAG_SPECS, SMS_TAG_SPECS, UNIVERSAL_ATTRIBUTES, UNIVERSAL_ATTRIBUTE_TAGS, WHATSAPP_TAG_SPECS, allowedChildren, parseSml };
+
+//# sourceMappingURL=parser.js.map