@the_dissidents/libemmm 0.0.5 → 0.0.8

package/dist/index.mjs

@@ -35,24 +35,43 @@ var ModifierBase = class {
     this.slotType = slotType;
     if (args) Object.assign(this, args);
   }
+  /**
+   * Common values: heading, emphasis, keyword, highlight, commentary, comment, link, quote
+   */
   roleHint;
   /**
-   * If true, any modifier encountered in the content of it will *not* be expanded, *unless* that modifier is `alwaysTryExpand`.
+   * If true, any modifier encountered inside it will *not* be expanded *during parse-content*, 
+   * *unless* that modifier is `alwaysTryExpand`. In the vast majority of cases, you shouldn't 
+   * be using this.
    */
   delayContentExpansion = false;
   /**
-   * If true, such a modifier will always be expanded whenever it is encountered, *even if* contained in a modifier with `delayContentExpansion`.
+   * If true, such a modifier will always be expanded whenever it is encountered, *even if* 
+   * it is contained in a modifier with `delayContentExpansion`. In the vast majority of cases, 
+   * you shouldn't be using this.
    */
   alwaysTryExpand = false;
-  /** Called before the modifier's content is parsed. */
+  /** Called before the modifier's content is parsed. 
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+  */
   beforeParseContent;
-  /** Called after the modifier's content is parsed. */
+  /** Called after the modifier's content is parsed. 
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+  */
   afterParseContent;
-  /** Called before reparsing of the expansion. */
+  /** Called before reparsing of the expansion. 
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.*/
   beforeProcessExpansion;
-  /** Called before reparsing of the expansion. */
+  /** Called before reparsing of the expansion. 
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.*/
   afterProcessExpansion;
+  /**
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+   */
   prepareExpand;
