@thigasdevelopment/luam 0.18.2 → 0.19.0

package/luam.mjs

@@ -6584,7 +6584,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.0" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -13296,13 +13296,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 +13314,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)}".`;
 }
 
@@ -13458,17 +13458,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;
       }
@@ -14272,6 +14279,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" },
@@ -17934,19 +18074,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 +18102,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 +18136,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 +18151,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 +18201,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 +18219,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 +18266,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 +18282,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 +18319,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 +18343,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 +18416,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 +18475,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 +18507,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 +18590,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 +18652,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 +18671,16 @@ 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" && 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);
@@ -18691,13 +18843,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);
     }
   }
@@ -19238,16 +19395,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
@@ -19320,7 +19547,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);
@@ -19956,11 +20183,11 @@ function canonicalEdit(input, statement, 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 };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thigasdevelopment/luam",
-    "version": "0.18.2",
+    "version": "0.19.0",
     "description": "The Luam compiler for Multi Theft Auto resources.",
     "keywords": [
         "mta",