luaut-parser 2.0.0 → 3.0.0

package/dist/index.cjs

@@ -45,6 +45,7 @@ __export(index_exports, {
   getBinding: () => getBinding,
   intersection: () => intersection,
   isAssignable: () => isAssignable,
+  isClassType: () => isClassType,
   isGlobal: () => isGlobal,
   isPossiblyFalsy: () => isPossiblyFalsy,
   isPossiblyTruthy: () => isPossiblyTruthy,
@@ -888,23 +889,14 @@ var Parser = class {
     if (t.type === "Punctuator" && t.value === "@") {
       const { attributes, start } = this.parseAttributes();
       const next = this.current();
-      if (next.type === "Keyword" && (next.value === "const" || next.value === "let")) {
-        const stmt = this.parseVariableDeclaration();
-        if (stmt.type === "FunctionDeclaration") {
-          stmt.attributes = attributes;
-          stmt.line.start = start.line.start;
-          stmt.column.start = start.column.start;
-        }
-        return stmt;
-      }
       if (next.type === "Keyword" && next.value === "function") {
-        const stmt = this.parseFunctionDeclarationStatement();
+        const stmt = this.parseFunctionStatement();
         stmt.attributes = attributes;
         stmt.line.start = start.line.start;
         stmt.column.start = start.column.start;
         return stmt;
       }
-      throw new ParseError("Expected 'function', 'const', or 'let' after attribute", next.line.start, next.column.start);
+      throw new ParseError("Expected 'function' after an attribute", next.line.start, next.column.start);
     }
     if (t.type === "Keyword") {
       switch (t.value) {
@@ -922,7 +914,7 @@ var Parser = class {
         case "for":
           return this.parseForStatement();
         case "function":
-          return this.parseFunctionDeclarationStatement();
+          return this.parseFunctionStatement();
         case "return":
           return this.parseReturnStatement();
         case "import":
@@ -944,6 +936,9 @@ var Parser = class {
     }
     if (t.type === "Identifier" && t.value === "declare") {
       const p1 = this.peek(1);
+      if (p1.type === "Identifier" && p1.value === "class" && this.peek(2).type === "Identifier") {
+        return this.parseDeclareClassStatement();
+      }
       if (p1.type === "Identifier" || p1.type === "Keyword" && p1.value === "function") {
         return this.parseDeclareStatement();
       }
@@ -985,26 +980,66 @@ var Parser = class {
     const valueType = this.parseType();
     return { type: "DeclareStatement", name: nameTok.value, id: tokenIdentifier(nameTok), valueType, ...spanFrom(start, this.previous()) };
   }
+  /** A declared type's name. It may be qualified once — `Enum.Material` —
+   *  which is how a definitions file names types under a namespace, and how
+   *  they are then written (`const m: Enum.Material`). */
+  parseTypeName() {
+    const first = this.expectIdentifier();
+    if (this.checkPunctuator(".") && this.peek(1).type === "Identifier") {
+      this.advance();
+      const second = this.expectIdentifier();
+      return { type: "Identifier", name: `${first.value}.${second.value}`, ...spanFrom(first, second) };
+    }
+    return tokenIdentifier(first);
+  }
+  // `declare class Name extends Base { member: T, ... }`
+  parseDeclareClassStatement() {
+    const start = this.current();
+    this.advance();
+    this.advance();
+    const name = this.parseTypeName();
+    let superclass;
+    if (this.checkIdentifierValue("extends")) {
+      this.advance();
+      const base = this.parseType();
+      if (base.type !== "TypeReference") this.error("A class can only extend another class, written by name");
+      superclass = base;
+    }
+    if (!this.checkPunctuator("{")) this.error("Expected '{' to start the class body");
+    const body = this.parseTableType();
+    if (body.type !== "TableTypeNode") this.error("A class body lists members ('name: T'), not a mapped type");
+    return { type: "DeclareClassStatement", name, superclass, body, ...spanFrom(start, this.previous()) };
+  }
   // `import { a, b as c } from '...'` / `import Default from '...'` /
   // `import Default, { a } from '...'`. Compiled away entirely by the
   // bundler — never survives into emitted Luau.
   parseImportStatement() {
     const start = this.current();
     this.advance();
+    const next = this.peek(1);
+    const isTypeOnly = this.checkIdentifierValue("type") && (next.type === "Punctuator" && next.value === "{" || next.type === "Operator" && next.value === "*" || next.type === "Identifier");
+    if (isTypeOnly) this.advance();
     let defaultImport;
     const specifiers = [];
-    if (this.checkType("Identifier")) {
-      const nameTok = this.expectIdentifier();
-      defaultImport = { type: "Identifier", name: nameTok.value, ...spanFrom(nameTok, nameTok) };
-      if (this.matchPunctuator(",")) {
-        this.expectPunctuator("{");
-        this.parseImportSpecifierList(specifiers);
-        this.expectPunctuator("}");
+    let namespaceImport;
+    const parseBindings = () => {
+      if (this.checkOperator("*")) {
+        this.advance();
+        if (!this.checkKeyword("as")) this.error("Expected 'as' after 'import *'");
+        this.advance();
+        namespaceImport = this.parseIdentifier();
+        return;
       }
-    } else {
       this.expectPunctuator("{");
       this.parseImportSpecifierList(specifiers);
       this.expectPunctuator("}");
+    };
+    if (this.checkType("Identifier")) {
+      const nameTok = this.expectIdentifier();
+      defaultImport = { type: "Identifier", name: nameTok.value, ...spanFrom(nameTok, nameTok) };
+      if (this.matchPunctuator(",")) parseBindings();
+    } else {
+      parseBindings();
     }
     if (!this.checkKeyword("from")) {
       this.error("Expected 'from' in import statement");
@@ -1021,7 +1056,15 @@ var Parser = class {
       raw: sourceTok.raw,
       ...spanFrom(sourceTok, sourceTok)
     };
-    return { type: "ImportStatement", defaultImport, specifiers, source, ...spanFrom(start, this.previous()) };
+    return {
+      type: "ImportStatement",
+      defaultImport,
+      namespaceImport,
+      specifiers,
+      source,
+      isTypeOnly: isTypeOnly || void 0,
+      ...spanFrom(start, this.previous())
+    };
   }
   parseImportSpecifierList(out) {
     if (this.checkPunctuator("}")) return;
@@ -1057,7 +1100,7 @@ var Parser = class {
       ...spanFrom(sourceTok, sourceTok)
     };
   }
-  // `export const ...` / `export let ...` / `export const function ...` /
+  // `export const ...` / `export let ...` / `export function ...` /
   // `export type ...` / `export default <expr>`
   parseExportStatement() {
     const start = this.current();
@@ -1075,6 +1118,11 @@ var Parser = class {
       const declaration = this.parseVariableDeclaration();
       return { type: "ExportStatement", declaration, ...spanFrom(start, this.previous()) };
     }
+    if (this.checkKeyword("function")) {
+      const declaration = this.parseFunctionStatement();
+      if (declaration.type !== "FunctionDeclaration") this.error("An exported function needs a plain name: 'export function name()'");
+      return { type: "ExportStatement", declaration, ...spanFrom(start, this.previous()) };
+    }
     if (this.checkPunctuator("{")) {
       this.advance();
       const specifiers = [];
@@ -1098,15 +1146,15 @@ var Parser = class {
       const source = this.parseModuleSource();
       return { type: "ExportAllStatement", source, ...spanFrom(start, this.previous()) };
     }
-    this.error("Expected 'const', 'let', 'type', 'default', '{' or '*' after 'export'");
+    this.error("Expected 'const', 'let', 'function', 'type', 'default', '{' or '*' after 'export'");
   }
-  // `const x = ...` / `let x, y = ...` / `const function f() ... end`.
+  // `const x = ...` / `let x, y = ...`.
   // luaut has no `local` — `const` bindings are immutable, `let` mutable.
   parseVariableDeclaration() {
     const start = this.current();
     const kind = this.advance().value;
-    if (this.matchKeyword("function")) {
-      return this.parseFunctionDeclarationRest(start, kind);
+    if (this.checkKeyword("function")) {
+      this.error(`A function is declared as 'function name()'; '${kind}' does not apply to functions`);
     }
     const names = [this.parseBindingTarget(true)];
     while (this.matchPunctuator(",")) {
@@ -1120,31 +1168,6 @@ var Parser = class {
     }
     return { type: "VariableDeclaration", kind, names, init, ...spanFrom(start, this.previous()) };
   }
-  /** `const/let function` — `function` already consumed. Collects TS-style
-   *  overload signatures. */
-  parseFunctionDeclarationRest(start, kind) {
-    const name = this.parseIdentifier();
-    const signatures = [];
-    while (true) {
-      const head = this.parseFunctionHead();
-      if (this.isOverloadContinuation(name.name, kind)) {
-        signatures.push(this.headToSignature(head));
-        this.advance();
-        this.expectKeyword("function");
-        this.parseIdentifier();
-        continue;
-      }
-      const func = this.headToBody(head);
-      return {
-        type: "FunctionDeclaration",
-        kind,
-        name,
-        func,
-        signatures: signatures.length ? signatures : void 0,
-        ...spanFrom(start, this.previous())
-      };
-    }
-  }
   parseIfStatement() {
     const start = this.current();
     this.expectKeyword("if");
@@ -1234,7 +1257,9 @@ var Parser = class {
       ...spanFrom(start, this.previous())
     };
   }
-  parseFunctionDeclarationStatement() {
+  /** `function name() end` declares `name`; `function a.b() end` and
+   *  `function T:m() end` define a member. */
+  parseFunctionStatement() {
     const start = this.current();
     this.expectKeyword("function");
     const target = this.parseFunctionName();
@@ -1250,6 +1275,15 @@ var Parser = class {
         continue;
       }
       const func = this.headToBody(head);
+      if (simpleName !== void 0) {
+        return {
+          type: "FunctionDeclaration",
+          name: target.base,
+          func,
+          signatures: signatures.length ? signatures : void 0,
+          ...spanFrom(start, this.previous())
+        };
+      }
       if (isMethod) {
         func.params.unshift({ type: "FunctionParameter", name: "self", ...spanFrom(target, target) });
         func.isMethod = true;
@@ -1266,12 +1300,8 @@ var Parser = class {
   }
   /** After a bodyless function head, is the next token the start of another
    *  declaration for the same simple `name` (making the head an overload
-   *  signature rather than an implementation)? `kind` is set for a
-   *  `const/let function` group, undefined for a bare `function` group. */
-  isOverloadContinuation(name, kind) {
-    if (kind) {
-      return this.checkKeyword(kind) && this.peek(1).type === "Keyword" && this.peek(1).value === "function" && this.peek(2).type === "Identifier" && this.peek(2).value === name;
-    }
+   *  signature rather than an implementation)? */
+  isOverloadContinuation(name) {
     return this.checkKeyword("function") && this.peek(1).type === "Identifier" && this.peek(1).value === name;
   }
   parseFunctionName() {
@@ -1315,8 +1345,7 @@ var Parser = class {
   parseTypeAliasStatement() {
     const start = this.current();
     this.advance();
-    const nameTok = this.expectIdentifier();
-    const name = { type: "Identifier", name: nameTok.value, ...spanFrom(nameTok, nameTok) };
+    const name = this.parseTypeName();
     let generics = [];
     if (this.checkOperator("<")) {
       generics = this.parseGenericTypeParameterList();
@@ -2579,7 +2608,7 @@ var Analyzer = class {
     };
   }
   // ---------------- declaration / resolution primitives ----------------
-  declare(scope, name, kind, node, isConst = false) {
+  declare(scope, name, kind, node, isConst = false, declaredBy) {
     if (scope.declarations.has(name) && scope !== this.globalScope) {
       this.diagnostics.push({
         node,
@@ -2588,7 +2617,7 @@ var Analyzer = class {
       });
     }
     const id = this.nextId++;
-    this.bindings.set(id, { id, name, kind, declarationNode: node, references: [], isConst });
+    this.bindings.set(id, { id, name, kind, declarationNode: node, references: [], isConst, declaredBy });
     scope.declarations.set(name, id);
     return id;
   }
@@ -2622,6 +2651,19 @@ var Analyzer = class {
     const id = this.resolve(scope, identifier.name);
     this.bindingOf.set(identifier, id);
     this.bindings.get(id).references.push(identifier);
+    if (this.typeQueryDepth === 0) this.checkTypeOnly(id, identifier);
+  }
+  /** Inside `typeof x` in a type, where a type-only import may be named. */
+  typeQueryDepth = 0;
+  /** A name from `import type` used as a value. */
+  checkTypeOnly(id, node) {
+    const b = this.bindings.get(id);
+    if (b.declaredBy !== "type") return;
+    this.diagnostics.push({
+      node,
+      message: `'${b.name}' is imported with 'import type' and can only be used as a type`,
+      kind: "type-only"
+    });
   }
   /** For assignment-like targets (`x = ...`, `function foo() end`): if
    *  this resolved to a global with no declaration site yet, treat this
@@ -2638,14 +2680,34 @@ var Analyzer = class {
     this.bindingOf.set(identifier, id);
     this.bindings.get(id).references.push(identifier);
     this.recordPossibleGlobalDefinition(id, identifier);
+    this.checkTypeOnly(id, identifier);
     this.checkConstAssign(id, identifier);
   }
+  /** `Module.x = 1` through `import * as Module`: a module's exports belong
+   *  to it and are read-only, as in ES modules. Deeper writes (`Module.x.y`)
+   *  change the value, not the module, and are fine. */
+  checkModuleWrite(target) {
+    if (target.type !== "MemberExpression" && target.type !== "IndexExpression") return;
+    if (target.object.type !== "Identifier") return;
+    const id = this.bindingOf.get(target.object);
+    if (id !== void 0 && this.bindings.get(id).declaredBy === "namespace") {
+      this.moduleWriteError(target.object.name, target);
+    }
+  }
+  moduleWriteError(name, node) {
+    this.diagnostics.push({
+      node,
+      message: `Cannot assign to a member of '${name}' \u2014 a module's exports are read-only`,
+      kind: "const-assign"
+    });
+  }
   checkConstAssign(id, node) {
     const b = this.bindings.get(id);
+    if (b.declaredBy === "type") return;
     if (b.isConst) {
       this.diagnostics.push({
         node,
-        message: `Cannot assign to '${b.name}' \u2014 it is a const`,
+        message: `Cannot assign to '${b.name}' \u2014 it is ${b.declaredBy === "import" || b.declaredBy === "namespace" ? "an import" : b.declaredBy === "function" ? "a function" : "a const"}`,
         kind: "const-assign"
       });
     }
@@ -2686,6 +2748,7 @@ var Analyzer = class {
           const id = this.resolve(scope, t.name);
           this.bindingOf.set(t, id);
           this.recordPossibleGlobalDefinition(id, t);
+          this.checkTypeOnly(id, t);
           this.checkConstAssign(id, t);
           return;
         }
@@ -2729,7 +2792,7 @@ var Analyzer = class {
         return;
       }
       case "FunctionDeclaration": {
-        this.declare(scope, stmt.name.name, "local", stmt.name, stmt.kind === "const");
+        this.declare(scope, stmt.name.name, "local", stmt.name, true, "function");
         for (const signature of stmt.signatures ?? []) this.visitSignature(signature, scope);
         this.visitFunctionBody(stmt.func, scope);
         return;
@@ -2739,6 +2802,11 @@ var Analyzer = class {
           this.referenceAsAssignmentTarget(scope, stmt.target.base);
         } else {
           this.reference(scope, stmt.target.base);
+          const id = this.bindingOf.get(stmt.target.base);
+          const depth = stmt.target.path.length + (stmt.target.method ? 1 : 0);
+          if (id !== void 0 && depth === 1 && this.bindings.get(id).declaredBy === "namespace") {
+            this.moduleWriteError(stmt.target.base.name, stmt.target);
+          }
         }
         for (const signature of stmt.signatures ?? []) this.visitSignature(signature, scope);
         this.visitFunctionBody(stmt.func, scope, stmt.isMethod);
@@ -2753,6 +2821,7 @@ var Analyzer = class {
             this.assignPattern(scope, target);
           } else {
             this.visitExpression(target, scope);
+            this.checkModuleWrite(target);
           }
         }
         return;
@@ -2765,6 +2834,7 @@ var Analyzer = class {
           if (id !== void 0) this.checkConstAssign(id, stmt.target);
         } else {
           this.visitExpression(stmt.target, scope);
+          this.checkModuleWrite(stmt.target);
         }
         return;
       }
@@ -2818,16 +2888,23 @@ var Analyzer = class {
       case "DeclareStatement":
         this.visitType(stmt.valueType, scope);
         return;
+      case "DeclareClassStatement":
+        this.visitType(stmt.body, scope);
+        return;
       case "TypeAliasStatement":
       case "ExportTypeAliasStatement":
         this.visitType(stmt.definition, scope);
         return;
       case "ImportStatement": {
+        const typeOnly = stmt.isTypeOnly ? "type" : void 0;
         if (stmt.defaultImport) {
-          this.declare(scope, stmt.defaultImport.name, "local", stmt.defaultImport);
+          this.declare(scope, stmt.defaultImport.name, "local", stmt.defaultImport, true, typeOnly ?? "import");
+        }
+        if (stmt.namespaceImport) {
+          this.declare(scope, stmt.namespaceImport.name, "local", stmt.namespaceImport, true, typeOnly ?? "namespace");
         }
         for (const spec of stmt.specifiers) {
-          this.declare(scope, spec.local.name, "local", spec.local);
+          this.declare(scope, spec.local.name, "local", spec.local, true, typeOnly ?? "import");
         }
         return;
       }
@@ -2886,7 +2963,12 @@ var Analyzer = class {
         return;
       }
       if (value.type === "TypeofTypeNode") {
-        this.visitExpression(value.expression, scope);
+        this.typeQueryDepth++;
+        try {
+          this.visitExpression(value.expression, scope);
+        } finally {
+          this.typeQueryDepth--;
+        }
         return;
       }
       for (const key of Object.keys(value)) {
@@ -2991,6 +3073,9 @@ function analyzeScopes(program, options = {}) {
 }
 
 // src/ast/typeModel.ts
+function isClassType(t) {
+  return t.kind === "object" && t.class !== void 0;
+}
 function typeParam(name, constraint, isConst) {
   return { kind: "typeParam", name, constraint, isConst };
 }
@@ -3050,10 +3135,16 @@ function substitute(t, subst) {
     }
     case "function": {
       const inner = t.typeParams ? new Map([...subst].filter(([k]) => !t.typeParams.includes(k))) : subst;
+      let params = t.params.map((p) => ({ ...p, type: substitute(p.type, inner) }));
+      let varargs = t.varargs && substitute(t.varargs, inner);
+      if (varargs?.kind === "tuple" && varargs.isPack) {
+        params = [...params, ...varargs.elements.map((type) => ({ type }))];
+        varargs = void 0;
+      }
       return {
         kind: "function",
-        params: t.params.map((p) => ({ ...p, type: substitute(p.type, inner) })),
-        varargs: t.varargs && substitute(t.varargs, inner),
+        params,
+        varargs,
         returns: substitute(t.returns, inner),
         typeParams: t.typeParams,
         predicate: t.predicate && {
@@ -3133,7 +3224,8 @@ function unify(param, arg, vars, out) {
       }
       return;
     case "object":
-      if (arg.kind === "object") {
+      if (param.class) return;
+      if (arg.kind === "object" && !arg.class) {
         for (const [k, pv] of param.properties) {
           const av = arg.properties.get(k);
           if (av) unify(pv.type, av.type, vars, out);
@@ -3216,7 +3308,7 @@ function widen(t) {
     case "tuple":
       return tuple(t.elements.map(widen), t.isPack);
     case "object": {
-      if (t.frozen) return t;
+      if (t.frozen || t.class) return t;
       const entries = [];
       for (const [k, v] of t.properties) entries.push([k, { ...v, type: widen(v.type) }]);
       const w = objectType(entries, t.indexer && { key: t.indexer.key, value: widen(t.indexer.value) });
@@ -3243,6 +3335,10 @@ function isAssignable(rawA, rawB) {
   if (expandAlias) {
     if (a.kind === "genericRef" && b.kind !== "genericRef") a = expandAlias(a);
     else if (b.kind === "genericRef" && a.kind !== "genericRef") b = expandAlias(b);
+    else if (a.kind === "genericRef" && b.kind === "genericRef" && a.name !== b.name) {
+      a = expandAlias(a);
+      b = expandAlias(b);
+    }
     if (a === b) return true;
   }
   for (let i = 0; i < comparing.length; i += 2) {
@@ -3298,6 +3394,8 @@ 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 (a.class && (b.indexer || b.properties.size === 0)) return false;
     for (const [name, bp] of b.properties) {
       const ap = a.properties.get(name);
       if (!ap) {
@@ -3440,6 +3538,7 @@ function containsFreeTypeParam(t, seen, bound) {
     case "intersection":
       return t.types.some((m) => containsTypeParam(m, seen, bound));
     case "object":
+      if (t.class) return false;
       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;
@@ -3638,7 +3737,7 @@ function mergeObjectMembers(types) {
       return expanded !== void 0 && expanded !== t && collect(expanded);
     }
     if (t.kind === "intersection") return t.types.every(collect);
-    if (t.kind === "object") {
+    if (t.kind === "object" && !t.class) {
       objects.push(t);
       return true;
     }
@@ -3850,6 +3949,62 @@ function keepsLiterals(paramType) {
   const members = paramType.constraint.kind === "union" ? paramType.constraint.types : [paramType.constraint];
   return members.some((m) => m.kind === "literal");
 }
+var AliasMap = class extends Map {
+  pending = /* @__PURE__ */ new Map();
+  defer(name, resolve5) {
+    super.delete(name);
+    this.pending.set(name, resolve5);
+  }
+  get(name) {
+    const resolved = super.get(name);
+    if (resolved !== void 0) return resolved;
+    const resolve5 = this.pending.get(name);
+    if (!resolve5) return void 0;
+    this.pending.delete(name);
+    const type = resolve5();
+    super.set(name, type);
+    return type;
+  }
+  has(name) {
+    return super.has(name) || (this.pending?.has(name) ?? false);
+  }
+  set(name, type) {
+    this.pending?.delete(name);
+    return super.set(name, type);
+  }
+  delete(name) {
+    const deferred = this.pending?.delete(name) ?? false;
+    return super.delete(name) || deferred;
+  }
+  get size() {
+    return super.size + (this.pending?.size ?? 0);
+  }
+  keys() {
+    return [...super.keys(), ...this.pending?.keys() ?? []][Symbol.iterator]();
+  }
+  entries() {
+    return [...this.keys()].map((name) => [name, this.get(name)])[Symbol.iterator]();
+  }
+  values() {
+    return [...this.keys()].map((name) => this.get(name))[Symbol.iterator]();
+  }
+  forEach(callback, thisArg) {
+    for (const [name, type] of this.entries()) callback.call(thisArg, type, name, this);
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+var METAMETHODS = {
+  "+": "__add",
+  "-": "__sub",
+  "*": "__mul",
+  "/": "__div",
+  "//": "__idiv",
+  "%": "__mod",
+  "^": "__pow",
+  "..": "__concat"
+};
 function posKey(name, line, column) {
   return `${name}@${line}:${column}`;
 }
@@ -3870,9 +4025,12 @@ var TypeAnalyzer = class {
   expectedTypeOf = /* @__PURE__ */ new Map();
   /** Public: each alias resolved once (generic aliases keep their params as
    *  `typeParam` nodes in the body). */
-  aliases = /* @__PURE__ */ new Map();
+  aliases = new AliasMap();
   /** Uninstantiated alias definitions, for `Name<Args>` instantiation. */
   aliasDefs = /* @__PURE__ */ new Map();
+  /** See `resolveClass`. */
+  classTypes = /* @__PURE__ */ new WeakMap();
+  classMembers = /* @__PURE__ */ new WeakMap();
   /** Generic parameters currently in lexical scope (alias body / generic fn),
    *  with their `extends` constraints resolved. */
   typeParamScope = [];
@@ -3969,6 +4127,13 @@ var TypeAnalyzer = class {
       if (stmt.type !== "ImportStatement") continue;
       const exports2 = this.moduleFor(stmt.source.value);
       if (!exports2) continue;
+      if (stmt.namespaceImport) {
+        for (const [name, exported] of exports2.types) {
+          const qualified = `${stmt.namespaceImport.name}.${name}`;
+          this.importedTypes.set(qualified, exported);
+          this.aliases.set(qualified, exported.type);
+        }
+      }
       for (const s of stmt.specifiers) {
         const exported = exports2.types.get(s.imported.name);
         if (exported) {
@@ -3982,24 +4147,123 @@ var TypeAnalyzer = class {
     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 (stmt.type === "DeclareClassStatement") {
+        this.aliasDefs.set(stmt.name.name, { params: [], node: stmt.body, class: stmt });
+      }
     }
   }
-  /** Seed global types from `declare` statements. Repeating a name builds an
-   *  *overload set* (an intersection, in declaration order) rather than
-   *  replacing — which is how `typeof` gets one signature per result string. */
+  /** A non-generic definition's type. */
+  resolveDef(def) {
+    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
+   *  object — its own members included, which refer back to it. */
+  classType(stmt) {
+    return this.classTypes.get(stmt) ?? this.resolveClass(stmt);
+  }
+  /** A class's members are resolved the first time anyone asks for
+   *  `properties` — its own from its body, the inherited ones from its
+   *  superclass.
+   *
+   *  Both have to wait. A definitions file for a whole engine declares
+   *  thousands of classes that all refer to one another; resolving each body
+   *  as soon as the class is named would resolve every class on every
+   *  analysis, when a script touches a handful. And classes refer to one
+   *  another constantly — `Object.IsA` mentions a map of every class, each
+   *  of which extends `Object` — so while one class resolves, one it extends
+   *  may itself be half-resolved; copying its members then would miss some
+   *  for good. */
+  resolveClass(stmt) {
+    const name = stmt.name.name;
+    const { ancestors, cyclic } = this.classChain(stmt);
+    const superclass = !cyclic && ancestors.length > 1 ? this.aliasDefs.get(ancestors[1])?.class : void 0;
+    let own;
+    let resolvingOwn = false;
+    const ownMembers = () => {
+      if (own || resolvingOwn) return own;
+      resolvingOwn = true;
+      try {
+        own = this.resolveType(stmt.body);
+      } finally {
+        resolvingOwn = false;
+      }
+      return own;
+    };
+    let complete;
+    const members = () => {
+      if (complete) return complete;
+      const mine = ownMembers();
+      if (!mine) return void 0;
+      const base = superclass ? this.classMembers.get(this.classType(superclass))?.() : void 0;
+      if (superclass && !base) return void 0;
+      return complete = {
+        properties: new Map([...base?.properties ?? [], ...mine.properties]),
+        indexer: mine.indexer ?? base?.indexer
+      };
+    };
+    const type = { kind: "object", name, class: { name, superclass: superclass?.name.name, ancestors } };
+    Object.defineProperties(type, {
+      properties: { enumerable: true, get: () => members()?.properties ?? own?.properties ?? /* @__PURE__ */ new Map() },
+      indexer: { enumerable: true, get: () => members()?.indexer ?? own?.indexer }
+    });
+    this.classTypes.set(stmt, type);
+    this.classMembers.set(type, members);
+    if (this.program.body.statements.includes(stmt)) ownMembers();
+    return type;
+  }
+  /** `extends` must name a class, and the chain must end. */
+  checkClass(stmt) {
+    if (!stmt.superclass || !this.emitDiagnostics) return;
+    const base = stmt.superclass.base;
+    if (!this.aliasDefs.get(base)?.class) {
+      const known = this.aliasDefs.has(base) || this.importedTypes.has(base);
+      this.diagnostics.push({
+        node: stmt.superclass,
+        message: known ? `'${base}' is not a class; a class can only extend another class` : `Cannot find class '${base}'`
+      });
+    } else if (this.classChain(stmt).cyclic) {
+      this.diagnostics.push({ node: stmt.superclass, message: `'${stmt.name.name}' cannot extend itself` });
+    }
+  }
+  /** The class and the classes it extends, nearest first, read from the
+   *  declarations — no type has to be resolved to know them. The walk stops
+   *  at a superclass that is not a class. */
+  classChain(stmt) {
+    const ancestors = [stmt.name.name];
+    for (let cls = stmt; cls?.superclass; ) {
+      const base = cls.superclass.base;
+      if (ancestors.includes(base)) return { ancestors, cyclic: true };
+      cls = this.aliasDefs.get(base)?.class;
+      if (!cls) break;
+      ancestors.push(base);
+    }
+    return { ancestors, cyclic: false };
+  }
+  /** Seed global types from `declare` statements. Repeating a function name
+   *  builds an *overload set* (an intersection, in declaration order) rather
+   *  than replacing — which is how `typeof` gets one signature per result
+   *  string. Any other value is simply redeclared: a sourcemap's
+   *  `declare script: <this file's instance>` replaces the library's
+   *  `declare script: LuaSourceContainer`. */
   harvestDeclares(block) {
     for (const stmt of block.statements) {
       if (stmt.type !== "DeclareStatement") continue;
       const t = this.resolveType(stmt.valueType);
       const prev = this.libGlobalTypes.get(stmt.name);
-      this.libGlobalTypes.set(stmt.name, prev ? intersection([prev, t]) : t);
+      const overload = prev && stmt.valueType.type === "FunctionTypeNode" && (prev.kind === "function" || prev.kind === "intersection");
+      this.libGlobalTypes.set(stmt.name, overload ? intersection([prev, t]) : t);
     }
   }
   resolveAllAliases() {
     for (const [name, def] of this.aliasDefs) {
+      if (def.class && !this.program.body.statements.includes(def.class)) {
+        const cls = def.class;
+        this.aliases.defer(name, () => this.classType(cls));
+        continue;
+      }
       if (containsTypeQuery(def.node)) continue;
       this.withTypeParams(def.params, () => {
-        this.aliases.set(name, this.resolveType(def.node));
+        this.aliases.set(name, this.resolveDef(def));
       });
     }
   }
@@ -4009,7 +4273,7 @@ var TypeAnalyzer = class {
     for (const [name, def] of this.aliasDefs) {
       if (this.aliases.has(name)) continue;
       this.withTypeParams(def.params, () => {
-        this.aliases.set(name, this.resolveType(def.node));
+        this.aliases.set(name, this.resolveDef(def));
       });
     }
     return this.aliases;
@@ -4037,10 +4301,7 @@ var TypeAnalyzer = class {
   /** Instantiate a generic alias: `Box<number>` -> `{ value: number }`. */
   instantiateAlias(def, args) {
     if (this.instantiationDepth > 20) return unknownType;
-    const subst = /* @__PURE__ */ new Map();
-    def.params.forEach((p, i) => {
-      subst.set(p.name, args[i] ?? (p.default ? this.resolveType(p.default) : unknownType));
-    });
+    const subst = this.bindTypeArguments(def.params, args);
     this.instantiationDepth++;
     try {
       const body = this.withTypeParams(def.params, () => this.resolveType(def.node));
@@ -4049,6 +4310,34 @@ var TypeAnalyzer = class {
       this.instantiationDepth--;
     }
   }
+  /** Pair written type arguments with the parameters they instantiate. A
+   *  pack parameter (`T...`) takes every argument from its position on, as
+   *  one pack: `Signal<Instance, string>` binds `T` to `(Instance, string)`,
+   *  and `Signal<()>` to the empty pack. Left out, a parameter takes its
+   *  default (`T... = ...any` is `any`), or `unknown`. */
+  bindTypeArguments(params, args) {
+    const subst = /* @__PURE__ */ new Map();
+    params.forEach((p, i) => {
+      let arg = args[i];
+      if (p.isPack && i < args.length) {
+        const rest = args.slice(i);
+        const single = rest.length === 1 ? rest[0] : void 0;
+        arg = single && (single.kind === "tuple" && single.isPack || single.kind === "typeParam" || single.kind === "any") ? single : tuple([...rest], true);
+      }
+      subst.set(p.name, arg ?? (p.default ? this.resolveType(p.default) : unknownType));
+    });
+    return subst;
+  }
+  /** An imported type, with its type arguments applied. */
+  importedType(imported, typeArguments) {
+    if (!imported.params.length) return imported.type;
+    const subst = /* @__PURE__ */ new Map();
+    imported.params.forEach((name, i) => {
+      const arg = typeArguments[i];
+      subst.set(name, arg ? this.resolveType(arg) : unknownType);
+    });
+    return this.reduceType(substitute(imported.type, subst));
+  }
   // --------------------------------------------------------
   // TypeNode -> Type
   // --------------------------------------------------------
@@ -4099,17 +4388,17 @@ var TypeAnalyzer = class {
             });
           }
           const imported = this.importedTypes.get(node.base);
-          if (imported) {
-            if (!imported.params.length) return imported.type;
-            const subst = /* @__PURE__ */ new Map();
-            imported.params.forEach((name2, i) => {
-              const arg = node.typeArguments[i];
-              subst.set(name2, arg ? this.resolveType(arg) : unknownType);
-            });
-            return this.reduceType(substitute(imported.type, subst));
-          }
+          if (imported) return this.importedType(imported, node.typeArguments);
           const lib = this.options.libTypes?.[node.base];
           if (lib) return lib;
+        } else if (this.importedTypes.has(name)) {
+          return this.importedType(this.importedTypes.get(name), node.typeArguments);
+        } else if (this.aliasDefs.has(name)) {
+          return this.expand({
+            kind: "genericRef",
+            name,
+            typeArguments: node.typeArguments.map((a) => this.resolveType(a))
+          });
         }
         return {
           kind: "genericRef",
@@ -4236,6 +4525,7 @@ var TypeAnalyzer = class {
         return this.resolveType(node.typeAnnotation);
       case "TypePackNode": {
         if (node.types.length === 1 && !node.hasVarargs) return this.resolveType(node.types[0]);
+        if (!node.types.length && node.varargType) return this.resolveType(node.varargType);
         return tuple(node.types.map((t) => this.resolveType(t)), true);
       }
     }
@@ -4259,7 +4549,7 @@ var TypeAnalyzer = class {
     this.reduceDepth++;
     try {
       const result = this.reduceTypeInner(t);
-      this.reduceCache.set(t, result);
+      if (result.kind !== "keyof") this.reduceCache.set(t, result);
       return result;
     } finally {
       this.reduceDepth--;
@@ -4271,6 +4561,7 @@ var TypeAnalyzer = class {
         case "keyof": {
           const target = this.reduceType(t.target);
           if (containsTypeParam(target)) return { kind: "keyof", target };
+          if (target.kind === "genericRef" && this.resolvingAliases.has(target.name)) return t;
           return this.keysOf(target);
         }
         case "indexedAccess": {
@@ -4312,6 +4603,7 @@ var TypeAnalyzer = class {
             t.predicate
           );
         case "object": {
+          if (t.class) return t;
           const entries = [];
           for (const [k, v] of t.properties) entries.push([k, { ...v, type: this.reduceType(v.type) }]);
           const reduced = objectType(entries, t.indexer && {
@@ -4451,6 +4743,7 @@ var TypeAnalyzer = class {
           t.typeParams
         );
       case "object": {
+        if (t.class) return t;
         const entries = [];
         for (const [k, v] of t.properties) entries.push([k, { ...v, type: this.stripInfer(v.type, bindings) }]);
         return objectType(entries, t.indexer && {
@@ -4504,6 +4797,11 @@ var TypeAnalyzer = class {
   visitStatement(stmt, env) {
     switch (stmt.type) {
       case "VariableDeclaration": {
+        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);
         stmt.names.forEach((target, i) => {
           const inferred = valueTypes[i] ?? (stmt.init.length ? unknownType : nilType);
@@ -4564,6 +4862,16 @@ var TypeAnalyzer = class {
         return;
       }
       case "AssignmentStatement": {
+        stmt.targets.forEach((target, i) => {
+          const value = stmt.values[i];
+          if (!value) return;
+          if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+            this.applyContext(value, this.infer(target, env));
+          } else if (target.type === "Identifier") {
+            const id = this.bindingIdOf(target);
+            if (id !== void 0 && this.annotated.has(id)) this.applyContext(value, this.bindingType.get(id));
+          }
+        });
         const { types: valueTypes, sources } = this.valueList(stmt.values, env);
         stmt.targets.forEach((target, i) => {
           const vt = valueTypes[i] ?? unknownType;
@@ -4688,6 +4996,14 @@ var TypeAnalyzer = class {
         };
         if (resolving && !exports2) report(stmt.source, `Cannot find module '${specifier}'`);
         const usable = exports2 && !exports2.partial ? exports2 : void 0;
+        if (stmt.namespaceImport) {
+          const id = this.bindingIdByName(stmt.namespaceImport.name, stmt.namespaceImport);
+          if (id !== void 0) {
+            const members = [...usable?.values ?? []].map(([name, type]) => [name, { type, optional: false, readonly: true }]);
+            if (usable?.default) members.push(["default", { type: usable.default, optional: false, readonly: true }]);
+            this.bindingType.set(id, usable ? objectType(members) : anyType);
+          }
+        }
         if (stmt.defaultImport) {
           if (usable && usable.default === void 0) {
             report(stmt.defaultImport, `Module '${specifier}' has no default export`);
@@ -4708,6 +5024,9 @@ var TypeAnalyzer = class {
       case "BreakStatement":
         this.breakStates[this.breakStates.length - 1]?.push(forkEnv(env));
         return;
+      case "DeclareClassStatement":
+        this.checkClass(stmt);
+        return;
       case "ContinueStatement":
       case "TypeAliasStatement":
       case "ExportTypeAliasStatement":
@@ -4829,7 +5148,89 @@ var TypeAnalyzer = class {
     }
     if (p.pattern) return this.patternToType(p.pattern, env);
     if (p.default) return widen(this.infer(p.default, env));
-    return anyType;
+    return this.contextualParams.get(p) ?? anyType;
+  }
+  /** What a function expression's unannotated parameters are, from where
+   *  it is written — see `applyContext`. */
+  contextualParams = /* @__PURE__ */ new WeakMap();
+  /** `expected` is the type the surroundings want for `expr`. A function
+   *  expression written there takes its unannotated parameters' types from
+   *  it, as in TypeScript: `signal:Connect(function(player) ... end)` knows
+   *  `player` from `Connect`'s callback type. Anything else is inferred as
+   *  usual. */
+  applyContext(expr, expected) {
+    let e = expr;
+    while (e.type === "ParenthesizedExpression") e = e.expression;
+    if (!expected) return;
+    if (e.type === "ArrayExpression") return this.applyArrayContext(e, expected);
+    if (e.type === "TableExpression") return this.applyTableContext(e, expected);
+    if (e.type !== "FunctionExpression") return;
+    const members = expected.kind === "union" ? expected.types : [expected];
+    const signatures = members.flatMap((m) => this.overloadsOf(this.expand(m)));
+    if (!signatures.length) return;
+    e.func.params.forEach((p, k) => {
+      if (p.typeAnnotation || p.pattern || p.default) return;
+      const candidates = [];
+      for (const signature of signatures) {
+        const t2 = signature.params[k]?.type ?? signature.varargs;
+        if (t2) candidates.push(t2);
+      }
+      if (!candidates.length) return;
+      const t = union(candidates);
+      this.contextualParams.set(p, containsTypeParam(t) ? anyType : t);
+    });
+  }
+  /** What an array literal is expected to be: an empty one takes that type
+   *  outright — `let queue: thread[] = []` is a `thread[]`, as in TypeScript
+   *  — and the elements of any other get the element type as their own
+   *  context. */
+  contextualArrays = /* @__PURE__ */ new WeakMap();
+  applyArrayContext(e, expected) {
+    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);
+      return;
+    }
+    e.elements.forEach((element, i) => {
+      if (element.type === "SpreadElement") return;
+      const elementType = target.kind === "array" ? target.element : target.elements[i];
+      this.applyContext(element, elementType);
+    });
+  }
+  /** `{ list: [] }` where `{ list: thread[] }` is expected: each field's
+   *  value gets its property's type as context. */
+  applyTableContext(e, expected) {
+    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;
+      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));
+    }
+  }
+  /** The members of an expected type worth matching a literal against:
+   *  aliases seen through, `nil` left out. */
+  expectedMembers(expected) {
+    const t = this.expand(expected);
+    const members = t.kind === "union" ? t.types : [t];
+    return members.map((m) => this.expand(m)).filter((m) => !(m.kind === "primitive" && m.name === "nil"));
+  }
+  /** The parameter type each written argument lands on, across `fns`. */
+  expectedArguments(written, fns, selfOf) {
+    return written.map((_, 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;
+        if (param) candidates.push(param);
+      }
+      return candidates.length ? union(candidates) : void 0;
+    });
   }
   /** Synthesize a type from a destructuring pattern used without an
    *  annotation (`function f({ a, b = 1 })`). */
@@ -4881,7 +5282,8 @@ var TypeAnalyzer = class {
     f.params.forEach((p, i) => {
       const arg = argTypes[i];
       if (arg === void 0) return;
-      unify(p.type, keepsLiterals(p.type) ? arg : widen(arg), vars, subst);
+      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);
     });
     for (const name of f.typeParams ?? []) if (!subst.has(name)) subst.set(name, unknownType);
     return subst;
@@ -4942,12 +5344,13 @@ var TypeAnalyzer = class {
         return;
       }
       const t = value;
+      if (t.kind === "object" && t.class) return;
       if (t.kind === "typeParam" && typeof t.name === "string" && bounds.has(t.name) && t.constraint && !containsTypeParam(t.constraint)) {
         bounds.set(t.name, this.reduceType(t.constraint));
       }
       for (const child of Object.values(value)) walk(child);
     };
-    for (const p of f.params) walk(p.type);
+    for (const p of f.params) if (containsTypeParam(p.type)) walk(p.type);
     return f.params.map((p) => substitute(p.type, bounds));
   }
   /** Record what each written argument is expected to be — see
@@ -5286,7 +5689,7 @@ var TypeAnalyzer = class {
     this.expandCache.set(key, t);
     this.resolvingAliases.add(t.name);
     try {
-      const r = def.params.length ? this.instantiateAlias(def, t.typeArguments) : this.resolveType(def.node);
+      const r = def.params.length ? this.instantiateAlias(def, t.typeArguments) : this.resolveDef(def);
       const named = def.params.length === 0 && (r.kind === "object" || r.kind === "intersection") && !r.name ? { ...r, name: t.name } : r;
       this.expandCache.set(key, named);
       return named;
@@ -5391,8 +5794,9 @@ var TypeAnalyzer = class {
         return this.resolveType(expr.typeAnnotation);
       }
       case "SatisfiesExpression": {
-        const actual = this.infer(expr.expression, env);
         const declared = this.resolveType(expr.typeAnnotation);
+        this.applyContext(expr.expression, declared);
+        const actual = this.infer(expr.expression, env);
         if (this.emitDiagnostics && declared.kind !== "any" && !this.fitsAnnotation(expr.expression, declared, actual, env)) {
           this.diagnostics.push({
             node: expr,
@@ -5409,9 +5813,9 @@ var TypeAnalyzer = class {
           case "not":
             return booleanType;
           case "-":
-            return numberType;
+            return this.operatorResult(expr, "-", arg, void 0) ?? numberType;
           case "#":
-            return numberType;
+            return this.operatorResult(expr, "#", arg, void 0) ?? numberType;
         }
         return arg;
       }
@@ -5433,7 +5837,7 @@ var TypeAnalyzer = class {
         const r = this.infer(expr.right, env);
         switch (op) {
           case "..":
-            return stringType;
+            return this.operatorResult(expr, op, l, r) ?? stringType;
           case "==":
           case "~=":
           case "<":
@@ -5448,7 +5852,7 @@ var TypeAnalyzer = class {
           case "//":
           case "%":
           case "^":
-            return numberType;
+            return this.operatorResult(expr, op, l, r) ?? numberType;
         }
         return union([l, r]);
       }
@@ -5467,8 +5871,10 @@ var TypeAnalyzer = class {
       }
       case "CallExpression": {
         const callee = this.infer(expr.callee, env);
-        const argTypes = expr.arguments.map((a) => this.infer(a, env));
         const fns = this.overloadsOf(callee);
+        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);
@@ -5483,8 +5889,10 @@ var TypeAnalyzer = class {
       }
       case "MethodCallExpression": {
         const objType = this.infer(expr.object, env);
-        const argTypes = expr.arguments.map((a) => this.infer(a, env));
         const fns = this.overloadsOf(this.propertyType(objType, expr.method.name));
+        const expected = this.expectedArguments(expr.arguments, fns, (f) => this.takesSelf(f) ? 1 : 0);
+        expr.arguments.forEach((a, i) => this.applyContext(a, expected[i]));
+        const argTypes = expr.arguments.map((a) => this.infer(a, env));
         if (fns.length) {
           const withSelf = (f) => this.takesSelf(f) ? [objType, ...argTypes] : argTypes;
           const selfOf = (f) => this.takesSelf(f) ? 1 : 0;
@@ -5516,6 +5924,8 @@ var TypeAnalyzer = class {
     }
   }
   inferArray(expr, env, asConst) {
+    const contextual = this.contextualArrays.get(expr);
+    if (contextual && !asConst) return contextual;
     const elems = [];
     let hadSpread = false;
     for (const el of expr.elements) {
@@ -5876,6 +6286,35 @@ var TypeAnalyzer = class {
       this.selfType = saved;
     }
   }
+  /** What an operator on a value with metamethods gives: `a + b` calls
+   *  `__add` on `a`, or failing that on `b` with the operands swapped — the
+   *  order Luau tries them in. That is how `Vector3 + Vector3`, `CFrame *
+   *  Vector3` and `2 * vector` get their types from the declarations.
+   *  `undefined` when neither operand declares the metamethod; an operand
+   *  that declares it but accepts neither argument is reported. */
+  operatorResult(node, op, left, right) {
+    const name = right === void 0 ? op === "-" ? "__unm" : "__len" : METAMETHODS[op];
+    if (!name) return void 0;
+    const candidates = right === void 0 ? [[left, void 0]] : [[left, right], [right, left]];
+    let declared;
+    for (const [receiver, other] of candidates) {
+      const t = this.expand(receiver);
+      const method = t.kind === "object" ? t.properties.get(name) : void 0;
+      if (!method) continue;
+      declared ??= receiver;
+      const args = other === void 0 ? [receiver] : [receiver, other];
+      const picked = this.pickOverload(this.overloadsOf(method.type), args);
+      if (picked) return this.callReturn(picked, args);
+    }
+    if (declared && this.emitDiagnostics) {
+      this.diagnostics.push({
+        node,
+        message: right === void 0 ? `Operator '${op}' cannot be applied to type '${formatType(left)}'` : `Operator '${op}' cannot be applied to types '${formatType(left)}' and '${formatType(right)}'`
+      });
+      return anyType;
+    }
+    return void 0;
+  }
   /** Does this signature take the receiver as its first parameter?
    *
    *  Luau's `:` is sugar both ways: `function T:m(a)` declares
@@ -6140,13 +6579,13 @@ function resolveTypeLibraries(config, host = nodeHost) {
       else problems.push({ file: config.path, message: `'${entry}' has no ${ENTRY_FILE} (or 'luaut.types' in its package.json)`, ...entryPosition(config, entry) });
       continue;
     }
-    const names = entry.startsWith("@") || entry.includes("/") ? [entry] : [`@luaut/${entry}`, entry];
-    const found = names.map((name) => findPackage(name, config.directory, host)).find(Boolean);
+    const name = entry.startsWith("@luaut/") ? entry : `@luaut/${entry}`;
+    const found = findPackage(name, config.directory, host);
     if (found) addPackage(found.directory, found.file, /* @__PURE__ */ new Set());
     else {
       problems.push({
         file: config.path,
-        message: `Cannot find type library '${entry}'. Install it with: npm i -D ${names[0]}`,
+        message: `Cannot find type library '${name}'. Install it with: npm i -D ${name}`,
         ...entryPosition(config, entry)
       });
     }
@@ -6249,7 +6688,6 @@ function sourceMapTypes(text, path, options) {
   const lines = [];
   const aliasOfFile = /* @__PURE__ */ new Map();
   const used = /* @__PURE__ */ new Set();
-  const canOmit = options.classes.has("Omit");
   const aliasOfNode = /* @__PURE__ */ new Map();
   const aliasFor = (segments) => {
     const base = `SourceMap_${segments.map((s) => s.replace(/[^A-Za-z0-9_]/g, "_")).join("_")}`;
@@ -6265,7 +6703,7 @@ function sourceMapTypes(text, path, options) {
     const className = IDENTIFIER.test(node.className) && options.classes.has(node.className) ? node.className : "Instance";
     const taken = options.membersOf?.(className) ?? INSTANCE_MEMBERS;
     const members = [];
-    if (parent && canOmit) members.push(`Parent: ${parent}`);
+    if (parent) members.push(`Parent: ${parent}`);
     const named = /* @__PURE__ */ new Set();
     for (const child of node.children ?? []) {
       if (!isNode(child)) continue;
@@ -6274,8 +6712,7 @@ function sourceMapTypes(text, path, options) {
       named.add(child.name);
       members.push(`${child.name}: ${childAlias}`);
     }
-    const base = parent && canOmit ? `Omit<${className}, "Parent">` : className;
-    lines.push(`type ${alias} = ${members.length ? `${base} & { ${members.join(", ")} }` : base}`);
+    lines.push(`declare class ${alias} extends ${className} { ${members.join(", ")} }`);
     return alias;
   };
   const rootAlias = visit(root, [root.name], void 0);
@@ -6353,6 +6790,7 @@ var index_default = luautparser;
   getBinding,
   intersection,
   isAssignable,
+  isClassType,
   isGlobal,
   isPossiblyFalsy,
   isPossiblyTruthy,