@the_dissidents/libemmm 0.0.5 → 0.0.7

package/dist/index.js

@@ -37,8 +37,10 @@ __export(index_exports, {
   RenderConfiguration: () => RenderConfiguration,
   RenderContext: () => RenderContext,
   SimpleScanner: () => SimpleScanner,
+  StringSource: () => StringSource,
   SystemModifierDefinition: () => SystemModifierDefinition,
   debugPrint: () => debugPrint,
+  emmmVersion: () => emmmVersion,
   messages: () => messages_exports,
   parse: () => parse,
   setDebugLevel: () => setDebugLevel
@@ -78,22 +80,38 @@ var ModifierBase = class {
   }
   roleHint;
   /**
-   * If true, any modifier encountered in the content of it will *not* be expanded, *unless* that modifier is `alwaysTryExpand`.
+   * If true, any modifier encountered inside it will *not* be expanded *during parse-content*, 
+   * *unless* that modifier is `alwaysTryExpand`. In the vast majority of cases, you shouldn't 
+   * be using this.
    */
   delayContentExpansion = false;
   /**
-   * If true, such a modifier will always be expanded whenever it is encountered, *even if* contained in a modifier with `delayContentExpansion`.
+   * If true, such a modifier will always be expanded whenever it is encountered, *even if* 
+   * contained in a modifier with `delayContentExpansion`. In the vast majority of cases, 
+   * you shouldn't be using this.
    */
   alwaysTryExpand = false;
-  /** Called before the modifier's content is parsed. */
+  /** Called before the modifier's content is parsed. 
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+  */
   beforeParseContent;
-  /** Called after the modifier's content is parsed. */
+  /** Called after the modifier's content is parsed. 
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+  */
   afterParseContent;
-  /** Called before reparsing of the expansion. */
+  /** Called before reparsing of the expansion. 
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.*/
   beforeProcessExpansion;
-  /** Called before reparsing of the expansion. */
+  /** Called before reparsing of the expansion. 
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.*/
   afterProcessExpansion;
+  /**
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+   */
   prepareExpand;
+  /**
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+   */
   expand;
 };
 var BlockModifierDefinition = class extends ModifierBase {
@@ -169,14 +187,6 @@ function assert(x) {
     throw error;
   }
 }
-function linePositions(src) {
-  let result = [0];
-  [...src].forEach((x, i) => {
-    if (x == "\n") result.push(i + 1);
-  });
-  result.push(Infinity);
-  return result;
-}
 var cloneArgument = (arg, options) => ({
   location: clonePosition(arg.location, options),
   content: arg.content.map((ent) => {
@@ -305,12 +315,52 @@ var debug = {
   }
 };
 
+// src/source.ts
+var StringSource = class {
+  constructor(d, src) {
+    this.src = src;
+    this.name = d.name;
+    this.lineMap = [0];
+    [...src].forEach((x, i) => {
+      if (x == "\n") this.lineMap.push(i + 1);
+    });
+    this.nLines = this.lineMap.length;
+    this.lineMap.push(Infinity);
+  }
+  name;
+  nLines;
+  lineMap;
+  getRowCol(pos) {
+    let line = -1, linepos = 0;
+    for (let i = 1; i < this.lineMap.length; i++) {
+      if (this.lineMap[i] > pos) {
+        line = i - 1;
+        linepos = this.lineMap[i - 1];
+        break;
+      }
+    }
+    return [line, pos - linepos];
+  }
+  getLineStart(n) {
+    assert(n >= 0);
+    if (n >= this.lineMap.length) return Infinity;
+    return this.lineMap[n];
+  }
+  getLine(n) {
+    const start = this.getLineStart(n);
+    const end = this.getLineStart(n + 1);
+    if (start === Infinity) return void 0;
+    return this.src.substring(start, end - 1);
+  }
+};
+
 // src/scanner.ts
 var SimpleScanner = class {
-  constructor(src, source = { name: "<input>" }) {
+  constructor(src, sourceDesc = { name: "<input>" }) {
     this.src = src;
-    this.source = source;
+    this.source = new StringSource(sourceDesc, src);
   }
+  source;
   pos = 0;
   position() {
     return this.pos;
@@ -352,7 +402,8 @@ var debugPrint = {
   blockShorthand: (x) => x.name + x.parts.map((x2, i) => ` .. <arg${i}> .. ${x2}`).join("") + (x.mod.slotType == 2 /* None */ ? "" : ` .. <slot> .. ${x.postfix ?? "<no postfix>"}`),
   argument: (arg) => arg.content.map(debugPrintArgEntity).join(""),
   node: (...nodes) => nodes.map((x) => debugPrintNode(x)).join("\n"),
-  message: (m, source, descriptor) => debugPrintMsg(m, descriptor, source),
+  message: debugPrintMsg,
+  range: debugPrintRange,
   document: debugDumpDocument
 };
 function debugPrintArgEntity(node) {
@@ -422,38 +473,46 @@ ${prefix}<expansion />`;
   }
   return result;
 }
-function debugPrintMsg(m, descriptor, source) {
-  let pos = (pos2) => `@${pos2}`;
-  if (source) {
-    const lines = linePositions(source);
-    pos = (pos2) => {
-      let line = -1, linepos = 0;
-      for (let i = 1; i < lines.length; i++) {
-        if (lines[i] > pos2) {
-          line = i;
-          linepos = lines[i - 1];
-          break;
-        }
-      }
-      return `l${line}c${pos2 - linepos + 1}`;
-    };
+function debugPrintRange(loc, context = 1) {
+  const isSingleCharacter = loc.start == loc.end;
+  let [sr, sc] = loc.source.getRowCol(loc.start);
+  let [er, ec] = loc.source.getRowCol(loc.actualEnd ?? loc.end);
+  const rowWidth = Math.max((sr + 1).toString().length, (er + 1).toString().length);
+  const startLine = Math.max(0, sr - context);
+  const endLine = Math.min(loc.source.nLines - 1, er + context);
+  let lines = [];
+  for (let i = startLine; i <= endLine; i++) {
+    const line = loc.source.getLine(i);
+    lines.push((i + 1).toString().padStart(rowWidth) + " | " + line);
+    if (i >= sr && i <= er) {
+      const startPos = i == sr ? sc : 0;
+      const endPos = i == er ? ec : line.length;
+      lines.push(
+        " ".repeat(rowWidth) + " | " + " ".repeat(startPos) + (isSingleCharacter ? "^" : "~".repeat(endPos - startPos + 1))
+      );
+    }
   }
+  return lines.join("\n");
+}
+function debugPrintMsg(m) {
+  const poss = (loc2) => {
+    const [r1, c1] = loc2.source.getRowCol(loc2.start);
+    if (loc2.start == loc2.end) return `l${r1 + 1}c${c1 + 1}`;
+    const [r2, c2] = loc2.source.getRowCol(loc2.end);
+    return `l${r1 + 1}c${c1 + 1}-l${r2 + 1}c${c2 + 1}`;
+  };
   let loc = m.location;
-  let result = `at ${pos(loc.start)}-${pos(loc.end)}: ${MessageSeverity[m.severity]}[${m.code}]: ${m.info}`;
-  if (descriptor && m.location.source !== descriptor) {
-    result += `
-warning: source descriptor mismatch: ${m.location.source.name}`;
-  }
+  let result = `at ${poss(loc)}: ${MessageSeverity[m.severity]}[${m.code}]: ${m.info}`;
   while (loc = loc.original) {
     let d = loc.source !== m.location.source ? `(in ${loc.source.name}) ` : "";
     result += `
----> original at: ${d}${pos(loc.start)}-${pos(loc.end)}`;
+---> original at: ${d}${poss(loc)}`;
   }
   return result;
 }
-function debugDumpDocument(doc, source) {
+function debugDumpDocument(doc) {
   let root = debugPrint.node(...doc.root.content);
-  let msgs = doc.messages.map((x) => debugPrintMsg(x, doc.root.source, source)).join("\n");
+  let msgs = doc.messages.map((x) => debugPrintRange(x.location) + "\n" + debugPrintMsg(x)).join("\n");
   if (msgs.length > 0) msgs += "\n";
   return `Document: ${doc.root.source.name}
 ${msgs}${root}`;
@@ -465,7 +524,6 @@ __export(messages_exports, {
   ArgumentCountMismatchMessage: () => ArgumentCountMismatchMessage,
   CannotExpandArgumentMessage: () => CannotExpandArgumentMessage,
   CannotUseModuleInSelfMessage: () => CannotUseModuleInSelfMessage,
-  ContentShouldBeOnNewlineMessage: () => ContentShouldBeOnNewlineMessage,
   EitherNormalOrPreMessage: () => EitherNormalOrPreMessage,
   EntityNotAllowedMessage: () => EntityNotAllowedMessage,
   ExpectedMessage: () => ExpectedMessage,
@@ -478,6 +536,7 @@ __export(messages_exports, {
   OverwriteDefinitionsMessage: () => OverwriteDefinitionsMessage,
   OverwriteSpecialVariableMessage: () => OverwriteSpecialVariableMessage,
   ReachedRecursionLimitMessage: () => ReachedRecursionLimitMessage,
+  ShouldBeOnNewlineMessage: () => ShouldBeOnNewlineMessage,
   SlotUsedOutsideDefinitionMessage: () => SlotUsedOutsideDefinitionMessage,
   UnclosedInlineModifierMessage: () => UnclosedInlineModifierMessage,
   UndefinedVariableMessage: () => UndefinedVariableMessage,
@@ -544,7 +603,7 @@ var UnknownModifierMessage = class {
   code = 2;
   severity = 2 /* Error */;
   get info() {
-    return `unknown modifier '${this.what}'; did you forget to escape it?`;
+    return `unknown modifier '${this.what}'`;
   }
   // get fixes(): readonly FixSuggestion[] {
   //     let [start, end] = [this.start, this.end];
@@ -714,13 +773,13 @@ var NewBlockShouldBeOnNewlineMessage = class extends AddThingMessage {
     );
   }
 };
-var ContentShouldBeOnNewlineMessage = class extends AddThingMessage {
+var ShouldBeOnNewlineMessage = class extends AddThingMessage {
   constructor(location) {
     super(
       3,
       1 /* Warning */,
       location,
-      "the content should begin in a new line to avoid confusion"
+      "the following should begin in a new line to avoid confusion"
     );
   }
 };
@@ -805,6 +864,41 @@ var Document = class _Document {
     );
     return doc;
   }
+  /**
+   * Performs a depth-first walk of the node tree.
+   */
+  walk(callback) {
+    let nodes = this.root.content;
+    let node;
+    while (node = nodes.shift()) {
+      const result = callback(node);
+      if (result == "break") break;
+      if (result == "skip") continue;
+      if ("arguments" in node)
+        nodes.push(...node.arguments.flatMap((x) => x.content));
+      if ("content" in node && Array.isArray(node.content))
+        nodes.push(...node.content);
+    }
+  }
+  /**
+   * Gets all nodes that covers the given position, from outermost to innermost (essentially a path).
+   */
+  resolvePosition(pos) {
+    const result = [];
+    let nodes = this.root.content;
+    let node;
+    while (node = nodes.shift()) {
+      if (node.location.start <= pos && (node.location.actualEnd ?? node.location.end) >= pos) {
+        result.push(node);
+        nodes = [];
+        if ("arguments" in node)
+          nodes.push(...node.arguments.flatMap((x) => x.content));
+        if ("content" in node && Array.isArray(node.content))
+          nodes.push(...node.content);
+      }
+    }
+    return result;
+  }
 };
 var Configuration = class _Configuration {
   initializers = [];
@@ -1061,7 +1155,7 @@ var Parser = class {
   SHOULD_BE_A_NEWLINE() {
     this.WHITESPACES();
     if (!this.scanner.accept("\n")) this.emit.message(
-      new ContentShouldBeOnNewlineMessage(this.#loc())
+      new ShouldBeOnNewlineMessage(this.#loc())
     );
   }
   // TODO: this is awkward and doesn't emit messages in the most appropriate way
@@ -1151,14 +1245,28 @@ var Parser = class {
     if (grouped) this.SHOULD_BE_A_NEWLINE();
     const posContentStart = this.scanner.position();
     let posContentEnd = this.scanner.position();
+    let paragraphEnd = void 0;
     let string = "";
     while (!this.scanner.isEOF()) {
       if (this.scanner.accept("\n")) {
         let white = "\n";
-        let char = "";
+        let char;
         while ((char = this.scanner.acceptWhitespaceChar()) !== null)
           white += char;
-        if (grouped && this.scanner.accept(GROUP_END) || !grouped && this.scanner.accept("\n")) break;
+        if (grouped && this.scanner.accept(GROUP_END)) {
+          paragraphEnd = this.scanner.position();
+          if (!this.scanner.isEOF()) {
+            this.SHOULD_BE_A_NEWLINE();
+            this.WARN_IF_MORE_NEWLINES_THAN(1);
+          }
+          break;
+        }
+        if (!grouped && this.scanner.accept("\n")) {
+          paragraphEnd = this.scanner.position() - 1;
+          if (!this.scanner.isEOF())
+            this.WARN_IF_MORE_NEWLINES_THAN(0);
+          break;
+        }
         if (this.scanner.isEOF()) {
           if (grouped) this.emit.message(
             new ExpectedMessage(this.#loc(), GROUP_END)
@@ -1173,7 +1281,7 @@ var Parser = class {
     }
     const node = {
       type: 2 /* Preformatted */,
-      location: this.#locFrom(posStart),
+      location: this.#locFrom(posStart, paragraphEnd ?? posContentEnd),
       content: {
         start: posContentStart,
         end: posContentEnd,
@@ -1190,6 +1298,10 @@ var Parser = class {
       this.WARN_IF_MORE_NEWLINES_THAN(1);
       while (!this.scanner.isEOF()) {
         if (this.scanner.accept(GROUP_END)) {
+          if (!this.scanner.isEOF()) {
+            this.SHOULD_BE_A_NEWLINE();
+            this.WARN_IF_MORE_NEWLINES_THAN(1);
+          }
           this.groupDepth--;
           return;
         }
@@ -1260,6 +1372,10 @@ var Parser = class {
     if (node.mod.delayContentExpansion) this.delayDepth++;
     let ok = true;
     if (isMarker) {
+      if (!this.scanner.isEOF() && type == 7 /* BlockModifier */) {
+        this.SHOULD_BE_A_NEWLINE();
+        this.WARN_IF_MORE_NEWLINES_THAN(1);
+      }
       if (type === 6 /* InlineModifier */) this.emit.addInlineNode(node);
       else this.emit.addBlockNode(node);
     } else if (type == 6 /* InlineModifier */) {
@@ -1306,6 +1422,10 @@ var Parser = class {
       return this.MODIFIER(6 /* InlineModifier */);
     if (this.scanner.peek(MODIFIER_SYSTEM_OPEN))
       return false;
+    if (this.scanner.peek(MODIFIER_BLOCK_OPEN)) {
+      this.SHOULD_BE_A_NEWLINE();
+      return false;
+    }
     const short = this.cxt.config.inlineShorthands.find((x) => this.scanner.accept(x.name));
     if (short) return this.SHORTHAND(6 /* InlineModifier */, short);
     if (this.scanner.accept("\\")) {
@@ -1540,28 +1660,33 @@ function onlyPermitPlaintextParagraph(node) {
     }
     return result;
   }
+  function checkContent(ents) {
+    if (ents.length == 0) return "";
+    else if (ents.length > 1) {
+      let last = ents.at(-1).location;
+      return [new MultipleBlocksNotPermittedMessage({
+        source: last.source,
+        start: ents[1].location.start,
+        end: last.actualEnd ?? last.end
+      })];
+    }
+    return check(ents[0]);
+  }
   function check(ent) {
     if (ent.type == 7 /* BlockModifier */) {
       if (!ent.expansion) return [new EntityNotAllowedMessage(
         ent.location,
         "it does not expand to plain text"
       )];
-      if (ent.expansion.length == 0) return "";
-      else if (ent.expansion.length > 1) {
-        let last = ent.expansion.at(-1).location;
-        return [new MultipleBlocksNotPermittedMessage({
-          source: last.source,
-          start: ent.expansion[1].location.start,
-          end: last.actualEnd ?? last.end
-        })];
-      }
-      return check(ent.expansion[0]);
+      return checkContent(ent.expansion);
+    } else if (ent.type == 2 /* Preformatted */) {
+      return ent.content.text;
     } else if (ent.type !== 1 /* Paragraph */) {
       return [new OnlySimpleParagraphsPermittedMessage(ent.location)];
     }
     return checkInline(ent.content);
   }
-  return check(node);
+  return checkContent(node.content);
 }
 function onlyPermitSimpleParagraphs(node) {
   function check(nodes) {
@@ -1641,24 +1766,20 @@ function customModifier(type, name, signature, content) {
       args: node.state.args,
       slotContent: node.content
     });
+    debug.trace(`pushed ${NodeType[type]} slot data for`, name);
     debug.trace(
-      `pushed ${NodeType[type]} slot data for`,
-      name,
-      signature.slotName == "" ? "(unnamed)" : `= ${signature.slotName}`
+      `... slotName:`,
+      signature.slotName === "" ? "<unnamed>" : signature.slotName === void 0 ? "<no slot>" : `'${signature.slotName}'`
     );
+    debug.trace(`... args:`, "{" + [...node.state.args].map(([a, b]) => `${a} => ${b}`).join(", ") + "}");
     return [];
   };
   mod.afterProcessExpansion = (node, cxt) => {
-    if (!node.state?.ok || signature.slotName === void 0) return [];
+    if (!node.state?.ok) return [];
     const store = cxt.get(builtins);
     const data = isInline ? store.inlineInstantiationData : store.blockInstantiationData;
-    const pop = data.pop();
-    assert(pop !== void 0);
-    debug.trace(
-      `popped ${NodeType[type]} slot data for`,
-      name,
-      signature.slotName == "" ? "(unnamed)" : `= ${signature.slotName}`
-    );
+    data.pop();
+    debug.trace(`popped ${NodeType[type]} slot data for`, name);
     return [];
   };
   return mod;
@@ -2011,6 +2132,17 @@ var DefineInlineShorthandMod = new SystemModifierDefinition(
   }
 );
 
+// src/builtin/misc.ts
+var RawBlockMod = new BlockModifierDefinition(
+  "raw",
+  1 /* Preformatted */,
+  {
+    expand(node) {
+      return node.content;
+    }
+  }
+);
+
 // src/builtin/module.ts
 function getDefs(cxt) {
   const data = cxt.get(builtins);
@@ -2307,6 +2439,48 @@ function resolveId(id, cxt) {
     value = cxt.variables.get(id);
   return value;
 }
+var ifdefBlock = (name, x) => new BlockModifierDefinition(
+  name,
+  0 /* Normal */,
+  {
+    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 ifdefInline = (name, x) => new InlineModifierDefinition(
+  name,
+  0 /* Normal */,
+  {
+    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 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 */,
@@ -2402,14 +2576,19 @@ builtin.blockModifiers.add(
   PreSlotBlockMod,
   InjectPreSlotBlockMod,
   ModuleMod,
-  UseBlockMod
+  UseBlockMod,
+  IfdefBlockMod,
+  IfndefBlockMod,
+  RawBlockMod
 );
 builtin.inlineModifiers.add(
   SlotInlineMod,
   PreSlotInlineMod,
   InjectPreSlotInlineMod,
   GetVarInlineMod,
-  PrintInlineMod
+  PrintInlineMod,
+  IfdefInlineMod,
+  IfndefInlineMod
 );
 builtin.argumentInterpolators.add(GetVarInterpolator);
 var BuiltinConfiguration = Object.freeze(builtin);
@@ -2482,9 +2661,8 @@ var headingBlock = new BlockModifierDefinition(
   "heading",
   0 /* Normal */,
   {
-    delayContentExpansion: true,
     roleHint: "heading",
-    beforeParseContent(node, cxt) {
+    prepareExpand(node, cxt) {
       let msgs = checkArguments(node, 0, 1);
       if (msgs) return msgs;
       msgs = onlyPermitSingleBlock(node);
@@ -2512,7 +2690,7 @@ var implicitHeadingBlock = new BlockModifierDefinition(
   2 /* None */,
   {
     roleHint: "heading",
-    beforeParseContent(node, cxt) {
+    prepareExpand(node, cxt) {
       let msgs = checkArguments(node, 0, 1);
       if (msgs) return msgs;
       node.state = {
@@ -2539,9 +2717,8 @@ var numberedHeadingBlock = new BlockModifierDefinition(
   "numbered-heading",
   0 /* Normal */,
   {
-    delayContentExpansion: true,
     roleHint: "heading",
-    beforeParseContent(node, cxt) {
+    prepareExpand(node, cxt) {
       let msgs = checkArguments(node, 1);
       if (msgs) return msgs;
       msgs = onlyPermitSingleBlock(node);
@@ -2886,7 +3063,7 @@ var MiscBlockRenderersHTML = [
   [styleBlock, (node, cxt) => {
     if (node.state === void 0)
       return cxt.state.invalidBlock(node, "bad format");
-    return `<div class="${node.state}" style="display:contents">${cxt.state.render(node.content, cxt)}</div>`;
+    return `<div class="emmmstyle-${node.state}" style="display:contents">${cxt.state.render(node.content, cxt)}</div>`;
   }],
   [breakBlock, () => {
     return `<hr>`;
@@ -2925,6 +3102,7 @@ function createWrapper(name, varname) {
       if (previous)
         msgs = [new OverwriteSpecialVariableMessage(node.head, varname, previous)];
       cxt.variables.set(varname, result);
+      debug.trace(varname, "->", result);
       return msgs ?? [];
     }
   });
@@ -3060,6 +3238,7 @@ htmlConfig.addInlineRenderer(
 var HTMLRenderConfiguration = htmlConfig;
 
 // src/index.ts
+var emmmVersion = "0.0.6";
 function setDebugLevel(level) {
   debug.level = level;
 }
@@ -3082,8 +3261,10 @@ function setDebugLevel(level) {
   RenderConfiguration,
   RenderContext,
   SimpleScanner,
+  StringSource,
   SystemModifierDefinition,
   debugPrint,
+  emmmVersion,
   messages,
   parse,
   setDebugLevel