@the_dissidents/libemmm 0.0.2 → 0.0.3

package/dist/index.mjs

@@ -23,18 +23,19 @@ var NodeType = /* @__PURE__ */ ((NodeType2) => {
   NodeType2[NodeType2["Interpolation"] = 8] = "Interpolation";
   return NodeType2;
 })(NodeType || {});
-var ModifierFlags = /* @__PURE__ */ ((ModifierFlags2) => {
-  ModifierFlags2[ModifierFlags2["Normal"] = 0] = "Normal";
-  ModifierFlags2[ModifierFlags2["Preformatted"] = 1] = "Preformatted";
-  ModifierFlags2[ModifierFlags2["Marker"] = 2] = "Marker";
-  return ModifierFlags2;
-})(ModifierFlags || {});
+var ModifierSlotType = /* @__PURE__ */ ((ModifierSlotType2) => {
+  ModifierSlotType2[ModifierSlotType2["Normal"] = 0] = "Normal";
+  ModifierSlotType2[ModifierSlotType2["Preformatted"] = 1] = "Preformatted";
+  ModifierSlotType2[ModifierSlotType2["None"] = 2] = "None";
+  return ModifierSlotType2;
+})(ModifierSlotType || {});
 var ModifierBase = class {
-  constructor(name, flags = 0 /* Normal */, args) {
+  constructor(name, slotType = 0 /* Normal */, args) {
     this.name = name;
-    this.flags = flags;
+    this.slotType = slotType;
     if (args) Object.assign(this, args);
   }
+  roleHint;
   delayContentExpansion = false;
   alwaysTryExpand = false;
   beforeParseContent;
@@ -59,158 +60,433 @@ var ArgumentInterpolatorDefinition = class {
   alwaysTryExpand = false;
   expand;
 };
-var ParseContext = class {
-  constructor(config, variables = /* @__PURE__ */ new Map()) {
-    this.config = config;
-    this.variables = variables;
-    config.initializers.forEach((x) => x(this));
+
+// 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]));
+    }
   }
-  data = {};
-  init(key, obj) {
-    assert(!(key in this.data));
-    this.data[key] = obj;
+  toArray() {
+    return this.array.map(({ v }) => v);
   }
-  set(key, obj) {
-    assert(key in this.data);
-    this.data[key] = obj;
+  toSet() {
+    return new Set(this.toArray());
   }
-  get(key) {
-    assert(key in this.data);
-    return this.data[key];
+  get(name) {
+    return this.data.get(name);
   }
-};
-var Document = class {
-  constructor(root, context, messages) {
-    this.root = root;
-    this.context = context;
-    this.messages = messages;
+  has(name) {
+    return this.data.has(name);
+  }
+  remove(name) {
+    let i = this.data.get(name);
+    assert(i !== 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 });
+    }
   }
-  debugPrint(source) {
-    return debugDumpDocument(this, source);
+  find(predicate) {
+    const result = this.array.find((x) => predicate(x.v));
+    return result ? result.v : void 0;
   }
 };
-var Configuration = class {
-  initializers = [];
-  blockModifiers;
-  inlineModifiers;
-  systemModifiers;
-  argumentInterpolators;
-  reparseDepthLimit = 10;
-  constructor(from) {
-    this.blockModifiers = new NameManager(from?.blockModifiers);
-    this.inlineModifiers = new NameManager(from?.inlineModifiers);
-    this.systemModifiers = new NameManager(from?.systemModifiers);
-    this.argumentInterpolators = new NameManager(from?.argumentInterpolators);
-    if (from) {
-      this.initializers = [...from.initializers];
-      this.reparseDepthLimit = from.reparseDepthLimit;
+function assert(x) {
+  if (!!!x) {
+    let error = new Error("assertion failed");
+    console.log(error.stack);
+    throw error;
+  }
+}
+function linePositions(src) {
+  let result = [0];
+  [...src].forEach((x, i) => {
+    if (x == "\n") result.push(i + 1);
+  });
+  result.push(Infinity);
+  return result;
+}
+var cloneArgument = (arg, options) => ({
+  location: clonePosition(arg.location, options),
+  content: arg.content.map((ent) => {
+    switch (ent.type) {
+      case 3 /* Text */:
+      case 4 /* Escaped */:
+        return structuredClone(ent);
+      case 8 /* Interpolation */:
+        return {
+          type: ent.type,
+          location: clonePosition(arg.location, options),
+          definition: ent.definition,
+          argument: cloneArgument(ent.argument, options),
+          expansion: ent.expansion
+        };
+      default:
+        return debug.never(ent);
+    }
+  })
+});
+function clonePosition(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 7 /* BlockModifier */:
+    case 6 /* InlineModifier */:
+    case 5 /* SystemModifier */:
+      return {
+        location: clonePosition(node.location, options),
+        type: node.type,
+        mod: node.mod,
+        state: options.withState ? node.state : void 0,
+        head: structuredClone(node.head),
+        arguments: node.arguments.map((x) => cloneArgument(x, options)),
+        content: node.content.map((x) => cloneNode(x, options)),
+        expansion: node.expansion ? cloneNodes(node.expansion, options) : void 0
+      };
+    case 0 /* Root */:
+      return {
+        type: node.type,
+        source: node.source,
+        content: node.content.map((x) => cloneNode(x, options))
+      };
+    case 1 /* Paragraph */:
+      return {
+        type: node.type,
+        location: clonePosition(node.location, options),
+        content: node.content.map((x) => cloneNode(x, options))
+      };
+    case 2 /* Preformatted */:
+    case 3 /* Text */:
+    case 4 /* Escaped */:
+      return structuredClone(node);
+    default:
+      return debug.never(node);
+  }
+}
+function cloneNodes(nodes, options = {}) {
+  return nodes.map((x) => cloneNode(x, options));
+}
+function stripNode(...nodes) {
+  return nodes.flatMap((node) => {
+    switch (node.type) {
+      case 2 /* Preformatted */:
+      case 3 /* Text */:
+      case 4 /* Escaped */:
+        return [node];
+      case 7 /* BlockModifier */:
+      case 6 /* InlineModifier */:
+        if (node.expansion !== void 0)
+          return node.expansion.flatMap((x) => stripNode(x));
+      // else fallthrough!
+      case 1 /* Paragraph */:
+      case 0 /* Root */:
+        node.content = node.content.flatMap((x) => stripNode(x));
+        return [node];
+      case 5 /* SystemModifier */:
+        return [];
+      default:
+        return debug.never(node);
     }
+  });
+}
+
+// src/debug.ts
+var DebugLevel = /* @__PURE__ */ ((DebugLevel3) => {
+  DebugLevel3[DebugLevel3["Trace"] = 0] = "Trace";
+  DebugLevel3[DebugLevel3["Info"] = 1] = "Info";
+  DebugLevel3[DebugLevel3["Warning"] = 2] = "Warning";
+  DebugLevel3[DebugLevel3["Error"] = 3] = "Error";
+  DebugLevel3[DebugLevel3["None"] = 4] = "None";
+  return DebugLevel3;
+})(DebugLevel || {});
+var debug = {
+  level: 1 /* Info */,
+  trace(arg0, ...args) {
+    if (this.level > 0 /* Trace */) return;
+    if (typeof arg0 == "function") arg0 = arg0();
+    console.info("TRACE", arg0, ...args);
+  },
+  info(arg0, ...args) {
+    if (this.level > 1 /* Info */) return;
+    if (typeof arg0 == "function") arg0 = arg0();
+    console.info(" INFO", arg0, ...args);
+  },
+  warning(arg0, ...args) {
+    if (this.level > 2 /* Warning */) return;
+    if (typeof arg0 == "function") arg0 = arg0();
+    console.warn(" WARN", arg0, ...args);
+  },
+  error(arg0, ...args) {
+    if (this.level > 3 /* Error */) return;
+    if (typeof arg0 == "function") arg0 = arg0();
+    console.error("ERROR", arg0, ...args);
+  },
+  never(_) {
+    assert(false);
+  }
+};
+
+// src/scanner.ts
+var SimpleScanner = class {
+  constructor(src, source = { name: "<input>" }) {
+    this.src = src;
+    this.source = source;
+  }
+  pos = 0;
+  position() {
+    return this.pos;
+  }
+  isEOF() {
+    return this.pos >= this.src.length;
+  }
+  peek(str) {
+    assert(str !== "");
+    let next = this.pos + str.length;
+    if (next > 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;
   }
 };
 
+// src/debug-print.ts
+var debugPrint = {
+  blockModifier: (x) => `[.${x.name}] (${ModifierSlotType[x.slotType]})`,
+  inlineModifier: (x) => `[/${x.name}] (${ModifierSlotType[x.slotType]})`,
+  inlineShorthand: (x) => x.name + x.parts.map((x2, i) => ` .. <arg${i}> .. ${x2}`).join("") + (x.mod.slotType == 2 /* None */ ? "" : ` .. <slot> .. ${x.postfix ?? "<no postfix>"}`),
+  blockShorthand: (x) => x.name + x.parts.map((x2, i) => ` .. <arg${i}> .. ${x2}`).join("") + (x.mod.slotType == 2 /* None */ ? "" : ` .. <slot> .. ${x.postfix ?? "<no postfix>"}`),
+  argument: (arg) => arg.content.map(debugPrintArgEntity).join(""),
+  node: (...nodes) => nodes.map((x) => debugPrintNode(x)).join("\n"),
+  message: (m, source, descriptor) => debugPrintMsg(m, descriptor, source),
+  document: debugDumpDocument
+};
+function debugPrintArgEntity(node) {
+  switch (node.type) {
+    case 3 /* Text */:
+      return node.content;
+    case 4 /* Escaped */:
+      return `<Escaped:${node.content}>`;
+    case 8 /* 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, prefix2 = "") {
+    let dumps = content.map((x) => debugPrintNode(x, prefix2 + "  ")).filter((x) => x.length > 0);
+    if (dumps.length == 0) return "";
+    return dumps.map((x) => `${prefix2}  ${x}`).join("\n");
+  }
+  let result = `<${NodeType[node.type]}@${node.location.start}`;
+  switch (node.type) {
+    case 1 /* Paragraph */:
+      const content = debugPrintNodes(node.content, prefix);
+      if (content.length > 0)
+        result += `>
+${content}
+${prefix}</${NodeType[node.type]}@${node.location.end}>`;
+      else result += `-${node.location.end} />`;
+      break;
+    case 4 /* Escaped */:
+      result += `>
+${prefix}  ${node.content}
+${prefix}</${NodeType[node.type]}@${node.location.end}>`;
+      break;
+    case 2 /* Preformatted */:
+      result += `>
+${prefix}  ${node.content.text}
+${prefix}</${NodeType[node.type]}@${node.location.end}>`;
+      break;
+    case 6 /* InlineModifier */:
+    case 7 /* BlockModifier */:
+    case 5 /* SystemModifier */:
+      const args = node.arguments.map((x, i) => `
+${prefix}    (${i})@${x.location.start}-${x.location.end}=${debugPrint.argument(x)}`).join("");
+      if (node.content.length > 0) {
+        result += ` id=${node.mod.name}${args}>
+` + debugPrintNodes(node.content, prefix) + `
+${prefix}</${NodeType[node.type]}@${node.location.end}>`;
+      } else result += `-${node.location.end} id=${node.mod.name}${args} />`;
+      if (node.expansion) {
+        const content2 = debugPrintNodes(node.expansion, prefix);
+        if (content2.length > 0)
+          result += `
+${prefix}<expansion>
+${content2}
+${prefix}</expansion>`;
+        else if (node.type != 5 /* SystemModifier */)
+          result += `
+${prefix}<expansion />`;
+      }
+      break;
+    case 3 /* Text */:
+      return node.content;
+    default:
+      return debug.never(node);
+  }
+  return result;
+}
+function debugPrintMsg(m, descriptor, source) {
+  let pos = (pos2) => `@${pos2}`;
+  if (source) {
+    const lines = linePositions(source);
+    pos = (pos2) => {
+      let line = -1, linepos = 0;
+      for (let i = 1; i < lines.length; i++) {
+        if (lines[i] > pos2) {
+          line = i;
+          linepos = lines[i - 1];
+          break;
+        }
+      }
+      return `l${line}c${pos2 - linepos + 1}`;
+    };
+  }
+  let loc = m.location;
+  let result = `at ${pos(loc.start)}-${pos(loc.end)}: ${MessageSeverity[m.severity]}[${m.code}]: ${m.info}`;
+  if (descriptor && m.location.source !== descriptor) {
+    result += `
+warning: source descriptor mismatch: ${m.location.source.name}`;
+  }
+  while (loc = loc.original) {
+    let d = loc.source !== m.location.source ? `(in ${loc.source.name}) ` : "";
+    result += `
+---> original at: ${d}${pos(loc.start)}-${pos(loc.end)}`;
+  }
+  return result;
+}
+function debugDumpDocument(doc, source) {
+  let root = debugPrint.node(...doc.root.content);
+  let msgs = doc.messages.map((x) => debugPrintMsg(x, doc.root.source, source)).join("\n");
+  if (msgs.length > 0) msgs += "\n";
+  return `Document: ${doc.root.source.name}
+${msgs}${root}`;
+}
+
 // src/messages.ts
 var messages_exports = {};
 __export(messages_exports, {
   ArgumentCountMismatchMessage: () => ArgumentCountMismatchMessage,
   CannotExpandArgumentMessage: () => CannotExpandArgumentMessage,
-  CannotPopNotationMessage: () => CannotPopNotationMessage,
+  CannotUseModuleInSelfMessage: () => CannotUseModuleInSelfMessage,
   ContentShouldBeOnNewlineMessage: () => ContentShouldBeOnNewlineMessage,
+  EitherNormalOrPreMessage: () => EitherNormalOrPreMessage,
+  EntityNotAllowedMessage: () => EntityNotAllowedMessage,
   ExpectedMessage: () => ExpectedMessage,
-  InlineDefinitonInvalidEntityMessage: () => InlineDefinitonInvalidEntityMessage,
   InvalidArgumentMessage: () => InvalidArgumentMessage,
+  MultipleBlocksNotPermittedMessage: () => MultipleBlocksNotPermittedMessage,
   NameAlreadyDefinedMessage: () => NameAlreadyDefinedMessage,
   NewBlockShouldBeOnNewlineMessage: () => NewBlockShouldBeOnNewlineMessage,
+  NoNestedModuleMessage: () => NoNestedModuleMessage,
+  OnlySimpleParagraphsPermittedMessage: () => OnlySimpleParagraphsPermittedMessage,
+  OverwriteDefinitionsMessage: () => OverwriteDefinitionsMessage,
   ReachedRecursionLimitMessage: () => ReachedRecursionLimitMessage,
-  ReferredMessage: () => ReferredMessage,
   SlotUsedOutsideDefinitionMessage: () => SlotUsedOutsideDefinitionMessage,
   UnclosedInlineModifierMessage: () => UnclosedInlineModifierMessage,
   UndefinedVariableMessage: () => UndefinedVariableMessage,
   UnknownModifierMessage: () => UnknownModifierMessage,
   UnnecessaryNewlineMessage: () => UnnecessaryNewlineMessage
 });
-var ReferredMessage = class {
-  constructor(original, position, length) {
-    this.original = original;
-    this.position = position;
-    this.length = length;
-  }
-  get severity() {
-    return this.original.severity;
-  }
-  get info() {
-    return this.original.info;
-  }
-  get code() {
-    return this.original.code;
-  }
-  fixes = [];
-};
 var AddThingMessage = class {
-  constructor(code, severity, position, length, info, fixstr, what) {
+  constructor(code, severity, location, info) {
     this.code = code;
     this.severity = severity;
-    this.position = position;
-    this.length = length;
+    this.location = location;
     this.info = info;
-    this.fixstr = fixstr;
-    this.what = what;
-  }
-  get fixes() {
-    let [pos, what, fixstr] = [this.position, this.what, this.fixstr];
-    return [{
-      get info() {
-        return fixstr;
-      },
-      apply(src, cursor) {
-        let newCursor = cursor < pos ? cursor : cursor + what.length;
-        return [src.substring(0, pos) + what + src.substring(pos), newCursor];
-      }
-    }];
   }
+  // get fixes(): readonly FixSuggestion[] {
+  //     let [start, what, fixstr] = [this.location.start, this.what, this.fixstr];
+  //     return [{
+  //         get info() { return fixstr; },
+  //         apply(src: string, cursor: number) {
+  //             let newCursor = (cursor < start) 
+  //                 ? cursor 
+  //                 : cursor + what.length;
+  //             return [src.substring(0, start) + what + src.substring(start), newCursor];
+  //         }
+  //     }];
+  // }
 };
 var RemoveThingMessage = class {
-  constructor(code, severity, position, length, info, fixstr) {
+  constructor(code, severity, location, info) {
     this.code = code;
     this.severity = severity;
-    this.position = position;
-    this.length = length;
+    this.location = location;
     this.info = info;
-    this.fixstr = fixstr;
-  }
-  get fixes() {
-    let [pos, len, fixstr] = [this.position, this.length, this.fixstr];
-    return [{
-      get info() {
-        return fixstr;
-      },
-      apply(src, cursor) {
-        let newCursor = cursor < pos + len && cursor >= pos ? pos : cursor - len;
-        return [src.substring(0, pos) + src.substring(pos + len), newCursor];
-      }
-    }];
   }
+  // get fixes(): readonly FixSuggestion[] {
+  //     let [start, end, fixstr] = [this.start, this.end, this.fixstr];
+  //     return [{
+  //         get info() { return fixstr; },
+  //         apply(src: string, cursor: number) {
+  //             let newCursor = (cursor < end && cursor >= start) 
+  //                 ? start 
+  //                 : cursor; // Removing text, cursor shouldn't shift if it's outside the removed range
+  //             return [src.substring(0, start) + src.substring(end), newCursor];
+  //         }
+  //     }];
+  // }
 };
 var ExpectedMessage = class {
-  constructor(position, what) {
-    this.position = position;
+  constructor(location, what) {
+    this.location = location;
     this.what = what;
+    assert(location.end == location.start);
   }
   code = 1;
   severity = 2 /* Error */;
-  get length() {
-    return 0;
-  }
   get info() {
     return `expected '${this.what}'`;
   }
-  get fixes() {
-    return [];
-  }
 };
 var UnknownModifierMessage = class {
-  constructor(position, length, what) {
-    this.position = position;
-    this.length = length;
+  constructor(location, what) {
+    this.location = location;
     this.what = what;
   }
   code = 2;
@@ -218,36 +494,34 @@ var UnknownModifierMessage = class {
   get info() {
     return `unknown modifier '${this.what}'; did you forget to escape it?`;
   }
-  get fixes() {
-    let [pos, len] = [this.position, this.length];
-    return [{
-      get info() {
-        return "this is not a modifier -- escape it";
-      },
-      apply(src, cursor) {
-        let newCursor = cursor < pos ? cursor : cursor + 1;
-        return [src.substring(0, pos) + "\\" + src.substring(pos), newCursor];
-      }
-    }];
-  }
+  // get fixes(): readonly FixSuggestion[] {
+  //     let [start, end] = [this.start, this.end];
+  //     return [{
+  //         get info() { return 'this is not a modifier -- escape it'; },
+  //         apply(src: string, cursor: number) {
+  //             let newCursor = (cursor < start) 
+  //                 ? cursor 
+  //                 : cursor + 1;
+  //             return [src.substring(0, start) + '\\' + src.substring(start), newCursor];
+  //         }
+  //     }];
+  // }
 };
 var UnclosedInlineModifierMessage = class {
-  constructor(position, what) {
-    this.position = position;
+  constructor(location, what) {
+    this.location = location;
     this.what = what;
+    assert(location.end == location.start);
   }
   code = 3;
   severity = 2 /* Error */;
-  length = 0;
-  fixes = [];
   get info() {
     return `unclosed inline modifier ${this.what}'`;
   }
 };
 var ArgumentCountMismatchMessage = class {
-  constructor(position, length, min, max) {
-    this.position = position;
-    this.length = length;
+  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`;
@@ -259,449 +533,235 @@ var ArgumentCountMismatchMessage = class {
   msg = "";
   code = 4;
   severity = 2 /* Error */;
-  fixes = [];
   get info() {
     return `argument count mismatch` + this.msg;
   }
 };
 var CannotExpandArgumentMessage = class {
-  constructor(position, length, what) {
-    this.position = position;
-    this.length = length;
+  constructor(location, what) {
+    this.location = location;
     this.what = what;
   }
   code = 5;
   severity = 2 /* Error */;
-  fixes = [];
   get info() {
     return `failed to expand argument` + (this.what === void 0 ? "" : `: ${this.what}`);
   }
 };
 var InvalidArgumentMessage = class {
-  constructor(position, length, what) {
-    this.position = position;
-    this.length = length;
+  constructor(location, what) {
+    this.location = location;
     this.what = what;
   }
   code = 6;
   severity = 2 /* Error */;
-  fixes = [];
   get info() {
     return `invalid argument` + (this.what === void 0 ? "" : `: ${this.what}`);
   }
 };
-var InlineDefinitonInvalidEntityMessage = class {
-  constructor(position, length) {
-    this.position = position;
-    this.length = length;
+var EntityNotAllowedMessage = class {
+  constructor(location, what) {
+    this.location = location;
+    this.what = what;
   }
   code = 7;
   severity = 2 /* Error */;
-  fixes = [];
   get info() {
-    return `Invalid entity in inline modifier definition`;
+    return "This entity is not allowed here" + (this.what ? `: ${this.what}` : "");
   }
 };
 var ReachedRecursionLimitMessage = class {
-  constructor(position, length, limit, what) {
-    this.position = position;
-    this.length = length;
+  constructor(location, limit, what) {
+    this.location = location;
     this.limit = limit;
     this.what = what;
   }
   code = 8;
   severity = 2 /* Error */;
-  fixes = [];
   get info() {
     return `Reached recursion limit ${this.limit} when expanding ${this.what}`;
   }
 };
 var SlotUsedOutsideDefinitionMessage = class {
-  constructor(position, length) {
-    this.position = position;
-    this.length = length;
+  constructor(location) {
+    this.location = location;
   }
   code = 9;
   severity = 2 /* Error */;
-  fixes = [];
   get info() {
     return `slot used outside a definition`;
   }
 };
-var CannotPopNotationMessage = class {
-  constructor(position, length) {
-    this.position = position;
-    this.length = length;
+var NoNestedModuleMessage = class {
+  constructor(location) {
+    this.location = location;
   }
   code = 10;
   severity = 2 /* Error */;
-  fixes = [];
   get info() {
-    return `cannot pop notation`;
+    return `nested module definitions not allowed`;
+  }
+};
+var CannotUseModuleInSelfMessage = class {
+  constructor(location) {
+    this.location = location;
+  }
+  code = 11;
+  severity = 2 /* Error */;
+  get info() {
+    return `cannot use the same module inside its definition`;
+  }
+};
+var EitherNormalOrPreMessage = class {
+  constructor(location) {
+    this.location = location;
+  }
+  code = 12;
+  severity = 2 /* Error */;
+  get info() {
+    return `a definition cannot be at once normal and preformatted`;
+  }
+};
+var MultipleBlocksNotPermittedMessage = class {
+  constructor(location) {
+    this.location = location;
+  }
+  code = 13;
+  severity = 2 /* Error */;
+  get info() {
+    return `multiple blocks are not permitted here`;
+  }
+};
+var OnlySimpleParagraphsPermittedMessage = class {
+  constructor(location) {
+    this.location = location;
+  }
+  code = 14;
+  severity = 2 /* Error */;
+  get info() {
+    return `Only simple paragraphs are permitted here`;
   }
 };
 var UnnecessaryNewlineMessage = class extends RemoveThingMessage {
-  constructor(pos, len) {
+  constructor(location) {
     super(
       1,
       1 /* Warning */,
-      pos,
-      len,
-      "more than one newlines have the same effect as one",
-      "remove the redundant newlines"
+      location,
+      "more than one newlines have the same effect as one"
     );
   }
 };
 var NewBlockShouldBeOnNewlineMessage = class extends AddThingMessage {
-  constructor(pos) {
+  constructor(location) {
     super(
       2,
       1 /* Warning */,
-      pos,
-      0,
-      "a new block should begin in a new line to avoid confusion",
-      "add a line break",
-      "\n"
+      location,
+      "a new block should begin in a new line to avoid confusion"
     );
   }
 };
 var ContentShouldBeOnNewlineMessage = class extends AddThingMessage {
-  constructor(pos) {
+  constructor(location) {
     super(
       3,
       1 /* Warning */,
-      pos,
-      0,
-      "the content should begin in a new line to avoid confusion",
-      "add a line break",
-      "\n"
+      location,
+      "the content should begin in a new line to avoid confusion"
     );
   }
 };
 var NameAlreadyDefinedMessage = class {
-  constructor(position, length, what) {
-    this.position = position;
-    this.length = length;
+  constructor(location, what) {
+    this.location = location;
     this.what = what;
   }
   code = 4;
   severity = 1 /* Warning */;
-  fixes = [];
   get info() {
     return `name is already defined, will overwrite: ${this.what}`;
   }
 };
 var UndefinedVariableMessage = class {
-  constructor(position, length, what) {
-    this.position = position;
-    this.length = length;
+  constructor(location, what) {
+    this.location = location;
     this.what = what;
   }
   code = 5;
   severity = 1 /* Warning */;
-  fixes = [];
   get info() {
     return `variable is undefined, will expand to empty string: ${this.what}`;
   }
 };
-
-// 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 {
-      assert(Array.isArray(from));
-      this.array = from.map((x) => ({ k: x.name, v: x }));
-      this.array.sort((a, b) => b.k.length - a.k.length);
-      this.data = new Map(from.map((x) => [x.name, x]));
-    }
-  }
-  toArray() {
-    return this.array.map(({ v }) => v);
-  }
-  get(name) {
-    return this.data.get(name);
-  }
-  has(name) {
-    return this.data.has(name);
-  }
-  remove(name) {
-    let i = this.data.get(name);
-    assert(i !== 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 = new Error("assertion failed");
-    console.log(error.stack);
-    throw error;
-  }
-}
-function has(v, f) {
-  return (v & f) === f;
-}
-function linePositions(src) {
-  let result = [0];
-  [...src].forEach((x, i) => {
-    if (x == "\n") result.push(i + 1);
-  });
-  result.push(Infinity);
-  return result;
-}
-var cloneArgument = (arg) => ({
-  start: arg.start,
-  end: arg.end,
-  content: arg.content.map((ent) => {
-    switch (ent.type) {
-      case 3 /* Text */:
-      case 4 /* Escaped */:
-        return structuredClone(ent);
-      case 8 /* Interpolation */:
-        return {
-          type: ent.type,
-          start: ent.start,
-          end: ent.end,
-          definition: ent.definition,
-          argument: cloneArgument(ent.argument),
-          expansion: ent.expansion
-        };
-      default:
-        return debug.never(ent);
-    }
-  })
-});
-function cloneNode(node, referring) {
-  switch (node.type) {
-    case 7 /* BlockModifier */:
-    case 6 /* InlineModifier */:
-    case 5 /* SystemModifier */:
-      return {
-        start: node.start,
-        end: node.end,
-        type: node.type,
-        mod: node.mod,
-        state: void 0,
-        head: structuredClone(node.head),
-        arguments: node.arguments.map(cloneArgument),
-        content: node.content.map((x) => cloneNode(x, referring)),
-        expansion: node.expansion ? cloneNodes(node.expansion) : void 0
-      };
-    case 0 /* Root */:
-    case 1 /* Paragraph */:
-      return {
-        type: node.type,
-        start: node.start,
-        end: node.end,
-        content: node.content.map((x) => cloneNode(x))
-      };
-    case 2 /* Preformatted */:
-    case 3 /* Text */:
-    case 4 /* Escaped */:
-      return structuredClone(node);
-    default:
-      return debug.never(node);
-  }
-}
-function cloneNodes(nodes) {
-  return nodes.map((x) => cloneNode(x));
-}
-function debugPrintArgEntity(node) {
-  switch (node.type) {
-    case 3 /* Text */:
-      return node.content;
-    case 4 /* Escaped */:
-      return `<Escaped:${node.content}>`;
-    case 8 /* Interpolation */:
-      return `<Interp:${node.definition.name}-${node.definition.postfix}:${debugPrintArgument(node.argument)}${node.expansion ? `=${node.expansion}` : ""}>`;
-    default:
-      return debug.never(node);
-  }
-}
-function debugPrintArgument(arg) {
-  return arg.content.map(debugPrintArgEntity).join("");
-}
-function debugPrintNode(node, prefix = "") {
-  let result = `<${NodeType[node.type]}@${node.start}`;
-  switch (node.type) {
-    case 0 /* Root */:
-    case 1 /* Paragraph */:
-      const content = debugPrintNodes(node.content, prefix);
-      if (content.length > 0)
-        result += `>
-${content}
-${prefix}</${NodeType[node.type]}@${node.end}>`;
-      else result += `-${node.end} />`;
-      break;
-    case 4 /* Escaped */:
-    case 2 /* Preformatted */:
-      result += `>
-${prefix}  ${node.content}
-${prefix}</${NodeType[node.type]}@${node.end}>`;
-      break;
-    case 6 /* InlineModifier */:
-    case 7 /* BlockModifier */:
-    case 5 /* SystemModifier */:
-      const args = node.arguments.map((x, i) => `
-${prefix}    (${i})@${x.start}-${x.end}=${debugPrintArgument(x)}`).join("");
-      if (node.content.length > 0) {
-        result += ` id=${node.mod.name}${args}>
-` + debugPrintNodes(node.content, prefix) + `
-${prefix}</${NodeType[node.type]}@${node.end}>`;
-      } else result += `-${node.end} id=${node.mod.name}${args} />`;
-      if (node.expansion) {
-        const content2 = debugPrintNodes(node.expansion, prefix);
-        if (content2.length > 0)
-          result += `
-${prefix}<expansion>
-${content2}
-${prefix}</expansion>`;
-        else if (node.type != 5 /* SystemModifier */)
-          result += `
-${prefix}<expansion />`;
-      }
-      break;
-    case 3 /* Text */:
-      return node.content;
-    default:
-      return debug.never(node);
-  }
-  return result;
-}
-function debugPrintNodes(content, prefix = "") {
-  let dumps = content.map((x) => debugPrintNode(x, prefix + "  ")).filter((x) => x.length > 0);
-  if (dumps.length == 0) return "";
-  return dumps.map((x) => `${prefix}  ${x}`).join("\n");
-}
-function debugDumpDocument(doc, source) {
-  const lines = linePositions(source);
-  function pos2lc(pos) {
-    let line = -1, linepos = 0;
-    for (let i = 1; i < lines.length; i++) {
-      if (lines[i] > pos) {
-        line = i;
-        linepos = lines[i - 1];
-        break;
-      }
-    }
-    return `l${line}c${pos - linepos + 1}`;
-  }
-  function dumpMsg(m) {
-    let result = `at ${pos2lc(m.position)}, len ${m.length}: ${MessageSeverity[m.severity]}[${m.code}]: ${m.info}`;
-    while (m instanceof ReferredMessage) {
-      m = m.original;
-      result += `
----> original at: ${pos2lc(m.position)}, len ${m.length}`;
-    }
-    return result;
+var OverwriteDefinitionsMessage = class {
+  constructor(location, what) {
+    this.location = location;
+    this.what = what;
   }
-  let root = debugPrintNode(doc.root);
-  let msgs = doc.messages.map(dumpMsg).join("\n");
-  if (msgs.length > 0) msgs += "\n";
-  return `${msgs}${root}`;
-}
-
-// src/debug.ts
-var DebugLevel = /* @__PURE__ */ ((DebugLevel3) => {
-  DebugLevel3[DebugLevel3["Trace"] = 0] = "Trace";
-  DebugLevel3[DebugLevel3["Info"] = 1] = "Info";
-  DebugLevel3[DebugLevel3["Warning"] = 2] = "Warning";
-  DebugLevel3[DebugLevel3["Error"] = 3] = "Error";
-  DebugLevel3[DebugLevel3["None"] = 4] = "None";
-  return DebugLevel3;
-})(DebugLevel || {});
-var debug = {
-  level: 1 /* Info */,
-  trace(arg0, ...args) {
-    if (this.level > 0 /* Trace */) return;
-    if (typeof arg0 == "function") arg0 = arg0();
-    console.info("TRACE", arg0, ...args);
-  },
-  info(arg0, ...args) {
-    if (this.level > 1 /* Info */) return;
-    if (typeof arg0 == "function") arg0 = arg0();
-    console.info(" INFO", arg0, ...args);
-  },
-  warning(arg0, ...args) {
-    if (this.level > 2 /* Warning */) return;
-    if (typeof arg0 == "function") arg0 = arg0();
-    console.warn(" WARN", arg0, ...args);
-  },
-  error(arg0, ...args) {
-    if (this.level > 3 /* Error */) return;
-    if (typeof arg0 == "function") arg0 = arg0();
-    console.error("ERROR", arg0, ...args);
-  },
-  never(_) {
-    assert(false);
+  code = 6;
+  severity = 1 /* Warning */;
+  get info() {
+    return `using this module will overwrite: ${this.what}`;
   }
 };
 
-// src/front.ts
-var SimpleScanner = class {
-  constructor(src) {
-    this.src = src;
-  }
-  pos = 0;
-  position() {
-    return this.pos;
-  }
-  isEOF() {
-    return this.pos >= this.src.length;
+// src/parser-config.ts
+var ParseContext = class {
+  constructor(config2, variables = /* @__PURE__ */ new Map()) {
+    this.config = config2;
+    this.variables = variables;
+    config2.initializers.forEach((x) => x(this));
   }
-  peek(str) {
-    let next = this.pos + str.length;
-    if (next > this.src.length) return false;
-    return this.src.slice(this.pos, this.pos + str.length) == str;
+  data = {};
+  init(key, obj) {
+    assert(!(key in this.data));
+    this.data[key] = obj;
   }
-  acceptChar() {
-    if (this.isEOF()) throw new RangeError("EOF");
-    let char = this.src[this.pos];
-    this.pos++;
-    return char;
+  set(key, obj) {
+    assert(key in this.data);
+    this.data[key] = obj;
   }
-  accept(str) {
-    if (!this.peek(str)) return false;
-    this.pos += str.length;
-    return true;
+  get(key) {
+    assert(key in this.data);
+    return this.data[key];
   }
-  acceptWhitespaceChar() {
-    if (this.isEOF()) return null;
-    let char = this.src[this.pos];
-    if (!" 	".includes(char)) return null;
-    this.pos++;
-    return char;
+};
+var Document = class _Document {
+  constructor(root, context, messages) {
+    this.root = root;
+    this.context = context;
+    this.messages = messages;
   }
-  acceptUntil(str) {
-    let start = this.pos;
-    while (!this.isEOF()) {
-      if (this.peek(str)) {
-        let result = this.src.slice(start, this.pos);
-        return result;
-      }
-      this.pos++;
-    }
-    return null;
+  toStripped() {
+    let doc = new _Document(
+      stripNode(cloneNode(this.root, { withState: true }))[0],
+      this.context,
+      this.messages
+    );
+    return doc;
+  }
+};
+var Configuration = class _Configuration {
+  initializers = [];
+  blockModifiers = new NameManager();
+  inlineModifiers = new NameManager();
+  systemModifiers = new NameManager();
+  argumentInterpolators = new NameManager();
+  blockShorthands = new NameManager();
+  inlineShorthands = new NameManager();
+  reparseDepthLimit = 10;
+  static from(from) {
+    let config2 = new _Configuration();
+    config2.initializers = [...from.initializers];
+    config2.reparseDepthLimit = from.reparseDepthLimit;
+    config2.blockModifiers = new NameManager(from.blockModifiers);
+    config2.inlineModifiers = new NameManager(from.inlineModifiers);
+    config2.systemModifiers = new NameManager(from.systemModifiers);
+    config2.argumentInterpolators = new NameManager(from.argumentInterpolators);
+    config2.blockShorthands = new NameManager(from.blockShorthands);
+    config2.inlineShorthands = new NameManager(from.inlineShorthands);
+    return config2;
   }
 };
 
@@ -722,31 +782,20 @@ var UnknownModifier = {
 var EmitEnvironment = class {
   constructor(scanner) {
     this.scanner = scanner;
+    this.root = { type: 0 /* Root */, source: scanner.source, content: [] };
   }
-  root = { type: 0 /* Root */, start: 0, end: -1, content: [] };
+  root;
   messages = [];
-  blockStack = [this.root];
+  blockStack = [];
   inlineStack = [];
-  referringStack = [];
   message(...m) {
-    const referringReverse = [...this.referringStack].reverse();
     for (let msg of m) {
-      for (const range of referringReverse)
-        msg = new ReferredMessage(msg, range.start, range.end - range.start);
       this.messages.push(msg);
       debug.trace("issued msg", msg.code, msg.info);
     }
   }
-  pushReferring(start, end) {
-    this.referringStack.push({ start, end });
-  }
-  popReferring() {
-    assert(this.referringStack.length > 0);
-    this.referringStack.pop();
-  }
   addBlockNode(n) {
-    assert(this.blockStack.length > 0);
-    this.blockStack.at(-1).content.push(n);
+    (this.blockStack.at(-1) ?? this.root).content.push(n);
     return n;
   }
   addInlineNode(n) {
@@ -760,11 +809,14 @@ var EmitEnvironment = class {
     const last = content.at(-1);
     if (last?.type == 3 /* Text */) {
       last.content += str;
-      last.end = this.scanner.position();
+      last.location.end = this.scanner.position();
     } else content.push({
       type: 3 /* Text */,
-      start: this.scanner.position() - str.length,
-      end: this.scanner.position(),
+      location: {
+        source: this.scanner.source,
+        start: this.scanner.position() - str.length,
+        end: this.scanner.position()
+      },
       content: str
     });
   }
@@ -773,9 +825,9 @@ var EmitEnvironment = class {
     this.blockStack.push(block);
   }
   endBlock() {
-    assert(this.blockStack.length >= 2);
+    assert(this.blockStack.length > 0);
     const node = this.blockStack.pop();
-    node.end = this.scanner.position();
+    node.location.end = this.scanner.position();
   }
   startInline(n) {
     if (n.type == 1 /* Paragraph */) this.addBlockNode(n);
@@ -785,19 +837,32 @@ var EmitEnvironment = class {
   endInline() {
     assert(this.inlineStack.length > 0);
     const node = this.inlineStack.pop();
-    node.end = this.scanner.position();
+    node.location.end = this.scanner.position();
   }
 };
 var Parser = class {
-  constructor(scanner, config) {
+  constructor(scanner, cxt) {
     this.scanner = scanner;
+    this.cxt = cxt;
     this.emit = new EmitEnvironment(scanner);
-    this.cxt = new ParseContext(config);
   }
   emit;
-  cxt;
   delayDepth = 0;
   groupDepth = 0;
+  #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()
+    };
+  }
   #defs(type) {
     switch (type) {
       case 5 /* SystemModifier */:
@@ -897,30 +962,23 @@ var Parser = class {
       node.expansion = node.mod.expand(node, this.cxt, immediate);
       if (!node.expansion) {
         return true;
-      } else if (node.expansion.length > 0) {
-        debug.trace(`${this.delayDepth > 0 ? "early " : ""}expanding:`, node.mod.name);
-        debug.trace(() => "-->\n" + debugPrintNodes(node.expansion, "  "));
-      } else {
-        debug.trace(`${this.delayDepth > 0 ? "early " : ""}expanding:`, node.mod.name);
       }
+      debug.trace(`${this.delayDepth > 0 ? "early " : ""}expanding:`, node.mod.name);
+      if (node.expansion.length > 0)
+        debug.trace(() => "-->\n" + debugPrint.node(...node.expansion));
     }
     const expansion = node.expansion ?? node.content;
     if (expansion.length == 0) return true;
     if (node.mod.beforeProcessExpansion)
       this.emit.message(...node.mod.beforeProcessExpansion(node, this.cxt, immediate));
-    this.emit.pushReferring(node.start, node.end);
     let ok = this.#reparse(expansion, depth);
-    this.emit.popReferring();
     if (node.mod.afterProcessExpansion)
       this.emit.message(...node.mod.afterProcessExpansion(node, this.cxt, immediate));
     if (!ok && depth == 0) {
       const limit = this.cxt.config.reparseDepthLimit;
-      this.emit.message(new ReachedRecursionLimitMessage(
-        node.start,
-        node.end - node.start,
-        limit,
-        node.mod.name
-      ));
+      this.emit.message(
+        new ReachedRecursionLimitMessage(node.location, limit, node.mod.name)
+      );
     }
     return ok;
   }
@@ -928,15 +986,18 @@ var Parser = class {
     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() {
-    while (this.scanner.acceptWhitespaceChar() !== null) {
-    }
+    this.WHITESPACES();
     if (!this.scanner.accept("\n")) this.emit.message(
-      new ContentShouldBeOnNewlineMessage(this.scanner.position())
+      new ContentShouldBeOnNewlineMessage(this.#loc())
     );
   }
   // TODO: this is awkward and doesn't emit messages in the most appropriate way
@@ -952,7 +1013,7 @@ var Parser = class {
     }
     const end = this.scanner.position();
     if (nlines > n) this.emit.message(
-      new UnnecessaryNewlineMessage(start, end - start)
+      new UnnecessaryNewlineMessage(this.#locFrom(start, end))
     );
   }
   DOCUMENT() {
@@ -972,6 +1033,8 @@ var Parser = class {
       this.MODIFIER(5 /* SystemModifier */);
       return;
     }
+    const short = this.cxt.config.blockShorthands.find((x) => this.scanner.accept(x.name));
+    if (short) return this.SHORTHAND(7 /* BlockModifier */, short);
     this.MAYBE_GROUPED_PARAGRAPH();
   }
   MODIFIER(type) {
@@ -992,71 +1055,29 @@ var Parser = class {
         name += this.scanner.acceptChar();
       }
       this.emit.message(
-        new UnknownModifierMessage(posStart, this.scanner.position() - posStart, name)
+        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 = has(mod.flags, 2 /* Marker */);
-    const isMarker = flagMarker || endsign;
+    const flagMarker = mod.slotType == 2 /* None */;
     if (!this.scanner.accept(MODIFIER_CLOSE_SIGN))
-      this.emit.message(new ExpectedMessage(
-        this.scanner.position(),
-        MODIFIER_CLOSE_SIGN
-      ));
+      this.emit.message(
+        new ExpectedMessage(this.#loc(), MODIFIER_CLOSE_SIGN)
+      );
     const headEnd = this.scanner.position();
     const node = {
       type,
       mod,
-      head: { start: posStart, end: headEnd },
+      head: this.#locFrom(posStart, headEnd),
+      location: this.#locFrom(posStart, headEnd),
       arguments: args,
-      start: posStart,
-      end: headEnd,
       content: [],
       expansion: void 0
     };
-    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 (type === 6 /* InlineModifier */) this.emit.addInlineNode(node);
-      else this.emit.addBlockNode(node);
-    } else if (type == 6 /* InlineModifier */) {
-      this.emit.startInline(node);
-      const entity = has(mod.flags, 1 /* Preformatted */) ? this.PREFORMATTED_INLINE_ENTITY.bind(this) : this.INLINE_ENTITY.bind(this);
-      while (true) {
-        if (this.scanner.accept(MODIFIER_INLINE_END_TAG)) break;
-        if (this.scanner.isEOF() || !(ok = entity())) {
-          this.emit.message(new UnclosedInlineModifierMessage(
-            this.scanner.position(),
-            mod.name
-          ));
-          break;
-        }
-      }
-      this.emit.endInline();
-    } else {
-      this.emit.startBlock(node);
-      this.WARN_IF_MORE_NEWLINES_THAN(1);
-      if (!this.scanner.isEOF()) {
-        if (has(mod.flags, 1 /* Preformatted */))
-          this.PRE_PARAGRAPH();
-        else
-          this.BLOCK_ENTITY();
-      }
-      this.emit.endBlock();
-    }
-    const last = node.content.at(-1);
-    node.actualEnd = last?.actualEnd ?? last?.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;
+    const isMarker = flagMarker || endsign;
+    return this.MODIFIER_BODY(type, node, MODIFIER_INLINE_END_TAG, isMarker);
   }
   // also handles "grouped" (delimited) pre-paragraphs
   PRE_PARAGRAPH() {
@@ -1075,10 +1096,9 @@ var Parser = class {
           white += char;
         if (grouped && this.scanner.accept(GROUP_END) || !grouped && this.scanner.accept("\n")) break;
         if (this.scanner.isEOF()) {
-          if (grouped) this.emit.message(new ExpectedMessage(
-            this.scanner.position(),
-            GROUP_END
-          ));
+          if (grouped) this.emit.message(
+            new ExpectedMessage(this.#loc(), GROUP_END)
+          );
           break;
         }
         string += white;
@@ -1089,8 +1109,7 @@ var Parser = class {
     }
     const node = {
       type: 2 /* Preformatted */,
-      start: posStart,
-      end: this.scanner.position(),
+      location: this.#locFrom(posStart),
       content: {
         start: posContentStart,
         end: posContentEnd,
@@ -1113,54 +1132,128 @@ var Parser = class {
         this.BLOCK_ENTITY();
         this.WARN_IF_MORE_NEWLINES_THAN(1);
       }
-      this.emit.message(new ExpectedMessage(
-        this.scanner.position(),
-        GROUP_END
-      ));
+      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 == 3 /* Text */)
+      first.content = first.content.trimStart();
+    if (last.type == 3 /* Text */)
+      last.content = last.content.trimEnd();
+  }
   PARAGRAPH() {
     assert(!this.scanner.isEOF());
     const node = {
       type: 1 /* Paragraph */,
-      start: this.scanner.position(),
-      end: -1,
+      location: this.#loc(),
       content: []
     };
-    debug.trace("PARSE para");
     this.emit.startInline(node);
     while (!this.scanner.isEOF() && this.INLINE_ENTITY()) {
     }
     this.emit.endInline();
     const last = node.content.at(-1);
-    node.actualEnd = last?.actualEnd ?? last?.end;
-    debug.trace("PARSE para end");
+    node.location.actualEnd = last?.location.actualEnd ?? last?.location.end;
+    this.#trimNode(node);
+  }
+  // returns false if breaking out of paragraph
+  SHORTHAND(type, d) {
+    const posStart = this.scanner.position() - d.name.length;
+    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, headEnd),
+      location: this.#locFrom(posStart, headEnd),
+      arguments: args,
+      content: [],
+      expansion: void 0
+    };
+    const isMarker = node.mod.slotType == 2 /* 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 (type === 6 /* InlineModifier */) this.emit.addInlineNode(node);
+      else this.emit.addBlockNode(node);
+    } else if (type == 6 /* InlineModifier */) {
+      node = node;
+      this.emit.startInline(node);
+      const pre = node.mod.slotType == 1 /* 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 == 1 /* 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;
   }
   // returns false if breaking out of paragraph
   INLINE_ENTITY() {
     assert(!this.scanner.isEOF());
-    if (this.scanner.peek(MODIFIER_BLOCK_OPEN)) {
-      this.emit.message(new NewBlockShouldBeOnNewlineMessage(this.scanner.position()));
-      return false;
-    }
-    if (this.scanner.peek(MODIFIER_INLINE_OPEN)) {
+    if (this.scanner.peek(MODIFIER_INLINE_OPEN))
       return this.MODIFIER(6 /* InlineModifier */);
-    }
-    if (this.scanner.peek(MODIFIER_SYSTEM_OPEN)) {
+    if (this.scanner.peek(MODIFIER_SYSTEM_OPEN))
       return false;
-    }
+    const short = this.cxt.config.inlineShorthands.find((x) => this.scanner.accept(x.name));
+    if (short) return this.SHORTHAND(6 /* InlineModifier */, short);
     if (this.scanner.accept("\\")) {
       if (this.scanner.isEOF()) {
         this.emit.addString("\\");
         return true;
       }
+      const start = this.scanner.position();
       const node = {
         type: 4 /* Escaped */,
-        start: this.scanner.position() - 1,
         content: this.scanner.acceptChar(),
-        end: this.scanner.position()
+        location: this.#locFrom(start - 1)
       };
       this.emit.addInlineNode(node);
       return true;
@@ -1171,9 +1264,8 @@ var Parser = class {
   PREFORMATTED_INLINE_ENTITY() {
     assert(!this.scanner.isEOF());
     if (this.scanner.accept("\n")) {
-      while (this.scanner.acceptWhitespaceChar() !== null) {
-      }
-      if (this.scanner.peek(MODIFIER_BLOCK_OPEN) || this.scanner.peek(MODIFIER_SYSTEM_OPEN) || this.scanner.peek(GROUP_END) && this.groupDepth > 0 || this.scanner.isEOF()) return false;
+      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.groupDepth > 0 || this.scanner.isEOF()) return false;
       if (this.scanner.accept("\n")) {
         this.WARN_IF_MORE_NEWLINES_THAN(0);
         return false;
@@ -1184,7 +1276,8 @@ var Parser = class {
     this.emit.addString(this.scanner.acceptChar());
     return true;
   }
-  ARGUMENT_CONTENT(end) {
+  // returns argument and isOk
+  ARGUMENT_CONTENT(end = void 0, close = [MODIFIER_END_SIGN, MODIFIER_CLOSE_SIGN]) {
     let ok = true;
     const content = [];
     const posStart = this.scanner.position();
@@ -1193,25 +1286,22 @@ var Parser = class {
       const last = content.at(-1);
       if (last?.type == 3 /* Text */) {
         last.content += s;
-        last.end += s.length;
+        last.location.end += s.length;
       } else {
         const end2 = this.scanner.position();
         content.push({
           type: 3 /* Text */,
-          end: end2,
-          start: end2 - s.length,
+          location: this.#locFrom(end2 - s.length),
           content: s
         });
       }
     };
     while (true) {
-      if (end !== void 0 && this.scanner.accept(end))
+      if (end && this.scanner.accept(end))
         break;
-      if (this.scanner.accept(":")) {
-        ok = end === void 0;
+      if (end === void 0 && this.scanner.accept(":"))
         break;
-      }
-      if (this.scanner.peek(MODIFIER_END_SIGN) || this.scanner.peek(MODIFIER_CLOSE_SIGN) || this.scanner.isEOF()) {
+      if (close.find((x) => this.scanner.peek(x)) || this.scanner.isEOF()) {
         ok = false;
         break;
       }
@@ -1225,8 +1315,7 @@ var Parser = class {
         content.push({
           type: 4 /* Escaped */,
           content: this.scanner.acceptChar(),
-          start: posEnd - 1,
-          end: posEnd + 1
+          location: this.#locFrom(posEnd - 1)
         });
         continue;
       }
@@ -1241,11 +1330,10 @@ var Parser = class {
           type: 8 /* Interpolation */,
           definition: result,
           argument: inner,
-          start: beforeInterp,
-          end: posEnd
+          location: this.#locFrom(beforeInterp)
         });
         if (!ok2) {
-          this.emit.message(new ExpectedMessage(posEnd, result.postfix));
+          this.emit.message(new ExpectedMessage(this.#loc(), result.postfix));
           ok = false;
           break;
         }
@@ -1255,8 +1343,7 @@ var Parser = class {
       }
     }
     return [{
-      start: posStart,
-      end: posEnd,
+      location: this.#locFrom(posStart, posEnd),
       content
     }, ok];
   }
@@ -1277,24 +1364,171 @@ var Parser = class {
     return list;
   }
 };
-function parse(scanner, config) {
-  return new Parser(scanner, config).parse();
+function parse(scanner, cxt) {
+  return new Parser(scanner, cxt).parse();
 }
 
+// src/renderer.ts
+var RenderContext = class {
+  constructor(config2, parseContext, state) {
+    this.config = config2;
+    this.parseContext = parseContext;
+    this.state = state;
+  }
+  renderEntity(node) {
+    switch (node.type) {
+      case 1 /* Paragraph */:
+        return this.config.paragraphRenderer?.(node, this);
+      case 2 /* Preformatted */:
+      case 3 /* Text */:
+      case 4 /* Escaped */:
+        return this.config.textRenderer?.(node, this);
+      case 6 /* InlineModifier */:
+        let ir = this.config.inlineRenderers.get(node.mod);
+        if (ir) return ir(node, this);
+        return this.config.undefinedInlineRenderer?.(node, this);
+      case 7 /* BlockModifier */:
+        let br = this.config.blockRenderers.get(node.mod);
+        if (br) return br(node, this);
+        return this.config.undefinedBlockRenderer?.(node, this);
+      case 5 /* SystemModifier */:
+        return void 0;
+      default:
+        return debug.never(node);
+    }
+  }
+};
+var RenderConfiguration = class _RenderConfiguration {
+  constructor(options, postprocessor) {
+    this.options = options;
+    this.postprocessor = postprocessor;
+  }
+  paragraphRenderer;
+  textRenderer;
+  undefinedBlockRenderer;
+  undefinedInlineRenderer;
+  blockRenderers = /* @__PURE__ */ new Map();
+  inlineRenderers = /* @__PURE__ */ new Map();
+  render(doc, state) {
+    let cxt = new RenderContext(this, doc.context, state);
+    let results = doc.toStripped().root.content.map((x) => cxt.renderEntity(x)).filter((x) => x !== void 0);
+    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 config2 = new _RenderConfiguration(from.options, from.postprocessor);
+    config2.paragraphRenderer = from.paragraphRenderer;
+    config2.textRenderer = from.textRenderer;
+    config2.undefinedBlockRenderer = from.undefinedBlockRenderer;
+    config2.undefinedInlineRenderer = from.undefinedInlineRenderer;
+    config2.inlineRenderers = new Map(from.inlineRenderers);
+    config2.blockRenderers = new Map(from.blockRenderers);
+    return config2;
+  }
+};
+
 // src/modifier-helper.ts
 function checkArgumentLength(node, min, max = min) {
   if (min !== void 0 && node.arguments.length < min || max !== void 0 && node.arguments.length > max) {
-    return [new ArgumentCountMismatchMessage(node.head.start, node.head.end - node.head.start, min, max)];
+    return [new ArgumentCountMismatchMessage({
+      source: node.location.source,
+      start: node.head.start,
+      end: node.head.end
+    }, min, max)];
   }
   return null;
 }
 function checkArguments(node, min, max = min) {
   const arg = node.arguments.find((x) => x.expansion === void 0);
   if (arg !== void 0) {
-    return [new CannotExpandArgumentMessage(arg.start, arg.end - arg.start)];
+    return [new CannotExpandArgumentMessage(arg.location)];
   }
   return checkArgumentLength(node, min, max);
 }
+function onlyPermitPlaintextParagraph(node) {
+  function checkInline(ents) {
+    let result = "";
+    for (const ent of ents) {
+      switch (ent.type) {
+        case 3 /* Text */:
+        case 4 /* Escaped */:
+          result += ent.content;
+          break;
+        case 5 /* SystemModifier */:
+          break;
+        case 6 /* 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 check(ent) {
+    if (ent.type == 7 /* BlockModifier */) {
+      if (!ent.expansion) return [new EntityNotAllowedMessage(
+        ent.location,
+        "it does not expand to plain text"
+      )];
+      if (ent.expansion.length == 0) return "";
+      else if (ent.expansion.length > 1) {
+        let last = ent.expansion.at(-1).location;
+        return [new MultipleBlocksNotPermittedMessage({
+          source: last.source,
+          start: ent.expansion[1].location.start,
+          end: last.actualEnd ?? last.end
+        })];
+      }
+      return check(ent.expansion[0]);
+    } else if (ent.type !== 1 /* Paragraph */) {
+      return [new OnlySimpleParagraphsPermittedMessage(ent.location)];
+    }
+    return checkInline(ent.content);
+  }
+  return check(node);
+}
+function onlyPermitSimpleParagraphs(node) {
+  function check(nodes) {
+    for (let ent of nodes) {
+      if (ent.type == 7 /* BlockModifier */ && ent.expansion !== void 0) {
+        const cs = check(ent.expansion);
+        if (cs) return cs;
+      } else if (ent.type !== 1 /* Paragraph */) {
+        return [new OnlySimpleParagraphsPermittedMessage(ent.location)];
+      }
+    }
+    return null;
+  }
+  return check(node.content);
+}
+function onlyPermitSingleBlock(node) {
+  function check(nodes) {
+    if (nodes.length > 1) {
+      let 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 === 7 /* BlockModifier */ && nodes[0].expansion !== void 0) {
+      return check(nodes[0].expansion);
+    }
+    return null;
+  }
+  return check(node.content);
+}
 
 // src/builtin/internal.ts
 var builtins = Symbol();
@@ -1302,358 +1536,706 @@ function initParseContext(cxt) {
   cxt.init(builtins, {
     blockSlotDelayedStack: [],
     inlineSlotDelayedStack: [],
-    blockSlotData: [],
-    inlineSlotData: [],
-    notationStack: []
+    blockInstantiationData: [],
+    inlineInstantiationData: [],
+    modules: /* @__PURE__ */ new Map(),
+    usedModules: /* @__PURE__ */ new Set(),
+    insideModule: void 0
   });
 }
-function customModifier(type, name, argNames, slotName, content) {
-  debug.info(`registered custom ${type} modifier:`, name);
-  debug.info("args:", argNames, `with ${slotName == "" ? "no slot name" : "slot name: " + slotName}`);
-  debug.trace(() => "content is\n" + debugPrintNodes(content));
-  const mod = type == 7 /* BlockModifier */ ? new BlockModifierDefinition(name, 0 /* Normal */) : new InlineModifierDefinition(name, 0 /* Normal */);
+function customModifier(type, name, signature, content) {
+  debug.info(`created custom ${NodeType[type]}:`, name);
+  debug.info("args:", signature.args, `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 ? 2 /* None */ : signature.preformatted ? 1 /* Preformatted */ : 0 /* Normal */;
+  const mod = type == 7 /* BlockModifier */ ? new BlockModifierDefinition(name, flag) : new InlineModifierDefinition(name, flag);
   const isInline = type == 6 /* InlineModifier */;
+  if (content.length == 1 && (content[0].type == 7 /* BlockModifier */ || content[0].type == 6 /* InlineModifier */))
+    mod.roleHint = content[0].mod.roleHint;
   mod.delayContentExpansion = true;
   mod.prepareExpand = (node, cxt) => {
-    let check = checkArguments(node, argNames.length);
+    let check = checkArguments(node, signature.args.length);
     if (check) return check;
     node.state = {
       ok: true,
-      args: new Map(node.arguments.map((x, i) => [argNames[i], x.expansion]))
+      args: new Map(node.arguments.map((x, i) => [signature.args[i], x.expansion]))
     };
     return [];
   };
-  mod.expand = (node, cxt) => {
+  mod.expand = (node) => {
     if (!node.state?.ok) return [];
-    const contentClone = cloneNodes(content);
+    const contentClone = cloneNodes(content, { newLocation: node.location });
     return contentClone;
   };
   mod.beforeProcessExpansion = (node, cxt) => {
     if (!node.state?.ok) return [];
     const store = cxt.get(builtins);
-    const data = isInline ? store.inlineSlotData : store.blockSlotData;
-    data.push([slotName, {
+    const data = isInline ? store.inlineInstantiationData : store.blockInstantiationData;
+    data.push({
+      slotName: signature.slotName,
       mod,
       args: node.state.args,
       slotContent: node.content
-    }]);
+    });
     debug.trace(
-      `pushed ${type} slot data for`,
+      `pushed ${NodeType[type]} slot data for`,
       name,
-      slotName == "" ? "(unnamed)" : `= ${slotName}`
+      signature.slotName == "" ? "(unnamed)" : `= ${signature.slotName}`
     );
     return [];
   };
   mod.afterProcessExpansion = (node, cxt) => {
-    if (!node.state?.ok) return [];
+    if (!node.state?.ok || signature.slotName === void 0) return [];
     const store = cxt.get(builtins);
-    const data = isInline ? store.inlineSlotData : store.blockSlotData;
+    const data = isInline ? store.inlineInstantiationData : store.blockInstantiationData;
     const pop = data.pop();
-    assert(pop !== void 0 && pop[0] == slotName);
+    assert(pop !== void 0);
     debug.trace(
-      `popped ${type} slot data for`,
+      `popped ${NodeType[type]} slot data for`,
       name,
-      slotName == "" ? "(unnamed)" : `= ${slotName}`
+      signature.slotName == "" ? "(unnamed)" : `= ${signature.slotName}`
     );
     return [];
   };
   return mod;
 }
-
-// src/builtin/define-block.ts
-var DefineBlockMod = new SystemModifierDefinition("define-block", 0 /* Normal */, {
-  // .define-block:name:args...[:(slot-id)]
-  delayContentExpansion: true,
-  alwaysTryExpand: true,
-  beforeParseContent(node, cxt) {
-    const check = checkArgumentLength(node, 1, Infinity);
-    if (check) return check;
-    const msgs = [];
-    const name = node.arguments[0];
-    const nameValue = name.expansion;
-    let slotName = "";
-    if (node.arguments.length > 1) {
-      const last = node.arguments.at(-1);
-      if (last.expansion)
-        slotName = /^\(.+\)$/.test(last.expansion) ? last.expansion.substring(1, last.expansion.length - 1) : "";
-      else msgs.push(
-        new InvalidArgumentMessage(last.start, last.end - last.start)
-      );
+function makeInlineDefinition(node, msgs) {
+  let lastIsParagraph = false;
+  let concat = [];
+  for (const n of node.content) {
+    switch (n.type) {
+      case 1 /* Paragraph */:
+        if (!lastIsParagraph) {
+          lastIsParagraph = true;
+          concat.push(...n.content);
+          continue;
+        }
+      case 2 /* Preformatted */:
+      case 7 /* BlockModifier */:
+        msgs.push(new EntityNotAllowedMessage(n.location));
+        break;
+      case 5 /* SystemModifier */:
+        lastIsParagraph = false;
+        concat.push(n);
+        break;
+      default:
+        debug.never(n);
     }
-    const args = node.arguments.slice(1, slotName !== "" ? node.arguments.length - 1 : void 0).map((x) => {
-      if (!x.expansion) msgs.push(
-        new InvalidArgumentMessage(x.start, x.end - x.start)
-      );
-      return x.expansion ?? "";
-    });
-    node.state = { name: nameValue, slotName, args, msgs };
-    const store = cxt.get(builtins);
-    store.blockSlotDelayedStack.push(node.state.slotName);
-    debug.trace("entering block definition:", node.state.name);
-    return [];
-  },
-  afterParseContent(node, cxt) {
-    if (!node.state) return [];
-    const store = cxt.get(builtins);
-    assert(store.blockSlotDelayedStack.pop() == node.state.slotName);
-    debug.trace("leaving block definition", node.state.name);
-    return [];
-  },
-  prepareExpand(node, cxt, immediate) {
-    if (!immediate || !node.state) return [];
-    const arg = node.arguments[0];
-    if (!node.state.name)
-      return [new InvalidArgumentMessage(arg.start, arg.end - arg.start)];
-    if (cxt.config.blockModifiers.has(node.state.name))
-      return [new NameAlreadyDefinedMessage(
-        arg.start,
-        arg.end - arg.start,
-        node.state.name
-      )];
-    return [];
-  },
-  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(
+  }
+  return concat;
+}
+
+// src/builtin/define-modifier.ts
+function parseDefineArguments(node, stack) {
+  const check = checkArgumentLength(node, 1, Infinity);
+  if (check) return check;
+  const msgs = [];
+  const name = node.arguments[0];
+  const nameValue = name.expansion;
+  if (nameValue === "" || nameValue?.includes("\n")) return [
+    new InvalidArgumentMessage(name.location, nameValue)
+  ];
+  let slotName = "";
+  if (node.arguments.length > 1) {
+    const last = node.arguments.at(-1);
+    if (last.expansion) {
+      const match = /^\((.*)\)$/.exec(last.expansion);
+      slotName = match ? match[1] : "";
+    } else msgs.push(
+      new InvalidArgumentMessage(last.location)
+    );
+  }
+  const args = node.arguments.slice(1, slotName !== "" ? node.arguments.length - 1 : void 0).map((x) => {
+    if (!x.expansion) msgs.push(
+      new InvalidArgumentMessage(x.location)
+    );
+    return x.expansion ?? "";
+  });
+  let signature = { slotName, args, preformatted: void 0 };
+  node.state = { name: nameValue, signature, msgs };
+  stack.push(signature);
+  return void 0;
+}
+var DefineBlockMod = new SystemModifierDefinition(
+  "define-block",
+  0 /* Normal */,
+  {
+    // .define-block:name:args...[:(slot-id)]
+    delayContentExpansion: true,
+    alwaysTryExpand: true,
+    beforeParseContent(node, cxt) {
+      const store = cxt.get(builtins);
+      const check = parseDefineArguments(node, store.blockSlotDelayedStack);
+      if (check) return check;
+      debug.trace("entering block definition:", node.state.name);
+      return [];
+    },
+    afterParseContent(node, cxt) {
+      if (!node.state) return [];
+      const store = cxt.get(builtins);
+      const pop = store.blockSlotDelayedStack.pop();
+      assert(pop === node.state.signature);
+      debug.trace("leaving block definition", node.state.name);
+      return [];
+    },
+    prepareExpand(node, cxt, immediate) {
+      if (!immediate || !node.state) return [];
+      const arg = node.arguments[0];
+      const msgs = node.state.msgs;
+      if (!node.state.name)
+        msgs.push(new InvalidArgumentMessage(arg.location));
+      else if (cxt.config.blockModifiers.has(node.state.name))
+        msgs.push(new NameAlreadyDefinedMessage(arg.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(
           7 /* BlockModifier */,
           node.state.name,
-          node.state.args,
-          node.state.slotName,
+          node.state.signature,
           node.content
-        )
-      );
+        ));
+      }
+      return [];
+    }
+  }
+);
+var DefineInlineMod = new SystemModifierDefinition(
+  "define-inline",
+  0 /* Normal */,
+  {
+    // .define-inline name:args...[:(slot-id)]
+    delayContentExpansion: true,
+    alwaysTryExpand: true,
+    beforeParseContent(node, cxt) {
+      const store = cxt.get(builtins);
+      const check = parseDefineArguments(node, store.inlineSlotDelayedStack);
+      if (check) return check;
+      debug.trace("entering inline definition:", node.state.name);
+      return [];
+    },
+    afterParseContent(node, cxt) {
+      if (!node.state) return [];
+      const store = cxt.get(builtins);
+      const pop = store.inlineSlotDelayedStack.pop();
+      assert(pop === node.state.signature);
+      debug.trace("leaving inline definition", node.state.name);
+      return [];
+    },
+    prepareExpand(node, cxt, immediate) {
+      if (!immediate || !node.state) return [];
+      const arg = node.arguments[0];
+      if (!node.state.name)
+        return [new InvalidArgumentMessage(arg.location)];
+      const msgs = node.state.msgs;
+      if (cxt.config.inlineModifiers.has(node.state.name))
+        msgs.push(new NameAlreadyDefinedMessage(arg.location, node.state.name));
+      node.state.definition = makeInlineDefinition(node, 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(
+            6 /* InlineModifier */,
+            node.state.name,
+            node.state.signature,
+            node.state.definition
+          )
+        );
+      }
+      return [];
     }
-    return [];
   }
-});
+);
 
-// src/builtin/define-inline.ts
-var DefineInlineMod = new SystemModifierDefinition("define-inline", 0 /* Normal */, {
-  // .define-inline name:args...[:(slot-id)]
-  delayContentExpansion: true,
-  alwaysTryExpand: true,
-  beforeParseContent(node, cxt) {
-    const check = checkArgumentLength(node, 1, Infinity);
-    if (check) return check;
-    const msgs = [];
-    const name = node.arguments[0];
-    const nameValue = name.expansion;
-    if (nameValue && cxt.config.inlineModifiers.has(nameValue))
-      msgs.push(new NameAlreadyDefinedMessage(
-        node.start,
-        name.end - name.start,
-        nameValue
-      ));
-    let slotName = "";
-    if (node.arguments.length > 1) {
-      const last = node.arguments.at(-1);
-      if (last.expansion)
-        slotName = /^\(.+\)$/.test(last.expansion) ? last.expansion.substring(1, last.expansion.length - 1) : "";
-      else msgs.push(
-        new InvalidArgumentMessage(last.start, last.end - last.start)
-      );
-    }
-    const args = node.arguments.slice(1, slotName !== "" ? node.arguments.length - 1 : void 0).map((x) => {
-      if (!x.expansion) msgs.push(
-        new InvalidArgumentMessage(x.start, x.end - x.start)
-      );
-      return x.expansion ?? "";
-    });
-    node.state = { name: nameValue, slotName, args, msgs };
-    const store = cxt.get(builtins);
-    store.inlineSlotDelayedStack.push(node.state.slotName);
-    debug.trace("entering inline definition:", node.state.name);
-    return [];
-  },
-  afterParseContent(node, cxt) {
-    if (!node.state) return [];
-    const store = cxt.get(builtins);
-    assert(store.inlineSlotDelayedStack.pop() == node.state.slotName);
-    debug.trace("leaving inline definition", node.state.name);
-    return [];
-  },
-  prepareExpand(node, cxt, immediate) {
-    if (!immediate || !node.state) return [];
-    const arg = node.arguments[0];
-    if (!node.state.name)
-      return [new InvalidArgumentMessage(arg.start, arg.end - arg.start)];
-    const msgs = [];
-    if (cxt.config.inlineModifiers.has(node.state.name))
-      msgs.push(new NameAlreadyDefinedMessage(
-        arg.start,
-        arg.end - arg.start,
-        node.state.name
-      ));
-    let lastIsParagraph = false;
-    let concat = [];
-    for (const n of node.content) {
-      switch (n.type) {
-        case 1 /* Paragraph */:
-          if (!lastIsParagraph) {
-            lastIsParagraph = true;
-            concat.push(...n.content);
-            continue;
+// src/builtin/define-shorthand.ts
+function parseDefineArguments2(type, node, stack) {
+  const check = checkArguments(node, 1, Infinity);
+  if (check) return check;
+  const msgs = [];
+  const name = node.arguments[0];
+  const nameValue = name.expansion;
+  if (nameValue === "" || nameValue?.includes("\n")) return [
+    new InvalidArgumentMessage(name.location, nameValue)
+  ];
+  let slotName = void 0;
+  let parts = [];
+  let postfix = void 0;
+  let i = 1;
+  while (i < node.arguments.length) {
+    const arg = node.arguments[i];
+    const match = /^\((.*)\)$/.exec(arg.expansion);
+    if (match) {
+      slotName = match[1];
+      i++;
+      if (type == 6 /* InlineModifier */) {
+        if (i < node.arguments.length) {
+          if (node.arguments[i].expansion === "") {
+            msgs.push(new InvalidArgumentMessage(
+              node.arguments[i].location,
+              "postfix"
+            ));
+          } else {
+            postfix = node.arguments[i].expansion;
+            i++;
           }
-        case 2 /* Preformatted */:
-        case 7 /* BlockModifier */:
-          msgs.push(new InlineDefinitonInvalidEntityMessage(n.start, n.end - n.start));
-          break;
-        case 5 /* SystemModifier */:
-          lastIsParagraph = false;
-          concat.push(n);
-          break;
-        default:
-          debug.never(n);
+        } else msgs.push(
+          new ArgumentCountMismatchMessage(node.location)
+        );
       }
+      break;
     }
-    node.state.definition = concat;
-    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(
-          6 /* InlineModifier */,
-          node.state.name,
-          node.state.args,
-          node.state.slotName,
-          node.state.definition
-        )
+    i++;
+    if (i < node.arguments.length) {
+      const id = arg.expansion;
+      if (id === "") {
+        return [new InvalidArgumentMessage(arg.location, "id")];
+      }
+      const part = node.arguments[i].expansion;
+      if (part === "") {
+        return [new InvalidArgumentMessage(
+          node.arguments[i].location,
+          "part"
+        )];
+      }
+      parts.push([id, part]);
+      i++;
+    } else {
+      msgs.push(new ArgumentCountMismatchMessage(node.location));
+      break;
+    }
+  }
+  if (i == node.arguments.length - 1) {
+    const last = node.arguments[i];
+    if (last.expansion !== "") msgs.push(
+      new InvalidArgumentMessage(last.location, "(must be empty)")
+    );
+  } else if (i < node.arguments.length - 1)
+    msgs.push(new ArgumentCountMismatchMessage(node.location));
+  let signature = { slotName, args: parts.map((x) => x[0]), preformatted: void 0 };
+  node.state = { name: nameValue, signature, parts, postfix, msgs };
+  stack.push(signature);
+  return [];
+}
+var DefineBlockShorthandMod = new SystemModifierDefinition(
+  "block-shorthand",
+  0 /* Normal */,
+  {
+    // -inline-shorthand prefix:arg1:part1:arg2:part2...:(slot):postfix:
+    delayContentExpansion: true,
+    alwaysTryExpand: true,
+    beforeParseContent(node, cxt) {
+      const store = cxt.get(builtins);
+      const check = parseDefineArguments2(
+        7 /* 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 [];
+      const store = cxt.get(builtins);
+      const pop = store.blockSlotDelayedStack.pop();
+      assert(pop === node.state.signature);
+      debug.trace("leaving inline shorthand definition", node.state.name);
+      return [];
+    },
+    prepareExpand(node, cxt, immediate) {
+      if (!immediate || !node.state) return [];
+      const arg = node.arguments[0];
+      if (!node.state)
+        return [new InvalidArgumentMessage(arg.location)];
+      const msgs = node.state.msgs;
+      if (cxt.config.blockShorthands.has(node.state.name))
+        msgs.push(new NameAlreadyDefinedMessage(arg.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(
+        7 /* 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 [];
     }
-    return [];
   }
-});
+);
+var DefineInlineShorthandMod = new SystemModifierDefinition(
+  "inline-shorthand",
+  0 /* Normal */,
+  {
+    // -inline-shorthand prefix:arg1:part1:arg2:part2...:(slot):postfix:
+    delayContentExpansion: true,
+    alwaysTryExpand: true,
+    beforeParseContent(node, cxt) {
+      const store = cxt.get(builtins);
+      const check = parseDefineArguments2(
+        6 /* 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 [];
+      const store = cxt.get(builtins);
+      const pop = store.inlineSlotDelayedStack.pop();
+      assert(pop === node.state.signature);
+      debug.trace("leaving inline shorthand definition", node.state.name);
+      return [];
+    },
+    prepareExpand(node, cxt, immediate) {
+      if (!immediate || !node.state) return [];
+      const arg = node.arguments[0];
+      if (!node.state)
+        return [new InvalidArgumentMessage(arg.location)];
+      const msgs = node.state.msgs;
+      if (cxt.config.inlineShorthands.has(node.state.name))
+        msgs.push(new NameAlreadyDefinedMessage(arg.location, node.state.name));
+      node.state.definition = makeInlineDefinition(node, 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(
+        6 /* 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 [];
+    }
+  }
+);
 
-// src/builtin/pushpop.ts
-var PushNotationMod = new SystemModifierDefinition(
-  "push-notation",
-  2 /* Marker */,
+// src/builtin/module.ts
+function getDefs(cxt) {
+  const data = cxt.get(builtins);
+  return {
+    usedModules: new Set(data.usedModules),
+    blocks: cxt.config.blockModifiers.toSet(),
+    inlines: cxt.config.inlineModifiers.toSet(),
+    inlineShorthands: cxt.config.inlineShorthands.toSet(),
+    blockShorthands: cxt.config.blockShorthands.toSet()
+  };
+}
+function applyDefs(cxt, defs) {
+  const data = cxt.get(builtins);
+  data.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);
+}
+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 diffDef(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)
+  };
+}
+function addDef(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 : "")
+  ];
+}
+var ModuleMod = new BlockModifierDefinition(
+  "module",
+  0 /* Normal */,
   {
-    expand(_, cxt) {
+    expand(node) {
+      return [];
+    },
+    beforeParseContent(node, cxt) {
+      const check = checkArguments(node, 1);
+      if (check) return check;
+      const data = cxt.get(builtins);
+      const name = node.arguments[0].expansion;
+      const defs = getDefs(cxt);
+      if (data.insideModule !== void 0) {
+        return [new NoNestedModuleMessage(node.head)];
+      }
+      let msgs = [];
+      node.state = { name, defs };
+      data.insideModule = name;
+      if (data.modules.has(name)) {
+        const [added, msg] = addDef(defs, data.modules.get(name));
+        if (msg) msgs.push(
+          new OverwriteDefinitionsMessage(node.head, msg)
+        );
+        applyDefs(cxt, added);
+        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.notationStack.push({
-        blocks: cxt.config.blockModifiers.toArray(),
-        inlines: cxt.config.inlineModifiers.toArray()
-      });
+      data.insideModule = void 0;
+      data.modules.set(
+        node.state.name,
+        diffDef(getDefs(cxt), node.state.defs)
+      );
+      applyDefs(cxt, node.state.defs);
+      debug.trace("exiting defs for module", node.state.name);
       return [];
     }
   }
 );
-var PopNotationMod = new SystemModifierDefinition(
-  "pop-notation",
-  2 /* Marker */,
+var UseSystemMod = new SystemModifierDefinition(
+  "use",
+  2 /* None */,
   {
     prepareExpand(node, cxt) {
+      const check = checkArguments(node, 1);
+      if (check) return check;
       const data = cxt.get(builtins);
-      const result = data.notationStack.pop();
-      if (!result) return [
-        new CannotPopNotationMessage(node.start, node.end - node.start)
-      ];
-      cxt.config.blockModifiers = new NameManager(result.blocks);
-      cxt.config.inlineModifiers = new NameManager(result.inlines);
+      const name = node.arguments[0];
+      if (!data.modules.has(name.expansion))
+        return [new InvalidArgumentMessage(name.location)];
+      if (data.insideModule === name.expansion)
+        return [new CannotUseModuleInSelfMessage(name.location)];
+      const [added, msg] = addDef(data.modules.get(name.expansion), getDefs(cxt));
+      node.state = added;
+      if (msg)
+        return [new OverwriteDefinitionsMessage(node.head, msg)];
       return [];
     },
-    expand() {
+    expand(node, cxt) {
+      if (node.state)
+        applyDefs(cxt, node.state);
       return [];
     }
   }
 );
+var UseBlockMod = new BlockModifierDefinition(
+  "use",
+  0 /* Normal */,
+  {
+    beforeParseContent(node, cxt) {
+      const check = checkArguments(node, 1);
+      if (check) return check;
+      const data = cxt.get(builtins);
+      const name = node.arguments[0];
+      if (!data.modules.has(name.expansion))
+        return [new InvalidArgumentMessage(name.location)];
+      if (data.insideModule === name.expansion)
+        return [new CannotUseModuleInSelfMessage(name.location)];
+      const old = getDefs(cxt);
+      const [added, msg] = addDef(data.modules.get(name.expansion), old);
+      applyDefs(cxt, added);
+      node.state = { old };
+      if (msg)
+        return [new OverwriteDefinitionsMessage(node.head, msg)];
+      return [];
+    },
+    afterParseContent(node, cxt) {
+      if (node.state)
+        applyDefs(cxt, node.state.old);
+      return [];
+    },
+    expand(node) {
+      return node.content;
+    }
+  }
+);
 
 // src/builtin/slot.ts
-function slotModifier(type) {
-  const mod = type == 7 /* BlockModifier */ ? new BlockModifierDefinition("slot", 2 /* Marker */) : new InlineModifierDefinition("slot", 2 /* Marker */);
+function slotModifier(name, type, preformatted, inject) {
+  const mod = type == 7 /* BlockModifier */ ? new BlockModifierDefinition(name, 2 /* None */) : new InlineModifierDefinition(name, 2 /* None */);
   const isInline = type == 6 /* InlineModifier */;
   mod.alwaysTryExpand = true;
   mod.prepareExpand = (node, cxt, immediate) => {
     if (node.state) return [];
-    const check = checkArgumentLength(node, 0, 1);
-    if (check && immediate) {
+    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 ? checkArguments(node, 1, 2) : checkArguments(node, 0, 1);
+    if (check) {
       node.state = { ok: false };
       return check;
     }
-    const store = cxt.get(builtins);
-    const data = isInline ? store.inlineSlotData : store.blockSlotData;
-    let id = "";
-    if (node.arguments.length == 1) {
-      const arg = node.arguments[0];
-      if (!arg.expansion) {
+    const msgs = (() => {
+      const store = cxt.get(builtins);
+      const data = isInline ? store.inlineInstantiationData : store.blockInstantiationData;
+      const stack = isInline ? store.inlineSlotDelayedStack : store.blockSlotDelayedStack;
+      if (data.length == 0 && stack.length == 0) {
         node.state = { ok: false };
-        return [new InvalidArgumentMessage(arg.start, arg.end - arg.start)];
+        return [new SlotUsedOutsideDefinitionMessage(node.location)];
+      }
+      if (node.arguments.length == (inject ? 1 : 0)) {
+        let signature2 = stack.at(-1);
+        if (signature2) return processSignature(signature2);
+        node.state = { ok: true, data: data.at(-1), index: data.length - 1 };
+        return;
+      }
+      const id = node.arguments[0].expansion;
+      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;
       }
-      id = arg.expansion;
-    }
-    if (data.length == 0) {
       if (immediate) {
         node.state = { ok: false };
-        return [new SlotUsedOutsideDefinitionMessage(node.start, node.head.end - node.start)];
+        const arg = node.arguments[0];
+        return [new InvalidArgumentMessage(arg.location, id)];
       }
-      return [];
-    }
-    const stack = isInline ? store.inlineSlotDelayedStack : store.blockSlotDelayedStack;
-    if (stack.includes(id)) {
-      debug.trace("delaying", id == "" ? "unnamed slot" : "slot: " + id);
-      return [];
-    }
-    if (node.arguments.length == 0) {
-      node.state = { ok: true, data: data.at(-1), index: data.length - 1 };
-      return [];
-    }
-    for (let i = data.length - 1; i >= 0; i--) if (data[i][0] == id) {
-      node.state = { ok: true, data: data[i], index: i };
-      return [];
-    }
-    if (immediate) {
-      node.state = { ok: false };
-      const arg = node.arguments[0];
-      return [new InvalidArgumentMessage(arg.start, arg.end - arg.start, id)];
+    })();
+    if (inject) {
+      const arg = node.arguments.at(-1);
+      const modName = arg.expansion;
+      const mod2 = (isInline ? cxt.config.inlineModifiers : cxt.config.blockModifiers).get(modName);
+      if (!mod2) {
+        node.state = { ok: false };
+        return [new UnknownModifierMessage(arg.location, modName)];
+      }
+      if (node.state?.ok)
+        node.state.injectMod = mod2;
     }
+    if (msgs) return msgs;
     return [];
   };
   mod.expand = (node, cxt) => {
     if (!node.state) return void 0;
     if (!node.state.ok) return [];
-    return cloneNodes(node.state.data[1].slotContent);
+    let cloned = cloneNodes(node.state.data.slotContent);
+    if (inject) {
+      const mod2 = node.state.injectMod;
+      const modNode = {
+        type,
+        mod: mod2,
+        location: node.location,
+        head: node.head,
+        arguments: [],
+        // TODO: enable injecting args
+        content: cloned
+      };
+      return [modNode];
+    } 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[1].mod.name);
-    const data = isInline ? store.inlineSlotData : store.blockSlotData;
+    debug.trace("temporarily removed slot data for", node.state.data.mod.name);
+    const data = isInline ? store.inlineInstantiationData : store.blockInstantiationData;
     data.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[1].mod.name);
-    const data = isInline ? store.inlineSlotData : store.blockSlotData;
+    debug.trace("reinstated slot data for", node.state.data.mod.name);
+    const data = isInline ? store.inlineInstantiationData : store.blockInstantiationData;
     data.splice(node.state.index, 0, node.state.data);
     return [];
   };
   return mod;
 }
-var SlotBlockMod = slotModifier(7 /* BlockModifier */);
-var SlotInlineMod = slotModifier(6 /* InlineModifier */);
+var SlotBlockMod = slotModifier("slot", 7 /* BlockModifier */, false, false);
+var SlotInlineMod = slotModifier("slot", 6 /* InlineModifier */, false, false);
+var PreSlotBlockMod = slotModifier("pre-slot", 7 /* BlockModifier */, true, false);
+var PreSlotInlineMod = slotModifier("pre-slot", 6 /* InlineModifier */, true, false);
+var InjectPreSlotBlockMod = slotModifier(
+  "inject-pre-slot",
+  7 /* BlockModifier */,
+  true,
+  true
+);
+var InjectPreSlotInlineMod = slotModifier(
+  "inject-pre-slot",
+  6 /* InlineModifier */,
+  true,
+  true
+);
 
 // 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 void 0;
+  }
   let value = void 0;
-  for (let i = store.inlineSlotData.length - 1; i >= 0; i--) {
-    const [_, data] = store.inlineSlotData[i];
+  for (let i = store.inlineInstantiationData.length - 1; i >= 0; i--) {
+    const data = store.inlineInstantiationData[i];
     if ((value = data.args.get(id)) !== void 0)
       break;
   }
-  for (let i = store.blockSlotData.length - 1; i >= 0; i--) {
-    const [_, data] = store.blockSlotData[i];
+  for (let i = store.blockInstantiationData.length - 1; i >= 0; i--) {
+    const data = store.blockInstantiationData[i];
     if ((value = data.args.get(id)) !== void 0)
       break;
   }
@@ -1661,53 +2243,62 @@ function resolveId(id, cxt) {
     value = cxt.variables.get(id);
   return value;
 }
-var GetVarInlineMod = new InlineModifierDefinition("$", 2 /* Marker */, {
-  // .$:id
-  prepareExpand(node, cxt) {
-    const check = checkArguments(node, 1);
-    if (check) return check;
-    const arg = node.arguments[0];
-    const id = arg.expansion;
-    if (id == "")
-      return [new InvalidArgumentMessage(arg.start, arg.end - arg.start)];
-    const value = resolveId(id, cxt);
-    if (value === void 0)
-      return [new UndefinedVariableMessage(arg.start, arg.end - arg.start, id)];
-    node.state = { value };
-    return [];
-  },
-  expand(node, cxt) {
-    if (!node.state) return [];
-    return [{ type: 3 /* Text */, content: node.state.value, start: -1, end: -1 }];
+var GetVarInlineMod = new InlineModifierDefinition(
+  "$",
+  2 /* None */,
+  {
+    alwaysTryExpand: true,
+    // .$:id
+    prepareExpand(node, cxt, immediate) {
+      const check = checkArguments(node, 1);
+      if (check)
+        return immediate ? check : [];
+      const arg = node.arguments[0];
+      const id = arg.expansion;
+      if (id == "")
+        return immediate ? [new InvalidArgumentMessage(arg.location)] : [];
+      const value = resolveId(id, cxt);
+      if (value === void 0)
+        return immediate ? [new UndefinedVariableMessage(arg.location, id)] : [];
+      node.state = { value };
+      return [];
+    },
+    expand(node, _, immediate) {
+      if (!node.state) return immediate ? [] : void 0;
+      return [{ type: 3 /* Text */, content: node.state.value, location: node.location }];
+    }
   }
-});
-var PrintInlineMod = new InlineModifierDefinition("print", 2 /* Marker */, {
-  // .print:args...
-  prepareExpand(node) {
-    const check = checkArguments(node);
-    if (check) return check;
-    node.state = { value: node.arguments.map((x) => x.expansion).join("") };
-    return [];
-  },
-  expand(node) {
-    if (!node.state) return [];
-    return [{ type: 3 /* Text */, content: node.state.value, start: -1, end: -1 }];
+);
+var PrintInlineMod = new InlineModifierDefinition(
+  "print",
+  2 /* None */,
+  {
+    // .print:args...
+    prepareExpand(node) {
+      const check = checkArguments(node);
+      if (check) return check;
+      node.state = { value: node.arguments.map((x) => x.expansion).join("") };
+      return [];
+    },
+    expand(node) {
+      if (!node.state) return [];
+      return [{ type: 3 /* Text */, content: node.state.value, location: node.location }];
+    }
   }
-});
+);
 var GetVarInterpolator = new ArgumentInterpolatorDefinition(
   "$(",
   ")",
   {
     alwaysTryExpand: true,
-    expand(content, cxt, immediate) {
+    expand(content, cxt) {
       const result = resolveId(content, cxt);
-      if (result === void 0) debug.trace("var interp failed:", content);
-      else debug.trace(`$(${content}) --> ${result}`);
+      if (result !== void 0) debug.trace(`$(${content}) --> ${result}`);
       return result;
     }
   }
 );
-var VarMod = new SystemModifierDefinition("var", 2 /* Marker */, {
+var VarMod = new SystemModifierDefinition("var", 2 /* None */, {
   // .var id:value
   prepareExpand(node, cxt) {
     const check = checkArguments(node, 2);
@@ -1715,7 +2306,7 @@ var VarMod = new SystemModifierDefinition("var", 2 /* Marker */, {
     const arg = node.arguments[0];
     const id = arg.expansion;
     if (id == "")
-      return [new InvalidArgumentMessage(arg.start, arg.end - arg.start)];
+      return [new InvalidArgumentMessage(arg.location)];
     node.state = {
       id,
       value: node.arguments[1].expansion
@@ -1732,13 +2323,576 @@ var VarMod = new SystemModifierDefinition("var", 2 /* Marker */, {
 });
 
 // src/builtin/builtin.ts
-var basic = new Configuration();
-basic.initializers = [initParseContext];
-basic.systemModifiers.add(DefineBlockMod, DefineInlineMod, VarMod, PushNotationMod, PopNotationMod);
-basic.blockModifiers.add(SlotBlockMod);
-basic.inlineModifiers.add(SlotInlineMod, GetVarInlineMod, PrintInlineMod);
-basic.argumentInterpolators.add(GetVarInterpolator);
-var BuiltinConfiguration = Object.freeze(basic);
+var builtin = new Configuration();
+builtin.initializers = [initParseContext];
+builtin.systemModifiers.add(
+  DefineBlockMod,
+  DefineInlineMod,
+  DefineBlockShorthandMod,
+  DefineInlineShorthandMod,
+  VarMod,
+  UseSystemMod
+);
+builtin.blockModifiers.add(
+  SlotBlockMod,
+  PreSlotBlockMod,
+  InjectPreSlotBlockMod,
+  ModuleMod,
+  UseBlockMod
+);
+builtin.inlineModifiers.add(
+  SlotInlineMod,
+  PreSlotInlineMod,
+  InjectPreSlotInlineMod,
+  GetVarInlineMod,
+  PrintInlineMod
+);
+builtin.argumentInterpolators.add(GetVarInterpolator);
+var BuiltinConfiguration = Object.freeze(builtin);
+
+// src/default/bullets.ts
+var bulletItemBlock = new BlockModifierDefinition(
+  "bullet-item",
+  0 /* Normal */,
+  { roleHint: void 0 }
+);
+var orderedListItemBlock = new BlockModifierDefinition(
+  "ordered-item",
+  0 /* Normal */,
+  {
+    roleHint: void 0,
+    prepareExpand(node) {
+      let msgs = checkArguments(node, 0, 1);
+      if (msgs) return msgs;
+      let arg = node.arguments[0];
+      let num = Number.parseInt(arg.expansion);
+      if (isNaN(num)) return [
+        new InvalidArgumentMessage(arg.location, "should be a number")
+      ];
+      node.state = num;
+      return [];
+    }
+  }
+);
+var subItemBlock = new BlockModifierDefinition(
+  "subitem",
+  0 /* Normal */,
+  { roleHint: void 0 }
+);
+var BulletBlocks = [bulletItemBlock, orderedListItemBlock, subItemBlock];
+var BulletBlockRenderersHTML = [
+  [bulletItemBlock, (node, cxt) => {
+    return `<li>${cxt.state.render(node.content, cxt)}</li>`;
+  }],
+  [subItemBlock, (node, cxt) => {
+    return `<div class='subitem'>${cxt.state.render(node.content, cxt)}</div>`;
+  }],
+  [orderedListItemBlock, (node, cxt) => {
+    if (node.state === void 0)
+      return cxt.state.invalidBlock(node, "bad format");
+    return `<li value='${node.state}'>${cxt.state.render(node.content, cxt)}</li>`;
+  }]
+];
+
+// src/default/headings.ts
+var headingBlock = new BlockModifierDefinition(
+  "heading",
+  0 /* Normal */,
+  {
+    delayContentExpansion: true,
+    roleHint: "heading",
+    prepareExpand(node) {
+      let msgs = checkArguments(node, 0, 1);
+      if (msgs) return msgs;
+      msgs = onlyPermitSingleBlock(node);
+      if (msgs) return msgs;
+      msgs = onlyPermitSimpleParagraphs(node);
+      if (msgs) return msgs;
+      if (node.arguments.length == 1) {
+        let arg = node.arguments[0];
+        let num = Number.parseInt(arg.expansion);
+        if (isNaN(num)) return [
+          new InvalidArgumentMessage(arg.location, "should be a number between 1 and 6")
+        ];
+        node.state = num;
+      } else {
+        node.state = 1;
+      }
+      return [];
+    }
+  }
+);
+var numberedHeadingBlock = new BlockModifierDefinition(
+  "numbered-heading",
+  0 /* Normal */,
+  {
+    delayContentExpansion: true,
+    roleHint: "heading",
+    prepareExpand(node) {
+      let msgs = checkArguments(node, 1);
+      if (msgs) return msgs;
+      msgs = onlyPermitSingleBlock(node);
+      if (msgs) return msgs;
+      msgs = onlyPermitSimpleParagraphs(node);
+      if (msgs) return msgs;
+      let arg = node.arguments[0];
+      let split = arg.expansion.trim().split(".").filter((x) => x.length > 0);
+      if (split.length == 0 || split.length > 6) return [
+        new InvalidArgumentMessage(arg.location, "heading level must be between 1 and 6")
+      ];
+      node.state = split;
+      debug.trace("numbered-heading", node.state);
+      return [];
+    }
+  }
+);
+var HeadingBlocks = [headingBlock, numberedHeadingBlock];
+var HeadingBlockRenderersHTML = [
+  [headingBlock, (node, cxt) => {
+    if (node.state !== void 0) {
+      assert(node.state >= 1 && node.state <= 6);
+      let tag = "h" + node.state;
+      let para = node.content[0];
+      return `<${tag}>${cxt.state.render(para.content, cxt)}</${tag}>`;
+    }
+    return cxt.state.invalidBlock(node, "Bad format");
+  }],
+  [numberedHeadingBlock, (node, cxt) => {
+    if (node.state !== void 0) {
+      assert(node.state.length >= 1 && node.state.length <= 6);
+      let tag = "h" + node.state.length;
+      let para = node.content[0];
+      return `<${tag}><span class='heading-number'>${node.state.join(".")}</span>${cxt.state.render(para.content, cxt)}</${tag}>`;
+    }
+    return cxt.state.invalidBlock(node, "Bad format");
+  }]
+];
+
+// src/default/notes.ts
+var notes = Symbol();
+function initNotes(cxt) {
+  cxt.init(notes, {
+    systems: /* @__PURE__ */ new Map(),
+    definitions: []
+  });
+}
+var noteMarkerInline = new InlineModifierDefinition(
+  "note",
+  2 /* None */,
+  {
+    roleHint: "link",
+    prepareExpand(node) {
+      let msgs = checkArguments(node, 1);
+      if (msgs) return msgs;
+      node.state = node.arguments[0].expansion;
+      return [];
+    }
+  }
+);
+var noteInline = new InlineModifierDefinition(
+  "note-inline",
+  0 /* Normal */,
+  {
+    roleHint: "quote",
+    prepareExpand(node) {
+      let msgs = checkArguments(node, 0, 1);
+      if (msgs) return msgs;
+      node.state = node.arguments.at(0)?.expansion ?? "";
+      return [];
+    },
+    afterProcessExpansion(node, cxt) {
+      if (node.state !== void 0) {
+        cxt.get(notes).definitions.push({
+          system: "",
+          name: node.state,
+          location: node.location,
+          content: [{
+            type: 1 /* Paragraph */,
+            location: {
+              source: node.location.source,
+              start: node.head.end,
+              end: node.location.actualEnd ?? node.location.end
+            },
+            content: node.content
+          }]
+        });
+      }
+      return [];
+    }
+  }
+);
+var noteBlock = new BlockModifierDefinition(
+  "note",
+  0 /* Normal */,
+  {
+    roleHint: "quote",
+    prepareExpand(node) {
+      let msgs = checkArguments(node, 1);
+      if (msgs) return msgs;
+      node.state = node.arguments[0].expansion;
+      return [];
+    },
+    afterProcessExpansion(node, cxt) {
+      if (node.state !== void 0) {
+        let content = stripNode(...node.content);
+        debug.trace(`add note: system=<${""}> name=${node.state} @${node.location.start}`);
+        debug.trace(`-->
+`, debugPrint.node(...content));
+        cxt.get(notes).definitions.push({
+          system: "",
+          name: node.state,
+          location: node.location,
+          content
+        });
+      }
+      node.expansion = [];
+      return [];
+    }
+  }
+);
+var NoteBlocks = [noteBlock];
+var NoteInlines = [noteInline, noteMarkerInline];
+var NoteInlineRenderersHTML = [
+  [noteMarkerInline, (node, cxt) => {
+    if (node.state === void 0)
+      return cxt.state.invalidInline(node, "bad format");
+    const defs = cxt.parseContext.get(notes).definitions;
+    const note = defs.findIndex((x) => (
+      /*x.position >= node.start &&*/
+      x.name == node.state
+    ));
+    if (note < 0)
+      return `<sup class='note invalid'>Not found: ${node.state}</sup>`;
+    return `<sup class='note' id='notemarker-id-${note}'><a href='#note-id-${note}'>${node.state}</a></sup>`;
+  }]
+];
+var NotesFooterPlugin = (cxt) => {
+  let defs = cxt.parseContext.get(notes).definitions;
+  if (defs.length == 0) return void 0;
+  return `<hr/>
+<section class='notes'>
+${defs.map((x, i) => `<section class='note' id='note-id-${i}'>
+<div class='note-name'><p><a href='#notemarker-id-${i}'>${x.name}</a></p></div>
+<div class='note-content'>${cxt.state.render(x.content, cxt)}</div></section>`).join("\n")}
+</section>`;
+};
+
+// src/default/code.ts
+var CodeBlock = new BlockModifierDefinition(
+  "code",
+  1 /* Preformatted */,
+  { roleHint: "code" }
+);
+var CodeInline = new InlineModifierDefinition(
+  "code",
+  1 /* Preformatted */,
+  { roleHint: "code" }
+);
+var CodeBlockRendererHTML = [CodeBlock, (node, cxt) => {
+  return `<pre><code>${cxt.state.render(node.content, cxt)}</code></pre>`;
+}];
+var CodeInlineRendererHTML = [CodeInline, (node, cxt) => {
+  return `<span><code>${cxt.state.render(node.content, cxt)}</code></span>`;
+}];
+
+// src/default/quotes.ts
+var quoteBlock = new BlockModifierDefinition(
+  "quote",
+  0 /* Normal */,
+  { roleHint: "quote" }
+);
+var epitaphBlock = new BlockModifierDefinition(
+  "epitaph",
+  0 /* Normal */,
+  { roleHint: "quote" }
+);
+var attributionBlock = new BlockModifierDefinition(
+  "by",
+  0 /* Normal */,
+  {
+    roleHint: "quote",
+    prepareExpand(node) {
+      let msgs = onlyPermitSingleBlock(node);
+      if (msgs) return msgs;
+      msgs = onlyPermitSimpleParagraphs(node);
+      if (msgs) return msgs;
+      node.state = true;
+      return [];
+    }
+  }
+);
+var QuoteBlocks = [quoteBlock, epitaphBlock, attributionBlock];
+var QuoteBlockRenderersHTML = [
+  [quoteBlock, (node, cxt) => {
+    return `<blockquote>${cxt.state.render(node.content, cxt)}</blockquote>`;
+  }],
+  [epitaphBlock, (node, cxt) => {
+    return `<blockquote class='epitaph'>${cxt.state.render(node.content, cxt)}</blockquote>`;
+  }],
+  [attributionBlock, (node, cxt) => {
+    if (!node.state)
+      return cxt.state.invalidBlock(node, "bad format");
+    let para = node.content[0];
+    return `<p class='attribution'>${cxt.state.render(para.content, cxt)}</p>`;
+  }]
+];
+
+// src/default/inline-styles.ts
+var emphasisInline = new InlineModifierDefinition(
+  "emphasis",
+  0 /* Normal */,
+  { roleHint: "emphasis" }
+);
+var keywordInline = new InlineModifierDefinition(
+  "keyword",
+  0 /* Normal */,
+  { roleHint: "keyword" }
+);
+var highlightInline = new InlineModifierDefinition(
+  "highlight",
+  0 /* Normal */,
+  { roleHint: "highlight" }
+);
+var commentaryInline = new InlineModifierDefinition(
+  "commentary",
+  0 /* Normal */,
+  { roleHint: "commentary" }
+);
+var InlineStyles = [emphasisInline, keywordInline, highlightInline, commentaryInline];
+var InlineStyleRenderersHTML = [
+  [emphasisInline, (node, cxt) => {
+    return `<em>${cxt.state.render(node.content, cxt)}</em>`;
+  }],
+  [keywordInline, (node, cxt) => {
+    return `<b>${cxt.state.render(node.content, cxt)}</b>`;
+  }],
+  [highlightInline, (node, cxt) => {
+    return `<mark>${cxt.state.render(node.content, cxt)}</mark>`;
+  }],
+  [commentaryInline, (node, cxt) => {
+    return `<span class='commentary'>${cxt.state.render(node.content, cxt)}</span>`;
+  }]
+];
+
+// src/default/misc.ts
+var rubyInline = new InlineModifierDefinition(
+  "ruby",
+  0 /* Normal */,
+  {
+    roleHint: void 0,
+    prepareExpand(node) {
+      let msgs = checkArguments(node, 1);
+      if (msgs) return msgs;
+      node.state = node.arguments[0].expansion;
+      return [];
+    }
+  }
+);
+var linkInline = new InlineModifierDefinition(
+  "link",
+  0 /* Normal */,
+  {
+    roleHint: "link",
+    prepareExpand(node) {
+      let msgs = checkArguments(node, 1);
+      if (msgs) return msgs;
+      node.state = node.arguments[0].expansion;
+      return [];
+    }
+  }
+);
+var imageBlock = new BlockModifierDefinition(
+  "image",
+  0 /* Normal */,
+  {
+    roleHint: "link",
+    prepareExpand(node) {
+      let msgs = checkArguments(node, 1, 2);
+      if (msgs) return msgs;
+      msgs = onlyPermitSingleBlock(node);
+      if (msgs) return msgs;
+      msgs = onlyPermitSimpleParagraphs(node);
+      if (msgs) return msgs;
+      let url = URL.parse(node.arguments.map((x) => x.expansion).join(":"));
+      if (url) node.state = url;
+      return [];
+    }
+  }
+);
+var MiscInlines = [rubyInline, linkInline];
+var MiscBlocks = [imageBlock];
+var MiscInlineRenderersHTML = [
+  [rubyInline, (node, cxt) => {
+    if (node.state === void 0)
+      return cxt.state.invalidInline(node, "bad format");
+    return `<ruby>${cxt.state.render(node.content, cxt)}<rt>${node.state}</rt></ruby>`;
+  }],
+  [linkInline, (node, cxt) => {
+    if (node.state === void 0)
+      return cxt.state.invalidInline(node, "bad format");
+    return `<a href="${encodeURI(node.state)}">${cxt.state.render(node.content, cxt)}</a>`;
+  }]
+];
+var MiscBlockRenderersHTML = [
+  [imageBlock, (node, cxt) => {
+    let transformed;
+    if (node.state === void 0)
+      return cxt.state.invalidBlock(node, "bad format");
+    try {
+      transformed = cxt.config.options.transformAsset(node.state);
+    } catch {
+      return cxt.state.invalidBlock(node, "bad format");
+    }
+    const img = transformed ? `<img src="${transformed}" data-original-src="${node.state.href}"/>` : `<img src="${node.state.href}"/>`;
+    const para = node.content.length == 0 ? "" : "\n<figcaption>" + cxt.state.render(node.content[0].content, cxt) + "</figcaption>";
+    return `<figure>${img}${para}</figure>`;
+  }]
+];
+
+// src/default/vars.ts
+function createWrapper(name, varname) {
+  varname = varname ?? name.toUpperCase();
+  return new SystemModifierDefinition(name, 0 /* Normal */, {
+    delayContentExpansion: true,
+    afterProcessExpansion(node, cxt) {
+      let msgs = checkArguments(node, 0);
+      if (msgs) return msgs;
+      let result = onlyPermitPlaintextParagraph(node);
+      if (typeof result !== "string") return result;
+      cxt.variables.set(varname, result);
+      return [];
+    }
+  });
+}
+var VarWrappers = [
+  createWrapper("title"),
+  createWrapper("subtitle"),
+  createWrapper("author"),
+  createWrapper("translator"),
+  createWrapper("proofreader"),
+  createWrapper("typeset-by"),
+  createWrapper("cover-by"),
+  createWrapper("cover-img"),
+  createWrapper("orig-title"),
+  createWrapper("orig-link"),
+  createWrapper("theme-color")
+];
+
+// src/default/default.ts
+var config = Configuration.from(BuiltinConfiguration);
+config.initializers.push(initNotes);
+config.blockModifiers.add(
+  ...HeadingBlocks,
+  ...BulletBlocks,
+  CodeBlock,
+  ...QuoteBlocks,
+  ...MiscBlocks,
+  ...NoteBlocks
+);
+config.inlineModifiers.add(
+  CodeInline,
+  ...InlineStyles,
+  ...MiscInlines,
+  ...NoteInlines
+);
+config.systemModifiers.add(
+  ...VarWrappers
+);
+var DefaultConfiguration = Object.freeze(config);
+
+// src/default/html-renderer.ts
+var HTMLRenderState = class {
+  title = "";
+  stylesheet = "";
+  // FIXME: very unsafe!
+  cssVariables = /* @__PURE__ */ new Map();
+  // https://stackoverflow.com/questions/7381974
+  escape(content) {
+    return content.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("\n", "<br/>");
+  }
+  invalidBlock(node, msg) {
+    let name = NodeType[node.type];
+    if (node.type === 7 /* BlockModifier */)
+      name += ` (${node.mod.name})`;
+    return `<details class='invalid'><summary>Invalid ${this.escape(name)}</summary><i>${this.escape(msg)}</i></details>`;
+  }
+  invalidInline(node, msg) {
+    let name = NodeType[node.type];
+    if (node.type === 6 /* InlineModifier */)
+      name += ` (${node.mod.name})`;
+    return `<span class='invalid'>Invalid ${this.escape(name)} \u2013 <i>${this.escape(msg)}</i></span>`;
+  }
+  render(elems, cxt) {
+    return elems.map((x) => cxt.renderEntity(x)).filter((x) => x !== void 0).join("");
+  }
+};
+var htmlConfig = new RenderConfiguration(
+  {
+    headPlugins: [],
+    headerPlugins: [],
+    footerPlugins: [NotesFooterPlugin],
+    transformAsset: (x) => void 0
+    // postprocessPlugins: [],
+  },
+  (results, cxt) => {
+    let styles = cxt.state.stylesheet.replaceAll(
+      /var\(--(.*?)\)/g,
+      (m, c) => cxt.state.cssVariables.get(c) ?? m
+    );
+    return `
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+${cxt.config.options.headPlugins.map((x) => x(cxt)).filter((x) => x !== void 0).join("\n")}
+<title>${cxt.state.escape(cxt.state.title)}</title>
+<style>${styles}</style>
+</head>
+<body>
+<section class="article-container">
+<section class="article-body">
+${cxt.config.options.headerPlugins.map((x) => x(cxt)).filter((x) => x !== void 0).join("\n")}
+${results.join("\n")}
+${cxt.config.options.footerPlugins.map((x) => x(cxt)).filter((x) => x !== void 0).join("\n")}
+</section>
+</section>
+</body>
+</html>`;
+  }
+);
+htmlConfig.paragraphRenderer = (node, cxt) => `<p>${node.content.map((x) => cxt.renderEntity(x)).filter((x) => x !== void 0).join("")}</p>`;
+htmlConfig.textRenderer = (node, cxt) => {
+  switch (node.type) {
+    case 2 /* Preformatted */:
+      return cxt.state.escape(node.content.text);
+    case 3 /* Text */:
+    case 4 /* Escaped */:
+      return cxt.state.escape(node.content);
+    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
+  // TODO: notes
+);
+htmlConfig.addInlineRenderer(
+  CodeInlineRendererHTML,
+  ...InlineStyleRenderersHTML,
+  ...MiscInlineRenderersHTML,
+  ...NoteInlineRenderersHTML
+);
+var HTMLRenderConfiguration = htmlConfig;
 
 // src/index.ts
 function setDebugLevel(level) {
@@ -1750,14 +2904,20 @@ export {
   BuiltinConfiguration,
   Configuration,
   DebugLevel,
+  DefaultConfiguration,
   Document,
+  HTMLRenderConfiguration,
+  HTMLRenderState,
   InlineModifierDefinition,
   MessageSeverity,
-  ModifierFlags,
+  ModifierSlotType,
   NodeType,
   ParseContext,
+  RenderConfiguration,
+  RenderContext,
   SimpleScanner,
   SystemModifierDefinition,
+  debugPrint,
   messages_exports as messages,
   parse,
   setDebugLevel