+  /**
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+   */
   expand;
 };
 var BlockModifierDefinition = class extends ModifierBase {
@@ -128,14 +147,6 @@ function assert(x) {
     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) => {
@@ -264,12 +275,52 @@ var debug = {
   }
 };
 
+// src/source.ts
+var StringSource = class {
+  constructor(d, src) {
+    this.src = src;
+    this.name = d.name;
+    this.lineMap = [0];
+    [...src].forEach((x, i) => {
+      if (x == "\n") this.lineMap.push(i + 1);
+    });
+    this.nLines = this.lineMap.length;
+    this.lineMap.push(Infinity);
+  }
+  name;
+  nLines;
+  lineMap;
+  getRowCol(pos) {
+    let line = -1, linepos = 0;
+    for (let i = 1; i < this.lineMap.length; i++) {
+      if (this.lineMap[i] > pos) {
+        line = i - 1;
+        linepos = this.lineMap[i - 1];
+        break;
+      }
+    }
+    return [line, pos - linepos];
+  }
+  getRowStart(n) {
+    assert(n >= 0);
+    if (n >= this.lineMap.length) return Infinity;
+    return this.lineMap[n];
+  }
+  getRow(n) {
+    const start = this.getRowStart(n);
+    const end = this.getRowStart(n + 1);
+    if (start === Infinity) return void 0;
+    return this.src.substring(start, end - 1);
+  }
+};
+
 // src/scanner.ts
 var SimpleScanner = class {
-  constructor(src, source = { name: "<input>" }) {
+  constructor(src, sourceDesc = { name: "<input>" }) {
     this.src = src;
-    this.source = source;
+    this.source = new StringSource(sourceDesc, src);
   }
+  source;
   pos = 0;
   position() {
     return this.pos;
@@ -311,7 +362,8 @@ var debugPrint = {
   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),
+  message: debugPrintMsg,
+  range: debugPrintRange,
   document: debugDumpDocument
 };
 function debugPrintArgEntity(node) {
@@ -381,38 +433,46 @@ ${prefix}<expansion />`;
   }
   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}`;
-    };
+function debugPrintRange(loc, context = 1) {
+  const isSingleCharacter = loc.start == loc.end;
+  let [sr, sc] = loc.source.getRowCol(loc.start);
+  let [er, ec] = loc.source.getRowCol(loc.actualEnd ?? loc.end);
+  const rowWidth = Math.max((sr + 1).toString().length, (er + 1).toString().length);
+  const startLine = Math.max(0, sr - context);
+  const endLine = Math.min(loc.source.nLines - 1, er + context);
+  let lines = [];
+  for (let i = startLine; i <= endLine; i++) {
+    const line = loc.source.getRow(i);
+    lines.push((i + 1).toString().padStart(rowWidth) + " | " + line);
+    if (i >= sr && i <= er) {
+      const startPos = i == sr ? sc : 0;
+      const endPos = i == er ? ec : line.length;
+      lines.push(
+        " ".repeat(rowWidth) + " | " + " ".repeat(startPos) + (isSingleCharacter ? "^" : "~".repeat(endPos - startPos + 1))
+      );
+    }
   }
+  return lines.join("\n");
+}
+function debugPrintMsg(m) {
+  const poss = (loc2) => {
+    const [r1, c1] = loc2.source.getRowCol(loc2.start);
+    if (loc2.start == loc2.end) return `l${r1 + 1}c${c1 + 1}`;
+    const [r2, c2] = loc2.source.getRowCol(loc2.end);
+    return `l${r1 + 1}c${c1 + 1}-l${r2 + 1}c${c2 + 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}`;
-  }
+  let result = `at ${poss(loc)}: ${MessageSeverity[m.severity]}[${m.code}]: ${m.info}`;
   while (loc = loc.original) {
     let d = loc.source !== m.location.source ? `(in ${loc.source.name}) ` : "";
     result += `
----> original at: ${d}${pos(loc.start)}-${pos(loc.end)}`;
+---> original at: ${d}${poss(loc)}`;
   }
   return result;
 }
-function debugDumpDocument(doc, source) {
+function debugDumpDocument(doc) {
   let root = debugPrint.node(...doc.root.content);
-  let msgs = doc.messages.map((x) => debugPrintMsg(x, doc.root.source, source)).join("\n");
+  let msgs = doc.messages.map((x) => debugPrintRange(x.location) + "\n" + debugPrintMsg(x)).join("\n");
   if (msgs.length > 0) msgs += "\n";
   return `Document: ${doc.root.source.name}
 ${msgs}${root}`;
@@ -424,7 +484,6 @@ __export(messages_exports, {
   ArgumentCountMismatchMessage: () => ArgumentCountMismatchMessage,
   CannotExpandArgumentMessage: () => CannotExpandArgumentMessage,
   CannotUseModuleInSelfMessage: () => CannotUseModuleInSelfMessage,
-  ContentShouldBeOnNewlineMessage: () => ContentShouldBeOnNewlineMessage,
   EitherNormalOrPreMessage: () => EitherNormalOrPreMessage,
   EntityNotAllowedMessage: () => EntityNotAllowedMessage,
   ExpectedMessage: () => ExpectedMessage,
@@ -437,6 +496,7 @@ __export(messages_exports, {
   OverwriteDefinitionsMessage: () => OverwriteDefinitionsMessage,
   OverwriteSpecialVariableMessage: () => OverwriteSpecialVariableMessage,
   ReachedRecursionLimitMessage: () => ReachedRecursionLimitMessage,
+  ShouldBeOnNewlineMessage: () => ShouldBeOnNewlineMessage,
   SlotUsedOutsideDefinitionMessage: () => SlotUsedOutsideDefinitionMessage,
   UnclosedInlineModifierMessage: () => UnclosedInlineModifierMessage,
   UndefinedVariableMessage: () => UndefinedVariableMessage,
@@ -503,7 +563,7 @@ var UnknownModifierMessage = class {
   code = 2;
   severity = 2 /* Error */;
   get info() {
-    return `unknown modifier '${this.what}'; did you forget to escape it?`;
+    return `unknown modifier '${this.what}'`;
   }
   // get fixes(): readonly FixSuggestion[] {
   //     let [start, end] = [this.start, this.end];
@@ -673,13 +733,13 @@ var NewBlockShouldBeOnNewlineMessage = class extends AddThingMessage {
     );
   }
 };
-var ContentShouldBeOnNewlineMessage = class extends AddThingMessage {
+var ShouldBeOnNewlineMessage = class extends AddThingMessage {
   constructor(location) {
     super(
       3,
       1 /* Warning */,
       location,
-      "the content should begin in a new line to avoid confusion"
+      "the following should begin in a new line to avoid confusion"
     );
   }
 };
@@ -764,6 +824,41 @@ var Document = class _Document {
     );
     return doc;
   }
+  /**
+   * Performs a depth-first walk of the node tree.
+   */
+  walk(callback) {
+    let nodes = this.root.content;
+    let node;
+    while (node = nodes.shift()) {
+      const result = callback(node);
+      if (result == "break") break;
+      if (result == "skip") continue;
+      if ("arguments" in node)
+        nodes.push(...node.arguments.flatMap((x) => x.content));
+      if ("content" in node && Array.isArray(node.content))
+        nodes.push(...node.content);
+    }
+  }
+  /**
+   * Gets all nodes that covers the given position, from outermost to innermost (essentially a path).
+   */
+  resolvePosition(pos) {
+    const result = [];
+    let nodes = this.root.content;
+    let node;
+    while (node = nodes.shift()) {
+      if (node.location.start <= pos && (node.location.actualEnd ?? node.location.end) >= pos) {
+        result.push(node);
+        nodes = [];
+        if ("arguments" in node)
+          nodes.push(...node.arguments.flatMap((x) => x.content));
+        if ("content" in node && Array.isArray(node.content))
+          nodes.push(...node.content);
+      }
+    }
+    return result;
+  }
 };
 var Configuration = class _Configuration {
   initializers = [];
@@ -886,6 +981,7 @@ var Parser = class {
       end: to ?? this.scanner.position()
     };
   }
+  /* istanbul ignore next -- @preserve */
   #defs(type) {
     switch (type) {
       case 5 /* SystemModifier */:
@@ -1020,7 +1116,7 @@ var Parser = class {
   SHOULD_BE_A_NEWLINE() {
     this.WHITESPACES();
     if (!this.scanner.accept("\n")) this.emit.message(
-      new ContentShouldBeOnNewlineMessage(this.#loc())
+      new ShouldBeOnNewlineMessage(this.#loc())
     );
   }
   // TODO: this is awkward and doesn't emit messages in the most appropriate way
@@ -1110,14 +1206,28 @@ var Parser = class {
     if (grouped) this.SHOULD_BE_A_NEWLINE();
     const posContentStart = this.scanner.position();
     let posContentEnd = this.scanner.position();
+    let paragraphEnd = void 0;
     let string = "";
     while (!this.scanner.isEOF()) {
       if (this.scanner.accept("\n")) {
         let white = "\n";
-        let char = "";
+        let char;
         while ((char = this.scanner.acceptWhitespaceChar()) !== null)
           white += char;
-        if (grouped && this.scanner.accept(GROUP_END) || !grouped && this.scanner.accept("\n")) break;
+        if (grouped && this.scanner.accept(GROUP_END)) {
+          paragraphEnd = this.scanner.position();
+          if (!this.scanner.isEOF()) {
+            this.SHOULD_BE_A_NEWLINE();
+            this.WARN_IF_MORE_NEWLINES_THAN(1);
+          }
+          break;
+        }
+        if (!grouped && this.scanner.accept("\n")) {
+          paragraphEnd = this.scanner.position() - 1;
+          if (!this.scanner.isEOF())
+            this.WARN_IF_MORE_NEWLINES_THAN(0);
+          break;
+        }
         if (this.scanner.isEOF()) {
           if (grouped) this.emit.message(
             new ExpectedMessage(this.#loc(), GROUP_END)
@@ -1132,7 +1242,7 @@ var Parser = class {
     }
     const node = {
       type: 2 /* Preformatted */,
-      location: this.#locFrom(posStart),
+      location: this.#locFrom(posStart, paragraphEnd ?? posContentEnd),
       content: {
         start: posContentStart,
         end: posContentEnd,
@@ -1149,6 +1259,10 @@ var Parser = class {
       this.WARN_IF_MORE_NEWLINES_THAN(1);
       while (!this.scanner.isEOF()) {
         if (this.scanner.accept(GROUP_END)) {
+          if (!this.scanner.isEOF()) {
+            this.SHOULD_BE_A_NEWLINE();
+            this.WARN_IF_MORE_NEWLINES_THAN(1);
+          }
           this.groupDepth--;
           return;
         }
@@ -1219,6 +1333,10 @@ var Parser = class {
     if (node.mod.delayContentExpansion) this.delayDepth++;
     let ok = true;
     if (isMarker) {
+      if (!this.scanner.isEOF() && type == 7 /* BlockModifier */) {
+        this.SHOULD_BE_A_NEWLINE();
+        this.WARN_IF_MORE_NEWLINES_THAN(1);
+      }
       if (type === 6 /* InlineModifier */) this.emit.addInlineNode(node);
       else this.emit.addBlockNode(node);
     } else if (type == 6 /* InlineModifier */) {
@@ -1265,6 +1383,10 @@ var Parser = class {
       return this.MODIFIER(6 /* InlineModifier */);
     if (this.scanner.peek(MODIFIER_SYSTEM_OPEN))
       return false;
+    if (this.scanner.peek(MODIFIER_BLOCK_OPEN)) {
+      this.SHOULD_BE_A_NEWLINE();
+      return false;
+    }
     const short = this.cxt.config.inlineShorthands.find((x) => this.scanner.accept(x.name));
     if (short) return this.SHORTHAND(6 /* InlineModifier */, short);
     if (this.scanner.accept("\\")) {
@@ -1393,9 +1515,9 @@ function parse(scanner, cxt) {
 
 // src/renderer.ts
 var RenderContext = class {
-  constructor(config2, parseContext, state) {
+  constructor(config2, parsedDocument, state) {
     this.config = config2;
-    this.parseContext = parseContext;
+    this.parsedDocument = parsedDocument;
     this.state = state;
   }
   renderEntity(node) {
@@ -1433,7 +1555,7 @@ var RenderConfiguration = class _RenderConfiguration {
   blockRenderers = /* @__PURE__ */ new Map();
   inlineRenderers = /* @__PURE__ */ new Map();
   render(doc, state) {
-    let cxt = new RenderContext(this, doc.context, state);
+    let cxt = new RenderContext(this, doc, state);
     let results = doc.toStripped().root.content.map((x) => cxt.renderEntity(x)).filter((x) => x !== void 0);
     return this.postprocessor(results, cxt);
   }
@@ -1456,6 +1578,14 @@ var RenderConfiguration = class _RenderConfiguration {
 };
 
 // src/modifier-helper.ts
+var modifier_helper_exports = {};
+__export(modifier_helper_exports, {
+  checkArgumentLength: () => checkArgumentLength,
+  checkArguments: () => checkArguments,
+  onlyPermitPlaintextParagraph: () => onlyPermitPlaintextParagraph,
+  onlyPermitSimpleParagraphs: () => onlyPermitSimpleParagraphs,
+  onlyPermitSingleBlock: () => onlyPermitSingleBlock
+});
 function checkArgumentLength(node, min, max = min) {
   if (min !== void 0 && node.arguments.length < min || max !== void 0 && node.arguments.length > max) {
     return [new ArgumentCountMismatchMessage({
@@ -1499,28 +1629,33 @@ function onlyPermitPlaintextParagraph(node) {
     }
     return result;
   }
+  function checkContent(ents) {
+    if (ents.length == 0) return "";
+    else if (ents.length > 1) {
+      let last = ents.at(-1).location;
+      return [new MultipleBlocksNotPermittedMessage({
+        source: last.source,
+        start: ents[1].location.start,
+        end: last.actualEnd ?? last.end
+      })];
+    }
+    return check(ents[0]);
+  }
   function check(ent) {
     if (ent.type == 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]);
+      return checkContent(ent.expansion);
+    } else if (ent.type == 2 /* Preformatted */) {
+      return ent.content.text;
     } else if (ent.type !== 1 /* Paragraph */) {
       return [new OnlySimpleParagraphsPermittedMessage(ent.location)];
     }
     return checkInline(ent.content);
   }
-  return check(node);
+  return checkContent(node.content);
 }
 function onlyPermitSimpleParagraphs(node) {
   function check(nodes) {
@@ -1600,24 +1735,20 @@ function customModifier(type, name, signature, content) {
       args: node.state.args,
       slotContent: node.content
     });
+    debug.trace(`pushed ${NodeType[type]} slot data for`, name);
     debug.trace(
-      `pushed ${NodeType[type]} slot data for`,
-      name,
-      signature.slotName == "" ? "(unnamed)" : `= ${signature.slotName}`
+      `... slotName:`,
+      signature.slotName === "" ? "<unnamed>" : signature.slotName === void 0 ? "<no slot>" : `'${signature.slotName}'`
     );
+    debug.trace(`... args:`, "{" + [...node.state.args].map(([a, b]) => `${a} => ${b}`).join(", ") + "}");
     return [];
   };
   mod.afterProcessExpansion = (node, cxt) => {
-    if (!node.state?.ok || signature.slotName === void 0) return [];
+    if (!node.state?.ok) return [];
     const store = cxt.get(builtins);
     const data = isInline ? store.inlineInstantiationData : store.blockInstantiationData;
-    const pop = data.pop();
-    assert(pop !== void 0);
-    debug.trace(
-      `popped ${NodeType[type]} slot data for`,
-      name,
-      signature.slotName == "" ? "(unnamed)" : `= ${signature.slotName}`
-    );
+    data.pop();
+    debug.trace(`popped ${NodeType[type]} slot data for`, name);
     return [];
   };
   return mod;
@@ -1970,6 +2101,17 @@ var DefineInlineShorthandMod = new SystemModifierDefinition(
   }
 );
 
+// src/builtin/misc.ts
+var RawBlockMod = new BlockModifierDefinition(
+  "raw",
+  1 /* Preformatted */,
+  {
+    expand(node) {
+      return node.content;
+    }
+  }
+);
+
 // src/builtin/module.ts
 function getDefs(cxt) {
   const data = cxt.get(builtins);
@@ -2266,6 +2408,27 @@ function resolveId(id, cxt) {
     value = cxt.variables.get(id);
   return value;
 }
+var ifdefBody = (x) => ({
+  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.location)];
+    const value = resolveId(id, cxt);
+    node.state = value !== void 0;
+    return [];
+  },
+  expand(node) {
+    return node.state == x ? node.content : [];
+  }
+});
+var ifdefBlock = (name, x) => new BlockModifierDefinition(name, 0 /* Normal */, ifdefBody(x));
+var ifdefInline = (name, x) => new InlineModifierDefinition(name, 0 /* Normal */, ifdefBody(x));
+var IfdefBlockMod = ifdefBlock("ifdef", true);
+var IfndefBlockMod = ifdefBlock("ifndef", false);
+var IfdefInlineMod = ifdefInline("ifdef", true);
+var IfndefInlineMod = ifdefInline("ifndef", false);
 var GetVarInlineMod = new InlineModifierDefinition(
   "$",
   2 /* None */,
@@ -2361,19 +2524,25 @@ builtin.blockModifiers.add(
   PreSlotBlockMod,
   InjectPreSlotBlockMod,
   ModuleMod,
-  UseBlockMod
+  UseBlockMod,
+  IfdefBlockMod,
+  IfndefBlockMod,
+  RawBlockMod
 );
 builtin.inlineModifiers.add(
   SlotInlineMod,
   PreSlotInlineMod,
   InjectPreSlotInlineMod,
   GetVarInlineMod,
-  PrintInlineMod
+  PrintInlineMod,
+  IfdefInlineMod,
+  IfndefInlineMod
 );
 builtin.argumentInterpolators.add(GetVarInterpolator);
 var BuiltinConfiguration = Object.freeze(builtin);
 
-// src/default/bullets.ts
+// src/default/bullets.tsx
+import { jsx } from "minimal-jsx-runtime/jsx-runtime";
 var bulletItemBlock = new BlockModifierDefinition(
   "bullet-item",
   0 /* Normal */,
@@ -2404,20 +2573,22 @@ var subItemBlock = new BlockModifierDefinition(
 );
 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>`;
-  }]
+  [
+    bulletItemBlock,
+    (node, cxt) => /* @__PURE__ */ jsx("li", { children: cxt.state.render(node.content, cxt) })
+  ],
+  [
+    subItemBlock,
+    (node, cxt) => /* @__PURE__ */ jsx("div", { class: "subitem", children: cxt.state.render(node.content, cxt) })
+  ],
+  [
+    orderedListItemBlock,
+    (node, cxt) => node.state === void 0 ? cxt.state.invalidBlock(node, "bad format") : /* @__PURE__ */ jsx("li", { value: node.state, children: cxt.state.render(node.content, cxt) })
+  ]
 ];
 
-// src/default/headings.ts
+// src/default/headings.tsx
+import { jsx as jsx2 } from "minimal-jsx-runtime/jsx-runtime";
 var headings = Symbol();
 function initHeadings(cxt) {
   cxt.init(headings, {
@@ -2441,9 +2612,8 @@ var headingBlock = new BlockModifierDefinition(
   "heading",
   0 /* Normal */,
   {
-    delayContentExpansion: true,
     roleHint: "heading",
-    beforeParseContent(node, cxt) {
+    prepareExpand(node, cxt) {
       let msgs = checkArguments(node, 0, 1);
       if (msgs) return msgs;
       msgs = onlyPermitSingleBlock(node);
@@ -2471,7 +2641,7 @@ var implicitHeadingBlock = new BlockModifierDefinition(
   2 /* None */,
   {
     roleHint: "heading",
-    beforeParseContent(node, cxt) {
+    prepareExpand(node, cxt) {
       let msgs = checkArguments(node, 0, 1);
       if (msgs) return msgs;
       node.state = {
@@ -2498,9 +2668,8 @@ var numberedHeadingBlock = new BlockModifierDefinition(
   "numbered-heading",
   0 /* Normal */,
   {
-    delayContentExpansion: true,
     roleHint: "heading",
-    beforeParseContent(node, cxt) {
+    prepareExpand(node, cxt) {
       let msgs = checkArguments(node, 1);
       if (msgs) return msgs;
       msgs = onlyPermitSingleBlock(node);
@@ -2525,37 +2694,103 @@ var HeadingBlocks = [headingBlock, implicitHeadingBlock, numberedHeadingBlock];
 var HeadingBlockRenderersHTML = [
   [headingBlock, (node, cxt) => {
     if (node.state !== void 0) {
-      let tag = "h" + node.state.level;
-      let para = node.content[0];
-      return `<${tag}>${cxt.state.render(para.content, cxt)}</${tag}>`;
+      const tag = "h" + node.state.level;
+      const para = node.content[0];
+      const element = document.createElement(tag);
+      element.appendChild(cxt.state.render(para.content, cxt));
+      return element;
     }
     return cxt.state.invalidBlock(node, "Bad format");
   }],
   [implicitHeadingBlock, (node, cxt) => {
     if (node.state !== void 0) {
-      let tag = "h" + node.state.level;
-      return `<${tag} class='implicit'></${tag}>`;
+      const tag = "h" + node.state.level;
+      const element = document.createElement(tag);
+      element.className = "implicit";
+      return element;
     }
     return cxt.state.invalidBlock(node, "Bad format");
   }],
   [numberedHeadingBlock, (node, cxt) => {
     if (node.state !== void 0) {
-      let tag = "h" + node.state.level;
-      let para = node.content[0];
-      return `<${tag}><span class='heading-number'>${node.state.name}</span>${cxt.state.render(para.content, cxt)}</${tag}>`;
+      const tag = "h" + node.state.level;
+      const para = node.content[0];
+      const element = document.createElement(tag);
+      element.appendChild(/* @__PURE__ */ jsx2("span", { class: "heading-number", children: node.state.name }));
+      element.appendChild(cxt.state.render(para.content, cxt));
+      return element;
     }
     return cxt.state.invalidBlock(node, "Bad format");
   }]
 ];
 
-// src/default/notes.ts
+// src/default/notes.tsx
+import { jsx as jsx3, jsxs } from "minimal-jsx-runtime/jsx-runtime";
 var notes = Symbol();
 function initNotes(cxt) {
   cxt.init(notes, {
     systems: /* @__PURE__ */ new Map(),
-    definitions: []
+    defaultSystem: {
+      position: "preserve",
+      autonumber: false
+    },
+    definitions: [],
+    currentId: 0
   });
 }
+function getSystem(cxt, name) {
+  const defs = cxt.get(notes);
+  let system;
+  if (name) {
+    if (!defs.systems.has(name)) {
+      system = { ...defs.defaultSystem };
+      defs.systems.set(name, system);
+    } else {
+      system = defs.systems.get(name);
+    }
+  } else {
+    system = defs.defaultSystem;
+  }
+  return system;
+}
+var notePositionSystem = new SystemModifierDefinition(
+  "note-position",
+  2 /* None */,
+  {
+    prepareExpand(node, cxt, immediate) {
+      let msgs = checkArguments(node, 1, 2);
+      if (msgs) return msgs;
+      const type = node.arguments[0].expansion.trim();
+      if (type != "global" && type != "preserve")
+        return [new InvalidArgumentMessage(
+          node.arguments[0].location,
+          "should be `preserve` or `global`"
+        )];
+      const name = node.arguments.at(1)?.expansion.trim();
+      getSystem(cxt, name).position = type;
+      return [];
+    }
+  }
+);
+var noteRenumberingSystem = new SystemModifierDefinition(
+  "note-renumbering",
+  2 /* None */,
+  {
+    prepareExpand(node, cxt, immediate) {
+      let msgs = checkArguments(node, 1, 2);
+      if (msgs) return msgs;
+      const type = node.arguments[0].expansion.trim();
+      if (type != "on" && type != "off")
+        return [new InvalidArgumentMessage(
+          node.arguments[0].location,
+          "should be `preserve` or `global`"
+        )];
+      const name = node.arguments.at(1)?.expansion.trim();
+      getSystem(cxt, name).autonumber = type == "on";
+      return [];
+    }
+  }
+);
 var noteMarkerInline = new InlineModifierDefinition(
   "note",
   2 /* None */,
@@ -2577,13 +2812,15 @@ var noteInline = new InlineModifierDefinition(
     prepareExpand(node) {
       let msgs = checkArguments(node, 0, 1);
       if (msgs) return msgs;
-      node.state = node.arguments.at(0)?.expansion ?? "";
+      node.state = node.arguments.at(0)?.expansion?.trim() ?? "";
       return [];
     },
     afterProcessExpansion(node, cxt) {
       if (node.state !== void 0) {
-        cxt.get(notes).definitions.push({
+        const defs = cxt.get(notes);
+        defs.definitions.push({
           system: "",
+          id: defs.currentId,
           name: node.state,
           location: node.location,
           content: [{
@@ -2596,6 +2833,7 @@ var noteInline = new InlineModifierDefinition(
             content: node.content
           }]
         });
+        defs.currentId++;
       }
       return [];
     }
@@ -2606,58 +2844,73 @@ var noteBlock = new BlockModifierDefinition(
   0 /* Normal */,
   {
     roleHint: "quote",
-    prepareExpand(node) {
-      let msgs = checkArguments(node, 1);
+    prepareExpand(node, cxt) {
+      let msgs = checkArguments(node, 1, 2);
       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(`-->
+      const name = node.arguments[0].expansion.trim();
+      const system = node.arguments.at(1)?.expansion.trim() ?? "";
+      const 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 = [];
+      const defs = cxt.get(notes);
+      const entry = {
+        id: defs.currentId,
+        system,
+        name,
+        location: node.location,
+        content
+      };
+      defs.currentId++;
+      defs.definitions.push(entry);
+      node.state = entry;
       return [];
     }
   }
 );
 var NoteBlocks = [noteBlock];
 var NoteInlines = [noteInline, noteMarkerInline];
+var NoteSystems = [notePositionSystem, noteRenumberingSystem];
+function makeNoteHTML(def, cxt) {
+  return /* @__PURE__ */ jsxs("section", { class: "note", id: `note-id-${def.id}`, children: [
+    /* @__PURE__ */ jsx3("div", { class: "note-name", children: /* @__PURE__ */ jsx3("p", { children: /* @__PURE__ */ jsx3("a", { href: `#notemarker-id-${def.id}`, children: def.name }) }) }),
+    /* @__PURE__ */ jsx3("div", { class: "note-content", children: cxt.state.render(def.content, cxt) })
+  ] });
+}
 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 defs = cxt.parsedDocument.context.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>`;
+    return /* @__PURE__ */ jsx3("sup", { class: "note", id: `notemarker-id-${note}`, children: note < 0 ? `Not found: ${node.state}` : /* @__PURE__ */ jsx3("a", { href: `#note-id-${note}`, children: node.state }) });
+  }]
+];
+var NoteBlockRenderersHTML = [
+  [noteBlock, (node, cxt) => {
+    if (node.state === void 0)
+      return cxt.state.invalidBlock(node, "bad format");
+    const defs = cxt.parsedDocument.context.get(notes);
+    const system = defs.systems.get(node.state.system) ?? defs.defaultSystem;
+    if (system.position != "preserve") return [];
+    return makeNoteHTML(node.state, cxt);
   }]
 ];
 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>`;
+  const defs = cxt.parsedDocument.context.get(notes);
+  const items = cxt.parsedDocument.context.get(notes).definitions.filter((x) => (defs.systems.get(x.system) ?? defs.defaultSystem).position == "global");
+  if (items.length == 0) return void 0;
+  return [
+    /* @__PURE__ */ jsx3("hr", {}),
+    /* @__PURE__ */ jsx3("section", { class: "notes-global", children: items.map((x) => makeNoteHTML(x, cxt)) })
+  ];
 };
 
-// src/default/code.ts
+// src/default/code.tsx
+import { jsx as jsx4 } from "minimal-jsx-runtime/jsx-runtime";
 var CodeBlock = new BlockModifierDefinition(
   "code",
   1 /* Preformatted */,
@@ -2668,14 +2921,17 @@ var CodeInline = new InlineModifierDefinition(
   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>`;
-}];
+var CodeBlockRendererHTML = [
+  CodeBlock,
+  (node, cxt) => /* @__PURE__ */ jsx4("pre", { children: /* @__PURE__ */ jsx4("code", { children: cxt.state.render(node.content, cxt) }) })
+];
+var CodeInlineRendererHTML = [
+  CodeInline,
+  (node, cxt) => /* @__PURE__ */ jsx4("span", { children: /* @__PURE__ */ jsx4("code", { children: cxt.state.render(node.content, cxt) }) })
+];
 
-// src/default/quotes.ts
+// src/default/quotes.tsx
+import { jsx as jsx5 } from "minimal-jsx-runtime/jsx-runtime";
 var quoteBlock = new BlockModifierDefinition(
   "quote",
   0 /* Normal */,
@@ -2686,6 +2942,16 @@ var epitaphBlock = new BlockModifierDefinition(
   0 /* Normal */,
   { roleHint: "quote" }
 );
+var calloutBlock = new BlockModifierDefinition(
+  "callout",
+  0 /* Normal */,
+  { roleHint: "quote" }
+);
+var detailBlock = new BlockModifierDefinition(
+  "detail",
+  0 /* Normal */,
+  { roleHint: "quote" }
+);
 var attributionBlock = new BlockModifierDefinition(
   "by",
   0 /* Normal */,
@@ -2701,23 +2967,34 @@ var attributionBlock = new BlockModifierDefinition(
     }
   }
 );
-var QuoteBlocks = [quoteBlock, epitaphBlock, attributionBlock];
+var QuoteBlocks = [quoteBlock, epitaphBlock, calloutBlock, detailBlock, 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>`;
-  }],
+  [
+    quoteBlock,
+    (node, cxt) => /* @__PURE__ */ jsx5("blockquote", { children: cxt.state.render(node.content, cxt) })
+  ],
+  [
+    epitaphBlock,
+    (node, cxt) => /* @__PURE__ */ jsx5("blockquote", { class: "epitaph", children: cxt.state.render(node.content, cxt) })
+  ],
+  [
+    detailBlock,
+    (node, cxt) => /* @__PURE__ */ jsx5("div", { class: "detail", children: cxt.state.render(node.content, cxt) })
+  ],
+  [
+    calloutBlock,
+    (node, cxt) => /* @__PURE__ */ jsx5("aside", { children: cxt.state.render(node.content, cxt) })
+  ],
   [attributionBlock, (node, cxt) => {
     if (!node.state)
       return cxt.state.invalidBlock(node, "bad format");
     let para = node.content[0];
-    return `<p class='attribution'>${cxt.state.render(para.content, cxt)}</p>`;
+    return /* @__PURE__ */ jsx5("p", { class: "attribution", children: cxt.state.render(para.content, cxt) });
   }]
 ];
 
-// src/default/inline-styles.ts
+// src/default/inline-styles.tsx
+import { jsx as jsx6 } from "minimal-jsx-runtime/jsx-runtime";
 var emphasisInline = new InlineModifierDefinition(
   "emphasis",
   0 /* Normal */,
@@ -2738,23 +3015,37 @@ var commentaryInline = new InlineModifierDefinition(
   0 /* Normal */,
   { roleHint: "commentary" }
 );
-var InlineStyles = [emphasisInline, keywordInline, highlightInline, commentaryInline];
+var sequenceInline = new InlineModifierDefinition(
+  "seq",
+  0 /* Normal */,
+  { roleHint: "commentary" }
+);
+var InlineStyles = [emphasisInline, keywordInline, highlightInline, commentaryInline, sequenceInline];
 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>`;
-  }]
+  [
+    emphasisInline,
+    (node, cxt) => /* @__PURE__ */ jsx6("em", { children: cxt.state.render(node.content, cxt) })
+  ],
+  [
+    keywordInline,
+    (node, cxt) => /* @__PURE__ */ jsx6("b", { children: cxt.state.render(node.content, cxt) })
+  ],
+  [
+    highlightInline,
+    (node, cxt) => /* @__PURE__ */ jsx6("mark", { children: cxt.state.render(node.content, cxt) })
+  ],
+  [
+    commentaryInline,
+    (node, cxt) => /* @__PURE__ */ jsx6("span", { class: "commentary", children: cxt.state.render(node.content, cxt) })
+  ],
+  [
+    sequenceInline,
+    (node, cxt) => /* @__PURE__ */ jsx6("span", { class: "seq", children: cxt.state.render(node.content, cxt) })
+  ]
 ];
 
-// src/default/misc.ts
+// src/default/misc.tsx
+import { jsx as jsx7, jsxs as jsxs2 } from "minimal-jsx-runtime/jsx-runtime";
 var rubyInline = new InlineModifierDefinition(
   "ruby",
   0 /* Normal */,
@@ -2830,43 +3121,46 @@ var imageBlock = new BlockModifierDefinition(
 var MiscInlines = [rubyInline, linkInline];
 var MiscBlocks = [styleBlock, breakBlock, linkBlock, 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>`;
-  }]
+  [
+    rubyInline,
+    (node, cxt) => node.state === void 0 ? cxt.state.invalidInline(node, "bad format") : /* @__PURE__ */ jsxs2("ruby", { children: [
+      cxt.state.render(node.content, cxt),
+      /* @__PURE__ */ jsx7("rt", { children: node.state })
+    ] })
+  ],
+  [
+    linkInline,
+    (node, cxt) => node.state === void 0 ? cxt.state.invalidInline(node, "bad format") : /* @__PURE__ */ jsx7("a", { href: encodeURI(node.state), children: cxt.state.render(node.content, cxt) })
+  ]
 ];
 var MiscBlockRenderersHTML = [
-  [styleBlock, (node, cxt) => {
-    if (node.state === void 0)
-      return cxt.state.invalidBlock(node, "bad format");
-    return `<div class="${node.state}" style="display:contents">${cxt.state.render(node.content, cxt)}</div>`;
-  }],
-  [breakBlock, () => {
-    return `<hr>`;
-  }],
-  [linkBlock, (node, cxt) => {
-    if (node.state === void 0)
-      return cxt.state.invalidBlock(node, "bad format");
-    return `<a href="${encodeURI(node.state)}">${cxt.state.render(node.content, cxt)}</a>`;
-  }],
+  [
+    styleBlock,
+    (node, cxt) => node.state === void 0 ? cxt.state.invalidBlock(node, "bad format") : /* @__PURE__ */ jsx7("div", { class: `emmmstyle-${node.state}`, style: "display:contents", children: cxt.state.render(node.content, cxt) })
+  ],
+  [breakBlock, () => /* @__PURE__ */ jsx7("hr", {})],
+  [
+    linkBlock,
+    (node, cxt) => {
+      if (node.state === void 0)
+        return cxt.state.invalidBlock(node, "bad format");
+      const content = cxt.state.render(node.content, cxt);
+      return /* @__PURE__ */ jsx7("a", { href: encodeURI(node.state), children: content.childElementCount > 0 ? content : node.state });
+    }
+  ],
   [imageBlock, (node, cxt) => {
-    let transformed;
     if (node.state === void 0)
       return cxt.state.invalidBlock(node, "bad format");
+    let transformed;
     try {
       transformed = cxt.config.options.transformAsset(node.state);
     } catch {
       return cxt.state.invalidBlock(node, "unable to transform asset");
     }
-    const img = transformed ? `<img src="${transformed}" data-original-src="${node.state}"/>` : `<img src="${node.state}"/>`;
-    const para = node.content.length == 0 ? "" : "\n<figcaption>" + cxt.state.render(node.content[0].content, cxt) + "</figcaption>";
-    return `<figure>${img}${para}</figure>`;
+    return /* @__PURE__ */ jsxs2("figure", { children: [
+      transformed ? /* @__PURE__ */ jsx7("img", { src: transformed, "data-original-src": node.state }) : /* @__PURE__ */ jsx7("img", { src: node.state }),
+      node.content.length > 0 ? /* @__PURE__ */ jsx7("figcaption", { children: cxt.state.render(node.content[0].content, cxt) }) : []
+    ] });
   }]
 ];
 
@@ -2884,6 +3178,7 @@ function createWrapper(name, varname) {
       if (previous)
         msgs = [new OverwriteSpecialVariableMessage(node.head, varname, previous)];
       cxt.variables.set(varname, result);
+      debug.trace(varname, "->", result);
       return msgs ?? [];
     }
   });
@@ -2920,34 +3215,45 @@ config.inlineModifiers.add(
   ...NoteInlines
 );
 config.systemModifiers.add(
-  ...VarWrappers
+  ...VarWrappers,
+  ...NoteSystems
 );
 var DefaultConfiguration = Object.freeze(config);
 
-// src/default/html-renderer.ts
+// src/default/html-renderer.tsx
+import { jsx as jsx8, jsxs as jsxs3 } from "minimal-jsx-runtime/jsx-runtime";
 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>`;
+    return /* @__PURE__ */ jsxs3("details", { class: "invalid", children: [
+      /* @__PURE__ */ jsxs3("summary", { children: [
+        "Invalid ",
+        name
+      ] }),
+      /* @__PURE__ */ jsx8("i", { children: msg })
+    ] });
   }
   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>`;
+    return /* @__PURE__ */ jsxs3("span", { class: "invalid", children: [
+      "Invalid ",
+      name,
+      ": ",
+      /* @__PURE__ */ jsx8("i", { children: msg })
+    ] });
   }
   render(elems, cxt) {
-    return elems.map((x) => cxt.renderEntity(x)).filter((x) => x !== void 0).join("");
+    let fragment = new DocumentFragment();
+    elems.map((x) => cxt.renderEntity(x)).filter((x) => x !== void 0).flat().forEach((x) => fragment.appendChild(x));
+    return fragment;
   }
 };
 var htmlConfig = new RenderConfiguration(
@@ -2955,7 +3261,8 @@ var htmlConfig = new RenderConfiguration(
     headPlugins: [],
     headerPlugins: [],
     footerPlugins: [NotesFooterPlugin],
-    transformAsset: (x) => void 0
+    postprocessPlugins: [],
+    transformAsset: () => void 0
     // postprocessPlugins: [],
   },
   (results, cxt) => {
@@ -2963,35 +3270,41 @@ var htmlConfig = new RenderConfiguration(
       /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>`;
+    let doc = document.implementation.createHTMLDocument(cxt.state.title);
+    doc.head.append(
+      /* @__PURE__ */ jsx8("meta", { charset: "UTF-8" }),
+      /* @__PURE__ */ jsx8("style", { children: styles }),
+      ...cxt.config.options.headPlugins.map((x) => x(cxt)).filter((x) => x !== void 0).flat()
+    );
+    doc.body.append(
+      /* @__PURE__ */ jsx8("section", { class: "article-container", children: /* @__PURE__ */ jsxs3("section", { class: "article-body", children: [
+        cxt.config.options.headerPlugins.map((x) => x(cxt)).filter((x) => x !== void 0),
+        results,
+        cxt.config.options.footerPlugins.map((x) => x(cxt)).filter((x) => x !== void 0)
+      ] }) })
+    );
+    for (const p of cxt.config.options.postprocessPlugins) {
+      p(cxt, doc);
+    }
+    return doc;
   }
 );
-htmlConfig.paragraphRenderer = (node, cxt) => `<p>${node.content.map((x) => cxt.renderEntity(x)).filter((x) => x !== void 0).join("")}</p>`;
+htmlConfig.paragraphRenderer = (node, cxt) => /* @__PURE__ */ jsx8("p", { children: node.content.map((x) => cxt.renderEntity(x)).filter((x) => x !== void 0) });
 htmlConfig.textRenderer = (node, cxt) => {
   switch (node.type) {
     case 2 /* Preformatted */:
-      return cxt.state.escape(node.content.text);
+      return new Text(node.content.text);
     case 3 /* Text */:
     case 4 /* Escaped */:
-      return cxt.state.escape(node.content);
+      const split = node.content.split("\n");
+      const result = [];
+      for (let i = 0; i < split.length; i++) {
+        result.push(new Text(split[i]));
+        if (i < split.length - 1)
+          result.push(/* @__PURE__ */ jsx8("br", {}));
+      }
+      console.log(result);
+      return result;
     default:
       return debug.never(node);
   }
@@ -3007,8 +3320,8 @@ htmlConfig.addBlockRenderer(
   ...BulletBlockRenderersHTML,
   CodeBlockRendererHTML,
   ...QuoteBlockRenderersHTML,
-  ...MiscBlockRenderersHTML
-  // TODO: notes
+  ...MiscBlockRenderersHTML,
+  ...NoteBlockRenderersHTML
 );
 htmlConfig.addInlineRenderer(
   CodeInlineRendererHTML,
@@ -3019,6 +3332,7 @@ htmlConfig.addInlineRenderer(
 var HTMLRenderConfiguration = htmlConfig;
 
 // src/index.ts
+var emmmVersion = "0.0.6";
 function setDebugLevel(level) {
   debug.level = level;
 }
@@ -3040,8 +3354,11 @@ export {
   RenderConfiguration,
   RenderContext,
   SimpleScanner,
+  StringSource,
   SystemModifierDefinition,
   debugPrint,
+  emmmVersion,
+  modifier_helper_exports as helper,
   messages_exports as messages,
   parse,
   setDebugLevel