@the_dissidents/libemmm 0.0.0 → 0.0.1

package/dist/index.js

@@ -21,65 +21,147 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ArgumentInterpolatorDefinition: () => ArgumentInterpolatorDefinition,
-  ArgumentsTooFewMessage: () => ArgumentsTooFewMessage,
-  ArgumentsTooManyMessage: () => ArgumentsTooManyMessage,
   BlockModifierDefinition: () => BlockModifierDefinition,
   BuiltinConfiguration: () => BuiltinConfiguration,
   Configuration: () => Configuration,
-  ContentShouldBeOnNewlineMessage: () => ContentShouldBeOnNewlineMessage,
-  Document: () => Document2,
-  ExpectedMessage: () => ExpectedMessage,
-  InlineDefinitonInvalidEntityMessage: () => InlineDefinitonInvalidEntityMessage,
+  DebugLevel: () => DebugLevel,
+  Document: () => Document,
   InlineModifierDefinition: () => InlineModifierDefinition,
-  InvalidArgumentMessage: () => InvalidArgumentMessage,
   MessageSeverity: () => MessageSeverity,
   ModifierFlags: () => ModifierFlags,
-  NameAlreadyDefinedMessage: () => NameAlreadyDefinedMessage,
-  NewBlockShouldBeOnNewlineMessage: () => NewBlockShouldBeOnNewlineMessage,
   NodeType: () => NodeType,
   ParseContext: () => ParseContext,
-  ReachedRecursionLimitMessage: () => ReachedRecursionLimitMessage,
-  ReferredMessage: () => ReferredMessage,
   SimpleScanner: () => SimpleScanner,
-  SlotUsedOutsideDefinitionMessage: () => SlotUsedOutsideDefinitionMessage,
   SystemModifierDefinition: () => SystemModifierDefinition,
