@the_dissidents/libemmm 0.0.8 → 0.0.10

package/dist/index.cjs

@@ -0,0 +1,3311 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let minimal_jsx_runtime_jsx_runtime = require("minimal-jsx-runtime/jsx-runtime");
+minimal_jsx_runtime_jsx_runtime = __toESM(minimal_jsx_runtime_jsx_runtime);
+
+//#region src/util.ts
+var NameManager = class NameManager {
+	array = [];
+	data = /* @__PURE__ */ new Map();
+	constructor(from) {
+		if (from === void 0) return;
+		if (from instanceof NameManager) {
+			this.array = [...from.array];
+			this.data = new Map(from.data);
+		} else {
+			const array = [...from];
+			assert((from instanceof Set ? from : new Set(array)).size == array.length);
+			this.array = array.map((x) => ({
+				k: x.name,
+				v: x
+			}));
+			this.array.sort((a, b) => b.k.length - a.k.length);
+			this.data = new Map(array.map((x) => [x.name, x]));
+		}
+	}
+	toArray() {
+		return this.array.map(({ v }) => v);
+	}
+	toSet() {
+		return new Set(this.toArray());
+	}
+	get(name) {
+		return this.data.get(name);
+	}
+	has(name) {
+		return this.data.has(name);
+	}
+	remove(name) {
+		assert(this.data.get(name) !== void 0);
+		this.data.delete(name);
+		this.array.splice(this.array.findIndex((x) => x.k == name), 1);
+	}
+	add(...elems) {
+		for (const elem of elems) {
+			assert(!this.has(elem.name));
+			this.data.set(elem.name, elem);
+			const len = elem.name.length;
+			let i = 0;
+			while (i < this.array.length && this.array[i].k.length > len) i++;
+			this.array.splice(i, 0, {
+				k: elem.name,
+				v: elem
+			});
+		}
+	}
+	find(predicate) {
+		const result = this.array.find((x) => predicate(x.v));
+		return result ? result.v : void 0;
+	}
+};
+function assert(x) {
+	if (!!!x) {
+		let error = /* @__PURE__ */ new Error("assertion failed");
+		console.log(error.stack);
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/debug.ts
+let DebugLevel = /* @__PURE__ */ function(DebugLevel$1) {
+	DebugLevel$1[DebugLevel$1["Trace"] = 0] = "Trace";
+	DebugLevel$1[DebugLevel$1["Info"] = 1] = "Info";
+	DebugLevel$1[DebugLevel$1["Warning"] = 2] = "Warning";
+	DebugLevel$1[DebugLevel$1["Error"] = 3] = "Error";
+	DebugLevel$1[DebugLevel$1["None"] = 4] = "None";
+	return DebugLevel$1;
+}({});
+const debug = {
+	level: DebugLevel.Info,
+	trace(arg0, ...args) {
+		if (this.level > DebugLevel.Trace) return;
+		if (typeof arg0 == "function") arg0 = arg0();
+		console.info("TRACE", arg0, ...args);
+	},
+	info(arg0, ...args) {
+		if (this.level > DebugLevel.Info) return;
+		if (typeof arg0 == "function") arg0 = arg0();
+		console.info(" INFO", arg0, ...args);
+	},
+	warning(arg0, ...args) {
+		if (this.level > DebugLevel.Warning) return;
+		if (typeof arg0 == "function") arg0 = arg0();
+		console.warn(" WARN", arg0, ...args);
+	},
+	error(arg0, ...args) {
+		if (this.level > DebugLevel.Error) return;
+		if (typeof arg0 == "function") arg0 = arg0();
+		console.error("ERROR", arg0, ...args);
+	},
+	never(_) {
+		assert(false);
+	}
+};
+
+//#endregion
+//#region src/source.ts
+var StringSource = class {
+	name;
+	nLines;
+	lineMap;
+	constructor(d, src) {
+		this.src = src;
+		this.name = d.name;
+		this.lineMap = [0];
+		[...src].forEach((x, i) => {
+			if (x == "\n") this.lineMap.push(i + 1);
+		});
+		this.nLines = this.lineMap.length;
+		this.lineMap.push(Infinity);
+	}
+	getRowCol(pos) {
+		let line = -1, linepos = 0;
+		for (let i = 1; i < this.lineMap.length; i++) if (this.lineMap[i] > pos) {
+			line = i - 1;
+			linepos = this.lineMap[i - 1];
+			break;
+		}
+		return [line, pos - linepos];
+	}
+	getRowStart(n) {
+		assert(n >= 0);
+		if (n >= this.lineMap.length) return Infinity;
+		return this.lineMap[n];
+	}
+	getRow(n) {
+		const start = this.getRowStart(n);
+		const end = this.getRowStart(n + 1);
+		if (start === Infinity) return void 0;
+		return this.src.substring(start, end - 1);
+	}
+};
+
+//#endregion
+//#region src/interface.ts
+let MessageSeverity = /* @__PURE__ */ function(MessageSeverity$1) {
+	MessageSeverity$1[MessageSeverity$1["Info"] = 0] = "Info";
+	MessageSeverity$1[MessageSeverity$1["Warning"] = 1] = "Warning";
+	MessageSeverity$1[MessageSeverity$1["Error"] = 2] = "Error";
+	return MessageSeverity$1;
+}({});
+let NodeType = /* @__PURE__ */ function(NodeType$1) {
+	NodeType$1[NodeType$1["Root"] = 0] = "Root";
+	NodeType$1[NodeType$1["Group"] = 1] = "Group";
+	NodeType$1[NodeType$1["Paragraph"] = 2] = "Paragraph";
+	NodeType$1[NodeType$1["Preformatted"] = 3] = "Preformatted";
+	NodeType$1[NodeType$1["Text"] = 4] = "Text";
+	NodeType$1[NodeType$1["Escaped"] = 5] = "Escaped";
+	NodeType$1[NodeType$1["SystemModifier"] = 6] = "SystemModifier";
+	NodeType$1[NodeType$1["InlineModifier"] = 7] = "InlineModifier";
+	NodeType$1[NodeType$1["BlockModifier"] = 8] = "BlockModifier";
+	NodeType$1[NodeType$1["Interpolation"] = 9] = "Interpolation";
+	return NodeType$1;
+}({});
+
+//#endregion
+//#region src/modifier.ts
+let ModifierSlotType = /* @__PURE__ */ function(ModifierSlotType$1) {
+	ModifierSlotType$1[ModifierSlotType$1["Normal"] = 0] = "Normal";
+	/** Content is preformatted: no escaping, no inner tags */
+	ModifierSlotType$1[ModifierSlotType$1["Preformatted"] = 1] = "Preformatted";
+	/** No content slot */
+	ModifierSlotType$1[ModifierSlotType$1["None"] = 2] = "None";
+	return ModifierSlotType$1;
+}({});
+var ModifierBase = class {
+	constructor(name, slotType = ModifierSlotType.Normal, args) {
+		this.name = name;
+		this.slotType = slotType;
+		if (args) Object.assign(this, args);
+	}
+	metadata = {};
+	/**
+	* Common values: heading, emphasis, keyword, highlight, commentary, comment, link, quote, pre
+	*/
+	roleHint;
+	/**
+	* If true, any modifier encountered inside it will *not* be expanded *during parse-content*,
+	* *unless* that modifier is `alwaysTryExpand`. In the vast majority of cases, you shouldn't
+	* be using this.
+	*/
+	delayContentExpansion = false;
+	/**
+	* If true, such a modifier will always be expanded whenever it is encountered, *even if*
+	* it is contained in a modifier with `delayContentExpansion`. In the vast majority of cases,
+	* you shouldn't be using this.
+	*/
+	alwaysTryExpand = false;
+	/** Called before the modifier's content is parsed.
+	* @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+	*/
+	beforeParseContent;
+	/** Called after the modifier's content is parsed.
+	* @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+	*/
+	afterParseContent;
+	/** Called before reparsing of the expansion.
+	* @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.*/
+	beforeProcessExpansion;
+	/** Called before reparsing of the expansion.
+	* @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.*/
+	afterProcessExpansion;
+	/**
+	* @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+	*/
+	prepareExpand;
+	/**
+	* @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+	*/
+	expand;
+};
+var BlockModifierDefinition = class extends ModifierBase {};
+var InlineModifierDefinition = class extends ModifierBase {};
+var SystemModifierDefinition = class extends ModifierBase {};
+var ArgumentInterpolatorDefinition = class {
+	constructor(name, postfix, args) {
+		this.name = name;
+		this.postfix = postfix;
+		if (args) Object.assign(this, args);
+	}
+	alwaysTryExpand = false;
+	expand;
+};
+
+//#endregion
+//#region src/scanner.ts
+var SimpleScanner = class {
+	source;
+	#pos = 0;
+	#inspectors;
+	constructor(src, sourceDesc = { name: "<input>" }, inspectors = []) {
+		this.src = src;
+		this.source = new StringSource(sourceDesc, src);
+		this.#inspectors = inspectors.toSorted((a, b) => a.position - b.position);
+	}
+	position() {
+		return this.#pos;
+	}
+	isEOF() {
+		return this.#pos >= this.src.length;
+	}
+	inspectors() {
+		let result = [];
+		while (this.#inspectors.length > 0 && this.#inspectors[0].position <= this.#pos) result.push(this.#inspectors.shift());
+		return result;
+	}
+	peek(str) {
+		assert(str !== "");
+		if (this.#pos + str.length > this.src.length) return false;
+		return this.src.slice(this.#pos, this.#pos + str.length) == str;
+	}
+	acceptChar() {
+		if (this.isEOF()) throw new RangeError("EOF");
+		let char = this.src[this.#pos];
+		this.#pos++;
+		return char;
+	}
+	accept(str) {
+		if (!this.peek(str)) return false;
+		this.#pos += str.length;
+		return true;
+	}
+	acceptWhitespaceChar() {
+		if (this.isEOF()) return null;
+		let char = this.src[this.#pos];
+		if (!" 	".includes(char)) return null;
+		this.#pos++;
+		return char;
+	}
+};
+
+//#endregion
+//#region src/debug-print.ts
+const debugPrint = {
+	blockModifier: (x) => `[.${x.name}] (${ModifierSlotType[x.slotType]})`,
+	inlineModifier: (x) => `[/${x.name}] (${ModifierSlotType[x.slotType]})`,
+	inlineShorthand: (x) => x.name + x.parts.map((x$1, i) => ` .. <arg${i}> .. ${x$1}`).join("") + (x.mod.slotType == ModifierSlotType.None ? "" : ` .. <slot> .. ${x.postfix ?? "<no postfix>"}`),
+	blockShorthand: (x) => x.name + x.parts.map((x$1, i) => ` .. <arg${i}> .. ${x$1}`).join("") + (x.mod.slotType == ModifierSlotType.None ? "" : ` .. <slot> .. ${x.postfix ?? "<no postfix>"}`),
+	argument: (arg) => arg.content.map(debugPrintArgEntity).join(""),
+	node: (...nodes) => nodes.map((x) => debugPrintNode(x)).join("\n"),
+	message: debugPrintMsg,
+	range: debugPrintRange,
+	document: debugDumpDocument
+};
+function debugPrintArgEntity(node) {
+	switch (node.type) {
+		case NodeType.Text: return node.content;
+		case NodeType.Escaped: return `<Escaped:${node.content}>`;
+		case NodeType.Interpolation: return `<Interp:${node.definition.name}-${node.definition.postfix}:${debugPrint.argument(node.argument)}${node.expansion ? `=${node.expansion}` : ""}>`;
+		default: return debug.never(node);
+	}
+}
+function debugPrintNode(node, prefix = "") {
+	function debugPrintNodes(content, prefix$1 = "") {
+		let dumps = content.map((x) => debugPrintNode(x, prefix$1 + "  ")).filter((x) => x.length > 0);
+		if (dumps.length == 0) return "";
+		return dumps.map((x) => `${prefix$1}  ${x}`).join("\n");
+	}
+	let result = `<${NodeType[node.type]}@${node.location.start}`;
+	switch (node.type) {
+		case NodeType.Group:
+		case NodeType.Paragraph:
+			const content = debugPrintNodes(node.content, prefix);
+			if (content.length > 0) result += `>\n${content}\n${prefix}</${NodeType[node.type]}@${node.location.end}>`;
+			else result += `-${node.location.end} />`;
+			break;
+		case NodeType.Escaped:
+			result += `>\n${prefix}  ${node.content}\n${prefix}</${NodeType[node.type]}@${node.location.end}>`;
+			break;
+		case NodeType.Preformatted:
+			result += `>\n${prefix}  ${node.content.text}\n${prefix}</${NodeType[node.type]}@${node.location.end}>`;
+			break;
+		case NodeType.InlineModifier:
+		case NodeType.BlockModifier:
+		case NodeType.SystemModifier:
+			const posargs = node.arguments.positional.map((x, i) => `\n${prefix}    (${i})@${x.location.start}-${x.location.end}=${debugPrint.argument(x)}`).join("");
+			const namedargs = [...node.arguments.named].map(([name, x], i) => `\n${prefix}    <${name}>@${x.location.start}-${x.location.end}=${debugPrint.argument(x)}`).join("");
+			if (node.content.length > 0) result += ` id=${node.mod.name}${posargs}${namedargs}>\n` + debugPrintNodes(node.content, prefix) + `\n${prefix}</${NodeType[node.type]}@${node.location.end}>`;
+			else result += `-${node.location.end} id=${node.mod.name}${posargs}${namedargs} />`;
+			if (node.expansion) {
+				const content$1 = debugPrintNodes(node.expansion, prefix);
+				if (content$1.length > 0) result += `\n${prefix}<expansion>\n${content$1}\n${prefix}</expansion>`;
+				else if (node.type != NodeType.SystemModifier) result += `\n${prefix}<expansion />`;
+			}
+			break;
+		case NodeType.Text: return node.content;
+		default: return debug.never(node);
+	}
+	return result;
+}
+function debugPrintRange(loc, context = 1) {
+	const isSingleCharacter = loc.start == loc.end;
+	let [sr, sc] = loc.source.getRowCol(loc.start);
+	let [er, ec] = loc.source.getRowCol(loc.actualEnd ?? loc.end);
+	const rowWidth = Math.max((sr + 1).toString().length, (er + 1).toString().length);
+	const startLine = Math.max(0, sr - context);
+	const endLine = Math.min(loc.source.nLines - 1, er + context);
+	let lines = [];
+	for (let i = startLine; i <= endLine; i++) {
+		const line = loc.source.getRow(i);
+		lines.push((i + 1).toString().padStart(rowWidth) + " | " + line);
+		if (i >= sr && i <= er) {
+			const startPos = i == sr ? sc : 0;
+			const endPos = i == er ? ec : line.length;
+			lines.push(" ".repeat(rowWidth) + " | " + " ".repeat(startPos) + (isSingleCharacter ? "^" : "~".repeat(endPos - startPos + 1)));
+		}
+	}
+	return lines.join("\n");
+}
+function debugPrintMsg(m) {
+	const poss = (loc$1) => {
+		const [r1, c1] = loc$1.source.getRowCol(loc$1.start);
+		if (loc$1.start == loc$1.end) return `l${r1 + 1}c${c1 + 1}`;
+		const [r2, c2] = loc$1.source.getRowCol(loc$1.end);
+		return `l${r1 + 1}c${c1 + 1}-l${r2 + 1}c${c2 + 1}`;
+	};
+	let loc = m.location;
+	let result = `at ${poss(loc)}: ${MessageSeverity[m.severity]}[${m.code}]: ${m.info}`;
+	while (loc = loc.original) {
+		let d = loc.source !== m.location.source ? `(in ${loc.source.name}) ` : "";
+		result += `\n---> original at: ${d}${poss(loc)}`;
+	}
+	return result;
+}
+function debugDumpDocument(doc) {
+	let root = debugPrint.node(...doc.root.content);
+	let msgs = doc.messages.map((x) => debugPrintRange(x.location) + "\n" + debugPrintMsg(x)).join("\n");
+	if (msgs.length > 0) msgs += "\n";
+	return `Document: ${doc.root.source.name}\n${msgs}${root}`;
+}
+
+//#endregion
+//#region src/messages.ts
+var messages_exports = /* @__PURE__ */ __export({
+	ArgumentCountMismatchMessage: () => ArgumentCountMismatchMessage,
+	CannotExpandArgumentMessage: () => CannotExpandArgumentMessage,
+	CannotUseModuleInSelfMessage: () => CannotUseModuleInSelfMessage,
+	ContentExpectedMessage: () => ContentExpectedMessage,
+	DuplicateNamedArgumentMessage: () => DuplicateNamedArgumentMessage,
+	EitherNormalOrPreMessage: () => EitherNormalOrPreMessage,
+	EntityNotAllowedMessage: () => EntityNotAllowedMessage,
+	ExpectedMessage: () => ExpectedMessage,
+	InternalErrorMessage: () => InternalErrorMessage,
+	InvalidArgumentMessage: () => InvalidArgumentMessage,
+	MultipleBlocksNotPermittedMessage: () => MultipleBlocksNotPermittedMessage,
+	NameAlreadyDefinedMessage: () => NameAlreadyDefinedMessage,
+	NewBlockShouldBeOnNewlineMessage: () => NewBlockShouldBeOnNewlineMessage,
+	NoNestedModuleMessage: () => NoNestedModuleMessage,
+	OnlySimpleParagraphsPermittedMessage: () => OnlySimpleParagraphsPermittedMessage,
+	OverwriteDefinitionsMessage: () => OverwriteDefinitionsMessage,
+	OverwriteSpecialVariableMessage: () => OverwriteSpecialVariableMessage,
+	ReachedRecursionLimitMessage: () => ReachedRecursionLimitMessage,
+	ShouldBeOnNewlineMessage: () => ShouldBeOnNewlineMessage,
+	SlotUsedOutsideDefinitionMessage: () => SlotUsedOutsideDefinitionMessage,
+	UnclosedInlineModifierMessage: () => UnclosedInlineModifierMessage,
+	UndefinedVariableMessage: () => UndefinedVariableMessage,
+	UnknownModifierMessage: () => UnknownModifierMessage,
+	UnnecessaryNewlineMessage: () => UnnecessaryNewlineMessage
+});
+var AddThingMessage = class {
+	constructor(code, severity, location, info) {
+		this.code = code;
+		this.severity = severity;
+		this.location = location;
+		this.info = info;
+	}
+};
+var RemoveThingMessage = class {
+	constructor(code, severity, location, info) {
+		this.code = code;
+		this.severity = severity;
+		this.location = location;
+		this.info = info;
+	}
+};
+var ExpectedMessage = class {
+	constructor(location, what) {
+		this.location = location;
+		this.what = what;
+		assert(location.end == location.start);
+	}
+	code = 1;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `expected '${this.what}'`;
+	}
+};
+var UnknownModifierMessage = class {
+	constructor(location, what) {
+		this.location = location;
+		this.what = what;
+	}
+	code = 2;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `unknown modifier '${this.what}'`;
+	}
+};
+var UnclosedInlineModifierMessage = class {
+	constructor(location, what) {
+		this.location = location;
+		this.what = what;
+		assert(location.end == location.start);
+	}
+	code = 3;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `unclosed inline modifier ${this.what}'`;
+	}
+};
+var ArgumentCountMismatchMessage = class {
+	constructor(location, min, max) {
+		this.location = location;
+		if (min !== void 0) if (max == min) this.msg = `: ${min} expected`;
+		else if (max !== void 0) this.msg = `: ${min} to ${max} expected`;
+		else this.msg = `: at least ${min} expected`;
+		else if (max !== void 0) this.msg = `: at most ${max} expected`;
+	}
+	msg = "";
+	code = 4;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `argument count mismatch` + this.msg;
+	}
+};
+var CannotExpandArgumentMessage = class {
+	constructor(location, what) {
+		this.location = location;
+		this.what = what;
+	}
+	code = 5;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `failed to expand argument` + (this.what === void 0 ? "" : `: ${this.what}`);
+	}
+};
+var InvalidArgumentMessage = class {
+	constructor(location, what) {
+		this.location = location;
+		this.what = what;
+	}
+	code = 6;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `invalid argument` + (this.what === void 0 ? "" : `: ${this.what}`);
+	}
+};
+var EntityNotAllowedMessage = class {
+	constructor(location, what) {
+		this.location = location;
+		this.what = what;
+	}
+	code = 7;
+	severity = MessageSeverity.Error;
+	get info() {
+		return "This entity is not allowed here" + (this.what ? `: ${this.what}` : "");
+	}
+};
+var ReachedRecursionLimitMessage = class {
+	constructor(location, limit, what) {
+		this.location = location;
+		this.limit = limit;
+		this.what = what;
+	}
+	code = 8;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `Reached recursion limit ${this.limit} when expanding ${this.what}`;
+	}
+};
+var SlotUsedOutsideDefinitionMessage = class {
+	constructor(location) {
+		this.location = location;
+	}
+	code = 9;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `slot used outside a definition`;
+	}
+};
+var NoNestedModuleMessage = class {
+	constructor(location) {
+		this.location = location;
+	}
+	code = 10;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `nested module definitions not allowed`;
+	}
+};
+var CannotUseModuleInSelfMessage = class {
+	constructor(location) {
+		this.location = location;
+	}
+	code = 11;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `cannot use the same module inside its definition`;
+	}
+};
+var EitherNormalOrPreMessage = class {
+	constructor(location) {
+		this.location = location;
+	}
+	code = 12;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `a definition cannot be at once normal and preformatted`;
+	}
+};
+var MultipleBlocksNotPermittedMessage = class {
+	constructor(location) {
+		this.location = location;
+	}
+	code = 13;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `multiple blocks are not permitted here`;
+	}
+};
+var OnlySimpleParagraphsPermittedMessage = class {
+	constructor(location) {
+		this.location = location;
+	}
+	code = 14;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `only simple paragraphs are permitted here`;
+	}
+};
+var ContentExpectedMessage = class {
+	constructor(location) {
+		this.location = location;
+	}
+	code = 15;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `content expected`;
+	}
+};
+var InternalErrorMessage = class {
+	constructor(location, error) {
+		this.location = location;
+		this.error = error;
+	}
+	code = 16;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `an internal error occurred when parsing: ${this.error}`;
+	}
+};
+var DuplicateNamedArgumentMessage = class {
+	constructor(location, name) {
+		this.location = location;
+		this.name = name;
+	}
+	code = 17;
+	severity = MessageSeverity.Error;
+	get info() {
+		return `an argument has already been defined with the same name "${this.name}"`;
+	}
+};
+var UnnecessaryNewlineMessage = class extends RemoveThingMessage {
+	constructor(location) {
+		super(1, MessageSeverity.Warning, location, "more than one newlines have the same effect as one");
+	}
+};
+var NewBlockShouldBeOnNewlineMessage = class extends AddThingMessage {
+	constructor(location) {
+		super(2, MessageSeverity.Warning, location, "a new block should begin in a new line to avoid confusion");
+	}
+};
+var ShouldBeOnNewlineMessage = class extends AddThingMessage {
+	constructor(location) {
+		super(3, MessageSeverity.Warning, location, "the following should begin in a new line to avoid confusion");
+	}
+};
+var NameAlreadyDefinedMessage = class {
+	constructor(location, what) {
+		this.location = location;
+		this.what = what;
+	}
+	code = 4;
+	severity = MessageSeverity.Warning;
+	get info() {
+		return `name is already defined, will overwrite: ${this.what}`;
+	}
+};
+var UndefinedVariableMessage = class {
+	constructor(location, what) {
+		this.location = location;
+		this.what = what;
+	}
+	code = 5;
+	severity = MessageSeverity.Warning;
+	get info() {
+		return `variable is undefined, will expand to empty string: ${this.what}`;
+	}
+};
+var OverwriteDefinitionsMessage = class {
+	constructor(location, what) {
+		this.location = location;
+		this.what = what;
+	}
+	code = 6;
+	severity = MessageSeverity.Warning;
+	get info() {
+		return `using this module will overwrite: ${this.what}`;
+	}
+};
+var OverwriteSpecialVariableMessage = class {
+	constructor(location, varname, previous) {
+		this.location = location;
+		this.varname = varname;
+		this.previous = previous;
+	}
+	code = 6;
+	severity = MessageSeverity.Warning;
+	get info() {
+		return `${this.varname} is already defined (as "${this.previous}"), will be overwritten`;
+	}
+};
+
+//#endregion
+//#region src/node-util.ts
+const cloneArgument = (arg, options) => ({
+	location: cloneLocation(arg.location, options),
+	content: arg.content.map((ent) => {
+		switch (ent.type) {
+			case NodeType.Text:
+			case NodeType.Escaped: return cloneNode(ent, options);
+			case NodeType.Interpolation: return {
+				type: ent.type,
+				location: cloneLocation(arg.location, options),
+				definition: ent.definition,
+				argument: cloneArgument(ent.argument, options),
+				expansion: ent.expansion
+			};
+			default: return debug.never(ent);
+		}
+	})
+});
+function cloneLocation(pos, options) {
+	let base = options.newLocation ?? pos;
+	return {
+		start: base.start,
+		end: base.end,
+		actualEnd: base.actualEnd,
+		original: options.newLocation ? pos : pos.original,
+		source: base.source
+	};
+}
+function cloneNode(node, options = {}) {
+	switch (node.type) {
+		case NodeType.BlockModifier:
+		case NodeType.InlineModifier:
+		case NodeType.SystemModifier: return {
+			location: cloneLocation(node.location, options),
+			type: node.type,
+			mod: node.mod,
+			state: options.withState ? node.state : void 0,
+			head: cloneLocation(node.head, options),
+			arguments: {
+				positional: node.arguments.positional.map((x) => cloneArgument(x, options)),
+				named: new Map([...node.arguments.named].map(([x, y]) => [x, cloneArgument(y, options)]))
+			},
+			content: node.content.map((x) => cloneNode(x, options)),
+			expansion: node.expansion ? cloneNodes(node.expansion, options) : void 0
+		};
+		case NodeType.Root: return {
+			type: node.type,
+			source: node.source,
+			content: node.content.map((x) => cloneNode(x, options))
+		};
+		case NodeType.Group: return {
+			type: node.type,
+			location: cloneLocation(node.location, options),
+			content: node.content.map((x) => cloneNode(x, options))
+		};
+		case NodeType.Paragraph: return {
+			type: node.type,
+			location: cloneLocation(node.location, options),
+			content: node.content.map((x) => cloneNode(x, options))
+		};
+		case NodeType.Preformatted: return {
+			type: node.type,
+			location: cloneLocation(node.location, options),
+			content: { ...node.content }
+		};
+		case NodeType.Text:
+		case NodeType.Escaped: return {
+			type: node.type,
+			location: cloneLocation(node.location, options),
+			content: node.content
+		};
+		default: return debug.never(node);
+	}
+}
+function cloneNodes(nodes, options = {}) {
+	return nodes.map((x) => cloneNode(x, options));
+}
+/** Warning: modifies the original nodes */
+function stripNode(...nodes) {
+	return nodes.flatMap((node) => {
+		switch (node.type) {
+			case NodeType.Preformatted:
+			case NodeType.Text:
+			case NodeType.Escaped: return [node];
+			case NodeType.BlockModifier:
+			case NodeType.InlineModifier: if (node.expansion !== void 0) return node.expansion.flatMap((x) => stripNode(x));
+			case NodeType.Root:
+			case NodeType.Group:
+			case NodeType.Paragraph:
+				node.content = node.content.flatMap((x) => stripNode(x));
+				return [node];
+			case NodeType.SystemModifier: return [];
+			default: return debug.never(node);
+		}
+	});
+}
+
+//#endregion
+//#region src/parser-config.ts
+var ParseContext = class {
+	data = {};
+	usedModules = /* @__PURE__ */ new Set();
+	constructor(config$1, variables = /* @__PURE__ */ new Map()) {
+		this.config = config$1;
+		this.variables = variables;
+		config$1.initializers.forEach((x) => x(this));
+	}
+	init(key, obj) {
+		assert(!(key in this.data));
+		this.data[key] = obj;
+	}
+	set(key, obj) {
+		assert(key in this.data);
+		this.data[key] = obj;
+	}
+	get(key) {
+		assert(key in this.data);
+		return this.data[key];
+	}
+	parse(scanner) {
+		return new Parser(scanner, this).parse();
+	}
+};
+var Document = class Document {
+	constructor(root, context, messages) {
+		this.root = root;
+		this.context = context;
+		this.messages = messages;
+	}
+	toStripped() {
+		return new Document(stripNode(cloneNode(this.root, { withState: true }))[0], this.context, this.messages);
+	}
+	/**
+	* Performs a depth-first walk of the node tree.
+	*/
+	walk(callback) {
+		let nodes = this.root.content;
+		let node;
+		while (node = nodes.shift()) {
+			const result = callback(node);
+			if (result == "break") break;
+			if (result == "skip") continue;
+			if ("arguments" in node) {
+				nodes.push(...node.arguments.positional.flatMap((x) => x.content));
+				nodes.push(...[...node.arguments.named].flatMap(([_name, x]) => x.content));
+			}
+			if ("content" in node && Array.isArray(node.content)) nodes.push(...node.content);
+		}
+	}
+	/**
+	* Gets all nodes that covers the given position, from outermost to innermost (essentially a path).
+	*/
+	resolvePosition(pos) {
+		const result = [];
+		this.walk((node) => {
+			if (node.location.start <= pos && (node.location.actualEnd ?? node.location.end) >= pos) {
+				result.push(node);
+				return "continue";
+			}
+			return "skip";
+		});
+		return result;
+	}
+};
+var Configuration = class Configuration {
+	initializers = [];
+	modules = /* @__PURE__ */ new Map();
+	blockModifiers = new NameManager();
+	inlineModifiers = new NameManager();
+	systemModifiers = new NameManager();
+	argumentInterpolators = new NameManager();
+	blockShorthands = new NameManager();
+	inlineShorthands = new NameManager();
+	kernel = {
+		collapseWhitespaces: false,
+		reparseDepthLimit: 10
+	};
+	static from(from) {
+		let config$1 = new Configuration();
+		config$1.initializers = [...from.initializers];
+		config$1.kernel = structuredClone(from.kernel);
+		config$1.blockModifiers = new NameManager(from.blockModifiers);
+		config$1.inlineModifiers = new NameManager(from.inlineModifiers);
+		config$1.systemModifiers = new NameManager(from.systemModifiers);
+		config$1.argumentInterpolators = new NameManager(from.argumentInterpolators);
+		config$1.blockShorthands = new NameManager(from.blockShorthands);
+		config$1.inlineShorthands = new NameManager(from.inlineShorthands);
+		return config$1;
+	}
+};
+
+//#endregion
+//#region src/parser.ts
+const ESCAPE_CHAR = "\\";
+const GROUP_BEGIN = "<<<";
+const GROUP_END = ">>>";
+const MODIFIER_BLOCK_OPEN = "[.";
+const MODIFIER_INLINE_OPEN = "[/";
+const MODIFIER_SYSTEM_OPEN = "[-";
+const MODIFIER_CLOSE_SIGN = "]";
+const MODIFIER_END_SIGN = ";";
+const MODIFIER_INLINE_END_TAG = "[;]";
+const MODIFIER_ARGUMENT_SEPARATOR = "|";
+const UnknownModifier = {
+	[NodeType.BlockModifier]: new BlockModifierDefinition("UNKNOWN", ModifierSlotType.Normal),
+	[NodeType.InlineModifier]: new InlineModifierDefinition("UNKNOWN", ModifierSlotType.Normal),
+	[NodeType.SystemModifier]: new SystemModifierDefinition("UNKNOWN", ModifierSlotType.Normal)
+};
+var EmitEnvironment = class {
+	root;
+	messages = [];
+	blockStack = [];
+	inlineStack = [];
+	constructor(scanner) {
+		this.scanner = scanner;
+		this.root = {
+			type: NodeType.Root,
+			source: scanner.source,
+			content: []
+		};
+	}
+	message(...m) {
+		for (let msg of m) {
+			this.messages.push(msg);
+			debug.trace("issued msg", msg.code, msg.info);
+		}
+	}
+	addBlockNode(n) {
+		(this.blockStack.at(-1) ?? this.root).content.push(n);
+		return n;
+	}
+	addInlineNode(n) {
+		assert(this.inlineStack.length > 0);
+		this.inlineStack.at(-1).content.push(n);
+		return n;
+	}
+	addString(str) {
+		assert(this.inlineStack.length > 0);
+		const content = this.inlineStack.at(-1).content;
+		const last = content.at(-1);
+		if (last?.type == NodeType.Text) {
+			last.content += str;
+			last.location.end = this.scanner.position();
+		} else content.push({
+			type: NodeType.Text,
+			location: {
+				source: this.scanner.source,
+				start: this.scanner.position() - str.length,
+				end: this.scanner.position()
+			},
+			content: str
+		});
+	}
+	startBlock(block) {
+		this.addBlockNode(block);
+		this.blockStack.push(block);
+	}
+	endBlock() {
+		assert(this.blockStack.length > 0);
+		const node = this.blockStack.pop();
+		node.location.end = this.scanner.position();
+	}
+	startInline(n) {
+		if (n.type == NodeType.Paragraph) this.addBlockNode(n);
+		else this.addInlineNode(n);
+		this.inlineStack.push(n);
+	}
+	endInline() {
+		assert(this.inlineStack.length > 0);
+		const node = this.inlineStack.pop();
+		node.location.end = this.scanner.position();
+	}
+};
+var Parser = class {
+	emit;
+	delayDepth = 0;
+	constructor(scanner, cxt) {
+		this.scanner = scanner;
+		this.cxt = cxt;
+		this.emit = new EmitEnvironment(scanner);
+	}
+	#loc(to) {
+		return {
+			source: this.scanner.source,
+			start: this.scanner.position(),
+			end: to ?? this.scanner.position()
+		};
+	}
+	#locFrom(from, to) {
+		return {
+			source: this.scanner.source,
+			start: from,
+			end: to ?? this.scanner.position()
+		};
+	}
+	/* istanbul ignore next -- @preserve */
+	#defs(type) {
+		switch (type) {
+			case NodeType.SystemModifier: return this.cxt.config.systemModifiers;
+			case NodeType.InlineModifier: return this.cxt.config.inlineModifiers;
+			case NodeType.BlockModifier: return this.cxt.config.blockModifiers;
+			default: return debug.never(type);
+		}
+	}
+	#reparse(nodes, depth) {
+		if (depth > this.cxt.config.kernel.reparseDepthLimit) return false;
+		let ok = true;
+		for (const node of nodes) switch (node.type) {
+			case NodeType.Preformatted:
+			case NodeType.Text:
+			case NodeType.Escaped: continue;
+			case NodeType.Group:
+			case NodeType.Paragraph:
+				ok = this.#reparse(node.content, depth + 1) && ok;
+				continue;
+			case NodeType.BlockModifier:
+			case NodeType.InlineModifier:
+			case NodeType.SystemModifier:
+				ok = this.#expand(node, depth + 1) && ok;
+				continue;
+			default: debug.never(node);
+		}
+		return ok;
+	}
+	#expandArgument(arg) {
+		if (arg.expansion !== void 0) return arg.expansion;
+		let result = "";
+		const immediate = this.delayDepth == 0;
+		for (const e of arg.content) switch (e.type) {
+			case NodeType.Text:
+			case NodeType.Escaped:
+				result += e.content;
+				break;
+			case NodeType.Interpolation:
+				if (e.expansion === void 0) {
+					const inner = this.#expandArgument(e.argument);
+					if (inner === void 0 || e.definition.expand === void 0 || !immediate && !e.definition.alwaysTryExpand) return void 0;
+					e.expansion = e.definition.expand(inner, this.cxt, immediate);
+					if (e.expansion === void 0) return void 0;
+				}
+				result += e.expansion;
+				break;
+			default: debug.never(e);
+		}
+		arg.expansion = result;
+		return result;
+	}
+	#expandArguments(node) {
+		for (const arg of node.arguments.positional) this.#expandArgument(arg);
+		for (const [_name, arg] of node.arguments.named) this.#expandArgument(arg);
+	}
+	#tryAndMessage(node, fn, ...p) {
+		if (!fn) return;
+		try {
+			this.emit.message(...fn.call(node.mod, ...p));
+		} catch (e) {
+			this.emit.message(new InternalErrorMessage(node.location, e));
+		}
+	}
+	#try(node, fn, ...p) {
+		if (!fn) return;
+		try {
+			return fn.call(node.mod, ...p);
+		} catch (e) {
+			this.emit.message(new InternalErrorMessage(node.location, e));
+			return;
+		}
+	}
+	#expand(node, depth = 0) {
+		if (node.expansion !== void 0) {
+			debug.trace("already expanded, skipping:", node.mod.name);
+			return true;
+		}
+		if (depth > 0) this.#expandArguments(node);
+		if (this.delayDepth > 0 && !node.mod.alwaysTryExpand) {
+			debug.trace("delaying expansion of", node.mod.name);
+			return true;
+		}
+		const immediate = this.delayDepth == 0;
+		if (depth > 0) {
+			this.#tryAndMessage(node, node.mod.beforeParseContent, node, this.cxt, immediate);
+			if (node.content.length > 0) {
+				if (node.mod.delayContentExpansion) this.delayDepth++;
+				this.#reparse(node.content, depth);
+				if (node.mod.delayContentExpansion) this.delayDepth--;
+			}
+			this.#tryAndMessage(node, node.mod.afterParseContent, node, this.cxt, immediate);
+		}
+		this.#tryAndMessage(node, node.mod.prepareExpand, node, this.cxt, immediate);
+		if (node.mod.expand) {
+			node.expansion = this.#try(node, node.mod.expand, node, this.cxt, immediate);
+			if (!node.expansion) return true;
+			debug.trace(`${this.delayDepth > 0 ? "early " : ""}expanding:`, node.mod.name);
+			if (node.expansion.length > 0) debug.trace(() => "-->\n" + debugPrint.node(...node.expansion));
+		}
+		this.#tryAndMessage(node, node.mod.beforeProcessExpansion, node, this.cxt, immediate);
+		const expansion = node.expansion;
+		if (!expansion || expansion.length == 0) return true;
+		debug.trace("reparsing expansion of:", node.mod.name);
+		let ok = this.#reparse(expansion, depth);
+		debug.trace("done reparsing expansion of:", node.mod.name);
+		this.#tryAndMessage(node, node.mod.afterProcessExpansion, node, this.cxt, immediate);
+		if (!ok && depth == 0) {
+			const limit = this.cxt.config.kernel.reparseDepthLimit;
+			this.emit.message(new ReachedRecursionLimitMessage(node.location, limit, node.mod.name));
+		}
+		return ok;
+	}
+	parse() {
+		this.DOCUMENT();
+		return new Document(this.emit.root, this.cxt, this.emit.messages);
+	}
+	WHITESPACES() {
+		while (this.scanner.acceptWhitespaceChar() !== null);
+	}
+	WHITESPACES_OR_NEWLINES() {
+		while (this.scanner.acceptWhitespaceChar() !== null || this.scanner.accept("\n"));
+	}
+	SHOULD_BE_A_NEWLINE() {
+		this.WHITESPACES();
+		if (!this.scanner.accept("\n")) this.emit.message(new ShouldBeOnNewlineMessage(this.#loc()));
+	}
+	WARN_IF_MORE_NEWLINES_THAN(n) {
+		let nlines = 0;
+		const start = this.scanner.position();
+		while (true) {
+			if (this.scanner.accept("\n")) {
+				nlines++;
+				continue;
+			}
+			if (this.scanner.acceptWhitespaceChar() == null) break;
+		}
+		const end = this.scanner.position();
+		if (nlines > n) this.emit.message(new UnnecessaryNewlineMessage(this.#locFrom(start, end)));
+	}
+	DOCUMENT() {
+		this.WHITESPACES_OR_NEWLINES();
+		while (!this.scanner.isEOF()) {
+			this.BLOCK_ENTITY();
+			this.WHITESPACES_OR_NEWLINES();
+		}
+		this.scanner.inspectors().forEach((x) => x.callback(this.cxt, this.scanner.position()));
+	}
+	BLOCK_ENTITY() {
+		assert(!this.scanner.isEOF());
+		this.scanner.inspectors().forEach((x) => x.callback(this.cxt, this.scanner.position()));
+		if (this.scanner.peek(MODIFIER_BLOCK_OPEN)) {
+			this.MODIFIER(NodeType.BlockModifier);
+			return;
+		}
+		if (this.scanner.peek(MODIFIER_SYSTEM_OPEN)) {
+			this.MODIFIER(NodeType.SystemModifier);
+			return;
+		}
+		const short = this.cxt.config.blockShorthands.find((x) => this.scanner.accept(x.name));
+		if (short) return this.SHORTHAND(NodeType.BlockModifier, short);
+		this.MAYBE_GROUPED_PARAGRAPH();
+		this.scanner.inspectors().forEach((x) => x.callback(this.cxt, this.scanner.position()));
+	}
+	MODIFIER(type) {
+		const posStart = this.scanner.position();
+		assert(this.scanner.accept({
+			[NodeType.BlockModifier]: MODIFIER_BLOCK_OPEN,
+			[NodeType.SystemModifier]: MODIFIER_SYSTEM_OPEN,
+			[NodeType.InlineModifier]: MODIFIER_INLINE_OPEN
+		}[type]));
+		const result = this.#defs(type).find((x) => this.scanner.accept(x.name));
+		const mod = result ?? UnknownModifier[type];
+		if (result === void 0) {
+			let name = "";
+			while (!this.scanner.isEOF() && !this.scanner.acceptWhitespaceChar() && !this.scanner.peek(MODIFIER_CLOSE_SIGN) && !this.scanner.peek(MODIFIER_END_SIGN)) {
+				if (this.scanner.accept(ESCAPE_CHAR)) {
+					if (this.scanner.isEOF()) break;
+				}
+				name += this.scanner.acceptChar();
+			}
+			this.emit.message(new UnknownModifierMessage(this.#locFrom(posStart), name));
+		}
+		const args = this.ARGUMENTS();
+		debug.trace(`PARSE ${NodeType[type]}:`, mod.name);
+		const endsign = this.scanner.accept(MODIFIER_END_SIGN);
+		const flagMarker = mod.slotType == ModifierSlotType.None;
+		if (!this.scanner.accept(MODIFIER_CLOSE_SIGN)) this.emit.message(new ExpectedMessage(this.#loc(), MODIFIER_CLOSE_SIGN));
+		const headEnd = this.scanner.position();
+		const node = {
+			type,
+			mod,
+			head: this.#locFrom(posStart, headEnd),
+			location: this.#locFrom(posStart, headEnd),
+			arguments: args,
+			content: [],
+			expansion: void 0
+		};
+		const isMarker = flagMarker || endsign;
+		return this.MODIFIER_BODY(type, node, MODIFIER_INLINE_END_TAG, isMarker);
+	}
+	PRE_PARAGRAPH() {
+		assert(!this.scanner.isEOF());
+		const posStart = this.scanner.position();
+		const grouped = this.scanner.accept(GROUP_BEGIN);
+		if (grouped) this.SHOULD_BE_A_NEWLINE();
+		const posContentStart = this.scanner.position();
+		let posContentEnd = this.scanner.position();
+		let paragraphEnd = void 0;
+		let string = "";
+		while (!this.scanner.isEOF()) {
+			if (this.scanner.accept("\n")) {
+				let white = "\n";
+				let char;
+				while ((char = this.scanner.acceptWhitespaceChar()) !== null) white += char;
+				if (grouped && this.scanner.accept(GROUP_END)) {
+					paragraphEnd = this.scanner.position();
+					if (!this.scanner.isEOF()) {
+						this.SHOULD_BE_A_NEWLINE();
+						this.WARN_IF_MORE_NEWLINES_THAN(1);
+					}
+					break;
+				}
+				if (!grouped && this.scanner.accept("\n")) {
+					paragraphEnd = this.scanner.position() - 1;
+					if (!this.scanner.isEOF()) this.WARN_IF_MORE_NEWLINES_THAN(0);
+					break;
+				}
+				if (this.scanner.isEOF()) {
+					if (grouped) this.emit.message(new ExpectedMessage(this.#loc(), GROUP_END));
+					break;
+				}
+				string += white;
+			} else string += this.scanner.acceptChar();
+			posContentEnd = this.scanner.position();
+		}
+		const node = {
+			type: NodeType.Preformatted,
+			location: this.#locFrom(posStart, paragraphEnd ?? posContentEnd),
+			content: {
+				start: posContentStart,
+				end: posContentEnd,
+				text: string
+			}
+		};
+		this.emit.addBlockNode(node);
+	}
+	MAYBE_GROUPED_PARAGRAPH() {
+		assert(!this.scanner.isEOF());
+		const posStart = this.scanner.position();
+		if (this.scanner.accept(GROUP_BEGIN)) {
+			this.SHOULD_BE_A_NEWLINE();
+			this.WARN_IF_MORE_NEWLINES_THAN(1);
+			const group = {
+				location: this.#locFrom(posStart),
+				type: NodeType.Group,
+				content: []
+			};
+			this.emit.startBlock(group);
+			while (!this.scanner.isEOF()) {
+				if (this.scanner.accept(GROUP_END)) {
+					this.emit.endBlock();
+					if (!this.scanner.isEOF()) {
+						this.SHOULD_BE_A_NEWLINE();
+						this.WARN_IF_MORE_NEWLINES_THAN(1);
+					}
+					return;
+				}
+				this.BLOCK_ENTITY();
+				this.WARN_IF_MORE_NEWLINES_THAN(1);
+			}
+			this.emit.message(new ExpectedMessage(this.#loc(), GROUP_END));
+		} else this.PARAGRAPH();
+	}
+	#trimNode(node) {
+		if (node.content.length == 0) return;
+		let first = node.content[0];
+		let last = node.content.at(-1);
+		if (first.type == NodeType.Text) first.content = first.content.trimStart();
+		if (last.type == NodeType.Text) last.content = last.content.trimEnd();
+	}
+	PARAGRAPH() {
+		assert(!this.scanner.isEOF());
+		const node = {
+			type: NodeType.Paragraph,
+			location: this.#loc(),
+			content: []
+		};
+		this.emit.startInline(node);
+		while (!this.scanner.isEOF() && this.INLINE_ENTITY());
+		this.emit.endInline();
+		const last = node.content.at(-1);
+		node.location.actualEnd = last?.location.actualEnd ?? last?.location.end;
+		this.#trimNode(node);
+	}
+	SHORTHAND(type, d) {
+		const posStart = this.scanner.position();
+		let args = [];
+		for (const part of d.parts) {
+			let [arg, ok] = this.ARGUMENT_CONTENT(part, ["\n\n"]);
+			if (!ok) {
+				this.emit.message(new ExpectedMessage(this.#loc(), part));
+				return false;
+			}
+			args.push(arg);
+		}
+		const headEnd = this.scanner.position();
+		const node = {
+			type,
+			mod: d.mod,
+			head: this.#locFrom(posStart - d.name.length, headEnd),
+			location: this.#locFrom(posStart - d.name.length, headEnd),
+			arguments: {
+				positional: args,
+				named: /* @__PURE__ */ new Map(),
+				location: this.#locFrom(posStart, headEnd)
+			},
+			content: [],
+			expansion: void 0
+		};
+		const isMarker = node.mod.slotType == ModifierSlotType.None;
+		return this.MODIFIER_BODY(type, node, d.postfix, isMarker);
+	}
+	MODIFIER_BODY(type, node, postfix, isMarker) {
+		this.#expandArguments(node);
+		const immediate = this.delayDepth == 0;
+		if (node.mod.beforeParseContent) this.emit.message(...node.mod.beforeParseContent(node, this.cxt, immediate));
+		if (node.mod.delayContentExpansion) this.delayDepth++;
+		let ok = true;
+		if (isMarker) {
+			if (!this.scanner.isEOF() && type == NodeType.BlockModifier) {
+				this.SHOULD_BE_A_NEWLINE();
+				this.WARN_IF_MORE_NEWLINES_THAN(1);
+			}
+			if (type === NodeType.InlineModifier) this.emit.addInlineNode(node);
+			else this.emit.addBlockNode(node);
+		} else if (type == NodeType.InlineModifier) {
+			node = node;
+			this.emit.startInline(node);
+			const pre = node.mod.slotType == ModifierSlotType.Preformatted;
+			const entity = pre ? this.PREFORMATTED_INLINE_ENTITY.bind(this) : this.INLINE_ENTITY.bind(this);
+			while (true) {
+				if (postfix && this.scanner.accept(postfix)) break;
+				if (this.scanner.isEOF() || !(ok = entity())) {
+					if (postfix) this.emit.message(new ExpectedMessage(this.#loc(), postfix));
+					break;
+				}
+			}
+			this.emit.endInline();
+			if (!pre && node.content.length > 0) this.#trimNode(node);
+		} else {
+			this.emit.startBlock(node);
+			this.WARN_IF_MORE_NEWLINES_THAN(1);
+			if (!this.scanner.isEOF()) if (node.mod.slotType == ModifierSlotType.Preformatted) this.PRE_PARAGRAPH();
+			else this.BLOCK_ENTITY();
+			this.emit.endBlock();
+		}
+		const last = node.content.at(-1);
+		node.location.actualEnd = last?.location.actualEnd ?? last?.location.end;
+		if (node.mod.delayContentExpansion) this.delayDepth--;
+		if (node.mod.afterParseContent) this.emit.message(...node.mod.afterParseContent(node, this.cxt, immediate));
+		this.#expand(node);
+		return ok;
+	}
+	INLINE_ENTITY() {
+		assert(!this.scanner.isEOF());
+		if (this.scanner.peek(MODIFIER_INLINE_OPEN)) return this.MODIFIER(NodeType.InlineModifier);
+		if (this.scanner.peek(MODIFIER_SYSTEM_OPEN)) return false;
+		if (this.scanner.peek(MODIFIER_BLOCK_OPEN)) {
+			this.SHOULD_BE_A_NEWLINE();
+			return false;
+		}
+		const short = this.cxt.config.inlineShorthands.find((x) => this.scanner.accept(x.name));
+		if (short) return this.SHORTHAND(NodeType.InlineModifier, short);
+		if (this.scanner.accept(ESCAPE_CHAR)) {
+			if (this.scanner.isEOF()) {
+				this.emit.addString(ESCAPE_CHAR);
+				return true;
+			}
+			const start = this.scanner.position();
+			const node = {
+				type: NodeType.Escaped,
+				content: this.scanner.acceptChar(),
+				location: this.#locFrom(start - 1)
+			};
+			this.emit.addInlineNode(node);
+			return true;
+		}
+		if (this.cxt.config.kernel.collapseWhitespaces && this.scanner.acceptWhitespaceChar() !== null) {
+			this.WHITESPACES();
+			this.emit.addString(" ");
+			return true;
+		}
+		return this.PREFORMATTED_INLINE_ENTITY();
+	}
+	PREFORMATTED_INLINE_ENTITY() {
+		assert(!this.scanner.isEOF());
+		if (this.scanner.accept("\n")) {
+			this.WHITESPACES();
+			if (this.scanner.peek(MODIFIER_BLOCK_OPEN) || this.scanner.peek(MODIFIER_SYSTEM_OPEN) || this.cxt.config.blockShorthands.find((x) => this.scanner.peek(x.name)) || this.scanner.peek(GROUP_END) || this.scanner.isEOF()) return false;
+			if (this.scanner.accept("\n")) {
+				this.WARN_IF_MORE_NEWLINES_THAN(0);
+				return false;
+			}
+			this.emit.addString("\n");
+			return true;
+		}
+		this.emit.addString(this.scanner.acceptChar());
+		return true;
+	}
+	ARGUMENT_CONTENT(end = void 0, close = [MODIFIER_END_SIGN, MODIFIER_CLOSE_SIGN]) {
+		let ok = true;
+		const content = [];
+		const posStart = this.scanner.position();
+		let posEnd = this.scanner.position();
+		const emitString = (s) => {
+			const last = content.at(-1);
+			if (last?.type == NodeType.Text) {
+				last.content += s;
+				last.location.end += s.length;
+			} else {
+				const end$1 = this.scanner.position();
+				content.push({
+					type: NodeType.Text,
+					location: this.#locFrom(end$1 - s.length),
+					content: s
+				});
+			}
+		};
+		while (true) {
+			if (end && this.scanner.accept(end)) break;
+			if (end === void 0 && this.scanner.accept(MODIFIER_ARGUMENT_SEPARATOR)) break;
+			if (close.find((x) => this.scanner.peek(x)) || this.scanner.isEOF()) {
+				ok = false;
+				break;
+			}
+			if (this.scanner.accept(ESCAPE_CHAR)) {
+				posEnd = this.scanner.position();
+				if (this.scanner.isEOF()) {
+					emitString(ESCAPE_CHAR);
+					ok = false;
+					break;
+				}
+				content.push({
+					type: NodeType.Escaped,
+					content: this.scanner.acceptChar(),
+					location: this.#locFrom(posEnd - 1)
+				});
+				continue;
+			}
+			const beforeInterp = this.scanner.position();
+			const result = this.cxt.config.argumentInterpolators.find((x) => this.scanner.accept(x.name));
+			if (result !== void 0) {
+				const [inner, ok2] = this.ARGUMENT_CONTENT(result.postfix);
+				posEnd = this.scanner.position();
+				content.push({
+					type: NodeType.Interpolation,
+					definition: result,
+					argument: inner,
+					location: this.#locFrom(beforeInterp)
+				});
+				if (!ok2) {
+					this.emit.message(new ExpectedMessage(this.#loc(), result.postfix));
+					ok = false;
+					break;
+				}
+			} else {
+				emitString(this.scanner.acceptChar());
+				posEnd = this.scanner.position();
+			}
+		}
+		return [{
+			location: this.#locFrom(posStart, posEnd),
+			content
+		}, ok];
+	}
+	POSSIBLY_NAMED_ARGUMENT(args) {
+		let ok = true;
+		const close = [MODIFIER_END_SIGN, MODIFIER_CLOSE_SIGN];
+		let content = [];
+		const posStart = this.scanner.position();
+		let contentStart = posStart;
+		let posEnd = this.scanner.position();
+		let name = {
+			type: "possible",
+			value: ""
+		};
+		const emitString = (s) => {
+			const last = content.at(-1);
+			if (last?.type == NodeType.Text) {
+				last.content += s;
+				last.location.end += s.length;
+			} else {
+				const end = this.scanner.position();
+				content.push({
+					type: NodeType.Text,
+					location: this.#locFrom(end - s.length),
+					content: s
+				});
+			}
+		};
+		while (true) {
+			if (this.scanner.accept(MODIFIER_ARGUMENT_SEPARATOR)) break;
+			if (close.find((x) => this.scanner.peek(x)) || this.scanner.isEOF()) {
+				ok = false;
+				break;
+			}
+			if (this.scanner.accept(ESCAPE_CHAR)) {
+				if (name?.type == "possible") name = void 0;
+				posEnd = this.scanner.position();
+				if (this.scanner.isEOF()) {
+					emitString(ESCAPE_CHAR);
+					ok = false;
+					break;
+				}
+				content.push({
+					type: NodeType.Escaped,
+					content: this.scanner.acceptChar(),
+					location: this.#locFrom(posEnd - 1)
+				});
+				continue;
+			}
+			const beforeInterp = this.scanner.position();
+			const result = this.cxt.config.argumentInterpolators.find((x) => this.scanner.accept(x.name));
+			if (result !== void 0) {
+				if (name?.type == "possible") name = void 0;
+				const [inner, ok2] = this.ARGUMENT_CONTENT(result.postfix);
+				posEnd = this.scanner.position();
+				content.push({
+					type: NodeType.Interpolation,
+					definition: result,
+					argument: inner,
+					location: this.#locFrom(beforeInterp)
+				});
+				if (!ok2) {
+					this.emit.message(new ExpectedMessage(this.#loc(), result.postfix));
+					ok = false;
+					break;
+				}
+			} else {
+				const char = this.scanner.acceptChar();
+				posEnd = this.scanner.position();
+				if (name?.type == "possible") {
+					if (char == "=") {
+						name.type = "ok";
+						content = [];
+						contentStart = posEnd;
+						continue;
+					}
+					if (/[:/\[\s]/.test(char)) name = void 0;
+					else name.value += char;
+				}
+				emitString(char);
+			}
+		}
+		const arg = {
+			location: this.#locFrom(contentStart, posEnd),
+			content
+		};
+		let msgs;
+		if (name?.type == "ok") {
+			if (args.named.has(name.value)) msgs = [new DuplicateNamedArgumentMessage(this.#locFrom(posStart, contentStart - 1), name.value)];
+			args.named.set(name.value, arg);
+		} else args.positional.push(arg);
+		return [msgs, ok];
+	}
+	ARGUMENTS() {
+		if (!this.scanner.accept(MODIFIER_ARGUMENT_SEPARATOR)) this.WHITESPACES_OR_NEWLINES();
+		const args = {
+			positional: [],
+			named: /* @__PURE__ */ new Map(),
+			location: this.#loc()
+		};
+		if (this.scanner.peek(MODIFIER_CLOSE_SIGN) || this.scanner.peek(MODIFIER_END_SIGN)) return args;
+		while (true) {
+			const [msgs, ok] = this.POSSIBLY_NAMED_ARGUMENT(args);
+			if (msgs) this.emit.message(...msgs);
+			if (!ok) break;
+		}
+		args.location.end = this.scanner.position();
+		return args;
+	}
+};
+
+//#endregion
+//#region src/renderer.ts
+var RenderContext = class {
+	renderEntity(node) {
+		switch (node.type) {
+			case NodeType.Group: return node.content.flatMap((x) => this.renderEntity(x));
+			case NodeType.Paragraph:
+				if (!this.config.paragraphRenderer) return [];
+				return this.config.paragraphRenderer(node, this);
+			case NodeType.Preformatted:
+			case NodeType.Text:
+			case NodeType.Escaped:
+				if (!this.config.textRenderer) return [];
+				return this.config.textRenderer(node, this);
+			case NodeType.InlineModifier:
+				let ir = this.config.inlineRenderers.get(node.mod);
+				if (ir) return ir(node, this);
+				if (!this.config.undefinedInlineRenderer) return [];
+				return this.config.undefinedInlineRenderer(node, this);
+			case NodeType.BlockModifier:
+				let br = this.config.blockRenderers.get(node.mod);
+				if (br) return br(node, this);
+				if (!this.config.undefinedBlockRenderer) return [];
+				return this.config.undefinedBlockRenderer(node, this);
+			case NodeType.SystemModifier: return [];
+			default: return debug.never(node);
+		}
+	}
+	constructor(config$1, parsedDocument, state) {
+		this.config = config$1;
+		this.parsedDocument = parsedDocument;
+		this.state = state;
+	}
+};
+var RenderConfiguration = class RenderConfiguration {
+	paragraphRenderer;
+	textRenderer;
+	undefinedBlockRenderer;
+	undefinedInlineRenderer;
+	blockRenderers = /* @__PURE__ */ new Map();
+	inlineRenderers = /* @__PURE__ */ new Map();
+	constructor(options, postprocessor) {
+		this.options = options;
+		this.postprocessor = postprocessor;
+	}
+	render(doc, state) {
+		let cxt = new RenderContext(this, doc, state);
+		let results = doc.toStripped().root.content.flatMap((x) => cxt.renderEntity(x));
+		return this.postprocessor(results, cxt);
+	}
+	addBlockRenderer(...rs) {
+		rs.forEach(([x, y]) => this.blockRenderers.set(x, y));
+	}
+	addInlineRenderer(...rs) {
+		rs.forEach(([x, y]) => this.inlineRenderers.set(x, y));
+	}
+	static from(from) {
+		let config$1 = new RenderConfiguration(from.options, from.postprocessor);
+		config$1.paragraphRenderer = from.paragraphRenderer;
+		config$1.textRenderer = from.textRenderer;
+		config$1.undefinedBlockRenderer = from.undefinedBlockRenderer;
+		config$1.undefinedInlineRenderer = from.undefinedInlineRenderer;
+		config$1.inlineRenderers = new Map(from.inlineRenderers);
+		config$1.blockRenderers = new Map(from.blockRenderers);
+		return config$1;
+	}
+};
+
+//#endregion
+//#region src/modifier-helper.ts
+var modifier_helper_exports = /* @__PURE__ */ __export({
+	bindArgs: () => bindArgs,
+	createParagraphWrapper: () => createParagraphWrapper,
+	createPlaintextWrapper: () => createPlaintextWrapper,
+	onlyPermitPlaintextParagraph: () => onlyPermitPlaintextParagraph,
+	onlyPermitSimpleParagraphs: () => onlyPermitSimpleParagraphs,
+	onlyPermitSingleBlock: () => onlyPermitSingleBlock
+});
+function bindArgs(node, p, opts) {
+	const badpos = node.arguments.positional.filter((x) => x.expansion === void 0);
+	const badnamed = [...node.arguments.named].filter((x) => x[1].expansion === void 0);
+	const bad = [...badpos, ...badnamed.map((x) => x[1])];
+	if (bad.length > 0) return {
+		msgs: bad.map((x) => new CannotExpandArgumentMessage(x.location)),
+		args: void 0,
+		nodes: void 0,
+		rest: void 0,
+		restNodes: void 0
+	};
+	const maxLength = opts?.rest ? Infinity : p.length + (opts?.optional?.length ?? 0);
+	if (node.arguments.positional.length < p.length || node.arguments.positional.length > maxLength) return {
+		msgs: [new ArgumentCountMismatchMessage({
+			source: node.location.source,
+			start: node.head.start,
+			end: node.head.end
+		}, p.length, maxLength)],
+		args: void 0,
+		nodes: void 0,
+		rest: void 0,
+		restNodes: void 0
+	};
+	const args = {};
+	const nodes = {};
+	const msgs = [];
+	p.forEach((name, i) => {
+		nodes[name] = node.arguments.positional[i];
+		args[name] = nodes[name].expansion;
+		if (opts?.trim) args[name] = args[name].trim();
+	});
+	if (opts?.optional) opts.optional.forEach((name, i) => {
+		nodes[name] = node.arguments.positional[p.length + i];
+		args[name] = nodes[name]?.expansion;
+		if (opts?.trim && args[name]) args[name] = args[name].trim();
+	});
+	if (opts?.named) Object.entries(opts.named).forEach(([name, def]) => {
+		nodes[name] = node.arguments.named.get(name);
+		args[name] = node.arguments.named.get(name)?.expansion ?? def;
+		if (opts?.trim && args[name]) args[name] = args[name].trim();
+	});
+	if (!opts?.restNamed) node.arguments.named.forEach((v, k) => {
+		if (!opts?.named || !Object.hasOwn(opts.named, k)) msgs.push(new InvalidArgumentMessage(v.location, `no such named argument: "${k}"`));
+	});
+	if (msgs.length) return {
+		msgs,
+		args: void 0,
+		nodes: void 0,
+		rest: void 0,
+		restNodes: void 0
+	};
+	const restNodes = node.arguments.positional.slice(p.length + (opts?.optional?.length ?? 0));
+	return {
+		msgs: null,
+		args,
+		nodes,
+		rest: restNodes.map((x) => opts?.trim ? x.expansion.trim() : x.expansion),
+		restNodes
+	};
+}
+/**
+* Helper function to ensure that a modifier only accepts plaintext paragraphs as content.
+* @returns The content as a string if OK, otherwise an array of error messages.
+*/
+function onlyPermitPlaintextParagraph(node) {
+	function checkInline(ents) {
+		let result = "";
+		for (const ent of ents) switch (ent.type) {
+			case NodeType.Text:
+			case NodeType.Escaped:
+				result += ent.content;
+				break;
+			case NodeType.SystemModifier: break;
+			case NodeType.InlineModifier:
+				if (!ent.expansion) return [new EntityNotAllowedMessage(ent.location, "it does not expand to plain text")];
+				let checkInner = checkInline(ent.expansion);
+				if (Array.isArray(checkInner)) return checkInner;
+				result += checkInner;
+				break;
+			default: return debug.never(ent);
+		}
+		return result;
+	}
+	function checkContent(ents) {
+		if (ents.length == 0) return "";
+		else if (ents.length > 1) {
+			let last = ents.at(-1).location;
+			return [new MultipleBlocksNotPermittedMessage({
+				source: last.source,
+				start: ents[1].location.start,
+				end: last.actualEnd ?? last.end
+			})];
+		}
+		return check(ents[0]);
+	}
+	function check(ent) {
+		if (ent.type == NodeType.BlockModifier) {
+			if (!ent.expansion) return [new EntityNotAllowedMessage(ent.location, "it does not expand to plain text")];
+			return checkContent(ent.expansion);
+		} else if (ent.type == NodeType.Preformatted) return ent.content.text;
+		else if (ent.type !== NodeType.Paragraph) return [new OnlySimpleParagraphsPermittedMessage(ent.location)];
+		return checkInline(ent.content);
+	}
+	return checkContent(node.content);
+}
+/**
+* Helper function to ensure that a modifier does not accept any block modifiers inside its content.
+* @returns `null` if OK, otherwise an array of error messages.
+*/
+function onlyPermitSimpleParagraphs(node) {
+	function check(nodes) {
+		for (const ent of nodes) if (ent.type == NodeType.BlockModifier && ent.expansion !== void 0) {
+			const cs = check(ent.expansion);
+			if (cs) return cs;
+		} else if (ent.type == NodeType.Group) {
+			const cs = check(ent.content);
+			if (cs) return cs;
+		} else if (ent.type !== NodeType.Paragraph) return [new OnlySimpleParagraphsPermittedMessage(ent.location)];
+		return null;
+	}
+	return check(node.expansion ?? node.content);
+}
+/**
+* Helper function to ensure that a modifier only accepts one block as its content.
+* @returns `null` if OK, otherwise an array of error messages.
+*/
+function onlyPermitSingleBlock(node, opt) {
+	function check(nodes) {
+		if (nodes.length > 1) {
+			const last = nodes.at(-1).location;
+			return [new MultipleBlocksNotPermittedMessage({
+				source: last.source,
+				start: nodes[1].location.start,
+				end: last.actualEnd ?? last.end
+			})];
+		} else if (nodes.length == 1 && nodes[0].type === NodeType.BlockModifier && nodes[0].expansion !== void 0) return check(nodes[0].expansion);
+		else if (nodes.length == 0 && !opt?.optional) return [new ContentExpectedMessage(node.location)];
+		return null;
+	}
+	return check(node.expansion ?? node.content);
+}
+function createPlaintextWrapper(name, get, set, slotType = ModifierSlotType.Normal) {
+	return new SystemModifierDefinition(name, slotType, {
+		delayContentExpansion: true,
+		beforeProcessExpansion(node, cxt) {
+			let { msgs } = bindArgs(node, []);
+			if (msgs) return msgs;
+			const result = onlyPermitPlaintextParagraph(node);
+			if (typeof result !== "string") return result;
+			const previous = get(cxt);
+			if (previous !== void 0) msgs = [new OverwriteSpecialVariableMessage(node.head, name, previous)];
+			set(cxt, result);
+			return msgs ?? [];
+		}
+	});
+}
+function createParagraphWrapper(name, get, set, slotType = ModifierSlotType.Normal) {
+	return new SystemModifierDefinition(name, slotType, { beforeProcessExpansion(node, cxt) {
+		let { msgs } = bindArgs(node, []);
+		if (msgs) return msgs;
+		msgs = onlyPermitSingleBlock(node);
+		if (msgs) return msgs;
+		msgs = onlyPermitSimpleParagraphs(node);
+		if (msgs) return msgs;
+		if (get(cxt) !== void 0) msgs = [new OverwriteSpecialVariableMessage(node.head, name, "<block>")];
+		const stripped = stripNode(cloneNode(node.content[0]))[0];
+		set(cxt, stripped);
+		debug.info(name, "->", debugPrint.node(stripped));
+		return msgs ?? [];
+	} });
+}
+
+//#endregion
+//#region src/builtin/internal.ts
+const builtins = Symbol();
+function initParseContext(cxt) {
+	cxt.init(builtins, {
+		blockSlotDelayedStack: [],
+		inlineSlotDelayedStack: [],
+		blockInstantiationData: [],
+		inlineInstantiationData: [],
+		insideModule: void 0
+	});
+}
+function customModifier(type, name, signature, content) {
+	debug.info(`created custom ${NodeType[type]}:`, name);
+	debug.info("args:", signature.args, "named:", signature.namedArgs, `with ${signature.slotName === void 0 ? "no slot" : signature.slotName == "" ? "empty slot name" : "slot name: " + signature.slotName}`);
+	debug.trace(() => "content is\n" + debugPrint.node(...content));
+	const flag = signature.slotName === void 0 ? ModifierSlotType.None : signature.preformatted ? ModifierSlotType.Preformatted : ModifierSlotType.Normal;
+	const mod = type == NodeType.BlockModifier ? new BlockModifierDefinition(name, flag) : new InlineModifierDefinition(name, flag);
+	const isInline = type == NodeType.InlineModifier;
+	if (content.length == 1 && (content[0].type == NodeType.BlockModifier || content[0].type == NodeType.InlineModifier)) mod.roleHint = content[0].mod.roleHint;
+	mod.delayContentExpansion = true;
+	mod.prepareExpand = (node) => {
+		let { msgs, args } = bindArgs(node, signature.args, { named: signature.namedArgs });
+		if (msgs) return msgs;
+		node.state = {
+			ok: true,
+			args: new Map(Object.entries(args))
+		};
+		return [];
+	};
+	mod.expand = (node) => {
+		if (!node.state?.ok) return [];
+		return cloneNodes(content, { newLocation: node.location });
+	};
+	mod.beforeProcessExpansion = (node, cxt) => {
+		if (!node.state?.ok) return [];
+		const store = cxt.get(builtins);
+		(isInline ? store.inlineInstantiationData : store.blockInstantiationData).push({
+			slotName: signature.slotName,
+			mod,
+			args: node.state.args,
+			slotContent: node.content
+		});
+		debug.trace(`pushed ${NodeType[type]} slot data for`, name);
+		debug.trace(`... slotName:`, signature.slotName === "" ? "<unnamed>" : signature.slotName === void 0 ? "<no slot>" : `'${signature.slotName}'`);
+		debug.trace(`... args:`, "{" + [...node.state.args].map(([a, b]) => `${a} => ${b}`).join(", ") + "}");
+		return [];
+	};
+	mod.afterProcessExpansion = (node, cxt) => {
+		if (!node.state?.ok) return [];
+		const store = cxt.get(builtins);
+		(isInline ? store.inlineInstantiationData : store.blockInstantiationData).pop();
+		debug.trace(`popped ${NodeType[type]} slot data for`, name);
+		return [];
+	};
+	return mod;
+}
+function makeInlineDefinition(content, msgs) {
+	let lastIsParagraph = false;
+	let concat = [];
+	for (const n of content) switch (n.type) {
+		case NodeType.Group:
+			concat.push(...makeInlineDefinition(n.content, msgs));
+			break;
+		case NodeType.Paragraph: if (!lastIsParagraph) {
+			lastIsParagraph = true;
+			concat.push(...n.content);
+			continue;
+		}
+		case NodeType.Preformatted:
+		case NodeType.BlockModifier:
+			msgs.push(new EntityNotAllowedMessage(n.location));
+			break;
+		case NodeType.SystemModifier:
+			lastIsParagraph = false;
+			concat.push(n);
+			break;
+		default: debug.never(n);
+	}
+	return concat;
+}
+
+//#endregion
+//#region src/builtin/define-modifier.ts
+function parseDefineArguments$1(node, stack) {
+	let { msgs, args, nodes, rest } = bindArgs(node, ["name"], {
+		rest: true,
+		restNamed: true
+	});
+	if (msgs) return msgs;
+	msgs = [];
+	const nameNode = nodes.name;
+	const name = args.name;
+	if (name === "" || name?.includes("\n")) return [new InvalidArgumentMessage(nameNode.location, name)];
+	let slotName = "";
+	if (rest.length > 0) {
+		const last = rest.at(-1);
+		const match = /^\((.*)\)$/.exec(last);
+		if (match) {
+			slotName = match[1];
+			rest.pop();
+		} else slotName = "";
+	}
+	let namedArgs = Object.fromEntries([...node.arguments.named].map((x) => [x[0], x[1].expansion]));
+	let signature = {
+		slotName,
+		args: rest,
+		namedArgs,
+		preformatted: void 0
+	};
+	node.state = {
+		name,
+		nameNode,
+		signature,
+		msgs
+	};
+	stack.push(signature);
+}
+const DefineBlockMod = new SystemModifierDefinition("define-block", ModifierSlotType.Normal, {
+	delayContentExpansion: true,
+	alwaysTryExpand: true,
+	beforeParseContent(node, cxt, immediate) {
+		const check = parseDefineArguments$1(node, cxt.get(builtins).blockSlotDelayedStack);
+		if (check) if (immediate) return check;
+		else {
+			debug.trace("skipping incomplete definition");
+			return [];
+		}
+		debug.trace("entering block definition:", node.state.name);
+		return [];
+	},
+	afterParseContent(node, cxt) {
+		if (!node.state) return [];
+		assert(cxt.get(builtins).blockSlotDelayedStack.pop() === node.state.signature);
+		debug.trace("leaving block definition", node.state.name);
+		return [];
+	},
+	prepareExpand(node, cxt, immediate) {
+		if (!immediate || !node.state) return [];
+		const msgs = node.state.msgs;
+		if (!node.state.name) msgs.push(new InvalidArgumentMessage(node.state.nameNode.location));
+		else if (cxt.config.blockModifiers.has(node.state.name)) msgs.push(new NameAlreadyDefinedMessage(node.state.nameNode.location, node.state.name));
+		return msgs;
+	},
+	expand(node, cxt, immediate) {
+		if (!immediate) return void 0;
+		if (node.state?.name) {
+			if (cxt.config.blockModifiers.has(node.state.name)) cxt.config.blockModifiers.remove(node.state.name);
+			cxt.config.blockModifiers.add(customModifier(NodeType.BlockModifier, node.state.name, node.state.signature, node.content));
+		}
+		return [];
+	}
+});
+const DefineInlineMod = new SystemModifierDefinition("define-inline", ModifierSlotType.Normal, {
+	delayContentExpansion: true,
+	alwaysTryExpand: true,
+	beforeParseContent(node, cxt, immediate) {
+		const check = parseDefineArguments$1(node, cxt.get(builtins).inlineSlotDelayedStack);
+		if (check) if (immediate) return check;
+		else {
+			debug.trace("skipping incomplete definition");
+			return [];
+		}
+		debug.trace("entering inline definition:", node.state.name);
+		return [];
+	},
+	afterParseContent(node, cxt) {
+		if (!node.state) return [];
+		assert(cxt.get(builtins).inlineSlotDelayedStack.pop() === node.state.signature);
+		debug.trace("leaving inline definition", node.state.name);
+		return [];
+	},
+	prepareExpand(node, cxt, immediate) {
+		if (!immediate || !node.state) return [];
+		if (!node.state.name) return [new InvalidArgumentMessage(node.state.nameNode.location)];
+		const msgs = node.state.msgs;
+		if (cxt.config.inlineModifiers.has(node.state.name)) msgs.push(new NameAlreadyDefinedMessage(node.state.nameNode.location, node.state.name));
+		node.state.definition = makeInlineDefinition(node.content, msgs);
+		return msgs;
+	},
+	expand(node, cxt, immediate) {
+		if (!immediate) return void 0;
+		if (node.state?.name) {
+			if (cxt.config.inlineModifiers.has(node.state.name)) cxt.config.inlineModifiers.remove(node.state.name);
+			cxt.config.inlineModifiers.add(customModifier(NodeType.InlineModifier, node.state.name, node.state.signature, node.state.definition));
+		}
+		return [];
+	}
+});
+
+//#endregion
+//#region src/builtin/define-shorthand.ts
+function parseDefineArguments(type, node, stack) {
+	let { msgs, args, nodes, rest, restNodes } = bindArgs(node, ["name"], { rest: true });
+	if (msgs) return msgs;
+	msgs = [];
+	const nameNode = nodes.name;
+	const name = args.name;
+	if (name === "" || name?.includes("\n")) return [new InvalidArgumentMessage(nameNode.location, name)];
+	let slotName = void 0;
+	let parts = [];
+	let postfix = void 0;
+	let i = 0;
+	while (i < rest.length) {
+		const arg = restNodes[i];
+		const match = /^\((.*)\)$/.exec(arg.expansion);
+		if (match) {
+			slotName = match[1];
+			i++;
+			if (type == NodeType.InlineModifier) if (i < rest.length) if (rest[i] === "") msgs.push(new InvalidArgumentMessage(restNodes[i].location, "postfix"));
+			else {
+				postfix = rest[i];
+				i++;
+			}
+			else msgs.push(new ArgumentCountMismatchMessage(node.head));
+			break;
+		}
+		i++;
+		if (i < rest.length) {
+			const id = arg.expansion;
+			if (id === "") return [new InvalidArgumentMessage(arg.location, "id")];
+			const part = rest[i];
+			if (part === "") return [new InvalidArgumentMessage(restNodes[i].location, "part")];
+			parts.push([id, part]);
+			i++;
+		} else {
+			msgs.push(new ArgumentCountMismatchMessage(node.head));
+			break;
+		}
+	}
+	if (i == rest.length - 1) {
+		if (rest[i] !== "") msgs.push(new InvalidArgumentMessage(restNodes[i].location, "(must be empty)"));
+	} else if (i < rest.length - 1) msgs.push(new ArgumentCountMismatchMessage(node.head));
+	let signature = {
+		slotName,
+		args: parts.map((x) => x[0]),
+		namedArgs: {},
+		preformatted: void 0
+	};
+	node.state = {
+		name,
+		nameNode,
+		signature,
+		parts,
+		postfix,
+		msgs
+	};
+	stack.push(signature);
+	return [];
+}
+const DefineBlockShorthandMod = new SystemModifierDefinition("block-shorthand", ModifierSlotType.Normal, {
+	delayContentExpansion: true,
+	alwaysTryExpand: true,
+	beforeParseContent(node, cxt, immediate) {
+		if (!immediate) return [];
+		const store = cxt.get(builtins);
+		const check = parseDefineArguments(NodeType.BlockModifier, node, store.blockSlotDelayedStack);
+		if (check) return check;
+		debug.trace("entering block shorthand definition", node.state.name);
+		return [];
+	},
+	afterParseContent(node, cxt) {
+		if (!node.state) return [];
+		assert(cxt.get(builtins).blockSlotDelayedStack.pop() === node.state.signature);
+		debug.trace("leaving inline shorthand definition", node.state.name);
+		return [];
+	},
+	prepareExpand(node, cxt, immediate) {
+		if (!immediate || !node.state) return [];
+		if (!node.state.name) return [new InvalidArgumentMessage(node.state.nameNode.location)];
+		const msgs = node.state.msgs;
+		if (cxt.config.blockShorthands.has(node.state.name)) msgs.push(new NameAlreadyDefinedMessage(node.state.nameNode.location, node.state.name));
+		return msgs;
+	},
+	expand(node, cxt, immediate) {
+		if (!immediate || !node.state) return void 0;
+		const name = "<block shorthand>";
+		const parts = node.state.parts.map((x) => x[1]);
+		const mod = customModifier(NodeType.BlockModifier, name, node.state.signature, node.content);
+		const shorthand = {
+			name: node.state.name,
+			postfix: node.state.postfix,
+			mod,
+			parts
+		};
+		if (cxt.config.blockShorthands.has(node.state.name)) cxt.config.blockShorthands.remove(node.state.name);
+		cxt.config.blockShorthands.add(shorthand);
+		debug.info(() => "created block shorthand: " + debugPrint.blockShorthand(shorthand));
+		return [];
+	}
+});
+const DefineInlineShorthandMod = new SystemModifierDefinition("inline-shorthand", ModifierSlotType.Normal, {
+	delayContentExpansion: true,
+	alwaysTryExpand: true,
+	beforeParseContent(node, cxt, immediate) {
+		if (!immediate) return [];
+		const store = cxt.get(builtins);
+		const check = parseDefineArguments(NodeType.InlineModifier, node, store.inlineSlotDelayedStack);
+		if (check) return check;
+		debug.trace("entering inline shorthand definition", node.state.name);
+		return [];
+	},
+	afterParseContent(node, cxt) {
+		if (!node.state) return [];
+		assert(cxt.get(builtins).inlineSlotDelayedStack.pop() === node.state.signature);
+		debug.trace("leaving inline shorthand definition", node.state.name);
+		return [];
+	},
+	prepareExpand(node, cxt, immediate) {
+		if (!immediate || !node.state) return [];
+		if (!node.state.name) return [new InvalidArgumentMessage(node.state.nameNode.location)];
+		const msgs = node.state.msgs;
+		if (cxt.config.inlineShorthands.has(node.state.name)) msgs.push(new NameAlreadyDefinedMessage(node.state.nameNode.location, node.state.name));
+		node.state.definition = makeInlineDefinition(node.content, msgs);
+		return msgs;
+	},
+	expand(node, cxt, immediate) {
+		if (!immediate || !node.state) return void 0;
+		const name = "<inline shorthand>";
+		const parts = node.state.parts.map((x) => x[1]);
+		const mod = customModifier(NodeType.InlineModifier, name, node.state.signature, node.state.definition);
+		const shorthand = {
+			name: node.state.name,
+			postfix: node.state.postfix,
+			mod,
+			parts
+		};
+		if (cxt.config.inlineShorthands.has(node.state.name)) cxt.config.inlineShorthands.remove(node.state.name);
+		cxt.config.inlineShorthands.add(shorthand);
+		debug.info(() => "created inline shorthand: " + debugPrint.inlineShorthand(shorthand));
+		return [];
+	}
+});
+
+//#endregion
+//#region src/builtin/misc.ts
+const RawBlockMod = new BlockModifierDefinition("raw", ModifierSlotType.Preformatted, { expand(node) {
+	return node.content;
+} });
+const ConcatBlockMod = new BlockModifierDefinition("concat", ModifierSlotType.Normal, {
+	prepareExpand(node) {
+		let { msgs, nodes } = bindArgs(node, [], { named: { sep: "" } });
+		if (msgs) return msgs;
+		msgs = onlyPermitSimpleParagraphs(node);
+		if (msgs) return msgs;
+		node.state = nodes?.sep;
+		return [];
+	},
+	expand(node) {
+		const result = {
+			location: node.location,
+			type: NodeType.Paragraph,
+			content: []
+		};
+		function separator() {
+			if (node.state?.expansion) result.content.push({
+				type: NodeType.Text,
+				location: node.state.location,
+				content: node.state.expansion
+			});
+		}
+		function work(nodes) {
+			for (const n of nodes) switch (n.type) {
+				case NodeType.Paragraph:
+					result.content.push(...n.content);
+					separator();
+					break;
+				case NodeType.Group:
+					work(n.content);
+					break;
+				case NodeType.BlockModifier:
+					if (n.expansion) work(n.expansion);
+					break;
+				case NodeType.Preformatted:
+				case NodeType.SystemModifier: break;
+				default: debug.never(n);
+			}
+		}
+		work(node.content);
+		if (node.state?.expansion && result.content.length > 0) result.content.pop();
+		return [result];
+	}
+});
+
+//#endregion
+//#region src/module.ts
+let ModuleDefinition;
+(function(_ModuleDefinition) {
+	function from(cxt) {
+		return {
+			usedModules: new Set(cxt.usedModules),
+			blocks: cxt.config.blockModifiers.toSet(),
+			inlines: cxt.config.inlineModifiers.toSet(),
+			inlineShorthands: cxt.config.inlineShorthands.toSet(),
+			blockShorthands: cxt.config.blockShorthands.toSet()
+		};
+	}
+	_ModuleDefinition.from = from;
+	function apply(defs, cxt) {
+		cxt.usedModules = new Set(defs.usedModules);
+		cxt.config.blockModifiers = new NameManager(defs.blocks);
+		cxt.config.inlineModifiers = new NameManager(defs.inlines);
+		cxt.config.inlineShorthands = new NameManager(defs.inlineShorthands);
+		cxt.config.blockShorthands = new NameManager(defs.blockShorthands);
+	}
+	_ModuleDefinition.apply = apply;
+	function diff(cnew, cold) {
+		return {
+			usedModules: cnew.usedModules.difference(cold.usedModules),
+			blocks: cnew.blocks.difference(cold.blocks),
+			inlines: cnew.inlines.difference(cold.inlines),
+			inlineShorthands: cnew.inlineShorthands.difference(cold.inlineShorthands),
+			blockShorthands: cnew.blockShorthands.difference(cold.blockShorthands)
+		};
+	}
+	_ModuleDefinition.diff = diff;
+	function add(snew, sold, transform) {
+		let newNames = new Set([...snew].map((x) => x.name));
+		let out = new Set(snew);
+		let overlap = [];
+		for (const x of sold) if (newNames.has(x.name)) overlap.push(x);
+		else out.add(x);
+		return [out, overlap.map(transform).join(", ")];
+	}
+	function combine(cnew, cold) {
+		let [blocks, s1] = add(cnew.blocks, cold.blocks, debugPrint.blockModifier);
+		let [inlines, s2] = add(cnew.inlines, cold.inlines, debugPrint.inlineModifier);
+		let [inlineShorthands, s3] = add(cnew.inlineShorthands, cold.inlineShorthands, debugPrint.inlineShorthand);
+		let [blockShorthands, s4] = add(cnew.blockShorthands, cold.blockShorthands, debugPrint.blockShorthand);
+		return [{
+			usedModules: cnew.usedModules.union(cold.usedModules),
+			blocks,
+			inlines,
+			inlineShorthands,
+			blockShorthands
+		}, (s1 ? s1 + "; " : "") + (s2 ? s2 + "; " : "") + (s3 ? "inline shorthand " + s3 + "; " : "") + (s4 ? "block shorthand " + s4 : "")];
+	}
+	_ModuleDefinition.combine = combine;
+})(ModuleDefinition || (ModuleDefinition = {}));
+
+//#endregion
+//#region src/builtin/module.ts
+const ModuleMod = new BlockModifierDefinition("module", ModifierSlotType.Normal, {
+	expand() {
+		return [];
+	},
+	beforeParseContent(node, cxt) {
+		let { msgs, args } = bindArgs(node, ["name"]);
+		if (msgs) return msgs;
+		const data = cxt.get(builtins);
+		const name = args.name;
+		const defs = ModuleDefinition.from(cxt);
+		if (data.insideModule !== void 0) return [new NoNestedModuleMessage(node.head)];
+		msgs = [];
+		node.state = {
+			name,
+			defs
+		};
+		data.insideModule = name;
+		if (cxt.config.modules.has(name)) {
+			const [combined, msg] = ModuleDefinition.combine(defs, cxt.config.modules.get(name));
+			if (msg) msgs.push(new OverwriteDefinitionsMessage(node.head, msg));
+			ModuleDefinition.apply(combined, cxt);
+			debug.trace("entering defs for module", name, "(earlier data loaded)");
+		} else debug.trace("entering defs for module", name);
+		return msgs;
+	},
+	afterParseContent(node, cxt) {
+		if (!node.state) return [];
+		const data = cxt.get(builtins);
+		data.insideModule = void 0;
+		const old = ModuleDefinition.from(cxt);
+		cxt.config.modules.set(node.state.name, ModuleDefinition.diff(old, node.state.defs));
+		ModuleDefinition.apply(node.state.defs, cxt);
+		debug.trace("exiting defs for module", node.state.name);
+		return [];
+	}
+});
+function use(node, cxt) {
+	let { msgs, args, nodes } = bindArgs(node, ["name"]);
+	if (msgs) return msgs;
+	const data = cxt.get(builtins);
+	if (!cxt.config.modules.has(args.name)) return [new InvalidArgumentMessage(nodes.name.location)];
+	if (data.insideModule === args.name) return [new CannotUseModuleInSelfMessage(nodes.name.location)];
+	const old = ModuleDefinition.from(cxt);
+	const [combined, msg] = ModuleDefinition.combine(cxt.config.modules.get(args.name), old);
+	ModuleDefinition.apply(combined, cxt);
+	node.state = old;
+	if (msg) return [new OverwriteDefinitionsMessage(node.head, msg)];
+	return [];
+}
+const UseSystemMod = new SystemModifierDefinition("use", ModifierSlotType.None, { prepareExpand(node, cxt) {
+	return use(node, cxt);
+} });
+const UseBlockMod = new BlockModifierDefinition("use", ModifierSlotType.Normal, {
+	beforeParseContent(node, cxt) {
+		return use(node, cxt);
+	},
+	afterParseContent(node, cxt) {
+		if (node.state) ModuleDefinition.apply(node.state, cxt);
+		return [];
+	},
+	expand(node) {
+		return node.content;
+	}
+});
+
+//#endregion
+//#region src/builtin/slot.ts
+function slotModifier(name, type, preformatted, inject) {
+	const mod = type == NodeType.BlockModifier ? new BlockModifierDefinition(name, ModifierSlotType.None) : new InlineModifierDefinition(name, ModifierSlotType.None);
+	const isInline = type == NodeType.InlineModifier;
+	mod.alwaysTryExpand = true;
+	mod.prepareExpand = (node, cxt, immediate) => {
+		if (node.state) return [];
+		function processSignature(s) {
+			if (s.preformatted === void 0) {
+				s.preformatted = preformatted;
+				debug.trace("set preformatted to ", preformatted);
+			} else if (s.preformatted !== preformatted) return [new EitherNormalOrPreMessage(node.location)];
+			return [];
+		}
+		const check = inject ? bindArgs(node, ["modname"], { optional: ["id"] }) : bindArgs(node, [], { optional: ["id"] });
+		if (check.msgs) {
+			node.state = { ok: false };
+			return check.msgs;
+		}
+		const store = cxt.get(builtins);
+		const data = isInline ? store.inlineInstantiationData : store.blockInstantiationData;
+		const stack = isInline ? store.inlineSlotDelayedStack : store.blockSlotDelayedStack;
+		let msgs = (() => {
+			if (data.length == 0 && stack.length == 0) {
+				node.state = { ok: false };
+				return [new SlotUsedOutsideDefinitionMessage(node.location)];
+			}
+			const id = check.args.id;
+			if (!id) {
+				let signature$1 = stack.at(-1);
+				if (signature$1) return processSignature(signature$1);
+				node.state = {
+					ok: true,
+					data: data.at(-1),
+					index: data.length - 1
+				};
+				return;
+			}
+			let signature = stack.find((x) => x.slotName == id);
+			if (signature) return processSignature(signature);
+			for (let i = data.length - 1; i >= 0; i--) if (data[i].slotName === id) {
+				node.state = {
+					ok: true,
+					data: data[i],
+					index: i
+				};
+				return;
+			}
+			if (immediate) {
+				node.state = { ok: false };
+				return [new InvalidArgumentMessage(check.nodes.id.location, id)];
+			}
+			return [];
+		})();
+		if (inject) {
+			const modname = check.args.modname;
+			const modnameNode = check.nodes.modname;
+			const mod$1 = (isInline ? cxt.config.inlineModifiers : cxt.config.blockModifiers).get(modname);
+			if (!mod$1) {
+				node.state = { ok: false };
+				return [new UnknownModifierMessage(modnameNode.location, modname)];
+			}
+			if (node.state?.ok) node.state.injectMod = mod$1;
+		}
+		if (msgs !== void 0) return msgs;
+		return [];
+	};
+	mod.expand = (node, cxt) => {
+		if (!node.state) return void 0;
+		if (!node.state.ok) return [];
+		let cloned = cloneNodes(node.state.data.slotContent);
+		if (inject) {
+			assert(node.state.injectMod !== void 0);
+			return [{
+				type,
+				mod: node.state.injectMod,
+				location: node.location,
+				head: node.head,
+				arguments: {
+					positional: [],
+					named: /* @__PURE__ */ new Map(),
+					location: node.location
+				},
+				content: cloned
+			}];
+		} else return cloned;
+	};
+	mod.beforeProcessExpansion = (node, cxt) => {
+		if (!node.state?.ok) return [];
+		const store = cxt.get(builtins);
+		debug.trace("temporarily removed slot data for", node.state.data.mod.name);
+		(isInline ? store.inlineInstantiationData : store.blockInstantiationData).splice(node.state.index, 1);
+		return [];
+	};
+	mod.afterProcessExpansion = (node, cxt) => {
+		if (!node.state?.ok) return [];
+		const store = cxt.get(builtins);
+		debug.trace("reinstated slot data for", node.state.data.mod.name);
+		(isInline ? store.inlineInstantiationData : store.blockInstantiationData).splice(node.state.index, 0, node.state.data);
+		return [];
+	};
+	return mod;
+}
+const SlotBlockMod = slotModifier("slot", NodeType.BlockModifier, false, false);
+const SlotInlineMod = slotModifier("slot", NodeType.InlineModifier, false, false);
+const PreSlotBlockMod = slotModifier("pre-slot", NodeType.BlockModifier, true, false);
+const PreSlotInlineMod = slotModifier("pre-slot", NodeType.InlineModifier, true, false);
+const InjectPreSlotBlockMod = slotModifier("inject-pre-slot", NodeType.BlockModifier, true, true);
+const InjectPreSlotInlineMod = slotModifier("inject-pre-slot", NodeType.InlineModifier, true, true);
+
+//#endregion
+//#region src/builtin/var.ts
+function resolveId(id, cxt) {
+	const store = cxt.get(builtins);
+	if (store.inlineSlotDelayedStack.find((x) => x.args.includes(id)) || store.blockSlotDelayedStack.find((x) => x.args.includes(id))) {
+		debug.trace("delaying the yet unknown argument", id);
+		return;
+	}
+	let value = void 0;
+	for (let i = store.inlineInstantiationData.length - 1; i >= 0; i--) if ((value = store.inlineInstantiationData[i].args.get(id)) !== void 0) break;
+	for (let i = store.blockInstantiationData.length - 1; i >= 0; i--) if ((value = store.blockInstantiationData[i].args.get(id)) !== void 0) break;
+	if (value === void 0) value = cxt.variables.get(id);
+	return value;
+}
+let ifdefBody = (x) => ({
+	prepareExpand(node, cxt) {
+		let { msgs, args, nodes } = bindArgs(node, ["id"]);
+		if (msgs) return msgs;
+		if (args.id == "") return [new InvalidArgumentMessage(nodes.id.location)];
+		node.state = resolveId(args.id, cxt) !== void 0;
+		return [];
+	},
+	expand(node) {
+		return node.state == x ? node.content : [];
+	}
+});
+let ifdefBlock = (name, x) => new BlockModifierDefinition(name, ModifierSlotType.Normal, ifdefBody(x));
+let ifdefInline = (name, x) => new InlineModifierDefinition(name, ModifierSlotType.Normal, ifdefBody(x));
+const IfdefBlockMod = ifdefBlock("ifdef", true);
+const IfndefBlockMod = ifdefBlock("ifndef", false);
+const IfdefInlineMod = ifdefInline("ifdef", true);
+const IfndefInlineMod = ifdefInline("ifndef", false);
+const GetVarInlineMod = new InlineModifierDefinition("$", ModifierSlotType.None, {
+	alwaysTryExpand: true,
+	prepareExpand(node, cxt, immediate) {
+		let { msgs, args, nodes } = bindArgs(node, ["id"]);
+		if (msgs) return immediate ? msgs : [];
+		const id = args.id;
+		if (id == "") return immediate ? [new InvalidArgumentMessage(nodes.id.location)] : [];
+		const value = resolveId(id, cxt);
+		if (value === void 0) return immediate ? [new UndefinedVariableMessage(nodes.id.location, id)] : [];
+		node.state = { value };
+		return [];
+	},
+	expand(node, _, immediate) {
+		if (!node.state) return immediate ? [] : void 0;
+		return [{
+			type: NodeType.Text,
+			content: node.state.value,
+			location: node.location
+		}];
+	}
+});
+const PrintInlineMod = new InlineModifierDefinition("print", ModifierSlotType.None, {
+	prepareExpand(node) {
+		let { msgs, rest } = bindArgs(node, [], { rest: true });
+		if (msgs) return msgs;
+		node.state = { value: rest.join("") };
+		return [];
+	},
+	expand(node) {
+		if (!node.state) return [];
+		return [{
+			type: NodeType.Text,
+			content: node.state.value,
+			location: node.location
+		}];
+	}
+});
+const GetVarInterpolator = new ArgumentInterpolatorDefinition("$(", ")", {
+	alwaysTryExpand: true,
+	expand(content, cxt) {
+		const result = resolveId(content, cxt);
+		if (result !== void 0) debug.trace(`$(${content}) --> ${result}`);
+		return result;
+	}
+});
+const VarMod = new SystemModifierDefinition("var", ModifierSlotType.None, {
+	prepareExpand(node) {
+		if (node.arguments.named.size == 1 && node.arguments.positional.length == 0) {
+			const [id, arg] = [...node.arguments.named][0];
+			if (arg.expansion === void 0) return [new CannotExpandArgumentMessage(arg.location)];
+			node.state = {
+				id,
+				value: arg.expansion
+			};
+			return [];
+		}
+		let { msgs, args, nodes } = bindArgs(node, ["id", "value"]);
+		if (msgs) return msgs;
+		if (!args.id) return [new InvalidArgumentMessage(nodes.id.location)];
+		node.state = {
+			id: args.id,
+			value: args.value
+		};
+		return [];
+	},
+	expand(node, cxt) {
+		if (node.state) {
+			cxt.variables.set(node.state.id, node.state.value);
+			debug.trace("set variable", node.state.id, "=", node.state.value);
+		}
+		return [];
+	}
+});
+
+//#endregion
+//#region src/builtin/builtin.ts
+let builtin = new Configuration();
+builtin.initializers = [initParseContext];
+builtin.systemModifiers.add(DefineBlockMod, DefineInlineMod, DefineBlockShorthandMod, DefineInlineShorthandMod, VarMod, UseSystemMod);
+builtin.blockModifiers.add(SlotBlockMod, PreSlotBlockMod, InjectPreSlotBlockMod, ModuleMod, UseBlockMod, IfdefBlockMod, IfndefBlockMod, RawBlockMod, ConcatBlockMod);
+builtin.inlineModifiers.add(SlotInlineMod, PreSlotInlineMod, InjectPreSlotInlineMod, GetVarInlineMod, PrintInlineMod, IfdefInlineMod, IfndefInlineMod);
+builtin.argumentInterpolators.add(GetVarInterpolator);
+const BuiltinConfiguration = Object.freeze(builtin);
+
+//#endregion
+//#region src/default/bullets.tsx
+const bulletItemBlock = new BlockModifierDefinition("bullet-item", ModifierSlotType.Normal, { roleHint: void 0 });
+const orderedListItemBlock = new BlockModifierDefinition("ordered-item", ModifierSlotType.Normal, {
+	roleHint: void 0,
+	prepareExpand(node) {
+		let { msgs, args, nodes } = bindArgs(node, ["number"]);
+		if (msgs) return msgs;
+		let num = Number.parseInt(args.number);
+		if (isNaN(num)) return [new InvalidArgumentMessage(nodes.number.location, "should be a number")];
+		node.state = num;
+		return [];
+	}
+});
+const subItemBlock = new BlockModifierDefinition("subitem", ModifierSlotType.Normal, { roleHint: void 0 });
+const BulletBlocks = [
+	bulletItemBlock,
+	orderedListItemBlock,
+	subItemBlock
+];
+const BulletBlockRenderersHTML = [
+	[bulletItemBlock, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("li", {
+		class: "bullet",
+		children: cxt.state.render(node.content, cxt)
+	})],
+	[subItemBlock, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("div", {
+		class: "subitem",
+		children: cxt.state.render(node.content, cxt)
+	})],
+	[orderedListItemBlock, (node, cxt) => node.state === void 0 ? cxt.state.invalidBlock(node, "bad format") : /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("li", {
+		class: "ordered",
+		value: node.state,
+		children: cxt.state.render(node.content, cxt)
+	})]
+];
+
+//#endregion
+//#region src/default/headings.tsx
+const headings = Symbol();
+function initHeadings(cxt) {
+	cxt.init(headings, { path: [] });
+}
+function setHeading(cxt, data) {
+	const path = cxt.get(headings).path;
+	while (path.length > 0 && path.at(-1).level >= data.level) path.pop();
+	path.push(data);
+	return [];
+}
+function currentHeadingLevel(cxt) {
+	return cxt.get(headings).path.at(-1)?.level;
+}
+function currentExplicitHeadingLevel(cxt) {
+	return cxt.get(headings).path.findLast((x) => !x.implicit)?.level;
+}
+const headingBlock = new BlockModifierDefinition("heading", ModifierSlotType.Normal, {
+	roleHint: "heading",
+	prepareExpand(node, cxt) {
+		let { msgs, args, nodes } = bindArgs(node, [], { optional: ["n"] });
+		if (msgs) return msgs;
+		msgs = onlyPermitSingleBlock(node);
+		if (msgs) return msgs;
+		msgs = onlyPermitSimpleParagraphs(node);
+		if (msgs) return msgs;
+		node.state = {
+			name: void 0,
+			level: currentHeadingLevel(cxt) ?? 1
+		};
+		if (args.n !== void 0) {
+			const level = Number.parseInt(args.n);
+			if (isNaN(level) || level < 1 || level > 6) msgs = [new InvalidArgumentMessage(nodes.n.location, "should be a number between 1 and 6")];
+			else node.state.level = level;
+		}
+		setHeading(cxt, node.state);
+		return msgs ?? [];
+	}
+});
+const implicitHeadingBlock = new BlockModifierDefinition("implicit-heading", ModifierSlotType.None, {
+	roleHint: "heading",
+	prepareExpand(node, cxt) {
+		let { msgs, args, nodes } = bindArgs(node, [], { optional: ["n"] });
+		if (msgs) return msgs;
+		node.state = {
+			name: void 0,
+			implicit: true,
+			level: (currentExplicitHeadingLevel(cxt) ?? 0) + 1
+		};
+		if (args.n !== void 0) {
+			const level = Number.parseInt(args.n);
+			if (isNaN(level) || level < 1 || level > 6) msgs = [new InvalidArgumentMessage(nodes.n.location, "should be a number between 1 and 6")];
+			else node.state.level = level;
+		}
+		setHeading(cxt, node.state);
+		return msgs ?? [];
+	}
+});
+const numberedHeadingBlock = new BlockModifierDefinition("numbered-heading", ModifierSlotType.Normal, {
+	roleHint: "heading",
+	prepareExpand(node, cxt) {
+		let { msgs, args, nodes } = bindArgs(node, ["number"]);
+		if (msgs) return msgs;
+		msgs = onlyPermitSingleBlock(node, { optional: true });
+		if (msgs) return msgs;
+		msgs = onlyPermitSimpleParagraphs(node);
+		if (msgs) return msgs;
+		node.state = {
+			name: void 0,
+			level: currentHeadingLevel(cxt) ?? 1
+		};
+		const split = args.number.trim().split(".").filter((x) => x.length > 0);
+		if (split.length == 0 || split.length > 6) msgs = [new InvalidArgumentMessage(nodes.number.location, "heading level should be between 1 and 6")];
+		else node.state = {
+			name: split.join("."),
+			level: split.length
+		};
+		setHeading(cxt, node.state);
+		return msgs ?? [];
+	}
+});
+const HeadingBlocks = [
+	headingBlock,
+	implicitHeadingBlock,
+	numberedHeadingBlock
+];
+const HeadingBlockRenderersHTML = [
+	[headingBlock, (node, cxt) => {
+		if (node.state !== void 0) {
+			const tag = "h" + node.state.level;
+			const para = node.content[0];
+			const element = document.createElement(tag);
+			element.appendChild(cxt.state.render(para.content, cxt));
+			return element;
+		}
+		return cxt.state.invalidBlock(node, "Bad format");
+	}],
+	[implicitHeadingBlock, (node, cxt) => {
+		if (node.state !== void 0) {
+			const tag = "h" + node.state.level;
+			const element = document.createElement(tag);
+			element.className = "implicit";
+			return element;
+		}
+		return cxt.state.invalidBlock(node, "Bad format");
+	}],
+	[numberedHeadingBlock, (node, cxt) => {
+		if (node.state !== void 0) {
+			const tag = "h" + node.state.level;
+			const element = document.createElement(tag);
+			element.className = "numbered-heading";
+			element.appendChild(/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("span", {
+				class: "heading-number",
+				children: node.state.name
+			}));
+			if (node.content.length > 0) {
+				const para = node.content[0];
+				element.appendChild(/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("span", {
+					class: "heading-content",
+					children: cxt.state.render(para.content, cxt)
+				}));
+			}
+			return element;
+		}
+		return cxt.state.invalidBlock(node, "Bad format");
+	}]
+];
+
+//#endregion
+//#region src/default/notes.tsx
+const notes = Symbol();
+function initNotes(cxt) {
+	cxt.init(notes, {
+		systems: /* @__PURE__ */ new Map(),
+		defaultSystem: {
+			position: "preserve",
+			autonumber: false
+		},
+		definitions: [],
+		currentId: 0
+	});
+}
+function getSystem(cxt, name) {
+	const defs = cxt.get(notes);
+	let system;
+	if (name) if (!defs.systems.has(name)) {
+		system = { ...defs.defaultSystem };
+		defs.systems.set(name, system);
+	} else system = defs.systems.get(name);
+	else system = defs.defaultSystem;
+	return system;
+}
+const notePositionSystem = new SystemModifierDefinition("note-position", ModifierSlotType.None, { prepareExpand(node, cxt) {
+	let { msgs, args, nodes } = bindArgs(node, ["type"], {
+		optional: ["name"],
+		trim: true
+	});
+	if (msgs) return msgs;
+	if (args.type != "global" && args.type != "preserve") return [new InvalidArgumentMessage(nodes.type.location, "should be `preserve` or `global`")];
+	getSystem(cxt, args.name).position = args.type;
+	return [];
+} });
+const noteRenumberingSystem = new SystemModifierDefinition("note-renumbering", ModifierSlotType.None, { prepareExpand(node, cxt) {
+	let { msgs, args, nodes } = bindArgs(node, ["type"], {
+		optional: ["name"],
+		trim: true
+	});
+	if (msgs) return msgs;
+	if (args.type != "on" && args.type != "off") return [new InvalidArgumentMessage(nodes.type.location, "should be `preserve` or `global`")];
+	getSystem(cxt, args.name).autonumber = args.type == "on";
+	return [];
+} });
+const noteMarkerInline = new InlineModifierDefinition("note", ModifierSlotType.None, {
+	roleHint: "link",
+	prepareExpand(node) {
+		let { msgs, args } = bindArgs(node, ["index"]);
+		if (msgs) return msgs;
+		node.state = args?.index;
+		return [];
+	}
+});
+const noteInline = new InlineModifierDefinition("note-inline", ModifierSlotType.Normal, {
+	roleHint: "quote",
+	prepareExpand(node) {
+		let { msgs, args } = bindArgs(node, [], { optional: ["index"] });
+		if (msgs) return msgs;
+		node.state = args?.index ?? "";
+		return [];
+	},
+	beforeProcessExpansion(node, cxt) {
+		if (node.state !== void 0) {
+			const defs = cxt.get(notes);
+			defs.definitions.push({
+				system: "",
+				id: defs.currentId,
+				name: node.state,
+				location: node.location,
+				content: [{
+					type: NodeType.Paragraph,
+					location: {
+						source: node.location.source,
+						start: node.head.end,
+						end: node.location.actualEnd ?? node.location.end
+					},
+					content: node.content
+				}]
+			});
+			defs.currentId++;
+		}
+		return [];
+	}
+});
+const noteBlock = new BlockModifierDefinition("note", ModifierSlotType.Normal, {
+	roleHint: "quote",
+	prepareExpand(node, cxt) {
+		let { msgs, args } = bindArgs(node, ["name"], {
+			optional: ["system"],
+			trim: true
+		});
+		if (msgs) return msgs;
+		const content = stripNode(...node.content);
+		debug.trace(`add note: system=<> name=${args.name} @${node.location.start}`);
+		debug.trace(`-->\n`, debugPrint.node(...content));
+		const defs = cxt.get(notes);
+		const entry = {
+			id: defs.currentId,
+			system: args.system ?? "",
+			name: args.name,
+			location: node.location,
+			content
+		};
+		defs.currentId++;
+		defs.definitions.push(entry);
+		node.state = entry;
+		return [];
+	}
+});
+const NoteBlocks = [noteBlock];
+const NoteInlines = [noteInline, noteMarkerInline];
+const NoteSystems = [notePositionSystem, noteRenumberingSystem];
+function makeNoteHTML(def, cxt) {
+	return /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsxs)("section", {
+		class: "note",
+		id: `note-id-${def.id}`,
+		children: [/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("div", {
+			class: "note-name",
+			children: /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("p", { children: /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("a", {
+				href: `#notemarker-id-${def.id}`,
+				children: def.name
+			}) })
+		}), /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("div", {
+			class: "note-content",
+			children: cxt.state.render(def.content, cxt)
+		})]
+	});
+}
+const NoteInlineRenderersHTML = [[noteMarkerInline, (node, cxt) => {
+	if (node.state === void 0) return cxt.state.invalidInline(node, "bad format");
+	const note = cxt.parsedDocument.context.get(notes).definitions.findIndex((x) => x.name == node.state);
+	return /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("sup", {
+		class: "note",
+		id: `notemarker-id-${note}`,
+		children: note < 0 ? `Not found: ${node.state}` : /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("a", {
+			href: `#note-id-${note}`,
+			children: node.state
+		})
+	});
+}]];
+const NoteBlockRenderersHTML = [[noteBlock, (node, cxt) => {
+	if (node.state === void 0) return cxt.state.invalidBlock(node, "bad format");
+	const defs = cxt.parsedDocument.context.get(notes);
+	if ((defs.systems.get(node.state.system) ?? defs.defaultSystem).position != "preserve") return [];
+	return makeNoteHTML(node.state, cxt);
+}]];
+const NotesFooterPlugin = (cxt) => {
+	const defs = cxt.parsedDocument.context.get(notes);
+	const items = cxt.parsedDocument.context.get(notes).definitions.filter((x) => (defs.systems.get(x.system) ?? defs.defaultSystem).position == "global");
+	if (items.length == 0) return void 0;
+	return [/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("hr", {}), /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("section", {
+		class: "notes-global",
+		children: items.map((x) => makeNoteHTML(x, cxt))
+	})];
+};
+
+//#endregion
+//#region src/default/code.tsx
+const CodeBlock = new BlockModifierDefinition("code", ModifierSlotType.Preformatted, { roleHint: "code" });
+const CodeInline = new InlineModifierDefinition("code", ModifierSlotType.Preformatted, { roleHint: "code" });
+const CodeBlockRendererHTML = [CodeBlock, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("pre", { children: /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("code", { children: cxt.state.render(node.content, cxt) }) })];
+const CodeInlineRendererHTML = [CodeInline, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("span", { children: /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("code", { children: cxt.state.render(node.content, cxt) }) })];
+
+//#endregion
+//#region src/default/quotes.tsx
+const quoteBlock = new BlockModifierDefinition("quote", ModifierSlotType.Normal, { roleHint: "quote" });
+const epitaphBlock = new BlockModifierDefinition("epitaph", ModifierSlotType.Normal, { roleHint: "quote" });
+const calloutBlock = new BlockModifierDefinition("callout", ModifierSlotType.Normal, { roleHint: "quote" });
+const detailBlock = new BlockModifierDefinition("detail", ModifierSlotType.Normal, { roleHint: "quote" });
+const attributionBlock = new BlockModifierDefinition("by", ModifierSlotType.Normal, {
+	roleHint: "quote",
+	prepareExpand(node) {
+		let msgs = onlyPermitSingleBlock(node);
+		if (msgs) return msgs;
+		msgs = onlyPermitSimpleParagraphs(node);
+		if (msgs) return msgs;
+		node.state = true;
+		return [];
+	}
+});
+const QuoteBlocks = [
+	quoteBlock,
+	epitaphBlock,
+	calloutBlock,
+	detailBlock,
+	attributionBlock
+];
+const QuoteBlockRenderersHTML = [
+	[quoteBlock, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("blockquote", { children: cxt.state.render(node.content, cxt) })],
+	[epitaphBlock, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("blockquote", {
+		class: "epitaph",
+		children: cxt.state.render(node.content, cxt)
+	})],
+	[detailBlock, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("div", {
+		class: "detail",
+		children: cxt.state.render(node.content, cxt)
+	})],
+	[calloutBlock, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("aside", { children: cxt.state.render(node.content, cxt) })],
+	[attributionBlock, (node, cxt) => {
+		if (!node.state) return cxt.state.invalidBlock(node, "bad format");
+		let para = node.content[0];
+		return /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("p", {
+			class: "attribution",
+			children: cxt.state.render(para.content, cxt)
+		});
+	}]
+];
+
+//#endregion
+//#region src/default/inline-styles.tsx
+const emphasisInline = new InlineModifierDefinition("emphasis", ModifierSlotType.Normal, { roleHint: "emphasis" });
+const keywordInline = new InlineModifierDefinition("keyword", ModifierSlotType.Normal, { roleHint: "keyword" });
+const highlightInline = new InlineModifierDefinition("highlight", ModifierSlotType.Normal, { roleHint: "highlight" });
+const commentaryInline = new InlineModifierDefinition("commentary", ModifierSlotType.Normal, { roleHint: "commentary" });
+const sequenceInline = new InlineModifierDefinition("seq", ModifierSlotType.Normal, { roleHint: "pre" });
+const InlineStyles = [
+	emphasisInline,
+	keywordInline,
+	highlightInline,
+	commentaryInline,
+	sequenceInline
+];
+const InlineStyleRenderersHTML = [
+	[emphasisInline, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("em", { children: cxt.state.render(node.content, cxt) })],
+	[keywordInline, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("b", { children: cxt.state.render(node.content, cxt) })],
+	[highlightInline, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("mark", { children: cxt.state.render(node.content, cxt) })],
+	[commentaryInline, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("span", {
+		class: "commentary",
+		children: cxt.state.render(node.content, cxt)
+	})],
+	[sequenceInline, (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("span", {
+		class: "seq",
+		children: cxt.state.render(node.content, cxt)
+	})]
+];
+
+//#endregion
+//#region src/default/misc.tsx
+const rubyInline = new InlineModifierDefinition("ruby", ModifierSlotType.Normal, {
+	roleHint: void 0,
+	prepareExpand(node) {
+		let { msgs, args } = bindArgs(node, ["text"]);
+		if (msgs) return msgs;
+		node.state = args.text;
+		return [];
+	}
+});
+const linkInline = new InlineModifierDefinition("link", ModifierSlotType.Normal, {
+	roleHint: "link",
+	prepareExpand(node) {
+		let { msgs, args } = bindArgs(node, ["url"]);
+		if (msgs) return msgs;
+		node.state = args.url;
+		return [];
+	}
+});
+const tabInline = new InlineModifierDefinition("tab", ModifierSlotType.None);
+const styleBlock = new BlockModifierDefinition("style", ModifierSlotType.Normal, { prepareExpand(node) {
+	let { msgs, args } = bindArgs(node, ["style"]);
+	if (msgs) return msgs;
+	node.state = args.style;
+	return [];
+} });
+const breakBlock = new BlockModifierDefinition("break", ModifierSlotType.None);
+const linkBlock = new BlockModifierDefinition("link", ModifierSlotType.Normal, {
+	roleHint: "link",
+	prepareExpand(node) {
+		let { msgs, args } = bindArgs(node, ["url"]);
+		if (msgs) return msgs;
+		node.state = args.url;
+		return [];
+	}
+});
+const imageBlock = new BlockModifierDefinition("image", ModifierSlotType.Normal, {
+	roleHint: "link",
+	prepareExpand(node) {
+		let { msgs, args } = bindArgs(node, ["url"]);
+		if (msgs) return msgs;
+		msgs = onlyPermitSingleBlock(node, { optional: true });
+		if (msgs) return msgs;
+		msgs = onlyPermitSimpleParagraphs(node);
+		if (msgs) return msgs;
+		node.state = args.url;
+		return [];
+	}
+});
+const MiscInlines = [
+	rubyInline,
+	linkInline,
+	tabInline
+];
+const MiscBlocks = [
+	styleBlock,
+	breakBlock,
+	linkBlock,
+	imageBlock
+];
+const MiscInlineRenderersHTML = [
+	[rubyInline, (node, cxt) => node.state === void 0 ? cxt.state.invalidInline(node, "bad format") : /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsxs)("ruby", { children: [cxt.state.render(node.content, cxt), /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("rt", { children: node.state })] })],
+	[linkInline, (node, cxt) => node.state === void 0 ? cxt.state.invalidInline(node, "bad format") : /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("a", {
+		href: encodeURI(node.state),
+		children: cxt.state.render(node.content, cxt)
+	})],
+	[tabInline, () => new Text("	")]
+];
+const MiscBlockRenderersHTML = [
+	[styleBlock, (node, cxt) => node.state === void 0 ? cxt.state.invalidBlock(node, "bad format") : /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("div", {
+		class: `emmmstyle-${node.state}`,
+		style: "display:contents",
+		children: cxt.state.render(node.content, cxt)
+	})],
+	[breakBlock, () => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("hr", {})],
+	[linkBlock, (node, cxt) => {
+		if (node.state === void 0) return cxt.state.invalidBlock(node, "bad format");
+		const content = cxt.state.render(node.content, cxt);
+		return /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("a", {
+			href: encodeURI(node.state),
+			children: content.childElementCount > 0 ? content : node.state
+		});
+	}],
+	[imageBlock, (node, cxt) => {
+		if (node.state === void 0) return cxt.state.invalidBlock(node, "bad format");
+		let transformed;
+		try {
+			transformed = cxt.config.options.transformAsset(node.state);
+		} catch {
+			return cxt.state.invalidBlock(node, "unable to transform asset");
+		}
+		return /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsxs)("figure", { children: [transformed ? /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("img", {
+			src: transformed,
+			"data-original-src": node.state
+		}) : /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("img", { src: node.state }), node.content.length > 0 ? /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("figcaption", { children: cxt.state.render(node.content[0].content, cxt) }) : []] });
+	}]
+];
+
+//#endregion
+//#region src/default/table.tsx
+const table = Symbol();
+function initTable(cxt) {
+	cxt.init(table, { current: void 0 });
+}
+const tableBlock = new BlockModifierDefinition("table", ModifierSlotType.Normal, {
+	beforeParseContent(node, cxt, immediate) {
+		if (!immediate || node.state) return [];
+		const t = cxt.get(table);
+		if (t.current) return [new EntityNotAllowedMessage(node.location, "tables cannot be nested")];
+		node.state = {
+			status: "header",
+			header: [],
+			body: [],
+			footer: []
+		};
+		t.current = node.state;
+		debug.trace("entering table");
+		return [];
+	},
+	afterParseContent(_node, cxt) {
+		cxt.get(table).current = void 0;
+		debug.trace("leaving table");
+		return [];
+	}
+});
+const tableRowBlock = new BlockModifierDefinition("table-row", ModifierSlotType.Normal, { beforeProcessExpansion(node, cxt, immediate) {
+	if (!immediate) return [];
+	const t = cxt.get(table).current;
+	if (!t) return [new EntityNotAllowedMessage(node.location, "rows can only appear in tables")];
+	const newNode = stripNode(cloneNode(node));
+	debug.info("pushing table row\n", debugPrint.node(...newNode));
+	if (t.status == "header") t.header.push(...newNode);
+	if (t.status == "body") t.body.push(...newNode);
+	if (t.status == "footer") t.footer.push(...newNode);
+	return [];
+} });
+const tableSeparatorBlock = new BlockModifierDefinition("table-separator", ModifierSlotType.None, {
+	prepareExpand(node, cxt) {
+		const t = cxt.get(table).current;
+		if (!t) return [new EntityNotAllowedMessage(node.location, "separators can only appear in tables")];
+		if (t.status == "header") t.status = "body";
+		else if (t.status == "body") t.status = "footer";
+		else if (t.status == "footer") {}
+		debug.trace("table status ->", t.status);
+		return [];
+	},
+	expand() {
+		return [];
+	}
+});
+const tableCellBlock = new BlockModifierDefinition("table-cell", ModifierSlotType.Normal, { beforeProcessExpansion(node, cxt, immediate) {
+	if (!immediate) return [];
+	if (!cxt.get(table).current) return [new EntityNotAllowedMessage(node.location, "cells can only appear in tables")];
+	return [];
+} });
+const tableCellInline = new InlineModifierDefinition("table-cell", ModifierSlotType.Normal, { beforeProcessExpansion(node, cxt, immediate) {
+	if (!immediate) return [];
+	if (!cxt.get(table).current) return [new EntityNotAllowedMessage(node.location, "cells can only appear in tables")];
+	return [];
+} });
+const TableBlocks = [
+	tableBlock,
+	tableRowBlock,
+	tableCellBlock,
+	tableSeparatorBlock
+];
+const TableInlines = [tableCellInline];
+const TableBlockRenderers = [
+	[tableBlock, (node, cxt) => {
+		const t = node.state;
+		if (!t) return cxt.state.invalidBlock(node, "bad format");
+		return /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsxs)("table", { children: [
+			/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("thead", { children: cxt.state.render(t.header, cxt) }),
+			/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("tbody", { children: cxt.state.render(t.body, cxt) }),
+			/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("tfoot", { children: cxt.state.render(t.footer, cxt) })
+		] });
+	}],
+	[tableRowBlock, (node, cxt) => {
+		return /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("tr", { children: cxt.state.render(node.content, cxt) });
+	}],
+	[tableCellBlock, (node, cxt) => {
+		return /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("td", { children: cxt.state.render(node.content, cxt) });
+	}]
+];
+const TableInlineRenderers = [[tableCellInline, (node, cxt) => {
+	return /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("td", { children: cxt.state.render(node.content, cxt) });
+}]];
+
+//#endregion
+//#region src/default/gallery.tsx
+const GalleryBlock = new BlockModifierDefinition("gallery", ModifierSlotType.Normal, {});
+const GalleryBlockRendererHTML = [GalleryBlock, (node, cxt) => {
+	return /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("ul", {
+		class: "gallery",
+		children: (node.content[0].type == NodeType.Group && node.content.length == 1 ? node.content[0].content : node.content).map((x) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("li", { children: cxt.state.render([x], cxt) }))
+	});
+}];
+
+//#endregion
+//#region src/default/default.ts
+let config = Configuration.from(BuiltinConfiguration);
+config.initializers.push(initNotes, initHeadings, initTable);
+config.blockModifiers.add(...HeadingBlocks, ...BulletBlocks, CodeBlock, ...QuoteBlocks, ...MiscBlocks, ...NoteBlocks, ...TableBlocks, GalleryBlock);
+config.inlineModifiers.add(CodeInline, ...InlineStyles, ...MiscInlines, ...NoteInlines, ...TableInlines);
+config.systemModifiers.add(...NoteSystems);
+const DefaultConfiguration = Object.freeze(config);
+
+//#endregion
+//#region src/default/html-renderer.tsx
+var HTMLRenderState = class {
+	title = "";
+	stylesheet = "";
+	cssVariables = /* @__PURE__ */ new Map();
+	invalidBlock(node, msg) {
+		let name = NodeType[node.type];
+		if (node.type === NodeType.BlockModifier) name += ` (${node.mod.name})`;
+		return /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsxs)("details", {
+			class: "invalid",
+			children: [
+				/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsxs)("summary", { children: ["Invalid ", name] }),
+				/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("i", { children: msg }),
+				/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("pre", { children: debugPrint.node(node) })
+			]
+		});
+	}
+	invalidInline(node, msg) {
+		let name = NodeType[node.type];
+		if (node.type === NodeType.InlineModifier) name += ` (${node.mod.name})`;
+		return /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsxs)("details", {
+			class: "invalid",
+			children: [
+				/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsxs)("summary", { children: ["Invalid ", name] }),
+				/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("i", { children: msg }),
+				/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("pre", { children: debugPrint.node(node) })
+			]
+		});
+	}
+	render(elems, cxt) {
+		const document$1 = cxt.config.options.document;
+		(0, minimal_jsx_runtime_jsx_runtime.useDocument)(document$1);
+		let fragment = document$1.createDocumentFragment();
+		elems.flatMap((x) => cxt.renderEntity(x)).flat().forEach((x) => fragment.appendChild(x));
+		return fragment;
+	}
+};
+const htmlConfig = new RenderConfiguration({
+	document: globalThis.window.document,
+	headPlugins: [],
+	headerPlugins: [],
+	footerPlugins: [NotesFooterPlugin],
+	postprocessPlugins: [],
+	transformAsset: () => void 0
+}, (results, cxt) => {
+	let styles = cxt.state.stylesheet.replaceAll(/var\(--(.*?)\)/g, (m, c) => cxt.state.cssVariables.get(c) ?? m);
+	let doc = document.implementation.createHTMLDocument(cxt.state.title);
+	doc.head.append(/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("meta", { charset: "UTF-8" }), /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("style", { children: styles }), ...cxt.config.options.headPlugins.map((x) => x(cxt)).filter((x) => x !== void 0).flat());
+	doc.body.append(/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("section", {
+		class: "article-container",
+		children: /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsxs)("section", {
+			class: "article-body",
+			children: [
+				cxt.config.options.headerPlugins.map((x) => x(cxt)).filter((x) => x !== void 0),
+				results,
+				cxt.config.options.footerPlugins.map((x) => x(cxt)).filter((x) => x !== void 0)
+			]
+		})
+	}));
+	for (const p of cxt.config.options.postprocessPlugins) p(cxt, doc);
+	return doc;
+});
+htmlConfig.paragraphRenderer = (node, cxt) => /* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("p", { children: node.content.flatMap((x) => cxt.renderEntity(x)) });
+htmlConfig.textRenderer = (node, cxt) => {
+	switch (node.type) {
+		case NodeType.Preformatted: return new Text(node.content.text);
+		case NodeType.Text:
+		case NodeType.Escaped:
+			const split = node.content.split("\n");
+			const result = [];
+			for (let i = 0; i < split.length; i++) {
+				result.push(new Text(split[i]));
+				if (i < split.length - 1) result.push(/* @__PURE__ */ (0, minimal_jsx_runtime_jsx_runtime.jsx)("br", {}));
+			}
+			return result;
+		default: return debug.never(node);
+	}
+};
+htmlConfig.undefinedBlockRenderer = (node, cxt) => {
+	return cxt.state.invalidBlock(node, `No renderer defined! for ${node.mod.name}`);
+};
+htmlConfig.undefinedInlineRenderer = (node, cxt) => {
+	return cxt.state.invalidInline(node, `No renderer defined! for ${node.mod.name}`);
+};
+htmlConfig.addBlockRenderer(...HeadingBlockRenderersHTML, ...BulletBlockRenderersHTML, CodeBlockRendererHTML, ...QuoteBlockRenderersHTML, ...MiscBlockRenderersHTML, ...NoteBlockRenderersHTML, ...TableBlockRenderers, GalleryBlockRendererHTML);
+htmlConfig.addInlineRenderer(CodeInlineRendererHTML, ...InlineStyleRenderersHTML, ...MiscInlineRenderersHTML, ...NoteInlineRenderersHTML, ...TableInlineRenderers);
+const HTMLRenderConfiguration = htmlConfig;
+
+//#endregion
+//#region src/index.ts
+const emmmVersion = "0.0.6";
+function setDebugLevel(level) {
+	debug.level = level;
+}
+
+//#endregion
+exports.ArgumentInterpolatorDefinition = ArgumentInterpolatorDefinition;
+exports.BlockModifierDefinition = BlockModifierDefinition;
+exports.BuiltinConfiguration = BuiltinConfiguration;
+exports.Configuration = Configuration;
+exports.DebugLevel = DebugLevel;
+exports.DefaultConfiguration = DefaultConfiguration;
+exports.Document = Document;
+exports.HTMLRenderConfiguration = HTMLRenderConfiguration;
+exports.HTMLRenderState = HTMLRenderState;
+exports.InlineModifierDefinition = InlineModifierDefinition;
+exports.MessageSeverity = MessageSeverity;
+exports.ModifierSlotType = ModifierSlotType;
+exports.NodeType = NodeType;
+exports.ParseContext = ParseContext;
+exports.Parser = Parser;
+exports.RenderConfiguration = RenderConfiguration;
+exports.RenderContext = RenderContext;
+exports.SimpleScanner = SimpleScanner;
+exports.StringSource = StringSource;
+exports.SystemModifierDefinition = SystemModifierDefinition;
+exports.cloneNode = cloneNode;
+exports.cloneNodes = cloneNodes;
+exports.debugPrint = debugPrint;
+exports.emmmVersion = emmmVersion;
+Object.defineProperty(exports, 'helper', {
+  enumerable: true,
+  get: function () {
+    return modifier_helper_exports;
+  }
+});
+Object.defineProperty(exports, 'messages', {
+  enumerable: true,
+  get: function () {
+    return messages_exports;
+  }
+});
+exports.setDebugLevel = setDebugLevel;
+exports.stripNode = stripNode;
+//# sourceMappingURL=index.cjs.map