@samva/markup 0.8.0 → 0.9.0

package/dist/parser.js

@@ -1,859 +0,0 @@
-import { SmlParseError } from "./diagnostics.js";
-import { a as printPredicate, i as parsePredicate, o as SML_PARSER_LIMITS } from "./predicate-BI6uRRM-.js";
-import { CHANNEL_BY_ROOT_TAG, ROOT_TAGS, SML_TAGS, isRootTag } from "./ast.js";
-import { TokenKind, createLexer } from "./lexer.js";
-import { Result } from "better-result";
-//#region src/parser.ts
-const parserLimitFailure = (code, message, sourceLength) => Result.err(new SmlParseError({ diagnostics: [{
-	code,
-	message,
-	span: {
-		start: 0,
-		end: sourceLength
-	}
-}] }));
-const SMS_CATEGORIES = [
-	"transactional",
-	"promotional",
-	"service_implicit"
-];
-const WHATSAPP_CATEGORIES = [
-	"marketing",
-	"utility",
-	"authentication"
-];
-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) => {
-	if (source.length > SML_PARSER_LIMITS.maxCharacters) return parserLimitFailure("source-character-limit", `SML source exceeds the ${SML_PARSER_LIMITS.maxCharacters} character limit (${source.length} characters)`, source.length);
-	const sourceBytes = new TextEncoder().encode(source).byteLength;
-	if (sourceBytes > SML_PARSER_LIMITS.maxUtf8Bytes) return parserLimitFailure("source-byte-limit", `SML source exceeds the ${SML_PARSER_LIMITS.maxUtf8Bytes} byte UTF-8 limit (${sourceBytes} bytes)`, source.length);
-	const lexer = createLexer(source);
-	let diagnostic;
-	let nodeCount = 0;
-	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 countNode = (span) => {
-		const observed = nodeCount + 1;
-		if (observed > SML_PARSER_LIMITS.maxNodes) {
-			fail("node-limit", `SML document exceeds the ${SML_PARSER_LIMITS.maxNodes} node limit (${observed} nodes)`, span);
-			return false;
-		}
-		nodeCount = observed;
-		return true;
-	};
-	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, depth) => {
-		if (depth > SML_PARSER_LIMITS.maxDepth) return fail("depth-limit", `SML nesting exceeds the maximum depth of ${SML_PARSER_LIMITS.maxDepth} (observed ${depth})`, {
-			start: lessThanToken.start,
-			end: lessThanToken.end
-		});
-		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
-			});
-		}
-		if (!countNode({
-			start: lessThanToken.start,
-			end: tagToken.end
-		})) return null;
-		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.isError(parsed)) {
-					const first = parsed.error[0];
-					return fail(first.code, first.message, first.span);
-				}
-				element.attributes[testIndex] = {
-					...testAttribute,
-					value: {
-						kind: "string",
-						value: printPredicate(parsed.value)
-					}
-				};
-			}
-		}
-		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
-					});
-					if (!countNode({
-						start: token.start,
-						end: token.end
-					})) return null;
-					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
-				});
-				if (!countNode({
-					start: token.start,
-					end: token.end
-				})) return null;
-				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, depth + 1);
-			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, 1);
-	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.err(new SmlParseError({ diagnostics: [diagnostic ?? {
-		code: "parse-failed",
-		message: "parse failed",
-		span: {
-			start: 0,
-			end: 0
-		}
-	}] }));
-	assignNodeIds(root);
-	return Result.ok({
-		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 pending = [root];
-	while (pending.length > 0) {
-		const node = pending.pop();
-		node.id = `n${next}`;
-		next++;
-		if (node.kind !== "element") continue;
-		for (let index = node.children.length - 1; index >= 0; index--) pending.push(node.children[index]);
-	}
-};
-//#endregion
-export { CHANNEL_TAG_SPECS, EMAIL_TAG_SPECS, SML_PARSER_LIMITS, SMS_TAG_SPECS, UNIVERSAL_ATTRIBUTES, UNIVERSAL_ATTRIBUTE_TAGS, WHATSAPP_TAG_SPECS, allowedChildren, parseSml };
-
-//# sourceMappingURL=parser.js.map