@thigasdevelopment/luam 0.18.2 → 0.19.1

package/luam.mjs

@@ -4521,7 +4521,7 @@ function parseDecorators(stream) {
   }
   return decorators;
 }
-function parseClassMethod(stream, token, decorators) {
+function parseClassMethod(stream, token, decorators, isStatic) {
   stream.expect("operator", "=");
   const expression = parseFunctionExpression(stream);
   return {
@@ -4529,6 +4529,7 @@ function parseClassMethod(stream, token, decorators) {
     name: token.value,
     isConstructor: token.value === "constructor",
     isSynthetic: false,
+    isStatic,
     parameters: expression.parameters,
     returnAnnotation: expression.returnAnnotation,
     body: expression.body,
@@ -4536,7 +4537,7 @@ function parseClassMethod(stream, token, decorators) {
     position: token.position
   };
 }
-function parseBraceClassMethod(stream, token, decorators) {
+function parseBraceClassMethod(stream, token, decorators, isStatic) {
   const parameters = parseParameters(stream);
   const returnAnnotation = parseOptionalAnnotation(stream);
   const body = parseBraceBlock(stream);
@@ -4545,6 +4546,7 @@ function parseBraceClassMethod(stream, token, decorators) {
     name: token.value,
     isConstructor: token.value === "constructor",
     isSynthetic: false,
+    isStatic,
     parameters,
     returnAnnotation,
     body,
@@ -4563,20 +4565,35 @@ function expectClassFieldBoundary(stream, token) {
   }
   throw stream.error(`Expected a line break or separator after class member "${token.value}".`, "parse-unexpected-token");
 }
+var STATIC_MODIFIER = "static";
+function parseStaticModifier(stream) {
+  if (!stream.check("identifier", STATIC_MODIFIER)) {
+    return false;
+  }
+  const modifier = stream.current();
+  if (!stream.checkName(1) || stream.peek(1).position.line !== modifier.position.line) {
+    return false;
+  }
+  const checkpoint = stream.checkpoint();
+  stream.next();
+  stream.eraseToCurrent(checkpoint);
+  return true;
+}
 function parseClassMember(stream) {
   const decorators = parseDecorators(stream);
+  const isStatic = parseStaticModifier(stream);
   const token = stream.expectName();
   if (stream.check("punctuation", "(")) {
     stream.report("parse-class-method-form", `Write class member "${token.value}" as "${token.value} = function (...) ... end".`, token.position);
-    return parseBraceClassMethod(stream, token, decorators);
+    return parseBraceClassMethod(stream, token, decorators, isStatic);
   }
   if (stream.check("operator", "=") && stream.checkAhead(1, "keyword", "function")) {
-    return parseClassMethod(stream, token, decorators);
+    return parseClassMethod(stream, token, decorators, isStatic);
   }
   const annotation = parseFieldAnnotation(stream);
   const value = stream.match("operator", "=") ? parseExpression(stream) : null;
   expectClassFieldBoundary(stream, token);
-  return { kind: "class-field", name: token.value, annotation, value, decorators, position: token.position };
+  return { kind: "class-field", name: token.value, annotation, value, decorators, isStatic, position: token.position };
 }
 function parseClassModifiers(stream, declaration) {
   while (stream.check("keyword") && CLASS_MODIFIERS.has(stream.current().value)) {
@@ -6584,7 +6601,7 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/cli/version.ts
-var VERSION = true ? "0.18.2" : "0.0.0-dev";
+var VERSION = true ? "0.19.1" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -8455,8 +8472,8 @@ var MTA_AUDIO_CLIENT = {
   isSoundPaused: fn([named("Element")], BOOLEAN, 1),
   playSFX: fn([STRING, NUMBER, NUMBER, BOOLEAN], named("Element"), 3),
   playSFX3D: fn([STRING, NUMBER, NUMBER, NUMBER, NUMBER, NUMBER, BOOLEAN], named("Element"), 6),
-  playSound: fn([STRING, BOOLEAN, BOOLEAN], named("Element"), 1),
-  playSound3D: fn([STRING, NUMBER, NUMBER, NUMBER, BOOLEAN, BOOLEAN], named("Element"), 4),
+  playSound: fn([STRING, BOOLEAN, BOOLEAN], named("Sound"), 1),
+  playSound3D: fn([STRING, NUMBER, NUMBER, NUMBER, BOOLEAN, BOOLEAN], named("Sound3D"), 4),
   playSoundFrontEnd: fn([NUMBER], BOOLEAN, 1),
   setRadioChannel: fn([NUMBER], BOOLEAN, 1),
   setSoundEffectEnabled: fn(
@@ -8521,7 +8538,7 @@ var MTA_BLIP_CLIENT = {
 var MTA_BROWSER_CLIENT = {
   canBrowserNavigateBack: fn([named("Browser")], BOOLEAN, 1),
   canBrowserNavigateForward: fn([named("Browser")], BOOLEAN, 1),
-  createBrowser: fn([NUMBER, NUMBER, BOOLEAN, BOOLEAN], named("Element"), 3),
+  createBrowser: fn([NUMBER, NUMBER, BOOLEAN, BOOLEAN], named("Browser"), 3),
   executeBrowserJavascript: fn([named("Browser"), STRING], BOOLEAN, 2),
   focusBrowser: fn([named("Browser")], BOOLEAN, 1),
   getBrowserProperty: fn([named("Browser"), STRING], BOOLEAN, 2),
@@ -8611,10 +8628,10 @@ var MTA_DISCORD_CLIENT = {
 // ../mta-types/src/generated/api/mta-drawing-client.ts
 var MTA_DRAWING_CLIENT = {
   dxConvertPixels: fn([STRING, STRING, NUMBER], STRING, 2),
-  dxCreateFont: fn([STRING, NUMBER, BOOLEAN, STRING], named("Element"), 1),
-  dxCreateRenderTarget: fn([NUMBER, NUMBER, BOOLEAN], named("Element"), 2),
-  dxCreateScreenSource: fn([NUMBER, NUMBER], named("Element"), 2),
-  dxCreateShader: fn([STRING, NUMBER, NUMBER, BOOLEAN, STRING], tupleOf([named("Element"), STRING]), 1),
+  dxCreateFont: fn([STRING, NUMBER, BOOLEAN, STRING], named("DxFont"), 1),
+  dxCreateRenderTarget: fn([NUMBER, NUMBER, BOOLEAN], named("DxRenderTarget"), 2),
+  dxCreateScreenSource: fn([NUMBER, NUMBER], named("DxScreenSource"), 2),
+  dxCreateShader: fn([STRING, NUMBER, NUMBER, BOOLEAN, STRING], tupleOf([named("DxShader"), STRING]), 1),
   dxCreateTexture: fn(
     [
       STRING,
@@ -9232,22 +9249,22 @@ var MTA_GUI_CLIENT = {
   guiComboBoxSetOpen: fn([named("Element"), BOOLEAN], BOOLEAN, 2),
   guiComboBoxSetSelected: fn([named("Element"), NUMBER], BOOLEAN, 2),
   guiCreateBrowser: fn([NUMBER, NUMBER, NUMBER, NUMBER, BOOLEAN, BOOLEAN, BOOLEAN, named("GuiElement")], named("GuiBrowser"), 6),
-  guiCreateButton: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("Element"), 5),
-  guiCreateCheckBox: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, BOOLEAN, named("GuiElement")], named("Element"), 6),
-  guiCreateComboBox: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("Element"), 5),
-  guiCreateEdit: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("Element"), 5),
-  guiCreateFont: fn([STRING, NUMBER], named("Element"), 1),
-  guiCreateGridList: fn([NUMBER, NUMBER, NUMBER, NUMBER, BOOLEAN, named("GuiElement")], named("Element"), 4),
-  guiCreateLabel: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("Element"), 5),
+  guiCreateButton: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("GuiButton"), 5),
+  guiCreateCheckBox: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, BOOLEAN, named("GuiElement")], named("GuiCheckbox"), 6),
+  guiCreateComboBox: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("GuiCombobox"), 5),
+  guiCreateEdit: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("GuiEdit"), 5),
+  guiCreateFont: fn([STRING, NUMBER], named("GuiFont"), 1),
+  guiCreateGridList: fn([NUMBER, NUMBER, NUMBER, NUMBER, BOOLEAN, named("GuiElement")], named("GuiGridList"), 4),
+  guiCreateLabel: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("GuiLabel"), 5),
   guiCreateMemo: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("GuiMemo"), 5),
   guiCreateProgressBar: fn([NUMBER, NUMBER, NUMBER, NUMBER, BOOLEAN, named("GuiElement")], named("Element"), 4),
-  guiCreateRadioButton: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("Element"), 5),
+  guiCreateRadioButton: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("GuiRadioButton"), 5),
   guiCreateScrollBar: fn([NUMBER, NUMBER, NUMBER, NUMBER, BOOLEAN, BOOLEAN, named("GuiElement")], named("GuiElement"), 5),
   guiCreateScrollPane: fn([NUMBER, NUMBER, NUMBER, NUMBER, BOOLEAN, named("GuiElement")], named("Element"), 4),
-  guiCreateStaticImage: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("Element"), 5),
-  guiCreateTab: fn([STRING, named("GuiElement")], named("Element"), 2),
-  guiCreateTabPanel: fn([NUMBER, NUMBER, NUMBER, NUMBER, BOOLEAN, named("GuiElement")], named("Element"), 4),
-  guiCreateWindow: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN], named("Element"), 5),
+  guiCreateStaticImage: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("GuiElement")], named("GuiStaticImage"), 5),
+  guiCreateTab: fn([STRING, named("GuiElement")], named("GuiTab"), 2),
+  guiCreateTabPanel: fn([NUMBER, NUMBER, NUMBER, NUMBER, BOOLEAN, named("GuiElement")], named("GuiTabPanel"), 4),
+  guiCreateWindow: fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN], named("GuiWindow"), 5),
   guiDeleteTab: fn([named("Element"), named("Element")], BOOLEAN, 2),
   guiEditGetCaretIndex: fn([named("Element")], NUMBER, 1),
   guiEditGetMaxLength: fn([named("GuiEdit")], NUMBER, 1),
