luaut-parser 3.1.0 → 5.0.0

package/dist/index.js

@@ -70,6 +70,7 @@ var Punctuators = [
   ",",
   ".",
   "?",
+  "=>",
   "->",
   "&",
   "|",
@@ -594,6 +595,13 @@ function applyDirectives(directives, diagnostics, lineOf) {
 var UNUSED_EXPECT_ERROR = "Unused '@luaut-expect-error' directive";
 
 // src/ast/builders.ts
+function bindThis(func, at) {
+  bindThisParam(func.params, at);
+  func.isMethod = true;
+}
+function bindThisParam(params, at) {
+  params.unshift({ type: "FunctionParameter", name: "this", ...spanFrom(at, at) });
+}
 var ParseError = class extends Error {
   constructor(message, line, column) {
     super(`${message} (${line}:${column})`);
@@ -687,10 +695,13 @@ var Parser = class {
   indentation;
   /** Populated in recovery mode. */
   errors = [];
-  /** Recovery found a block without its `end`. */
+  /** Recovery found a block without its `}`. */
   missingEnd = false;
   /** The column of the first token on each line, for `indentation`. */
   lineIndent;
+  /** Inside a class body, where `super` means the base class. Outside
+   *  one it is an ordinary name, so existing code using it still reads. */
+  classDepth = 0;
   constructor(tokens, options = {}) {
     this.tokens = tokens;
     this.recover = options.recover ?? false;
@@ -829,8 +840,12 @@ var Parser = class {
   expressionOr(stop) {
     return this.attempt(() => this.parseExpression(), stop, (start, from) => this.errorExpression(start, from));
   }
+  /** A comma-separated list of values: a `return`'s, a declaration's, an
+   *  assignment's. `...xs` spreads an array into it, as in a call's
+   *  arguments; bare `...` is the vararg pack, as it always was. */
   expressionListOr(stop) {
-    const item = () => this.expressionOr(() => stop() || this.checkPunctuator(","));
+    const until = () => stop() || this.checkPunctuator(",");
+    const item = () => this.checkOperator("...") && this.startsSpread() ? this.parseSpreadArgument(until) : this.expressionOr(until);
     const list = [item()];
     while (this.matchPunctuator(",")) list.push(item());
     return list;
@@ -998,7 +1013,62 @@ var Parser = class {
   // Block / Statement
   // ============================================================
   isBlockEnd() {
-    return this.isAtEnd() || this.checkKeyword("end") || this.checkKeyword("else") || this.checkKeyword("elseif") || this.checkKeyword("until");
+    return this.isAtEnd() || this.checkPunctuator("}") || this.checkKeyword("end") || this.checkKeyword("else") || this.checkKeyword("elseif") || this.checkKeyword("until");
+  }
+  // ============================================================
+  // Bodies
+  // ------------------------------------------------------------
+  // luaut writes a block in braces — `if (ready) { ... }`, `function f() {
+  // ... }`. The `end` spellings Lua uses are still read, so a file written
+  // in them keeps working while it is being moved over.
+  //
+  // A condition is in parentheses because `f {}` is a call: without them
+  // `if ready { ... }` would be a call of `ready` and then a block. With
+  // them the form is decided by looking past the closing parenthesis, which
+  // is why a parenthesized condition in the older spelling still reads.
+  // ============================================================
+  /** `{ ... }` — a block in braces. */
+  parseBraceBlock() {
+    const brace = this.advance();
+    const body = this.parseBlock(brace);
+    if (this.matchPunctuator("}")) return body;
+    if (!this.recover) this.error(`Expected '}' to close the block opened on line ${brace.line.start}`);
+    this.softError(`Expected '}' to close the block opened on line ${brace.line.start}`);
+    this.missingEnd = true;
+    return body;
+  }
+  /** The `{ ... }` a construct's body is written in. Half-written — the
+   *  `{` not typed yet — it is empty and says so, rather than throwing the
+   *  whole construct away: what has been written is what an editor answers
+   *  from. */
+  parseBracedBody(what) {
+    if (this.checkPunctuator("{")) return this.parseBraceBlock();
+    const at = this.current();
+    if (!this.recover) this.error(`Expected '{' to open the body of '${what}'`);
+    this.softError(`Expected '{' to open the body of '${what}'`);
+    return { type: "Block", statements: [], ...spanFrom(at, at) };
+  }
+  /** Does a `{` follow the parenthesized group starting here? That is what
+   *  tells `if (ready) { ... }` from `if (ready) then ... end`. */
+  braceFollowsGroup() {
+    if (!this.checkPunctuator("(")) return false;
+    const closers = { "(": ")", "[": "]", "{": "}" };
+    const stack = [];
+    for (let i = 0; ; i++) {
+      const token = this.peek(i);
+      if (token.type === "EOF") return false;
+      if (token.type === "Punctuator") {
+        const value = String(token.value);
+        if (closers[value]) stack.push(closers[value]);
+        else if (value === stack[stack.length - 1]) {
+          stack.pop();
+          if (!stack.length) {
+            const next = this.peek(i + 1);
+            return next.type === "Punctuator" && next.value === "{";
+          }
+        }
+      }
+    }
   }
   /** `opener` is the token that began the block (`if`, `function`, ...), for
    *  indentation recovery. */
@@ -1110,6 +1180,9 @@ var Parser = class {
     if (t.type === "Identifier" && t.value === "type" && this.peek(1).type === "Identifier") {
       return this.parseTypeAliasStatement();
     }
+    if (t.type === "Identifier" && t.value === "class" && this.peek(1).type === "Identifier") {
+      return this.parseClassDeclaration();
+    }
     if (t.type === "Identifier" && t.value === "declare") {
       const p1 = this.peek(1);
       if (p1.type === "Identifier" && p1.value === "class" && this.peek(2).type === "Identifier") {
@@ -1135,6 +1208,7 @@ var Parser = class {
         name: p.name || void 0,
         id: p.name ? nameIdentifier(p.name, p) : void 0,
         optional: p.optional,
+        rest: p.rest,
         typeAnnotation: p.typeAnnotation ?? { type: "TypeReference", base: "any", typeArguments: [], line: p.line, column: p.column },
         line: p.line,
         column: p.column
@@ -1283,7 +1357,7 @@ var Parser = class {
     this.advance();
     if (this.checkIdentifierValue("default")) {
       this.advance();
-      const declaration = this.parseExpression(0);
+      const declaration = this.checkIdentifierValue("class") && this.peek(1).type === "Identifier" && !this.punctuatorAt(2, ":") && !this.operatorAt(2, "=") && !this.punctuatorAt(2, "(") ? this.parseClassDeclaration() : this.parseExpression(0);
       return { type: "ExportDefaultStatement", declaration, ...spanFrom(start, this.previous()) };
     }
     if (this.checkIdentifierValue("type") && this.peek(1).type === "Identifier") {
@@ -1294,6 +1368,10 @@ var Parser = class {
       const declaration = this.parseVariableDeclaration();
       return { type: "ExportStatement", declaration, ...spanFrom(start, this.previous()) };
     }
+    if (this.checkIdentifierValue("class") && this.peek(1).type === "Identifier") {
+      const declaration = this.parseClassDeclaration();
+      return { type: "ExportStatement", declaration, ...spanFrom(start, this.previous()) };
+    }
     if (this.checkKeyword("function")) {
       const declaration = this.parseFunctionStatement(true);
       if (declaration.type !== "FunctionDeclaration") this.error("An exported function needs a plain name: 'export function name()'");
@@ -1322,7 +1400,7 @@ var Parser = class {
       const source = this.parseModuleSource();
       return { type: "ExportAllStatement", source, ...spanFrom(start, this.previous()) };
     }
-    this.error("Expected 'const', 'let', 'function', 'type', 'default', '{' or '*' after 'export'");
+    this.error("Expected 'const', 'let', 'function', 'class', 'type', 'default', '{' or '*' after 'export'");
   }
   // `const x = ...` / `let x, y = ...`.
   // luaut has no `local` — `const` bindings are immutable, `let` mutable.
@@ -1350,63 +1428,63 @@ var Parser = class {
   parseIfStatement() {
     const start = this.current();
     this.expectKeyword("if");
+    return this.parseBracedIf(start);
+  }
+  parseBracedIf(start) {
     const clauses = [];
-    const untilThen = () => this.checkKeyword("then");
-    const cond = this.expressionOr(untilThen);
-    this.expectKeywordSoft("then");
-    const body = this.parseBlock(start);
-    clauses.push({ type: "IfClause", condition: cond, body, ...spanFrom(cond, this.previous()) });
-    while (this.checkKeyword("elseif")) {
+    const clause = () => {
       const clauseStart = this.current();
-      this.advance();
-      const c = this.expressionOr(untilThen);
-      this.expectKeywordSoft("then");
-      const b = this.parseBlock(start);
-      clauses.push({ type: "IfClause", condition: c, body: b, ...spanFrom(clauseStart, this.previous()) });
-    }
+      this.expectPunctuator("(");
+      const condition = this.expressionOr(() => this.checkPunctuator(")"));
+      this.expectCloser(")");
+      const body = this.parseBracedBody("if");
+      clauses.push({ type: "IfClause", condition, body, ...spanFrom(clauseStart, this.previous()) });
+    };
+    clause();
     let alternate;
-    if (this.matchKeyword("else")) {
-      alternate = this.parseBlock(start);
+    while (this.checkKeyword("elseif") || this.checkKeyword("else")) {
+      const isElse = this.checkKeyword("else");
+      this.advance();
+      if (!isElse) {
+        clause();
+        continue;
+      }
+      alternate = this.parseBracedBody("else");
+      break;
     }
-    this.expectEnd(start);
     return { type: "IfStatement", clauses, alternate, ...spanFrom(start, this.previous()) };
   }
   parseWhileStatement() {
     const start = this.current();
     this.expectKeyword("while");
-    const condition = this.expressionOr(() => this.checkKeyword("do"));
-    this.expectKeywordSoft("do");
-    const body = this.parseBlock(start);
-    this.expectEnd(start);
+    this.expectPunctuator("(");
+    const condition = this.expressionOr(() => this.checkPunctuator(")"));
+    this.expectCloser(")");
+    const body = this.parseBracedBody("while");
     return { type: "WhileStatement", condition, body, ...spanFrom(start, this.previous()) };
   }
   parseRepeatStatement() {
     const start = this.current();
     this.expectKeyword("repeat");
-    const body = this.parseBlock(start);
-    let condition;
-    if (this.checkKeyword("until") || !this.recover) {
-      this.expectKeyword("until");
-      condition = this.expressionOr(() => false);
-    } else {
-      this.softError(`Expected 'until' to close 'repeat' on line ${start.line.start}`);
-      this.missingEnd = true;
-      condition = this.errorExpression(this.current(), this.cursor);
-    }
+    const body = this.parseBracedBody("repeat");
+    this.expectKeyword("until");
+    this.expectPunctuator("(");
+    const condition = this.expressionOr(() => this.checkPunctuator(")"));
+    this.expectCloser(")");
     return { type: "RepeatStatement", body, condition, ...spanFrom(start, this.previous()) };
   }
   parseDoStatement() {
     const start = this.current();
     this.expectKeyword("do");
-    const body = this.parseBlock(start);
-    this.expectEnd(start);
+    const body = this.parseBracedBody("do");
     return { type: "DoStatement", body, ...spanFrom(start, this.previous()) };
   }
   parseForStatement() {
     const start = this.current();
     this.expectKeyword("for");
+    this.expectPunctuator("(");
     const first = this.parseBindingTarget(true);
-    const untilDo = () => this.checkKeyword("do");
+    const untilDo = () => this.checkPunctuator(")");
     if (first.type === "IdentifierPattern" && this.matchOperator("=")) {
       const from = this.expressionOr(() => untilDo() || this.checkPunctuator(","));
       this.expectPunctuator(",");
@@ -1415,9 +1493,7 @@ var Parser = class {
       if (this.matchPunctuator(",")) {
         step = this.expressionOr(untilDo);
       }
-      this.expectKeywordSoft("do");
-      const body2 = this.parseBlock(start);
-      this.expectEnd(start);
+      const body2 = this.parseForBody();
       return {
         type: "NumericForStatement",
         variable: this.identifierPatternToTypedIdentifier(first),
@@ -1434,9 +1510,7 @@ var Parser = class {
     }
     this.expectKeyword("in");
     const iterators = this.expressionListOr(untilDo);
-    this.expectKeywordSoft("do");
-    const body = this.parseBlock(start);
-    this.expectEnd(start);
+    const body = this.parseForBody();
     return {
       type: "GenericForStatement",
       variables,
@@ -1445,6 +1519,10 @@ var Parser = class {
       ...spanFrom(start, this.previous())
     };
   }
+  parseForBody() {
+    this.expectCloser(")");
+    return this.parseBracedBody("for");
+  }
   /** `function name() end` declares `name`; `function a.b() end` and
    *  `function T:m() end` define a member. */
   /** `exported` — the `export` before this `function` has been consumed, so
@@ -1511,6 +1589,183 @@ var Parser = class {
     if (!this.recover) throw error;
     this.record(error);
   }
+  /** `class Name extends Base <members> end`.
+   *
+   *  The body is a block like every other in luaut, closed by `end` — not a
+   *  brace-delimited list. Members are written the way the same thing is
+   *  written outside a class: a field like a field (`x: number`), a method
+   *  like a function (`function m() ... end`). */
+  parseClassDeclaration() {
+    const start = this.current();
+    this.advance();
+    const name = this.parseIdentifier();
+    const typeParams = this.checkOperator("<") ? this.parseGenericTypeParameterList() : [];
+    const { superclass, superArguments } = this.parseExtends();
+    const members = this.parseClassBody(start);
+    return {
+      type: "ClassDeclaration",
+      name,
+      typeParams,
+      superclass,
+      superArguments,
+      members,
+      ...spanFrom(start, this.previous())
+    };
+  }
+  /** `class ... end` as a value. It may be named — the name is for the class
+   *  itself, not for the scope around it — and takes no type parameters,
+   *  since nothing could write the arguments. */
+  parseClassExpression() {
+    const start = this.current();
+    this.advance();
+    const name = this.checkType("Identifier") && !this.checkIdentifierValue("extends") && !this.punctuatorAt(1, ":") && !this.operatorAt(1, "=") && !this.punctuatorAt(1, "(") ? this.parseIdentifier() : void 0;
+    if (this.checkOperator("<")) {
+      this.error("A class written as a value takes no type parameters: nothing could write the arguments");
+    }
+    const { superclass, superArguments } = this.parseExtends();
+    const members = this.parseClassBody(start);
+    return { type: "ClassExpression", name, superclass, superArguments, members, ...spanFrom(start, this.previous()) };
+  }
+  /** `extends Base` / `extends Box<number>`. */
+  parseExtends() {
+    if (!this.checkIdentifierValue("extends")) return {};
+    this.advance();
+    const superclass = this.parseIdentifier();
+    let superArguments;
+    if (this.checkOperator("<")) {
+      const written = this.tryTypeArguments();
+      if (written) superArguments = written;
+    }
+    return { superclass, superArguments };
+  }
+  parseClassBody(start) {
+    void start;
+    if (!this.checkPunctuator("{")) this.error("Expected '{' to open the class body");
+    this.advance();
+    const members = [];
+    this.classDepth++;
+    try {
+      while (!this.checkPunctuator("}") && !this.isAtEnd()) {
+        if (this.matchPunctuator(",") || this.matchPunctuator(";")) continue;
+        const member = this.parseClassMember();
+        if (member) members.push(member);
+      }
+    } finally {
+      this.classDepth--;
+    }
+    this.expectCloser("}");
+    return members;
+  }
+  /** `<A, B>` in a type position that is not a call: the arguments a class
+   *  extends its base with. */
+  tryTypeArguments() {
+    const saved = this.cursor;
+    try {
+      this.expectOperator("<");
+      const args = [this.parseType()];
+      while (this.matchPunctuator(",")) args.push(this.parseType());
+      this.expectOperator(">");
+      return args;
+    } catch (error) {
+      if (error instanceof ParseError || error instanceof ParseRecover) {
+        this.cursor = saved;
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  parseClassMember() {
+    const start = this.current();
+    const isStatic = this.checkIdentifierValue("static") && !this.punctuatorAt(1, ":") && !this.operatorAt(1, "=");
+    if (isStatic) this.advance();
+    if (this.checkKeyword("function")) {
+      this.advance();
+      const memberName = this.parseIdentifier();
+      const signatures = [];
+      let written = memberName;
+      while (true) {
+        const head = this.parseFunctionHead();
+        if (this.isClassOverloadContinuation(memberName.name, isStatic)) {
+          if (!isStatic) bindThisParam(head.params, start);
+          signatures.push({ ...this.headToSignature(head), name: written });
+          if (isStatic) this.advance();
+          this.expectKeyword("function");
+          written = this.parseIdentifier();
+          continue;
+        }
+        const func = this.headToBody(head, start);
+        if (!isStatic) bindThis(func, start);
+        return {
+          type: "ClassMethod",
+          name: memberName,
+          isStatic,
+          func,
+          signatures: signatures.length ? signatures : void 0,
+          ...spanFrom(start, this.previous())
+        };
+      }
+    }
+    if (!isStatic && this.checkIdentifierValue("constructor") && this.punctuatorAt(1, "(")) {
+      this.advance();
+      const head = this.parseFunctionHead();
+      if (head.returnType) this.problem("A constructor has no return type; it always builds the instance");
+      const func = this.headToBody(head, start);
+      bindThis(func, start);
+      return { type: "ClassConstructor", func, ...spanFrom(start, this.previous()) };
+    }
+    if ((this.checkIdentifierValue("get") || this.checkIdentifierValue("set")) && this.peek(1).type === "Identifier" && this.punctuatorAt(2, "(")) {
+      const kind = this.advance().value;
+      const memberName = this.parseIdentifier();
+      const head = this.parseFunctionHead();
+      const func = this.headToBody(head, start);
+      if (!isStatic) bindThis(func, start);
+      const written = func.params.length - (isStatic ? 0 : 1);
+      if (kind === "get" && written > 0) {
+        this.problem("A getter takes no parameters");
+      }
+      if (kind === "set" && written !== 1) {
+        this.problem("A setter takes exactly one parameter: the value being assigned");
+      }
+      return { type: "ClassAccessor", kind, name: memberName, isStatic, func, ...spanFrom(start, this.previous()) };
+    }
+    if (this.checkType("Identifier")) {
+      const memberName = this.parseIdentifier();
+      let typeAnnotation;
+      if (this.matchPunctuator(":")) {
+        typeAnnotation = this.typeOr(() => this.checkOperator("="));
+      }
+      let init;
+      if (this.matchOperator("=")) init = this.expressionOr(() => false);
+      if (!typeAnnotation && !init) {
+        this.error("A class field needs a type ('name: T') or a value ('name = v')");
+      }
+      return { type: "ClassField", name: memberName, isStatic, typeAnnotation, init, ...spanFrom(start, this.previous()) };
+    }
+    if (this.recover) {
+      this.softError("Expected a class member: a field, 'function', 'constructor', 'get' or 'set'");
+      this.advance();
+      return void 0;
+    }
+    this.error("Expected a class member: a field, 'function', 'constructor', 'get' or 'set'");
+  }
+  /** Give a class method its `this`: a real first parameter, the way
+   *  `function T:m()` gets a real `self`. Every later pass — scopes, types,
+   *  arity, lowering — then sees an ordinary parameter and needs to know
+   *  nothing about classes. */
+  /** After a bodyless head inside a class body, does another declaration of
+   *  the same member follow? Then the head was an overload signature. */
+  isClassOverloadContinuation(name, isStatic) {
+    const offset = isStatic ? 1 : 0;
+    if (isStatic && !this.checkIdentifierValue("static")) return false;
+    const keyword = this.peek(offset);
+    if (!(keyword.type === "Keyword" && keyword.value === "function")) return false;
+    const named = this.peek(offset + 1);
+    return named.type === "Identifier" && named.value === name;
+  }
+  operatorAt(ahead, value) {
+    const token = this.peek(ahead);
+    return token.type === "Operator" && token.value === value;
+  }
   parseFunctionName() {
     const start = this.current();
     const base = this.parseIdentifier();
@@ -1604,7 +1859,7 @@ var Parser = class {
         ...spanFrom(start, this.previous())
       };
     }
-    if (first.type === "CallExpression" || first.type === "MethodCallExpression") {
+    if (first.type === "CallExpression" || first.type === "MethodCallExpression" || first.type === "NewExpression") {
       return { type: "CallStatement", expression: first, ...spanFrom(start, this.previous()) };
     }
     this.error("Unexpected expression statement (expected assignment or call)");
@@ -1792,12 +2047,20 @@ var Parser = class {
     if (t.type === "Keyword" && t.value === "if") {
       return this.parseIfElseExpression();
     }
+    if (t.type === "Identifier" && t.value === "class") {
+      return this.parseClassExpression();
+    }
     if (t.type === "Punctuator" && t.value === "{") {
       return this.parseTableExpression();
     }
     if (t.type === "Punctuator" && t.value === "[") {
       return this.parseArrayExpression();
     }
+    if (this.checkType("Identifier") && this.punctuatorAt(1, "=>")) return this.parseArrow();
+    if (this.checkPunctuator("(") || this.checkOperator("<")) {
+      const arrow = this.tryParse(() => this.parseArrow());
+      if (arrow) return arrow;
+    }
     if (t.type === "Identifier" || t.type === "Punctuator" && t.value === "(") {
       return this.parsePrefixExpression();
     }
@@ -1811,7 +2074,7 @@ var Parser = class {
       } else {
         let expression;
         try {
-          expression = shiftSpans(parseExpressionFromSource(p.raw), p.line, p.column);
+          expression = shiftSpans(parseExpressionFromSource(p.raw, this.classDepth > 0), p.line, p.column);
         } catch (e) {
           if (!this.recover || !(e instanceof ParseError || e instanceof LexError)) throw e;
           const at = token;
@@ -1849,7 +2112,12 @@ var Parser = class {
   parsePrefixExpression() {
     const start = this.current();
     let base;
-    if (this.checkType("Identifier")) {
+    if (this.startsNew()) {
+      base = this.parseNewExpression();
+    } else if (this.classDepth > 0 && this.checkIdentifierValue("super") && this.startsSuperUse()) {
+      this.advance();
+      base = { type: "SuperExpression", ...spanFrom(start, start) };
+    } else if (this.checkType("Identifier")) {
       base = this.parseIdentifier();
     } else if (this.matchPunctuator("(")) {
       const inner = this.parseExpression();
@@ -1946,11 +2214,13 @@ var Parser = class {
         }
       }
       if (this.startsCallArguments()) {
+        const onNewLine = this.current().line.start > base.line.end;
         const args = this.parseCallArguments();
         base = {
           type: "CallExpression",
           callee: base,
           arguments: args,
+          argumentsOnNewLine: onNewLine || void 0,
           ...spanFrom(base, this.previous())
         };
         continue;
@@ -1959,6 +2229,52 @@ var Parser = class {
     }
     return base;
   }
+  /** `new` is a soft keyword: it starts a construction only when a name
+   *  follows it, so a function or field called `new` — `Instance.new(x)`,
+   *  and `Vec.new(1)` itself — is untouched. */
+  startsNew() {
+    return this.checkIdentifierValue("new") && this.peek(1).type === "Identifier";
+  }
+  /** `super` on its own means the base class, and only `super(...)` and
+   *  `super.member` say anything; anything else is a name that happens to
+   *  be spelled that way. */
+  startsSuperUse() {
+    return this.punctuatorAt(1, "(") || this.punctuatorAt(1, ".") && this.peek(2).type === "Identifier";
+  }
+  /** `new Name(args)` / `new Module.Name(args)`. The callee is a name, or a
+   *  name reached through a module — never an arbitrary expression, so the
+   *  arguments are unambiguously the constructor's. */
+  parseNewExpression() {
+    const start = this.current();
+    this.advance();
+    let callee = this.parseIdentifier();
+    while (this.checkPunctuator(".") && this.peek(1).type === "Identifier") {
+      this.advance();
+      const property = this.parseIdentifier();
+      callee = { type: "MemberExpression", object: callee, property, ...spanFrom(start, property) };
+    }
+    const typeArguments = this.tryCallTypeArguments();
+    if (!this.checkPunctuator("(")) {
+      this.error("Expected '(' after the class being constructed: 'new Name(...)'");
+    }
+    const args = this.parseCallArguments();
+    return { type: "NewExpression", callee, arguments: args, typeArguments, ...spanFrom(start, this.previous()) };
+  }
+  /** After `...`, is there something to spread? Nothing following it means
+   *  the vararg pack, which is what `f(...)` has always passed on. */
+  startsSpread() {
+    const next = this.peek(1);
+    if (next.type === "Punctuator") {
+      const value = next.value;
+      return value === "(" || value === "{" || value === "[";
+    }
+    return next.type === "Identifier" || next.type === "Literal" || next.type === "InterpolatedString";
+  }
+  parseSpreadArgument(stop) {
+    const dots = this.advance();
+    const argument = this.expressionOr(stop);
+    return { type: "SpreadElement", argument, ...spanFrom(dots, argument) };
+  }
   /** Is the token `ahead` places on the punctuator `value`? */
   punctuatorAt(ahead, value) {
     const token = this.peek(ahead);
@@ -2005,7 +2321,7 @@ var Parser = class {
         while (true) {
           if (this.recover && this.onNewLine() && this.startsTableField() && !this.startsMethodCall(1)) break;
           const before = this.cursor;
-          const argument = this.expressionOr(stop);
+          const argument = this.checkOperator("...") && this.startsSpread() ? this.parseSpreadArgument(stop) : this.expressionOr(stop);
           if (argument.type !== "ErrorExpression" || this.cursor > before || list.length) list.push(argument);
           if (this.matchPunctuator(",") && !this.checkPunctuator(")")) continue;
           if (!this.recover || this.checkPunctuator(")")) break;
@@ -2108,8 +2424,12 @@ var Parser = class {
     while (!this.checkPunctuator("]")) {
       if (this.checkOperator("...")) {
         const dots = this.advance();
-        const argument = this.expressionOr(stop);
-        elements.push({ type: "SpreadElement", argument, ...spanFrom(dots, argument) });
+        if (this.checkPunctuator("]") || this.checkPunctuator(",")) {
+          elements.push({ type: "VarargExpression", ...spanFrom(dots, dots) });
+        } else {
+          const argument = this.expressionOr(stop);
+          elements.push({ type: "SpreadElement", argument, ...spanFrom(dots, argument) });
+        }
       } else {
         elements.push(this.expressionOr(stop));
       }
@@ -2298,8 +2618,26 @@ var Parser = class {
     if (!this.checkPunctuator(")")) {
       while (true) {
         if (this.checkOperator("...")) {
-          this.advance();
+          const dots = this.advance();
           hasVarargs = true;
+          if (this.checkType("Identifier")) {
+            const nameTok = this.expectIdentifier();
+            let typeAnnotation2;
+            if (this.matchPunctuator(":")) {
+              typeAnnotation2 = this.typeOr(() => this.checkPunctuator(")"));
+            }
+            params.push({
+              type: "FunctionParameter",
+              name: nameTok.value,
+              typeAnnotation: typeAnnotation2,
+              rest: true,
+              ...spanFrom(dots, this.previous())
+            });
+            if (this.checkPunctuator(",")) {
+              this.problem("A rest parameter is the last one: nothing can follow '...'");
+            }
+            break;
+          }
           if (this.matchPunctuator(":")) {
             varargTypeAnnotation = this.parseTypeOrTypePackReference();
           }
@@ -2391,10 +2729,64 @@ var Parser = class {
     }
     return void 0;
   }
+  /** Run `parse`, and put the parser back where it was if it fails. Used
+   *  where two forms start alike and only their end tells them apart: `(a,
+   *  b) => a + b` and `(a + b)` both open with a `(`. */
+  tryParse(parse2) {
+    const cursor = this.cursor;
+    const errors = this.errors.length;
+    try {
+      return parse2();
+    } catch (error) {
+      if (!(error instanceof ParseError || error instanceof ParseRecover)) throw error;
+      this.cursor = cursor;
+      this.errors.length = errors;
+      return void 0;
+    }
+  }
+  /** `x => x * 2` — a function, written short. The body is an expression,
+   *  which is returned, or a block in braces, as in TypeScript. */
+  parseArrow() {
+    const start = this.current();
+    const head = this.checkType("Identifier") ? (() => {
+      const name = this.expectIdentifier();
+      return {
+        start,
+        generics: [],
+        params: [{ type: "FunctionParameter", name: name.value, ...spanFrom(name, name) }],
+        hasVarargs: false,
+        varargTypeAnnotation: void 0,
+        returnType: void 0,
+        predicate: void 0
+      };
+    })() : this.parseFunctionHead();
+    this.expectPunctuator("=>");
+    const body = this.checkPunctuator("{") ? this.parseBraceBlock() : this.returnOf(this.parseExpression(0));
+    const func = {
+      type: "FunctionBody",
+      generics: head.generics,
+      params: head.params,
+      hasVarargs: head.hasVarargs,
+      varargTypeAnnotation: head.varargTypeAnnotation,
+      returnType: head.returnType,
+      predicate: head.predicate,
+      body,
+      ...spanFrom(start, this.previous())
+    };
+    return { type: "FunctionExpression", func, ...spanFrom(start, this.previous()) };
+  }
+  /** A one-expression body: the value is what the function returns. */
+  returnOf(expression) {
+    const statement = {
+      type: "ReturnStatement",
+      arguments: [expression],
+      ...spanFrom(expression, expression)
+    };
+    return { type: "Block", statements: [statement], ...spanFrom(expression, expression) };
+  }
   parseFunctionBody(opener) {
     const head = this.parseFunctionHead();
-    const body = this.parseBlock(opener);
-    this.expectEnd(opener);
+    const body = this.parseStatementBody(opener);
     return {
       type: "FunctionBody",
       generics: head.generics,
@@ -2419,9 +2811,13 @@ var Parser = class {
       ...spanFrom(head.start, this.previous())
     };
   }
+  /** A function's statements. */
+  parseStatementBody(opener) {
+    void opener;
+    return this.parseBracedBody("function");
+  }
   headToBody(head, opener) {
-    const body = this.parseBlock(opener);
-    this.expectEnd(opener);
+    const body = this.parseStatementBody(opener);
     return {
       type: "FunctionBody",
       generics: head.generics,
@@ -2645,8 +3041,21 @@ var Parser = class {
     if (!this.checkPunctuator(")")) {
       while (true) {
         if (this.checkOperator("...")) {
-          this.advance();
+          const dots = this.advance();
           hasVarargs = true;
+          if (this.checkType("Identifier") && this.punctuatorAt(1, ":")) {
+            const nameTok2 = this.expectIdentifier();
+            this.advance();
+            params.push({
+              type: "FunctionTypeParameter",
+              name: nameTok2.value,
+              id: tokenIdentifier(nameTok2),
+              typeAnnotation: this.parseType(),
+              rest: true,
+              ...spanFrom(dots, this.previous())
+            });
+            break;
+          }
           varargType = this.parseType();
           break;
         }
@@ -2684,7 +3093,7 @@ var Parser = class {
       }
     }
     this.expectPunctuator(")");
-    if (this.matchPunctuator("->")) {
+    if (this.matchPunctuator("=>") || this.matchPunctuator("->")) {
       const predicate = this.tryParseTypePredicate();
       const returnType = predicate ? { type: "TypeReference", base: "boolean", typeArguments: [], ...spanFrom(start, this.previous()) } : this.parseTypeOrTypePackReference();
       return {
@@ -2827,8 +3236,22 @@ var Parser = class {
           optional: optional2,
           ...spanFrom(propStart, this.previous())
         });
+      } else if (this.checkType("Literal") && this.current().kind === "string" && this.peek(1).type === "Punctuator" && (this.peek(1).value === ":" || this.peek(1).value === "?" && this.peek(2).type === "Punctuator" && this.peek(2).value === ":")) {
+        const keyTok = this.advance();
+        const name = String(keyTok.value);
+        const optional2 = this.matchPunctuator("?");
+        this.expectPunctuator(":");
+        const valueType = this.parseType();
+        properties.push({
+          type: "TableTypeProperty",
+          name,
+          key: tokenIdentifier(keyTok),
+          valueType,
+          optional: optional2,
+          ...spanFrom(propStart, this.previous())
+        });
       } else {
-        this.error("Expected object type property ('name: T' or '[K]: V'); use 'T[]' for arrays and '[T, U]' for tuples");
+        this.error(`Expected object type property ('name: T', '"name": T' or '[K]: V'); use 'T[]' for arrays and '[T, U]' for tuples`);
       }
       if (this.matchPunctuator(",") || this.matchPunctuator(";")) continue;
       break;
@@ -2914,9 +3337,10 @@ function parseTypeFromSource(raw) {
   const parser = new Parser(tokenize(raw));
   return parser.parseType();
 }
-function parseExpressionFromSource(raw) {
+function parseExpressionFromSource(raw, inClass = false) {
   const tokens = tokenize(raw);
   const parser = new Parser(tokens);
+  if (inClass) parser.classDepth = 1;
   const expr = parser.parseExpression();
   return expr;
 }
@@ -3025,6 +3449,11 @@ var Analyzer = class {
   hoistFunctions(block, scope) {
     for (const statement of block.statements) {
       const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
+      if (declaration.type === "ClassDeclaration") {
+        this.declare(scope, declaration.name.name, "local", declaration.name, true, "class");
+        this.hoisted.set(declaration.name, scope === this.moduleScope ? -1 : this.functionDepth);
+        continue;
+      }
       if (declaration.type !== "FunctionDeclaration") continue;
       this.declare(scope, declaration.name.name, "local", declaration.name, true, "function");
       this.hoisted.set(declaration.name, scope === this.moduleScope ? -1 : this.functionDepth);
@@ -3037,7 +3466,7 @@ var Analyzer = class {
    *  hoisted, and this does not apply. */
   checkUseBeforeDefine(identifier, id) {
     const binding = this.bindings.get(id);
-    if (binding.declaredBy !== "function" || this.typeQueryDepth > 0) return;
+    if (binding.declaredBy !== "function" && binding.declaredBy !== "class" || this.typeQueryDepth > 0) return;
     const declaration = binding.declarationNode;
     const depth = declaration && this.hoisted.get(declaration);
     if (depth === void 0 || depth !== this.functionDepth) return;
@@ -3292,6 +3721,11 @@ var Analyzer = class {
         this.visitFunctionBody(stmt.func, scope);
         return;
       }
+      case "ClassDeclaration": {
+        if (!this.hoisted.has(stmt.name)) this.declare(scope, stmt.name.name, "local", stmt.name, true, "class");
+        this.visitClassBody(stmt, scope);
+        return;
+      }
       case "FunctionDeclarationStatement": {
         if (stmt.target.path.length === 0 && !stmt.target.method) {
           this.referenceAsAssignmentTarget(scope, stmt.target.base);
@@ -3411,7 +3845,8 @@ var Analyzer = class {
         this.visitStatement(stmt.declaration, scope);
         return;
       case "ExportDefaultStatement":
-        this.visitExpression(stmt.declaration, scope);
+        if (stmt.declaration.type === "ClassDeclaration") this.visitStatement(stmt.declaration, scope);
+        else this.visitExpression(stmt.declaration, scope);
         return;
       case "ExportNamedStatement":
         if (!stmt.source) {
@@ -3459,6 +3894,33 @@ var Analyzer = class {
   }
   /** `<K extends typeof config>` — a constraint is a type like any other,
    *  and the `typeof` in it reads a value. */
+  /** A class body. Its type parameters live in a scope of their own, and
+   *  every member is written inside it — so a method's annotations see `T`,
+   *  and everything else sees what the class declaration sees, itself
+   *  included. `this` is not declared here: the parser makes it a real first
+   *  parameter, so it arrives with the rest of them. */
+  visitClassBody(node, outer) {
+    const scope = node.typeParams?.length ? childScope(outer) : outer;
+    this.visitGenerics(node.typeParams, scope);
+    if (node.superclass) this.reference(outer, node.superclass);
+    for (const argument of node.superArguments ?? []) this.visitType(argument, scope);
+    for (const member of node.members) {
+      switch (member.type) {
+        case "ClassField":
+          this.visitType(member.typeAnnotation, scope);
+          if (member.init) this.visitExpression(member.init, scope);
+          break;
+        case "ClassMethod":
+          for (const signature of member.signatures ?? []) this.visitSignature(signature, scope);
+          this.visitFunctionBody(member.func, scope, member.func.isMethod);
+          break;
+        case "ClassAccessor":
+        case "ClassConstructor":
+          this.visitFunctionBody(member.func, scope, member.func.isMethod);
+          break;
+      }
+    }
+  }
   visitGenerics(generics, scope) {
     for (const generic of generics ?? []) {
       this.visitType(generic.constraint, scope);
@@ -3541,6 +4003,22 @@ var Analyzer = class {
         this.visitExpression(expr.callee, scope);
         for (const arg of expr.arguments) this.visitExpression(arg, scope);
         return;
+      case "NewExpression":
+        this.visitExpression(expr.callee, scope);
+        for (const argument of expr.arguments) this.visitExpression(argument, scope);
+        for (const argument of expr.typeArguments ?? []) this.visitType(argument, scope);
+        return;
+      case "SuperExpression":
+        return;
+      case "SpreadElement":
+        this.visitExpression(expr.argument, scope);
+        return;
+      case "ClassExpression": {
+        const inner = childScope(scope);
+        if (expr.name) this.declare(inner, expr.name.name, "local", expr.name, true, "class");
+        this.visitClassBody(expr, inner);
+        return;
+      }
       case "MethodCallExpression":
         this.visitExpression(expr.object, scope);
         for (const arg of expr.arguments) this.visitExpression(arg, scope);
@@ -3622,6 +4100,14 @@ function preludeProgram() {
 function isClassType(t) {
   return t.kind === "object" && t.class !== void 0;
 }
+function isClassAssignable(got, want) {
+  if (!got || !got.ancestors.includes(want.name)) return false;
+  const wanted = want.typeArguments?.get(want.name);
+  if (!wanted?.length) return true;
+  const given = got.typeArguments?.get(want.name);
+  if (!given) return true;
+  return wanted.every((w, i) => given[i] !== void 0 && isAssignable(given[i], w));
+}
 function typeParam(name, constraint, isConst) {
   return { kind: "typeParam", name, constraint, isConst };
 }
@@ -3673,11 +4159,21 @@ function substitute(t, subst) {
     case "object": {
       const entries = [];
       for (const [k, v] of t.properties) entries.push([k, { ...v, type: substitute(v.type, subst) }]);
-      return objectType(
+      const out = objectType(
         entries,
         t.indexer && { key: substitute(t.indexer.key, subst), value: substitute(t.indexer.value, subst) },
         t.frozen
       );
+      if (t.name) out.name = t.name;
+      if (t.class) {
+        out.class = {
+          ...t.class,
+          typeArguments: t.class.typeArguments && new Map(
+            [...t.class.typeArguments].map(([name, args]) => [name, args.map((a) => substitute(a, subst))])
+          )
+        };
+      }
+      return out;
     }
     case "function": {
       const inner = t.typeParams ? new Map([...subst].filter(([k]) => !t.typeParams.includes(k))) : subst;
@@ -3744,6 +4240,11 @@ function substitute(t, subst) {
       return t;
   }
 }
+function classArguments(t, name) {
+  if (t.kind === "genericRef") return t.name === name ? t.typeArguments : void 0;
+  if (t.kind === "object") return t.class?.typeArguments?.get(name);
+  return void 0;
+}
 function unify(param, arg, vars, out) {
   if (param.kind === "typeParam" && param.constraint && !vars.has(param.name)) {
     unify(param.constraint, arg, vars, out);
@@ -3771,7 +4272,12 @@ function unify(param, arg, vars, out) {
       }
       return;
     case "object":
-      if (param.class) return;
+      if (param.class) {
+        const wanted = param.class.typeArguments?.get(param.class.name);
+        const given = classArguments(arg, param.class.name);
+        if (wanted && given) wanted.forEach((w, i) => given[i] && unify(w, given[i], vars, out));
+        return;
+      }
       if (arg.kind === "object" && !arg.class) {
         for (const [k, pv] of param.properties) {
           const av = arg.properties.get(k);
@@ -3780,6 +4286,11 @@ function unify(param, arg, vars, out) {
         if (param.indexer && arg.indexer) unify(param.indexer.value, arg.indexer.value, vars, out);
       }
       return;
+    case "genericRef": {
+      const given = classArguments(arg, param.name);
+      if (given) param.typeArguments.forEach((p, i) => given[i] && unify(p, given[i], vars, out));
+      return;
+    }
     case "union":
       for (const m of param.types) unify(m, arg, vars, out);
       return;
@@ -3874,6 +4385,10 @@ var expandAlias;
 function setAliasExpander(fn2) {
   expandAlias = fn2;
 }
+var deferredBound;
+function setDeferredBound(fn2) {
+  deferredBound = fn2;
+}
 var comparing = [];
 function isAssignable(rawA, rawB) {
   let a = isNoValue(rawA) ? nilType : rawA;
@@ -3904,10 +4419,29 @@ function isAssignableInner(a, b) {
   if (b.kind === "unknown") return true;
   if (b.kind === "never") return false;
   if (a.kind === "unknown") return false;
+  if (a.kind === "difference" && b.kind === "difference") {
+    return isAssignable(a.base, b.base) && isAssignable(b.excluded, a.excluded);
+  }
   if (b.kind === "difference") {
     return isAssignable(a, b.base) && !overlaps(a, b.excluded);
   }
-  if (a.kind === "difference") return isAssignable(a.base, b);
+  if (a.kind === "difference") {
+    if (b.kind === "union" && b.types.some((m) => isAssignable(a, m))) return true;
+    return isAssignable(a.base, b);
+  }
+  if (a.kind === "conditional" || a.kind === "indexedAccess") {
+    if ((b.kind === "conditional" || b.kind === "indexedAccess" || b.kind === "union") && equalTypes(a, b)) {
+      return true;
+    }
+    if (b.kind === "union" && b.types.some((m) => equalTypes(a, m))) return true;
+    const bound = deferredBound?.(a);
+    if (bound && bound !== a) return isAssignable(bound, b);
+  }
+  if (a.kind === "typeParam") {
+    if (b.kind === "typeParam" && a.name === b.name) return true;
+    if (b.kind === "union" && b.types.some((m) => m.kind === "typeParam" && m.name === a.name)) return true;
+    return a.constraint ? isAssignable(a.constraint, b) : false;
+  }
   if (a.kind === "union") return a.types.every((t) => isAssignable(t, b));
   if (b.kind === "union") return b.types.some((t) => isAssignable(a, t));
   if (b.kind === "intersection") return b.types.every((t) => isAssignable(a, t));
@@ -3941,7 +4475,7 @@ function isAssignableInner(a, b) {
   }
   if (a.kind === "object") {
     if (b.kind !== "object") return false;
-    if (b.class) return a.class !== void 0 && a.class.ancestors.includes(b.class.name);
+    if (b.class) return isClassAssignable(a.class, b.class);
     if (a.class && (b.indexer || b.properties.size === 0)) return false;
     for (const [name, bp] of b.properties) {
       const ap = a.properties.get(name);
@@ -3950,7 +4484,7 @@ function isAssignableInner(a, b) {
         if (a.indexer && isAssignable(a.indexer.value, bp.type)) continue;
         return false;
       }
-      if (!isAssignable(ap.type, bp.type)) return false;
+      if (!isAssignable(ap.type, bp.optional ? optional(bp.type) : bp.type)) return false;
     }
     if (b.indexer) {
       for (const [name, ap] of a.properties) {
@@ -3971,10 +4505,6 @@ function isAssignableInner(a, b) {
     }
     return isAssignable(a.returns, b.returns);
   }
-  if (a.kind === "typeParam") {
-    if (b.kind === "typeParam" && a.name === b.name) return true;
-    return a.constraint ? isAssignable(a.constraint, b) : false;
-  }
   if (b.kind === "typeParam") return false;
   if (a.kind === "genericRef" || b.kind === "genericRef") {
     return a.kind === "genericRef" && b.kind === "genericRef" && a.name === b.name && a.typeArguments.length === b.typeArguments.length && a.typeArguments.every((x, i) => equalTypes(x, b.typeArguments[i]));
@@ -4094,7 +4624,9 @@ function containsFreeTypeParam(t, seen, bound) {
     case "intersection":
       return t.types.some((m) => containsTypeParam(m, seen, bound));
     case "object":
-      if (t.class) return false;
+      if (t.class) {
+        return [...t.class.typeArguments?.values() ?? []].some((args) => args.some((a) => containsTypeParam(a, seen, bound)));
+      }
       return [...t.properties.values()].some((v) => containsTypeParam(v.type, seen, bound)) || !!t.indexer && (containsTypeParam(t.indexer.key, seen, bound) || containsTypeParam(t.indexer.value, seen, bound));
     case "function": {
       const inner = t.typeParams?.length ? /* @__PURE__ */ new Set([...bound, ...t.typeParams]) : bound;
@@ -4264,7 +4796,10 @@ function formatTypeUncached(t) {
       return t.isPack ? `(${inner})` : `[${inner}]`;
     }
     case "object": {
-      if (t.name) return t.name;
+      if (t.name) {
+        const args = t.class?.typeArguments?.get(t.class.name);
+        return args?.length ? `${t.name}<${args.map(formatType).join(", ")}>` : t.name;
+      }
       const props = [...t.properties.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${v.readonly ? "readonly " : ""}${formatKey(k)}${v.optional ? "?" : ""}: ${formatType(v.type)}`);
       if (t.indexer) props.push(`[${formatType(t.indexer.key)}]: ${formatType(t.indexer.value)}`);
       return props.length ? `{ ${props.join(", ")} }` : "{}";
@@ -4283,7 +4818,7 @@ function formatTypeUncached(t) {
       }).join(", ")}>` : "";
       const ps = t.params.map((p) => `${p.name ? p.name + ": " : ""}${formatType(p.type)}`);
       if (t.varargs) ps.push(`...${formatType(t.varargs)}`);
-      return `${gen}(${ps.join(", ")}) -> ${formatPredicate(t) ?? formatType(t.returns)}`;
+      return `${gen}(${ps.join(", ")}) => ${formatPredicate(t) ?? formatType(t.returns)}`;
     }
     case "typeParam":
       return t.name;
@@ -4327,7 +4862,7 @@ function formatPredicate(t) {
 }
 function formatAtom(t) {
   if (t.kind === "intersection" && t.name) return t.name;
-  if (t.kind === "union" || t.kind === "intersection" || t.kind === "function" || t.kind === "difference") {
+  if (t.kind === "union" || t.kind === "intersection" || t.kind === "function" || t.kind === "difference" || t.kind === "conditional") {
     return `(${formatType(t)})`;
   }
   return formatType(t);
@@ -4431,13 +4966,33 @@ function moduleExports(program, scopes, types, resolveModule) {
     if (stmt.type === "ExportStatement") {
       const declaration = stmt.declaration;
       if (declaration.type === "FunctionDeclaration") exportName(declaration.name, declaration.name.name);
-      else for (const target of declaration.names) exportPattern(target);
+      else if (declaration.type === "ClassDeclaration") {
+        exportName(declaration.name, declaration.name.name);
+        const instance = types.aliases.get(declaration.name.name);
+        if (instance) {
+          exportedTypes.set(declaration.name.name, {
+            type: instance,
+            params: declaration.typeParams.map((g) => g.name)
+          });
+        }
+      } else for (const target of declaration.names) exportPattern(target);
     } else if (stmt.type === "ExportTypeAliasStatement") {
       const name = stmt.alias.name.name;
       const type = types.aliases.get(name);
       if (type) exportedTypes.set(name, { type, params: stmt.alias.generics.map((g) => g.name) });
     } else if (stmt.type === "ExportDefaultStatement") {
-      defaultType = types.typeOf.get(stmt.declaration) ?? anyType;
+      if (stmt.declaration.type === "ClassDeclaration") {
+        const id = byDeclaration.get(stmt.declaration.name);
+        defaultType = (id !== void 0 ? types.bindingType.get(id) : void 0) ?? anyType;
+        const instance = types.aliases.get(stmt.declaration.name.name);
+        if (instance) {
+          const exported = { type: instance, params: stmt.declaration.typeParams.map((g) => g.name) };
+          exportedTypes.set(stmt.declaration.name.name, exported);
+          exportedTypes.set("default", exported);
+        }
+      } else {
+        defaultType = types.typeOf.get(stmt.declaration) ?? anyType;
+      }
     } else if (stmt.type === "ExportNamedStatement") {
       if (stmt.source) {
         const from = resolveModule?.(stmt.source.value);
@@ -4565,6 +5120,51 @@ function keepsLiterals(paramType) {
   const members = paramType.constraint.kind === "union" ? paramType.constraint.types : [paramType.constraint];
   return members.some((m) => m.kind === "literal");
 }
+var CLASS_LINKS = /* @__PURE__ */ new Set(["new", "ClassObject", "ParentClass"]);
+var CLASS_RESERVED = /* @__PURE__ */ new Set([
+  "new",
+  "ClassObject",
+  "ParentClass",
+  "__init",
+  "__index",
+  "__newindex",
+  "__getters",
+  "__setters",
+  "__dynamic"
+]);
+function callsSuper(block) {
+  let found = false;
+  walkNodes(block, (node) => {
+    const record = node;
+    if (record.type === "CallExpression" && record.callee?.type === "SuperExpression") found = true;
+  });
+  return found;
+}
+function assignedFields(block) {
+  const names = /* @__PURE__ */ new Set();
+  walkNodes(block, (node) => {
+    const record = node;
+    const targets = record.type === "AssignmentStatement" ? record.targets : record.type === "CompoundAssignmentStatement" ? [record.target] : void 0;
+    for (const target of targets ?? []) {
+      const member = target;
+      if (member.type === "MemberExpression" && member.object?.type === "Identifier" && member.object.name === "this" && member.property?.name) {
+        names.add(member.property.name);
+      }
+    }
+  });
+  return names;
+}
+function walkNodes(root, visit) {
+  if (!root || typeof root !== "object") return;
+  if (Array.isArray(root)) {
+    for (const item of root) walkNodes(item, visit);
+    return;
+  }
+  visit(root);
+  for (const [key, value] of Object.entries(root)) {
+    if (key !== "line" && key !== "column" && value && typeof value === "object") walkNodes(value, visit);
+  }
+}
 var AliasMap = class extends Map {
   pending = /* @__PURE__ */ new Map();
   defer(name, resolve5) {
@@ -4688,6 +5288,8 @@ var TypeAnalyzer = class {
   aliasDefs = /* @__PURE__ */ new Map();
   /** See `resolveClass`. */
   classTypes = /* @__PURE__ */ new WeakMap();
+  /** See `instanceType` — one instance type per `class ... end`. */
+  instanceTypes = /* @__PURE__ */ new WeakMap();
   classMembers = /* @__PURE__ */ new WeakMap();
   /** Generic parameters currently in lexical scope (alias body / generic fn),
    *  with their `extends` constraints resolved. */
@@ -4726,9 +5328,10 @@ var TypeAnalyzer = class {
   /** Recursion guard for `preVisitBody`. */
   preVisitDepth = 0;
   run() {
-    this.registerAliasDefs(preludeProgram().body);
-    for (const lib of this.options.libs ?? []) this.registerAliasDefs(lib.body);
+    this.registerAliasDefs(preludeProgram().body, true);
+    for (const lib of this.options.libs ?? []) this.registerAliasDefs(lib.body, true);
     this.registerAliasDefs(this.program.body);
+    this.registerNestedClasses();
     for (const lib of this.options.libs ?? []) this.harvestDeclares(lib.body);
     this.registerImportedTypes();
     this.resolveAllAliases();
@@ -4740,6 +5343,7 @@ var TypeAnalyzer = class {
       this.bindingType.set(id, t);
     }
     setAliasExpander((t) => this.expand(t));
+    setDeferredBound((t) => this.deferredBound(t));
     try {
       const env = /* @__PURE__ */ new Map();
       this.visitBlock(this.program.body, env);
@@ -4747,6 +5351,7 @@ var TypeAnalyzer = class {
       if (this.options.reportUnknownTypes) this.reportUnknownTypes();
     } finally {
       setAliasExpander(void 0);
+      setDeferredBound(void 0);
     }
     return {
       typeOf: this.typeOf,
@@ -4796,6 +5401,11 @@ var TypeAnalyzer = class {
           this.aliases.set(qualified, exported.type);
         }
       }
+      const asDefault = stmt.defaultImport && exports.types.get("default");
+      if (stmt.defaultImport && asDefault) {
+        this.importedTypes.set(stmt.defaultImport.name, asDefault);
+        this.aliases.set(stmt.defaultImport.name, asDefault.type);
+      }
       for (const s of stmt.specifiers) {
         const exported = exports.types.get(s.imported.name);
         if (exported) {
@@ -4805,17 +5415,65 @@ var TypeAnalyzer = class {
       }
     }
   }
-  registerAliasDefs(block) {
+  /** `layering` is on for the prelude and for definitions files: a second
+   *  library that declares an alias already declared *adds* to it, the way a
+   *  second `declare` of a table's name does, so `@luaut/roblox` can give
+   *  `StringMethods` Luau's `split` without restating Lua's. The file being
+   *  analysed is not a layer: its own alias replaces what the libraries
+   *  gave, which is how a project opts out of a set. */
+  registerAliasDefs(block, layering = false) {
     for (const stmt of block.statements) {
       const alias = stmt.type === "TypeAliasStatement" ? stmt : stmt.type === "ExportTypeAliasStatement" ? stmt.alias : void 0;
-      if (alias) this.aliasDefs.set(alias.name.name, { params: alias.generics, node: alias.definition });
+      if (alias) {
+        const previous = layering ? this.aliasDefs.get(alias.name.name) : void 0;
+        const node = previous && !previous.class ? {
+          type: "IntersectionTypeNode",
+          types: [previous.node, alias.definition],
+          line: alias.definition.line,
+          column: alias.definition.column
+        } : alias.definition;
+        this.aliasDefs.set(alias.name.name, {
+          params: previous && !previous.class && previous.params.length ? previous.params : alias.generics,
+          node
+        });
+      }
       if (stmt.type === "DeclareClassStatement") {
         this.aliasDefs.set(stmt.name.name, { params: [], node: stmt.body, class: stmt });
       }
+      const declaration = stmt.type === "ExportStatement" || stmt.type === "ExportDefaultStatement" ? stmt.declaration : stmt;
+      if (declaration.type === "ClassDeclaration") this.registerClass(declaration);
     }
   }
+  /** A class written inside a function or a block names a type too — its
+   *  own instances', which its methods' `this` is annotated with. Type names
+   *  are one namespace here, so it is registered with the rest; only a
+   *  second class of the same name would notice. */
+  registerNestedClasses() {
+    walkNodes(this.program.body, (node) => {
+      const record = node;
+      if (record.type !== "ClassDeclaration") return;
+      const declaration = node;
+      if (this.aliasDefs.has(declaration.name.name)) return;
+      this.registerClass(declaration);
+    });
+  }
+  /** A class's name as a type. `node` is a placeholder: `resolveDef` and
+   *  `instantiateAlias` both go to the declaration itself. */
+  registerClass(declaration) {
+    this.aliasDefs.set(declaration.name.name, {
+      params: declaration.typeParams,
+      node: {
+        type: "TableTypeNode",
+        properties: [],
+        line: declaration.line,
+        column: declaration.column
+      },
+      runtimeClass: declaration
+    });
+  }
   /** A non-generic definition's type. */
   resolveDef(def) {
+    if (def.runtimeClass) return this.instanceType(def.runtimeClass);
     return def.class ? this.classType(def.class) : this.resolveType(def.node);
   }
   /** One type per class declaration, so every mention of a class is the same
@@ -4873,6 +5531,381 @@ var TypeAnalyzer = class {
     if (this.program.body.statements.includes(stmt)) ownMembers();
     return type;
   }
+  // ============================================================
+  // `class ... end` — the runtime kind
+  // ------------------------------------------------------------
+  // A declaration says two things at once. Its *name as a type* is
+  // the type of its instances, nominal the way `declare class` is:
+  // only the class and the classes extending it produce one. Its
+  // *name as a value* is the class table — the statics, the class
+  // it extends (`ParentClass`), and the `new` that builds an
+  // instance, which is an ordinary function and can be called as
+  // one. An instance reaches its own class back through
+  // `ClassObject`.
+  //
+  // Members are resolved into one shape, filled in two passes: the
+  // fields first, then the functions. That order is what lets a
+  // method body read `this.x` while the class it belongs to is
+  // still being worked out.
+  // ============================================================
+  classShapes = /* @__PURE__ */ new WeakMap();
+  classValues = /* @__PURE__ */ new WeakMap();
+  /** Identity for a class written as a value, which has no name to be known
+   *  by: two of them are different types however alike they look. */
+  classIdentities = /* @__PURE__ */ new WeakMap();
+  classIdentityCount = 0;
+  /** The class whose members are being read, so `super` knows its base. */
+  currentClass;
+  withClass(stmt, fn2) {
+    const previous = this.currentClass;
+    this.currentClass = stmt;
+    try {
+      return fn2();
+    } finally {
+      this.currentClass = previous;
+    }
+  }
+  /** What the class is known by. A declaration is known by its name, the way
+   *  a `declare class` is — that is what makes it the same class across
+   *  modules. A class written as a value is known by where it is written. */
+  classIdentity(stmt) {
+    if (stmt.type === "ClassDeclaration") return stmt.name.name;
+    let identity = this.classIdentities.get(stmt);
+    if (!identity) {
+      identity = `${stmt.name?.name ?? "class"}@${++this.classIdentityCount}`;
+      this.classIdentities.set(stmt, identity);
+    }
+    return identity;
+  }
+  /** What it is *shown* as. A class written as a value has no name of its
+   *  own, so it borrows the one it is being bound to — `const Counter =
+   *  class ... end` reads as `Counter` everywhere. */
+  className(stmt) {
+    return stmt.name?.name ?? this.classDisplayNames.get(stmt) ?? "(class)";
+  }
+  classDisplayNames = /* @__PURE__ */ new WeakMap();
+  /** `const Name = class ... end` — the name the class will be known by. */
+  nameClassExpressions(stmt) {
+    stmt.names.forEach((target, i) => {
+      const value = stmt.init[i];
+      if (target.type === "IdentifierPattern" && value?.type === "ClassExpression" && !value.name) {
+        this.classDisplayNames.set(value, target.name);
+      }
+    });
+  }
+  classTypeParams(stmt) {
+    return stmt.type === "ClassDeclaration" ? stmt.typeParams : [];
+  }
+  /** The class a declaration extends, when it is one written in this file.
+   *  An imported class is reached through its type and its value instead. */
+  superDecl(stmt) {
+    if (!stmt.superclass) return void 0;
+    const base = this.aliasDefs.get(stmt.superclass.name)?.runtimeClass;
+    return base && base !== stmt && !this.extendsThrough(base, stmt) ? base : void 0;
+  }
+  /** Does `from` reach `target` by `extends`? Guards against a cycle turning
+   *  resolution into a loop. */
+  extendsThrough(from, target) {
+    const seen = /* @__PURE__ */ new Set();
+    for (let cls = from; cls && !seen.has(cls); ) {
+      if (cls === target) return true;
+      seen.add(cls);
+      cls = cls.superclass ? this.aliasDefs.get(cls.superclass.name)?.runtimeClass : void 0;
+    }
+    return false;
+  }
+  /** The instance type of what `stmt` extends, with the arguments it was
+   *  extended with filled in — a class in this file, or any class type a
+   *  name in scope stands for (an imported one). */
+  baseInstance(stmt) {
+    if (!stmt.superclass) return void 0;
+    const written = (stmt.superArguments ?? []).map((argument) => this.resolveType(argument));
+    if (this.aliasDefs.get(stmt.superclass.name)?.runtimeClass) {
+      const local = this.superDecl(stmt);
+      if (!local) return void 0;
+      const base = this.instanceType(local);
+      const params = this.classTypeParams(local);
+      if (!params.length) return base;
+      const applied = substitute(base, this.bindTypeArguments(params, written));
+      return applied.kind === "object" ? applied : void 0;
+    }
+    const imported = this.importedTypes.get(stmt.superclass.name);
+    const named = imported ? this.importedType(imported, stmt.superArguments ?? []) : this.aliases.get(stmt.superclass.name);
+    return named && isClassType(named) ? named : void 0;
+  }
+  /** One instance type per declaration, so every mention of the class is the
+   *  same object — the `this` of its own methods included. Members are read
+   *  lazily for the reason `declare class` reads them lazily: a class can
+   *  name itself, and two classes can name each other. */
+  instanceType(stmt) {
+    const cached = this.instanceTypes.get(stmt);
+    if (cached) return cached;
+    const name = this.className(stmt);
+    const identity = this.classIdentity(stmt);
+    const params = this.classTypeParams(stmt);
+    const type = { kind: "object", name };
+    this.instanceTypes.set(stmt, type);
+    const own = params.map((p) => typeParam(p.name, p.constraint ? this.resolveType(p.constraint) : void 0));
+    const info = () => {
+      const base = this.baseInstance(stmt)?.class;
+      const typeArguments = new Map(base?.typeArguments ?? []);
+      if (own.length) typeArguments.set(identity, own);
+      return {
+        name: identity,
+        superclass: base?.name,
+        ancestors: [identity, ...base?.ancestors ?? []],
+        typeArguments: typeArguments.size ? typeArguments : void 0
+      };
+    };
+    Object.defineProperties(type, {
+      properties: {
+        enumerable: true,
+        get: () => {
+          const shape = this.shapeOf(stmt);
+          const base = this.baseInstance(stmt)?.properties;
+          const members = base?.size ? new Map([...base, ...shape.instance]) : new Map(shape.instance);
+          members.set("ClassObject", { type: this.classValueType(stmt), optional: false, readonly: true });
+          return members;
+        }
+      },
+      class: { enumerable: true, get: info }
+    });
+    return type;
+  }
+  /** `Box<T>` as its own methods see it — a reference, not the object, so
+   *  substituting the arguments in does not have to walk the class. */
+  selfTypeOf(stmt) {
+    const params = this.classTypeParams(stmt);
+    if (!params.length || stmt.type !== "ClassDeclaration") return this.instanceType(stmt);
+    return {
+      kind: "genericRef",
+      name: stmt.name.name,
+      typeArguments: params.map((p) => typeParam(p.name, p.constraint ? this.resolveType(p.constraint) : void 0))
+    };
+  }
+  /** The class table: the statics, what it inherits from the class it
+   *  extends, `ParentClass`, `ClassObject`, and `new`. */
+  classValueType(stmt) {
+    const cached = this.classValues.get(stmt);
+    if (cached) return cached;
+    const type = objectType([]);
+    this.classValues.set(stmt, type);
+    type.name = `typeof ${this.className(stmt)}`;
+    const shape = this.shapeOf(stmt);
+    const local = this.superDecl(stmt);
+    const parent = local ? this.classValueType(local) : stmt.superclass ? this.classStaticsByNameType(stmt.superclass.name) : void 0;
+    if (parent?.kind === "object") {
+      for (const [key, property] of parent.properties) {
+        if (!CLASS_LINKS.has(key)) type.properties.set(key, property);
+      }
+    }
+    for (const [key, property] of shape.statics) type.properties.set(key, property);
+    const constructor = this.constructorType(stmt);
+    const params = this.classTypeParams(stmt);
+    type.properties.set("new", {
+      type: fn(
+        constructor?.params.filter((p) => p.name !== "this") ?? [],
+        this.selfTypeOf(stmt),
+        constructor?.varargs,
+        params.map((p) => p.name)
+      ),
+      optional: false,
+      readonly: true
+    });
+    type.properties.set("ParentClass", { type: parent ?? nilType, optional: false, readonly: true });
+    return type;
+  }
+  /** The value side of a class named by a binding rather than by a
+   *  declaration in this file — an imported one. */
+  classStaticsByNameType(name) {
+    const id = this.classBindingByName(name);
+    const declared = id !== void 0 ? this.bindingType.get(id) : void 0;
+    return declared?.kind === "object" ? declared : void 0;
+  }
+  /** The binding a class name stands for, wherever it was declared. */
+  classBindingByName(name) {
+    for (const [id, binding] of this.scopes.bindings) {
+      if (binding.name === name && binding.declaredBy === "class") return id;
+    }
+    return this.scopes.globalsByName.get(name);
+  }
+  /** What `super(...)` takes: the constructor of the class `stmt` extends,
+   *  its own skipped. */
+  baseConstructorType(stmt) {
+    return this.constructorType(stmt, /* @__PURE__ */ new Set([stmt]));
+  }
+  /** A class's constructor signature — its own, or the one it inherits. */
+  constructorType(stmt, seen = /* @__PURE__ */ new Set()) {
+    if (seen.has(stmt)) return void 0;
+    seen.add(stmt);
+    const own = this.shapeOf(stmt).ctor;
+    if (own) return own;
+    const local = this.superDecl(stmt);
+    if (local) return this.constructorType(local, seen);
+    const parent = stmt.superclass ? this.classStaticsByNameType(stmt.superclass.name) : void 0;
+    const inherited = parent && this.overloadsOf(this.propertyType(parent, "new"))[0];
+    return inherited;
+  }
+  /** `super` as a value: the base class's instance members with the `this`
+   *  slot already filled, because `super.m(a)` passes this instance. */
+  superType(stmt) {
+    const base = this.baseInstance(stmt);
+    if (!base) return anyType;
+    const entries = [];
+    for (const [name, property] of base.properties) {
+      const bound = this.overloadsOf(property.type);
+      entries.push([name, bound.length ? {
+        ...property,
+        type: intersection(bound.map((f) => this.takesSelf(f) ? fn(f.params.slice(1), f.returns, f.varargs, f.typeParams) : f))
+      } : property]);
+    }
+    return objectType(entries);
+  }
+  shapeOf(stmt) {
+    const cached = this.classShapes.get(stmt);
+    if (cached) return cached;
+    const shape = { instance: /* @__PURE__ */ new Map(), statics: /* @__PURE__ */ new Map(), filling: true };
+    this.classShapes.set(stmt, shape);
+    const wasEmitting = this.emitDiagnostics;
+    this.emitDiagnostics = false;
+    try {
+      this.withClass(stmt, () => this.withTypeParams(this.classTypeParams(stmt), () => {
+        this.withSelfType(this.selfTypeOf(stmt), () => this.fillShape(stmt, shape));
+      }));
+    } finally {
+      this.emitDiagnostics = wasEmitting;
+      shape.filling = false;
+    }
+    return shape;
+  }
+  fillShape(stmt, shape) {
+    const put = (isStatic, name, property) => {
+      (isStatic ? shape.statics : shape.instance).set(name, property);
+    };
+    for (const member of stmt.members) {
+      if (member.type !== "ClassField") continue;
+      const type = member.typeAnnotation ? this.resolveType(member.typeAnnotation) : member.init ? widen(this.infer(member.init, /* @__PURE__ */ new Map())) : anyType;
+      put(member.isStatic, member.name.name, { type, optional: false });
+    }
+    for (const member of stmt.members) {
+      switch (member.type) {
+        case "ClassField":
+          break;
+        case "ClassMethod": {
+          this.paramsFromSignatures(member.func, member.signatures);
+          const type = member.signatures?.length ? intersection(member.signatures.map((sig) => this.signatureToFnType(sig))) : this.inferFunctionBody(member.func, /* @__PURE__ */ new Map());
+          put(member.isStatic, member.name.name, { type, optional: false });
+          break;
+        }
+        case "ClassAccessor": {
+          const signature = this.inferFunctionBody(member.func, /* @__PURE__ */ new Map());
+          if (signature.kind !== "function") break;
+          const target = member.isStatic ? shape.statics : shape.instance;
+          const existing = target.get(member.name.name);
+          if (member.kind === "get") {
+            put(member.isStatic, member.name.name, {
+              type: signature.returns,
+              optional: false,
+              readonly: existing === void 0 || existing.readonly !== false
+            });
+          } else {
+            put(member.isStatic, member.name.name, {
+              type: existing?.type ?? signature.params[signature.params.length - 1]?.type ?? anyType,
+              optional: false,
+              readonly: false
+            });
+          }
+          break;
+        }
+        case "ClassConstructor": {
+          const signature = this.inferFunctionBody(member.func, /* @__PURE__ */ new Map());
+          if (signature.kind === "function") shape.ctor = signature;
+          break;
+        }
+      }
+    }
+  }
+  /** Bind the class's value, and check what its members say. Shared by the
+   *  declaration and the expression forms. */
+  visitClass(stmt, env) {
+    this.checkClassDeclaration(stmt);
+    const value = this.classValueType(stmt);
+    this.withClass(stmt, () => this.withTypeParams(this.classTypeParams(stmt), () => {
+      this.withSelfType(this.selfTypeOf(stmt), () => {
+        for (const member of stmt.members) {
+          if (member.type === "ClassField") {
+            if (!member.init) continue;
+            const declared = member.typeAnnotation ? this.resolveType(member.typeAnnotation) : void 0;
+            if (declared) this.applyContext(member.init, declared);
+            const actual = this.infer(member.init, env);
+            if (declared && this.emitDiagnostics && !isAssignable(actual, declared)) {
+              this.diagnostics.push({
+                node: member.init,
+                message: `Type '${formatType(actual)}' is not assignable to type '${formatType(declared)}'`
+              });
+            }
+            continue;
+          }
+          this.checkParamOrder(member.func.params, member);
+          for (const signature of member.signatures ?? []) {
+            this.checkParamOrder(signature.params, member);
+          }
+          this.visitFunctionBody(member.func, env);
+        }
+      });
+    }));
+    return value;
+  }
+  /** What a class gets wrong, reported where it is written. */
+  checkClassDeclaration(stmt) {
+    if (!this.emitDiagnostics) return;
+    const report = (node, message) => {
+      this.diagnostics.push({ node, message });
+    };
+    const name = this.className(stmt);
+    if (stmt.superclass) {
+      const local = this.aliasDefs.get(stmt.superclass.name)?.runtimeClass;
+      if (local && this.extendsThrough(local, stmt)) {
+        report(stmt.superclass, `'${name}' cannot extend itself`);
+      } else if (!this.baseInstance(stmt)) {
+        const known = this.aliases.has(stmt.superclass.name) || this.importedTypes.has(stmt.superclass.name);
+        report(stmt.superclass, known ? `'${stmt.superclass.name}' is not a class; a class can only extend another class` : `Cannot find class '${stmt.superclass.name}'`);
+      }
+    }
+    for (const member of stmt.members) {
+      if (member.type === "ClassConstructor") continue;
+      if (CLASS_RESERVED.has(member.name.name)) {
+        report(member.name, `'${member.name.name}' is what the compiler calls part of a class; a member cannot be named that`);
+      }
+    }
+    const seen = /* @__PURE__ */ new Map();
+    for (const member of stmt.members) {
+      if (member.type === "ClassConstructor") {
+        if (seen.has("constructor")) report(member, "A class has one constructor");
+        seen.set("constructor", member.type);
+        continue;
+      }
+      const key = `${member.isStatic ? "static " : ""}${member.name.name}`;
+      const before = seen.get(key);
+      const pair = member.type === "ClassAccessor" && before === "ClassAccessor";
+      if (before !== void 0 && !pair) {
+        report(member.name, `'${member.name.name}' is declared twice in class '${name}'`);
+      }
+      seen.set(key, member.type);
+    }
+    const constructor = stmt.members.find((m) => m.type === "ClassConstructor");
+    if (stmt.superclass && this.baseInstance(stmt) && constructor && !callsSuper(constructor.func.body)) {
+      report(constructor, `'${name}' extends '${stmt.superclass.name}', so its constructor must call 'super(...)'`);
+    }
+    const assigned = constructor ? assignedFields(constructor.func.body) : /* @__PURE__ */ new Set();
+    for (const member of stmt.members) {
+      if (member.type !== "ClassField" || member.isStatic || member.init) continue;
+      if (assigned.has(member.name.name)) continue;
+      const type = member.typeAnnotation ? this.withTypeParams(this.classTypeParams(stmt), () => this.resolveType(member.typeAnnotation)) : anyType;
+      if (isAssignable(nilType, type)) continue;
+      report(member.name, `'${member.name.name}' has no value: give it one, assign it in the constructor, or let its type admit nil`);
+    }
+  }
   /** `extends` must name a class, and the chain must end. */
   checkClass(stmt) {
     if (!stmt.superclass || !this.emitDiagnostics) return;
@@ -5129,6 +6162,7 @@ var TypeAnalyzer = class {
   instantiateAlias(def, args) {
     if (this.instantiationDepth > 20) return unknownType;
     const subst = this.bindTypeArguments(def.params, args);
+    if (def.runtimeClass) return substitute(this.instanceType(def.runtimeClass), subst);
     this.instantiationDepth++;
     try {
       const body = this.withTypeParams(def.params, () => this.resolveType(def.node));
@@ -5273,15 +6307,17 @@ var TypeAnalyzer = class {
       case "FunctionTypeNode": {
         const names = node.generics.map((g) => g.name);
         return this.withTypeParams(node.generics, () => {
-          const params = node.params.map((p) => ({
+          const params = node.params.filter((p) => !p.rest).map((p) => ({
             name: p.name,
             type: p.optional ? optional(this.resolveType(p.typeAnnotation)) : this.resolveType(p.typeAnnotation),
             optional: p.optional
           }));
+          const restParam = node.params.find((p) => p.rest);
+          const restElement = restParam ? this.resolveType(restParam.typeAnnotation) : void 0;
           return this.withTypeParamDefaults(fn(
             params,
             this.resolveType(node.returnType),
-            node.hasVarargs ? node.varargType ? this.resolveType(node.varargType) : anyType : void 0,
+            restParam ? restElement?.kind === "array" ? restElement.element : unknownType : node.hasVarargs ? node.varargType ? this.resolveType(node.varargType) : anyType : void 0,
             names,
             this.resolvePredicate(node.predicate, params)
           ), node.generics);
@@ -5475,7 +6511,10 @@ var TypeAnalyzer = class {
   accessType(obj, index) {
     if (index.kind === "union") return union(index.types.map((m) => this.accessType(obj, m)));
     if (index.kind === "literal" && typeof index.value === "string") {
-      return this.propertyType(obj, index.value);
+      const member = this.propertyType(obj, index.value);
+      if (member.kind !== "unknown") return member;
+      const t = this.expand(obj);
+      return t.kind === "object" && !t.class && !t.indexer ? nilType : member;
     }
     return this.indexedType(obj, index);
   }
@@ -5628,12 +6667,13 @@ var TypeAnalyzer = class {
   visitStatement(stmt, env) {
     switch (stmt.type) {
       case "VariableDeclaration": {
+        this.nameClassExpressions(stmt);
         stmt.names.forEach((target, i) => {
           if (target.type === "IdentifierPattern" && target.typeAnnotation && stmt.init[i]) {
             this.applyContext(stmt.init[i], this.resolveType(target.typeAnnotation));
           }
         });
-        const { types: valueTypes, sources } = this.valueList(stmt.init, env);
+        const { types: valueTypes, sources } = this.valueList(stmt.init, env, stmt.names.length);
         stmt.names.forEach((target, i) => {
           const inferred = valueTypes[i] ?? (stmt.init.length ? unknownType : nilType);
           const source = sources[i];
@@ -5658,6 +6698,15 @@ var TypeAnalyzer = class {
         });
         return;
       }
+      case "ClassDeclaration": {
+        const id = this.bindingIdByName(stmt.name.name, stmt.name);
+        const value = this.visitClass(stmt, env);
+        if (id !== void 0) {
+          this.bindingType.set(id, value);
+          this.setBinding(env, id, value);
+        }
+        return;
+      }
       case "FunctionDeclaration": {
         this.checkParamOrder(stmt.func.params, stmt);
         for (const sig of stmt.signatures ?? []) this.checkParamOrder(sig.params, stmt);
@@ -5713,7 +6762,7 @@ var TypeAnalyzer = class {
             if (id !== void 0 && this.annotated.has(id)) this.applyContext(value, this.bindingType.get(id));
           }
         });
-        const { types: valueTypes, sources } = this.valueList(stmt.values, env);
+        const { types: valueTypes, sources } = this.valueList(stmt.values, env, stmt.targets.length);
         stmt.targets.forEach((target, i) => {
           const vt = valueTypes[i] ?? unknownType;
           const source = sources[i];
@@ -5821,7 +6870,8 @@ var TypeAnalyzer = class {
             stmt.arguments.forEach((a, i) => this.applyContext(a, declared.elements[i]));
           }
         }
-        const { types, sources } = this.valueList(stmt.arguments, env);
+        const want = declared?.kind === "tuple" && declared.isPack ? declared.elements.length : 0;
+        const { types, sources } = this.valueList(stmt.arguments, env, want);
         this.checkReturn(stmt, declared, types, sources, env);
         if (this.returnTypes) {
           this.returnTypes.push(stmt.arguments.length === 0 ? nilType : types.length === 1 ? types[0] : tuple([...types], true));
@@ -5832,7 +6882,8 @@ var TypeAnalyzer = class {
         this.visitStatement(stmt.declaration, env);
         return;
       case "ExportDefaultStatement":
-        this.infer(stmt.declaration, env);
+        if (stmt.declaration.type === "ClassDeclaration") this.visitStatement(stmt.declaration, env);
+        else this.infer(stmt.declaration, env);
         return;
       case "ExportNamedStatement": {
         if (stmt.source) {
@@ -5911,12 +6962,35 @@ var TypeAnalyzer = class {
    *  `sources` maps each produced value back to the expression it came from
    *  (undefined for the 2nd and later values of a multi-value call), so the
    *  caller can still do contextual typing against the written expression. */
-  valueList(exprs, env) {
+  valueList(exprs, env, want = 0) {
     const types = [];
     const sources = [];
     exprs.forEach((e, i) => {
       const t = this.infer(e, env);
       const last = i === exprs.length - 1;
+      if (e.type === "SpreadElement") {
+        const held = this.typeOf.get(e.argument);
+        const expanded = held && this.expand(held);
+        if (expanded?.kind === "tuple") {
+          for (const element of expanded.elements) {
+            types.push(element);
+            sources.push(e);
+          }
+          return;
+        }
+        do {
+          types.push(t);
+          sources.push(e);
+        } while (last && types.length < want);
+        return;
+      }
+      if (last && e.type === "VarargExpression") {
+        do {
+          types.push(t);
+          sources.push(types.length - 1 === i ? e : void 0);
+        } while (types.length < want);
+        return;
+      }
       if (last && t.kind === "tuple" && t.isPack && producesMultipleValues(e)) {
         t.elements.forEach((el, j) => {
           types.push(el);
@@ -6005,7 +7079,8 @@ var TypeAnalyzer = class {
   /** A parameter's type: annotation, else a shape synthesized from a
    *  destructuring pattern, else inferred from its default, else `any`. */
   paramType(p, env) {
-    if (!p.typeAnnotation && !p.pattern && !p.default && p.name === "self" && this.selfType) {
+    const receiver = p.name === "self" || p.name === "this";
+    if (!p.typeAnnotation && !p.pattern && !p.default && receiver && this.selfType) {
       return this.selfType;
     }
     if (p.typeAnnotation) {
@@ -6013,6 +7088,7 @@ var TypeAnalyzer = class {
       if (p.default) this.applyContext(p.default, t);
       return p.optional ? optional(t) : t;
     }
+    if (p.rest) return arrayOf(unknownType);
     if (p.pattern) return this.patternToType(p.pattern, env);
     if (p.default) return widen(this.infer(p.default, env));
     return this.contextualParams.get(p) ?? anyType;
@@ -6033,6 +7109,11 @@ var TypeAnalyzer = class {
     this.expectedTypeOf.set(e, expected);
     if (e.type === "ArrayExpression") return this.applyArrayContext(e, expected);
     if (e.type === "TableExpression") return this.applyTableContext(e, expected);
+    if (e.type === "BinaryExpression" && (e.operator === "or" || e.operator === "and")) {
+      if (e.operator === "or") this.applyContext(e.left, expected);
+      this.applyContext(e.right, expected);
+      return;
+    }
     if (e.type !== "FunctionExpression") return;
     const members = expected.kind === "union" ? expected.types : [expected];
     const signatures = members.flatMap((m) => this.overloadsOf(this.expand(m)));
@@ -6058,7 +7139,7 @@ var TypeAnalyzer = class {
     const target = this.expectedMembers(expected).find((m) => m.kind === "array" || m.kind === "tuple");
     if (!target) return;
     if (!e.elements.length) {
-      if (!containsTypeParam(target)) this.contextualArrays.set(e, target);
+      this.contextualArrays.set(e, target);
       return;
     }
     e.elements.forEach((element, i) => {
@@ -6073,13 +7154,15 @@ var TypeAnalyzer = class {
     const objects = this.expectedMembers(expected).filter((m) => m.kind === "object");
     if (!objects.length) return;
     for (const field of e.fields) {
-      if (field.type !== "TableFieldNamed") continue;
-      const key = field.key.type === "Identifier" ? field.key.name : field.key.value;
+      if (field.type !== "TableFieldNamed" && field.type !== "TableFieldShorthand") continue;
+      const key = field.type === "TableFieldShorthand" ? field.name.name : field.key.type === "Identifier" ? field.key.name : field.key.value;
       const types = objects.flatMap((o) => {
         const property = o.properties.get(key);
         return property ? [property.type] : o.indexer ? [o.indexer.value] : [];
       });
-      if (types.length) this.applyContext(field.value, union(types));
+      if (types.length) {
+        this.applyContext(field.type === "TableFieldShorthand" ? field.name : field.value, union(types));
+      }
     }
   }
   /** The members of an expected type worth matching a literal against:
@@ -6116,13 +7199,26 @@ var TypeAnalyzer = class {
     }
     return tuple(target.elements.map((el) => el ? leaf(el.value, el.default) : anyType));
   }
+  /** What a vararg function's `...` holds, one value at a time.
+   *
+   *  Written three ways, and they mean the same call: `...` says nothing,
+   *  `...: T` says each value is a `T`, and `...rest: T[]` collects them
+   *  into an array the body reads by name. Only the last changes what the
+   *  body sees — the signature is the same either way. */
+  varargElement(func) {
+    if (!func.hasVarargs) return void 0;
+    const rest = func.params.find((p) => p.rest);
+    if (!rest) return func.varargTypeAnnotation ? this.resolveType(func.varargTypeAnnotation) : anyType;
+    const declared = rest.typeAnnotation ? this.resolveType(rest.typeAnnotation) : void 0;
+    return declared?.kind === "array" ? declared.element : unknownType;
+  }
   /** The type of `...` in each function body being walked. */
   varargs = [];
   /** What each function body being walked declared it returns. */
   declaredReturns = [];
   /** Run `body` with `...` and `return` as `func` declares them. */
   withVarargs(func, body) {
-    this.varargs.push(func.hasVarargs ? func.varargTypeAnnotation ? this.resolveType(func.varargTypeAnnotation) : anyType : void 0);
+    this.varargs.push(this.varargElement(func));
     this.declaredReturns.push(func.predicate ? booleanType : func.returnType ? this.resolveType(func.returnType) : void 0);
     try {
       return body();
@@ -6203,6 +7299,13 @@ var TypeAnalyzer = class {
       const param = p.type.kind === "typeParam" && p.type.constraint ? { ...p.type, constraint: this.reduceType(p.type.constraint) } : p.type;
       unify(p.type, keepsLiterals(param) ? arg : widen(arg), vars, subst);
     });
+    if (f.varargs) {
+      const keeps = keepsLiterals(f.varargs);
+      for (let i = f.params.length; i < argTypes.length; i++) {
+        const arg = argTypes[i];
+        if (arg !== void 0) unify(f.varargs, keeps ? arg : widen(arg), vars, subst);
+      }
+    }
     for (const name of f.typeParams ?? []) {
       if (!subst.has(name)) subst.set(name, f.typeParamDefaults?.[name] ?? unknownType);
     }
@@ -6227,11 +7330,11 @@ var TypeAnalyzer = class {
    *  after every concrete signature has been tried. That ordering is what
    *  lets `typeof` declare `(v: number) -> "number"` alongside a trailing
    *  `<T>(v: T) -> string` and still pick the precise one. */
-  pickOverload(fns, argTypes, argsFor) {
+  pickOverload(fns, argTypes, argsFor, spread) {
     for (const generic of [false, true]) {
       for (const f of fns) {
         if ((f.typeParams?.length ?? 0) > 0 !== generic) continue;
-        if (this.overloadAccepts(f, argsFor ? argsFor(f) : argTypes)) return f;
+        if (this.overloadAccepts(f, argsFor ? argsFor(f) : argTypes, spread)) return f;
       }
     }
     return void 0;
@@ -6266,12 +7369,27 @@ var TypeAnalyzer = class {
    *  own type parameters stand for what the call would infer, so each is
    *  checked only against its constraint — `<K extends keyof Services>`
    *  accepts `"Players"` but not `""`. */
-  overloadAccepts(f, argTypes) {
-    if (!f.varargs && argTypes.length > f.params.length) return false;
+  overloadAccepts(f, argTypes, spread) {
+    const at = (i) => {
+      if (!spread || i < spread.index) return argTypes[i];
+      if (!spread.elements) return argTypes[spread.index];
+      const held = spread.elements[i - spread.index];
+      return held ?? argTypes[i - spread.index + 1 + spread.elements.length - 1];
+    };
+    const written = spread?.elements ? argTypes.length + spread.elements.length - 1 : argTypes.length;
+    if (!f.varargs && (!spread || spread.elements) && written > f.params.length) return false;
+    if (f.varargs && !f.typeParams?.length) {
+      const last = spread && !spread.elements ? Math.max(f.params.length + 1, written) : written;
+      for (let i = f.params.length; i < last; i++) {
+        const arg = at(i);
+        if (arg !== void 0 && !isAssignable(arg, f.varargs)) return false;
+      }
+    }
     const params = this.boundParams(f);
     return f.params.every((p, i) => {
-      if (argTypes[i] === void 0) return p.optional === true;
-      return isAssignable(argTypes[i], params[i]);
+      const arg = at(i);
+      if (arg === void 0) return p.optional === true;
+      return isAssignable(arg, params[i]);
     });
   }
   /** A signature's parameter types as a call site sees them before inference:
@@ -6301,17 +7419,40 @@ var TypeAnalyzer = class {
   }
   /** Record what each written argument is expected to be — see
    *  `TypeAnalysis.expectedTypeOf`. */
-  recordExpected(written, fns, selfOf) {
+  recordExpected(written, fns, selfOf, argsOf = () => []) {
+    const paramsOf = /* @__PURE__ */ new Map();
+    for (const f of fns) paramsOf.set(f, this.paramsAsCalled(f, argsOf(f)));
     written.forEach((arg, j) => {
       const candidates = [];
       for (const f of fns) {
         const i = j + selfOf(f);
-        const param = i < f.params.length ? this.boundParams(f)[i] : f.varargs;
+        const params = paramsOf.get(f);
+        const param = i < params.length ? params[i] : f.varargs;
         if (param) candidates.push(param);
       }
       if (candidates.length) this.expectedTypeOf.set(arg, union(candidates));
     });
   }
+  /** The parameters as *this* call makes them read: a type argument the
+   *  arguments already written pin down is substituted in, and one nothing
+   *  has pinned down yet falls back to its constraint.
+   *
+   *  It is what makes the second argument of
+   *  `get(page, skill: Extract<Rows, { Page: Page }>["Skills"][number])`
+   *  worth completing — with `page` written, `skill` is the skills of that
+   *  page, not of every page. */
+  paramsAsCalled(f, argTypes) {
+    const fallback = this.boundParams(f);
+    if (!f.typeParams?.length || !argTypes.length) return fallback;
+    return f.params.map((p, i) => {
+      if (!containsTypeParam(p.type)) return p.type;
+      const subst = this.inferTypeArgs(f, argTypes.map((t, k) => k === i ? void 0 : t));
+      for (const [name, bound] of [...subst]) if (bound.kind === "unknown") subst.delete(name);
+      if (!subst.size) return fallback[i];
+      const applied = this.reduceType(substitute(p.type, subst));
+      return containsTypeParam(applied) ? fallback[i] : applied;
+    });
+  }
   /** No signature accepts the call, and the argument count is not the
    *  problem: say which argument is wrong, the way TypeScript does. */
   /** Check what was written against the parameters as this call's own type
@@ -6322,10 +7463,11 @@ var TypeAnalyzer = class {
     if (!this.emitDiagnostics || !f.typeParams?.length) return;
     const subst = this.inferTypeArgs(f, [...argTypes]);
     for (const bound of subst.values()) if (bound.kind === "unknown") return;
-    for (let i = 0; i < f.params.length; i++) {
+    const declaredAt = (i) => i < f.params.length ? f.params[i].type : f.varargs;
+    for (let i = 0; i < Math.max(f.params.length, argTypes.length); i++) {
       const arg = argTypes[i];
-      const declared = f.params[i].type;
-      if (arg === void 0 || !containsTypeParam(declared)) continue;
+      const declared = declaredAt(i);
+      if (arg === void 0 || declared === void 0 || !containsTypeParam(declared)) continue;
       const expected = this.reduceType(substitute(declared, subst));
       if (containsTypeParam(expected) || expected.kind === "any" || expected.kind === "unknown") continue;
       if (isAssignable(arg, expected) || isAssignable(widen(arg), expected)) continue;
@@ -6346,15 +7488,26 @@ var TypeAnalyzer = class {
     const args = argsFor(f);
     const params = this.boundParams(f);
     const self = selfOf(f);
+    const spread = this.spreadOf(written, self);
     for (let i = 0; i < f.params.length; i++) {
-      const arg = args[i];
-      if (arg === void 0 || isAssignable(arg, params[i])) continue;
+      const arg = spread && i >= spread.index ? this.spreadValue(spread, i) : args[i];
+      if (spread && i > spread.index && !spread.elements) break;
+      if (arg === void 0 || arg.kind === "never" || isAssignable(arg, params[i])) continue;
       this.diagnostics.push({
-        node: written[i - self] ?? call,
+        node: (spread && i >= spread.index ? written[spread.index - self] : written[i - self]) ?? call,
         message: `Argument of type '${formatType(arg)}' is not assignable to parameter of type '${briefType(params[i])}'`
       });
       return;
     }
+    if (!f.varargs || f.typeParams?.length) return;
+    for (let i = f.params.length; i < args.length; i++) {
+      if (isAssignable(args[i], f.varargs)) continue;
+      this.diagnostics.push({
+        node: written[i - self] ?? call,
+        message: `Argument of type '${formatType(args[i])}' is not assignable to parameter of type '${briefType(f.varargs)}'`
+      });
+      return;
+    }
   }
   /** A required parameter may not follow an optional one — otherwise the
    *  optional one could never actually be omitted. Same rule as TypeScript,
@@ -6363,6 +7516,10 @@ var TypeAnalyzer = class {
     if (!this.emitDiagnostics) return;
     let seenOptional;
     for (const p of params) {
+      if (p.rest === true) {
+        this.checkRestType(p, node);
+        continue;
+      }
       const isOptional = p.optional === true || p.default !== void 0;
       if (isOptional) {
         if (seenOptional === void 0) seenOptional = p.name ?? "parameter";
@@ -6388,8 +7545,10 @@ var TypeAnalyzer = class {
    *  when *no* overload accepts the count, so an overload set still reports
    *  once, against its first signature. Returns whether the count fits, so
    *  an argument's type is only complained about when its count is right. */
-  checkArity(node, fns, argCount, selfArgs) {
+  checkArity(node, fns, argCount, selfArgs, spread) {
     if (!fns.length) return true;
+    if (spread && !spread.elements) return true;
+    if (spread?.elements) argCount += spread.elements.length - 1;
     const fits = fns.some((f) => {
       const { min: min2, max: max2 } = this.arityOf(f);
       const n = argCount + selfArgs;
@@ -6432,7 +7591,7 @@ var TypeAnalyzer = class {
       return type;
     };
     return record(this.withTypeParams(sig.generics, () => {
-      const params = sig.params.map((p) => ({
+      const params = sig.params.filter((p) => !p.rest).map((p) => ({
         name: p.pattern ? void 0 : p.name,
         type: this.paramType(p, /* @__PURE__ */ new Map()),
         optional: p.optional || p.default !== void 0
@@ -6440,12 +7599,23 @@ var TypeAnalyzer = class {
       return fn(
         params,
         sig.returnType ? this.resolveType(sig.returnType) : sig.predicate ? booleanType : anyType,
-        sig.hasVarargs ? sig.varargTypeAnnotation ? this.resolveType(sig.varargTypeAnnotation) : anyType : void 0,
+        this.varargElement(sig),
         names,
         this.resolvePredicate(sig.predicate, params)
       );
     }));
   }
+  /** `...rest: T[]` holds every argument from its position on, so its type
+   *  is an array of what each one is. */
+  checkRestType(p, node) {
+    if (!this.emitDiagnostics || !p.typeAnnotation) return;
+    const declared = this.resolveType(p.typeAnnotation);
+    if (declared.kind === "array" || declared.kind === "any" || declared.kind === "typeParam") return;
+    this.diagnostics.push({
+      node,
+      message: `A rest parameter holds every argument from its position on, so '${p.name ?? "..."}' is an array: '${formatType(declared)}[]', not '${formatType(declared)}'`
+    });
+  }
   /** Turn a parsed `v is T` / `asserts v` annotation into a `TypePredicate`,
    *  resolving the named parameter to its index. A guard naming a parameter
    *  the function does not have is dropped rather than mis-narrowing an
@@ -6463,17 +7633,18 @@ var TypeAnalyzer = class {
   inferFunctionBody(func, env) {
     const names = func.generics.map((g) => g.name);
     return this.withTypeParams(func.generics, () => {
-      const params = func.params.map((p) => {
+      const params = func.params.flatMap((p) => {
         const type = this.paramType(p, env);
         if (!p.pattern) {
           const id = this.bindingIdByName(p.name, p);
           if (id !== void 0 && !this.bindingType.has(id)) this.bindingType.set(id, type);
         }
-        return {
+        if (p.rest) return [];
+        return [{
           name: p.pattern ? void 0 : p.name,
           type,
           optional: p.optional || p.default !== void 0
-        };
+        }];
       });
       const bodyEnv = forkEnv(env);
       for (const p of func.params) {
@@ -6498,7 +7669,7 @@ var TypeAnalyzer = class {
       return fn(
         params,
         returns,
-        func.hasVarargs ? func.varargTypeAnnotation ? this.resolveType(func.varargTypeAnnotation) : anyType : void 0,
+        this.varargElement(func),
         names,
         this.resolvePredicate(func.predicate, params)
       );
@@ -6712,6 +7883,13 @@ var TypeAnalyzer = class {
         if (src.kind === "array") return [numberType, src.element];
       }
     }
+    const iterator = this.expand(iterType);
+    if (iterator.kind === "function") {
+      const returns = this.expand(iterator.returns);
+      const parts = returns.kind === "tuple" ? returns.elements.map((m) => this.expand(m)) : [returns];
+      const at = (i) => parts[i] ?? (parts.length === 1 ? parts[0] : unknownType);
+      return [at(0), at(1)];
+    }
     const t = this.expand(iterType);
     if (t.kind === "array") return varCount >= 2 ? [numberType, t.element] : [t.element, unknownType];
     if (t.kind === "object") {
@@ -6863,7 +8041,21 @@ var TypeAnalyzer = class {
   expand(t) {
     if (t.kind !== "genericRef") return t;
     const def = this.aliasDefs.get(t.name);
-    if (!def || this.resolvingAliases.has(t.name)) return t;
+    if (!def) {
+      const imported = this.importedTypes.get(t.name);
+      if (!imported) return t;
+      if (!imported.params.length) return imported.type;
+      const subst = /* @__PURE__ */ new Map();
+      imported.params.forEach((name, i) => subst.set(name, t.typeArguments[i] ?? unknownType));
+      const key2 = `import ${formatType(t)}`;
+      const cached2 = this.expandCache.get(key2);
+      if (cached2) return cached2;
+      this.expandCache.set(key2, t);
+      const applied = substitute(imported.type, subst);
+      this.expandCache.set(key2, applied);
+      return applied;
+    }
+    if (this.resolvingAliases.has(t.name)) return t;
     const key = t.typeArguments.length ? formatType(t) : t.name;
     const cached = this.expandCache.get(key);
     if (cached) return cached;
@@ -6878,6 +8070,126 @@ var TypeAnalyzer = class {
       this.resolvingAliases.delete(t.name);
     }
   }
+  /** `names:filter(f)`, `text:trim()` — the methods arrays and strings have.
+   *  They are written in the prelude as `ArrayMethods<T>` and
+   *  `StringMethods`, so a file (or a type library) that declares one of
+   *  those names again replaces the whole set, and nothing here is a special
+   *  case in the analyzer. The build lowers each call to a plain function. */
+  builtInMethod(t, name) {
+    const parts = (t.kind === "union" ? t.types : [t]).map((m) => this.expand(m));
+    const elements = parts.map((m) => m.kind === "array" ? m.element : m.kind === "tuple" ? union(m.elements) : void 0);
+    const element = elements.every((e) => e !== void 0) ? union(elements) : void 0;
+    const isString = (m) => m.kind === "primitive" && m.name === "string" || m.kind === "literal" && m.base === "string" || m.kind === "templateLiteral";
+    const methodTable = element !== void 0 ? "ArrayMethods" : parts.every(isString) ? "StringMethods" : void 0;
+    const def = methodTable === void 0 ? void 0 : this.aliasDefs.get(methodTable);
+    if (!def || def.class) return void 0;
+    const table = this.expand(this.instantiateAlias(def, element !== void 0 ? [element] : []));
+    const layers = table.kind === "intersection" ? table.types.map((m) => this.expand(m)) : [table];
+    for (let i = layers.length - 1; i >= 0; i--) {
+      const part = layers[i];
+      const property = part.kind === "object" ? part.properties.get(name) : void 0;
+      if (property) return property.type;
+    }
+    return void 0;
+  }
+  /** The most a deferred type could turn out to be. A conditional is one of
+   *  its branches, and the true branch stands for a member of what was
+   *  tested (`T` in `T extends U ? T : never`); an indexed access reads
+   *  through the bound of what it indexes. Anything else has no bound worth
+   *  giving — `undefined` leaves the comparison as it was. */
+  deferredBound(t, depth = 0) {
+    if (depth > 8) return void 0;
+    switch (t.kind) {
+      case "conditional": {
+        const check = this.reduceType(t.checkType);
+        if (containsTypeParam(check)) return void 0;
+        const subst = /* @__PURE__ */ new Map();
+        if (t.distributeParam) subst.set(t.distributeParam, check);
+        for (const name of t.inferVars ?? []) subst.set(name, unknownType);
+        const branches = [substitute(t.trueType, subst), t.falseType].map((branch) => this.reduceType(branch));
+        if (branches.some((branch) => containsTypeParam(branch))) return void 0;
+        return union(branches);
+      }
+      case "indexedAccess": {
+        const object = this.deferredBound(t.objectType, depth + 1) ?? this.atConstraints(t.objectType);
+        const index = this.atConstraints(this.reduceType(t.indexType));
+        if (!object || !index) return void 0;
+        return this.indexedType(object, index);
+      }
+      default:
+        return void 0;
+    }
+  }
+  /** `t` with every type parameter standing at its constraint: `Map[K]`
+   *  where `K extends "a" | "b"` is at most what those two keys hold. A
+   *  parameter with no constraint bounds nothing, and says so. */
+  atConstraints(t) {
+    if (!containsTypeParam(t)) return t;
+    const bounds = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new WeakSet();
+    let open = false;
+    const walk = (value) => {
+      if (!value || typeof value !== "object" || seen.has(value)) return;
+      seen.add(value);
+      if (value instanceof Map) {
+        value.forEach(walk);
+        return;
+      }
+      const part = value;
+      if (part.kind === "object" && part.class) return;
+      if (part.kind === "typeParam" && typeof part.name === "string") {
+        if (part.constraint && !containsTypeParam(part.constraint)) {
+          bounds.set(part.name, this.reduceType(part.constraint));
+        } else {
+          open = true;
+        }
+      }
+      for (const child of Object.values(value)) walk(child);
+    };
+    walk(t);
+    if (open) return void 0;
+    const applied = this.reduceType(substitute(t, bounds));
+    return containsTypeParam(applied) ? void 0 : applied;
+  }
+  /** What `text["upper"]` reads: a string answers only to its methods, the
+   *  way Lua's string metatable does. */
+  stringMember(object, index) {
+    if (index.kind !== "literal" || typeof index.value !== "string") return void 0;
+    const parts = this.stringParts(object);
+    if (!parts) return void 0;
+    const found = parts.map((part) => this.builtInMethod(part, index.value));
+    return found.every((t) => t !== void 0) ? union(found) : void 0;
+  }
+  /** The members of `t` when every one of them is a string — `"a" | "b"` is
+   *  as much a string as `string` is. */
+  stringParts(t) {
+    let expanded = this.expand(t);
+    if (expanded.kind === "conditional" || expanded.kind === "indexedAccess") {
+      const bound = this.deferredBound(expanded);
+      if (!bound) return void 0;
+      expanded = this.expand(bound);
+    }
+    const parts = (expanded.kind === "union" ? expanded.types : [expanded]).map((m) => this.expand(m));
+    const isString = (m) => m.kind === "primitive" && m.name === "string" || m.kind === "literal" && m.base === "string" || m.kind === "templateLiteral";
+    return parts.length && parts.every(isString) ? parts : void 0;
+  }
+  /** `text.Sans` or `text["Sans"]`: a string is not a table, and the only
+   *  members it has are the ones a type library gave it — so a name that is
+   *  not one of them is a mistake worth reporting, rather than the nil Lua
+   *  would hand back. */
+  checkStringMember(node, object, key) {
+    if (!this.emitDiagnostics) return;
+    const parts = this.stringParts(object);
+    if (!parts) return;
+    const keys = (key.kind === "union" ? key.types : [key]).map((m) => this.expand(m));
+    if (!keys.length || !keys.every((m) => m.kind === "literal" && typeof m.value === "string")) return;
+    const names = keys.map((m) => String(m.value));
+    if (names.some((name) => parts.some((part) => this.builtInMethod(part, name)))) return;
+    this.diagnostics.push({
+      node,
+      message: names.length === 1 ? `'${names[0]}' does not exist on a string` : `'${briefType(key)}' does not name a member of a string`
+    });
+  }
   propertyType(raw, name) {
     const t = this.deferredAccess(this.expand(raw));
     if (t.kind === "object") {
@@ -6885,7 +8197,13 @@ var TypeAnalyzer = class {
       if (p) return p.optional ? optional(p.type) : p.type;
       if (t.indexer) return t.indexer.value;
     }
-    if (t.kind === "union") return union(t.types.map((m) => this.propertyType(m, name)));
+    const built = this.builtInMethod(t, name);
+    if (built) return built;
+    if (t.kind === "union") {
+      const built2 = this.builtInMethod(t, name);
+      if (built2) return built2;
+      return union(t.types.map((m) => this.propertyType(m, name)));
+    }
     if (t.kind === "intersection") {
       const parts = t.types.map((m) => this.propertyType(m, name)).filter((p) => p.kind !== "unknown");
       if (parts.length) return intersection(parts);
@@ -6893,6 +8211,10 @@ var TypeAnalyzer = class {
     if (t.kind === "typeParam" && t.constraint) return this.propertyType(t.constraint, name);
     if (t.kind === "difference") return this.propertyType(t.base, name);
     if (t.kind === "any") return anyType;
+    if (t.kind === "conditional" || t.kind === "indexedAccess") {
+      const bound = this.deferredBound(t);
+      if (bound) return this.propertyType(bound, name);
+    }
     return unknownType;
   }
   /** `t[k]`. A statically known string key resolves against the declared
@@ -6968,6 +8290,20 @@ var TypeAnalyzer = class {
       // `...` holds what the function declared it takes.
       case "VarargExpression":
         return this.varargs[this.varargs.length - 1] ?? anyType;
+      // `f(a, ...rest)` — every value the array holds, one after
+      // another. Each of them is an element, so that is what the
+      // parameters it fills are checked against.
+      case "SpreadElement": {
+        const spread = this.infer(expr.argument, env);
+        const element = this.spreadElement(spread);
+        if (element === void 0 && this.emitDiagnostics) {
+          this.diagnostics.push({
+            node: expr,
+            message: `Only an array can be spread, and '${formatType(spread)}' is not one`
+          });
+        }
+        return element ?? anyType;
+      }
       // Broken syntax is reported by the parser; nothing more to say.
       case "ErrorExpression":
         return anyType;
@@ -7073,6 +8409,7 @@ var TypeAnalyzer = class {
         const { type: obj, shortCircuits } = this.chainObject(expr, expr.object, env);
         const key = this.refKeyOf(expr);
         const narrowed = key === void 0 ? void 0 : env.get(key);
+        this.checkStringMember(expr, obj, literal(expr.property.name));
         return this.chainResult(expr, narrowed ?? this.propertyType(obj, expr.property.name), shortCircuits);
       }
       case "IndexExpression": {
@@ -7080,12 +8417,33 @@ var TypeAnalyzer = class {
         const idx = this.infer(expr.index, env);
         const key = this.refKeyOf(expr);
         const narrowed = key === void 0 ? void 0 : env.get(key);
+        this.checkStringMember(expr, obj, this.expand(idx));
+        const member = this.stringMember(obj, this.expand(idx));
+        if (member) return this.chainResult(expr, member, shortCircuits);
         return this.chainResult(expr, narrowed ?? this.indexedType(obj, idx), shortCircuits);
       }
       case "CallExpression": {
+        if (expr.callee.type === "SuperExpression") return this.inferSuperCall(expr, env);
         const { type: callee, shortCircuits } = this.chainObject(expr, expr.callee, env);
         return this.chainResult(expr, this.inferCall(expr, callee, env), shortCircuits);
       }
+      case "NewExpression":
+        return this.inferNew(expr, env);
+      case "ClassExpression":
+        return this.visitClass(expr, env);
+      case "SuperExpression": {
+        const stmt = this.currentClass;
+        if (!stmt?.superclass) {
+          if (this.emitDiagnostics) {
+            this.diagnostics.push({
+              node: expr,
+              message: "'super' is only available inside a class that extends another"
+            });
+          }
+          return anyType;
+        }
+        return this.superType(stmt);
+      }
       case "MethodCallExpression": {
         const { type: objType, shortCircuits } = this.chainObject(expr, expr.object, env);
         return this.chainResult(expr, this.inferMethodCall(expr, objType, env), shortCircuits);
@@ -7104,16 +8462,56 @@ var TypeAnalyzer = class {
       }
     }
   }
+  /** `new Name(args)` is `Name.new(args)` — the same function, and the
+   *  same check. Saying so here rather than rewriting the tree keeps the
+   *  error messages pointing at what was written. */
+  inferNew(expr, env) {
+    const calleeType = this.infer(expr.callee, env);
+    const constructor = this.propertyType(calleeType, "new");
+    if (!this.overloadsOf(constructor).length && calleeType.kind !== "any") {
+      if (this.emitDiagnostics) {
+        const label = expressionLabel(expr.callee) ?? formatType(calleeType);
+        this.diagnostics.push({ node: expr.callee, message: `'${label}' is not a class; 'new' needs one` });
+      }
+      for (const argument of expr.arguments) this.infer(argument, env);
+      return anyType;
+    }
+    return this.inferCall(expr, constructor, env);
+  }
+  /** `super(...)` — the base constructor, run on the instance being built. */
+  inferSuperCall(expr, env) {
+    const stmt = this.currentClass;
+    const constructor = stmt ? this.baseConstructorType(stmt) : void 0;
+    if (!stmt?.superclass) {
+      if (this.emitDiagnostics) {
+        this.diagnostics.push({
+          node: expr,
+          message: "'super(...)' is only available inside the constructor of a class that extends another"
+        });
+      }
+      for (const argument of expr.arguments) this.infer(argument, env);
+      return nilType;
+    }
+    if (!constructor) {
+      for (const argument of expr.arguments) this.infer(argument, env);
+      return nilType;
+    }
+    const callable = fn(constructor.params.filter((p) => p.name !== "this"), nilType, constructor.varargs);
+    this.inferCall(expr, callable, env);
+    return nilType;
+  }
   inferCall(expr, callee, env) {
+    this.checkAmbiguousCall(expr);
     const fns = this.overloadsOf(callee);
     const explicit = this.explicitTypeArguments(expr, fns);
     const expected = this.expectedArguments(expr.arguments, fns, () => 0);
     expr.arguments.forEach((a, i) => this.applyContext(a, expected[i]));
     const argTypes = expr.arguments.map((a) => this.infer(a, env));
     if (fns.length) {
-      this.recordExpected(expr.arguments, fns, () => 0);
-      const arityFits = this.checkArity(expr, fns, argTypes.length, 0);
-      const picked = this.pickOverload(fns, argTypes);
+      this.recordExpected(expr.arguments, fns, () => 0, () => argTypes);
+      const spread = this.spreadOf(expr.arguments);
+      const arityFits = this.checkArity(expr, fns, argTypes.length, 0, spread);
+      const picked = this.pickOverload(fns, argTypes, void 0, spread);
       const distributed = this.distributedReturn(fns, argTypes, picked, (_, args) => args);
       if (distributed) return distributed;
       if (picked) {
@@ -7125,6 +8523,21 @@ var TypeAnalyzer = class {
     }
     return callee.kind === "any" ? anyType : unknownType;
   }
+  /** A `(` on a line of its own continues the statement above it:
+   *
+   *      const value = map[key]
+   *      ("text"):upper()
+   *
+   *  calls `map[key]`, in luaut as in Lua and in JavaScript. It is almost
+   *  never what was meant, and what it does instead is invisible — so say
+   *  so, and name the fix. */
+  checkAmbiguousCall(expr) {
+    if (!this.emitDiagnostics || !expr.argumentsOnNewLine) return;
+    this.diagnostics.push({
+      node: expr,
+      message: "This calls the value the line above ends with \u2014 a line break does not end a statement. Write ';' before '(' if a new statement was meant."
+    });
+  }
   inferMethodCall(expr, objType, env) {
     const fns = this.overloadsOf(this.propertyType(objType, expr.method.name));
     const explicit = this.explicitTypeArguments(expr, fns);
@@ -7134,9 +8547,11 @@ var TypeAnalyzer = class {
     if (fns.length) {
       const withSelf = (f) => this.takesSelf(f) ? [objType, ...argTypes] : argTypes;
       const selfOf = (f) => this.takesSelf(f) ? 1 : 0;
-      this.recordExpected(expr.arguments, fns, selfOf);
-      const arityFits = this.checkArity(expr, fns, argTypes.length, this.takesSelf(fns[0]) ? 1 : 0);
-      const picked = this.pickOverload(fns, argTypes, withSelf);
+      this.recordExpected(expr.arguments, fns, selfOf, withSelf);
+      const self0 = this.takesSelf(fns[0]) ? 1 : 0;
+      const spread = this.spreadOf(expr.arguments, self0);
+      const arityFits = this.checkArity(expr, fns, argTypes.length, self0, spread);
+      const picked = this.pickOverload(fns, argTypes, withSelf, spread);
       const distributed = this.distributedReturn(
         fns,
         argTypes,
@@ -7238,7 +8653,21 @@ var TypeAnalyzer = class {
       }
     }
     if (asConst && !hadSpread) return tuple(elems);
-    return arrayOf(elems.length ? union(elems.map((t) => asConst ? t : widen(t))) : unknownType);
+    return arrayOf(elems.length ? union(elems.map((t, i) => {
+      const element = expr.elements[i];
+      return asConst || !element || element.type === "SpreadElement" ? t : this.widenUnlessAsked(t, element);
+    })) : unknownType);
+  }
+  /** A literal written inside a fresh table or array widens — `{ n = 1 }` is
+   *  `{ n: number }` — unless the surroundings said a literal belongs there.
+   *  `request({ Method: "GET" })` keeps `"GET"` when `Method` is a union of
+   *  string literals, exactly as TypeScript's contextual typing does, and
+   *  goes on widening to `string` when the parameter only says `string`.
+   *  The context was recorded by `applyContext` before the value was
+   *  inferred, so this is a lookup rather than a second pass. */
+  widenUnlessAsked(value, at) {
+    const wanted = this.expectedTypeOf.get(at);
+    return wanted === void 0 ? widen(value) : this.keepContextualLiterals(value, wanted);
   }
   inferObject(expr, env, asConst) {
     const entries = [];
@@ -7246,16 +8675,24 @@ var TypeAnalyzer = class {
     for (const field of expr.fields) {
       if (field.type === "TableFieldNamed") {
         const key = field.key.type === "Identifier" ? field.key.name : field.key.value;
-        const v = asConst ? this.inferAsConst(field.value, env) : widen(this.infer(field.value, env));
+        const v = asConst ? this.inferAsConst(field.value, env) : this.widenUnlessAsked(this.infer(field.value, env), field.value);
         entries.push([key, { type: v, optional: false, readonly: asConst }]);
       } else if (field.type === "TableFieldShorthand") {
         const v = this.infer(field.name, env);
-        entries.push([field.name.name, { type: asConst ? v : widen(v), optional: false, readonly: asConst }]);
+        entries.push([field.name.name, {
+          type: asConst ? v : this.widenUnlessAsked(v, field.name),
+          optional: false,
+          readonly: asConst
+        }]);
       } else if (field.type === "TableFieldComputed") {
         const k = this.infer(field.key, env);
         const v = this.infer(field.value, env);
         if (k.kind === "literal" && typeof k.value === "string") {
-          entries.push([k.value, { type: asConst ? v : widen(v), optional: false, readonly: asConst }]);
+          entries.push([k.value, {
+            type: asConst ? v : this.widenUnlessAsked(v, field.value),
+            optional: false,
+            readonly: asConst
+          }]);
         } else {
           indexer = mergeIndexer(indexer, { key: widen(k), value: asConst ? v : widen(v) });
         }
@@ -7763,7 +9200,39 @@ var TypeAnalyzer = class {
    *  out. Every place that has to line arguments up with parameters goes
    *  through here so the two sides cannot drift apart. */
   takesSelf(f) {
-    return f.params[0]?.name === "self";
+    const first = f.params[0]?.name;
+    return first === "self" || first === "this";
+  }
+  /** What one value of a spread array is, or `undefined` when the thing
+   *  spread is not a list of values at all. */
+  spreadElement(t) {
+    const spread = this.expand(t);
+    if (spread.kind === "array") return spread.element;
+    if (spread.kind === "tuple") return union(spread.elements);
+    if (spread.kind === "any") return anyType;
+    return void 0;
+  }
+  /** Where a call's arguments stop being one each, and what fills the rest.
+   *  From a spread on, every remaining parameter is filled by one of the
+   *  array's values — however many that turns out to be, so neither the
+   *  count nor the positions after it are known. A *tuple* is the exception:
+   *  it holds a known value at each position, and `elements` says which. */
+  spreadOf(args, self = 0) {
+    const index = args.findIndex((a) => a.type === "SpreadElement");
+    if (index < 0) return void 0;
+    const spread = args[index];
+    const held = this.typeOf.get(spread.argument);
+    const expanded = held && this.expand(held);
+    return {
+      index: index + self,
+      element: this.typeOf.get(spread) ?? unknownType,
+      elements: expanded?.kind === "tuple" ? expanded.elements : void 0
+    };
+  }
+  /** One of `spread`'s values, at the position `i` of a call's arguments. */
+  spreadValue(spread, i) {
+    if (!spread.elements) return spread.element;
+    return spread.elements[i - spread.index] ?? neverType;
   }
   /** A function type as a list of call signatures: a lone function is a
    *  one-element list, an intersection is the overload set in source order. */
@@ -7818,6 +9287,8 @@ var TypeAnalyzer = class {
         type = this.resolveType(statement.valueType);
       } else if (statement.type === "FunctionDeclaration") {
         type = statement.signatures?.length ? intersection(statement.signatures.map((sig) => this.signatureToFnType(sig))) : this.inferFunctionBody(statement.func, /* @__PURE__ */ new Map());
+      } else if (statement.type === "ClassDeclaration") {
+        type = this.classValueType(statement);
       } else if (statement.type === "VariableDeclaration") {
         const target = statement.names[index];
         if (target.type === "IdentifierPattern" && target.typeAnnotation) {
@@ -7854,6 +9325,10 @@ var TypeAnalyzer = class {
         return;
       }
       const record = node;
+      if (record.type === "ClassDeclaration" && record.name) {
+        const id = this.bindingIdByName(record.name.name, record.name);
+        if (id !== void 0) out.set(id, { statement: node, index: 0 });
+      }
       if (record.type === "FunctionDeclaration" && record.name) {
         const id = this.bindingIdByName(record.name.name, record.name);
         if (id !== void 0) out.set(id, { statement: node, index: 0 });
@@ -8080,6 +9555,7 @@ function offsetPosition(source, offset) {
 import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
 function resolveTypeLibraries(config, host = nodeHost) {
   const files = [];
+  const lowerings = [];
   const problems = [];
   const loaded = /* @__PURE__ */ new Set();
   const addFile = (file) => {
@@ -8097,6 +9573,8 @@ function resolveTypeLibraries(config, host = nodeHost) {
       if (found) addPackage(found.directory, found.file, visiting);
     }
     addFile(entryFile);
+    const lowering = loweringModule(directory, host, problems, config);
+    if (lowering) lowerings.push(lowering);
   };
   for (const entry of config.types) {
     const relative = entry.startsWith("./") || entry.startsWith("../") || entry.startsWith("/") || /^[A-Za-z]:[\\/]/.test(entry);
@@ -8123,7 +9601,19 @@ function resolveTypeLibraries(config, host = nodeHost) {
       });
     }
   }
-  return { files, problems };
+  return { files, lowerings, problems };
+}
+function loweringModule(directory, host, problems, config) {
+  const manifest = readJson(join2(directory, "package.json"), host);
+  const declared = manifest?.luaut?.lowering;
+  if (typeof declared !== "string") return void 0;
+  const from = typeof manifest?.name === "string" ? manifest.name : directory;
+  const file = resolve2(directory, declared);
+  if (host.readFile(file) === void 0) {
+    problems.push({ file: config.path, message: `'${from}' names a lowering module '${declared}', which is not there` });
+    return void 0;
+  }
+  return { file, from };
 }
 var ENTRY_FILE = "index.d.luaut";
 function packageEntry(directory, host) {
@@ -8358,6 +9848,7 @@ export {
   resolveModulePath,
   resolveTypeLibraries,
   setAliasExpander,
+  setDeferredBound,
   sourceMapTypes,
   stringType,
   stripJsonComments,