@nova-lang/cli 0.1.1 → 0.2.0

package/lib/parser.js

@@ -0,0 +1,1037 @@
+const { TokenType, NodeTag, makeNode } = require("./types");
+
+function parse(tokens) {
+  const pool = new StringPool();
+  const p = new Parser(tokens, pool);
+  return p.parse();
+}
+
+class ParseError extends Error {
+  constructor(msg, tok) {
+    super(`ParseError: ${msg} at line ${tok.line}, col ${tok.col}`);
+    this.name = "ParseError";
+  }
+}
+
+class StringPool {
+  constructor() {
+    this._map = new Map();
+    this._strings = [];
+  }
+
+  dup(s) {
+    if (this._map.has(s)) return this._map.get(s);
+    this._map.set(s, s);
+    this._strings.push(s);
+    return s;
+  }
+}
+
+class Parser {
+  constructor(tokens, pool) {
+    this.tokens = tokens;
+    this.pos = 0;
+    this.pool = pool;
+  }
+
+  peek(offset = 0) {
+    const idx = this.pos + offset;
+    return idx < this.tokens.length ? this.tokens[idx] : this.tokens[this.tokens.length - 1];
+  }
+
+  advance() {
+    return this.tokens[this.pos++];
+  }
+
+  expect(type) {
+    const tok = this.peek();
+    if (tok.type !== type) {
+      throw new ParseError(
+        `Expected ${type}, got ${tok.type} ('${tok.value}')`,
+        tok
+      );
+    }
+    return this.advance();
+  }
+
+  maybe(type) {
+    if (this.peek().type === type) return this.advance();
+    return null;
+  }
+
+  skipNewlines() {
+    while (this.peek().type === TokenType.newline) this.advance();
+  }
+
+  skipIndentDedent() {
+    while (this.peek().type === TokenType.indent || this.peek().type === TokenType.dedent) this.advance();
+  }
+
+  skipToRbrace() {
+    let depth = 1;
+    while (depth > 0 && this.peek().type !== TokenType.eof) {
+      const t = this.peek().type;
+      if (t === TokenType.lbrace) depth++;
+      else if (t === TokenType.rbrace) depth--;
+      if (depth > 0) this.advance();
+    }
+  }
+
+  parse() {
+    const children = [];
+    const meta = {};
+
+    while (this.peek().type !== TokenType.eof) {
+      const node = this.parseTopLevel();
+      if (node) {
+        if (node.tag === NodeTag.meta_block) {
+          Object.assign(meta, node.data.pairs);
+        } else {
+          children.push(node);
+        }
+      }
+      this.skipNewlines();
+    }
+
+    return makeNode(NodeTag.document, {
+      children,
+      meta,
+    });
+  }
+
+  parseTopLevel() {
+    this.skipNewlines();
+    this.skipIndentDedent();
+    const tok = this.peek();
+    switch (tok.type) {
+      case TokenType.at:
+        return this.parseBlock();
+      case TokenType.text: {
+        this.advance();
+        return makeNode(NodeTag.text, { value: tok.value });
+      }
+      case TokenType.dash:
+      case TokenType.star:
+        return this.parseList(false);
+      case TokenType.plus:
+        return this.parseList(true);
+      case TokenType.lbracket: {
+        this.advance();
+        return this.parseTableData();
+      }
+      default:
+        this.advance();
+        return null;
+    }
+  }
+
+  parseBlock() {
+    this.expect(TokenType.at);
+    const name = this.expect(TokenType.ident).value;
+
+    const handlers = {
+      def: () => this.parseMacroDef(),
+      macro: () => this.parseMacroDef(),
+      use: () => this.parseUse(),
+      meta: () => this.parseMeta(),
+      schema: () => this.parseSchema(),
+      service: () => this.parseService(),
+      if: () => this.parseIf(),
+      for: () => this.parseFor(),
+      table: () => this.parseTable(),
+      ul: () => this.parseUL(false),
+      ol: () => this.parseUL(true),
+      entry: () => this.parseEntry(),
+      config: () => this.parseMapping(name),
+    };
+
+    if (handlers[name]) return handlers[name]();
+
+    const attrs = this.parseAttrs();
+    const inline_content = this.parseInlineContent();
+    let children = [];
+    if (this.peek().type === TokenType.lbrace) {
+      children = this.parseBlockWithChildren();
+    }
+    return makeNode(NodeTag.block, {
+      name,
+      attrs,
+      inline_content,
+      children,
+    });
+  }
+
+  parseBlockWithChildren() {
+    this.expect(TokenType.lbrace);
+    const children = [];
+    this.skipNewlines();
+    this.skipIndentDedent();
+    while (this.peek().type !== TokenType.rbrace && this.peek().type !== TokenType.eof) {
+      this.skipNewlines();
+      this.skipIndentDedent();
+      if (this.peek().type === TokenType.rbrace) break;
+      const node = this.parseTopLevel();
+      if (node) children.push(node);
+    }
+    this.expect(TokenType.rbrace);
+    return children;
+  }
+
+  parseAttrs() {
+    const attrs = {};
+    if (this.peek().type !== TokenType.lparen) return attrs;
+    this.advance();
+    let idx = 0;
+    this.skipNewlines();
+    while (this.peek().type !== TokenType.rparen && this.peek().type !== TokenType.eof) {
+      this.skipNewlines();
+      this.skipIndentDedent();
+      if (this.peek().type === TokenType.rparen) break;
+      if (this.peek().type === TokenType.comma) { this.advance(); continue; }
+
+      const keyTok = this.peek();
+      if (keyTok.type === TokenType.ident && this.peek(1).type === TokenType.colon) {
+        this.advance();
+        this.advance();
+        attrs[keyTok.value] = this.parseAttrValue();
+      } else if (keyTok.type === TokenType.ident && this.peek(1).type === TokenType.equals) {
+        this.advance();
+        this.advance();
+        attrs[keyTok.value] = this.parseAttrValue();
+      } else if (keyTok.type === TokenType.ident &&
+        (this.peek(1).type === TokenType.comma ||
+          this.peek(1).type === TokenType.rparen ||
+          this.peek(1).type === TokenType.newline)) {
+        this.advance();
+        attrs[keyTok.value] = "true";
+      } else {
+        const val = this.parseAttrValue();
+        attrs[String(idx++)] = val;
+      }
+      this.maybe(TokenType.comma);
+      this.skipNewlines();
+    }
+    this.expect(TokenType.rparen);
+    return attrs;
+  }
+
+  parseAttrValue() {
+    const tok = this.peek();
+    switch (tok.type) {
+      case TokenType.string:
+      case TokenType.number:
+      case TokenType.bool:
+      case TokenType.null:
+        return this.advance().value;
+      case TokenType.ident: {
+        const val = this.advance().value;
+        return val;
+      }
+      case TokenType.text:
+        return this.advance().value;
+      case TokenType.lbracket:
+        return this.parseArrayLiteral();
+      case TokenType.at:
+        return this.parseInlineCommandValue();
+      default:
+        return "";
+    }
+  }
+
+  parseArrayLiteral() {
+    this.expect(TokenType.lbracket);
+    const parts = ["["];
+    while (this.peek().type !== TokenType.rbracket && this.peek().type !== TokenType.eof) {
+      this.skipNewlines();
+      if (this.peek().type === TokenType.rbracket) break;
+      if ([TokenType.comma, TokenType.indent, TokenType.dedent].includes(this.peek().type)) {
+        this.advance();
+        parts.push(",");
+        continue;
+      }
+      if (this.peek().type === TokenType.lbracket) {
+        parts.push(this.parseArrayLiteral());
+      } else {
+        parts.push(this.parseAttrValue());
+      }
+      this.maybe(TokenType.comma);
+      this.skipNewlines();
+    }
+    while ([TokenType.indent, TokenType.dedent].includes(this.peek().type)) this.advance();
+    this.expect(TokenType.rbracket);
+    parts.push("]");
+    return parts.join("");
+  }
+
+  parseInlineContent() {
+    const nodes = [];
+    let textBuf = "";
+
+    const flush = () => {
+      if (textBuf) {
+        nodes.push(makeNode(NodeTag.text, { value: this.pool.dup(textBuf) }));
+        textBuf = "";
+      }
+    };
+
+    while (true) {
+      const tok = this.peek();
+      switch (tok.type) {
+        case TokenType.text:
+        case TokenType.string:
+        case TokenType.number:
+          this.advance();
+          textBuf += tok.value;
+          break;
+        case TokenType.bool:
+        case TokenType.null:
+          this.advance();
+          textBuf += tok.value;
+          break;
+        case TokenType.ident:
+          if (this.peek(1).type === TokenType.colon) break;
+          this.advance();
+          if (textBuf.length > 0 && /\w/.test(textBuf[textBuf.length - 1]) && /\w/.test(tok.value[0])) {
+            textBuf += " ";
+          }
+          textBuf += tok.value;
+          break;
+        case TokenType.at:
+          flush();
+          const inl = this.parseInlineCommand();
+          if (inl) nodes.push(inl);
+          break;
+        case TokenType.math_inline:
+          flush();
+          this.advance();
+          nodes.push(makeNode(NodeTag.math_inline, { source: tok.value }));
+          break;
+        case TokenType.math_display:
+          flush();
+          this.advance();
+          nodes.push(makeNode(NodeTag.math_display, { source: tok.value }));
+          break;
+        case TokenType.interp_start:
+          flush();
+          this.advance();
+          nodes.push(makeNode(NodeTag.interpolation, { expression: tok.value }));
+          break;
+        case TokenType.lbrace:
+          if (nodes.length > 0 && nodes[nodes.length - 1].tag === NodeTag.text) {
+            this.advance();
+            textBuf += "{";
+            break;
+          } else {
+            flush();
+            return nodes;
+          }
+        case TokenType.lparen:
+        case TokenType.rparen:
+        case TokenType.lbracket:
+        case TokenType.rbracket:
+        case TokenType.equals:
+        case TokenType.dot:
+          this.advance();
+          break;
+        default:
+          flush();
+          return nodes;
+      }
+    }
+  }
+
+  parseInlineCommand() {
+    this.expect(TokenType.at);
+    const name = this.expect(TokenType.ident).value;
+    if (["ref", "cite", "label"].includes(name)) return this.parseRefLikeInline(name);
+    const attrs = this.parseAttrs();
+    let content = [];
+    if (this.peek().type === TokenType.lbrace) {
+      content = this.parseInlineBracedContent();
+    }
+    return makeNode(NodeTag.inline_block, { name, attrs, content });
+  }
+
+  parseInlineCommandValue() {
+    this.expect(TokenType.at);
+    const name = this.expect(TokenType.ident).value;
+    this.parseAttrs();
+    if (this.peek().type === TokenType.lparen) this.parseAttrs();
+    let val = "";
+    if (this.peek().type === TokenType.lbrace) {
+      val = this.parseInlineBracedString();
+    }
+    if (val) return `@${name}(${val})`;
+    return `@${name}`;
+  }
+
+  parseInlineBracedString() {
+    this.expect(TokenType.lbrace);
+    let buf = "";
+    while (this.peek().type !== TokenType.rbrace && this.peek().type !== TokenType.eof) {
+      const tok = this.peek();
+      if ([TokenType.text, TokenType.string, TokenType.number, TokenType.ident].includes(tok.type)) {
+        this.advance();
+        buf += tok.value;
+      } else break;
+    }
+    this.expect(TokenType.rbrace);
+    return this.pool.dup(buf);
+  }
+
+  parseRefLikeInline(name) {
+    const keyAttr = name === "label" ? "id" : "key";
+    const attrs = {};
+    if (this.peek().type === TokenType.lparen) {
+      this.advance();
+      let parts = [];
+      while (this.peek().type !== TokenType.rparen && this.peek().type !== TokenType.eof) {
+        const tok = this.peek();
+        if ([TokenType.ident, TokenType.colon, TokenType.string, TokenType.number, TokenType.dot].includes(tok.type)) {
+          this.advance();
+          parts.push(tok.value || ":");
+        } else if (tok.type === TokenType.comma) {
+          this.advance();
+          parts.push(", ");
+        } else if ([TokenType.newline, TokenType.indent, TokenType.dedent].includes(tok.type)) {
+          this.advance();
+        } else break;
+      }
+      const combined = parts.join("").trim();
+      if (combined) attrs[keyAttr] = this.pool.dup(combined);
+      this.expect(TokenType.rparen);
+    }
+    let content = [];
+    if (this.peek().type === TokenType.lbrace) {
+      content = this.parseInlineBracedContent();
+    }
+    return makeNode(NodeTag.inline_block, { name, attrs, content });
+  }
+
+  parseInlineBracedContent() {
+    this.expect(TokenType.lbrace);
+    const nodes = [];
+    let textBuf = "";
+
+    const flush = () => {
+      if (textBuf) {
+        nodes.push(makeNode(NodeTag.text, { value: this.pool.dup(textBuf) }));
+        textBuf = "";
+      }
+    };
+
+    while (this.peek().type !== TokenType.rbrace && this.peek().type !== TokenType.eof) {
+      const tok = this.peek();
+      switch (tok.type) {
+        case TokenType.text:
+        case TokenType.string:
+        case TokenType.number:
+        case TokenType.bool:
+        case TokenType.null:
+          this.advance();
+          if (textBuf.length > 0 && /\w/.test(textBuf[textBuf.length - 1]) && /\w/.test(tok.value[0])) textBuf += " ";
+          textBuf += tok.value;
+          break;
+        case TokenType.ident:
+          this.advance();
+          if (textBuf.length > 0 && /\w/.test(textBuf[textBuf.length - 1]) && /\w/.test(tok.value[0])) textBuf += " ";
+          textBuf += tok.value;
+          break;
+        case TokenType.at:
+          flush();
+          const inl = this.parseInlineCommand();
+          if (inl) nodes.push(inl);
+          break;
+        case TokenType.math_inline:
+          flush();
+          this.advance();
+          nodes.push(makeNode(NodeTag.math_inline, { source: tok.value }));
+          break;
+        case TokenType.interp_start:
+          flush();
+          this.advance();
+          nodes.push(makeNode(NodeTag.interpolation, { expression: tok.value }));
+          break;
+        case TokenType.lparen:
+        case TokenType.rparen:
+        case TokenType.lbracket:
+        case TokenType.rbracket:
+        case TokenType.equals:
+        case TokenType.colon:
+        case TokenType.dot: {
+          this.advance();
+          const c =
+            tok.type === TokenType.lparen ? "(" :
+              tok.type === TokenType.rparen ? ")" :
+                tok.type === TokenType.lbracket ? "[" :
+                  tok.type === TokenType.rbracket ? "]" :
+                    tok.type === TokenType.equals ? "=" :
+                      tok.type === TokenType.colon ? ":" :
+                        tok.value[0] || " ";
+          textBuf += c;
+          break;
+        }
+        case TokenType.comma:
+          this.advance();
+          flush();
+          nodes.push(makeNode(NodeTag.text, { value: ", " }));
+          break;
+        case TokenType.newline:
+        case TokenType.indent:
+        case TokenType.dedent:
+          this.advance();
+          break;
+        default:
+          flush();
+          return nodes;
+      }
+    }
+    flush();
+    if (this.peek().type === TokenType.rbrace) this.advance();
+    else this.skipToRbrace();
+    return nodes;
+  }
+
+  parseList(ordered) {
+    const items = [];
+    while ([TokenType.dash, TokenType.star, TokenType.plus].includes(this.peek().type)) {
+      this.advance();
+      const itemNodes = this.parseListItemContent();
+      const item = itemNodes.length === 1 ? itemNodes[0] :
+        makeNode(NodeTag.block, {
+          name: "li",
+          attrs: {},
+          inline_content: [],
+          children: itemNodes,
+        });
+      items.push(item);
+      this.skipNewlines();
+    }
+    return makeNode(NodeTag.list_block, { ordered, items });
+  }
+
+  parseUL(ordered) {
+    this.parseAttrs();
+    const items = [];
+    if (this.peek().type === TokenType.lbrace) {
+      this.advance();
+      this.skipNewlines();
+      this.skipIndentDedent();
+      while (this.peek().type !== TokenType.rbrace && this.peek().type !== TokenType.eof) {
+        this.skipNewlines();
+        this.skipIndentDedent();
+        if (this.peek().type === TokenType.rbrace) break;
+        const tok = this.peek();
+        if (tok.type === TokenType.dash || tok.type === TokenType.star || (ordered && tok.type === TokenType.plus)) {
+          this.advance();
+          const itemNodes = this.parseListItemContent();
+          const item = itemNodes.length === 1 ? itemNodes[0] :
+            makeNode(NodeTag.block, {
+              name: "li",
+              attrs: {},
+              inline_content: [],
+              children: itemNodes,
+            });
+          items.push(item);
+        } else break;
+        this.skipNewlines();
+      }
+      this.skipToRbrace();
+      this.expect(TokenType.rbrace);
+    }
+    return makeNode(NodeTag.list_block, { ordered, items });
+  }
+
+  parseListItemContent() {
+    const nodes = [];
+    this.skipNewlines();
+    if (this.peek().type === TokenType.at) {
+      const block = this.parseBlock();
+      if (block) nodes.push(block);
+      return nodes;
+    }
+    let textParts = "";
+    let lastWasText = false;
+
+    while (true) {
+      const tok = this.peek();
+      switch (tok.type) {
+        case TokenType.text:
+          this.advance();
+          textParts += tok.value;
+          lastWasText = true;
+          break;
+        case TokenType.string:
+        case TokenType.bool:
+        case TokenType.null:
+          this.advance();
+          textParts += tok.value;
+          lastWasText = false;
+          break;
+        case TokenType.number:
+          this.advance();
+          if (lastWasText) textParts += " ";
+          textParts += tok.value;
+          lastWasText = false;
+          break;
+        case TokenType.ident:
+          this.advance();
+          if (lastWasText) textParts += " ";
+          textParts += tok.value;
+          lastWasText = false;
+          break;
+        case TokenType.at:
+          if (textParts) {
+            nodes.push(makeNode(NodeTag.text, { value: this.pool.dup(textParts) }));
+            textParts = "";
+          }
+          const inl = this.parseInlineCommand();
+          if (inl) nodes.push(inl);
+          lastWasText = false;
+          break;
+        case TokenType.math_inline:
+          if (textParts) {
+            nodes.push(makeNode(NodeTag.text, { value: this.pool.dup(textParts) }));
+            textParts = "";
+          }
+          this.advance();
+          nodes.push(makeNode(NodeTag.math_inline, { source: tok.value }));
+          lastWasText = false;
+          break;
+        case TokenType.interp_start:
+          if (textParts) {
+            nodes.push(makeNode(NodeTag.text, { value: this.pool.dup(textParts) }));
+            textParts = "";
+          }
+          this.advance();
+          nodes.push(makeNode(NodeTag.interpolation, { expression: tok.value }));
+          lastWasText = false;
+          break;
+        default:
+          if (textParts) {
+            nodes.push(makeNode(NodeTag.text, { value: this.pool.dup(textParts) }));
+          }
+          return nodes;
+      }
+    }
+  }
+
+  parseMapping(name) {
+    const pairs = {};
+    if (this.peek().type === TokenType.lbrace) {
+      this.advance();
+      this.skipNewlines();
+      while (this.peek().type !== TokenType.rbrace && this.peek().type !== TokenType.eof) {
+        this.skipNewlines();
+        this.skipIndentDedent();
+        if (this.peek().type === TokenType.rbrace) break;
+        const keyTok = this.peek();
+        if (keyTok.type === TokenType.ident &&
+          (this.peek(1).type === TokenType.colon || this.peek(1).type === TokenType.equals)) {
+          this.advance();
+          this.advance();
+          pairs[keyTok.value] = this.parseAttrValue();
+        } else break;
+        this.maybe(TokenType.comma);
+        this.skipNewlines();
+      }
+      this.skipToRbrace();
+      this.expect(TokenType.rbrace);
+    }
+    return makeNode(NodeTag.block, { name, attrs: pairs, inline_content: [], children: [] });
+  }
+
+  parseMacroDef() {
+    const name = this.expect(TokenType.ident).value;
+    const params = [];
+    const kwargs = {};
+    let hasBlockParam = false;
+    let blockParamName = "content";
+
+    if (this.peek().type === TokenType.lparen) {
+      this.advance();
+      while (this.peek().type !== TokenType.rparen && this.peek().type !== TokenType.eof) {
+        if (this.peek().type === TokenType.comma) { this.advance(); continue; }
+        if (this.peek().type === TokenType.at) {
+          this.advance();
+          hasBlockParam = true;
+          blockParamName = this.expect(TokenType.ident).value;
+        } else if (this.peek().type === TokenType.ident && this.peek(1).type === TokenType.colon) {
+          const key = this.advance().value;
+          this.advance();
+          this.advance(); // type name
+          let defaultVal = "";
+          if (this.peek().type === TokenType.equals) {
+            this.advance();
+            defaultVal = this.parseAttrValue();
+          }
+          kwargs[key] = defaultVal;
+        } else {
+          params.push(this.expect(TokenType.ident).value);
+        }
+        this.maybe(TokenType.comma);
+      }
+      this.expect(TokenType.rparen);
+    }
+
+    let body = [];
+    if (this.peek().type === TokenType.lbrace) {
+      body = this.parseBlockWithChildren();
+    }
+    return makeNode(NodeTag.macro_def, {
+      name,
+      params,
+      kwargs,
+      hasBlockParam,
+      blockParamName,
+      body,
+    });
+  }
+
+  parseUse() {
+    const path = this.expect(TokenType.string).value;
+    return makeNode(NodeTag.use_block, { path });
+  }
+
+  parseMeta() {
+    const pairs = {};
+    if (this.peek().type === TokenType.lbrace) {
+      this.advance();
+      this.skipNewlines();
+      this.skipIndentDedent();
+      while (this.peek().type !== TokenType.rbrace && this.peek().type !== TokenType.eof) {
+        this.skipNewlines();
+        this.skipIndentDedent();
+        if (this.peek().type === TokenType.rbrace) break;
+        const key = this.expect(TokenType.ident).value;
+        this.expect(TokenType.colon);
+        pairs[key] = this.parseMetaValue();
+        this.maybe(TokenType.comma);
+        this.skipNewlines();
+      }
+      this.expect(TokenType.rbrace);
+    }
+    return makeNode(NodeTag.meta_block, { pairs });
+  }
+
+  parseMetaValue() {
+    const tok = this.peek();
+    switch (tok.type) {
+      case TokenType.string:
+      case TokenType.bool:
+      case TokenType.null:
+        return this.advance().value;
+      case TokenType.lbracket:
+        return this.parseArrayLiteral();
+      default: {
+        let buf = "";
+        while (true) {
+          const t = this.peek();
+          if ([TokenType.newline, TokenType.rbrace, TokenType.comma, TokenType.eof, TokenType.dedent].includes(t.type)) break;
+          if ([TokenType.text, TokenType.number, TokenType.ident, TokenType.dash, TokenType.dot, TokenType.colon, TokenType.equals].includes(t.type)) {
+            this.advance();
+            buf += t.value || "";
+          } else break;
+        }
+        return this.pool.dup(buf.trim());
+      }
+    }
+  }
+
+  parseEntry() {
+    let attrs = {};
+    if (this.peek().type === TokenType.lparen) {
+      attrs = this.parseAttrs();
+    }
+    const key = attrs.key || "";
+    return makeNode(NodeTag.biblio_entry, { key, attrs });
+  }
+
+  parseSchema() {
+    let name;
+    if (this.peek().type === TokenType.lparen) {
+      this.advance();
+      name = this.expect(TokenType.ident).value;
+      this.expect(TokenType.rparen);
+    } else {
+      name = this.expect(TokenType.ident).value;
+    }
+    const fields = [];
+    if (this.peek().type === TokenType.lbrace) {
+      this.advance();
+      this.skipNewlines();
+      while (this.peek().type !== TokenType.rbrace && this.peek().type !== TokenType.eof) {
+        this.skipNewlines();
+        this.skipIndentDedent();
+        if (this.peek().type === TokenType.rbrace) break;
+        const fieldName = this.expect(TokenType.ident).value;
+        this.expect(TokenType.colon);
+        const typeName = this.parseTypeExpr();
+        let optional = false;
+        if (this.peek().type === TokenType.question) {
+          this.advance();
+          optional = true;
+        }
+        let tag = 0;
+        if (this.peek().type === TokenType.at) {
+          this.advance();
+          tag = parseInt(this.expect(TokenType.number).value, 10);
+        }
+        let defaultVal = null;
+        if (this.peek().type === TokenType.equals) {
+          this.advance();
+          defaultVal = this.parseAttrValue();
+        }
+        fields.push({ name: fieldName, type_name: typeName, tag, optional, default: defaultVal });
+        this.maybe(TokenType.comma);
+        this.skipNewlines();
+      }
+      this.expect(TokenType.rbrace);
+    }
+    return makeNode(NodeTag.schema_def, { name, fields });
+  }
+
+  parseTypeExpr() {
+    let buf = this.expect(TokenType.ident).value;
+    if (this.peek().type === TokenType.lt) {
+      this.advance();
+      buf += "<";
+      buf += this.parseTypeExpr();
+      while (this.peek().type === TokenType.comma) {
+        this.advance();
+        buf += ", ";
+        buf += this.parseTypeExpr();
+      }
+      this.expect(TokenType.gt);
+      buf += ">";
+    }
+    return this.pool.dup(buf);
+  }
+
+  parseService() {
+    let name;
+    if (this.peek().type === TokenType.lparen) {
+      this.advance();
+      name = this.expect(TokenType.ident).value;
+      this.expect(TokenType.rparen);
+    } else {
+      name = this.expect(TokenType.ident).value;
+    }
+    const methods = [];
+    if (this.peek().type === TokenType.lbrace) {
+      this.advance();
+      this.skipNewlines();
+      while (this.peek().type !== TokenType.rbrace && this.peek().type !== TokenType.eof) {
+        this.skipNewlines();
+        this.skipIndentDedent();
+        if (this.peek().type === TokenType.rbrace) break;
+        const methodName = this.expect(TokenType.ident).value;
+        const params = [];
+        if (this.peek().type === TokenType.lparen) {
+          this.advance();
+          while (this.peek().type !== TokenType.rparen && this.peek().type !== TokenType.eof) {
+            if (this.peek().type === TokenType.comma) { this.advance(); continue; }
+            const pname = this.expect(TokenType.ident).value;
+            this.expect(TokenType.colon);
+            const ptype = this.parseTypeExpr();
+            params.push({ name: pname, type_name: ptype });
+            this.maybe(TokenType.comma);
+          }
+          this.expect(TokenType.rparen);
+        }
+        let returns = null;
+        if (this.peek().type === TokenType.dash && this.peek(1).type === TokenType.gt) {
+          this.advance();
+          this.advance();
+          returns = this.parseTypeExpr();
+        }
+        methods.push({ name: methodName, params, returns });
+        this.maybe(TokenType.comma);
+        this.skipNewlines();
+      }
+      this.expect(TokenType.rbrace);
+    }
+    return makeNode(NodeTag.service_def, { name, methods });
+  }
+
+  parseIf() {
+    let condition = "";
+    if (this.peek().type === TokenType.lparen) {
+      this.advance();
+      const parts = [];
+      let depth = 1;
+      while (depth > 0 && this.peek().type !== TokenType.eof) {
+        const tok = this.peek();
+        if (tok.type === TokenType.lparen) depth++;
+        else if (tok.type === TokenType.rparen) depth--;
+        if (depth === 0) break;
+        this.advance();
+        parts.push(tok.value);
+      }
+      condition = this.pool.dup(parts.join("").trim());
+      this.expect(TokenType.rparen);
+    }
+    let thenBody = [];
+    if (this.peek().type === TokenType.lbrace) thenBody = this.parseBlockWithChildren();
+    let elseBody = [];
+    this.skipNewlines();
+    if (this.peek().type === TokenType.at && this.peek(1).type === TokenType.ident &&
+      this.peek(1).value === "else") {
+      this.advance();
+      this.advance();
+      if (this.peek().type === TokenType.lbrace) elseBody = this.parseBlockWithChildren();
+    }
+    return makeNode(NodeTag.if_block, { condition, then_body: thenBody, else_body: elseBody });
+  }
+
+  parseFor() {
+    let varName = "";
+    let iterable = "";
+    if (this.peek().type === TokenType.lparen) {
+      this.advance();
+      varName = this.expect(TokenType.ident).value;
+      this.expect(TokenType.comma);
+      iterable = this.expect(TokenType.ident).value;
+      this.expect(TokenType.rparen);
+    } else {
+      varName = this.expect(TokenType.ident).value;
+      if (this.peek().type === TokenType.ident && this.peek().value === "in") this.advance();
+      iterable = this.expect(TokenType.ident).value;
+    }
+    let body = [];
+    if (this.peek().type === TokenType.lbrace) body = this.parseBlockWithChildren();
+    return makeNode(NodeTag.for_block, { var_name: varName, iterable, body });
+  }
+
+  parseTable() {
+    let attrs = this.parseAttrs();
+    const src = attrs.src || null;
+    const caption = attrs.caption || attrs.cap || null;
+    let headers = null;
+    const rows = [];
+    let data = null;
+
+    if (this.peek().type === TokenType.lbrace) {
+      this.advance();
+      this.skipNewlines();
+      this.skipIndentDedent();
+      while (this.peek().type !== TokenType.rbrace && this.peek().type !== TokenType.eof) {
+        this.skipNewlines();
+        this.skipIndentDedent();
+        if (this.peek().type === TokenType.rbrace) break;
+        if (this.peek().type === TokenType.at) {
+          this.advance();
+          const subName = this.expect(TokenType.ident).value;
+          const cells = this.parseTableRowContent();
+          if (subName === "header") headers = cells;
+          else if (subName === "row") rows.push(cells);
+        } else if (this.peek().type === TokenType.lbracket) {
+          data = this.parseTableArrayData();
+        } else break;
+        this.skipNewlines();
+        this.skipIndentDedent();
+      }
+      this.skipToRbrace();
+      this.expect(TokenType.rbrace);
+    }
+    return makeNode(NodeTag.table_block, { headers, rows, src, caption, data });
+  }
+
+  parseTableRowContent() {
+    const cells = [];
+    if (this.peek().type === TokenType.lbrace) {
+      this.advance();
+      this.skipNewlines();
+      while (this.peek().type !== TokenType.rbrace && this.peek().type !== TokenType.eof) {
+        if ([TokenType.comma, TokenType.newline, TokenType.indent, TokenType.dedent].includes(this.peek().type)) {
+          this.advance();
+          continue;
+        }
+        const val = this.parseAttrValue();
+        cells.push(val || "");
+        this.maybe(TokenType.comma);
+      }
+      this.skipToRbrace();
+      this.expect(TokenType.rbrace);
+    } else if (this.peek().type === TokenType.lbracket) {
+      this.advance();
+      this.skipNewlines();
+      while (this.peek().type !== TokenType.rbracket && this.peek().type !== TokenType.eof) {
+        if ([TokenType.comma, TokenType.newline, TokenType.indent, TokenType.dedent].includes(this.peek().type)) {
+          this.advance();
+          continue;
+        }
+        const val = this.parseAttrValue();
+        cells.push(val || "");
+        this.maybe(TokenType.comma);
+        this.skipNewlines();
+      }
+      this.expect(TokenType.rbracket);
+    } else {
+      let cellText = "";
+      while (true) {
+        const tok = this.peek();
+        if ([TokenType.newline, TokenType.rbrace, TokenType.dedent, TokenType.indent, TokenType.eof].includes(tok.type)) break;
+        if (tok.type === TokenType.comma) {
+          this.advance();
+          cells.push(this.pool.dup(cellText.trim()));
+          cellText = "";
+        } else if ([TokenType.text, TokenType.string, TokenType.number, TokenType.ident, TokenType.bool, TokenType.null].includes(tok.type)) {
+          this.advance();
+          cellText += tok.value;
+        } else break;
+      }
+      if (cellText) cells.push(this.pool.dup(cellText.trim()));
+    }
+    return cells;
+  }
+
+  parseTableData() {
+    this.advance();
+    const data = this.parseTableArrayData2();
+    return makeNode(NodeTag.table_block, {
+      headers: null,
+      rows: [],
+      src: null,
+      caption: null,
+      data,
+    });
+  }
+
+  parseTableArrayData() {
+    const data = [];
+    this.expect(TokenType.lbracket);
+    this.skipNewlines();
+    this.skipIndentDedent();
+    while (this.peek().type === TokenType.lbracket) {
+      data.push(this.parseTableRowContent());
+      this.maybe(TokenType.comma);
+      this.skipNewlines();
+      this.skipIndentDedent();
+    }
+    this.expect(TokenType.rbracket);
+    return data;
+  }
+
+  parseTableArrayData2() {
+    const data = [];
+    this.expect(TokenType.lbracket);
+    this.skipNewlines();
+    this.skipIndentDedent();
+    while (this.peek().type !== TokenType.rbracket && this.peek().type !== TokenType.eof) {
+      this.skipNewlines();
+      this.skipIndentDedent();
+      if (this.peek().type === TokenType.rbracket) break;
+      if (this.peek().type === TokenType.lbracket) {
+        data.push(this.parseTableRowContent());
+      } else break;
+      this.maybe(TokenType.comma);
+      this.skipNewlines();
+      this.skipIndentDedent();
+    }
+    this.expect(TokenType.rbracket);
+    return data;
+  }
+}
+
+module.exports = { parse, Parser };