@thigasdevelopment/luam 0.2.0 → 0.4.0

package/luam.mjs

@@ -212,7 +212,7 @@ var EXIT_DIAGNOSTICS = 1;
 var EXIT_USAGE = 2;
 
 // src/cli/usage.ts
-var VERSION = true ? "0.2.0" : "0.0.0-dev";
+var VERSION = true ? "0.4.0" : "0.0.0-dev";
 var USAGE = [
   "luam \u2014 the Luam compiler for Multi Theft Auto resources.",
   "",
@@ -279,7 +279,7 @@ function classify(raw) {
   return { value, kind: value.length > 0 && Number.isFinite(Number(value)) ? "number" : "string" };
 }
 function parseEnvFile(source) {
-  const entries = [];
+  const entries2 = [];
   const errors = [];
   source.split(/\r?\n/).forEach((raw, index) => {
     const trimmed = raw.trim();
@@ -293,9 +293,9 @@ function parseEnvFile(source) {
       return;
     }
     const { value, kind } = classify(match[2]);
-    entries.push({ key: match[1], value, kind, line: line2 });
+    entries2.push({ key: match[1], value, kind, line: line2 });
   });
-  return { entries, errors };
+  return { entries: entries2, errors };
 }
 function isSensitiveKey(key) {
   return SENSITIVE.test(key);
@@ -759,27 +759,27 @@ var PROCESS_GLOBAL = "process";
 var PROCESS_ENV = "process.env";
 var ENV_GLOBAL = "env";
 var VALUE_TYPES = { boolean: BOOLEAN, number: NUMBER, string: STRING };
-function envMembers(entries) {
+function envMembers(entries2) {
   const members = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
+  for (const entry of entries2) {
     members.set(entry.key, { name: entry.key, type: VALUE_TYPES[entry.kind] });
   }
   return [...members.values()].sort((left, right) => left.name.localeCompare(right.name));
 }
-function environmentDeclaration(entries, origin) {
-  const env = record(PROCESS_ENV, envMembers(entries), origin);
+function environmentDeclaration(entries2, origin) {
+  const env = record(PROCESS_ENV, envMembers(entries2), origin);
   const process2 = record(PROCESS_GLOBAL, [{ name: ENV_GLOBAL, type: env }], origin);
   return { name: PROCESS_GLOBAL, environment: "server", source: "project", type: process2 };
 }
-function envDeclaration(entries, origin) {
-  const env = record(ENV_GLOBAL, envMembers(entries), origin);
+function envDeclaration(entries2, origin) {
+  const env = record(ENV_GLOBAL, envMembers(entries2), origin);
   return { name: ENV_GLOBAL, environment: "server", source: "project", type: env };
 }
-function projectDeclarations(entries, origin) {
-  if (entries === null) {
+function projectDeclarations(entries2, origin) {
+  if (entries2 === null) {
     return EMPTY_PROJECT_DECLARATIONS;
   }
-  return { globals: [environmentDeclaration(entries, origin), envDeclaration(entries, origin)] };
+  return { globals: [environmentDeclaration(entries2, origin), envDeclaration(entries2, origin)] };
 }
 
 // ../compiler/src/checker/ambient.ts
@@ -792,9 +792,9 @@ function ambientFromRegistry(registry) {
     globals: registry.allGlobals()
   };
 }
-function withoutNames(entries, excluded) {
+function withoutNames(entries2, excluded) {
   const names = new Set(excluded.map((entry) => entry.name));
-  return entries.filter((entry) => !names.has(entry.name));
+  return entries2.filter((entry) => !names.has(entry.name));
 }
 function ownDeclarations(registry, ambient) {
   const all = ambientFromRegistry(registry);
@@ -916,6 +916,15 @@ function createNamed(name) {
 function createRecord(name, members, origin = null) {
   return { kind: "record", name, origin, members };
 }
+function renameRecord(type, name) {
+  return type.kind === "record" ? createRecord(name, type.members, type.origin) : type;
+}
+function createObjectType(members) {
+  const keys = [...members].map(
+    ([name, member]) => member.kind === "optional" ? `${name}?: ${typeToString(member.element)}` : `${name}: ${typeToString(member)}`
+  );
+  return createRecord(keys.length === 0 ? "{}" : `{ ${keys.join(", ")} }`, members);
+}
 function createFunction(parameters, returnType, minimumArguments2, isVariadic = false) {
   return { kind: "function", parameters, returnType, minimumArguments: minimumArguments2 ?? parameters.length, isVariadic };
 }
@@ -1022,6 +1031,21 @@ function isFunctionAssignable(source, target, options) {
   }
   return target.returnType.kind === "void" || isAssignable(source.returnType, target.returnType, options);
 }
+function isRecordAssignable(source, target, options) {
+  for (const [name, member] of target.members) {
+    const value = source.members.get(name);
+    if (value === void 0) {
+      if (member.kind !== "optional") {
+        return false;
+      }
+      continue;
+    }
+    if (!isAssignable(value, member, options)) {
+      return false;
+    }
+  }
+  return true;
+}
 function isAssignable(source, target, options = { allowNil: false }) {
   if (source.kind === "any" || target.kind === "any" || target.kind === "unknown") {
     return true;
@@ -1053,6 +1077,9 @@ function isAssignable(source, target, options = { allowNil: false }) {
   if (target.kind === "table") {
     return isTableLike(source) || source.kind === "record";
   }
+  if (target.kind === "record") {
+    return source.kind === "record" ? isRecordAssignable(source, target, options) : source.kind === "table";
+  }
   if (target.kind === "array") {
     return source.kind === "table" || source.kind === "array" && isAssignable(source.element, target.element, options);
   }
@@ -4831,6 +4858,14 @@ var DeclarationRegistry = class {
   lookupInterface(name) {
     return this.interfaces.get(name) ?? null;
   }
+  interfaceExtends(name, target, visited = /* @__PURE__ */ new Set()) {
+    const current = this.lookupInterface(name);
+    if (current === null || visited.has(name)) {
+      return false;
+    }
+    visited.add(name);
+    return current.superInterfaces.some((parent) => parent === target || this.interfaceExtends(parent, target, visited));
+  }
   declareEnum(info) {
     this.enums.set(info.name, info);
   }
@@ -4846,24 +4881,42 @@ var DeclarationRegistry = class {
   allEnums() {
     return [...this.enums.values()];
   }
-  collectMembers(className) {
+  collectInterfaceMembers(name, collected, visited) {
+    const current = this.lookupInterface(name);
+    if (current === null || visited.has(current.name)) {
+      return;
+    }
+    visited.add(current.name);
+    for (const [memberName, member] of current.members) {
+      if (!collected.has(memberName)) {
+        collected.set(memberName, member);
+      }
+    }
+    for (const parent of current.superInterfaces) {
+      this.collectInterfaceMembers(parent, collected, visited);
+    }
+  }
+  collectMembers(name) {
     const collected = /* @__PURE__ */ new Map();
     const visited = /* @__PURE__ */ new Set();
-    let current = this.lookupClass(className);
+    let current = this.lookupClass(name);
     while (current !== null && !visited.has(current.name)) {
-      for (const [name, member] of current.members) {
-        if (!collected.has(name)) {
-          collected.set(name, member);
+      for (const [name2, member] of current.members) {
+        if (!collected.has(name2)) {
+          collected.set(name2, member);
         }
       }
       visited.add(current.name);
       current = current.superClass === null ? null : this.lookupClass(current.superClass);
     }
+    if (current === null && this.lookupClass(name) === null) {
+      this.collectInterfaceMembers(name, collected, visited);
+    }
     return [...collected.values()];
   }
-  lookupMember(className, member) {
+  lookupMember(name, member) {
     const visited = /* @__PURE__ */ new Set();
-    let current = this.lookupClass(className);
+    let current = this.lookupClass(name);
     while (current !== null && !visited.has(current.name)) {
       const found = current.members.get(member);
       if (found !== void 0) {
@@ -4872,7 +4925,9 @@ var DeclarationRegistry = class {
       visited.add(current.name);
       current = current.superClass === null ? null : this.lookupClass(current.superClass);
     }
-    return null;
+    const collected = /* @__PURE__ */ new Map();
+    this.collectInterfaceMembers(name, collected, visited);
+    return collected.get(member) ?? null;
   }
 };
 
@@ -4987,6 +5042,7 @@ var CheckContext = class {
   methodStack = [];
   projectEnvironments = /* @__PURE__ */ new Map();
   ambientClasses = /* @__PURE__ */ new Set();
+  ambientInterfaces = /* @__PURE__ */ new Set();
   constructor(mode, environment, ambient = EMPTY_AMBIENT, project = EMPTY_PROJECT_DECLARATIONS, oop = false) {
     this.mode = mode;
     this.environment = environment;
@@ -5008,6 +5064,9 @@ var CheckContext = class {
   isAmbientClass(name) {
     return this.ambientClasses.has(name);
   }
+  isAmbientInterface(name) {
+    return this.ambientInterfaces.has(name);
+  }
   noteExternalReference(name, position2) {
     if (!this.externalReferences.has(name)) {
       this.externalReferences.set(name, position2);
@@ -5057,6 +5116,16 @@ var CheckContext = class {
     if (annotation.kind === "type-union") {
       return createUnion(annotation.options.map((option) => this.resolveAnnotation(option)));
     }
+    if (annotation.kind === "type-object") {
+      const members = /* @__PURE__ */ new Map();
+      for (const member of annotation.members) {
+        members.set(member.name, this.resolveAnnotation(member.annotation));
+      }
+      return createObjectType(members);
+    }
+    if (annotation.kind === "type-tuple") {
+      return createTuple(annotation.elements.map((element) => this.resolveAnnotation(element)));
+    }
     if (annotation.kind === "type-function") {
       const parameters = annotation.parameters.map((parameter) => this.resolveAnnotation(parameter));
       const optional = parameters.findIndex((parameter) => parameter.kind === "optional");
@@ -5088,6 +5157,7 @@ var CheckContext = class {
       this.binder.declareGlobal({ name: info.name, type: createNamed(info.name), isLocal: false, position: info.position });
     }
     for (const info of ambient.interfaces) {
+      this.ambientInterfaces.add(info.name);
       this.declarations.declareInterface(info);
     }
     for (const info of ambient.enums) {
@@ -5387,7 +5457,7 @@ function expandClassDecorators(context, statement, fieldTypes) {
   const occupied = new Map(statement.members.filter((member) => member.kind === "class-method").map((member) => [member.name, member.name]));
   const classDecorators = validateDecorators(context, statement.decorators, "class");
   for (const member of statement.members) {
-    if (member.kind === "class-method") {
+    if (member.kind === "class-method" || member.name === "constructor") {
       validateDecorators(context, member.decorators, "method");
       continue;
     }
@@ -5969,7 +6039,11 @@ function resolveNamedMember(context, name, expression) {
     return resolveMtaMember(context, name, expression.property, expression.position)?.type ?? ANY_TYPE;
   }
   const contract = context.declarations.lookupClass(name) === null ? context.declarations.lookupInterface(name) : null;
-  return contract === null ? null : checkInterfaceMember(context, name, contract.members, expression);
+  if (contract === null) {
+    return null;
+  }
+  const members = new Map(context.declarations.collectMembers(name).map((member2) => [member2.name, member2]));
+  return checkInterfaceMember(context, name, members, expression);
 }
 var NATIVE_CONSTRUCTOR = "new";
 function nativeConstructor(context, name) {
@@ -6334,6 +6408,10 @@ function registerMembers(context, info, statement) {
   return generated;
 }
 function checkMethodBody(context, info, member) {
+  const explicitSelf = member.parameters.find((parameter) => parameter.name === "self");
+  if (explicitSelf !== void 0) {
+    context.report("check-explicit-self-parameter", 'Class methods receive "self" automatically; remove it from the parameter list.', explicitSelf.position);
+  }
   context.pushClassMethod({ className: info.name, methodName: member.name });
   checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, createNamed(info.name));
   context.popClassMethod();
@@ -6360,7 +6438,7 @@ function checkInterfaces(context, info) {
       context.report("check-unknown-interface", `Class "${info.name}" implements "${name}", which is not defined.`, info.position);
       continue;
     }
-    for (const member of contract.members.values()) {
+    for (const member of context.declarations.collectMembers(contract.name)) {
       checkContract(context, info, name, member);
     }
   }
@@ -6418,11 +6496,46 @@ function checkInterfaceDeclaration(context, statement) {
     return;
   }
   const members = /* @__PURE__ */ new Map();
+  for (const name of new Set(statement.superInterfaces)) {
+    const parent = context.declarations.lookupInterface(name);
+    if (name === statement.name || context.declarations.interfaceExtends(name, statement.name)) {
+      context.report("check-interface-cycle", `Interface "${statement.name}" creates an inheritance cycle through "${name}".`, statement.position);
+    } else if (parent === null) {
+      context.noteExternalReference(name, statement.position);
+      context.report("check-unknown-interface", `Interface "${statement.name}" extends "${name}", which is not defined.`, statement.position);
+    } else if (context.isAmbientInterface(name)) {
+      context.noteExternalReference(name, statement.position);
+    }
+  }
+  if (new Set(statement.superInterfaces).size !== statement.superInterfaces.length) {
+    context.report("check-duplicate-interface-parent", `Interface "${statement.name}" extends the same interface more than once.`, statement.position);
+  }
   for (const member of statement.members) {
     const type = member.kind === "interface-field" ? context.resolveAnnotation(member.annotation) : buildFunctionType(context, member.parameters, member.returnAnnotation);
-    members.set(member.name, { name: member.name, type, isMethod: member.kind === "interface-method", position: member.position });
+    const info = { name: member.name, type, isMethod: member.kind === "interface-method", position: member.position };
+    if (members.has(member.name)) {
+      context.report("check-duplicate-interface-member", `Interface "${statement.name}" declares member "${member.name}" more than once.`, member.position);
+    } else {
+      members.set(member.name, info);
+    }
   }
-  context.declarations.declareInterface({ name: statement.name, members, position: statement.position });
+  const inherited = /* @__PURE__ */ new Map();
+  for (const parent of statement.superInterfaces) {
+    for (const member of context.declarations.collectMembers(parent)) {
+      const existing = members.get(member.name) ?? inherited.get(member.name);
+      if (existing !== void 0 && (existing.isMethod !== member.isMethod || typeToString(existing.type) !== typeToString(member.type))) {
+        context.report("check-conflicting-interface-member", `Interface "${statement.name}" inherits conflicting declarations of "${member.name}".`, statement.position);
+      } else if (existing === void 0) {
+        inherited.set(member.name, member);
+      }
+    }
+  }
+  context.declarations.declareInterface({
+    name: statement.name,
+    superInterfaces: statement.superInterfaces,
+    members,
+    position: statement.position
+  });
 }
 function checkEnumDeclaration(context, statement) {
   if (context.declarations.lookupEnum(statement.name) !== null) {
@@ -6582,6 +6695,23 @@ function checkReturn(context, statement) {
     }
     return;
   }
+  if (expected.kind === "tuple") {
+    if (valueTypes.length !== expected.elements.length) {
+      const message = `This function declares ${expected.elements.length} return values but returns ${valueTypes.length}.`;
+      context.report("check-return-mismatch", message, statement.position);
+      return;
+    }
+    valueTypes.forEach((type, index) => {
+      const value2 = statement.values[Math.min(index, statement.values.length - 1)];
+      context.expectAssignable(type, expected.elements[index] ?? ANY_TYPE, value2?.position ?? statement.position, `Return value ${index + 1}`);
+    });
+    return;
+  }
+  if (valueTypes.length > 1) {
+    const message = `This function declares one return value of type "${typeToString(expected)}" but returns ${valueTypes.length} values.`;
+    context.report("check-return-mismatch", message, statement.position);
+    return;
+  }
   const first = valueTypes[0];
   const value = statement.values[0];
   if (first === void 0 || value === void 0) {
@@ -6628,9 +6758,12 @@ function checkStatement(context, statement) {
       return checkNumericFor(context, statement);
     case "generic-for-statement":
       return checkGenericFor(context, statement);
-    case "type-alias-statement":
-      context.binder.declareAlias(statement.name, context.resolveAnnotation(statement.annotation));
+    case "type-alias-statement": {
+      const resolved = context.resolveAnnotation(statement.annotation);
+      const named2 = statement.annotation.kind === "type-object" ? renameRecord(resolved, statement.name) : resolved;
+      context.binder.declareAlias(statement.name, named2);
       return;
+    }
     case "declare-statement":
       return checkDeclareStatement(context, statement);
     case "class-declaration":
@@ -6988,22 +7121,22 @@ function emitMethod(state, className, member) {
   return withSymbol(state, `${className}:${member.name}`, () => emitFunctionBody(state, [self, ...member.parameters], member.body, `${member.name} = function`));
 }
 function emitMembers(state, statement) {
-  const entries = [];
+  const entries2 = [];
   state.indent += 1;
   for (const member of statement.members) {
     if (member.kind === "class-method") {
-      entries.push(indentLine(state, `${markSource(state, member.position.line, `${statement.name}:${member.name}`)}${emitMethod(state, statement.name, member)}`));
+      entries2.push(indentLine(state, `${markSource(state, member.position.line, `${statement.name}:${member.name}`)}${emitMethod(state, statement.name, member)}`));
       continue;
     }
     if (member.value !== null) {
-      entries.push(indentLine(state, `${markSource(state, member.position.line, statement.name)}${member.name} = ${emitExpression(state, member.value)}`));
+      entries2.push(indentLine(state, `${markSource(state, member.position.line, statement.name)}${member.name} = ${emitExpression(state, member.value)}`));
     }
   }
   for (const generated of state.generatedMembers.get(statement) ?? []) {
-    entries.push(indentLine(state, `${markSource(state, generated.position.line, `${statement.name}:${generated.name}`)}${emitMethod(state, statement.name, generated)}`));
+    entries2.push(indentLine(state, `${markSource(state, generated.position.line, `${statement.name}:${generated.name}`)}${emitMethod(state, statement.name, generated)}`));
   }
   state.indent -= 1;
-  return entries;
+  return entries2;
 }
 function emitClassHeader(statement) {
   const name = emitString(statement.name);
@@ -7012,11 +7145,11 @@ function emitClassHeader(statement) {
 function emitClassDeclaration(state, statement) {
   requireHelper(state, "class");
   const header = emitClassHeader(statement);
-  const entries = emitMembers(state, statement);
-  if (entries.length === 0) {
+  const entries2 = emitMembers(state, statement);
+  if (entries2.length === 0) {
     return `${header} {}`;
   }
-  return [`${header} {`, entries.join(",\n"), indentLine(state, "}")].join("\n");
+  return [`${header} {`, entries2.join(",\n"), indentLine(state, "}")].join("\n");
 }
 function emitEnumDeclaration(state, statement) {
   if (!state.references.has(statement.name)) {
@@ -7781,13 +7914,45 @@ function parseFunctionType(stream) {
   return { kind: "type-function", parameters, isVariadic, returnType, position: position2 };
 }
 function parseGroupedType(stream) {
-  stream.expect("punctuation", "(");
+  const position2 = stream.expect("punctuation", "(").position;
   const inner = parseTypeAnnotation(stream);
-  if (stream.check("punctuation", ",")) {
-    throw stream.error("A parenthesized type must contain a single type.", "parse-invalid-type");
+  if (!stream.match("punctuation", ",")) {
+    stream.expect("punctuation", ")");
+    return inner;
   }
+  const elements = [inner];
+  do {
+    elements.push(parseTypeAnnotation(stream));
+  } while (stream.match("punctuation", ","));
   stream.expect("punctuation", ")");
-  return inner;
+  return { kind: "type-tuple", elements, position: position2 };
+}
+function parseObjectMember(stream) {
+  const token = stream.expectName();
+  const annotation = parseNamedAnnotation(stream, "field");
+  if (annotation === null) {
+    throw stream.error(`Key "${token.value}" of an object type requires a type annotation.`, "parse-invalid-type");
+  }
+  return { name: token.value, annotation, position: token.position };
+}
+function parseObjectType(stream) {
+  const position2 = stream.expect("punctuation", "{").position;
+  const members = [];
+  const declared = /* @__PURE__ */ new Set();
+  while (!stream.check("punctuation", "}") && !stream.isEof()) {
+    if (stream.match("punctuation", ";") || stream.match("punctuation", ",")) {
+      continue;
+    }
+    const member = parseObjectMember(stream);
+    if (declared.has(member.name)) {
+      stream.report("parse-duplicate-key", `Object type key "${member.name}" is declared more than once.`, member.position);
+      continue;
+    }
+    declared.add(member.name);
+    members.push(member);
+  }
+  stream.expect("punctuation", "}");
+  return { kind: "type-object", members, position: position2 };
 }
 function parsePrimaryType(stream) {
   if (stream.check("keyword", "function")) {
@@ -7796,6 +7961,9 @@ function parsePrimaryType(stream) {
   if (stream.check("identifier", FUNCTION_TYPE)) {
     return parseFunctionType(stream);
   }
+  if (stream.check("punctuation", "{")) {
+    return parseObjectType(stream);
+  }
   return stream.check("punctuation", "(") ? parseGroupedType(stream) : parseTypeName(stream);
 }
 function parsePostfixType(stream) {
@@ -8125,16 +8293,24 @@ function parseForStatement(stream) {
 }
 
 // ../compiler/src/parser/recovery.ts
-function recoverInBlock(stream, error) {
+var BRACE_TERMINATORS = /* @__PURE__ */ new Set(["}"]);
+function isTerminator(stream, terminators) {
+  const token = stream.current();
+  if (token.kind !== "punctuation" && token.kind !== "keyword") {
+    return false;
+  }
+  return terminators.has(token.value);
+}
+function recoverInBlock(stream, error, terminators = BRACE_TERMINATORS) {
   stream.diagnostics.push(error.diagnostic);
   if (stream.isEof()) {
     return;
   }
   const start = stream.current();
-  while (!stream.isEof() && !stream.check("punctuation", "}") && stream.current().position.line === start.position.line) {
+  while (!stream.isEof() && !isTerminator(stream, terminators) && stream.current().position.line === start.position.line) {
     stream.next();
   }
-  if (!stream.isEof() && !stream.check("punctuation", "}") && stream.current().position.offset === start.position.offset) {
+  if (!stream.isEof() && !isTerminator(stream, terminators) && stream.current().position.offset === start.position.offset) {
     stream.next();
   }
 }
@@ -8244,7 +8420,10 @@ function isDeclarationStart(stream) {
   if (offset > 0 && token.value !== "class") {
     return false;
   }
-  return token.value === "class" ? isClassHeader(stream, offset) : stream.checkAhead(offset + 2, "punctuation", "{");
+  if (token.value === "class") {
+    return isClassHeader(stream, offset);
+  }
+  return token.value === "interface" ? stream.checkAhead(offset + 2, "punctuation", "{") || stream.checkAhead(offset + 2, "keyword", "extends") : stream.checkAhead(offset + 2, "punctuation", "{");
 }
 function skipDecoratorArguments(stream) {
   let depth = 0;
@@ -8271,6 +8450,21 @@ function parseDecorators(stream) {
   return decorators;
 }
 function parseClassMethod(stream, token, decorators) {
+  stream.expect("operator", "=");
+  const expression = parseFunctionExpression(stream);
+  return {
+    kind: "class-method",
+    name: token.value,
+    isConstructor: token.value === "constructor",
+    isSynthetic: false,
+    parameters: expression.parameters,
+    returnAnnotation: expression.returnAnnotation,
+    body: expression.body,
+    decorators,
+    position: token.position
+  };
+}
+function parseLegacyClassMethod(stream, token, decorators) {
   const parameters = parseParameters(stream);
   const returnAnnotation = parseOptionalAnnotation(stream);
   const body = parseBraceBlock(stream);
@@ -8293,6 +8487,9 @@ function parseClassMember(stream) {
   const decorators = parseDecorators(stream);
   const token = stream.expectName();
   if (stream.check("punctuation", "(")) {
+    return parseLegacyClassMethod(stream, token, decorators);
+  }
+  if (stream.check("operator", "=") && stream.checkAhead(1, "keyword", "function")) {
     return parseClassMethod(stream, token, decorators);
   }
   const annotation = parseFieldAnnotation(stream);
@@ -8348,7 +8545,13 @@ function parseInterfaceMember(stream) {
 function parseInterfaceDeclaration(stream) {
   const position2 = stream.next().position;
   const name = stream.expect("identifier").value;
+  const superInterfaces = [];
   const members = [];
+  if (stream.match("keyword", "extends")) {
+    do {
+      superInterfaces.push(stream.expect("identifier").value);
+    } while (stream.match("punctuation", ","));
+  }
   stream.expect("punctuation", "{");
   while (!stream.check("punctuation", "}") && !stream.isEof()) {
     if (stream.match("punctuation", ";") || stream.match("punctuation", ",")) {
@@ -8364,7 +8567,7 @@ function parseInterfaceDeclaration(stream) {
     }
   }
   stream.expect("punctuation", "}");
-  return { kind: "interface-declaration", name, members, position: position2 };
+  return { kind: "interface-declaration", name, superInterfaces, members, position: position2 };
 }
 function parseEnumDeclaration(stream) {
   const position2 = stream.next().position;
@@ -8564,14 +8767,14 @@ function parseStatement(stream) {
   }
   return parseExpressionStatement(stream);
 }
-function parseBlockStatement(stream) {
+function parseBlockStatement(stream, terminators = BRACE_TERMINATORS) {
   try {
     return parseStatement(stream);
   } catch (error) {
     if (!(error instanceof ParserError)) {
       throw error;
     }
-    recoverInBlock(stream, error);
+    recoverInBlock(stream, error, terminators);
     return null;
   }
 }
@@ -8604,7 +8807,14 @@ function parseBlock(stream, terminators) {
     if (stream.current().kind === "keyword" && stop.has(stream.current().value)) {
       return body;
     }
-    const statement = parseStatement(stream);
+    const offset = stream.current().position.offset;
+    const statement = parseBlockStatement(stream, stop);
+    if (statement === null) {
+      if (stream.current().position.offset === offset) {
+        return body;
+      }
+      continue;
+    }
     body.push(statement);
     if (statement.kind === "return-statement") {
       return body;
@@ -8751,7 +8961,7 @@ function classText(info) {
   return `class ${info.name}:${info.superClass ?? ""}:${[...info.interfaces].sort(compareText).join(",")}{${membersText(info.members)}}`;
 }
 function interfaceText(info) {
-  return `interface ${info.name}{${membersText(info.members)}}`;
+  return `interface ${info.name}:${[...info.superInterfaces].sort(compareText).join(",")}{${membersText(info.members)}}`;
 }
 function enumText(info) {
   return `enum ${info.name}{${info.members.join(",")}}`;
@@ -8809,8 +9019,8 @@ function attribute(name, value) {
 function textElement(name, value) {
   return `${INDENT2}<${name}>${escapeXml(value)}</${name}>`;
 }
-function section(text, entries) {
-  return entries.length === 0 ? [] : [`${INDENT2}<!-- ${text} -->`, ...entries];
+function section(text, entries2) {
+  return entries2.length === 0 ? [] : [`${INDENT2}<!-- ${text} -->`, ...entries2];
 }
 function infoElement(info) {
   const attributes = info.author === void 0 ? [] : [attribute("author", info.author)];
@@ -8949,16 +9159,16 @@ function createAmbientResolver(collected) {
   const visible = /* @__PURE__ */ new Map();
   const merged = /* @__PURE__ */ new Map();
   for (const environment of ALL_ENVIRONMENTS) {
-    const entries = collected.filter((entry) => canReference(environment, entry.environment) && !declaresNothing(entry.declarations));
-    visible.set(environment, entries);
-    merged.set(environment, mergeAmbient(entries.map((entry) => entry.declarations)));
+    const entries2 = collected.filter((entry) => canReference(environment, entry.environment) && !declaresNothing(entry.declarations));
+    visible.set(environment, entries2);
+    merged.set(environment, mergeAmbient(entries2.map((entry) => entry.declarations)));
   }
   return (entry) => {
     if (declaresNothing(entry.declarations)) {
       return merged.get(entry.environment) ?? EMPTY_AMBIENT;
     }
-    const entries = visible.get(entry.environment) ?? [];
-    return mergeAmbient(entries.filter((candidate) => candidate.path !== entry.path).map((candidate) => candidate.declarations));
+    const entries2 = visible.get(entry.environment) ?? [];
+    return mergeAmbient(entries2.filter((candidate) => candidate.path !== entry.path).map((candidate) => candidate.declarations));
   };
 }
 function compileModule(file, ambient, context) {
@@ -9245,12 +9455,12 @@ var MISSING_LOAD_ORDER = 'is listed in "loadOrder" but no source file or asset m
 function missingEntry(entry) {
   return { path: entry, diagnostic: createDiagnostic("project", "project-load-order-missing", `"${entry}" ${MISSING_LOAD_ORDER}`, FILE_START) };
 }
-function resolveLoadOrder(entries, scripts, assets) {
+function resolveLoadOrder(entries2, scripts, assets) {
   const byScript = new Map(scripts.map((script) => [normalizePath(script.source), script]));
   const byAsset = new Map(assets.map((asset) => [normalizePath(asset.source), asset]));
   const resolved = { scripts: [], assets: [], diagnostics: [] };
   const seen = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
+  for (const entry of entries2) {
     const path = normalizePath(entry).replace(/^\.\//, "");
     const script = byScript.get(path);
     const asset = byAsset.get(path);
@@ -9482,8 +9692,8 @@ function materialize(build, resource, includeMap) {
   const bundled = materializeBundles(resource, build.bundles, helperContent);
   return { ...build, scripts: bundled.scripts, map: includeMap ? bundled.map : null };
 }
-function diagnosticSources(files, entries) {
-  const paths = new Set(entries.map((entry) => entry.path));
+function diagnosticSources(files, entries2) {
+  const paths = new Set(entries2.map((entry) => entry.path));
   return new Map(files.filter((file) => paths.has(file.path)).map((file) => [file.path, file.source]));
 }
 function runCompile(root, config, options = {}) {
@@ -9644,13 +9854,13 @@ function isSearchable(name) {
   return !name.startsWith(".") && !SKIPPED_DIRECTORIES.has(name);
 }
 function collectResourceMaps(directory, found) {
-  let entries;
+  let entries2;
   try {
-    entries = readdirSync3(directory, { withFileTypes: true });
+    entries2 = readdirSync3(directory, { withFileTypes: true });
   } catch {
     return;
   }
-  for (const entry of entries) {
+  for (const entry of entries2) {
     const absolute = join3(directory, entry.name);
     if (entry.isDirectory()) {
       if (isSearchable(entry.name)) {
@@ -9995,9 +10205,9 @@ function pluralize(count, singular, plural = `${singular}s`) {
 var MAX_ENTRIES_PER_FILE = 10;
 var MAX_FILES = 10;
 var GUTTER_WIDTH = 6;
-function groupByFile(entries) {
+function groupByFile(entries2) {
   const groups = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
+  for (const entry of entries2) {
     const group = groups.get(entry.path);
     if (group === void 0) {
       groups.set(entry.path, [entry]);
@@ -10044,19 +10254,19 @@ function emit2(reporter, entry, block) {
   }
   reporter.rawWarn(block);
 }
-function reportGroup(reporter, path, entries, options) {
+function reportGroup(reporter, path, entries2, options) {
   const limit = options.maxPerFile ?? MAX_ENTRIES_PER_FILE;
   const source = options.sources.get(path);
   reporter.raw(reporter.style.paint("strong", path));
-  for (const entry of entries.slice(0, limit)) {
+  for (const entry of entries2.slice(0, limit)) {
     emit2(reporter, entry, entryBlock(reporter, entry, source));
   }
-  if (entries.length > limit) {
-    reporter.detail(`  ... and ${pluralize(entries.length - limit, "more diagnostic")} in this file.`);
+  if (entries2.length > limit) {
+    reporter.detail(`  ... and ${pluralize(entries2.length - limit, "more diagnostic")} in this file.`);
   }
 }
-function reportGroupedDiagnostics(reporter, entries, options) {
-  const groups = [...groupByFile(entries)];
+function reportGroupedDiagnostics(reporter, entries2, options) {
+  const groups = [...groupByFile(entries2)];
   const limit = options.maxFiles ?? MAX_FILES;
   for (const [path, group] of groups.slice(0, limit)) {
     reportGroup(reporter, path, group, options);
@@ -10072,9 +10282,9 @@ function formatFileDiagnostic(entry) {
   const location = `${path}:${diagnostic.position.line}:${diagnostic.position.column}`;
   return `${location} ${diagnostic.severity} ${diagnostic.code}: ${diagnostic.message}`;
 }
-function countFileDiagnostics(entries) {
-  const errors = entries.filter((entry) => entry.diagnostic.severity === "error").length;
-  return { errors, warnings: entries.length - errors };
+function countFileDiagnostics(entries2) {
+  const errors = entries2.filter((entry) => entry.diagnostic.severity === "error").length;
+  return { errors, warnings: entries2.length - errors };
 }
 function countCliDiagnostics(diagnostics) {
   const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
@@ -10090,8 +10300,8 @@ function reportCliDiagnostics(reporter, diagnostics) {
     reporter.warn(line2);
   }
 }
-function reportPlainFileDiagnostics(reporter, entries) {
-  for (const entry of entries) {
+function reportPlainFileDiagnostics(reporter, entries2) {
+  for (const entry of entries2) {
     const line2 = formatFileDiagnostic(entry);
     if (entry.diagnostic.severity === "error") {
       reporter.rawError(line2);
@@ -10100,12 +10310,12 @@ function reportPlainFileDiagnostics(reporter, entries) {
     reporter.rawWarn(line2);
   }
 }
-function reportFileDiagnostics(reporter, entries, sources) {
+function reportFileDiagnostics(reporter, entries2, sources) {
   if (!reporter.capability.interactive) {
-    reportPlainFileDiagnostics(reporter, entries);
+    reportPlainFileDiagnostics(reporter, entries2);
     return;
   }
-  reportGroupedDiagnostics(reporter, entries, { sources });
+  reportGroupedDiagnostics(reporter, entries2, { sources });
 }
 function formatCounts(counts) {
   return `${pluralize(counts.errors, "error")}, ${pluralize(counts.warnings, "warning")}`;
@@ -11002,11 +11212,11 @@ function readStringArray(source, field, diagnostics, scope = "") {
   if (!Array.isArray(value) || value.length === 0) {
     return report2(diagnostics, `${scope}${field}`, "a non-empty array of strings", value);
   }
-  const entries = value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
-  if (entries.length !== value.length) {
+  const entries2 = value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+  if (entries2.length !== value.length) {
     return report2(diagnostics, `${scope}${field}`, "a non-empty array of strings", value);
   }
-  return entries.map((entry) => entry.trim());
+  return entries2.map((entry) => entry.trim());
 }
 function readObject(source, field, diagnostics, scope = "") {
   const value = source[field];
@@ -11376,10 +11586,70 @@ function runTraceCommand(root, reporter, options) {
 }
 
 // src/editor/editor-service.ts
-import { spawnSync } from "node:child_process";
 import { mkdtempSync, rmSync, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
+
+// src/editor/editor-command.ts
+import { spawnSync } from "node:child_process";
+import { statSync as statSync4 } from "node:fs";
+import { extname, isAbsolute as isAbsolute7, join as join5 } from "node:path";
+var WINDOWS_SEPARATOR = ";";
+var DEFAULT_EXTENSIONS = ".COM;.EXE;.BAT;.CMD";
+var SHELL_EXTENSIONS = /* @__PURE__ */ new Set([".bat", ".cmd"]);
+var SPAWN_OPTIONS = { encoding: "utf8", shell: false, windowsHide: true, maxBuffer: 1024 * 1024 };
+function entries(value) {
+  return value.split(WINDOWS_SEPARATOR).map((entry) => entry.trim().replace(/^"|"$/gu, "")).filter((entry) => entry.length > 0);
+}
+function present(path) {
+  try {
+    return statSync4(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function failure(error) {
+  return { pid: 0, output: [null, "", ""], stdout: "", stderr: "", status: null, signal: null, error };
+}
+function resolveWindowsCommand(command) {
+  const extensions = entries(process.env.PATHEXT ?? DEFAULT_EXTENSIONS);
+  const named2 = extname(command).toLowerCase();
+  const suffixes = named2 !== "" && extensions.some((entry) => entry.toLowerCase() === named2) ? [""] : extensions;
+  const rooted = isAbsolute7(command) || command.includes("/") || command.includes("\\");
+  const directories = rooted ? [""] : entries(process.env.PATH ?? process.env.Path ?? "");
+  for (const directory of directories) {
+    for (const suffix of suffixes) {
+      const path = directory === "" ? `${command}${suffix}` : join5(directory, `${command}${suffix}`);
+      if (present(path)) {
+        return path;
+      }
+    }
+  }
+  return null;
+}
+function buildInvocation(executable, args) {
+  if (!SHELL_EXTENSIONS.has(extname(executable).toLowerCase())) {
+    return { file: executable, args: [...args], verbatim: false };
+  }
+  const line2 = [executable, ...args].map((token) => `"${token}"`).join(" ");
+  return { file: process.env.COMSPEC ?? "cmd.exe", args: ["/d", "/s", "/c", `"${line2}"`], verbatim: true };
+}
+function runEditorCommand(command, args) {
+  if (process.platform !== "win32") {
+    return spawnSync(command, [...args], SPAWN_OPTIONS);
+  }
+  const executable = resolveWindowsCommand(command);
+  if (executable === null) {
+    return failure(new Error(`The command ${command} was not found on PATH.`));
+  }
+  if ([executable, ...args].some((token) => token.includes('"'))) {
+    return failure(new Error(`The command ${command} received an argument that cannot be quoted safely.`));
+  }
+  const invocation = buildInvocation(executable, args);
+  return spawnSync(invocation.file, invocation.args, { ...SPAWN_OPTIONS, windowsVerbatimArguments: invocation.verbatim });
+}
+
+// src/editor/editor-service.ts
 var EXTENSION_ID = "thigasdevelopment.luam";
 var SUPPORTED_EDITORS = [
   { id: "vscode", name: "Visual Studio Code", command: "code" },
@@ -11390,11 +11660,8 @@ var SUPPORTED_EDITORS = [
 ];
 var MAX_VSIX_BYTES = 50 * 1024 * 1024;
 var RELEASE_URL = `https://github.com/ThigasDevelopment/luam/releases/download/v${VERSION}/luam-${VERSION}.vsix`;
-function run(command, args) {
-  return spawnSync(command, [...args], { encoding: "utf8", shell: false, windowsHide: true, maxBuffer: 1024 * 1024 });
-}
 function succeeded(result) {
-  return result.error === void 0 && result.status === 0;
+  return (result.error === void 0 || result.error === null) && result.status === 0;
 }
 function trustedReleaseHost(url) {
   const host = new URL(url).hostname.toLowerCase();
@@ -11419,11 +11686,11 @@ async function downloadRelease() {
   return bytes;
 }
 function installVsix(editor, bytes) {
-  const directory = mkdtempSync(join5(tmpdir(), "luam-"));
-  const path = join5(directory, `luam-${VERSION}.vsix`);
+  const directory = mkdtempSync(join6(tmpdir(), "luam-"));
+  const path = join6(directory, `luam-${VERSION}.vsix`);
   try {
     writeFileSync5(path, bytes, { flag: "wx" });
-    const result = run(editor.command, ["--install-extension", path, "--force"]);
+    const result = runEditorCommand(editor.command, ["--install-extension", path, "--force"]);
     return succeeded(result) ? { source: "release", error: null } : { source: null, error: "The editor rejected the release VSIX." };
   } finally {
     rmSync(directory, { recursive: true, force: true });
@@ -11432,13 +11699,13 @@ function installVsix(editor, bytes) {
 function createEditorService() {
   let release = null;
   return {
-    detect: () => SUPPORTED_EDITORS.filter((editor) => succeeded(run(editor.command, ["--version"]))),
+    detect: () => SUPPORTED_EDITORS.filter((editor) => succeeded(runEditorCommand(editor.command, ["--version"]))),
     hasExtension: (editor) => {
-      const result = run(editor.command, ["--list-extensions"]);
+      const result = runEditorCommand(editor.command, ["--list-extensions"]);
       return succeeded(result) && result.stdout.split(/\r?\n/u).some((entry) => entry.trim().toLowerCase() === EXTENSION_ID);
     },
     install: async (editor) => {
-      const marketplace = run(editor.command, ["--install-extension", EXTENSION_ID, "--force"]);
+      const marketplace = runEditorCommand(editor.command, ["--install-extension", EXTENSION_ID, "--force"]);
       if (succeeded(marketplace)) {
         return { source: "marketplace", error: null };
       }