-  UnclosedInlineModifierMessage: () => UnclosedInlineModifierMessage,
-  UndefinedVariableMessage: () => UndefinedVariableMessage,
-  UnknownModifierMessage: () => UnknownModifierMessage,
-  UnnecessaryNewlineMessage: () => UnnecessaryNewlineMessage,
-  parse: () => parse
+  messages: () => messages_exports,
+  parse: () => parse,
+  setDebugLevel: () => setDebugLevel
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/debug.ts
-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/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 ModifierFlags = /* @__PURE__ */ ((ModifierFlags2) => {
+  ModifierFlags2[ModifierFlags2["Normal"] = 0] = "Normal";
+  ModifierFlags2[ModifierFlags2["Preformatted"] = 1] = "Preformatted";
+  ModifierFlags2[ModifierFlags2["Marker"] = 2] = "Marker";
+  return ModifierFlags2;
+})(ModifierFlags || {});
+var ModifierBase = class {
+  constructor(name, flags = 0 /* Normal */, args) {
+    this.name = name;
+    this.flags = flags;
+    if (args) Object.assign(this, args);
+  }
+  delayContentExpansion = false;
+  alwaysTryExpand = false;
+  beforeParseContent;
+  afterParseContent;
+  beforeProcessExpansion;
+  afterProcessExpansion;
+  prepareExpand;
+  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;
+};
+var ParseContext = class {
+  constructor(config, variables = /* @__PURE__ */ new Map()) {
+    this.config = config;
+    this.variables = variables;
+    config.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 {
+  constructor(root, context, messages) {
+    this.root = root;
+    this.context = context;
+    this.messages = messages;
+  }
+  debugPrint(source) {
+    return debugDumpDocument(this, source);
+  }
+};
+var Configuration = class {
+  initializers = [];
+  blockModifiers;
+  inlineModifiers;
+  systemModifiers;
+  argumentInterpolators;
+  reparseDepthLimit = 10;
+  constructor(from) {
+    this.blockModifiers = new NameManager(from?.blockModifiers);
+    this.inlineModifiers = new NameManager(from?.inlineModifiers);
+    this.systemModifiers = new NameManager(from?.systemModifiers);
+    this.argumentInterpolators = new NameManager(from?.argumentInterpolators);
+    if (from) {
+      this.initializers = [...from.initializers];
+      this.reparseDepthLimit = from.reparseDepthLimit;
+    }
   }
 };
 
 // src/messages.ts
+var messages_exports = {};
+__export(messages_exports, {
+  ArgumentCountMismatchMessage: () => ArgumentCountMismatchMessage,
+  CannotExpandArgumentMessage: () => CannotExpandArgumentMessage,
+  ContentShouldBeOnNewlineMessage: () => ContentShouldBeOnNewlineMessage,
+  ExpectedMessage: () => ExpectedMessage,
+  InlineDefinitonInvalidEntityMessage: () => InlineDefinitonInvalidEntityMessage,
+  InvalidArgumentMessage: () => InvalidArgumentMessage,
+  NameAlreadyDefinedMessage: () => NameAlreadyDefinedMessage,
+  NewBlockShouldBeOnNewlineMessage: () => NewBlockShouldBeOnNewlineMessage,
+  ReachedRecursionLimitMessage: () => ReachedRecursionLimitMessage,
+  ReferredMessage: () => ReferredMessage,
+  SlotUsedOutsideDefinitionMessage: () => SlotUsedOutsideDefinitionMessage,
+  UnclosedInlineModifierMessage: () => UnclosedInlineModifierMessage,
+  UndefinedVariableMessage: () => UndefinedVariableMessage,
+  UnknownModifierMessage: () => UnknownModifierMessage,
+  UnnecessaryNewlineMessage: () => UnnecessaryNewlineMessage
+});
 var ReferredMessage = class {
   constructor(original, position, length) {
     this.original = original;
@@ -193,29 +275,37 @@ var UnclosedInlineModifierMessage = class {
     return `unclosed inline modifier ${this.what}'`;
   }
 };
-var ArgumentsTooFewMessage = class {
-  constructor(position, length, expected) {
+var ArgumentCountMismatchMessage = class {
+  constructor(position, length, min, max) {
     this.position = position;
     this.length = length;
-    this.expected = expected;
+    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 */;
   fixes = [];
   get info() {
-    return `too few argument(s)` + (this.expected === void 0 ? "" : `, ${this.expected} expected`);
+    return `argument count mismatch` + this.msg;
   }
 };
-var ArgumentsTooManyMessage = class extends RemoveThingMessage {
-  constructor(pos, len, expected) {
-    super(
-      5,
-      1 /* Warning */,
-      pos,
-      len,
-      "too many arguments" + (expected === void 0 ? "" : `, ${expected} expected`),
-      "remove them"
-    );
+var CannotExpandArgumentMessage = class {
+  constructor(position, length, what) {
+    this.position = position;
+    this.length = length;
+    this.what = what;
+  }
+  code = 5;
+  severity = 2 /* Error */;
+  fixes = [];
+  get info() {
+    return `failed to expand argument` + (this.what === void 0 ? "" : `: ${this.what}`);
   }
 };
 var InvalidArgumentMessage = class {
@@ -379,6 +469,36 @@ function assert(x) {
 function has(v, f) {
   return (v & f) === f;
 }
+function linePositions(src) {
+  let result = [0];
+  [...src].forEach((x, i) => {
+    if (x == "\n") result.push(i + 1);
+  });
+  result.push(Infinity);
+  return result;
+}
+var cloneArgument = (arg) => ({
+  start: arg.start,
+  end: arg.end,
+  content: arg.content.map((ent) => {
+    switch (ent.type) {
+      case 3 /* Text */:
+      case 4 /* Escaped */:
+        return structuredClone(ent);
+      case 8 /* Interpolation */:
+        return {
+          type: ent.type,
+          start: ent.start,
+          end: ent.end,
+          definition: ent.definition,
+          argument: cloneArgument(ent.argument),
+          expansion: ent.expansion
+        };
+      default:
+        return debug.never(ent);
+    }
+  })
+});
 function cloneNode(node, referring) {
   switch (node.type) {
     case 7 /* BlockModifier */:
@@ -391,7 +511,7 @@ function cloneNode(node, referring) {
         mod: node.mod,
         state: void 0,
         head: structuredClone(node.head),
-        arguments: structuredClone(node.arguments),
+        arguments: node.arguments.map(cloneArgument),
         content: node.content.map((x) => cloneNode(x, referring)),
         expansion: node.expansion ? cloneNodes(node.expansion) : void 0
       };
@@ -421,7 +541,7 @@ function debugPrintArgEntity(node) {
     case 4 /* Escaped */:
       return `<Escaped:${node.content}>`;
     case 8 /* Interpolation */:
-      return `<Interp:${node.definition.name}-${node.definition.postfix}:${debugPrintArgument(node.arg)}>`;
+      return `<Interp:${node.definition.name}-${node.definition.postfix}:${debugPrintArgument(node.argument)}${node.expansion ? `=${node.expansion}` : ""}>`;
     default:
       return debug.never(node);
   }
@@ -430,7 +550,7 @@ function debugPrintArgument(arg) {
   return arg.content.map(debugPrintArgEntity).join("");
 }
 function debugPrintNode(node, prefix = "") {
-  let result = `<${node.type}@${node.start}`;
+  let result = `<${NodeType[node.type]}@${node.start}`;
   switch (node.type) {
     case 0 /* Root */:
     case 1 /* Paragraph */:
@@ -438,14 +558,14 @@ function debugPrintNode(node, prefix = "") {
       if (content.length > 0)
         result += `>
 ${content}
-${prefix}</${node.type}@${node.end}>`;
+${prefix}</${NodeType[node.type]}@${node.end}>`;
       else result += `-${node.end} />`;
       break;
     case 4 /* Escaped */:
     case 2 /* Preformatted */:
       result += `>
 ${prefix}  ${node.content}
-${prefix}</${node.type}@${node.end}>`;
+${prefix}</${NodeType[node.type]}@${node.end}>`;
       break;
     case 6 /* InlineModifier */:
     case 7 /* BlockModifier */:
@@ -455,7 +575,7 @@ ${prefix}    (${i})@${x.start}-${x.end}=${debugPrintArgument(x)}`).join("");
       if (node.content.length > 0) {
         result += ` id=${node.mod.name}${args}>
 ` + debugPrintNodes(node.content, prefix) + `
-${prefix}</${node.type}@${node.end}>`;
+${prefix}</${NodeType[node.type]}@${node.end}>`;
       } else result += `-${node.end} id=${node.mod.name}${args} />`;
       if (node.expansion) {
         const content2 = debugPrintNodes(node.expansion, prefix);
@@ -481,118 +601,67 @@ function debugPrintNodes(content, prefix = "") {
   if (dumps.length == 0) return "";
   return dumps.map((x) => `${prefix}  ${x}`).join("\n");
 }
-
-// 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 ModifierFlags = /* @__PURE__ */ ((ModifierFlags2) => {
-  ModifierFlags2[ModifierFlags2["Normal"] = 0] = "Normal";
-  ModifierFlags2[ModifierFlags2["Preformatted"] = 1] = "Preformatted";
-  ModifierFlags2[ModifierFlags2["Marker"] = 2] = "Marker";
-  return ModifierFlags2;
-})(ModifierFlags || {});
-var ModifierBase = class {
-  constructor(name, flags = 0 /* Normal */, args) {
-    this.name = name;
-    this.flags = flags;
-    if (args) Object.assign(this, args);
-  }
-  delayContentExpansion = false;
-  alwaysTryExpand = false;
-  beforeParseContent;
-  afterParseContent;
-  beforeProcessExpansion;
-  afterProcessExpansion;
-  prepareExpand;
-  expand;
-};
-var BlockModifierDefinition = class extends ModifierBase {
-};
-var InlineModifierDefinition = class extends ModifierBase {
-};
-var SystemModifierDefinition = class extends ModifierBase {
-};
-var ArgumentInterpolatorDefinition = class {
-  constructor(name, postfix, expand) {
-    this.name = name;
-    this.postfix = postfix;
-    this.expand = expand;
-  }
-};
-var ParseContext = class {
-  constructor(config, variables = /* @__PURE__ */ new Map()) {
-    this.config = config;
-    this.variables = variables;
-    config.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];
-  }
-  #evalEntity(e) {
-    switch (e.type) {
-      case 3 /* Text */:
-      case 4 /* Escaped */:
-        return e.content;
-      case 8 /* Interpolation */:
-        const inner = this.evaluateArgument(e.arg);
-        return e.definition.expand(inner, this);
-      default:
-        assert(false);
+function debugDumpDocument(doc, source) {
+  const lines = linePositions(source);
+  function pos2lc(pos) {
+    let line = -1, linepos = 0;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i] > pos) {
+        line = i;
+        linepos = lines[i - 1];
+        break;
+      }
     }
-  }
-  evaluateArgument(arg) {
-    return arg.content.map((x) => this.#evalEntity(x)).join("");
-  }
-};
-var Document2 = class {
-  constructor(root, context, messages) {
-    this.root = root;
-    this.context = context;
-    this.messages = messages;
-  }
-};
-var Configuration = class {
-  initializers = [];
-  blockModifiers;
-  inlineModifiers;
-  systemModifiers;
-  argumentInterpolators;
-  reparseDepthLimit = 10;
-  constructor(from) {
-    this.blockModifiers = new NameManager(from?.blockModifiers);
-    this.inlineModifiers = new NameManager(from?.inlineModifiers);
-    this.systemModifiers = new NameManager(from?.systemModifiers);
-    this.argumentInterpolators = new NameManager(from?.argumentInterpolators);
-    if (from) {
-      this.initializers = [...from.initializers];
-      this.reparseDepthLimit = from.reparseDepthLimit;
+    return `l${line}c${pos - linepos + 1}`;
+  }
+  function dumpMsg(m) {
+    let result = `at ${pos2lc(m.position)}, len ${m.length}: ${MessageSeverity[m.severity]}[${m.code}]: ${m.info}`;
+    while (m instanceof ReferredMessage) {
+      m = m.original;
+      result += `
+---> original at: ${pos2lc(m.position)}, len ${m.length}`;
     }
+    return result;
+  }
+  let root = debugPrintNode(doc.root);
+  let msgs = doc.messages.map(dumpMsg).join("\n");
+  if (msgs.length > 0) msgs += "\n";
+  return `${msgs}${root}`;
+}
+
+// src/debug.ts
+var DebugLevel = /* @__PURE__ */ ((DebugLevel3) => {
+  DebugLevel3[DebugLevel3["Trace"] = 0] = "Trace";
+  DebugLevel3[DebugLevel3["Info"] = 1] = "Info";
+  DebugLevel3[DebugLevel3["Warning"] = 2] = "Warning";
+  DebugLevel3[DebugLevel3["Error"] = 3] = "Error";
+  DebugLevel3[DebugLevel3["None"] = 4] = "None";
+  return DebugLevel3;
+})(DebugLevel || {});
+var debug = {
+  level: 1 /* Info */,
+  trace(arg0, ...args) {
+    if (this.level > 0 /* Trace */) return;
+    if (typeof arg0 == "function") arg0 = arg0();
+    console.info("TRACE", arg0, ...args);
+  },
+  info(arg0, ...args) {
+    if (this.level > 1 /* Info */) return;
+    if (typeof arg0 == "function") arg0 = arg0();
+    console.info(" INFO", arg0, ...args);
+  },
+  warning(arg0, ...args) {
+    if (this.level > 2 /* Warning */) return;
+    if (typeof arg0 == "function") arg0 = arg0();
+    console.warn(" WARN", arg0, ...args);
+  },
+  error(arg0, ...args) {
+    if (this.level > 3 /* Error */) return;
+    if (typeof arg0 == "function") arg0 = arg0();
+    console.error("ERROR", arg0, ...args);
+  },
+  never(_) {
+    assert(false);
   }
 };
 
@@ -772,22 +841,61 @@ var Parser = class {
     }
     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 (node.content.length > 0 && depth > 0) {
+    if (depth > 0) {
       if (node.mod.beforeParseContent)
         this.emit.message(...node.mod.beforeParseContent(node, this.cxt, immediate));
-      if (node.mod.delayContentExpansion) this.delayDepth++;
-      this.#reparse(node.content, depth);
-      if (node.mod.delayContentExpansion) this.delayDepth--;
+      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));
     }
@@ -826,7 +934,7 @@ var Parser = class {
   }
   parse() {
     this.DOCUMENT();
-    return new Document2(this.emit.root, this.cxt, this.emit.messages);
+    return new Document(this.emit.root, this.cxt, this.emit.messages);
   }
   WHITESPACES_OR_NEWLINES() {
     while (this.scanner.acceptWhitespaceChar() !== null || this.scanner.accept("\n")) {
@@ -893,7 +1001,7 @@ var Parser = class {
       );
     }
     const args = this.ARGUMENTS();
-    debug.trace(`PARSE ${type} modifier:`, mod.name);
+    debug.trace(`PARSE ${NodeType[type]}:`, mod.name);
     const endsign = this.scanner.accept(MODIFIER_END_SIGN);
     const flagMarker = has(mod.flags, 2 /* Marker */);
     const isMarker = flagMarker || endsign;
@@ -902,16 +1010,18 @@ var Parser = class {
         this.scanner.position(),
         MODIFIER_CLOSE_SIGN
       ));
+    const headEnd = this.scanner.position();
     const node = {
       type,
       mod,
-      head: { start: posStart, end: this.scanner.position() },
+      head: { start: posStart, end: headEnd },
       arguments: args,
       start: posStart,
-      end: -1,
+      end: headEnd,
       content: [],
       expansion: void 0
     };
+    this.#expandArguments(node);
     const immediate = this.delayDepth == 0;
     if (node.mod.beforeParseContent)
       this.emit.message(...node.mod.beforeParseContent(node, this.cxt, immediate));
@@ -1096,10 +1206,8 @@ var Parser = class {
       }
     };
     while (true) {
-      if (end !== void 0 && this.scanner.accept(end)) {
-        debug.trace("found end", end);
+      if (end !== void 0 && this.scanner.accept(end))
         break;
-      }
       if (this.scanner.accept(":")) {
         ok = end === void 0;
         break;
@@ -1132,7 +1240,7 @@ var Parser = class {
         content.push({
           type: 8 /* Interpolation */,
           definition: result,
-          arg: inner,
+          argument: inner,
           start: posEnd - 2,
           end: posEnd
         });
@@ -1173,6 +1281,21 @@ function parse(scanner, config) {
   return new Parser(scanner, config).parse();
 }
 
+// src/modifier-helper.ts
+function checkArgumentLength(node, min, max = min) {
+  if (min !== void 0 && node.arguments.length < min || max !== void 0 && node.arguments.length > max) {
+    return [new ArgumentCountMismatchMessage(node.head.start, node.head.end - node.head.start, min, max)];
+  }
+  return null;
+}
+function checkArguments(node, min, max = min) {
+  const arg = node.arguments.find((x) => x.expansion === void 0);
+  if (arg !== void 0) {
+    return [new CannotExpandArgumentMessage(arg.start, arg.end - arg.start)];
+  }
+  return checkArgumentLength(node, min, max);
+}
+
 // src/builtin/internal.ts
 var builtins = Symbol();
 function initParseContext(cxt) {
@@ -1183,15 +1306,6 @@ function initParseContext(cxt) {
     inlineSlotData: []
   });
 }
-function checkArgumentLength(node, n) {
-  if (node.arguments.length < n)
-    return new ArgumentsTooFewMessage(node.head.end - 1, 0, n);
-  if (node.arguments.length > n) {
-    const start = node.arguments[n].start - 1;
-    return new ArgumentsTooManyMessage(start, node.head.end - start, n);
-  }
-  return null;
-}
 function customModifier(type, name, argNames, slotName, content) {
   debug.info(`registered custom ${type} modifier:`, name);
   debug.info("args:", argNames, `with ${slotName == "" ? "no slot name" : "slot name: " + slotName}`);
@@ -1200,9 +1314,12 @@ function customModifier(type, name, argNames, slotName, content) {
   const isInline = type == 6 /* InlineModifier */;
   mod.delayContentExpansion = true;
   mod.prepareExpand = (node, cxt) => {
-    const check = checkArgumentLength(node, argNames.length);
-    if (check) return [check];
-    node.state = { ok: true };
+    let check = checkArguments(node, argNames.length);
+    if (check) return check;
+    node.state = {
+      ok: true,
+      args: new Map(node.arguments.map((x, i) => [argNames[i], x.expansion]))
+    };
     return [];
   };
   mod.expand = (node, cxt) => {
@@ -1213,11 +1330,12 @@ function customModifier(type, name, argNames, slotName, content) {
   mod.beforeProcessExpansion = (node, cxt) => {
     if (!node.state?.ok) return [];
     const store = cxt.get(builtins);
-    const args = new Map(
-      node.arguments.map((x, i) => [argNames[i], cxt.evaluateArgument(x)])
-    );
     const data = isInline ? store.inlineSlotData : store.blockSlotData;
-    data.push([slotName, { mod, args, slotContent: node.content }]);
+    data.push([slotName, {
+      mod,
+      args: node.state.args,
+      slotContent: node.content
+    }]);
     debug.trace(
       `pushed ${type} slot data for`,
       name,
@@ -1247,28 +1365,31 @@ var DefineBlockMod = new SystemModifierDefinition("define-block", 0 /* Normal */
   delayContentExpansion: true,
   alwaysTryExpand: true,
   beforeParseContent(node, cxt) {
-    if (node.arguments.length == 0)
-      return [new ArgumentsTooFewMessage(node.head.end - 1, 0)];
+    const check = checkArgumentLength(node, 1, Infinity);
+    if (check) return check;
     const msgs = [];
     const name = node.arguments[0];
-    const nameValue = cxt.evaluateArgument(name);
-    if (cxt.config.blockModifiers.has(nameValue))
-      msgs.push(new NameAlreadyDefinedMessage(
-        node.start,
-        name.end - name.start,
-        nameValue
-      ));
+    const nameValue = name.expansion;
     let slotName = "";
     if (node.arguments.length > 1) {
-      const last = cxt.evaluateArgument(node.arguments.at(-1));
-      slotName = /^\(.+\)$/.test(last) ? last.substring(1, last.length - 1) : "";
+      const last = node.arguments.at(-1);
+      if (last.expansion)
+        slotName = /^\(.+\)$/.test(last.expansion) ? last.expansion.substring(1, last.expansion.length - 1) : "";
+      else msgs.push(
+        new InvalidArgumentMessage(last.start, last.end - last.start)
+      );
     }
-    const args = node.arguments.slice(1, slotName !== "" ? node.arguments.length - 1 : void 0).map((x) => cxt.evaluateArgument(x));
-    node.state = { name: nameValue, slotName, args };
+    const args = node.arguments.slice(1, slotName !== "" ? node.arguments.length - 1 : void 0).map((x) => {
+      if (!x.expansion) msgs.push(
+        new InvalidArgumentMessage(x.start, x.end - x.start)
+      );
+      return x.expansion ?? "";
+    });
+    node.state = { name: nameValue, slotName, args, msgs };
     const store = cxt.get(builtins);
     store.blockSlotDelayedStack.push(node.state.slotName);
     debug.trace("entering block definition:", node.state.name);
-    return msgs;
+    return [];
   },
   afterParseContent(node, cxt) {
     if (!node.state) return [];
@@ -1277,9 +1398,22 @@ var DefineBlockMod = new SystemModifierDefinition("define-block", 0 /* Normal */
     debug.trace("leaving block definition", node.state.name);
     return [];
   },
+  prepareExpand(node, cxt, immediate) {
+    if (!immediate || !node.state) return [];
+    const arg = node.arguments[0];
+    if (!node.state.name)
+      return [new InvalidArgumentMessage(arg.start, arg.end - arg.start)];
+    if (cxt.config.blockModifiers.has(node.state.name))
+      return [new NameAlreadyDefinedMessage(
+        arg.start,
+        arg.end - arg.start,
+        node.state.name
+      )];
+    return [];
+  },
   expand(node, cxt, immediate) {
     if (!immediate) return void 0;
-    if (node.state) {
+    if (node.state?.name) {
       if (cxt.config.blockModifiers.has(node.state.name))
         cxt.config.blockModifiers.remove(node.state.name);
       cxt.config.blockModifiers.add(
@@ -1302,12 +1436,12 @@ var DefineInlineMod = new SystemModifierDefinition("define-inline", 0 /* Normal
   delayContentExpansion: true,
   alwaysTryExpand: true,
   beforeParseContent(node, cxt) {
-    if (node.arguments.length == 0)
-      return [new ArgumentsTooFewMessage(node.head.end - 1, 0)];
+    const check = checkArgumentLength(node, 1, Infinity);
+    if (check) return check;
     const msgs = [];
     const name = node.arguments[0];
-    const nameValue = cxt.evaluateArgument(name);
-    if (cxt.config.inlineModifiers.has(nameValue))
+    const nameValue = name.expansion;
+    if (nameValue && cxt.config.inlineModifiers.has(nameValue))
       msgs.push(new NameAlreadyDefinedMessage(
         node.start,
         name.end - name.start,
@@ -1315,15 +1449,24 @@ var DefineInlineMod = new SystemModifierDefinition("define-inline", 0 /* Normal
       ));
     let slotName = "";
     if (node.arguments.length > 1) {
-      const last = cxt.evaluateArgument(node.arguments.at(-1));
-      slotName = /^\(.+\)$/.test(last) ? last.substring(1, last.length - 1) : "";
+      const last = node.arguments.at(-1);
+      if (last.expansion)
+        slotName = /^\(.+\)$/.test(last.expansion) ? last.expansion.substring(1, last.expansion.length - 1) : "";
+      else msgs.push(
+        new InvalidArgumentMessage(last.start, last.end - last.start)
+      );
     }
-    const args = node.arguments.slice(1, slotName !== "" ? node.arguments.length - 1 : void 0).map((x) => cxt.evaluateArgument(x));
-    node.state = { name: nameValue, slotName, args };
+    const args = node.arguments.slice(1, slotName !== "" ? node.arguments.length - 1 : void 0).map((x) => {
+      if (!x.expansion) msgs.push(
+        new InvalidArgumentMessage(x.start, x.end - x.start)
+      );
+      return x.expansion ?? "";
+    });
+    node.state = { name: nameValue, slotName, args, msgs };
     const store = cxt.get(builtins);
     store.inlineSlotDelayedStack.push(node.state.slotName);
     debug.trace("entering inline definition:", node.state.name);
-    return msgs;
+    return [];
   },
   afterParseContent(node, cxt) {
     if (!node.state) return [];
@@ -1332,9 +1475,18 @@ var DefineInlineMod = new SystemModifierDefinition("define-inline", 0 /* Normal
     debug.trace("leaving inline definition", node.state.name);
     return [];
   },
-  prepareExpand(node, cxt) {
-    if (!node.state) return [];
+  prepareExpand(node, cxt, immediate) {
+    if (!immediate || !node.state) return [];
+    const arg = node.arguments[0];
+    if (!node.state.name)
+      return [new InvalidArgumentMessage(arg.start, arg.end - arg.start)];
     const msgs = [];
+    if (cxt.config.inlineModifiers.has(node.state.name))
+      msgs.push(new NameAlreadyDefinedMessage(
+        arg.start,
+        arg.end - arg.start,
+        node.state.name
+      ));
     let lastIsParagraph = false;
     let concat = [];
     for (const n of node.content) {
@@ -1362,7 +1514,7 @@ var DefineInlineMod = new SystemModifierDefinition("define-inline", 0 /* Normal
   },
   expand(node, cxt, immediate) {
     if (!immediate) return void 0;
-    if (node.state) {
+    if (node.state?.name) {
       if (cxt.config.inlineModifiers.has(node.state.name))
         cxt.config.inlineModifiers.remove(node.state.name);
       cxt.config.inlineModifiers.add(
@@ -1385,21 +1537,27 @@ function slotModifier(type) {
   const isInline = type == 6 /* InlineModifier */;
   mod.alwaysTryExpand = true;
   mod.prepareExpand = (node, cxt, immediate) => {
+    if (node.state) return [];
+    const check = checkArgumentLength(node, 0, 1);
+    if (check && immediate) {
+      node.state = { ok: false };
+      return check;
+    }
     const store = cxt.get(builtins);
     const data = isInline ? store.inlineSlotData : store.blockSlotData;
-    const id = node.arguments.length == 1 ? cxt.evaluateArgument(node.arguments[0]) : "";
-    if (data.length == 0) {
-      if (immediate) {
+    let id = "";
+    if (node.arguments.length == 1) {
+      const arg = node.arguments[0];
+      if (!arg.expansion) {
         node.state = { ok: false };
-        return [new SlotUsedOutsideDefinitionMessage(node.start, node.head.end - node.start)];
+        return [new InvalidArgumentMessage(arg.start, arg.end - arg.start)];
       }
-      return [];
+      id = arg.expansion;
     }
-    if (node.arguments.length > 1) {
+    if (data.length == 0) {
       if (immediate) {
         node.state = { ok: false };
-        const start = node.arguments[1].start - 1;
-        return [new ArgumentsTooManyMessage(start, node.head.end - start)];
+        return [new SlotUsedOutsideDefinitionMessage(node.start, node.head.end - node.start)];
       }
       return [];
     }
@@ -1470,10 +1628,10 @@ function resolveId(id, cxt) {
 var GetVarInlineMod = new InlineModifierDefinition("$", 2 /* Marker */, {
   // .$:id
   prepareExpand(node, cxt) {
-    const check = checkArgumentLength(node, 1);
-    if (check) return [check];
+    const check = checkArguments(node, 1);
+    if (check) return check;
     const arg = node.arguments[0];
-    const id = cxt.evaluateArgument(arg);
+    const id = arg.expansion;
     if (id == "")
       return [new InvalidArgumentMessage(arg.start, arg.end - arg.start)];
     const value = resolveId(id, cxt);
@@ -1490,20 +1648,28 @@ var GetVarInlineMod = new InlineModifierDefinition("$", 2 /* Marker */, {
 var GetVarInterpolator = new ArgumentInterpolatorDefinition(
   "$(",
   ")",
-  (content, cxt) => resolveId(content, cxt) ?? ""
+  {
+    alwaysTryExpand: true,
+    expand(content, cxt, immediate) {
+      const result = resolveId(content, cxt);
+      if (result === void 0) debug.trace("var interp failed:", content);
+      else debug.trace(`$(${content}) --> ${result}`);
+      return result;
+    }
+  }
 );
 var VarMod = new SystemModifierDefinition("var", 2 /* Marker */, {
   // .var id:value
   prepareExpand(node, cxt) {
-    const check = checkArgumentLength(node, 2);
-    if (check) return [check];
+    const check = checkArguments(node, 2);
+    if (check) return check;
     const arg = node.arguments[0];
-    const argValue = cxt.evaluateArgument(arg);
-    if (argValue == "")
+    const id = arg.expansion;
+    if (id == "")
       return [new InvalidArgumentMessage(arg.start, arg.end - arg.start)];
     node.state = {
-      id: argValue,
-      value: cxt.evaluateArgument(node.arguments[1])
+      id,
+      value: node.arguments[1].expansion
     };
     return [];
   },
@@ -1524,35 +1690,28 @@ basic.blockModifiers.add(SlotBlockMod);
 basic.inlineModifiers.add(SlotInlineMod, GetVarInlineMod);
 basic.argumentInterpolators.add(GetVarInterpolator);
 var BuiltinConfiguration = Object.freeze(basic);
+
+// src/index.ts
+function setDebugLevel(level) {
+  debug.level = level;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArgumentInterpolatorDefinition,
-  ArgumentsTooFewMessage,
-  ArgumentsTooManyMessage,
   BlockModifierDefinition,
   BuiltinConfiguration,
   Configuration,
-  ContentShouldBeOnNewlineMessage,
+  DebugLevel,
   Document,
-  ExpectedMessage,
-  InlineDefinitonInvalidEntityMessage,
   InlineModifierDefinition,
-  InvalidArgumentMessage,
   MessageSeverity,
   ModifierFlags,
-  NameAlreadyDefinedMessage,
-  NewBlockShouldBeOnNewlineMessage,
   NodeType,
   ParseContext,
-  ReachedRecursionLimitMessage,
-  ReferredMessage,
   SimpleScanner,
-  SlotUsedOutsideDefinitionMessage,
   SystemModifierDefinition,
-  UnclosedInlineModifierMessage,
-  UndefinedVariableMessage,
-  UnknownModifierMessage,
-  UnnecessaryNewlineMessage,
-  parse
+  messages,
+  parse,
+  setDebugLevel
 });
 //# sourceMappingURL=index.js.map