@xnoxs/flux-lang 3.1.1

package/src/self/parser.js

@@ -0,0 +1,1571 @@
+// ── Flux stdlib ──
+
+function map(arr, fn) { return arr.map(fn); }
+
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
+// ── end stdlib ──
+
+// Generated by Flux Transpiler v3.1.0
+"use strict";
+
+const { T } = require("./lexer");
+function makeParseError(msg, tok) {
+  const line = (tok?.line ?? "?");
+  const col = (tok?.col ?? "?");
+  const err = new Error(`[Parser ${line}:${col}] ${msg}`);
+  err.name = "ParseError";
+  err.tok = tok;
+  return err;
+}
+class Parser {
+  constructor(tokens, pos) {
+    this.tokens = tokens;
+    this.pos = pos;
+  }
+
+  peek(n = 0) {
+    return (this.tokens[(this.pos + n)] ?? { type: "EOF", value: null, line: 0, col: 0 });
+  }
+
+  check(typ) {
+    return (this.peek().type == typ);
+  }
+
+  at(a, b = null, c = null, d = null, e = null, f = null) {
+    const t = this.peek().type;
+    return ((((((t == a) || ((b != null) && (t == b))) || ((c != null) && (t == c))) || ((d != null) && (t == d))) || ((e != null) && (t == e))) || ((f != null) && (t == f)));
+  }
+
+  eat(typ) {
+    const tok = this.peek();
+    if ((tok.type != typ)) {
+      throw makeParseError(`Expected '${typ}', got '${tok.type}' (${JSON.stringify(tok.value)})`, tok);
+    }
+    this.pos = (this.pos + 1);
+    return tok;
+  }
+
+  maybe(typ) {
+    if (this.check(typ)) {
+      this.pos = (this.pos + 1);
+      return true;
+    }
+    return false;
+  }
+
+  skip() {
+    const t = this.tokens[this.pos];
+    this.pos = (this.pos + 1);
+    return t;
+  }
+
+  skipNewlines() {
+    while (this.check(T.NEWLINE)) {
+      this.pos = (this.pos + 1);
+    }
+  }
+
+  err(msg) {
+    throw makeParseError(msg, this.peek());
+  }
+
+  parseBlock() {
+    this.eat(T.COLON);
+    if (this.check(T.NEWLINE)) {
+      this.pos = (this.pos + 1);
+      this.eat(T.INDENT);
+      const body = this.parseStmtList();
+      this.maybe(T.DEDENT);
+      return body;
+    }
+    const stmt = this.parseOneStmt();
+    return [stmt];
+  }
+
+  parseStmtList() {
+    const stmts = [];
+    while ((!this.check(T.DEDENT) && !this.check(T.EOF))) {
+      this.skipNewlines();
+      if ((this.check(T.DEDENT) || this.check(T.EOF))) {
+        break;
+      }
+      stmts.push(this.parseOneStmt());
+    }
+    return stmts;
+  }
+
+  parse() {
+    this.skipNewlines();
+    const body = [];
+    while (!this.check(T.EOF)) {
+      this.skipNewlines();
+      if (this.check(T.EOF)) {
+        break;
+      }
+      body.push(this.parseOneStmt());
+    }
+    return { type: "Program", body };
+  }
+
+  parseOneStmt() {
+    const tok = this.peek();
+    if (((tok.type == T.VAR) || (tok.type == T.VAL))) {
+      return this.parseVarDecl();
+    }
+    if ((tok.type == T.FN)) {
+      return this.parseFnDecl(false);
+    }
+    if ((tok.type == T.ASYNC)) {
+      return this.parseAsyncFn();
+    }
+    if ((tok.type == T.CLASS)) {
+      return this.parseClassDecl();
+    }
+    if ((tok.type == T.IF)) {
+      return this.parseIf();
+    }
+    if ((tok.type == T.FOR)) {
+      return this.parseFor();
+    }
+    if ((tok.type == T.WHILE)) {
+      return this.parseWhile();
+    }
+    if ((tok.type == T.DO)) {
+      return this.parseDoWhile();
+    }
+    if ((tok.type == T.MATCH)) {
+      return this.parseMatch();
+    }
+    if ((tok.type == T.RETURN)) {
+      return this.parseReturn();
+    }
+    if ((tok.type == T.BREAK)) {
+      this.skip();
+      this.skipNewlines();
+      return { type: "BreakStmt", loc: tok };
+    }
+    if ((tok.type == T.CONTINUE)) {
+      this.skip();
+      this.skipNewlines();
+      return { type: "ContinueStmt", loc: tok };
+    }
+    if ((tok.type == T.IMPORT)) {
+      return this.parseImport();
+    }
+    if ((tok.type == T.EXPORT)) {
+      return this.parseExport();
+    }
+    if ((tok.type == T.TRY)) {
+      return this.parseTryCatch();
+    }
+    if ((tok.type == T.THROW)) {
+      return this.parseThrow();
+    }
+    if ((tok.type == T.TYPE)) {
+      return this.parseTypeDecl();
+    }
+    if ((tok.type == T.INTERFACE)) {
+      return this.parseInterfaceDecl();
+    }
+    if ((tok.type == T.ENUM)) {
+      return this.parseEnumDecl();
+    }
+    return this.parseExprStmt();
+  }
+
+  parseVarDecl() {
+    const kind = ((this.peek().type == T.VAR) ? "var" : "val");
+    const loc = this.skip();
+    if (this.check(T.LBRACE)) {
+      const pattern = this.parseObjectDestructurePattern();
+      this.eat(T.EQ);
+      const init = this.parseExpr();
+      this.skipNewlines();
+      return { type: "DestructureDecl", kind, patternType: "object", pattern, init, loc };
+    }
+    if (this.check(T.LBRACKET)) {
+      const pattern = this.parseArrayDestructurePattern();
+      this.eat(T.EQ);
+      const init = this.parseExpr();
+      this.skipNewlines();
+      return { type: "DestructureDecl", kind, patternType: "array", pattern, init, loc };
+    }
+    const name = this.eat(T.IDENT).value;
+    let typeAnn = null;
+    if (this.maybe(T.COLON)) {
+      typeAnn = this.parseTypeAnn();
+    }
+    let init = null;
+    if (this.maybe(T.EQ)) {
+      init = this.parseExpr();
+    }
+    this.skipNewlines();
+    return { type: "VarDecl", kind, name, typeAnn, init, loc };
+  }
+
+  parseObjectDestructurePattern() {
+    this.eat(T.LBRACE);
+    const props = [];
+    while ((!this.check(T.RBRACE) && !this.check(T.EOF))) {
+      let rest = false;
+      if (this.check(T.DOTDOTDOT)) {
+        this.pos = (this.pos + 1);
+        rest = true;
+      }
+      const key = this.eat(T.IDENT).value;
+      if (rest) {
+        props.push({ key, alias: key, rest: true });
+        break;
+      }
+      let alias = key;
+      if (this.maybe(T.COLON)) {
+        alias = this.eat(T.IDENT).value;
+      }
+      let defaultVal = null;
+      if (this.maybe(T.EQ)) {
+        defaultVal = this.parseExpr();
+      }
+      props.push({ key, alias, defaultVal, rest: false });
+      if (!this.maybe(T.COMMA)) {
+        break;
+      }
+    }
+    this.eat(T.RBRACE);
+    return props;
+  }
+
+  parseArrayDestructurePattern() {
+    this.eat(T.LBRACKET);
+    const items = [];
+    while ((!this.check(T.RBRACKET) && !this.check(T.EOF))) {
+      if (this.check(T.COMMA)) {
+        items.push(null);
+        this.pos = (this.pos + 1);
+        continue;
+      }
+      let rest = false;
+      if (this.check(T.DOTDOTDOT)) {
+        this.pos = (this.pos + 1);
+        rest = true;
+      }
+      const name = this.eat(T.IDENT).value;
+      let defaultVal = null;
+      if (this.maybe(T.EQ)) {
+        defaultVal = this.parseExpr();
+      }
+      items.push({ name, defaultVal, rest });
+      if (rest) {
+        break;
+      }
+      if (!this.maybe(T.COMMA)) {
+        break;
+      }
+    }
+    this.eat(T.RBRACKET);
+    return items;
+  }
+
+  parseTypeAnn() {
+    let name = this.parseIntersectionType();
+    while (this.check(T.PIPEB)) {
+      this.pos = (this.pos + 1);
+      name = ((name + " | ") + this.parseIntersectionType());
+    }
+    return name;
+  }
+
+  parseIntersectionType() {
+    let name = this.parseSingleType();
+    while (this.check(T.AMPERSAND)) {
+      this.pos = (this.pos + 1);
+      name = ((name + " & ") + this.parseSingleType());
+    }
+    return name;
+  }
+
+  parseSingleType() {
+    const tok = this.peek();
+    if ((tok.type == T.LBRACKET)) {
+      this.pos = (this.pos + 1);
+      const parts = [];
+      while ((!this.check(T.RBRACKET) && !this.check(T.EOF))) {
+        parts.push(this.parseTypeAnn());
+        if (!this.maybe(T.COMMA)) {
+          break;
+        }
+      }
+      this.eat(T.RBRACKET);
+      return (("[" + parts.join(", ")) + "]");
+    }
+    if ((tok.type == T.LBRACE)) {
+      this.pos = (this.pos + 1);
+      const pairs = [];
+      while ((!this.check(T.RBRACE) && !this.check(T.EOF))) {
+        if (this.check(T.LBRACKET)) {
+          this.pos = (this.pos + 1);
+          const iname = this.eat(T.IDENT).value;
+          this.eat(T.COLON);
+          const iktype = this.parseTypeAnn();
+          this.eat(T.RBRACKET);
+          this.eat(T.COLON);
+          const ivtype = this.parseTypeAnn();
+          pairs.push(`[${iname}: ${iktype}]: ${ivtype}`);
+        }
+        else {
+          const key = (this.at(T.IDENT, T.STRING) ? this.skip().value : this.eat(T.IDENT).value);
+          let optional = false;
+          if (this.check(T.QUESTION)) {
+            this.pos = (this.pos + 1);
+            optional = true;
+          }
+          this.eat(T.COLON);
+          const valType = this.parseTypeAnn();
+          const optStr = (optional ? "?" : "");
+          pairs.push(`${key}${optStr}: ${valType}`);
+        }
+        this.maybe(T.COMMA);
+      }
+      this.eat(T.RBRACE);
+      return (("{ " + pairs.join(", ")) + " }");
+    }
+    if ((tok.type == T.LPAREN)) {
+      this.pos = (this.pos + 1);
+      const inner = this.parseTypeAnn();
+      this.eat(T.RPAREN);
+      return (("(" + inner) + ")");
+    }
+    if (((tok.type == T.IDENT) && (tok.value == "keyof"))) {
+      this.pos = (this.pos + 1);
+      return ("keyof " + this.parseSingleType());
+    }
+    if ((tok.type == T.TYPEOF)) {
+      this.pos = (this.pos + 1);
+      return ("typeof " + this.eat(T.IDENT).value);
+    }
+    if ((tok.type == T.READONLY)) {
+      this.pos = (this.pos + 1);
+      return ("readonly " + this.parseSingleType());
+    }
+    if (((tok.type == T.IDENT) && (tok.value == "infer"))) {
+      this.pos = (this.pos + 1);
+      return ("infer " + this.eat(T.IDENT).value);
+    }
+    if ((tok.type == T.FN)) {
+      this.pos = (this.pos + 1);
+      const paramTypes = [];
+      if (this.check(T.LPAREN)) {
+        this.pos = (this.pos + 1);
+        while ((!this.check(T.RPAREN) && !this.check(T.EOF))) {
+          let pt = "";
+          if ((this.check(T.IDENT) && (this.peek(1).type == T.COLON))) {
+            this.pos = (this.pos + 2);
+            pt = this.parseTypeAnn();
+          }
+          else {
+            pt = this.parseTypeAnn();
+          }
+          paramTypes.push(pt);
+          if (!this.maybe(T.COMMA)) {
+            break;
+          }
+        }
+        this.eat(T.RPAREN);
+      }
+      let retType = "Void";
+      if (this.check(T.ARROW)) {
+        this.pos = (this.pos + 1);
+        retType = this.parseTypeAnn();
+      }
+      return ((("fn(" + paramTypes.join(", ")) + ") -> ") + retType);
+    }
+    let name = "";
+    if ((((tok.type == T.IDENT) || (tok.type == T.CONST)) || (tok.type == T.TYPE))) {
+      name = this.skip().value;
+    }
+    else {
+      name = this.eat(T.IDENT).value;
+    }
+    if (this.check(T.EXTENDS)) {
+      this.pos = (this.pos + 1);
+      const constraint = this.parseSingleType();
+      this.eat(T.QUESTION);
+      const thenType = this.parseTypeAnn();
+      this.eat(T.COLON);
+      const elseType = this.parseTypeAnn();
+      return `${name} extends ${constraint} ? ${thenType} : ${elseType}`;
+    }
+    if (this.check(T.LT)) {
+      this.pos = (this.pos + 1);
+      const params = [this.parseTypeAnn()];
+      while (this.maybe(T.COMMA)) {
+        params.push(this.parseTypeAnn());
+      }
+      this.eat(T.GT);
+      name = (((name + "<") + params.join(", ")) + ">");
+    }
+    while ((this.check(T.LBRACKET) && (this.peek(1).type == T.RBRACKET))) {
+      this.pos = (this.pos + 2);
+      name = (name + "[]");
+    }
+    if ((this.check(T.QUESTION) && (this.peek(1).type != T.DOT))) {
+      this.pos = (this.pos + 1);
+      name = (name + "?");
+    }
+    return name;
+  }
+
+  isTypeAnnBeforeColon() {
+    const saved = this.pos;
+    try {
+      const tok0 = this.peek();
+      if ((((tok0.type == T.LBRACKET) || (tok0.type == T.LBRACE)) || (tok0.type == T.LPAREN))) {
+        let depth = 0;
+        let i = 0;
+        while ((this.tokens[(this.pos + i)] && (this.tokens[(this.pos + i)].type != T.EOF))) {
+          const tt = this.tokens[(this.pos + i)].type;
+          if (((((tt == T.LBRACKET) || (tt == T.LBRACE)) || (tt == T.LPAREN)) || (tt == T.LT))) {
+            depth = (depth + 1);
+          }
+          if (((((tt == T.RBRACKET) || (tt == T.RBRACE)) || (tt == T.RPAREN)) || (tt == T.GT))) {
+            depth = (depth - 1);
+          }
+          i = (i + 1);
+          if ((depth == 0)) {
+            break;
+          }
+        }
+        if ((this.tokens[(this.pos + i)] && (this.tokens[(this.pos + i)].type == T.QUESTION))) {
+          i = (i + 1);
+        }
+        const nextType = this.tokens[(this.pos + i)]?.type;
+        this.pos = saved;
+        return (nextType == T.COLON);
+      }
+      if (((((tok0.type != T.IDENT) && (tok0.type != T.TYPEOF)) && (tok0.type != T.READONLY)) && (tok0.type != T.FN))) {
+        this.pos = saved;
+        return false;
+      }
+      this.parseTypeAnn();
+      const result = (this.check(T.NEWLINE) || this.check(T.EOF));
+      this.pos = saved;
+      return result;
+    }
+    catch (e) {
+      this.pos = saved;
+      return false;
+    }
+  }
+
+  isColonReturnType() {
+    const saved = this.pos;
+    try {
+      this.pos = (this.pos + 1);
+      if (!this.at(T.IDENT, T.LBRACKET, T.LBRACE, T.LPAREN, T.FN, T.READONLY, T.TYPEOF)) {
+        this.pos = saved;
+        return false;
+      }
+      this.parseTypeAnn();
+      const result = (this.check(T.NEWLINE) || this.check(T.EOF));
+      this.pos = saved;
+      return result;
+    }
+    catch (e) {
+      this.pos = saved;
+      return false;
+    }
+  }
+
+  parseTypeDecl() {
+    const loc = this.eat(T.TYPE);
+    const name = this.eat(T.IDENT).value;
+    const typeParams = [];
+    if (this.check(T.LT)) {
+      this.pos = (this.pos + 1);
+      while ((!this.check(T.GT) && !this.check(T.EOF))) {
+        typeParams.push(this.eat(T.IDENT).value);
+        if (!this.maybe(T.COMMA)) {
+          break;
+        }
+      }
+      this.eat(T.GT);
+    }
+    this.eat(T.EQ);
+    const variants = [];
+    let running = true;
+    while (running) {
+      const vname = this.eat(T.IDENT).value;
+      const fields = [];
+      const fieldTypes = {  };
+      if (this.check(T.LPAREN)) {
+        this.eat(T.LPAREN);
+        while ((!this.check(T.RPAREN) && !this.check(T.EOF))) {
+          const ftok = this.peek();
+          let fname = "";
+          if ((ftok.type == T.IDENT)) {
+            fname = this.skip().value;
+          }
+          else {
+            fname = this.skip().value;
+          }
+          if (this.maybe(T.COLON)) {
+            fieldTypes[fname] = this.parseTypeAnn();
+          }
+          fields.push(fname);
+          if (!this.maybe(T.COMMA)) {
+            break;
+          }
+        }
+        this.eat(T.RPAREN);
+      }
+      variants.push({ name: vname, fields, fieldTypes });
+      if (!this.check(T.PIPEB)) {
+        running = false;
+      }
+      else {
+        this.pos = (this.pos + 1);
+      }
+    }
+    this.skipNewlines();
+    return { type: "TypeDecl", name, variants, loc };
+  }
+
+  parseInterfaceDecl() {
+    const loc = this.eat(T.INTERFACE);
+    const name = this.eat(T.IDENT).value;
+    const typeParams = [];
+    if (this.check(T.LT)) {
+      this.pos = (this.pos + 1);
+      while ((!this.check(T.GT) && !this.check(T.EOF))) {
+        typeParams.push(this.eat(T.IDENT).value);
+        if (!this.maybe(T.COMMA)) {
+          break;
+        }
+      }
+      this.eat(T.GT);
+    }
+    const superInterfaces = [];
+    if (this.maybe(T.EXTENDS)) {
+      superInterfaces.push(this.eat(T.IDENT).value);
+      while (this.maybe(T.COMMA)) {
+        superInterfaces.push(this.eat(T.IDENT).value);
+      }
+    }
+    this.eat(T.COLON);
+    if (this.check(T.NEWLINE)) {
+      this.pos = (this.pos + 1);
+    }
+    this.eat(T.INDENT);
+    const members = [];
+    while ((!this.check(T.DEDENT) && !this.check(T.EOF))) {
+      this.skipNewlines();
+      if ((this.check(T.DEDENT) || this.check(T.EOF))) {
+        break;
+      }
+      const mods = this.parseAccessModifiers();
+      if (this.check(T.FN)) {
+        this.eat(T.FN);
+        const mname = this.eat(T.IDENT).value;
+        const params = this.parseParamList();
+        let retType = null;
+        if (this.maybe(T.ARROW)) {
+          retType = this.parseTypeAnn();
+        }
+        this.skipNewlines();
+        members.push({ kind: "method", name: mname, params, retType, modifiers: mods, isAsync: false });
+      }
+      else if (this.check(T.IDENT)) {
+        const fname = this.eat(T.IDENT).value;
+        let optional = false;
+        if (this.check(T.QUESTION)) {
+          this.pos = (this.pos + 1);
+          optional = true;
+        }
+        this.eat(T.COLON);
+        const ftype = this.parseTypeAnn();
+        this.skipNewlines();
+        members.push({ kind: "field", name: fname, typeAnn: ftype, optional, modifiers: mods });
+      }
+      else {
+        this.skip();
+      }
+    }
+    this.maybe(T.DEDENT);
+    return { type: "InterfaceDecl", name, typeParams, superInterfaces, members, loc };
+  }
+
+  parseEnumDecl() {
+    const loc = this.eat(T.ENUM);
+    const name = this.eat(T.IDENT).value;
+    this.eat(T.COLON);
+    if (this.check(T.NEWLINE)) {
+      this.pos = (this.pos + 1);
+      this.eat(T.INDENT);
+    }
+    const members = [];
+    let autoIndex = 0;
+    while ((!this.check(T.DEDENT) && !this.check(T.EOF))) {
+      this.skipNewlines();
+      if ((this.check(T.DEDENT) || this.check(T.EOF))) {
+        break;
+      }
+      const mname = this.eat(T.IDENT).value;
+      let value = { type: "NumberLit", value: autoIndex };
+      if (this.maybe(T.EQ)) {
+        const parsed = this.parseExpr();
+        value = parsed;
+        if ((parsed.type == "NumberLit")) {
+          autoIndex = parsed.value;
+        }
+      }
+      else {
+        value = { type: "NumberLit", value: autoIndex };
+      }
+      autoIndex = (autoIndex + 1);
+      this.skipNewlines();
+      members.push({ name: mname, value });
+    }
+    this.maybe(T.DEDENT);
+    return { type: "EnumDecl", name, members, loc };
+  }
+
+  parseIf() {
+    const loc = this.eat(T.IF);
+    const cond = this.parseExpr();
+    const then = this.parseBlock();
+    const elseifs = [];
+    let else_ = null;
+    this.skipNewlines();
+    while (this.check(T.ELSE)) {
+      this.pos = (this.pos + 1);
+      if (this.check(T.IF)) {
+        this.pos = (this.pos + 1);
+        const eic = this.parseExpr();
+        const eib = this.parseBlock();
+        elseifs.push({ cond: eic, body: eib });
+        this.skipNewlines();
+      }
+      else {
+        else_ = this.parseBlock();
+        break;
+      }
+    }
+    return { type: "IfStmt", cond, then, elseifs, else_, loc };
+  }
+
+  parseFor() {
+    const loc = this.eat(T.FOR);
+    let isAwait = false;
+    if (this.check(T.AWAIT)) {
+      this.pos = (this.pos + 1);
+      isAwait = true;
+    }
+    const varName = this.eat(T.IDENT).value;
+    this.eat(T.IN);
+    const iter = this.parseExpr();
+    const body = this.parseBlock();
+    return { type: "ForInStmt", var: varName, iter, body, isAwait, loc };
+  }
+
+  parseWhile() {
+    const loc = this.eat(T.WHILE);
+    const cond = this.parseExpr();
+    const body = this.parseBlock();
+    return { type: "WhileStmt", cond, body, loc };
+  }
+
+  parseDoWhile() {
+    const loc = this.eat(T.DO);
+    const body = this.parseBlock();
+    this.skipNewlines();
+    this.eat(T.WHILE);
+    const cond = this.parseExpr();
+    this.skipNewlines();
+    return { type: "DoWhileStmt", body, cond, loc };
+  }
+
+  parseMatch() {
+    const loc = this.eat(T.MATCH);
+    const subject = this.parseExpr();
+    this.eat(T.COLON);
+    if (this.check(T.NEWLINE)) {
+      this.pos = (this.pos + 1);
+    }
+    this.eat(T.INDENT);
+    const arms = [];
+    while ((!this.check(T.DEDENT) && !this.check(T.EOF))) {
+      this.skipNewlines();
+      if ((this.check(T.DEDENT) || this.check(T.EOF))) {
+        break;
+      }
+      this.eat(T.WHEN);
+      const pattern = this.parsePattern();
+      let guard = null;
+      if (this.check(T.IF)) {
+        this.pos = (this.pos + 1);
+        guard = this.parseExpr();
+      }
+      if (this.check(T.ARROW)) {
+        this.pos = (this.pos + 1);
+        const expr = this.parseExpr();
+        this.skipNewlines();
+        arms.push({ pattern, guard, body: [{ type: "ExprStmt", expr }], inline: true });
+      }
+      else if (this.check(T.COLON)) {
+        const isInline = (this.peek(1).type != T.NEWLINE);
+        const body = this.parseBlock();
+        const inlineArm = ((isInline && (body.length == 1)) && (body[0].type == "ExprStmt"));
+        arms.push({ pattern, guard, body, inline: inlineArm });
+      }
+    }
+    this.maybe(T.DEDENT);
+    return { type: "MatchStmt", subject, arms, loc };
+  }
+
+  parsePattern() {
+    if (this.check(T.WILDCARD)) {
+      this.skip();
+      return { type: "WildcardPat" };
+    }
+    if ((this.check(T.IDENT) && (this.peek(1).type == T.LPAREN))) {
+      const vname = this.eat(T.IDENT).value;
+      this.eat(T.LPAREN);
+      const bindings = [];
+      while ((!this.check(T.RPAREN) && !this.check(T.EOF))) {
+        if (this.check(T.WILDCARD)) {
+          bindings.push("_");
+          this.pos = (this.pos + 1);
+        }
+        else {
+          bindings.push(this.eat(T.IDENT).value);
+        }
+        if (!this.maybe(T.COMMA)) {
+          break;
+        }
+      }
+      this.eat(T.RPAREN);
+      return { type: "VariantPat", variant: vname, bindings };
+    }
+    let left = this.parsePrimary();
+    while (this.check(T.DOT)) {
+      this.pos = (this.pos + 1);
+      const prop = this.skip().value;
+      left = { type: "MemberExpr", obj: left, prop };
+    }
+    if (this.check(T.DOTDOT)) {
+      this.pos = (this.pos + 1);
+      const right = this.parsePrimary();
+      return { type: "RangePat", start: left, end: right };
+    }
+    return { type: "LiteralPat", value: left };
+  }
+
+  parseReturn() {
+    const loc = this.eat(T.RETURN);
+    let value = null;
+    if (!this.at(T.NEWLINE, T.EOF, T.DEDENT)) {
+      value = this.parseExpr();
+    }
+    this.skipNewlines();
+    return { type: "ReturnStmt", value, loc };
+  }
+
+  parseTryCatch() {
+    const loc = this.eat(T.TRY);
+    const tryBody = this.parseBlock();
+    let catchParam = null;
+    let catchBody = null;
+    let finallyBody = null;
+    this.skipNewlines();
+    if (this.check(T.CATCH)) {
+      this.pos = (this.pos + 1);
+      if (this.check(T.LPAREN)) {
+        this.pos = (this.pos + 1);
+        catchParam = this.eat(T.IDENT).value;
+        if (this.maybe(T.COLON)) {
+          this.parseTypeAnn();
+        }
+        this.eat(T.RPAREN);
+      }
+      catchBody = this.parseBlock();
+      this.skipNewlines();
+    }
+    if (this.check(T.FINALLY)) {
+      this.pos = (this.pos + 1);
+      finallyBody = this.parseBlock();
+    }
+    return { type: "TryCatchStmt", tryBody, catchParam, catchBody, finallyBody, loc };
+  }
+
+  parseThrow() {
+    const loc = this.eat(T.THROW);
+    const value = this.parseExpr();
+    this.skipNewlines();
+    return { type: "ThrowStmt", value, loc };
+  }
+
+  parseImport() {
+    this.eat(T.IMPORT);
+    if (this.check(T.STAR)) {
+      this.pos = (this.pos + 1);
+      this.eat(T.AS);
+      const namespaceName = this.eat(T.IDENT).value;
+      this.eat(T.FROM);
+      const source = this.eat(T.STRING).value;
+      this.skipNewlines();
+      return { type: "ImportDecl", names: [], defaultName: null, namespaceName, source };
+    }
+    if (this.check(T.IDENT)) {
+      const defaultName = this.eat(T.IDENT).value;
+      this.eat(T.FROM);
+      const source = this.eat(T.STRING).value;
+      this.skipNewlines();
+      return { type: "ImportDecl", names: [], defaultName, source };
+    }
+    const names = [];
+    if (this.maybe(T.LBRACE)) {
+      while ((!this.check(T.RBRACE) && !this.check(T.EOF))) {
+        const name = this.eat(T.IDENT).value;
+        let alias = name;
+        if (this.check(T.AS)) {
+          this.pos = (this.pos + 1);
+          alias = this.eat(T.IDENT).value;
+        }
+        names.push({ name, alias });
+        if (!this.maybe(T.COMMA)) {
+          break;
+        }
+      }
+      this.eat(T.RBRACE);
+    }
+    this.eat(T.FROM);
+    const source = this.eat(T.STRING).value;
+    this.skipNewlines();
+    return { type: "ImportDecl", names, defaultName: null, source };
+  }
+
+  parseExport() {
+    this.eat(T.EXPORT);
+    if (this.check(T.DEFAULT)) {
+      this.pos = (this.pos + 1);
+      if (this.check(T.ASYNC)) {
+        this.pos = (this.pos + 1);
+        const decl = this.parseFnDecl(true);
+        return { type: "ExportDecl", isDefault: true, decl };
+      }
+      if (this.check(T.FN)) {
+        const decl = this.parseFnDecl(false);
+        return { type: "ExportDecl", isDefault: true, decl };
+      }
+      const value = this.parseExpr();
+      this.skipNewlines();
+      return { type: "ExportDecl", isDefault: true, decl: value };
+    }
+    if (this.check(T.ASYNC)) {
+      this.pos = (this.pos + 1);
+      if (!this.check(T.FN)) {
+        this.err("Expected fn after async");
+      }
+      const decl = this.parseFnDecl(true);
+      return { type: "ExportDecl", isDefault: false, decl };
+    }
+    const decl = this.parseOneStmt();
+    return { type: "ExportDecl", isDefault: false, decl };
+  }
+
+  parseFnDecl(isAsync = false) {
+    const loc = this.eat(T.FN);
+    let name = null;
+    if ((((((((this.check(T.IDENT) || this.check(T.NEW)) || this.check(T.FROM)) || this.check(T.AS)) || this.check(T.DEFAULT)) || this.check(T.IS)) || this.check(T.IN)) || this.check(T.TYPE))) {
+      name = this.skip().value;
+    }
+    const params = this.parseParamList();
+    let retType = null;
+    if (this.check(T.ARROW)) {
+      this.pos = (this.pos + 1);
+      if (this.isTypeAnnBeforeColon()) {
+        retType = this.parseTypeAnn();
+        const body = this.parseBlock();
+        return { type: "FnDecl", name, params, retType, body, inline: false, async: isAsync, loc };
+      }
+      const body = this.parseExpr();
+      this.skipNewlines();
+      return { type: "FnDecl", name, params, retType: null, body, inline: true, async: isAsync, loc };
+    }
+    if (this.check(T.COLON)) {
+      if (this.isColonReturnType()) {
+        this.pos = (this.pos + 1);
+        retType = this.parseTypeAnn();
+        if (this.check(T.NEWLINE)) {
+          this.pos = (this.pos + 1);
+        }
+        if (this.check(T.INDENT)) {
+          this.pos = (this.pos + 1);
+          const body = this.parseStmtList();
+          this.maybe(T.DEDENT);
+          return { type: "FnDecl", name, params, retType, body, inline: false, async: isAsync, loc };
+        }
+        const stmt = this.parseOneStmt();
+        return { type: "FnDecl", name, params, retType, body: [stmt], inline: false, async: isAsync, loc };
+      }
+      const body = this.parseBlock();
+      return { type: "FnDecl", name, params, retType: null, body, inline: false, async: isAsync, loc };
+    }
+    this.err("Expected -> or : after function signature");
+  }
+
+  parseAsyncFn() {
+    this.eat(T.ASYNC);
+    if (!this.check(T.FN)) {
+      this.err("Expected fn after async");
+    }
+    return this.parseFnDecl(true);
+  }
+
+  parseParamList() {
+    this.eat(T.LPAREN);
+    const params = [];
+    while ((!this.check(T.RPAREN) && !this.check(T.EOF))) {
+      let rest = false;
+      if (this.check(T.DOTDOTDOT)) {
+        this.pos = (this.pos + 1);
+        rest = true;
+      }
+      const name = this.eat(T.IDENT).value;
+      let optional = false;
+      let typeAnn = null;
+      if ((!rest && this.check(T.QUESTION))) {
+        this.pos = (this.pos + 1);
+        optional = true;
+      }
+      if ((!rest && this.maybe(T.COLON))) {
+        typeAnn = this.parseTypeAnn();
+      }
+      let defaultVal = null;
+      if ((!rest && this.maybe(T.EQ))) {
+        defaultVal = this.parseExpr();
+      }
+      params.push({ name, typeAnn, optional, defaultVal, rest });
+      if (rest) {
+        break;
+      }
+      if (!this.maybe(T.COMMA)) {
+        break;
+      }
+    }
+    this.eat(T.RPAREN);
+    return params;
+  }
+
+  parseAccessModifiers() {
+    const mods = new Set([]);
+    let running = true;
+    while (running) {
+      const t = this.peek().type;
+      if ((((((((t == T.PRIVATE) || (t == T.PUBLIC)) || (t == T.PROTECTED)) || (t == T.READONLY)) || (t == T.STATIC)) || (t == T.ABSTRACT)) || (t == T.OVERRIDE))) {
+        mods.add(this.skip().value);
+      }
+      else {
+        running = false;
+      }
+    }
+    return mods;
+  }
+
+  parseClassDecl() {
+    const loc = this.eat(T.CLASS);
+    const name = this.eat(T.IDENT).value;
+    let superClass = null;
+    const interfaces = [];
+    const typeParams = [];
+    if (this.check(T.LT)) {
+      this.pos = (this.pos + 1);
+      typeParams.push(this.eat(T.IDENT).value);
+      while (this.maybe(T.COMMA)) {
+        typeParams.push(this.eat(T.IDENT).value);
+      }
+      this.eat(T.GT);
+    }
+    if (this.maybe(T.EXTENDS)) {
+      superClass = this.eat(T.IDENT).value;
+    }
+    if (this.maybe(T.IMPLEMENTS)) {
+      interfaces.push(this.eat(T.IDENT).value);
+      while (this.maybe(T.COMMA)) {
+        interfaces.push(this.eat(T.IDENT).value);
+      }
+    }
+    this.eat(T.COLON);
+    if (this.check(T.NEWLINE)) {
+      this.pos = (this.pos + 1);
+      this.eat(T.INDENT);
+    }
+    const fields = [];
+    const methods = [];
+    while ((!this.check(T.DEDENT) && !this.check(T.EOF))) {
+      this.skipNewlines();
+      if ((this.check(T.DEDENT) || this.check(T.EOF))) {
+        break;
+      }
+      const mods = this.parseAccessModifiers();
+      if (this.check(T.FN)) {
+        const m = this.parseFnDecl(false);
+        m.modifiers = mods;
+        methods.push(m);
+      }
+      else if (this.check(T.ASYNC)) {
+        const m = this.parseAsyncFn();
+        m.modifiers = mods;
+        methods.push(m);
+      }
+      else if ((this.check(T.STATIC) && (this.peek(1).type == T.FN))) {
+        this.skip();
+        const m = this.parseFnDecl(false);
+        m.modifiers = mods;
+        m.modifiers.add("static");
+        methods.push(m);
+      }
+      else if (this.check(T.IDENT)) {
+        const fname = this.eat(T.IDENT).value;
+        let optional = false;
+        if (this.check(T.QUESTION)) {
+          this.pos = (this.pos + 1);
+          optional = true;
+        }
+        this.eat(T.COLON);
+        const ftype = this.parseTypeAnn();
+        this.skipNewlines();
+        fields.push({ name: fname, typeAnn: ftype, optional, modifiers: mods });
+      }
+      else {
+        this.skip();
+      }
+    }
+    this.maybe(T.DEDENT);
+    return { type: "ClassDecl", name, typeParams, superClass, interfaces, fields, methods, loc };
+  }
+
+  parseExprStmt() {
+    const expr = this.parseExpr();
+    this.skipNewlines();
+    return { type: "ExprStmt", expr };
+  }
+
+  parseExpr() {
+    return this.parsePipe();
+  }
+
+  parsePipe() {
+    let left = this.parseAssign();
+    let running = true;
+    while (running) {
+      if (this.check(T.PIPE)) {
+        this.pos = (this.pos + 1);
+        const right = this.parseAssign();
+        left = { type: "PipeExpr", left, right };
+      }
+      else if (this.check(T.NEWLINE)) {
+        let i = 1;
+        while ((this.peek(i).type == T.NEWLINE)) {
+          i = (i + 1);
+        }
+        if ((this.peek(i).type == T.PIPE)) {
+          while (this.check(T.NEWLINE)) {
+            this.pos = (this.pos + 1);
+          }
+          this.pos = (this.pos + 1);
+          const right = this.parseAssign();
+          left = { type: "PipeExpr", left, right };
+        }
+        else {
+          running = false;
+        }
+      }
+      else {
+        running = false;
+      }
+    }
+    return left;
+  }
+
+  parseAssign() {
+    const left = this.parseTernary();
+    const t = this.peek().type;
+    let op = "";
+    if ((t == T.EQ)) {
+      op = "=";
+    }
+    else if ((t == T.PLUSEQ)) {
+      op = "+=";
+    }
+    else if ((t == T.MINUSEQ)) {
+      op = "-=";
+    }
+    else if ((t == T.STAREQ)) {
+      op = "*=";
+    }
+    else if ((t == T.SLASHEQ)) {
+      op = "/=";
+    }
+    else if ((t == T.PERCENTEQ)) {
+      op = "%=";
+    }
+    if (op) {
+      this.pos = (this.pos + 1);
+      return { type: "AssignExpr", target: left, op, value: this.parseAssign() };
+    }
+    return left;
+  }
+
+  parseTernary() {
+    const cond = this.parseNullish();
+    if (this.maybe(T.QUESTION)) {
+      const then = this.parseNullish();
+      this.eat(T.COLON);
+      const else_ = this.parseTernary();
+      return { type: "TernaryExpr", cond, then, else_ };
+    }
+    return cond;
+  }
+
+  parseNullish() {
+    let l = this.parseOr();
+    while (this.check(T.NULLISH)) {
+      this.pos = (this.pos + 1);
+      const r = this.parseOr();
+      l = { type: "BinaryExpr", op: "??", left: l, right: r };
+    }
+    return l;
+  }
+
+  parseOr() {
+    let l = this.parseAnd();
+    while ((this.check(T.OR) || this.check(T.OROR))) {
+      this.pos = (this.pos + 1);
+      const r = this.parseAnd();
+      l = { type: "BinaryExpr", op: "||", left: l, right: r };
+    }
+    return l;
+  }
+
+  parseAnd() {
+    let l = this.parseBitOr();
+    while ((this.check(T.AND) || this.check(T.ANDAND))) {
+      this.pos = (this.pos + 1);
+      const r = this.parseBitOr();
+      l = { type: "BinaryExpr", op: "&&", left: l, right: r };
+    }
+    return l;
+  }
+
+  parseBitOr() {
+    let l = this.parseBitXor();
+    while (this.check(T.PIPEB)) {
+      this.pos = (this.pos + 1);
+      const r = this.parseBitXor();
+      l = { type: "BinaryExpr", op: "|", left: l, right: r };
+    }
+    return l;
+  }
+
+  parseBitXor() {
+    let l = this.parseBitAnd();
+    while (this.check(T.CARET)) {
+      this.pos = (this.pos + 1);
+      const r = this.parseBitAnd();
+      l = { type: "BinaryExpr", op: "^", left: l, right: r };
+    }
+    return l;
+  }
+
+  parseBitAnd() {
+    let l = this.parseEq();
+    while (this.check(T.AMPERSAND)) {
+      this.pos = (this.pos + 1);
+      const r = this.parseEq();
+      l = { type: "BinaryExpr", op: "&", left: l, right: r };
+    }
+    return l;
+  }
+
+  parseEq() {
+    let l = this.parseRel();
+    while (this.at(T.EQEQ, T.NEQ, T.EQEQEQ, T.NEQEQ)) {
+      const op = this.skip().value;
+      const r = this.parseRel();
+      l = { type: "BinaryExpr", op, left: l, right: r };
+    }
+    return l;
+  }
+
+  parseRel() {
+    let l = this.parseShift();
+    while ((this.at(T.LT, T.LTE, T.GT, T.GTE) || this.check(T.IN))) {
+      const op = this.skip().value;
+      const r = this.parseShift();
+      l = { type: "BinaryExpr", op, left: l, right: r };
+    }
+    return l;
+  }
+
+  parseShift() {
+    let l = this.parseRange();
+    while (this.at(T.LSHIFT, T.RSHIFT)) {
+      const op = this.skip().value;
+      const r = this.parseRange();
+      l = { type: "BinaryExpr", op, left: l, right: r };
+    }
+    return l;
+  }
+
+  parseRange() {
+    const l = this.parseAdd();
+    if (this.check(T.DOTDOT)) {
+      this.pos = (this.pos + 1);
+      const r = this.parseAdd();
+      return { type: "RangeExpr", start: l, end: r };
+    }
+    return l;
+  }
+
+  parseAdd() {
+    let l = this.parseMul();
+    while (this.at(T.PLUS, T.MINUS)) {
+      const op = this.skip().value;
+      const r = this.parseMul();
+      l = { type: "BinaryExpr", op, left: l, right: r };
+    }
+    return l;
+  }
+
+  parseMul() {
+    let l = this.parsePow();
+    while (this.at(T.STAR, T.SLASH, T.PERCENT)) {
+      const op = this.skip().value;
+      const r = this.parsePow();
+      l = { type: "BinaryExpr", op, left: l, right: r };
+    }
+    return l;
+  }
+
+  parsePow() {
+    const l = this.parseUnary();
+    if (this.check(T.STARSTAR)) {
+      this.pos = (this.pos + 1);
+      return { type: "BinaryExpr", op: "**", left: l, right: this.parsePow() };
+    }
+    return l;
+  }
+
+  parseUnary() {
+    if (this.check(T.MINUS)) {
+      this.pos = (this.pos + 1);
+      return { type: "UnaryExpr", op: "-", operand: this.parseUnary() };
+    }
+    if (this.check(T.NOT)) {
+      this.pos = (this.pos + 1);
+      return { type: "UnaryExpr", op: "!", operand: this.parseUnary() };
+    }
+    if (this.check(T.BANG)) {
+      this.pos = (this.pos + 1);
+      return { type: "UnaryExpr", op: "!", operand: this.parseUnary() };
+    }
+    if (this.check(T.TILDE)) {
+      this.pos = (this.pos + 1);
+      return { type: "UnaryExpr", op: "~", operand: this.parseUnary() };
+    }
+    if (this.check(T.PLUSPLUS)) {
+      this.pos = (this.pos + 1);
+      return { type: "UpdateExpr", op: "++", prefix: true, operand: this.parseUnary() };
+    }
+    if (this.check(T.MINUSMINUS)) {
+      this.pos = (this.pos + 1);
+      return { type: "UpdateExpr", op: "--", prefix: true, operand: this.parseUnary() };
+    }
+    if (this.check(T.AWAIT)) {
+      this.pos = (this.pos + 1);
+      return { type: "AwaitExpr", operand: this.parseUnary() };
+    }
+    if (this.check(T.TYPEOF)) {
+      this.pos = (this.pos + 1);
+      return { type: "TypeofExpr", operand: this.parseUnary() };
+    }
+    return this.parseLambdaOrPostfix();
+  }
+
+  parseLambdaOrPostfix() {
+    const saved = this.pos;
+    if ((this.check(T.IDENT) || this.check(T.WILDCARD))) {
+      const name = (this.skip().value ?? "_");
+      if (this.check(T.ARROW)) {
+        this.pos = (this.pos + 1);
+        const body = this.parseExpr();
+        return { type: "LambdaExpr", params: [{ name }], body };
+      }
+      this.pos = saved;
+    }
+    return this.parsePostfix();
+  }
+
+  parsePostfix() {
+    let expr = this.parsePrimary();
+    let running = true;
+    while (running) {
+      if (this.check(T.PLUSPLUS)) {
+        this.pos = (this.pos + 1);
+        expr = { type: "UpdateExpr", op: "++", prefix: false, operand: expr };
+      }
+      else if (this.check(T.MINUSMINUS)) {
+        this.pos = (this.pos + 1);
+        expr = { type: "UpdateExpr", op: "--", prefix: false, operand: expr };
+      }
+      else if (this.check(T.DOT)) {
+        this.pos = (this.pos + 1);
+        const propTok = this.peek();
+        const prop = this.skip().value;
+        expr = { type: "MemberExpr", obj: expr, prop };
+      }
+      else if (this.check(T.QUESTIONDOT)) {
+        this.pos = (this.pos + 1);
+        if (this.check(T.LPAREN)) {
+          const args = this.parseArgList();
+          expr = { type: "OptCallExpr", callee: expr, args };
+        }
+        else if (this.check(T.LBRACKET)) {
+          this.pos = (this.pos + 1);
+          const idx = this.parseExpr();
+          this.eat(T.RBRACKET);
+          expr = { type: "OptIndexExpr", obj: expr, idx };
+        }
+        else {
+          const prop = this.skip().value;
+          expr = { type: "OptMemberExpr", obj: expr, prop };
+        }
+      }
+      else if (this.check(T.INSTANCEOF)) {
+        this.pos = (this.pos + 1);
+        const right = this.eat(T.IDENT).value;
+        expr = { type: "BinaryExpr", op: "instanceof", left: expr, right: { type: "Identifier", name: right } };
+      }
+      else if (this.check(T.AS)) {
+        this.pos = (this.pos + 1);
+        if (this.check(T.CONST)) {
+          this.pos = (this.pos + 1);
+          expr = { type: "AsConstExpr", expr };
+        }
+        else {
+          const castType = this.parseTypeAnn();
+          expr = { type: "CastExpr", expr, castType };
+        }
+      }
+      else if (this.check(T.SATISFIES)) {
+        this.pos = (this.pos + 1);
+        const satType = this.parseTypeAnn();
+        expr = { type: "SatisfiesExpr", expr, satType };
+      }
+      else if (this.check(T.IS)) {
+        this.pos = (this.pos + 1);
+        const isType = this.parseTypeAnn();
+        expr = { type: "IsExpr", expr, isType };
+      }
+      else if (this.check(T.BANG)) {
+        this.pos = (this.pos + 1);
+        expr = { type: "NonNullExpr", expr };
+      }
+      else if (this.check(T.LBRACKET)) {
+        this.pos = (this.pos + 1);
+        const idx = this.parseExpr();
+        this.eat(T.RBRACKET);
+        expr = { type: "IndexExpr", obj: expr, idx };
+      }
+      else if (this.check(T.LPAREN)) {
+        const args = this.parseArgList();
+        if (this.check(T.ARROW)) {
+          this.pos = (this.pos + 1);
+          const body = this.parseExpr();
+          const lambdaParams = args.map((a) => { name: ((a.type == "Identifier") ? a.name : "_") });
+          return { type: "LambdaExpr", params: lambdaParams, body };
+        }
+        expr = { type: "CallExpr", callee: expr, args };
+      }
+      else {
+        running = false;
+      }
+    }
+    return expr;
+  }
+
+  parseArgList() {
+    this.eat(T.LPAREN);
+    const args = [];
+    while ((!this.check(T.RPAREN) && !this.check(T.EOF))) {
+      if (this.check(T.DOTDOTDOT)) {
+        this.pos = (this.pos + 1);
+        args.push({ type: "SpreadExpr", expr: this.parseExpr() });
+      }
+      else {
+        args.push(this.parseExpr());
+      }
+      if (!this.maybe(T.COMMA)) {
+        break;
+      }
+    }
+    this.eat(T.RPAREN);
+    return args;
+  }
+
+  parsePrimary() {
+    const tok = this.peek();
+    if ((tok.type == T.NUMBER)) {
+      this.pos = (this.pos + 1);
+      return { type: "NumberLit", value: tok.value, loc: tok };
+    }
+    if ((tok.type == T.BOOL)) {
+      this.pos = (this.pos + 1);
+      return { type: "BoolLit", value: tok.value, loc: tok };
+    }
+    if ((tok.type == T.NULL)) {
+      this.pos = (this.pos + 1);
+      return { type: "NullLit", loc: tok };
+    }
+    if ((tok.type == T.SELF)) {
+      this.pos = (this.pos + 1);
+      return { type: "SelfExpr", loc: tok };
+    }
+    if ((tok.type == T.WILDCARD)) {
+      this.pos = (this.pos + 1);
+      return { type: "Identifier", name: "_", loc: tok };
+    }
+    if ((tok.type == T.IDENT)) {
+      this.pos = (this.pos + 1);
+      return { type: "Identifier", name: tok.value, loc: tok };
+    }
+    if ((tok.type == T.STRING)) {
+      this.pos = (this.pos + 1);
+      if ((tok.value && tok.value.template)) {
+        return { type: "TemplateLit", parts: tok.value.parts, loc: tok };
+      }
+      return { type: "StringLit", value: tok.value, loc: tok };
+    }
+    if ((tok.type == T.REGEX)) {
+      this.pos = (this.pos + 1);
+      return { type: "RegexLit", value: tok.value, loc: tok };
+    }
+    if ((tok.type == T.NEW)) {
+      this.pos = (this.pos + 1);
+      const callee = this.eat(T.IDENT).value;
+      const args = this.parseArgList();
+      return { type: "NewExpr", callee, args };
+    }
+    if ((tok.type == T.MATCH)) {
+      return this.parseMatch();
+    }
+    if ((tok.type == T.FN)) {
+      this.pos = (this.pos + 1);
+      const params = this.parseParamList();
+      if (this.check(T.ARROW)) {
+        this.pos = (this.pos + 1);
+        if (this.isTypeAnnBeforeColon()) {
+          const retType = this.parseTypeAnn();
+          const body = this.parseBlock();
+          return { type: "FnDecl", name: null, params, retType, body, inline: false, async: false, loc: tok };
+        }
+        const body = this.parseExpr();
+        return { type: "FnDecl", name: null, params, retType: null, body, inline: true, async: false, loc: tok };
+      }
+      if (this.check(T.COLON)) {
+        const body = this.parseBlock();
+        return { type: "FnDecl", name: null, params, retType: null, body, inline: false, async: false, loc: tok };
+      }
+      this.err("Expected -> or : after anonymous fn");
+    }
+    if ((tok.type == T.LPAREN)) {
+      this.pos = (this.pos + 1);
+      if (this.check(T.RPAREN)) {
+        this.pos = (this.pos + 1);
+        if (this.check(T.ARROW)) {
+          this.pos = (this.pos + 1);
+          const body = this.parseExpr();
+          return { type: "LambdaExpr", params: [], body };
+        }
+        return { type: "NullLit" };
+      }
+      const first = this.parseExpr();
+      if (this.check(T.RPAREN)) {
+        this.pos = (this.pos + 1);
+        if (this.check(T.ARROW)) {
+          this.pos = (this.pos + 1);
+          const body = this.parseExpr();
+          const pname = ((first.type == "Identifier") ? first.name : "_");
+          return { type: "LambdaExpr", params: [{ name: pname }], body };
+        }
+        return first;
+      }
+      const items = [first];
+      while (this.maybe(T.COMMA)) {
+        items.push(this.parseExpr());
+      }
+      this.eat(T.RPAREN);
+      if (this.check(T.ARROW)) {
+        this.pos = (this.pos + 1);
+        const body = this.parseExpr();
+        const lambdaParams = items.map((i) => { name: ((i.type == "Identifier") ? i.name : "_") });
+        return { type: "LambdaExpr", params: lambdaParams, body };
+      }
+      return items[0];
+    }
+    if ((tok.type == T.LBRACKET)) {
+      this.pos = (this.pos + 1);
+      const items = [];
+      while ((!this.check(T.RBRACKET) && !this.check(T.EOF))) {
+        if (this.check(T.DOTDOTDOT)) {
+          this.pos = (this.pos + 1);
+          items.push({ type: "SpreadExpr", expr: this.parseExpr() });
+        }
+        else {
+          items.push(this.parseExpr());
+        }
+        if (!this.maybe(T.COMMA)) {
+          break;
+        }
+      }
+      this.eat(T.RBRACKET);
+      return { type: "ArrayExpr", items };
+    }
+    if ((tok.type == T.LBRACE)) {
+      this.pos = (this.pos + 1);
+      const pairs = [];
+      while ((!this.check(T.RBRACE) && !this.check(T.EOF))) {
+        if (this.check(T.DOTDOTDOT)) {
+          this.pos = (this.pos + 1);
+          pairs.push({ spread: true, value: this.parseExpr() });
+          if (!this.maybe(T.COMMA)) {
+            break;
+          }
+          continue;
+        }
+        const key = (this.check(T.STRING) ? this.eat(T.STRING).value : (this.check(T.IDENT) ? this.skip().value : this.skip().value));
+        if (!this.check(T.COLON)) {
+          pairs.push({ key, value: { type: "Identifier", name: key } });
+        }
+        else {
+          this.eat(T.COLON);
+          const v = this.parseExpr();
+          pairs.push({ key, value: v });
+        }
+        if (!this.maybe(T.COMMA)) {
+          break;
+        }
+      }
+      this.eat(T.RBRACE);
+      return { type: "ObjectExpr", pairs };
+    }
+    this.err(`Unexpected token: ${tok.type} (${JSON.stringify(tok.value)})`);
+  }
+
+}
+
+module.exports.Parser = Parser;
+function makeParser(tokens) {
+  return new Parser(tokens, 0);
+}
+module.exports.makeParser = makeParser;