@@ -11590,7 +11607,7 @@ var MTA_OOP_1 = [
   ),
   oopClass(
     "DxFont",
-    null,
+    "Element",
     [
       oopMethod("getHeight", "client", "dxGetFontHeight", fn([NUMBER, ANY], NUMBER, 0)),
       oopMethod("getSize", "client", "dxGetTextSize", fn([STRING, NUMBER, NUMBER, NUMBER, ANY, BOOLEAN, BOOLEAN], tupleOf([NUMBER, NUMBER]), 1)),
@@ -11601,14 +11618,14 @@ var MTA_OOP_1 = [
   ),
   oopClass(
     "DxRenderTarget",
-    null,
+    "Element",
     [],
     [],
     oopConstructor("client", fn([NUMBER, NUMBER, BOOLEAN], named("DxRenderTarget"), 2), "dxCreateRenderTarget")
   ),
   oopClass(
     "DxScreenSource",
-    null,
+    "Element",
     [
       oopMethod("update", "client", "dxUpdateScreenSource", fn([BOOLEAN], BOOLEAN, 0))
     ],
@@ -11621,14 +11638,14 @@ var MTA_OOP_1 = [
 var MTA_OOP_2 = [
   oopClass(
     "DxShader",
-    null,
+    "Element",
     [],
     [],
     oopConstructor("client", fn([STRING, NUMBER, NUMBER, BOOLEAN, STRING], named("DxShader"), 1), "dxCreateShader")
   ),
   oopClass(
     "DxTexture",
-    null,
+    "Element",
     [
       oopMethod("getPixels", "client", "dxGetTexturePixels", fn([ANY, ANY, NUMBER, NUMBER, NUMBER, ANY], STRING, 1)),
       oopMethod("setEdge", "client", "dxSetTextureEdge", fn([STRING, NUMBER], BOOLEAN, 1)),
@@ -11917,7 +11934,7 @@ var MTA_OOP_3 = [
   ),
   oopClass(
     "GuiButton",
-    null,
+    "GuiElement",
     [],
     [],
     oopConstructor("client", fn([NUMBER, NUMBER, NUMBER, NUMBER, STRING, BOOLEAN, named("Element")], named("GuiButton"), 6), "guiCreateButton")
@@ -11974,7 +11991,7 @@ var MTA_OOP_3 = [
   ),
   oopClass(
     "GuiElement",
-    null,
+    "Element",
     [
       oopProperty("alpha", "client", "guiGetAlpha", NUMBER),
       oopMethod("blur", "client", "guiBlur", fn([], BOOLEAN, 0)),
@@ -12027,7 +12044,7 @@ var MTA_OOP_3 = [
   ),
   oopClass(
     "GuiFont",
-    null,
+    "Element",
     [],
     [],
     oopConstructor("client", fn([STRING, NUMBER], named("GuiFont"), 1), "guiCreateFont")
@@ -12115,7 +12132,7 @@ var MTA_OOP_3 = [
   ),
   oopClass(
     "GuiRadioButton",
-    null,
+    "GuiElement",
     [
       oopMethod("getSelected", "client", "guiRadioButtonGetSelected", fn([], BOOLEAN, 0)),
       oopProperty("selected", "client", "guiRadioButtonGetSelected", BOOLEAN),
@@ -12176,7 +12193,7 @@ var MTA_OOP_4 = [
   ),
   oopClass(
     "Light",
-    null,
+    "Element",
     [
       oopProperty("color", "client", "getLightColor", tupleOf([NUMBER, NUMBER, NUMBER])),
       oopProperty("direction", "client", "getLightDirection", tupleOf([NUMBER, NUMBER, NUMBER])),
@@ -13186,6 +13203,34 @@ var DeclarationRegistry = class {
     }
     return null;
   }
+  lookupStaticMember(name, member) {
+    const visited = /* @__PURE__ */ new Set();
+    let current = this.lookupClass(name);
+    while (current !== null && !visited.has(current.name)) {
+      const found = current.statics.get(member);
+      if (found !== void 0) {
+        return found;
+      }
+      visited.add(current.name);
+      current = current.superClass === null ? null : this.lookupClass(current.superClass);
+    }
+    return null;
+  }
+  collectStatics(name) {
+    const collected = /* @__PURE__ */ new Map();
+    const visited = /* @__PURE__ */ new Set();
+    let current = this.lookupClass(name);
+    while (current !== null && !visited.has(current.name)) {
+      for (const [member, info] of current.statics) {
+        if (!collected.has(member)) {
+          collected.set(member, info);
+        }
+      }
+      visited.add(current.name);
+      current = current.superClass === null ? null : this.lookupClass(current.superClass);
+    }
+    return [...collected.values()];
+  }
   lookupMember(name, member) {
     const visited = /* @__PURE__ */ new Set();
     const found = this.lookupClassMember(name, member, visited);
@@ -13217,7 +13262,7 @@ function buildRegistry() {
         procedural: member.procedural
       });
     }
-    registry.declareClass({ name: declaration.name, superClass: declaration.parent, interfaces: [], members, position: MTA_POSITION });
+    registry.declareClass({ name: declaration.name, superClass: declaration.parent, interfaces: [], members, statics: /* @__PURE__ */ new Map(), position: MTA_POSITION });
   }
   return registry;
 }
@@ -13296,13 +13341,13 @@ function chooseCandidate(source, candidates3) {
   return matching.length === 1 && best !== void 0 ? best : null;
 }
 function missingKeys(source, target) {
-  const missing = [];
+  const missing2 = [];
   for (const [name, member] of target.members) {
     if (member.kind !== "optional" && !source.members.has(name)) {
-      missing.push(`"${name}"`);
+      missing2.push(`"${name}"`);
     }
   }
-  return missing;
+  return missing2;
 }
 function missingKeyHint(source, target) {
   if (source.kind !== "record" || source.isLiteral !== true) {
@@ -13314,11 +13359,11 @@ function missingKeyHint(source, target) {
   if (candidate === null) {
     return "";
   }
-  const missing = missingKeys(source, candidate);
-  if (missing.length === 0) {
+  const missing2 = missingKeys(source, candidate);
+  if (missing2.length === 0) {
     return "";
   }
-  const label2 = missing.length === 1 ? `Key ${missing[0]} is` : `Keys ${missing.join(", ")} are`;
+  const label2 = missing2.length === 1 ? `Key ${missing2[0]} is` : `Keys ${missing2.join(", ")} are`;
   return ` ${label2} missing from "${typeToString(candidate)}".`;
 }
 
@@ -13424,6 +13469,7 @@ var CheckContext = class {
   externalReferences = /* @__PURE__ */ new Map();
   unknownTypes = /* @__PURE__ */ new Map();
   calledMembers = /* @__PURE__ */ new Set();
+  staticAccess = /* @__PURE__ */ new Set();
   typeParameters = /* @__PURE__ */ new Set();
   generatedMembers = /* @__PURE__ */ new Map();
   mode;
@@ -13458,17 +13504,24 @@ var CheckContext = class {
   pushNarrowing(facts) {
     this.narrowings.push(new Map(facts));
   }
+  get isNarrowed() {
+    return this.narrowings.length > 0;
+  }
   popNarrowing() {
     this.narrowings.pop();
   }
-  forgetNarrowing(name) {
+  forgetNarrowing(path) {
     for (const frame of this.narrowings) {
-      frame.delete(name);
+      for (const key of [...frame.keys()]) {
+        if (key === path || key.startsWith(`${path}.`) || path.startsWith(`${key}.`)) {
+          frame.delete(key);
+        }
+      }
     }
   }
-  narrowedType(name) {
+  narrowedType(path) {
     for (let index = this.narrowings.length - 1; index >= 0; index -= 1) {
-      const found = this.narrowings[index]?.get(name);
+      const found = this.narrowings[index]?.get(path);
       if (found !== void 0) {
         return found;
       }
@@ -13483,20 +13536,20 @@ var CheckContext = class {
     this.predeclared.delete(name);
     return info;
   }
-  isPredeclaredClass(name) {
-    return this.predeclared.has(name);
-  }
-  awaitsDeclaration(name) {
+  pendingDeclarationOf(name) {
     const seen = /* @__PURE__ */ new Set();
     let current = this.declarations.lookupClass(name);
     while (current !== null && !seen.has(current.name)) {
       if (this.predeclared.has(current.name)) {
-        return true;
+        return current.name;
       }
       seen.add(current.name);
       current = current.superClass === null ? null : this.declarations.lookupClass(current.superClass);
     }
-    return false;
+    return null;
+  }
+  awaitsDeclaration(name) {
+    return this.pendingDeclarationOf(name) !== null;
   }
   insideFunction() {
     return this.returnStack.length > 0;
@@ -14156,6 +14209,7 @@ function accessorMethod(field2, decorator, name) {
     name,
     isConstructor: false,
     isSynthetic: true,
+    isStatic: false,
     parameters: decorator === "Getter" ? [] : [value],
     returnAnnotation: decorator === "Getter" ? field2.annotation : voidAnnotation,
     body,
@@ -14164,7 +14218,7 @@ function accessorMethod(field2, decorator, name) {
   };
 }
 function generatedMethod(field2, name, parameters, returnAnnotation, kind, fields) {
-  return { kind: "class-method", name, isConstructor: false, isSynthetic: true, parameters, returnAnnotation, body: [], decorators: [], generated: { kind, fields }, position: field2.position };
+  return { kind: "class-method", name, isConstructor: false, isSynthetic: true, isStatic: false, parameters, returnAnnotation, body: [], decorators: [], generated: { kind, fields }, position: field2.position };
 }
 function typeName(name, node) {
   return { kind: "type-name", name, typeArguments: [], position: node.position };
@@ -14272,6 +14326,139 @@ function expandClassDecorators(context, statement, fieldTypes) {
   return generated;
 }
 
+// ../compiler/src/checker/access-path.ts
+function pathOf2(expression) {
+  if (expression.kind === "identifier") {
+    return expression.name;
+  }
+  if (expression.kind !== "member-expression") {
+    return null;
+  }
+  const object = pathOf2(expression.object);
+  return object === null ? null : `${object}.${expression.property}`;
+}
+function assignedPath(target) {
+  const direct = pathOf2(target);
+  if (direct !== null) {
+    return direct;
+  }
+  return target.kind === "member-expression" || target.kind === "index-expression" ? assignedPath(target.object) : null;
+}
+function pathType(context, expression) {
+  if (expression.kind === "identifier") {
+    return context.binder.lookup(expression.name)?.type ?? null;
+  }
+  return expression.kind === "member-expression" ? context.types.get(expression) ?? null : null;
+}
+function childExpressions2(expression) {
+  switch (expression.kind) {
+    case "member-expression":
+      return [expression.object];
+    case "index-expression":
+      return [expression.object, expression.index];
+    case "call-expression":
+      return [expression.callee, ...expression.args];
+    case "new-expression":
+      return expression.args;
+    case "table-expression":
+      return expression.fields.flatMap((field2) => field2.key === null ? [field2.value] : [field2.key, field2.value]);
+    case "binary-expression":
+      return [expression.left, expression.right];
+    case "unary-expression":
+      return [expression.operand];
+    case "group-expression":
+      return [expression.expression];
+    default:
+      return [];
+  }
+}
+function statementExpressions2(statement) {
+  switch (statement.kind) {
+    case "local-statement":
+    case "return-statement":
+      return statement.values;
+    case "assignment-statement":
+      return [...statement.targets, ...statement.values];
+    case "call-statement":
+      return [statement.expression];
+    case "while-statement":
+    case "repeat-statement":
+      return [statement.condition];
+    case "if-statement":
+      return statement.clauses.map((clause) => clause.condition);
+    case "numeric-for-statement":
+      return statement.step === null ? [statement.start, statement.limit] : [statement.start, statement.limit, statement.step];
+    case "generic-for-statement":
+      return statement.iterators;
+    case "class-declaration":
+      return statement.members.flatMap((member) => member.kind === "class-field" && member.value !== null ? [member.value] : []);
+    default:
+      return [];
+  }
+}
+function blockBodies(statement) {
+  switch (statement.kind) {
+    case "do-statement":
+    case "while-statement":
+    case "repeat-statement":
+    case "numeric-for-statement":
+    case "generic-for-statement":
+    case "function-declaration":
+      return [statement.body];
+    case "if-statement":
+      return [...statement.clauses.map((clause) => clause.body), ...statement.alternate === null ? [] : [statement.alternate]];
+    case "class-declaration":
+      return statement.members.filter((member) => member.kind === "class-method").map((member) => member.body);
+    default:
+      return [];
+  }
+}
+function collectExpressionPaths(expression, paths) {
+  if (expression.kind === "function-expression") {
+    collectPaths(expression.body, paths);
+  }
+  for (const child of childExpressions2(expression)) {
+    collectExpressionPaths(child, paths);
+  }
+}
+function addTargets(statement, paths) {
+  if (statement.kind === "assignment-statement") {
+    for (const target of statement.targets) {
+      const path = assignedPath(target);
+      if (path !== null) {
+        paths.add(path);
+      }
+    }
+  }
+  if (statement.kind === "local-statement") {
+    statement.declarations.forEach((declaration) => paths.add(declaration.name));
+  }
+}
+function collectPaths(body, paths) {
+  for (const statement of body) {
+    addTargets(statement, paths);
+    for (const expression of statementExpressions2(statement)) {
+      collectExpressionPaths(expression, paths);
+    }
+    for (const block of blockBodies(statement)) {
+      collectPaths(block, paths);
+    }
+  }
+}
+function assignedPaths(body) {
+  const paths = /* @__PURE__ */ new Set();
+  collectPaths(body, paths);
+  return paths;
+}
+function forgetAssignedPaths(context, body) {
+  if (!context.isNarrowed) {
+    return;
+  }
+  for (const path of assignedPaths(body)) {
+    context.forgetNarrowing(path);
+  }
+}
+
 // ../compiler/src/extensions/native-extensions.ts
 var NATIVE_EXTENSIONS = [
   { receiver: "table", property: "count", target: "table.size", style: "property", result: "number", helper: "table" },
@@ -17591,11 +17778,11 @@ var ELEMENT_TYPES = [
   { name: "Camera", parent: "Element" },
   { name: "ColShape", parent: "Element" },
   { name: "Connection", parent: null },
-  { name: "DxFont", parent: null },
-  { name: "DxRenderTarget", parent: null },
-  { name: "DxScreenSource", parent: null },
-  { name: "DxShader", parent: null },
-  { name: "DxTexture", parent: null },
+  { name: "DxFont", parent: "Element" },
+  { name: "DxRenderTarget", parent: "Element" },
+  { name: "DxScreenSource", parent: "Element" },
+  { name: "DxShader", parent: "Element" },
+  { name: "DxTexture", parent: "Element" },
   { name: "Effect", parent: "Element" },
   { name: "Element", parent: null },
   { name: "Engine", parent: null },
@@ -17604,21 +17791,21 @@ var ELEMENT_TYPES = [
   { name: "EngineTXD", parent: null },
   { name: "File", parent: null },
   { name: "GuiBrowser", parent: "GuiElement" },
-  { name: "GuiButton", parent: null },
+  { name: "GuiButton", parent: "GuiElement" },
   { name: "GuiCheckbox", parent: "GuiElement" },
   { name: "GuiCombobox", parent: "GuiElement" },
   { name: "GuiEdit", parent: "GuiElement" },
-  { name: "GuiElement", parent: null },
-  { name: "GuiFont", parent: null },
+  { name: "GuiElement", parent: "Element" },
+  { name: "GuiFont", parent: "Element" },
   { name: "GuiGridList", parent: "GuiElement" },
   { name: "GuiLabel", parent: "GuiElement" },
   { name: "GuiMemo", parent: "GuiElement" },
-  { name: "GuiRadioButton", parent: null },
+  { name: "GuiRadioButton", parent: "GuiElement" },
   { name: "GuiStaticImage", parent: "GuiElement" },
   { name: "GuiTab", parent: "GuiElement" },
   { name: "GuiTabPanel", parent: "GuiElement" },
   { name: "GuiWindow", parent: "GuiElement" },
-  { name: "Light", parent: null },
+  { name: "Light", parent: "Element" },
   { name: "Marker", parent: "Element" },
   { name: "Material", parent: "Element" },
   { name: "Object", parent: "Element" },
@@ -17774,6 +17961,28 @@ function checkInterfaceMember(context, name, members, expression) {
   context.report("check-unknown-member", `Interface "${name}" has no member "${expression.property}". Declared members: ${keys}.`, expression.position);
   return ANY_TYPE;
 }
+function isUserClassReference(context, name) {
+  const symbol = context.binder.lookup(name);
+  return symbol !== null && !symbol.isLocal && context.declarations.lookupClass(name) !== null;
+}
+function resolveStaticMember(context, className, expression) {
+  const member = context.declarations.lookupStaticMember(className, expression.property);
+  if (member !== null) {
+    if (member.deprecated === true) {
+      context.warn("check-deprecated-use", `Member "${expression.property}" is deprecated.`, expression.position);
+    }
+    context.staticAccess.add(expression);
+    return member.type;
+  }
+  if (context.awaitsDeclaration(className)) {
+    context.staticAccess.add(expression);
+    return ANY_TYPE;
+  }
+  const instance = context.declarations.lookupMember(className, expression.property);
+  const hint = instance === null ? "" : ` It is an instance member, so read it from a value of "${className}".`;
+  context.report("check-unknown-member", `Class "${className}" has no static member "${expression.property}".${hint}`, expression.position);
+  return ANY_TYPE;
+}
 function resolveNamedMember(context, name, expression) {
   const enumeration = context.declarations.lookupEnum(name);
   if (enumeration !== null) {
@@ -17789,6 +17998,12 @@ function resolveNamedMember(context, name, expression) {
   if (isMtaElement(context, name)) {
     return resolveMtaMember(context, name, expression.property, expression.position)?.type ?? ANY_TYPE;
   }
+  const staticMember = context.declarations.lookupStaticMember(name, expression.property);
+  if (staticMember !== null) {
+    const message = `"${expression.property}" is a static member of class "${name}". Read it as "${name}.${expression.property}".`;
+    context.report("check-static-receiver", message, expression.position);
+    return staticMember.type;
+  }
   if (context.awaitsDeclaration(name)) {
     return ANY_TYPE;
   }
@@ -17821,9 +18036,10 @@ function checkNewExpression(context, expression) {
     context.report("check-unknown-class", `Class "${expression.className}" is not defined.`, expression.position);
     return ANY_TYPE;
   }
-  if (context.isPredeclaredClass(expression.className) && !context.insideFunction()) {
-    const message = `Class "${expression.className}" is declared further down this file, so it does not exist yet at this point.`;
-    context.report("check-class-before-declaration", message, expression.position);
+  const pending = context.insideFunction() ? null : context.pendingDeclarationOf(expression.className);
+  if (pending !== null) {
+    const subject = pending === expression.className ? `Class "${pending}"` : `Class "${expression.className}" extends "${pending}", which`;
+    context.report("check-class-before-declaration", `${subject} is declared further down this file, so it does not exist yet at this point.`, expression.position);
   }
   const constructor = context.declarations.lookupMember(expression.className, "constructor");
   if (constructor !== null && constructor.type.kind === "function") {
@@ -17934,19 +18150,19 @@ function resolveUnionMember(context, type, expression) {
     return null;
   }
   const resolved2 = [];
-  const missing = [];
+  const missing2 = [];
   for (const option of type.options) {
     const member = memberOf(context, option, expression.property);
     if (member === null) {
-      missing.push(`"${typeToString(option)}"`);
+      missing2.push(`"${typeToString(option)}"`);
     } else {
       resolved2.push(member);
     }
   }
-  if (missing.length === 0) {
+  if (missing2.length === 0) {
     return createUnion(resolved2);
   }
-  const message = `"${expression.property}" is not a key of every member of "${typeToString(type)}". It is missing from ${missing.join(", ")}.`;
+  const message = `"${expression.property}" is not a key of every member of "${typeToString(type)}". It is missing from ${missing2.join(", ")}.`;
   context.report("check-unknown-union-key", message, expression.position);
   return ANY_TYPE;
 }
@@ -17962,18 +18178,19 @@ function literalValue(expression) {
   return expression.kind === "number-literal" ? createNumberLiteral(expression.value) : null;
 }
 function discriminantTest(left, right) {
-  if (left.kind !== "member-expression" || left.object.kind !== "identifier") {
+  if (left.kind !== "member-expression") {
     return null;
   }
+  const path = pathOf2(left.object);
   const value = literalValue(right);
-  return value === null ? null : { name: left.object.name, property: left.property, value };
+  return path === null || value === null ? null : { path, subject: left.object, property: left.property, value };
 }
-function subjectType(context, name) {
-  const type = context.narrowedType(name) ?? context.binder.lookup(name)?.type ?? null;
+function subjectType(context, test) {
+  const type = context.narrowedType(test.path) ?? pathType(context, test.subject);
   return type === null ? null : withoutNil(type);
 }
 function filterOptions(context, test, keep) {
-  const subject = subjectType(context, test.name);
+  const subject = subjectType(context, test);
   if (subject === null || subject.kind !== "union") {
     return null;
   }
@@ -17995,7 +18212,7 @@ function discriminantFact(context, left, right, keep) {
     return null;
   }
   const narrowed = filterOptions(context, test, keep);
-  return narrowed === null ? null : [test.name, narrowed];
+  return narrowed === null ? null : [test.path, narrowed];
 }
 
 // ../compiler/src/checker/narrowing.ts
@@ -18010,38 +18227,42 @@ var GUARD_TYPES = {
   thread: THREAD_TYPE,
   userdata: USERDATA_TYPE
 };
-function declaredType(context, name) {
-  return context.binder.lookup(name)?.type ?? null;
-}
-function guardedName(expression) {
+function guardedPath(expression) {
   if (expression.kind !== "call-expression" || expression.callee.kind !== "identifier" || expression.callee.name !== GUARD_FUNCTION) {
     return null;
   }
   const [argument] = expression.args;
-  return argument !== void 0 && argument.kind === "identifier" ? argument.name : null;
+  return argument === void 0 ? null : pathOf2(argument);
 }
 function guardFact(left, right) {
-  const name = guardedName(left);
+  const path = guardedPath(left);
   const value = right.kind === "string-literal" ? GUARD_TYPES[right.value] : void 0;
-  return name === null || value === void 0 ? null : [name, value];
+  return path === null || value === void 0 ? null : [path, value];
 }
 function nilComparison(left, right) {
-  if (left.kind === "identifier" && right.kind === "nil-literal") {
-    return left.name;
+  if (right.kind === "nil-literal" && pathOf2(left) !== null) {
+    return left;
+  }
+  return left.kind === "nil-literal" && pathOf2(right) !== null ? right : null;
+}
+function present2(context, expression, facts) {
+  const path = pathOf2(expression);
+  const declared = path === null ? null : pathType(context, expression);
+  if (path !== null && declared !== null) {
+    facts.set(path, withoutNil(declared));
   }
-  return right.kind === "identifier" && left.kind === "nil-literal" ? right.name : null;
 }
-function present2(context, name, facts) {
-  const declared = declaredType(context, name);
-  if (declared !== null) {
-    facts.set(name, withoutNil(declared));
+function missing(expression, facts) {
+  const path = pathOf2(expression);
+  if (path !== null) {
+    facts.set(path, NIL_TYPE);
   }
 }
 function mergeAlternatives(left, right, facts) {
-  for (const [name, type] of left) {
-    const other = right.get(name);
+  for (const [path, type] of left) {
+    const other = right.get(path);
     if (other !== void 0) {
-      facts.set(name, createUnion([type, other]));
+      facts.set(path, createUnion([type, other]));
     }
   }
 }
@@ -18056,8 +18277,8 @@ function collectFacts(context, expression, facts) {
     collectFacts(context, expression.expression, facts);
     return;
   }
-  if (expression.kind === "identifier") {
-    present2(context, expression.name, facts);
+  if (expression.kind === "identifier" || expression.kind === "member-expression") {
+    present2(context, expression, facts);
     return;
   }
   if (expression.kind !== "binary-expression") {
@@ -18074,20 +18295,20 @@ function collectFacts(context, expression, facts) {
   }
   if (expression.operator === "==") {
     const guard = guardFact(expression.left, expression.right) ?? guardFact(expression.right, expression.left);
-    const missing = nilComparison(expression.left, expression.right);
+    const absent = nilComparison(expression.left, expression.right);
     if (guard !== null) {
       facts.set(guard[0], guard[1]);
-    } else if (missing !== null) {
-      facts.set(missing, NIL_TYPE);
+    } else if (absent !== null) {
+      missing(absent, facts);
     } else {
       applyDiscriminant(context, expression.left, expression.right, true, facts);
     }
     return;
   }
   if (expression.operator === "~=") {
-    const name = nilComparison(expression.left, expression.right);
-    if (name !== null) {
-      present2(context, name, facts);
+    const tested = nilComparison(expression.left, expression.right);
+    if (tested !== null) {
+      present2(context, tested, facts);
     } else {
       applyDiscriminant(context, expression.left, expression.right, false, facts);
     }
@@ -18121,15 +18342,15 @@ function guardFacts(context, statement) {
 function negatedFacts(context, condition) {
   const facts = /* @__PURE__ */ new Map();
   if (condition.kind === "binary-expression" && condition.operator === "or") {
-    for (const [name, type] of [...negatedFacts(context, condition.left), ...negatedFacts(context, condition.right)]) {
-      facts.set(name, type);
+    for (const [path, type] of [...negatedFacts(context, condition.left), ...negatedFacts(context, condition.right)]) {
+      facts.set(path, type);
     }
     return facts;
   }
   if (condition.kind === "binary-expression" && condition.operator === "==") {
-    const name = nilComparison(condition.left, condition.right);
-    if (name !== null) {
-      present2(context, name, facts);
+    const tested = nilComparison(condition.left, condition.right);
+    if (tested !== null) {
+      present2(context, tested, facts);
     } else {
       applyDiscriminant(context, condition.left, condition.right, false, facts);
     }
@@ -18137,8 +18358,8 @@ function negatedFacts(context, condition) {
   if (condition.kind === "binary-expression" && condition.operator === "~=") {
     applyDiscriminant(context, condition.left, condition.right, true, facts);
   }
-  if (condition.kind === "unary-expression" && condition.operator === "not" && condition.operand.kind === "identifier") {
-    present2(context, condition.operand.name, facts);
+  if (condition.kind === "unary-expression" && condition.operator === "not") {
+    present2(context, condition.operand, facts);
   }
   return facts;
 }
@@ -18174,6 +18395,7 @@ function checkNumericFor(context, statement) {
       context.report("check-invalid-operand", `Numeric "for" expects "number" but received "${typeToString(type)}".`, bound.position);
     }
   }
+  forgetAssignedPaths(context, statement.body);
   context.binder.pushScope();
   context.binder.declare({ name: statement.variable.name, type: NUMBER_TYPE, isLocal: true, position: statement.variable.position, origin: "local" });
   checkStatements(context, statement.body);
@@ -18197,6 +18419,7 @@ function iteratedTypes(context, iterators) {
 function checkGenericFor(context, statement) {
   statement.iterators.forEach((iterator) => checkExpression(context, iterator));
   const iterated = iteratedTypes(context, statement.iterators);
+  forgetAssignedPaths(context, statement.body);
   context.binder.pushScope();
   statement.variables.forEach((variable, index) => {
     const inferred = iterated[index] ?? ANY_TYPE;
@@ -18269,6 +18492,7 @@ function buildFunctionType(context, parameters, returnAnnotation, contextual = n
   return createFunction(types, context.resolveAnnotation(returnAnnotation), minimumArguments(context, parameters), isVariadic);
 }
 function checkFunctionBody(context, parameters, returnAnnotation, body, signature, selfType) {
+  forgetAssignedPaths(context, body);
   context.binder.pushScope();
   context.pushReturnType(returnAnnotation === null ? null : context.resolveAnnotation(returnAnnotation));
   if (selfType !== null) {
@@ -18327,6 +18551,10 @@ function checkCompoundOperand(context, operator, type, position2) {
 function checkAssignment(context, statement) {
   const valueTypes = checkValueList(context, statement.values);
   statement.targets.forEach((target, index) => {
+    const assigned = assignedPath(target);
+    if (assigned !== null) {
+      context.forgetNarrowing(assigned);
+    }
     const targetType = checkExpression(context, target);
     const valueType = valueTypes[index] ?? NIL_TYPE;
     const value = valueAt(statement.values, valueTypes, index);
@@ -18355,9 +18583,6 @@ function checkAssignment(context, statement) {
     if (value !== void 0) {
       context.expectAssignable(valueType, declared, value.position, "Assignment");
     }
-    if (target.kind === "identifier") {
-      context.forgetNarrowing(target.name);
-    }
   });
 }
 function checkFunctionDeclaration(context, statement) {
@@ -18441,8 +18666,10 @@ function checkStatement(context, statement) {
       return checkBlock(context, statement.body);
     case "while-statement":
       checkExpression(context, statement.condition);
+      forgetAssignedPaths(context, statement.body);
       return checkBlock(context, statement.body);
     case "repeat-statement":
+      forgetAssignedPaths(context, statement.body);
       checkBlock(context, statement.body);
       checkExpression(context, statement.condition);
       return;
@@ -18501,20 +18728,12 @@ function parseInterpolation(segment) {
 function collectInterpolations(segments) {
   return segments.filter((segment) => segment.kind === "interpolation").map(parseInterpolation);
 }
-function collectTemplateRoots(segments) {
-  const roots = [];
-  for (const interpolation of collectInterpolations(segments)) {
-    if (interpolation.root.length > 0 && !roots.includes(interpolation.root)) {
-      roots.push(interpolation.root);
-    }
-  }
-  return roots;
-}
 function templateLiteralText(segments) {
   return segments.map((segment) => segment.kind === "text" ? segment.value : `\${${segment.value}}`).join("");
 }
 
 // ../compiler/src/checker/expressions.ts
+var NAME_PATH_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/;
 var EXTENSION_RESULTS = {
   boolean: BOOLEAN_TYPE,
   number: NUMBER_TYPE,
@@ -18528,7 +18747,20 @@ function isNativeConstruction(context, expression) {
   }
   return nativeConstructor(context, object.name) !== null;
 }
+function narrowedMember(context, expression) {
+  const path = pathOf2(expression);
+  return path === null ? null : context.narrowedType(path);
+}
 function checkMember(context, expression) {
+  const narrowed = narrowedMember(context, expression);
+  if (narrowed !== null) {
+    checkExpression(context, expression.object);
+    return context.record(expression, narrowed);
+  }
+  if (expression.object.kind === "identifier" && isUserClassReference(context, expression.object.name)) {
+    context.references.add(expression.object.name);
+    return context.record(expression, resolveStaticMember(context, expression.object.name, expression));
+  }
   if (expression.object.kind === "identifier" && isMtaClassReference(context, expression.object.name)) {
     context.references.add(expression.object.name);
     return context.record(expression, resolveMtaStaticMember(context, expression.object.name, expression.property, expression.position)?.type ?? ANY_TYPE);
@@ -18652,6 +18884,13 @@ function checkCall(context, expression) {
     }
     return context.record(expression, checkSignature(context, expression.args, constructor, expression.position));
   }
+  if (expression.method !== null && expression.callee.kind === "identifier" && isUserClassReference(context, expression.callee.name)) {
+    const name = expression.callee.name;
+    const message = `Call the static member "${expression.method}" as "${name}.${expression.method}(...)". A class value has no "self" to pass.`;
+    context.report("check-static-receiver", message, expression.position);
+    checkValueList(context, expression.args);
+    return context.record(expression, ANY_TYPE);
+  }
   if (expression.method === null) {
     context.calledMembers.add(expression.callee);
   }
@@ -18691,13 +18930,18 @@ function checkTable(context, expression) {
 }
 function checkTemplate(context, expression) {
   for (const interpolation of collectInterpolations(expression.segments)) {
-    if (interpolation.root.length === 0) {
+    if (interpolation.path.length === 0) {
       const message = 'Template interpolation is empty. Write "${name}", "${object.field}", or "${name:fallback}".';
       context.report("check-empty-interpolation", message, interpolation.position);
       continue;
     }
-    if (context.binder.lookup(interpolation.root) === null) {
-      const message = `Template interpolation "${interpolation.path}" refers to "${interpolation.root}", which is not in scope.`;
+    if (!NAME_PATH_PATTERN.test(interpolation.path)) {
+      const message = `Template interpolation "${interpolation.path}" is not a name or a member path. Compute the value first, then interpolate the name.`;
+      context.report("check-unknown-template-root", message, interpolation.position);
+      continue;
+    }
+    if (interpolation.fallback === null && context.binder.lookup(interpolation.root) === null) {
+      const message = `Template interpolation "${interpolation.path}" refers to "${interpolation.root}", which is not in scope. Write "\${${interpolation.path}:fallback}" to accept a value that may be missing.`;
       context.report("check-unknown-template-root", message, interpolation.position);
     }
   }
@@ -18803,6 +19047,26 @@ function syntheticMethodType(context, member, fieldTypes) {
   }
   return buildFunctionType(context, member.parameters, member.returnAnnotation);
 }
+function checkMemberSpaces(context, info, statement) {
+  for (const member of statement.members) {
+    if (member.isStatic && info.members.has(member.name)) {
+      context.report("check-duplicate-class-member", `Class "${info.name}" declares "${member.name}" as both a static and an instance member.`, member.position);
+    }
+    if (!member.isStatic || info.superClass === null) {
+      continue;
+    }
+    const inherited = context.declarations.lookupStaticMember(info.superClass, member.name);
+    const declared = info.statics.get(member.name);
+    if (inherited === void 0 || inherited === null || declared === void 0) {
+      continue;
+    }
+    const options = { allowNil: context.allowNil };
+    if (!isAssignable(declared.type, inherited.type, options) || !isAssignable(inherited.type, declared.type, options)) {
+      const message = `Static member "${member.name}" must match "${typeToString(inherited.type)}" declared by class "${info.superClass}".`;
+      context.report("check-invalid-override", message, member.position);
+    }
+  }
+}
 function registerMembers(context, info, statement) {
   const fieldTypes = /* @__PURE__ */ new Map();
   for (const member of statement.members) {
@@ -18815,7 +19079,8 @@ function registerMembers(context, info, statement) {
   for (const member of [...statement.members, ...generated]) {
     const type = member.kind === "class-field" ? fieldTypes.get(member) ?? ANY_TYPE : member.isSynthetic ? syntheticMethodType(context, member, fieldTypes) : buildFunctionType(context, member.parameters, member.returnAnnotation);
     const decorators = member.decorators.map((decorator) => decorator.name);
-    info.members.set(member.name, {
+    const space = member.isStatic ? info.statics : info.members;
+    space.set(member.name, {
       name: member.name,
       type,
       isMethod: member.kind === "class-method",
@@ -18824,6 +19089,7 @@ function registerMembers(context, info, statement) {
       deprecated: decorators.includes("Deprecated")
     });
   }
+  checkMemberSpaces(context, info, statement);
   return generated;
 }
 function declareBuilder(context, info, statement) {
@@ -18840,7 +19106,7 @@ function declareBuilder(context, info, statement) {
     }
   }
   members.set("build", { name: "build", type: { kind: "function", parameters: [], minimumArguments: 0, isVariadic: false, returnType: createNamed(statement.name) }, isMethod: true, position: statement.position });
-  context.declarations.declareClass({ name, superClass: null, interfaces: [], members, position: statement.position });
+  context.declarations.declareClass({ name, superClass: null, interfaces: [], members, statics: /* @__PURE__ */ new Map(), position: statement.position });
   context.declareModuleGlobal({ name, type: createNamed(name), isLocal: false, position: statement.position });
 }
 function checkMethodBody(context, info, member) {
@@ -18848,10 +19114,14 @@ function checkMethodBody(context, info, member) {
   if (explicitSelf !== void 0) {
     context.report("check-explicit-self-parameter", 'Class methods receive "self" automatically; remove it from the parameter list.', explicitSelf.position);
   }
-  const signature = info.members.get(member.name)?.type;
+  const signature = (member.isStatic ? info.statics : info.members).get(member.name)?.type;
   if (signature?.kind !== "function") {
     return;
   }
+  if (member.isStatic) {
+    checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature, null);
+    return;
+  }
   context.pushClassMethod({ className: info.name, methodName: member.name });
   checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature, createNamed(info.name));
   context.popClassMethod();
@@ -18890,6 +19160,7 @@ function declareClassInfo(context, statement) {
     superClass: null,
     interfaces: statement.interfaces,
     members: /* @__PURE__ */ new Map(),
+    statics: /* @__PURE__ */ new Map(),
     position: statement.position
   };
   context.declarations.declareClass(info);
@@ -19089,6 +19360,7 @@ function check(program2, mode, environment = DEFAULT_ENVIRONMENT, options = {})
     diagnostics: sortDiagnostics([...structure, ...directives.diagnostics, ...context.diagnostics]),
     types: context.types,
     references: context.references,
+    staticAccess: context.staticAccess,
     declarations: context.declarations,
     aliases: context.binder.resolvedAliases(),
     declaredGlobals: context.declaredGlobals,
@@ -19205,8 +19477,8 @@ function finalizeEmission(code, markers, sourceLineOffset = 0) {
 
 // ../compiler/src/emitter/state.ts
 var INDENT2 = "    ";
-function createEmitState(types, references, generatedMembers) {
-  return { types, references, generatedMembers, helpers: /* @__PURE__ */ new Set(), indent: 0, markers: [], symbol: void 0, loopWrap: false };
+function createEmitState(types, references, generatedMembers, staticAccess = /* @__PURE__ */ new Set()) {
+  return { types, references, staticAccess, generatedMembers, helpers: /* @__PURE__ */ new Set(), indent: 0, markers: [], symbol: void 0, loopWrap: false };
 }
 function requireHelper(state, helper) {
   if (helper !== null) {
@@ -19238,16 +19510,86 @@ function withSymbol(state, symbol, action) {
 }
 
 // ../compiler/src/emitter/template.ts
+var SELF_PATH_PATTERN = /^self((?:\.[A-Za-z_][A-Za-z0-9_]*)+)$/;
+function flattenedName(path) {
+  const fields = SELF_PATH_PATTERN.exec(path)?.[1] ?? null;
+  if (fields === null) {
+    return null;
+  }
+  const name = fields.slice(1).split(".").join("_");
+  return LUA_KEYWORDS.has(name) ? null : name;
+}
+function collectFlattened(segments) {
+  const interpolations = collectInterpolations(segments);
+  const reserved = /* @__PURE__ */ new Set();
+  const claims = /* @__PURE__ */ new Map();
+  const conflicting = /* @__PURE__ */ new Set();
+  for (const interpolation of interpolations) {
+    const name = flattenedName(interpolation.path);
+    if (name === null) {
+      reserved.add(interpolation.root);
+      continue;
+    }
+    const claimed = claims.get(name) ?? null;
+    if (claimed !== null && claimed !== interpolation.path) {
+      conflicting.add(name);
+      continue;
+    }
+    claims.set(name, interpolation.path);
+  }
+  const flattened = /* @__PURE__ */ new Map();
+  for (const interpolation of interpolations) {
+    const name = flattenedName(interpolation.path);
+    if (name !== null && !reserved.has(name) && !conflicting.has(name)) {
+      flattened.set(interpolation.raw, name);
+    }
+  }
+  return flattened;
+}
+function rewriteInterpolation(raw, name) {
+  const separator = raw.indexOf(":");
+  const key = separator === -1 ? raw : raw.slice(0, separator);
+  const rest = separator === -1 ? "" : raw.slice(separator);
+  const path = key.trim();
+  const start = key.indexOf(path);
+  return `${key.slice(0, start)}${name}${key.slice(start + path.length)}${rest}`;
+}
+function flattenedLiteral(segments, flattened) {
+  if (flattened.size === 0) {
+    return templateLiteralText(segments);
+  }
+  return segments.map((segment) => {
+    if (segment.kind === "text") {
+      return segment.value;
+    }
+    const name = flattened.get(segment.value) ?? null;
+    return `\${${name === null ? segment.value : rewriteInterpolation(segment.value, name)}}`;
+  }).join("");
+}
+function collectBindings(segments, flattened) {
+  const bindings = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const interpolation of collectInterpolations(segments)) {
+    const flatName = flattened.get(interpolation.raw) ?? null;
+    const name = flatName ?? interpolation.root;
+    if (name.length === 0 || seen.has(name)) {
+      continue;
+    }
+    seen.add(name);
+    bindings.push({ name, value: flatName === null ? name : interpolation.path });
+  }
+  return bindings;
+}
 function lowerTemplate(segments) {
-  const roots = collectTemplateRoots(segments);
+  const flattened = collectFlattened(segments);
   const isInterpolated = segments.some((segment) => segment.kind === "interpolation");
-  return { literal: templateLiteralText(segments), roots, isInterpolated };
+  return { literal: flattenedLiteral(segments, flattened), bindings: collectBindings(segments, flattened), isInterpolated };
 }
-function templateContext(roots) {
-  if (roots.length === 0) {
+function templateContext(bindings) {
+  if (bindings.length === 0) {
     return "{}";
   }
-  return `{ ${roots.map((root) => `${root} = ${root}`).join(", ")} }`;
+  return `{ ${bindings.map((binding) => `${binding.name} = ${binding.value}`).join(", ")} }`;
 }
 
 // ../compiler/src/emitter/expressions.ts
@@ -19288,6 +19630,10 @@ function emitTable(state, expression) {
   return `{ ${fields.join(", ")} }`;
 }
 function emitMember(state, expression) {
+  if (state.staticAccess.has(expression) && expression.object.kind === "identifier") {
+    requireHelper(state, "class");
+    return `getClass(${emitString(expression.object.name)}).${expression.property}`;
+  }
   const extension = resolvePropertyExtension(typeOf(state, expression.object), expression.property);
   const object = emitExpression(state, expression.object, UNARY_PRECEDENCE);
   if (extension === null) {
@@ -19320,7 +19666,7 @@ function emitTemplate(state, segments) {
     return emitString(lowered.literal);
   }
   requireHelper(state, "string");
-  return `string.template(${emitString(lowered.literal)}, ${templateContext(lowered.roots)})`;
+  return `string.template(${emitString(lowered.literal)}, ${templateContext(lowered.bindings)})`;
 }
 function emitBinary(state, expression, limit) {
   const precedence = binaryPrecedence(expression.operator);
@@ -19382,7 +19728,8 @@ function emitMethod(state, className, member) {
   if (member.generated !== void 0) {
     return emitGeneratedMethod(state, className, member);
   }
-  return withSymbol(state, `${className}:${member.name}`, () => emitFunctionBody(state, [self, ...member.parameters], member.body, `${member.name} = function`));
+  const parameters = member.isStatic ? member.parameters : [self, ...member.parameters];
+  return withSymbol(state, `${className}${member.isStatic ? "." : ":"}${member.name}`, () => emitFunctionBody(state, parameters, member.body, `${member.name} = function`));
 }
 function emitGeneratedMethod(state, className, member) {
   const fields = member.generated?.fields ?? [];
@@ -19454,7 +19801,7 @@ function emitMembers(state, statement) {
   state.indent += 1;
   for (const member of statement.members) {
     if (member.kind === "class-method") {
-      entries2.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.isStatic ? "." : ":"}${member.name}`)}${emitMethod(state, statement.name, member)}`));
       continue;
     }
     if (member.decorators.some((decorator) => decorator.name === "Lazy")) {
@@ -19696,8 +20043,8 @@ function emitBlock(state, statements) {
   }
   return lines;
 }
-function emit2(program2, types, references, generatedMembers = /* @__PURE__ */ new Map(), sourceLineOffset = 0) {
-  const state = createEmitState(types, references, generatedMembers);
+function emit2(program2, types, references, generatedMembers = /* @__PURE__ */ new Map(), sourceLineOffset = 0, staticAccess = /* @__PURE__ */ new Set()) {
+  const state = createEmitState(types, references, generatedMembers, staticAccess);
   const lines = emitBlock(state, program2.body);
   const markedCode = lines.length === 0 ? "" : `${lines.join("\n")}
 `;
@@ -19949,18 +20296,18 @@ function erasedEdit(source, span) {
 }
 function canonicalEdit(input, statement, span) {
   const { source } = input;
-  const emitted = emit2({ ...input.program, body: [statement] }, input.types, input.references, input.generatedMembers, statement.position.line - 1);
+  const emitted = emit2({ ...input.program, body: [statement] }, input.types, input.references, input.generatedMembers, statement.position.line - 1, input.staticAccess);
   const trimmed = span.end < source.length && emitted.code.endsWith("\n") ? emitted.code.slice(0, -1) : emitted.code;
   if (trimmed.length === 0) {
     return erasedEdit(source, span);
   }
   const authored = source.slice(span.start, span.end);
   const replacement = reindent(trimmed, indentOf(source, span.start));
-  const missing = lineCount2(authored) - lineCount2(replacement);
-  if (missing < 0 && input.development) {
+  const missing2 = lineCount2(authored) - lineCount2(replacement);
+  if (missing2 < 0 && input.development) {
     return null;
   }
-  const padded = missing > 0 && source.slice(span.end).trim().length > 0 ? `${replacement}${"\n".repeat(missing)}` : replacement;
+  const padded = missing2 > 0 && source.slice(span.end).trim().length > 0 ? `${replacement}${"\n".repeat(missing2)}` : replacement;
   return { start: span.start, end: span.end, replacement: padded, lines: emitted.lines };
 }
 
@@ -19984,15 +20331,16 @@ function builderClassText(input, statement) {
 }
 
 // ../compiler/src/emitter/preserve-guards.ts
-function isPreservableExpression(expression, types) {
+var NO_STATIC_ACCESS = /* @__PURE__ */ new Set();
+function isPreservableExpression(expression, types, statics = NO_STATIC_ACCESS) {
   switch (expression.kind) {
     case "template-literal":
     case "new-expression":
       return false;
     case "member-expression":
-      return resolvePropertyExtension(types.get(expression.object) ?? null, expression.property) === null && isPreservableExpression(expression.object, types);
+      return !statics.has(expression) && resolvePropertyExtension(types.get(expression.object) ?? null, expression.property) === null && isPreservableExpression(expression.object, types, statics);
     case "index-expression":
-      return isPreservableExpression(expression.object, types) && isPreservableExpression(expression.index, types);
+      return isPreservableExpression(expression.object, types, statics) && isPreservableExpression(expression.index, types, statics);
     case "call-expression":
       if (expression.method === null && expression.callee.kind === "identifier" && expression.callee.name === "super") {
         return false;
@@ -20000,43 +20348,43 @@ function isPreservableExpression(expression, types) {
       if (expression.callee.kind === "member-expression" && resolveCallExtension(types.get(expression.callee.object) ?? null, expression.callee.property) !== null) {
         return false;
       }
-      return isPreservableExpression(expression.callee, types) && expression.args.every((argument) => isPreservableExpression(argument, types));
+      return isPreservableExpression(expression.callee, types, statics) && expression.args.every((argument) => isPreservableExpression(argument, types, statics));
     case "table-expression":
       return expression.fields.every(
-        (field2) => (field2.key === null || isPreservableExpression(field2.key, types)) && isPreservableExpression(field2.value, types)
+        (field2) => (field2.key === null || isPreservableExpression(field2.key, types, statics)) && isPreservableExpression(field2.value, types, statics)
       );
     case "binary-expression":
-      return isPreservableExpression(expression.left, types) && isPreservableExpression(expression.right, types);
+      return isPreservableExpression(expression.left, types, statics) && isPreservableExpression(expression.right, types, statics);
     case "unary-expression":
-      return isPreservableExpression(expression.operand, types);
+      return isPreservableExpression(expression.operand, types, statics);
     case "group-expression":
-      return isPreservableExpression(expression.expression, types);
+      return isPreservableExpression(expression.expression, types, statics);
     default:
       return true;
   }
 }
-function every(expressions, types) {
-  return expressions.every((expression) => isPreservableExpression(expression, types));
+function every(expressions, types, statics) {
+  return expressions.every((expression) => isPreservableExpression(expression, types, statics));
 }
-function isPreservableStatement(statement, types) {
+function isPreservableStatement(statement, types, statics = NO_STATIC_ACCESS) {
   switch (statement.kind) {
     case "local-statement":
-      return every(statement.values, types);
+      return every(statement.values, types, statics);
     case "assignment-statement":
-      return statement.operator === "=" && every(statement.targets, types) && every(statement.values, types);
+      return statement.operator === "=" && every(statement.targets, types, statics) && every(statement.values, types, statics);
     case "call-statement":
-      return isPreservableExpression(statement.expression, types);
+      return isPreservableExpression(statement.expression, types, statics);
     case "return-statement":
-      return every(statement.values, types);
+      return every(statement.values, types, statics);
     case "while-statement":
     case "repeat-statement":
-      return isPreservableExpression(statement.condition, types);
+      return isPreservableExpression(statement.condition, types, statics);
     case "if-statement":
-      return statement.clauses.every((clause) => isPreservableExpression(clause.condition, types));
+      return statement.clauses.every((clause) => isPreservableExpression(clause.condition, types, statics));
     case "numeric-for-statement":
-      return isPreservableExpression(statement.start, types) && isPreservableExpression(statement.limit, types) && (statement.step === null || isPreservableExpression(statement.step, types));
+      return isPreservableExpression(statement.start, types, statics) && isPreservableExpression(statement.limit, types, statics) && (statement.step === null || isPreservableExpression(statement.step, types, statics));
     case "generic-for-statement":
-      return every(statement.iterators, types);
+      return every(statement.iterators, types, statics);
     case "break-statement":
     case "declare-statement":
     case "do-statement":
@@ -20164,7 +20512,7 @@ function classEdits(input, statement, spans) {
       edits.push({ start: span.start, end, replacement: isLazyField(member) ? longComment(text) : blankSpan(text) });
       continue;
     }
-    if (member.kind === "class-method") {
+    if (member.kind === "class-method" && !member.isStatic) {
       const self = selfEdit(source, member, span);
       if (self === null) {
         return null;
@@ -20278,7 +20626,7 @@ function surgery(collector, statement) {
     const edits2 = classEdits(input, statement, { span, members: input.spans });
     return edits2 === null ? null : { edits: edits2, wrapsBody: false };
   }
-  if (loopBody(statement) === null || !isPreservableStatement(statement, input.types)) {
+  if (loopBody(statement) === null || !isPreservableStatement(statement, input.types, input.staticAccess)) {
     return null;
   }
   const edits = loopEdits(input, statement);
@@ -20307,7 +20655,7 @@ function visit(collector, statement, wrapped) {
     descend(collector, statement, false, surgical.wrapsBody);
     return;
   }
-  if (isPreservableStatement(statement, collector.input.types) && keepsScaffolding(statement)) {
+  if (isPreservableStatement(statement, collector.input.types, collector.input.staticAccess) && keepsScaffolding(statement)) {
     const inherited = statement.kind === "do-statement" || statement.kind === "if-statement" ? wrapped : false;
     descend(collector, statement, inherited, false);
     return;
@@ -20460,7 +20808,7 @@ function compile(source, options = {}) {
     return { ...shared, code: null, requiredHelpers: [], lines: [] };
   }
   const references = reachedNames(checked.references, options.projectReferences);
-  const emitted = emit2(parsed.program, checked.types, references, checked.generatedMembers);
+  const emitted = emit2(parsed.program, checked.types, references, checked.generatedMembers, 0, checked.staticAccess);
   const preserved = emitPreservingSource({
     source,
     program: parsed.program,
@@ -20470,6 +20818,7 @@ function compile(source, options = {}) {
     types: checked.types,
     references,
     generatedMembers: checked.generatedMembers,
+    staticAccess: checked.staticAccess,
     development: options.development === true
   });
   const required = new Set(emitted.requiredHelpers);