@the_dissidents/libemmm 0.0.8 → 0.0.9

package/dist/index.mjs

@@ -1,3366 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/interface.ts
-var MessageSeverity = /* @__PURE__ */ ((MessageSeverity2) => {
-  MessageSeverity2[MessageSeverity2["Info"] = 0] = "Info";
-  MessageSeverity2[MessageSeverity2["Warning"] = 1] = "Warning";
-  MessageSeverity2[MessageSeverity2["Error"] = 2] = "Error";
-  return MessageSeverity2;
-})(MessageSeverity || {});
-var NodeType = /* @__PURE__ */ ((NodeType2) => {
-  NodeType2[NodeType2["Root"] = 0] = "Root";
-  NodeType2[NodeType2["Paragraph"] = 1] = "Paragraph";
-  NodeType2[NodeType2["Preformatted"] = 2] = "Preformatted";
-  NodeType2[NodeType2["Text"] = 3] = "Text";
-  NodeType2[NodeType2["Escaped"] = 4] = "Escaped";
-  NodeType2[NodeType2["SystemModifier"] = 5] = "SystemModifier";
-  NodeType2[NodeType2["InlineModifier"] = 6] = "InlineModifier";
-  NodeType2[NodeType2["BlockModifier"] = 7] = "BlockModifier";
-  NodeType2[NodeType2["Interpolation"] = 8] = "Interpolation";
-  return NodeType2;
-})(NodeType || {});
-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, slotType = 0 /* Normal */, args) {
-    this.name = name;
-    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 inside it will *not* be expanded *during parse-content*, 
-   * *unless* that modifier is `alwaysTryExpand`. In the vast majority of cases, you shouldn't 
-   * be using this.
-   */
-  delayContentExpansion = false;
-  /**
-   * If true, such a modifier will always be expanded whenever it is encountered, *even if* 
-   * it is contained in a modifier with `delayContentExpansion`. In the vast majority of cases, 
-   * you shouldn't be using this.
-   */
-  alwaysTryExpand = false;
-  /** Called before the modifier's content is parsed. 
-   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
-  */
-  beforeParseContent;
-  /** Called after the modifier's content is parsed. 
-   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
-  */
-  afterParseContent;
-  /** Called before reparsing of the expansion. 
-   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.*/
-  beforeProcessExpansion;
-  /** Called before reparsing of the expansion. 
-   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.*/
-  afterProcessExpansion;
-  /**
-   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
-   */
-  prepareExpand;
-  /**
-   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
-   */
-  expand;
-};
-var BlockModifierDefinition = class extends ModifierBase {
-};
-var InlineModifierDefinition = class extends ModifierBase {
-};
-var SystemModifierDefinition = class extends ModifierBase {
-};
-var ArgumentInterpolatorDefinition = class {
-  constructor(name, postfix, args) {
-    this.name = name;
-    this.postfix = postfix;
-    if (args) Object.assign(this, args);
-  }
-  alwaysTryExpand = false;
-  expand;
-};
-
-// src/util.ts
-var NameManager = class _NameManager {
-  array = [];
-  data = /* @__PURE__ */ new Map();
-  constructor(from) {
-    if (from === void 0) return;
-    if (from instanceof _NameManager) {
-      this.array = [...from.array];
-      this.data = new Map(from.data);
-    } else {
-      const array = [...from];
-      assert((from instanceof Set ? from : new Set(array)).size == array.length);
-      this.array = array.map((x) => ({ k: x.name, v: x }));
-      this.array.sort((a, b) => b.k.length - a.k.length);
-      this.data = new Map(array.map((x) => [x.name, x]));
-    }
-  }
-  toArray() {
-    return this.array.map(({ v }) => v);
-  }
-  toSet() {
-    return new Set(this.toArray());
-  }
-  get(name) {
-    return this.data.get(name);
-  }
-  has(name) {
-    return this.data.has(name);
-  }
-  remove(name) {
-    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;
-  }
-}
-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/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, sourceDesc = { name: "<input>" }) {
-    this.src = src;
-    this.source = new StringSource(sourceDesc, src);
-  }
-  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: debugPrintMsg,
-  range: debugPrintRange,
-  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 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 ${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}${poss(loc)}`;
-  }
-  return result;
-}
-function debugDumpDocument(doc) {
-  let root = debugPrint.node(...doc.root.content);
-  let msgs = doc.messages.map((x) => debugPrintRange(x.location) + "\n" + debugPrintMsg(x)).join("\n");
-  if (msgs.length > 0) msgs += "\n";
-  return `Document: ${doc.root.source.name}
-${msgs}${root}`;
-}
-
-// src/messages.ts
-var messages_exports = {};
-__export(messages_exports, {
-  ArgumentCountMismatchMessage: () => ArgumentCountMismatchMessage,
-  CannotExpandArgumentMessage: () => CannotExpandArgumentMessage,
-  CannotUseModuleInSelfMessage: () => CannotUseModuleInSelfMessage,
-  EitherNormalOrPreMessage: () => EitherNormalOrPreMessage,
-  EntityNotAllowedMessage: () => EntityNotAllowedMessage,
-  ExpectedMessage: () => ExpectedMessage,
-  InvalidArgumentMessage: () => InvalidArgumentMessage,
-  MultipleBlocksNotPermittedMessage: () => MultipleBlocksNotPermittedMessage,
-  NameAlreadyDefinedMessage: () => NameAlreadyDefinedMessage,
-  NewBlockShouldBeOnNewlineMessage: () => NewBlockShouldBeOnNewlineMessage,
-  NoNestedModuleMessage: () => NoNestedModuleMessage,
-  OnlySimpleParagraphsPermittedMessage: () => OnlySimpleParagraphsPermittedMessage,
-  OverwriteDefinitionsMessage: () => OverwriteDefinitionsMessage,
-  OverwriteSpecialVariableMessage: () => OverwriteSpecialVariableMessage,
-  ReachedRecursionLimitMessage: () => ReachedRecursionLimitMessage,
-  ShouldBeOnNewlineMessage: () => ShouldBeOnNewlineMessage,
-  SlotUsedOutsideDefinitionMessage: () => SlotUsedOutsideDefinitionMessage,
-  UnclosedInlineModifierMessage: () => UnclosedInlineModifierMessage,
-  UndefinedVariableMessage: () => UndefinedVariableMessage,
-  UnknownModifierMessage: () => UnknownModifierMessage,
-  UnnecessaryNewlineMessage: () => UnnecessaryNewlineMessage
-});
-var AddThingMessage = class {
-  constructor(code, severity, location, info) {
-    this.code = code;
-    this.severity = severity;
-    this.location = location;
-    this.info = info;
-  }
-  // 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, location, info) {
-    this.code = code;
-    this.severity = severity;
-    this.location = location;
-    this.info = info;
-  }
-  // 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(location, what) {
-    this.location = location;
-    this.what = what;
-    assert(location.end == location.start);
-  }
-  code = 1;
-  severity = 2 /* Error */;
-  get info() {
-    return `expected '${this.what}'`;
-  }
-};
-var UnknownModifierMessage = class {
-  constructor(location, what) {
-    this.location = location;
-    this.what = what;
-  }
-  code = 2;
-  severity = 2 /* Error */;
-  get info() {
-    return `unknown modifier '${this.what}'`;
-  }
-  // 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(location, what) {
-    this.location = location;
-    this.what = what;
-    assert(location.end == location.start);
-  }
-  code = 3;
-  severity = 2 /* Error */;
-  get info() {
-    return `unclosed inline modifier ${this.what}'`;
-  }
-};
-var ArgumentCountMismatchMessage = class {
-  constructor(location, min, max) {
-    this.location = location;
-    if (min !== void 0) {
-      if (max == min) this.msg = `: ${min} expected`;
-      else if (max !== void 0) this.msg = `: ${min} to ${max} expected`;
-      else this.msg = `: at least ${min} expected`;
-    } else {
-      if (max !== void 0) this.msg = `: at most ${max} expected`;
-    }
-  }
-  msg = "";
-  code = 4;
-  severity = 2 /* Error */;
-  get info() {
-    return `argument count mismatch` + this.msg;
-  }
-};
-var CannotExpandArgumentMessage = class {
-  constructor(location, what) {
-    this.location = location;
-    this.what = what;
-  }
-  code = 5;
-  severity = 2 /* Error */;
-  get info() {
-    return `failed to expand argument` + (this.what === void 0 ? "" : `: ${this.what}`);
-  }
-};
-var InvalidArgumentMessage = class {
-  constructor(location, what) {
-    this.location = location;
-    this.what = what;
-  }
-  code = 6;
-  severity = 2 /* Error */;
-  get info() {
-    return `invalid argument` + (this.what === void 0 ? "" : `: ${this.what}`);
-  }
-};
-var EntityNotAllowedMessage = class {
-  constructor(location, what) {
-    this.location = location;
-    this.what = what;
-  }
-  code = 7;
-  severity = 2 /* Error */;
-  get info() {
-    return "This entity is not allowed here" + (this.what ? `: ${this.what}` : "");
-  }
-};
-var ReachedRecursionLimitMessage = class {
-  constructor(location, limit, what) {
-    this.location = location;
-    this.limit = limit;
-    this.what = what;
-  }
-  code = 8;
-  severity = 2 /* Error */;
-  get info() {
-    return `Reached recursion limit ${this.limit} when expanding ${this.what}`;
-  }
-};
-var SlotUsedOutsideDefinitionMessage = class {
-  constructor(location) {
-    this.location = location;
-  }
-  code = 9;
-  severity = 2 /* Error */;
-  get info() {
-    return `slot used outside a definition`;
-  }
-};
-var NoNestedModuleMessage = class {
-  constructor(location) {
-    this.location = location;
-  }
-  code = 10;
-  severity = 2 /* Error */;
-  get info() {
-    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(location) {
-    super(
-      1,
-      1 /* Warning */,
-      location,
-      "more than one newlines have the same effect as one"
-    );
-  }
-};
-var NewBlockShouldBeOnNewlineMessage = class extends AddThingMessage {
-  constructor(location) {
-    super(
-      2,
-      1 /* Warning */,
-      location,
-      "a new block should begin in a new line to avoid confusion"
-    );
-  }
-};
-var ShouldBeOnNewlineMessage = class extends AddThingMessage {
-  constructor(location) {
-    super(
-      3,
-      1 /* Warning */,
-      location,
-      "the following should begin in a new line to avoid confusion"
-    );
-  }
-};
-var NameAlreadyDefinedMessage = class {
-  constructor(location, what) {
-    this.location = location;
-    this.what = what;
-  }
-  code = 4;
-  severity = 1 /* Warning */;
-  get info() {
-    return `name is already defined, will overwrite: ${this.what}`;
-  }
-};
-var UndefinedVariableMessage = class {
-  constructor(location, what) {
-    this.location = location;
-    this.what = what;
-  }
-  code = 5;
-  severity = 1 /* Warning */;
-  get info() {
-    return `variable is undefined, will expand to empty string: ${this.what}`;
-  }
-};
-var OverwriteDefinitionsMessage = class {
-  constructor(location, what) {
-    this.location = location;
-    this.what = what;
-  }
-  code = 6;
-  severity = 1 /* Warning */;
-  get info() {
-    return `using this module will overwrite: ${this.what}`;
-  }
-};
-var OverwriteSpecialVariableMessage = class {
-  constructor(location, varname, previous) {
-    this.location = location;
-    this.varname = varname;
-    this.previous = previous;
-  }
-  code = 6;
-  severity = 1 /* Warning */;
-  get info() {
-    return `${this.varname} is already defined (as "${this.previous}"), will be overwritten`;
-  }
-};
-
-// 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));
-  }
-  data = {};
-  init(key, obj) {
-    assert(!(key in this.data));
-    this.data[key] = obj;
-  }
-  set(key, obj) {
-    assert(key in this.data);
-    this.data[key] = obj;
-  }
-  get(key) {
-    assert(key in this.data);
-    return this.data[key];
-  }
-};
-var Document = class _Document {
-  constructor(root, context, messages) {
-    this.root = root;
-    this.context = context;
-    this.messages = messages;
-  }
-  toStripped() {
-    let doc = new _Document(
-      stripNode(cloneNode(this.root, { withState: true }))[0],
-      this.context,
-      this.messages
-    );
-    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 = [];
-  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;
-  }
-};
-
-// src/parser.ts
-var GROUP_BEGIN = ":--";
-var GROUP_END = "--:";
-var MODIFIER_BLOCK_OPEN = "[.";
-var MODIFIER_CLOSE_SIGN = "]";
-var MODIFIER_END_SIGN = ";";
-var MODIFIER_INLINE_OPEN = "[/";
-var MODIFIER_INLINE_END_TAG = "[;]";
-var MODIFIER_SYSTEM_OPEN = "[-";
-var UnknownModifier = {
-  [7 /* BlockModifier */]: new BlockModifierDefinition("UNKNOWN", 0 /* Normal */),
-  [6 /* InlineModifier */]: new InlineModifierDefinition("UNKNOWN", 0 /* Normal */),
-  [5 /* SystemModifier */]: new SystemModifierDefinition("UNKNOWN", 0 /* Normal */)
-};
-var EmitEnvironment = class {
-  constructor(scanner) {
-    this.scanner = scanner;
-    this.root = { type: 0 /* Root */, source: scanner.source, content: [] };
-  }
-  root;
-  messages = [];
-  blockStack = [];
-  inlineStack = [];
-  message(...m) {
-    for (let msg of m) {
-      this.messages.push(msg);
-      debug.trace("issued msg", msg.code, msg.info);
-    }
-  }
-  addBlockNode(n) {
-    (this.blockStack.at(-1) ?? this.root).content.push(n);
-    return n;
-  }
-  addInlineNode(n) {
-    assert(this.inlineStack.length > 0);
-    this.inlineStack.at(-1).content.push(n);
-    return n;
-  }
-  addString(str) {
-    assert(this.inlineStack.length > 0);
-    const content = this.inlineStack.at(-1).content;
-    const last = content.at(-1);
-    if (last?.type == 3 /* Text */) {
-      last.content += str;
-      last.location.end = this.scanner.position();
-    } else content.push({
-      type: 3 /* Text */,
-      location: {
-        source: this.scanner.source,
-        start: this.scanner.position() - str.length,
-        end: this.scanner.position()
-      },
-      content: str
-    });
-  }
-  startBlock(block) {
-    this.addBlockNode(block);
-    this.blockStack.push(block);
-  }
-  endBlock() {
-    assert(this.blockStack.length > 0);
-    const node = this.blockStack.pop();
-    node.location.end = this.scanner.position();
-  }
-  startInline(n) {
-    if (n.type == 1 /* Paragraph */) this.addBlockNode(n);
-    else this.addInlineNode(n);
-    this.inlineStack.push(n);
-  }
-  endInline() {
-    assert(this.inlineStack.length > 0);
-    const node = this.inlineStack.pop();
-    node.location.end = this.scanner.position();
-  }
-};
-var Parser = class {
-  constructor(scanner, cxt) {
-    this.scanner = scanner;
-    this.cxt = cxt;
-    this.emit = new EmitEnvironment(scanner);
-  }
-  emit;
-  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()
-    };
-  }
-  /* istanbul ignore next -- @preserve */
-  #defs(type) {
-    switch (type) {
-      case 5 /* SystemModifier */:
-        return this.cxt.config.systemModifiers;
-      case 6 /* InlineModifier */:
-        return this.cxt.config.inlineModifiers;
-      case 7 /* BlockModifier */:
-        return this.cxt.config.blockModifiers;
-      default:
-        return debug.never(type);
-    }
-  }
-  #reparse(nodes, depth) {
-    if (depth > this.cxt.config.reparseDepthLimit) return false;
-    let ok = true;
-    for (const node of nodes) {
-      switch (node.type) {
-        case 2 /* Preformatted */:
-        case 3 /* Text */:
-        case 4 /* Escaped */:
-          continue;
-        case 1 /* Paragraph */:
-          ok = this.#reparse(node.content, depth + 1) && ok;
-          continue;
-        case 7 /* BlockModifier */:
-        case 6 /* InlineModifier */:
-        case 5 /* SystemModifier */:
-          ok = this.#expand(node, depth + 1) && ok;
-          continue;
-        default:
-          debug.never(node);
-      }
-    }
-    return ok;
-  }
-  #expandArgument(arg) {
-    if (arg.expansion !== void 0)
-      return arg.expansion;
-    let result = "";
-    const immediate = this.delayDepth == 0;
-    for (const e of arg.content) {
-      switch (e.type) {
-        case 3 /* Text */:
-        case 4 /* Escaped */:
-          result += e.content;
-          break;
-        case 8 /* Interpolation */:
-          if (e.expansion === void 0) {
-            const inner = this.#expandArgument(e.argument);
-            if (inner === void 0 || e.definition.expand === void 0 || !immediate && !e.definition.alwaysTryExpand)
-              return void 0;
-            e.expansion = e.definition.expand(inner, this.cxt, immediate);
-            if (e.expansion === void 0)
-              return void 0;
-          }
-          result += e.expansion;
-          break;
-        default:
-          debug.never(e);
-      }
-    }
-    arg.expansion = result;
-    return result;
-  }
-  #expandArguments(node) {
-    for (const arg of node.arguments) {
-      this.#expandArgument(arg);
-    }
-  }
-  #expand(node, depth = 0) {
-    if (node.expansion !== void 0) {
-      debug.trace("already expanded, skipping:", node.mod.name);
-      return true;
-    }
-    if (depth > 0) {
-      this.#expandArguments(node);
-    }
-    if (this.delayDepth > 0 && !node.mod.alwaysTryExpand) {
-      debug.trace("delaying expansion of", node.mod.name);
-      return true;
-    }
-    const immediate = this.delayDepth == 0;
-    if (depth > 0) {
-      if (node.mod.beforeParseContent)
-        this.emit.message(...node.mod.beforeParseContent(node, this.cxt, immediate));
-      if (node.content.length > 0) {
-        if (node.mod.delayContentExpansion) this.delayDepth++;
-        this.#reparse(node.content, depth);
-        if (node.mod.delayContentExpansion) this.delayDepth--;
-      }
-      if (node.mod.afterParseContent)
-        this.emit.message(...node.mod.afterParseContent(node, this.cxt, immediate));
-    }
-    if (node.mod.prepareExpand)
-      this.emit.message(...node.mod.prepareExpand(node, this.cxt, immediate));
-    if (node.mod.expand) {
-      node.expansion = node.mod.expand(node, this.cxt, immediate);
-      if (!node.expansion) {
-        return true;
-      }
-      debug.trace(`${this.delayDepth > 0 ? "early " : ""}expanding:`, node.mod.name);
-      if (node.expansion.length > 0)
-        debug.trace(() => "-->\n" + debugPrint.node(...node.expansion));
-    }
-    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));
-    let ok = this.#reparse(expansion, depth);
-    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.location, limit, node.mod.name)
-      );
-    }
-    return ok;
-  }
-  parse() {
-    this.DOCUMENT();
-    return new Document(this.emit.root, this.cxt, this.emit.messages);
-  }
-  WHITESPACES() {
-    while (this.scanner.acceptWhitespaceChar() !== null) {
-    }
-  }
-  WHITESPACES_OR_NEWLINES() {
-    while (this.scanner.acceptWhitespaceChar() !== null || this.scanner.accept("\n")) {
-    }
-  }
-  SHOULD_BE_A_NEWLINE() {
-    this.WHITESPACES();
-    if (!this.scanner.accept("\n")) this.emit.message(
-      new ShouldBeOnNewlineMessage(this.#loc())
-    );
-  }
-  // TODO: this is awkward and doesn't emit messages in the most appropriate way
-  WARN_IF_MORE_NEWLINES_THAN(n) {
-    let nlines = 0;
-    const start = this.scanner.position();
-    while (true) {
-      if (this.scanner.accept("\n")) {
-        nlines++;
-        continue;
-      }
-      if (this.scanner.acceptWhitespaceChar() == null) break;
-    }
-    const end = this.scanner.position();
-    if (nlines > n) this.emit.message(
-      new UnnecessaryNewlineMessage(this.#locFrom(start, end))
-    );
-  }
-  DOCUMENT() {
-    this.WHITESPACES_OR_NEWLINES();
-    while (!this.scanner.isEOF()) {
-      this.BLOCK_ENTITY();
-      this.WHITESPACES_OR_NEWLINES();
-    }
-  }
-  BLOCK_ENTITY() {
-    assert(!this.scanner.isEOF());
-    if (this.scanner.peek(MODIFIER_BLOCK_OPEN)) {
-      this.MODIFIER(7 /* BlockModifier */);
-      return;
-    }
-    if (this.scanner.peek(MODIFIER_SYSTEM_OPEN)) {
-      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) {
-    const posStart = this.scanner.position();
-    assert(this.scanner.accept({
-      [7 /* BlockModifier */]: MODIFIER_BLOCK_OPEN,
-      [5 /* SystemModifier */]: MODIFIER_SYSTEM_OPEN,
-      [6 /* InlineModifier */]: MODIFIER_INLINE_OPEN
-    }[type]));
-    const result = this.#defs(type).find((x) => this.scanner.accept(x.name));
-    const mod = result ?? UnknownModifier[type];
-    if (result === void 0) {
-      let name = "";
-      while (!this.scanner.isEOF() && !this.scanner.acceptWhitespaceChar() && !this.scanner.peek(MODIFIER_CLOSE_SIGN) && !this.scanner.peek(MODIFIER_END_SIGN)) {
-        if (this.scanner.accept("\\")) {
-          if (this.scanner.isEOF()) break;
-        }
-        name += this.scanner.acceptChar();
-      }
-      this.emit.message(
-        new UnknownModifierMessage(this.#locFrom(posStart), name)
-      );
-    }
-    const args = this.ARGUMENTS();
-    debug.trace(`PARSE ${NodeType[type]}:`, mod.name);
-    const endsign = this.scanner.accept(MODIFIER_END_SIGN);
-    const flagMarker = mod.slotType == 2 /* None */;
-    if (!this.scanner.accept(MODIFIER_CLOSE_SIGN))
-      this.emit.message(
-        new ExpectedMessage(this.#loc(), MODIFIER_CLOSE_SIGN)
-      );
-    const headEnd = this.scanner.position();
-    const node = {
-      type,
-      mod,
-      head: this.#locFrom(posStart, headEnd),
-      location: this.#locFrom(posStart, headEnd),
-      arguments: args,
-      content: [],
-      expansion: void 0
-    };
-    const isMarker = flagMarker || endsign;
-    return this.MODIFIER_BODY(type, node, MODIFIER_INLINE_END_TAG, isMarker);
-  }
-  // also handles "grouped" (delimited) pre-paragraphs
-  PRE_PARAGRAPH() {
-    assert(!this.scanner.isEOF());
-    const posStart = this.scanner.position();
-    const grouped = this.scanner.accept(GROUP_BEGIN);
-    if (grouped) this.SHOULD_BE_A_NEWLINE();
-    const posContentStart = this.scanner.position();
-    let posContentEnd = this.scanner.position();
-    let paragraphEnd = void 0;
-    let string = "";
-    while (!this.scanner.isEOF()) {
-      if (this.scanner.accept("\n")) {
-        let white = "\n";
-        let char;
-        while ((char = this.scanner.acceptWhitespaceChar()) !== null)
-          white += char;
-        if (grouped && this.scanner.accept(GROUP_END)) {
-          paragraphEnd = this.scanner.position();
-          if (!this.scanner.isEOF()) {
-            this.SHOULD_BE_A_NEWLINE();
-            this.WARN_IF_MORE_NEWLINES_THAN(1);
-          }
-          break;
-        }
-        if (!grouped && this.scanner.accept("\n")) {
-          paragraphEnd = this.scanner.position() - 1;
-          if (!this.scanner.isEOF())
-            this.WARN_IF_MORE_NEWLINES_THAN(0);
-          break;
-        }
-        if (this.scanner.isEOF()) {
-          if (grouped) this.emit.message(
-            new ExpectedMessage(this.#loc(), GROUP_END)
-          );
-          break;
-        }
-        string += white;
-      } else {
-        string += this.scanner.acceptChar();
-      }
-      posContentEnd = this.scanner.position();
-    }
-    const node = {
-      type: 2 /* Preformatted */,
-      location: this.#locFrom(posStart, paragraphEnd ?? posContentEnd),
-      content: {
-        start: posContentStart,
-        end: posContentEnd,
-        text: string
-      }
-    };
-    this.emit.addBlockNode(node);
-  }
-  MAYBE_GROUPED_PARAGRAPH() {
-    assert(!this.scanner.isEOF());
-    if (this.scanner.accept(GROUP_BEGIN)) {
-      this.groupDepth++;
-      this.SHOULD_BE_A_NEWLINE();
-      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;
-        }
-        this.BLOCK_ENTITY();
-        this.WARN_IF_MORE_NEWLINES_THAN(1);
-      }
-      this.emit.message(
-        new ExpectedMessage(this.#loc(), GROUP_END)
-      );
-    } else {
-      this.PARAGRAPH();
-    }
-  }
-  #trimNode(node) {
-    if (node.content.length == 0) return;
-    let first = node.content[0];
-    let last = node.content.at(-1);
-    if (first.type == 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 */,
-      location: this.#loc(),
-      content: []
-    };
-    this.emit.startInline(node);
-    while (!this.scanner.isEOF() && this.INLINE_ENTITY()) {
-    }
-    this.emit.endInline();
-    const last = node.content.at(-1);
-    node.location.actualEnd = last?.location.actualEnd ?? last?.location.end;
-    this.#trimNode(node);
-  }
-  // 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 (!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 */) {
-      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_INLINE_OPEN))
-      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("\\")) {
-      if (this.scanner.isEOF()) {
-        this.emit.addString("\\");
-        return true;
-      }
-      const start = this.scanner.position();
-      const node = {
-        type: 4 /* Escaped */,
-        content: this.scanner.acceptChar(),
-        location: this.#locFrom(start - 1)
-      };
-      this.emit.addInlineNode(node);
-      return true;
-    }
-    return this.PREFORMATTED_INLINE_ENTITY();
-  }
-  // returns false if breaking out of paragraph
-  PREFORMATTED_INLINE_ENTITY() {
-    assert(!this.scanner.isEOF());
-    if (this.scanner.accept("\n")) {
-      this.WHITESPACES();
-      if (this.scanner.peek(MODIFIER_BLOCK_OPEN) || this.scanner.peek(MODIFIER_SYSTEM_OPEN) || this.cxt.config.blockShorthands.find((x) => this.scanner.peek(x.name)) || this.scanner.peek(GROUP_END) && this.groupDepth > 0 || this.scanner.isEOF()) return false;
-      if (this.scanner.accept("\n")) {
-        this.WARN_IF_MORE_NEWLINES_THAN(0);
-        return false;
-      }
-      this.emit.addString("\n");
-      return true;
-    }
-    this.emit.addString(this.scanner.acceptChar());
-    return true;
-  }
-  // 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();
-    let posEnd = this.scanner.position();
-    const emitString = (s) => {
-      const last = content.at(-1);
-      if (last?.type == 3 /* Text */) {
-        last.content += s;
-        last.location.end += s.length;
-      } else {
-        const end2 = this.scanner.position();
-        content.push({
-          type: 3 /* Text */,
-          location: this.#locFrom(end2 - s.length),
-          content: s
-        });
-      }
-    };
-    while (true) {
-      if (end && this.scanner.accept(end))
-        break;
-      if (end === void 0 && this.scanner.accept(":"))
-        break;
-      if (close.find((x) => this.scanner.peek(x)) || this.scanner.isEOF()) {
-        ok = false;
-        break;
-      }
-      if (this.scanner.accept("\\")) {
-        posEnd = this.scanner.position();
-        if (this.scanner.isEOF()) {
-          emitString("\\");
-          ok = false;
-          break;
-        }
-        content.push({
-          type: 4 /* Escaped */,
-          content: this.scanner.acceptChar(),
-          location: this.#locFrom(posEnd - 1)
-        });
-        continue;
-      }
-      const beforeInterp = this.scanner.position();
-      const result = this.cxt.config.argumentInterpolators.find(
-        (x) => this.scanner.accept(x.name)
-      );
-      if (result !== void 0) {
-        const [inner, ok2] = this.ARGUMENT_CONTENT(result.postfix);
-        posEnd = this.scanner.position();
-        content.push({
-          type: 8 /* Interpolation */,
-          definition: result,
-          argument: inner,
-          location: this.#locFrom(beforeInterp)
-        });
-        if (!ok2) {
-          this.emit.message(new ExpectedMessage(this.#loc(), result.postfix));
-          ok = false;
-          break;
-        }
-      } else {
-        emitString(this.scanner.acceptChar());
-        posEnd = this.scanner.position();
-      }
-    }
-    return [{
-      location: this.#locFrom(posStart, posEnd),
-      content
-    }, ok];
-  }
-  ARGUMENTS() {
-    const firstSemicolon = this.scanner.accept(":");
-    if (!firstSemicolon) this.WHITESPACES_OR_NEWLINES();
-    const list = [];
-    let end = false;
-    while (!end) {
-      const [arg, ok] = this.ARGUMENT_CONTENT();
-      if (!ok) {
-        end = true;
-        if (list.length == 0 && arg.content.length == 0 && !firstSemicolon)
-          break;
-      }
-      list.push(arg);
-    }
-    return list;
-  }
-};
-function parse(scanner, cxt) {
-  return new Parser(scanner, cxt).parse();
-}
-
-// src/renderer.ts
-var RenderContext = class {
-  constructor(config2, parsedDocument, state) {
-    this.config = config2;
-    this.parsedDocument = parsedDocument;
-    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, 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
-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({
-      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.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 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"
-      )];
-      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 checkContent(node.content);
-}
-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();
-function initParseContext(cxt) {
-  cxt.init(builtins, {
-    blockSlotDelayedStack: [],
-    inlineSlotDelayedStack: [],
-    blockInstantiationData: [],
-    inlineInstantiationData: [],
-    modules: /* @__PURE__ */ new Map(),
-    usedModules: /* @__PURE__ */ new Set(),
-    insideModule: void 0
-  });
-}
-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, signature.args.length);
-    if (check) return check;
-    node.state = {
-      ok: true,
-      args: new Map(node.arguments.map((x, i) => [signature.args[i], x.expansion]))
-    };
-    return [];
-  };
-  mod.expand = (node) => {
-    if (!node.state?.ok) return [];
-    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.inlineInstantiationData : store.blockInstantiationData;
-    data.push({
-      slotName: signature.slotName,
-      mod,
-      args: node.state.args,
-      slotContent: node.content
-    });
-    debug.trace(`pushed ${NodeType[type]} slot data for`, name);
-    debug.trace(
-      `... slotName:`,
-      signature.slotName === "" ? "<unnamed>" : signature.slotName === void 0 ? "<no slot>" : `'${signature.slotName}'`
-    );
-    debug.trace(`... args:`, "{" + [...node.state.args].map(([a, b]) => `${a} => ${b}`).join(", ") + "}");
-    return [];
-  };
-  mod.afterProcessExpansion = (node, cxt) => {
-    if (!node.state?.ok) return [];
-    const store = cxt.get(builtins);
-    const data = isInline ? store.inlineInstantiationData : store.blockInstantiationData;
-    data.pop();
-    debug.trace(`popped ${NodeType[type]} slot data for`, name);
-    return [];
-  };
-  return mod;
-}
-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);
-    }
-  }
-  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.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 [];
-    }
-  }
-);
-
-// 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++;
-          }
-        } else msgs.push(
-          new ArgumentCountMismatchMessage(node.location)
-        );
-      }
-      break;
-    }
-    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 [];
-    }
-  }
-);
-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/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);
-  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(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.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 UseSystemMod = new SystemModifierDefinition(
-  "use",
-  2 /* None */,
-  {
-    prepareExpand(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 [added, msg] = addDef(data.modules.get(name.expansion), getDefs(cxt));
-      node.state = added;
-      if (msg)
-        return [new OverwriteDefinitionsMessage(node.head, msg)];
-      return [];
-    },
-    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(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 [];
-    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 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 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;
-      }
-      if (immediate) {
-        node.state = { ok: false };
-        const arg = node.arguments[0];
-        return [new InvalidArgumentMessage(arg.location, 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 [];
-    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.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.mod.name);
-    const data = isInline ? store.inlineInstantiationData : store.blockInstantiationData;
-    data.splice(node.state.index, 0, node.state.data);
-    return [];
-  };
-  return mod;
-}
-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.inlineInstantiationData.length - 1; i >= 0; i--) {
-    const data = store.inlineInstantiationData[i];
-    if ((value = data.args.get(id)) !== void 0)
-      break;
-  }
-  for (let i = store.blockInstantiationData.length - 1; i >= 0; i--) {
-    const data = store.blockInstantiationData[i];
-    if ((value = data.args.get(id)) !== void 0)
-      break;
-  }
-  if (value === void 0)
-    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 */,
-  {
-    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 /* 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) {
-      const result = resolveId(content, cxt);
-      if (result !== void 0) debug.trace(`$(${content}) --> ${result}`);
-      return result;
-    }
-  }
-);
-var VarMod = new SystemModifierDefinition("var", 2 /* None */, {
-  // .var id:value
-  prepareExpand(node, cxt) {
-    const check = checkArguments(node, 2);
-    if (check) return check;
-    const arg = node.arguments[0];
-    const id = arg.expansion;
-    if (id == "")
-      return [new InvalidArgumentMessage(arg.location)];
-    node.state = {
-      id,
-      value: node.arguments[1].expansion
-    };
-    return [];
-  },
-  expand(node, cxt) {
-    if (node.state) {
-      cxt.variables.set(node.state.id, node.state.value);
-      debug.trace("set variable", node.state.id, "=", node.state.value);
-    }
-    return [];
-  }
-});
-
-// src/builtin/builtin.ts
-var builtin = new Configuration();
-builtin.initializers = [initParseContext];
-builtin.systemModifiers.add(
-  DefineBlockMod,
-  DefineInlineMod,
-  DefineBlockShorthandMod,
-  DefineInlineShorthandMod,
-  VarMod,
-  UseSystemMod
-);
-builtin.blockModifiers.add(
-  SlotBlockMod,
-  PreSlotBlockMod,
-  InjectPreSlotBlockMod,
-  ModuleMod,
-  UseBlockMod,
-  IfdefBlockMod,
-  IfndefBlockMod,
-  RawBlockMod
-);
-builtin.inlineModifiers.add(
-  SlotInlineMod,
-  PreSlotInlineMod,
-  InjectPreSlotInlineMod,
-  GetVarInlineMod,
-  PrintInlineMod,
-  IfdefInlineMod,
-  IfndefInlineMod
-);
-builtin.argumentInterpolators.add(GetVarInterpolator);
-var BuiltinConfiguration = Object.freeze(builtin);
-
-// src/default/bullets.tsx
-import { jsx } from "minimal-jsx-runtime/jsx-runtime";
-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) => /* @__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.tsx
-import { jsx as jsx2 } from "minimal-jsx-runtime/jsx-runtime";
-var headings = Symbol();
-function initHeadings(cxt) {
-  cxt.init(headings, {
-    path: []
-  });
-}
-function setHeading(cxt, data) {
-  const path = cxt.get(headings).path;
-  while (path.length > 0 && path.at(-1).level >= data.level)
-    path.pop();
-  path.push(data);
-  return [];
-}
-function currentHeadingLevel(cxt) {
-  return cxt.get(headings).path.at(-1)?.level;
-}
-function currentExplicitHeadingLevel(cxt) {
-  return cxt.get(headings).path.findLast((x) => !x.implicit)?.level;
-}
-var headingBlock = new BlockModifierDefinition(
-  "heading",
-  0 /* Normal */,
-  {
-    roleHint: "heading",
-    prepareExpand(node, cxt) {
-      let msgs = checkArguments(node, 0, 1);
-      if (msgs) return msgs;
-      msgs = onlyPermitSingleBlock(node);
-      if (msgs) return msgs;
-      msgs = onlyPermitSimpleParagraphs(node);
-      if (msgs) return msgs;
-      node.state = { name: void 0, level: currentHeadingLevel(cxt) ?? 1 };
-      if (node.arguments.length == 1) {
-        const arg = node.arguments[0];
-        const level = Number.parseInt(arg.expansion);
-        if (isNaN(level) || level < 1 || level > 6)
-          msgs = [new InvalidArgumentMessage(
-            arg.location,
-            "should be a number between 1 and 6"
-          )];
-        else node.state.level = level;
-      }
-      setHeading(cxt, node.state);
-      return msgs ?? [];
-    }
-  }
-);
-var implicitHeadingBlock = new BlockModifierDefinition(
-  "implicit-heading",
-  2 /* None */,
-  {
-    roleHint: "heading",
-    prepareExpand(node, cxt) {
-      let msgs = checkArguments(node, 0, 1);
-      if (msgs) return msgs;
-      node.state = {
-        name: void 0,
-        implicit: true,
-        level: (currentExplicitHeadingLevel(cxt) ?? 0) + 1
-      };
-      if (node.arguments.length == 1) {
-        const arg = node.arguments[0];
-        const level = Number.parseInt(arg.expansion);
-        if (isNaN(level) || level < 1 || level > 6)
-          msgs = [new InvalidArgumentMessage(
-            arg.location,
-            "should be a number between 1 and 6"
-          )];
-        else node.state.level = level;
-      }
-      setHeading(cxt, node.state);
-      return msgs ?? [];
-    }
-  }
-);
-var numberedHeadingBlock = new BlockModifierDefinition(
-  "numbered-heading",
-  0 /* Normal */,
-  {
-    roleHint: "heading",
-    prepareExpand(node, cxt) {
-      let msgs = checkArguments(node, 1);
-      if (msgs) return msgs;
-      msgs = onlyPermitSingleBlock(node);
-      if (msgs) return msgs;
-      msgs = onlyPermitSimpleParagraphs(node);
-      if (msgs) return msgs;
-      node.state = { name: void 0, level: currentHeadingLevel(cxt) ?? 1 };
-      const arg = node.arguments[0];
-      const split = arg.expansion.trim().split(".").filter((x) => x.length > 0);
-      if (split.length == 0 || split.length > 6)
-        msgs = [new InvalidArgumentMessage(
-          arg.location,
-          "should be a number between 1 and 6"
-        )];
-      else node.state = { name: split.join("."), level: split.length };
-      setHeading(cxt, node.state);
-      return msgs ?? [];
-    }
-  }
-);
-var HeadingBlocks = [headingBlock, implicitHeadingBlock, numberedHeadingBlock];
-var HeadingBlockRenderersHTML = [
-  [headingBlock, (node, cxt) => {
-    if (node.state !== void 0) {
-      const tag = "h" + node.state.level;
-      const para = node.content[0];
-      const element = document.createElement(tag);
-      element.appendChild(cxt.state.render(para.content, cxt));
-      return element;
-    }
-    return cxt.state.invalidBlock(node, "Bad format");
-  }],
-  [implicitHeadingBlock, (node, cxt) => {
-    if (node.state !== void 0) {
-      const tag = "h" + node.state.level;
-      const element = document.createElement(tag);
-      element.className = "implicit";
-      return element;
-    }
-    return cxt.state.invalidBlock(node, "Bad format");
-  }],
-  [numberedHeadingBlock, (node, cxt) => {
-    if (node.state !== void 0) {
-      const tag = "h" + node.state.level;
-      const 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.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(),
-    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 */,
-  {
-    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?.trim() ?? "";
-      return [];
-    },
-    afterProcessExpansion(node, cxt) {
-      if (node.state !== void 0) {
-        const defs = cxt.get(notes);
-        defs.definitions.push({
-          system: "",
-          id: defs.currentId,
-          name: node.state,
-          location: node.location,
-          content: [{
-            type: 1 /* Paragraph */,
-            location: {
-              source: node.location.source,
-              start: node.head.end,
-              end: node.location.actualEnd ?? node.location.end
-            },
-            content: node.content
-          }]
-        });
-        defs.currentId++;
-      }
-      return [];
-    }
-  }
-);
-var noteBlock = new BlockModifierDefinition(
-  "note",
-  0 /* Normal */,
-  {
-    roleHint: "quote",
-    prepareExpand(node, cxt) {
-      let msgs = checkArguments(node, 1, 2);
-      if (msgs) return msgs;
-      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));
-      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.parsedDocument.context.get(notes).definitions;
-    const note = defs.findIndex((x) => (
-      /*x.position >= node.start &&*/
-      x.name == node.state
-    ));
-    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) => {
-  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.tsx
-import { jsx as jsx4 } from "minimal-jsx-runtime/jsx-runtime";
-var CodeBlock = new BlockModifierDefinition(
-  "code",
-  1 /* Preformatted */,
-  { roleHint: "code" }
-);
-var CodeInline = new InlineModifierDefinition(
-  "code",
-  1 /* Preformatted */,
-  { roleHint: "code" }
-);
-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.tsx
-import { jsx as jsx5 } from "minimal-jsx-runtime/jsx-runtime";
-var quoteBlock = new BlockModifierDefinition(
-  "quote",
-  0 /* Normal */,
-  { roleHint: "quote" }
-);
-var epitaphBlock = new BlockModifierDefinition(
-  "epitaph",
-  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 */,
-  {
-    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, calloutBlock, detailBlock, attributionBlock];
-var QuoteBlockRenderersHTML = [
-  [
-    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 /* @__PURE__ */ jsx5("p", { class: "attribution", children: cxt.state.render(para.content, cxt) });
-  }]
-];
-
-// src/default/inline-styles.tsx
-import { jsx as jsx6 } from "minimal-jsx-runtime/jsx-runtime";
-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 sequenceInline = new InlineModifierDefinition(
-  "seq",
-  0 /* Normal */,
-  { roleHint: "commentary" }
-);
-var InlineStyles = [emphasisInline, keywordInline, highlightInline, commentaryInline, sequenceInline];
-var InlineStyleRenderersHTML = [
-  [
-    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.tsx
-import { jsx as jsx7, jsxs as jsxs2 } from "minimal-jsx-runtime/jsx-runtime";
-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 styleBlock = new BlockModifierDefinition(
-  "style",
-  0 /* Normal */,
-  {
-    prepareExpand(node) {
-      let msgs = checkArguments(node, 1);
-      if (msgs) return msgs;
-      node.state = node.arguments[0].expansion;
-      return [];
-    }
-  }
-);
-var breakBlock = new BlockModifierDefinition(
-  "break",
-  2 /* None */
-);
-var linkBlock = new BlockModifierDefinition(
-  "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;
-      node.state = node.arguments.map((x) => x.expansion).join(":");
-      return [];
-    }
-  }
-);
-var MiscInlines = [rubyInline, linkInline];
-var MiscBlocks = [styleBlock, breakBlock, linkBlock, imageBlock];
-var MiscInlineRenderersHTML = [
-  [
-    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) => 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) => {
-    if (node.state === void 0)
-      return cxt.state.invalidBlock(node, "bad format");
-    let transformed;
-    try {
-      transformed = cxt.config.options.transformAsset(node.state);
-    } catch {
-      return cxt.state.invalidBlock(node, "unable to transform asset");
-    }
-    return /* @__PURE__ */ 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) }) : []
-    ] });
-  }]
-];
-
-// 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;
-      const result = onlyPermitPlaintextParagraph(node);
-      if (typeof result !== "string") return result;
-      const previous = cxt.variables.get(varname);
-      if (previous)
-        msgs = [new OverwriteSpecialVariableMessage(node.head, varname, previous)];
-      cxt.variables.set(varname, result);
-      debug.trace(varname, "->", result);
-      return msgs ?? [];
-    }
-  });
-}
-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, initHeadings);
-config.blockModifiers.add(
-  ...HeadingBlocks,
-  ...BulletBlocks,
-  CodeBlock,
-  ...QuoteBlocks,
-  ...MiscBlocks,
-  ...NoteBlocks
-);
-config.inlineModifiers.add(
-  CodeInline,
-  ...InlineStyles,
-  ...MiscInlines,
-  ...NoteInlines
-);
-config.systemModifiers.add(
-  ...VarWrappers,
-  ...NoteSystems
-);
-var DefaultConfiguration = Object.freeze(config);
-
-// 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();
-  invalidBlock(node, msg) {
-    let name = NodeType[node.type];
-    if (node.type === 7 /* BlockModifier */)
-      name += ` (${node.mod.name})`;
-    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 /* @__PURE__ */ jsxs3("span", { class: "invalid", children: [
-      "Invalid ",
-      name,
-      ": ",
-      /* @__PURE__ */ jsx8("i", { children: msg })
-    ] });
-  }
-  render(elems, cxt) {
-    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(
-  {
-    headPlugins: [],
-    headerPlugins: [],
-    footerPlugins: [NotesFooterPlugin],
-    postprocessPlugins: [],
-    transformAsset: () => void 0
-    // postprocessPlugins: [],
-  },
-  (results, cxt) => {
-    let styles = cxt.state.stylesheet.replaceAll(
-      /var\(--(.*?)\)/g,
-      (m, c) => cxt.state.cssVariables.get(c) ?? m
-    );
-    let doc = document.implementation.createHTMLDocument(cxt.state.title);
-    doc.head.append(
-      /* @__PURE__ */ 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) => /* @__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 new Text(node.content.text);
-    case 3 /* Text */:
-    case 4 /* Escaped */:
-      const split = node.content.split("\n");
-      const result = [];
-      for (let i = 0; i < split.length; i++) {
-        result.push(new Text(split[i]));
-        if (i < split.length - 1)
-          result.push(/* @__PURE__ */ jsx8("br", {}));
-      }
-      console.log(result);
-      return result;
-    default:
-      return debug.never(node);
-  }
-};
-htmlConfig.undefinedBlockRenderer = (node, cxt) => {
-  return cxt.state.invalidBlock(node, `No renderer defined for ${node.mod.name}`);
-};
-htmlConfig.undefinedInlineRenderer = (node, cxt) => {
-  return cxt.state.invalidInline(node, `No renderer defined for ${node.mod.name}`);
-};
-htmlConfig.addBlockRenderer(
-  ...HeadingBlockRenderersHTML,
-  ...BulletBlockRenderersHTML,
-  CodeBlockRendererHTML,
-  ...QuoteBlockRenderersHTML,
-  ...MiscBlockRenderersHTML,
-  ...NoteBlockRenderersHTML
-);
-htmlConfig.addInlineRenderer(
-  CodeInlineRendererHTML,
-  ...InlineStyleRenderersHTML,
-  ...MiscInlineRenderersHTML,
-  ...NoteInlineRenderersHTML
-);
-var HTMLRenderConfiguration = htmlConfig;
-
-// src/index.ts
-var emmmVersion = "0.0.6";
-function setDebugLevel(level) {
-  debug.level = level;
-}
-export {
-  ArgumentInterpolatorDefinition,
-  BlockModifierDefinition,
-  BuiltinConfiguration,
-  Configuration,
-  DebugLevel,
-  DefaultConfiguration,
-  Document,
-  HTMLRenderConfiguration,
-  HTMLRenderState,
-  InlineModifierDefinition,
-  MessageSeverity,
-  ModifierSlotType,
-  NodeType,
-  ParseContext,
-  RenderConfiguration,
-  RenderContext,
-  SimpleScanner,
-  StringSource,
-  SystemModifierDefinition,
-  debugPrint,
-  emmmVersion,
-  modifier_helper_exports as helper,
-  messages_exports as messages,
-  parse,
-  setDebugLevel
-};
-//# sourceMappingURL=index.mjs.map