@the_dissidents/libemmm 0.0.0

package/dist/index.js

@@ -0,0 +1,1558 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+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,
+  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
+});
+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/messages.ts
+var ReferredMessage = class {
+  constructor(original, position, length) {
+    this.original = original;
+    this.position = position;
+    this.length = length;
+  }
+  get severity() {
+    return this.original.severity;
+  }
+  get info() {
+    return this.original.info;
+  }
+  get code() {
+    return this.original.code;
+  }
+  fixes = [];
+};
+var AddThingMessage = class {
+  constructor(code, severity, position, length, info, fixstr, what) {
+    this.code = code;
+    this.severity = severity;
+    this.position = position;
+    this.length = length;
+    this.info = info;
+    this.fixstr = fixstr;
+    this.what = what;
+  }
+  get fixes() {
+    let [pos, what, fixstr] = [this.position, this.what, this.fixstr];
+    return [{
+      get info() {
+        return fixstr;
+      },
+      apply(src, cursor) {
+        let newCursor = cursor < pos ? cursor : cursor + what.length;
+        return [src.substring(0, pos) + what + src.substring(pos), newCursor];
+      }
+    }];
+  }
+};
+var RemoveThingMessage = class {
+  constructor(code, severity, position, length, info, fixstr) {
+    this.code = code;
+    this.severity = severity;
+    this.position = position;
+    this.length = length;
+    this.info = info;
+    this.fixstr = fixstr;
+  }
+  get fixes() {
+    let [pos, len, fixstr] = [this.position, this.length, this.fixstr];
+    return [{
+      get info() {
+        return fixstr;
+      },
+      apply(src, cursor) {
+        let newCursor = cursor < pos + len && cursor >= pos ? pos : cursor - len;
+        return [src.substring(0, pos) + src.substring(pos + len), newCursor];
+      }
+    }];
+  }
+};
+var ExpectedMessage = class {
+  constructor(position, what) {
+    this.position = position;
+    this.what = what;
+  }
+  code = 1;
+  severity = 2 /* Error */;
+  get length() {
+    return this.what.length;
+  }
+  get info() {
+    return `expected '${this.what}'`;
+  }
+  get fixes() {
+    return [];
+  }
+};
+var UnknownModifierMessage = class {
+  constructor(position, length) {
+    this.position = position;
+    this.length = length;
+  }
+  code = 2;
+  severity = 2 /* Error */;
+  info = `unknown modifier; did you forget to escape it?`;
+  get fixes() {
+    let [pos, len] = [this.position, this.length];
+    return [{
+      get info() {
+        return "this is not a modifier -- escape it";
+      },
+      apply(src, cursor) {
+        let newCursor = cursor < pos ? cursor : cursor + 1;
+        return [src.substring(0, pos) + "\\" + src.substring(pos), newCursor];
+      }
+    }];
+  }
+};
+var UnclosedInlineModifierMessage = class {
+  constructor(position, what) {
+    this.position = position;
+    this.what = what;
+  }
+  code = 3;
+  severity = 2 /* Error */;
+  length = 0;
+  fixes = [];
+  get info() {
+    return `unclosed inline modifier ${this.what}'`;
+  }
+};
+var ArgumentsTooFewMessage = class {
+  constructor(position, length, expected) {
+    this.position = position;
+    this.length = length;
+    this.expected = expected;
+  }
+  code = 4;
+  severity = 2 /* Error */;
+  fixes = [];
+  get info() {
+    return `too few argument(s)` + (this.expected === void 0 ? "" : `, ${this.expected} expected`);
+  }
+};
+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 InvalidArgumentMessage = class {
+  constructor(position, length, what) {
+    this.position = position;
+    this.length = length;
+    this.what = what;
+  }
+  code = 6;
+  severity = 2 /* Error */;
+  fixes = [];
+  get info() {
+    return `invalid argument` + (this.what === void 0 ? "" : `: ${this.what}`);
+  }
+};
+var InlineDefinitonInvalidEntityMessage = class {
+  constructor(position, length) {
+    this.position = position;
+    this.length = length;
+  }
+  code = 7;
+  severity = 2 /* Error */;
+  fixes = [];
+  get info() {
+    return `Invalid entity in inline modifier definition`;
+  }
+};
+var ReachedRecursionLimitMessage = class {
+  constructor(position, length, limit, what) {
+    this.position = position;
+    this.length = length;
+    this.limit = limit;
+    this.what = what;
+  }
+  code = 8;
+  severity = 2 /* Error */;
+  fixes = [];
+  get info() {
+    return `Reached recursion limit ${this.limit} when expanding ${this.what}`;
+  }
+};
+var SlotUsedOutsideDefinitionMessage = class {
+  constructor(position, length) {
+    this.position = position;
+    this.length = length;
+  }
+  code = 9;
+  severity = 2 /* Error */;
+  fixes = [];
+  get info() {
+    return `[.slot] used outside a block definition`;
+  }
+};
+var UnnecessaryNewlineMessage = class extends RemoveThingMessage {
+  constructor(pos, len) {
+    super(
+      1,
+      1 /* Warning */,
+      pos,
+      len,
+      "more than one newlines have the same effect as one",
+      "remove the redundant newlines"
+    );
+  }
+};
+var NewBlockShouldBeOnNewlineMessage = class extends AddThingMessage {
+  constructor(pos) {
+    super(
+      2,
+      1 /* Warning */,
+      pos,
+      0,
+      "a new block should begin in a new line to avoid confusion",
+      "add a line break",
+      "\n"
+    );
+  }
+};
+var ContentShouldBeOnNewlineMessage = class extends AddThingMessage {
+  constructor(pos) {
+    super(
+      3,
+      1 /* Warning */,
+      pos,
+      0,
+      "the content should begin in a new line to avoid confusion",
+      "add a line break",
+      "\n"
+    );
+  }
+};
+var NameAlreadyDefinedMessage = class {
+  constructor(position, length, what) {
+    this.position = position;
+    this.length = length;
+    this.what = what;
+  }
+  code = 4;
+  severity = 1 /* Warning */;
+  fixes = [];
+  get info() {
+    return `name is already defined, will overwrite: ${this.what}`;
+  }
+};
+var UndefinedVariableMessage = class {
+  constructor(position, length, what) {
+    this.position = position;
+    this.length = length;
+    this.what = what;
+  }
+  code = 5;
+  severity = 1 /* Warning */;
+  fixes = [];
+  get info() {
+    return `variable is undefined, will expand to empty string: ${this.what}`;
+  }
+};
+
+// src/util.ts
+var NameManager = class {
+  array = [];
+  data;
+  constructor(from) {
+    this.array = [...from?.array ?? []];
+    this.data = new Map(from?.data);
+  }
+  get(name) {
+    return this.data.get(name);
+  }
+  has(name) {
+    return this.data.has(name);
+  }
+  remove(name) {
+    let i = this.data.get(name);
+    assert(i !== void 0);
+    this.data.delete(name);
+    this.array.splice(this.array.findIndex((x) => x.k == name), 1);
+  }
+  add(...elems) {
+    for (const elem of elems) {
+      assert(!this.has(elem.name));
+      this.data.set(elem.name, elem);
+      const len = elem.name.length;
+      let i = 0;
+      while (i < this.array.length && this.array[i].k.length > len) i++;
+      this.array.splice(i, 0, { k: elem.name, v: elem });
+    }
+  }
+  find(predicate) {
+    const result = this.array.find((x) => predicate(x.v));
+    return result ? result.v : void 0;
+  }
+};
+function assert(x) {
+  if (!!!x) {
+    let error = new Error("assertion failed");
+    console.log(error.stack);
+    throw error;
+  }
+}
+function has(v, f) {
+  return (v & f) === f;
+}
+function cloneNode(node, referring) {
+  switch (node.type) {
+    case 7 /* BlockModifier */:
+    case 6 /* InlineModifier */:
+    case 5 /* SystemModifier */:
+      return {
+        start: node.start,
+        end: node.end,
+        type: node.type,
+        mod: node.mod,
+        state: void 0,
+        head: structuredClone(node.head),
+        arguments: structuredClone(node.arguments),
+        content: node.content.map((x) => cloneNode(x, referring)),
+        expansion: node.expansion ? cloneNodes(node.expansion) : void 0
+      };
+    case 0 /* Root */:
+    case 1 /* Paragraph */:
+      return {
+        type: node.type,
+        start: node.start,
+        end: node.end,
+        content: node.content.map((x) => cloneNode(x))
+      };
+    case 2 /* Preformatted */:
+    case 3 /* Text */:
+    case 4 /* Escaped */:
+      return structuredClone(node);
+    default:
+      return debug.never(node);
+  }
+}
+function cloneNodes(nodes) {
+  return nodes.map((x) => cloneNode(x));
+}
+function debugPrintArgEntity(node) {
+  switch (node.type) {
+    case 3 /* Text */:
+      return node.content;
+    case 4 /* Escaped */:
+      return `<Escaped:${node.content}>`;
+    case 8 /* Interpolation */:
+      return `<Interp:${node.definition.name}-${node.definition.postfix}:${debugPrintArgument(node.arg)}>`;
+    default:
+      return debug.never(node);
+  }
+}
+function debugPrintArgument(arg) {
+  return arg.content.map(debugPrintArgEntity).join("");
+}
+function debugPrintNode(node, prefix = "") {
+  let result = `<${node.type}@${node.start}`;
+  switch (node.type) {
+    case 0 /* Root */:
+    case 1 /* Paragraph */:
+      const content = debugPrintNodes(node.content, prefix);
+      if (content.length > 0)
+        result += `>
+${content}
+${prefix}</${node.type}@${node.end}>`;
+      else result += `-${node.end} />`;
+      break;
+    case 4 /* Escaped */:
+    case 2 /* Preformatted */:
+      result += `>
+${prefix}  ${node.content}
+${prefix}</${node.type}@${node.end}>`;
+      break;
+    case 6 /* InlineModifier */:
+    case 7 /* BlockModifier */:
+    case 5 /* SystemModifier */:
+      const args = node.arguments.map((x, i) => `
+${prefix}    (${i})@${x.start}-${x.end}=${debugPrintArgument(x)}`).join("");
+      if (node.content.length > 0) {
+        result += ` id=${node.mod.name}${args}>
+` + debugPrintNodes(node.content, prefix) + `
+${prefix}</${node.type}@${node.end}>`;
+      } else result += `-${node.end} id=${node.mod.name}${args} />`;
+      if (node.expansion) {
+        const content2 = debugPrintNodes(node.expansion, prefix);
+        if (content2.length > 0)
+          result += `
+${prefix}<expansion>
+${content2}
+${prefix}</expansion>`;
+        else if (node.type != 5 /* SystemModifier */)
+          result += `
+${prefix}<expansion />`;
+      }
+      break;
+    case 3 /* Text */:
+      return node.content;
+    default:
+      return debug.never(node);
+  }
+  return result;
+}
+function debugPrintNodes(content, prefix = "") {
+  let dumps = content.map((x) => debugPrintNode(x, prefix + "  ")).filter((x) => x.length > 0);
+  if (dumps.length == 0) return "";
+  return dumps.map((x) => `${prefix}  ${x}`).join("\n");
+}
+
+// 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);
+    }
+  }
+  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;
+    }
+  }
+};
+
+// src/front.ts
+var SimpleScanner = class {
+  constructor(src) {
+    this.src = src;
+  }
+  pos = 0;
+  position() {
+    return this.pos;
+  }
+  isEOF() {
+    return this.pos >= this.src.length;
+  }
+  peek(str) {
+    let next = this.pos + str.length;
+    if (next > this.src.length) return false;
+    return this.src.slice(this.pos, this.pos + str.length) == str;
+  }
+  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;
+  }
+  acceptUntil(str) {
+    let start = this.pos;
+    while (!this.isEOF()) {
+      if (this.peek(str)) {
+        let result = this.src.slice(start, this.pos);
+        return result;
+      }
+      this.pos++;
+    }
+    return null;
+  }
+};
+
+// 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;
+  }
+  root = { type: 0 /* Root */, start: 0, end: -1, content: [] };
+  messages = [];
+  blockStack = [this.root];
+  inlineStack = [];
+  referringStack = [];
+  message(...m) {
+    const referringReverse = [...this.referringStack].reverse();
+    for (let msg of m) {
+      for (const range of referringReverse)
+        msg = new ReferredMessage(msg, range.start, range.end - range.start);
+      this.messages.push(msg);
+      debug.trace("issued msg", msg.code, msg.info);
+    }
+  }
+  pushReferring(start, end) {
+    this.referringStack.push({ start, end });
+  }
+  popReferring() {
+    assert(this.referringStack.length > 0);
+    this.referringStack.pop();
+  }
+  addBlockNode(n) {
+    assert(this.blockStack.length > 0);
+    this.blockStack.at(-1).content.push(n);
+    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.end = this.scanner.position();
+    } else content.push({
+      type: 3 /* Text */,
+      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 >= 2);
+    const node = this.blockStack.pop();
+    node.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.end = this.scanner.position();
+  }
+};
+var Parser = class {
+  constructor(scanner, config) {
+    this.scanner = scanner;
+    this.emit = new EmitEnvironment(scanner);
+    this.cxt = new ParseContext(config);
+  }
+  emit;
+  cxt;
+  delayDepth = 0;
+  groupDepth = 0;
+  #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;
+  }
+  #expand(node, depth = 0) {
+    if (node.expansion !== void 0) {
+      debug.trace("already expanded, skipping:", node.mod.name);
+      return true;
+    }
+    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 (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.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;
+      } else if (node.expansion.length > 0) {
+        debug.trace(`${this.delayDepth > 0 ? "early " : ""}expanding:`, node.mod.name);
+        debug.trace(() => "-->\n" + debugPrintNodes(node.expansion, "  "));
+      } else {
+        debug.trace(`${this.delayDepth > 0 ? "early " : ""}expanding:`, node.mod.name);
+      }
+    }
+    const expansion = node.expansion ?? node.content;
+    if (expansion.length == 0) return true;
+    if (node.mod.beforeProcessExpansion)
+      this.emit.message(...node.mod.beforeProcessExpansion(node, this.cxt, immediate));
+    this.emit.pushReferring(node.start, node.end);
+    let ok = this.#reparse(expansion, depth);
+    this.emit.popReferring();
+    if (node.mod.afterProcessExpansion)
+      this.emit.message(...node.mod.afterProcessExpansion(node, this.cxt, immediate));
+    if (!ok && depth == 0) {
+      const limit = this.cxt.config.reparseDepthLimit;
+      this.emit.message(new ReachedRecursionLimitMessage(
+        node.start,
+        node.end - node.start,
+        limit,
+        node.mod.name
+      ));
+    }
+    return ok;
+  }
+  parse() {
+    this.DOCUMENT();
+    return new Document2(this.emit.root, this.cxt, this.emit.messages);
+  }
+  WHITESPACES_OR_NEWLINES() {
+    while (this.scanner.acceptWhitespaceChar() !== null || this.scanner.accept("\n")) {
+    }
+  }
+  SHOULD_BE_A_NEWLINE() {
+    while (this.scanner.acceptWhitespaceChar() !== null) {
+    }
+    if (!this.scanner.accept("\n")) this.emit.message(
+      new ContentShouldBeOnNewlineMessage(this.scanner.position())
+    );
+  }
+  // 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(start, end - start)
+    );
+  }
+  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;
+    }
+    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) {
+      const args2 = this.scanner.acceptUntil(MODIFIER_CLOSE_SIGN);
+      if (args2 === null) this.emit.message(
+        new ExpectedMessage(this.scanner.position(), MODIFIER_CLOSE_SIGN)
+      );
+      this.emit.message(
+        new UnknownModifierMessage(posStart, this.scanner.position() - posStart)
+      );
+    }
+    const args = this.ARGUMENTS();
+    debug.trace(`PARSE ${type} modifier:`, mod.name);
+    const endsign = this.scanner.accept(MODIFIER_END_SIGN);
+    const flagMarker = has(mod.flags, 2 /* Marker */);
+    const isMarker = flagMarker || endsign;
+    if (!this.scanner.accept(MODIFIER_CLOSE_SIGN))
+      this.emit.message(new ExpectedMessage(
+        this.scanner.position(),
+        MODIFIER_CLOSE_SIGN
+      ));
+    const node = {
+      type,
+      mod,
+      head: { start: posStart, end: this.scanner.position() },
+      arguments: args,
+      start: posStart,
+      end: -1,
+      content: [],
+      expansion: void 0
+    };
+    const immediate = this.delayDepth == 0;
+    if (node.mod.beforeParseContent)
+      this.emit.message(...node.mod.beforeParseContent(node, this.cxt, immediate));
+    if (node.mod.delayContentExpansion) this.delayDepth++;
+    let ok = true;
+    if (isMarker) {
+      if (type === 6 /* InlineModifier */) this.emit.addInlineNode(node);
+      else this.emit.addBlockNode(node);
+    } else if (type == 6 /* InlineModifier */) {
+      this.emit.startInline(node);
+      const entity = has(mod.flags, 1 /* Preformatted */) ? this.PREFORMATTED_INLINE_ENTITY.bind(this) : this.INLINE_ENTITY.bind(this);
+      while (true) {
+        if (this.scanner.accept(MODIFIER_INLINE_END_TAG)) break;
+        if (this.scanner.isEOF() || !(ok = entity())) {
+          this.emit.message(new UnclosedInlineModifierMessage(
+            this.scanner.position(),
+            mod.name
+          ));
+          break;
+        }
+      }
+      this.emit.endInline();
+    } else {
+      this.emit.startBlock(node);
+      this.WARN_IF_MORE_NEWLINES_THAN(1);
+      if (!this.scanner.isEOF()) {
+        if (has(mod.flags, 1 /* Preformatted */))
+          this.PRE_PARAGRAPH();
+        else
+          this.BLOCK_ENTITY();
+      }
+      this.emit.endBlock();
+    }
+    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;
+  }
+  // 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 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) || !grouped && this.scanner.accept("\n")) break;
+        if (this.scanner.isEOF()) {
+          if (grouped) this.emit.message(new ExpectedMessage(
+            this.scanner.position(),
+            GROUP_END
+          ));
+          break;
+        }
+        string += white;
+      } else {
+        string += this.scanner.acceptChar();
+      }
+      posContentEnd = this.scanner.position();
+    }
+    const node = {
+      type: 2 /* Preformatted */,
+      start: posStart,
+      end: this.scanner.position(),
+      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)) {
+          this.groupDepth--;
+          return;
+        }
+        this.BLOCK_ENTITY();
+        this.WARN_IF_MORE_NEWLINES_THAN(1);
+      }
+      this.emit.message(new ExpectedMessage(
+        this.scanner.position(),
+        GROUP_END
+      ));
+    } else {
+      this.PARAGRAPH();
+    }
+  }
+  PARAGRAPH() {
+    assert(!this.scanner.isEOF());
+    const node = {
+      type: 1 /* Paragraph */,
+      start: this.scanner.position(),
+      end: -1,
+      content: []
+    };
+    debug.trace("PARSE para");
+    this.emit.startInline(node);
+    while (!this.scanner.isEOF() && this.INLINE_ENTITY()) {
+    }
+    this.emit.endInline();
+    debug.trace("PARSE para end");
+  }
+  // returns false if breaking out of paragraph
+  INLINE_ENTITY() {
+    assert(!this.scanner.isEOF());
+    if (this.scanner.peek(MODIFIER_BLOCK_OPEN)) {
+      this.emit.message(new NewBlockShouldBeOnNewlineMessage(this.scanner.position()));
+      return false;
+    }
+    if (this.scanner.peek(MODIFIER_INLINE_OPEN)) {
+      return this.MODIFIER(6 /* InlineModifier */);
+    }
+    if (this.scanner.peek(MODIFIER_SYSTEM_OPEN)) {
+      return false;
+    }
+    if (this.scanner.accept("\\")) {
+      if (this.scanner.isEOF()) {
+        this.emit.addString("\\");
+        return true;
+      }
+      const node = {
+        type: 4 /* Escaped */,
+        start: this.scanner.position() - 1,
+        content: this.scanner.acceptChar(),
+        end: this.scanner.position()
+      };
+      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")) {
+      while (this.scanner.acceptWhitespaceChar() !== null) {
+      }
+      if (this.scanner.peek(MODIFIER_BLOCK_OPEN) || this.scanner.peek(MODIFIER_SYSTEM_OPEN) || this.scanner.peek(GROUP_END) && this.groupDepth > 0 || this.scanner.isEOF()) return false;
+      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;
+  }
+  ARGUMENT_CONTENT(end) {
+    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.end += s.length;
+      } else {
+        const end2 = this.scanner.position();
+        content.push({
+          type: 3 /* Text */,
+          end: end2,
+          start: end2 - s.length,
+          content: s
+        });
+      }
+    };
+    while (true) {
+      if (end !== void 0 && this.scanner.accept(end)) {
+        debug.trace("found end", end);
+        break;
+      }
+      if (this.scanner.accept(":")) {
+        ok = end === void 0;
+        break;
+      }
+      if (this.scanner.peek(MODIFIER_END_SIGN) || this.scanner.peek(MODIFIER_CLOSE_SIGN) || 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(),
+          start: posEnd - 2,
+          end: posEnd
+        });
+        continue;
+      }
+      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,
+          arg: inner,
+          start: posEnd - 2,
+          end: posEnd
+        });
+        if (!ok2) {
+          this.emit.message(new ExpectedMessage(posEnd, result.postfix));
+          ok = false;
+          break;
+        }
+      } else {
+        emitString(this.scanner.acceptChar());
+        posEnd = this.scanner.position();
+      }
+    }
+    return [{
+      start: posStart,
+      end: 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, config) {
+  return new Parser(scanner, config).parse();
+}
+
+// src/builtin/internal.ts
+var builtins = Symbol();
+function initParseContext(cxt) {
+  cxt.init(builtins, {
+    blockSlotDelayedStack: [],
+    inlineSlotDelayedStack: [],
+    blockSlotData: [],
+    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}`);
+  debug.trace(() => "content is\n" + debugPrintNodes(content));
+  const mod = type == 7 /* BlockModifier */ ? new BlockModifierDefinition(name, 0 /* Normal */) : new InlineModifierDefinition(name, 0 /* Normal */);
+  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 };
+    return [];
+  };
+  mod.expand = (node, cxt) => {
+    if (!node.state?.ok) return [];
+    const contentClone = cloneNodes(content);
+    return contentClone;
+  };
+  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 }]);
+    debug.trace(
+      `pushed ${type} slot data for`,
+      name,
+      slotName == "" ? "(unnamed)" : `= ${slotName}`
+    );
+    return [];
+  };
+  mod.afterProcessExpansion = (node, cxt) => {
+    if (!node.state?.ok) return [];
+    const store = cxt.get(builtins);
+    const data = isInline ? store.inlineSlotData : store.blockSlotData;
+    const pop = data.pop();
+    assert(pop !== void 0 && pop[0] == slotName);
+    debug.trace(
+      `popped ${type} slot data for`,
+      name,
+      slotName == "" ? "(unnamed)" : `= ${slotName}`
+    );
+    return [];
+  };
+  return mod;
+}
+
+// src/builtin/define-block.ts
+var DefineBlockMod = new SystemModifierDefinition("define-block", 0 /* Normal */, {
+  // .define-block:name:args...[:(slot-id)]
+  delayContentExpansion: true,
+  alwaysTryExpand: true,
+  beforeParseContent(node, cxt) {
+    if (node.arguments.length == 0)
+      return [new ArgumentsTooFewMessage(node.head.end - 1, 0)];
+    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
+      ));
+    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 args = node.arguments.slice(1, slotName !== "" ? node.arguments.length - 1 : void 0).map((x) => cxt.evaluateArgument(x));
+    node.state = { name: nameValue, slotName, args };
+    const store = cxt.get(builtins);
+    store.blockSlotDelayedStack.push(node.state.slotName);
+    debug.trace("entering block definition:", node.state.name);
+    return msgs;
+  },
+  afterParseContent(node, cxt) {
+    if (!node.state) return [];
+    const store = cxt.get(builtins);
+    assert(store.blockSlotDelayedStack.pop() == node.state.slotName);
+    debug.trace("leaving block definition", node.state.name);
+    return [];
+  },
+  expand(node, cxt, immediate) {
+    if (!immediate) return void 0;
+    if (node.state) {
+      if (cxt.config.blockModifiers.has(node.state.name))
+        cxt.config.blockModifiers.remove(node.state.name);
+      cxt.config.blockModifiers.add(
+        customModifier(
+          7 /* BlockModifier */,
+          node.state.name,
+          node.state.args,
+          node.state.slotName,
+          node.content
+        )
+      );
+    }
+    return [];
+  }
+});
+
+// src/builtin/define-inline.ts
+var DefineInlineMod = new SystemModifierDefinition("define-inline", 0 /* Normal */, {
+  // .define-inline name:args...[:(slot-id)]
+  delayContentExpansion: true,
+  alwaysTryExpand: true,
+  beforeParseContent(node, cxt) {
+    if (node.arguments.length == 0)
+      return [new ArgumentsTooFewMessage(node.head.end - 1, 0)];
+    const msgs = [];
+    const name = node.arguments[0];
+    const nameValue = cxt.evaluateArgument(name);
+    if (cxt.config.inlineModifiers.has(nameValue))
+      msgs.push(new NameAlreadyDefinedMessage(
+        node.start,
+        name.end - name.start,
+        nameValue
+      ));
+    let slotName = "";
+    if (node.arguments.length > 1) {
+      const last = cxt.evaluateArgument(node.arguments.at(-1));
+      slotName = /^\(.+\)$/.test(last) ? last.substring(1, last.length - 1) : "";
+    }
+    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 store = cxt.get(builtins);
+    store.inlineSlotDelayedStack.push(node.state.slotName);
+    debug.trace("entering inline definition:", node.state.name);
+    return msgs;
+  },
+  afterParseContent(node, cxt) {
+    if (!node.state) return [];
+    const store = cxt.get(builtins);
+    assert(store.inlineSlotDelayedStack.pop() == node.state.slotName);
+    debug.trace("leaving inline definition", node.state.name);
+    return [];
+  },
+  prepareExpand(node, cxt) {
+    if (!node.state) return [];
+    const 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 InlineDefinitonInvalidEntityMessage(n.start, n.end - n.start));
+          break;
+        case 5 /* SystemModifier */:
+          lastIsParagraph = false;
+          concat.push(n);
+          break;
+        default:
+          debug.never(n);
+      }
+    }
+    node.state.definition = concat;
+    return msgs;
+  },
+  expand(node, cxt, immediate) {
+    if (!immediate) return void 0;
+    if (node.state) {
+      if (cxt.config.inlineModifiers.has(node.state.name))
+        cxt.config.inlineModifiers.remove(node.state.name);
+      cxt.config.inlineModifiers.add(
+        customModifier(
+          6 /* InlineModifier */,
+          node.state.name,
+          node.state.args,
+          node.state.slotName,
+          node.state.definition
+        )
+      );
+    }
+    return [];
+  }
+});
+
+// src/builtin/slot.ts
+function slotModifier(type) {
+  const mod = type == 7 /* BlockModifier */ ? new BlockModifierDefinition("slot", 2 /* Marker */) : new InlineModifierDefinition("slot", 2 /* Marker */);
+  const isInline = type == 6 /* InlineModifier */;
+  mod.alwaysTryExpand = true;
+  mod.prepareExpand = (node, cxt, immediate) => {
+    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) {
+        node.state = { ok: false };
+        return [new SlotUsedOutsideDefinitionMessage(node.start, node.head.end - node.start)];
+      }
+      return [];
+    }
+    if (node.arguments.length > 1) {
+      if (immediate) {
+        node.state = { ok: false };
+        const start = node.arguments[1].start - 1;
+        return [new ArgumentsTooManyMessage(start, node.head.end - start)];
+      }
+      return [];
+    }
+    const stack = isInline ? store.inlineSlotDelayedStack : store.blockSlotDelayedStack;
+    if (stack.includes(id)) {
+      debug.trace("delaying", id == "" ? "unnamed slot" : "slot: " + id);
+      return [];
+    }
+    if (node.arguments.length == 0) {
+      node.state = { ok: true, data: data.at(-1), index: data.length - 1 };
+      return [];
+    }
+    for (let i = data.length - 1; i >= 0; i--) if (data[i][0] == id) {
+      node.state = { ok: true, data: data[i], index: i };
+      return [];
+    }
+    if (immediate) {
+      node.state = { ok: false };
+      const arg = node.arguments[0];
+      return [new InvalidArgumentMessage(arg.start, arg.end - arg.start, id)];
+    }
+    return [];
+  };
+  mod.expand = (node, cxt) => {
+    if (!node.state) return void 0;
+    if (!node.state.ok) return [];
+    return cloneNodes(node.state.data[1].slotContent);
+  };
+  mod.beforeProcessExpansion = (node, cxt) => {
+    if (!node.state?.ok) return [];
+    const store = cxt.get(builtins);
+    debug.trace("temporarily removed slot data for", node.state.data[1].mod.name);
+    const data = isInline ? store.inlineSlotData : store.blockSlotData;
+    data.splice(node.state.index, 1);
+    return [];
+  };
+  mod.afterProcessExpansion = (node, cxt) => {
+    if (!node.state?.ok) return [];
+    const store = cxt.get(builtins);
+    debug.trace("reinstated slot data for", node.state.data[1].mod.name);
+    const data = isInline ? store.inlineSlotData : store.blockSlotData;
+    data.splice(node.state.index, 0, node.state.data);
+    return [];
+  };
+  return mod;
+}
+var SlotBlockMod = slotModifier(7 /* BlockModifier */);
+var SlotInlineMod = slotModifier(6 /* InlineModifier */);
+
+// src/builtin/var.ts
+function resolveId(id, cxt) {
+  const store = cxt.get(builtins);
+  let value = void 0;
+  for (let i = store.inlineSlotData.length - 1; i >= 0; i--) {
+    const [_, data] = store.inlineSlotData[i];
+    if ((value = data.args.get(id)) !== void 0)
+      break;
+  }
+  for (let i = store.blockSlotData.length - 1; i >= 0; i--) {
+    const [_, data] = store.blockSlotData[i];
+    if ((value = data.args.get(id)) !== void 0)
+      break;
+  }
+  if (value === void 0)
+    value = cxt.variables.get(id);
+  return value;
+}
+var GetVarInlineMod = new InlineModifierDefinition("$", 2 /* Marker */, {
+  // .$:id
+  prepareExpand(node, cxt) {
+    const check = checkArgumentLength(node, 1);
+    if (check) return [check];
+    const arg = node.arguments[0];
+    const id = cxt.evaluateArgument(arg);
+    if (id == "")
+      return [new InvalidArgumentMessage(arg.start, arg.end - arg.start)];
+    const value = resolveId(id, cxt);
+    if (value === void 0)
+      return [new UndefinedVariableMessage(arg.start, arg.end - arg.start, id)];
+    node.state = { value };
+    return [];
+  },
+  expand(node, cxt) {
+    if (!node.state) return [];
+    return [{ type: 3 /* Text */, content: node.state.value, start: -1, end: -1 }];
+  }
+});
+var GetVarInterpolator = new ArgumentInterpolatorDefinition(
+  "$(",
+  ")",
+  (content, cxt) => resolveId(content, cxt) ?? ""
+);
+var VarMod = new SystemModifierDefinition("var", 2 /* Marker */, {
+  // .var id:value
+  prepareExpand(node, cxt) {
+    const check = checkArgumentLength(node, 2);
+    if (check) return [check];
+    const arg = node.arguments[0];
+    const argValue = cxt.evaluateArgument(arg);
+    if (argValue == "")
+      return [new InvalidArgumentMessage(arg.start, arg.end - arg.start)];
+    node.state = {
+      id: argValue,
+      value: cxt.evaluateArgument(node.arguments[1])
+    };
+    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 basic = new Configuration();
+basic.initializers = [initParseContext];
+basic.systemModifiers.add(DefineBlockMod, DefineInlineMod, VarMod);
+basic.blockModifiers.add(SlotBlockMod);
+basic.inlineModifiers.add(SlotInlineMod, GetVarInlineMod);
+basic.argumentInterpolators.add(GetVarInterpolator);
+var BuiltinConfiguration = Object.freeze(basic);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArgumentInterpolatorDefinition,
+  ArgumentsTooFewMessage,
+  ArgumentsTooManyMessage,
+  BlockModifierDefinition,
+  BuiltinConfiguration,
+  Configuration,
+  ContentShouldBeOnNewlineMessage,
+  Document,
+  ExpectedMessage,
+  InlineDefinitonInvalidEntityMessage,
+  InlineModifierDefinition,
+  InvalidArgumentMessage,
+  MessageSeverity,
+  ModifierFlags,
+  NameAlreadyDefinedMessage,
+  NewBlockShouldBeOnNewlineMessage,
+  NodeType,
+  ParseContext,
+  ReachedRecursionLimitMessage,
+  ReferredMessage,
+  SimpleScanner,
+  SlotUsedOutsideDefinitionMessage,
+  SystemModifierDefinition,
+  UnclosedInlineModifierMessage,
+  UndefinedVariableMessage,
+  UnknownModifierMessage,
+  UnnecessaryNewlineMessage,
+  parse
+});
+//# sourceMappingURL=index.js.map