@tilua/compiler 2.2.0 → 2.4.0

package/dist/{chunk-TBSJRVKA.js → chunk-3ZQ3EITC.js}

@@ -262,12 +262,10 @@ var Lowerer = class {
       for (const node of allNodes(this.source.body)) {
         const statement = node;
         if (statement.type === "VariableDeclaration") {
-          statement.names.forEach((target, index2) => {
-            const value = statement.init[index2];
-            if (target.type !== "IdentifierPattern" || !value) return;
-            const binding = this.bindingByDeclaration.get(target);
-            if (binding) this.declarations.set(binding.id, value);
-          });
+          const target = statement.name;
+          if (target.type !== "IdentifierPattern" || !statement.init) continue;
+          const binding = this.bindingByDeclaration.get(target);
+          if (binding) this.declarations.set(binding.id, statement.init);
         } else if (statement.type === "FunctionDeclaration") {
           const binding = this.bindingByDeclaration.get(statement.name);
           if (binding) this.declarations.set(binding.id, statement);
@@ -541,7 +539,7 @@ var Lowerer = class {
           const declaration = statement.declaration;
           if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
             exportBinding(declaration.name, declaration.name.name);
-          } else for (const pattern of declaration.names.flatMap(identifierPatterns)) exportBinding(pattern, pattern.name);
+          } else for (const pattern of identifierPatterns(declaration.name)) exportBinding(pattern, pattern.name);
           break;
         }
         case "ExportDefaultStatement":
@@ -577,7 +575,7 @@ var Lowerer = class {
     for (const statement of statements) {
       const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
       if (declaration.type === "VariableDeclaration") {
-        for (const pattern of declaration.names.flatMap(identifierPatterns)) {
+        for (const pattern of identifierPatterns(declaration.name)) {
           if (!this.isRewritten(pattern)) locals.push(this.name(pattern.name));
         }
       } else if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && !this.isRewritten(declaration.name)) {
@@ -674,7 +672,7 @@ var Lowerer = class {
         continue;
       }
       if (statement.type !== "VariableDeclaration") continue;
-      const patterns = statement.names.flatMap(identifierPatterns);
+      const patterns = identifierPatterns(statement.name);
       const end = { line: { start: statement.line.end }, column: { start: statement.column.end } };
       const needed = patterns.some((pattern) => {
         const binding = this.bindingByDeclaration.get(pattern);
@@ -715,7 +713,7 @@ var Lowerer = class {
     const body = [];
     for (const statement of statements) {
       if (statement.type === "VariableDeclaration") {
-        for (const pattern of statement.names.flatMap(identifierPatterns)) locals.push(this.name(pattern.name));
+        for (const pattern of identifierPatterns(statement.name)) locals.push(this.name(pattern.name));
         body.push(...this.variableDeclaration(statement, "assign"));
       } else if (statement.type === "FunctionDeclaration") {
         locals.push(this.name(statement.name.name));
@@ -848,12 +846,13 @@ var Lowerer = class {
         }];
       case "GenericForStatement": {
         const prelude = [];
+        const variable = declared(node.variable);
         let item;
-        if (node.variable.type === "IdentifierPattern") {
-          item = this.name(node.variable.name);
+        if (variable.type === "IdentifierPattern") {
+          item = this.name(variable.name);
         } else {
           item = this.names.fresh("item");
-          prelude.push(...this.destructure(node.variable, identifier(item), "declare"));
+          prelude.push(...this.destructure(variable, identifier(item), "declare"));
         }
         const form = this.options.types?.loops.get(node) ?? { walks: "values", viaIter: false };
         let source = this.expression(node.iterator);
@@ -867,7 +866,7 @@ var Lowerer = class {
         )];
       }
       case "ReturnStatement":
-        return [returns(node.argument ? [this.expression(node.argument)] : [])];
+        return [returns(node.argument ? [this.keptToOne(this.expression(node.argument))] : [])];
       case "BreakStatement":
         return [{ type: "BreakStatement", ...spanOf(node) }];
       case "ContinueStatement":
@@ -1116,63 +1115,37 @@ end
       ...spanOf(node)
     };
   }
-  /** `const a, { b } = x, y`. In "assign" mode — a module's top level, where
-   *  every name is declared up front — nothing is declared, only assigned. */
+  /** `const a = x`, `const { a, b } = x`. In "assign" mode — a module's top
+   *  level, where every name is declared up front — nothing is declared,
+   *  only assigned. */
   variableDeclaration(node, mode) {
-    if (mode === "assign" && !node.init.length) {
-      const exported = node.names.flatMap(identifierPatterns).filter((p) => this.isRewritten(p));
+    const target = declared(node.name);
+    if (!node.init) {
+      const names = identifierPatterns(target);
+      if (mode === "declare") return [local(names.map((p) => this.name(p.name)), [])];
+      const exported = names.filter((p) => this.isRewritten(p));
       return exported.length ? [assign(exported.map((p) => this.reference(p)), exported.map(() => nil()))] : [];
     }
-    const init = this.values(node.init);
-    if (node.names.every((n) => n.type === "IdentifierPattern")) {
-      const names2 = node.names;
-      return mode === "declare" ? [local(names2.map((n) => this.name(n.name)), init)] : [assign(names2.map((n) => this.reference(n)), init)];
-    }
-    const only = node.names.length === 1 && node.init.length === 1 ? node.names[0] : void 0;
-    if (only && only.type !== "IdentifierPattern") {
-      if (init[0].type === "Identifier") return this.destructure(only, init[0], mode);
-      const temp = this.names.fresh("ref");
-      return [local([temp], init), ...this.destructure(only, identifier(temp), mode)];
-    }
-    const after = [];
-    const names = [];
-    const targets = [];
-    for (const target of node.names) {
-      if (target.type === "IdentifierPattern") {
-        names.push(this.name(target.name));
-        targets.push(this.reference(target));
-        continue;
-      }
-      const temp = this.names.fresh("ref");
-      names.push(temp);
-      targets.push(identifier(temp));
-      after.push(...this.destructure(target, identifier(temp), mode));
+    const value = this.expression(node.init);
+    if (target.type === "IdentifierPattern") {
+      return mode === "declare" ? [local([this.name(target.name)], [value])] : [assign([this.reference(target)], [value])];
     }
-    if (mode === "declare") return [local(names, init), ...after];
-    const temps = node.names.flatMap((t, i) => t.type === "IdentifierPattern" ? [] : [names[i]]);
-    return [...temps.length ? [local(temps, [])] : [], assign(targets, init), ...after];
+    if (value.type === "Identifier") return this.destructure(target, value, mode);
+    const temp = this.names.fresh("ref");
+    return [local([temp], [value]), ...this.destructure(target, identifier(temp), mode)];
   }
   assignment(node) {
-    if (node.targets.every((t) => t.type !== "ObjectPattern" && t.type !== "ArrayPattern")) {
-      return [assign(node.targets.map((t) => this.expression(t)), this.values(node.values))];
+    const target = node.target;
+    const value = this.expression(node.value);
+    if (target.type !== "ObjectPattern" && target.type !== "ArrayPattern") {
+      return [assign([this.expression(target)], [value])];
     }
-    const values = this.values(node.values);
-    const only = node.targets.length === 1 && values.length === 1 ? node.targets[0] : void 0;
-    if (only && (only.type === "ObjectPattern" || only.type === "ArrayPattern") && values[0].type === "Identifier") {
-      const statements = this.destructure(only, values[0], "assign");
+    if (value.type === "Identifier") {
+      const statements = this.destructure(target, value, "assign");
       return statements.some((s) => s.type === "LocalStatement") ? [doBlock(statements)] : statements;
     }
-    const temps = node.targets.map(() => this.names.fresh("ref"));
-    const body = [local(temps, values)];
-    node.targets.forEach((target, i) => {
-      const value = identifier(temps[i]);
-      if (target.type === "ObjectPattern" || target.type === "ArrayPattern") {
-        body.push(...this.destructure(target, value, "assign"));
-      } else {
-        body.push(assign([this.expression(target)], [value]));
-      }
-    });
-    return [doBlock(body)];
+    const temp = this.names.fresh("ref");
+    return [doBlock([local([temp], [value]), ...this.destructure(target, identifier(temp), "assign")])];
   }
   // --------------------------------------------------------
   // Destructuring
@@ -1188,6 +1161,12 @@ end
     const reads = [];
     const after = [];
     const bind = (target, value, fallback) => {
+      if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+        const reference = this.expression(target);
+        reads.push({ name: "", target: reference, value, temp: false });
+        if (fallback) after.push(this.defaultValue(reference, fallback));
+        return;
+      }
       if (target.type === "IdentifierPattern") {
         const name2 = this.name(target.name);
         const reference = mode === "declare" ? identifier(name2) : this.reference(target);
@@ -1260,6 +1239,11 @@ end
    *  a temporary that a nested pattern then destructures (`then`). The
    *  statement creating it is pushed onto `after`. */
   restTarget(target, initial, mode, after) {
+    if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+      const reference = this.expression(target);
+      after.push(assign([reference], [initial]));
+      return { target: reference, then: [] };
+    }
     if (target.type === "IdentifierPattern") {
       if (mode === "declare") {
         const name2 = this.name(target.name);
@@ -1307,7 +1291,7 @@ end
       if (through !== void 0) {
         return call(member(this.superClassReference(node), through), [
           identifier(this.thisName()),
-          ...this.values(node.arguments)
+          ...this.arguments(node.arguments)
         ]);
       }
     }
@@ -1392,35 +1376,29 @@ end
     return this.link(node, this.expression(object));
   }
   /** A call is one value in tilua, and Luau would hand on every value one
-   *  in the last place of an argument list or an array returns. Types say
-   *  how many a call returns; where a type says nothing — `any`, `unknown`
-   *  — the call is kept to one: `f((g()))`. */
-  keptToOne(nodes, values) {
-    const node = nodes[nodes.length - 1];
-    const last = values[values.length - 1];
-    if (!node || !last || !expandsToMany(last)) return values;
-    const type = this.options.types?.typeOf.get(node);
-    if (type && type.kind !== "any" && type.kind !== "unknown") return values;
-    return [...values.slice(0, -1), parenthesized(last)];
+   *  returns in the last place of an argument list or a `return`: it is
+   *  kept to one there, `f((g()))`. Every value is taken only where the
+   *  program asks for them, as an array's last element: `[g()]`. */
+  keptToOne(value) {
+    return expandsToMany(value) ? parenthesized(value) : value;
   }
   /** Is this `scriptArgs` the language's own, not a name the file declared? */
   isLanguageGlobal(node) {
     const id = this.bindingIdOf(node);
     return id === void 0 || this.scopes.bindings.get(id)?.kind === "global";
   }
-  /** A list of values — a call's arguments, a `return`'s, a declaration's,
-   *  an assignment's. `f(a, ...xs)` is Lua's own last-value expansion,
+  /** A call's arguments. `f(a, ...xs)` is Lua's own last-value expansion,
    *  `f(a, table.unpack(xs))`; a spread anywhere else cannot be, since only
    *  the last value of a list expands, so the whole list is built as an
-   *  array first and that is what expands.
-   *
-   *  `arguments` is set for a call's arguments, where Luau hands on every
-   *  value the last one returns — see `keptToOne`. */
-  values(list, asArguments = false) {
+   *  array first and that is what expands. A call written last is one
+   *  value — see `keptToOne`. */
+  arguments(written) {
+    const { items: list, many } = packs(written);
     const spreads = list.filter((a) => a.type === "SpreadElement");
     if (!spreads.length) {
       const lowered = list.map((a) => this.expression(a));
-      return asArguments ? this.keptToOne(list, lowered) : lowered;
+      const last2 = list.length - 1;
+      return lowered.length && !many.has(list[last2]) ? [...lowered.slice(0, -1), this.keptToOne(lowered[last2])] : lowered;
     }
     const unpack = (value) => call(member(this.builtin("table"), "unpack"), [value]);
     const last = list[list.length - 1];
@@ -1442,13 +1420,13 @@ end
         return index(object, this.expression(node.index));
       case "CallExpression": {
         const lowered = this.loweredGlobalCall(node);
-        const args = this.values(node.arguments, true);
+        const args = this.arguments(node.arguments);
         if (!lowered) return call(object, args);
         return call(calleePath(lowered.callee), [...lowered.prepend, ...args]);
       }
       case "MethodCallExpression": {
         const lowered = this.loweredMethodCall(node);
-        const args = this.values(node.arguments, true);
+        const args = this.arguments(node.arguments);
         if (lowered) {
           return call(calleePath(lowered.callee), [
             ...lowered.prepend,
@@ -1681,33 +1659,55 @@ end
   /** `[1, ...xs, 2]`. Without a spread it is a Luau sequence; with one, the
    *  runs of plain elements and the spread arrays are joined by `concat`. */
   arrayExpression(node) {
-    if (!node.elements.some((e) => e.type === "SpreadElement")) {
-      const elements = node.elements;
-      return table(this.keptToOne(elements, elements.map((e) => this.expression(e))).map((value) => ({ type: "TableFieldPositional", value })));
+    const elements = packs(node.elements).items;
+    if (!elements.some((e) => e.type === "SpreadElement")) {
+      return table(elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) })));
     }
     const parts = [];
     let current = [];
-    const flush = () => {
+    const flush = (last) => {
       if (!current.length) return;
       parts.push(table(current.map((e, i) => {
         const value = this.expression(e);
-        const last = i === current.length - 1;
-        return { type: "TableFieldPositional", value: last && expandsToMany(value) ? parenthesized(value) : value };
+        return { type: "TableFieldPositional", value: last || i < current.length - 1 ? value : this.keptToOne(value) };
       })));
       current = [];
     };
-    for (const element of node.elements) {
+    for (const element of elements) {
       if (element.type === "SpreadElement") {
-        flush();
+        flush(false);
         parts.push(this.expression(element.argument));
       } else {
         current.push(element);
       }
     }
-    flush();
+    flush(true);
     return call(this.helper("concat"), parts);
   }
 };
+function packs(list) {
+  const items = [];
+  const many = /* @__PURE__ */ new Set();
+  const add = (elements) => {
+    for (const element of elements) {
+      if (element.type === "SpreadElement" && element.argument.type === "ArrayExpression") {
+        const inner = element.argument.elements;
+        add(inner);
+        const last = inner[inner.length - 1];
+        if (last && (last.type === "CallExpression" || last.type === "MethodCallExpression")) many.add(last);
+      } else {
+        items.push(element);
+      }
+    }
+  };
+  add(list);
+  items.forEach((item, i) => {
+    if (!many.has(item) || i === items.length - 1) return;
+    many.delete(item);
+    items[i] = { type: "SpreadElement", argument: { type: "ArrayExpression", elements: [item], ...spanOf(item) }, ...spanOf(item) };
+  });
+  return { items, many };
+}
 function isLink(node) {
   return node.type === "MemberExpression" || node.type === "IndexExpression" || node.type === "CallExpression" || node.type === "MethodCallExpression";
 }
@@ -1756,10 +1756,19 @@ function memberChain(e) {
   }
   return void 0;
 }
+function declared(target) {
+  if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+    throw new Error("a declaration binds names, not a member or an index");
+  }
+  return target;
+}
 function identifierPatterns(target) {
   switch (target.type) {
     case "IdentifierPattern":
       return [target];
+    case "MemberExpression":
+    case "IndexExpression":
+      return [];
     case "ObjectPattern":
       return [...target.properties.flatMap((p) => identifierPatterns(p.value)), ...target.rest ? identifierPatterns(target.rest) : []];
     case "ArrayPattern":
@@ -1773,7 +1782,7 @@ function topLevelDeclaration(statements, name) {
   for (const statement of statements) {
     const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
     if (declaration.type === "VariableDeclaration") {
-      const pattern = declaration.names.flatMap(identifierPatterns).find((p) => p.name === name);
+      const pattern = identifierPatterns(declaration.name).find((p) => p.name === name);
       if (pattern) return { type: "Declaration", node: pattern };
     } else if (declaration.type === "FunctionDeclaration" && declaration.name.name === name) {
       return { type: "Declaration", node: declaration.name };

package/dist/cli.cjs

@@ -274,12 +274,10 @@ var Lowerer = class {
       for (const node of allNodes(this.source.body)) {
         const statement = node;
         if (statement.type === "VariableDeclaration") {
-          statement.names.forEach((target, index2) => {
-            const value = statement.init[index2];
-            if (target.type !== "IdentifierPattern" || !value) return;
-            const binding = this.bindingByDeclaration.get(target);
-            if (binding) this.declarations.set(binding.id, value);
-          });
+          const target = statement.name;
+          if (target.type !== "IdentifierPattern" || !statement.init) continue;
+          const binding = this.bindingByDeclaration.get(target);
+          if (binding) this.declarations.set(binding.id, statement.init);
         } else if (statement.type === "FunctionDeclaration") {
           const binding = this.bindingByDeclaration.get(statement.name);
           if (binding) this.declarations.set(binding.id, statement);
@@ -553,7 +551,7 @@ var Lowerer = class {
           const declaration = statement.declaration;
           if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
             exportBinding(declaration.name, declaration.name.name);
-          } else for (const pattern of declaration.names.flatMap(identifierPatterns)) exportBinding(pattern, pattern.name);
+          } else for (const pattern of identifierPatterns(declaration.name)) exportBinding(pattern, pattern.name);
           break;
         }
         case "ExportDefaultStatement":
@@ -589,7 +587,7 @@ var Lowerer = class {
     for (const statement of statements) {
       const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
       if (declaration.type === "VariableDeclaration") {
-        for (const pattern of declaration.names.flatMap(identifierPatterns)) {
+        for (const pattern of identifierPatterns(declaration.name)) {
           if (!this.isRewritten(pattern)) locals.push(this.name(pattern.name));
         }
       } else if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && !this.isRewritten(declaration.name)) {
@@ -686,7 +684,7 @@ var Lowerer = class {
         continue;
       }
       if (statement.type !== "VariableDeclaration") continue;
-      const patterns = statement.names.flatMap(identifierPatterns);
+      const patterns = identifierPatterns(statement.name);
       const end = { line: { start: statement.line.end }, column: { start: statement.column.end } };
       const needed = patterns.some((pattern) => {
         const binding = this.bindingByDeclaration.get(pattern);
@@ -727,7 +725,7 @@ var Lowerer = class {
     const body = [];
     for (const statement of statements) {
       if (statement.type === "VariableDeclaration") {
-        for (const pattern of statement.names.flatMap(identifierPatterns)) locals.push(this.name(pattern.name));
+        for (const pattern of identifierPatterns(statement.name)) locals.push(this.name(pattern.name));
         body.push(...this.variableDeclaration(statement, "assign"));
       } else if (statement.type === "FunctionDeclaration") {
         locals.push(this.name(statement.name.name));
@@ -860,12 +858,13 @@ var Lowerer = class {
         }];
       case "GenericForStatement": {
         const prelude = [];
+        const variable = declared(node.variable);
         let item;
-        if (node.variable.type === "IdentifierPattern") {
-          item = this.name(node.variable.name);
+        if (variable.type === "IdentifierPattern") {
+          item = this.name(variable.name);
         } else {
           item = this.names.fresh("item");
-          prelude.push(...this.destructure(node.variable, identifier(item), "declare"));
+          prelude.push(...this.destructure(variable, identifier(item), "declare"));
         }
         const form = this.options.types?.loops.get(node) ?? { walks: "values", viaIter: false };
         let source = this.expression(node.iterator);
@@ -879,7 +878,7 @@ var Lowerer = class {
         )];
       }
       case "ReturnStatement":
-        return [returns(node.argument ? [this.expression(node.argument)] : [])];
+        return [returns(node.argument ? [this.keptToOne(this.expression(node.argument))] : [])];
       case "BreakStatement":
         return [{ type: "BreakStatement", ...spanOf(node) }];
       case "ContinueStatement":
@@ -1128,63 +1127,37 @@ end
       ...spanOf(node)
     };
   }
-  /** `const a, { b } = x, y`. In "assign" mode — a module's top level, where
-   *  every name is declared up front — nothing is declared, only assigned. */
+  /** `const a = x`, `const { a, b } = x`. In "assign" mode — a module's top
+   *  level, where every name is declared up front — nothing is declared,
+   *  only assigned. */
   variableDeclaration(node, mode) {
-    if (mode === "assign" && !node.init.length) {
-      const exported = node.names.flatMap(identifierPatterns).filter((p) => this.isRewritten(p));
+    const target = declared(node.name);
+    if (!node.init) {
+      const names = identifierPatterns(target);
+      if (mode === "declare") return [local(names.map((p) => this.name(p.name)), [])];
+      const exported = names.filter((p) => this.isRewritten(p));
       return exported.length ? [assign(exported.map((p) => this.reference(p)), exported.map(() => nil()))] : [];
     }
-    const init = this.values(node.init);
-    if (node.names.every((n) => n.type === "IdentifierPattern")) {
-      const names2 = node.names;
-      return mode === "declare" ? [local(names2.map((n) => this.name(n.name)), init)] : [assign(names2.map((n) => this.reference(n)), init)];
-    }
-    const only = node.names.length === 1 && node.init.length === 1 ? node.names[0] : void 0;
-    if (only && only.type !== "IdentifierPattern") {
-      if (init[0].type === "Identifier") return this.destructure(only, init[0], mode);
-      const temp = this.names.fresh("ref");
-      return [local([temp], init), ...this.destructure(only, identifier(temp), mode)];
-    }
-    const after = [];
-    const names = [];
-    const targets = [];
-    for (const target of node.names) {
-      if (target.type === "IdentifierPattern") {
-        names.push(this.name(target.name));
-        targets.push(this.reference(target));
-        continue;
-      }
-      const temp = this.names.fresh("ref");
-      names.push(temp);
-      targets.push(identifier(temp));
-      after.push(...this.destructure(target, identifier(temp), mode));
+    const value = this.expression(node.init);
+    if (target.type === "IdentifierPattern") {
+      return mode === "declare" ? [local([this.name(target.name)], [value])] : [assign([this.reference(target)], [value])];
     }
-    if (mode === "declare") return [local(names, init), ...after];
-    const temps = node.names.flatMap((t, i) => t.type === "IdentifierPattern" ? [] : [names[i]]);
-    return [...temps.length ? [local(temps, [])] : [], assign(targets, init), ...after];
+    if (value.type === "Identifier") return this.destructure(target, value, mode);
+    const temp = this.names.fresh("ref");
+    return [local([temp], [value]), ...this.destructure(target, identifier(temp), mode)];
   }
   assignment(node) {
-    if (node.targets.every((t) => t.type !== "ObjectPattern" && t.type !== "ArrayPattern")) {
-      return [assign(node.targets.map((t) => this.expression(t)), this.values(node.values))];
+    const target = node.target;
+    const value = this.expression(node.value);
+    if (target.type !== "ObjectPattern" && target.type !== "ArrayPattern") {
+      return [assign([this.expression(target)], [value])];
     }
-    const values = this.values(node.values);
-    const only = node.targets.length === 1 && values.length === 1 ? node.targets[0] : void 0;
-    if (only && (only.type === "ObjectPattern" || only.type === "ArrayPattern") && values[0].type === "Identifier") {
-      const statements = this.destructure(only, values[0], "assign");
+    if (value.type === "Identifier") {
+      const statements = this.destructure(target, value, "assign");
       return statements.some((s) => s.type === "LocalStatement") ? [doBlock(statements)] : statements;
     }
-    const temps = node.targets.map(() => this.names.fresh("ref"));
-    const body = [local(temps, values)];
-    node.targets.forEach((target, i) => {
-      const value = identifier(temps[i]);
-      if (target.type === "ObjectPattern" || target.type === "ArrayPattern") {
-        body.push(...this.destructure(target, value, "assign"));
-      } else {
-        body.push(assign([this.expression(target)], [value]));
-      }
-    });
-    return [doBlock(body)];
+    const temp = this.names.fresh("ref");
+    return [doBlock([local([temp], [value]), ...this.destructure(target, identifier(temp), "assign")])];
   }
   // --------------------------------------------------------
   // Destructuring
@@ -1200,6 +1173,12 @@ end
     const reads = [];
     const after = [];
     const bind = (target, value, fallback) => {
+      if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+        const reference = this.expression(target);
+        reads.push({ name: "", target: reference, value, temp: false });
+        if (fallback) after.push(this.defaultValue(reference, fallback));
+        return;
+      }
       if (target.type === "IdentifierPattern") {
         const name2 = this.name(target.name);
         const reference = mode === "declare" ? identifier(name2) : this.reference(target);
@@ -1272,6 +1251,11 @@ end
    *  a temporary that a nested pattern then destructures (`then`). The
    *  statement creating it is pushed onto `after`. */
   restTarget(target, initial, mode, after) {
+    if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+      const reference = this.expression(target);
+      after.push(assign([reference], [initial]));
+      return { target: reference, then: [] };
+    }
     if (target.type === "IdentifierPattern") {
       if (mode === "declare") {
         const name2 = this.name(target.name);
@@ -1319,7 +1303,7 @@ end
       if (through !== void 0) {
         return call(member(this.superClassReference(node), through), [
           identifier(this.thisName()),
-          ...this.values(node.arguments)
+          ...this.arguments(node.arguments)
         ]);
       }
     }
@@ -1404,35 +1388,29 @@ end
     return this.link(node, this.expression(object));
   }
   /** A call is one value in tilua, and Luau would hand on every value one
-   *  in the last place of an argument list or an array returns. Types say
-   *  how many a call returns; where a type says nothing — `any`, `unknown`
-   *  — the call is kept to one: `f((g()))`. */
-  keptToOne(nodes, values) {
-    const node = nodes[nodes.length - 1];
-    const last = values[values.length - 1];
-    if (!node || !last || !expandsToMany(last)) return values;
-    const type = this.options.types?.typeOf.get(node);
-    if (type && type.kind !== "any" && type.kind !== "unknown") return values;
-    return [...values.slice(0, -1), parenthesized(last)];
+   *  returns in the last place of an argument list or a `return`: it is
+   *  kept to one there, `f((g()))`. Every value is taken only where the
+   *  program asks for them, as an array's last element: `[g()]`. */
+  keptToOne(value) {
+    return expandsToMany(value) ? parenthesized(value) : value;
   }
   /** Is this `scriptArgs` the language's own, not a name the file declared? */
   isLanguageGlobal(node) {
     const id = this.bindingIdOf(node);
     return id === void 0 || this.scopes.bindings.get(id)?.kind === "global";
   }
-  /** A list of values — a call's arguments, a `return`'s, a declaration's,
-   *  an assignment's. `f(a, ...xs)` is Lua's own last-value expansion,
+  /** A call's arguments. `f(a, ...xs)` is Lua's own last-value expansion,
    *  `f(a, table.unpack(xs))`; a spread anywhere else cannot be, since only
    *  the last value of a list expands, so the whole list is built as an
-   *  array first and that is what expands.
-   *
-   *  `arguments` is set for a call's arguments, where Luau hands on every
-   *  value the last one returns — see `keptToOne`. */
-  values(list, asArguments = false) {
+   *  array first and that is what expands. A call written last is one
+   *  value — see `keptToOne`. */
+  arguments(written) {
+    const { items: list, many } = packs(written);
     const spreads = list.filter((a) => a.type === "SpreadElement");
     if (!spreads.length) {
       const lowered = list.map((a) => this.expression(a));
-      return asArguments ? this.keptToOne(list, lowered) : lowered;
+      const last2 = list.length - 1;
+      return lowered.length && !many.has(list[last2]) ? [...lowered.slice(0, -1), this.keptToOne(lowered[last2])] : lowered;
     }
     const unpack = (value) => call(member(this.builtin("table"), "unpack"), [value]);
     const last = list[list.length - 1];
@@ -1454,13 +1432,13 @@ end
         return index(object, this.expression(node.index));
       case "CallExpression": {
         const lowered = this.loweredGlobalCall(node);
-        const args2 = this.values(node.arguments, true);
+        const args2 = this.arguments(node.arguments);
         if (!lowered) return call(object, args2);
         return call(calleePath(lowered.callee), [...lowered.prepend, ...args2]);
       }
       case "MethodCallExpression": {
         const lowered = this.loweredMethodCall(node);
-        const args2 = this.values(node.arguments, true);
+        const args2 = this.arguments(node.arguments);
         if (lowered) {
           return call(calleePath(lowered.callee), [
             ...lowered.prepend,
@@ -1693,33 +1671,55 @@ end
   /** `[1, ...xs, 2]`. Without a spread it is a Luau sequence; with one, the
    *  runs of plain elements and the spread arrays are joined by `concat`. */
   arrayExpression(node) {
-    if (!node.elements.some((e) => e.type === "SpreadElement")) {
-      const elements = node.elements;
-      return table(this.keptToOne(elements, elements.map((e) => this.expression(e))).map((value) => ({ type: "TableFieldPositional", value })));
+    const elements = packs(node.elements).items;
+    if (!elements.some((e) => e.type === "SpreadElement")) {
+      return table(elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) })));
     }
     const parts = [];
     let current = [];
-    const flush = () => {
+    const flush = (last) => {
       if (!current.length) return;
       parts.push(table(current.map((e, i) => {
         const value = this.expression(e);
-        const last = i === current.length - 1;
-        return { type: "TableFieldPositional", value: last && expandsToMany(value) ? parenthesized(value) : value };
+        return { type: "TableFieldPositional", value: last || i < current.length - 1 ? value : this.keptToOne(value) };
       })));
       current = [];
     };
-    for (const element of node.elements) {
+    for (const element of elements) {
       if (element.type === "SpreadElement") {
-        flush();
+        flush(false);
         parts.push(this.expression(element.argument));
       } else {
         current.push(element);
       }
     }
-    flush();
+    flush(true);
     return call(this.helper("concat"), parts);
   }
 };
+function packs(list) {
+  const items = [];
+  const many = /* @__PURE__ */ new Set();
+  const add = (elements) => {
+    for (const element of elements) {
+      if (element.type === "SpreadElement" && element.argument.type === "ArrayExpression") {
+        const inner = element.argument.elements;
+        add(inner);
+        const last = inner[inner.length - 1];
+        if (last && (last.type === "CallExpression" || last.type === "MethodCallExpression")) many.add(last);
+      } else {
+        items.push(element);
+      }
+    }
+  };
+  add(list);
+  items.forEach((item, i) => {
+    if (!many.has(item) || i === items.length - 1) return;
+    many.delete(item);
+    items[i] = { type: "SpreadElement", argument: { type: "ArrayExpression", elements: [item], ...spanOf(item) }, ...spanOf(item) };
+  });
+  return { items, many };
+}
 function isLink(node) {
   return node.type === "MemberExpression" || node.type === "IndexExpression" || node.type === "CallExpression" || node.type === "MethodCallExpression";
 }
@@ -1768,10 +1768,19 @@ function memberChain(e) {
   }
   return void 0;
 }
+function declared(target) {
+  if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+    throw new Error("a declaration binds names, not a member or an index");
+  }
+  return target;
+}
 function identifierPatterns(target) {
   switch (target.type) {
     case "IdentifierPattern":
       return [target];
+    case "MemberExpression":
+    case "IndexExpression":
+      return [];
     case "ObjectPattern":
       return [...target.properties.flatMap((p) => identifierPatterns(p.value)), ...target.rest ? identifierPatterns(target.rest) : []];
     case "ArrayPattern":
@@ -1785,7 +1794,7 @@ function topLevelDeclaration(statements, name) {
   for (const statement of statements) {
     const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
     if (declaration.type === "VariableDeclaration") {
-      const pattern = declaration.names.flatMap(identifierPatterns).find((p) => p.name === name);
+      const pattern = identifierPatterns(declaration.name).find((p) => p.name === name);
       if (pattern) return { type: "Declaration", node: pattern };
     } else if (declaration.type === "FunctionDeclaration" && declaration.name.name === name) {
       return { type: "Declaration", node: declaration.name };

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   bundle
-} from "./chunk-TBSJRVKA.js";
+} from "./chunk-3ZQ3EITC.js";
 
 // src/cli.ts
 import { writeFileSync } from "fs";

package/dist/index.cjs

@@ -298,12 +298,10 @@ var Lowerer = class {
       for (const node of allNodes(this.source.body)) {
         const statement = node;
         if (statement.type === "VariableDeclaration") {
-          statement.names.forEach((target, index2) => {
-            const value = statement.init[index2];
-            if (target.type !== "IdentifierPattern" || !value) return;
-            const binding = this.bindingByDeclaration.get(target);
-            if (binding) this.declarations.set(binding.id, value);
-          });
+          const target = statement.name;
+          if (target.type !== "IdentifierPattern" || !statement.init) continue;
+          const binding = this.bindingByDeclaration.get(target);
+          if (binding) this.declarations.set(binding.id, statement.init);
         } else if (statement.type === "FunctionDeclaration") {
           const binding = this.bindingByDeclaration.get(statement.name);
           if (binding) this.declarations.set(binding.id, statement);
@@ -577,7 +575,7 @@ var Lowerer = class {
           const declaration = statement.declaration;
           if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
             exportBinding(declaration.name, declaration.name.name);
-          } else for (const pattern of declaration.names.flatMap(identifierPatterns)) exportBinding(pattern, pattern.name);
+          } else for (const pattern of identifierPatterns(declaration.name)) exportBinding(pattern, pattern.name);
           break;
         }
         case "ExportDefaultStatement":
@@ -613,7 +611,7 @@ var Lowerer = class {
     for (const statement of statements) {
       const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
       if (declaration.type === "VariableDeclaration") {
-        for (const pattern of declaration.names.flatMap(identifierPatterns)) {
+        for (const pattern of identifierPatterns(declaration.name)) {
           if (!this.isRewritten(pattern)) locals.push(this.name(pattern.name));
         }
       } else if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && !this.isRewritten(declaration.name)) {
@@ -710,7 +708,7 @@ var Lowerer = class {
         continue;
       }
       if (statement.type !== "VariableDeclaration") continue;
-      const patterns = statement.names.flatMap(identifierPatterns);
+      const patterns = identifierPatterns(statement.name);
       const end = { line: { start: statement.line.end }, column: { start: statement.column.end } };
       const needed = patterns.some((pattern) => {
         const binding = this.bindingByDeclaration.get(pattern);
@@ -751,7 +749,7 @@ var Lowerer = class {
     const body = [];
     for (const statement of statements) {
       if (statement.type === "VariableDeclaration") {
-        for (const pattern of statement.names.flatMap(identifierPatterns)) locals.push(this.name(pattern.name));
+        for (const pattern of identifierPatterns(statement.name)) locals.push(this.name(pattern.name));
         body.push(...this.variableDeclaration(statement, "assign"));
       } else if (statement.type === "FunctionDeclaration") {
         locals.push(this.name(statement.name.name));
@@ -884,12 +882,13 @@ var Lowerer = class {
         }];
       case "GenericForStatement": {
         const prelude = [];
+        const variable = declared(node.variable);
         let item;
-        if (node.variable.type === "IdentifierPattern") {
-          item = this.name(node.variable.name);
+        if (variable.type === "IdentifierPattern") {
+          item = this.name(variable.name);
         } else {
           item = this.names.fresh("item");
-          prelude.push(...this.destructure(node.variable, identifier(item), "declare"));
+          prelude.push(...this.destructure(variable, identifier(item), "declare"));
         }
         const form = this.options.types?.loops.get(node) ?? { walks: "values", viaIter: false };
         let source = this.expression(node.iterator);
@@ -903,7 +902,7 @@ var Lowerer = class {
         )];
       }
       case "ReturnStatement":
-        return [returns(node.argument ? [this.expression(node.argument)] : [])];
+        return [returns(node.argument ? [this.keptToOne(this.expression(node.argument))] : [])];
       case "BreakStatement":
         return [{ type: "BreakStatement", ...spanOf(node) }];
       case "ContinueStatement":
@@ -1152,63 +1151,37 @@ end
       ...spanOf(node)
     };
   }
-  /** `const a, { b } = x, y`. In "assign" mode — a module's top level, where
-   *  every name is declared up front — nothing is declared, only assigned. */
+  /** `const a = x`, `const { a, b } = x`. In "assign" mode — a module's top
+   *  level, where every name is declared up front — nothing is declared,
+   *  only assigned. */
   variableDeclaration(node, mode) {
-    if (mode === "assign" && !node.init.length) {
-      const exported = node.names.flatMap(identifierPatterns).filter((p) => this.isRewritten(p));
+    const target = declared(node.name);
+    if (!node.init) {
+      const names = identifierPatterns(target);
+      if (mode === "declare") return [local(names.map((p) => this.name(p.name)), [])];
+      const exported = names.filter((p) => this.isRewritten(p));
       return exported.length ? [assign(exported.map((p) => this.reference(p)), exported.map(() => nil()))] : [];
     }
-    const init = this.values(node.init);
-    if (node.names.every((n) => n.type === "IdentifierPattern")) {
-      const names2 = node.names;
-      return mode === "declare" ? [local(names2.map((n) => this.name(n.name)), init)] : [assign(names2.map((n) => this.reference(n)), init)];
-    }
-    const only = node.names.length === 1 && node.init.length === 1 ? node.names[0] : void 0;
-    if (only && only.type !== "IdentifierPattern") {
-      if (init[0].type === "Identifier") return this.destructure(only, init[0], mode);
-      const temp = this.names.fresh("ref");
-      return [local([temp], init), ...this.destructure(only, identifier(temp), mode)];
-    }
-    const after = [];
-    const names = [];
-    const targets = [];
-    for (const target of node.names) {
-      if (target.type === "IdentifierPattern") {
-        names.push(this.name(target.name));
-        targets.push(this.reference(target));
-        continue;
-      }
-      const temp = this.names.fresh("ref");
-      names.push(temp);
-      targets.push(identifier(temp));
-      after.push(...this.destructure(target, identifier(temp), mode));
+    const value = this.expression(node.init);
+    if (target.type === "IdentifierPattern") {
+      return mode === "declare" ? [local([this.name(target.name)], [value])] : [assign([this.reference(target)], [value])];
     }
-    if (mode === "declare") return [local(names, init), ...after];
-    const temps = node.names.flatMap((t, i) => t.type === "IdentifierPattern" ? [] : [names[i]]);
-    return [...temps.length ? [local(temps, [])] : [], assign(targets, init), ...after];
+    if (value.type === "Identifier") return this.destructure(target, value, mode);
+    const temp = this.names.fresh("ref");
+    return [local([temp], [value]), ...this.destructure(target, identifier(temp), mode)];
   }
   assignment(node) {
-    if (node.targets.every((t) => t.type !== "ObjectPattern" && t.type !== "ArrayPattern")) {
-      return [assign(node.targets.map((t) => this.expression(t)), this.values(node.values))];
+    const target = node.target;
+    const value = this.expression(node.value);
+    if (target.type !== "ObjectPattern" && target.type !== "ArrayPattern") {
+      return [assign([this.expression(target)], [value])];
     }
-    const values = this.values(node.values);
-    const only = node.targets.length === 1 && values.length === 1 ? node.targets[0] : void 0;
-    if (only && (only.type === "ObjectPattern" || only.type === "ArrayPattern") && values[0].type === "Identifier") {
-      const statements = this.destructure(only, values[0], "assign");
+    if (value.type === "Identifier") {
+      const statements = this.destructure(target, value, "assign");
       return statements.some((s) => s.type === "LocalStatement") ? [doBlock(statements)] : statements;
     }
-    const temps = node.targets.map(() => this.names.fresh("ref"));
-    const body = [local(temps, values)];
-    node.targets.forEach((target, i) => {
-      const value = identifier(temps[i]);
-      if (target.type === "ObjectPattern" || target.type === "ArrayPattern") {
-        body.push(...this.destructure(target, value, "assign"));
-      } else {
-        body.push(assign([this.expression(target)], [value]));
-      }
-    });
-    return [doBlock(body)];
+    const temp = this.names.fresh("ref");
+    return [doBlock([local([temp], [value]), ...this.destructure(target, identifier(temp), "assign")])];
   }
   // --------------------------------------------------------
   // Destructuring
@@ -1224,6 +1197,12 @@ end
     const reads = [];
     const after = [];
     const bind = (target, value, fallback) => {
+      if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+        const reference = this.expression(target);
+        reads.push({ name: "", target: reference, value, temp: false });
+        if (fallback) after.push(this.defaultValue(reference, fallback));
+        return;
+      }
       if (target.type === "IdentifierPattern") {
         const name2 = this.name(target.name);
         const reference = mode === "declare" ? identifier(name2) : this.reference(target);
@@ -1296,6 +1275,11 @@ end
    *  a temporary that a nested pattern then destructures (`then`). The
    *  statement creating it is pushed onto `after`. */
   restTarget(target, initial, mode, after) {
+    if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+      const reference = this.expression(target);
+      after.push(assign([reference], [initial]));
+      return { target: reference, then: [] };
+    }
     if (target.type === "IdentifierPattern") {
       if (mode === "declare") {
         const name2 = this.name(target.name);
@@ -1343,7 +1327,7 @@ end
       if (through !== void 0) {
         return call(member(this.superClassReference(node), through), [
           identifier(this.thisName()),
-          ...this.values(node.arguments)
+          ...this.arguments(node.arguments)
         ]);
       }
     }
@@ -1428,35 +1412,29 @@ end
     return this.link(node, this.expression(object));
   }
   /** A call is one value in tilua, and Luau would hand on every value one
-   *  in the last place of an argument list or an array returns. Types say
-   *  how many a call returns; where a type says nothing — `any`, `unknown`
-   *  — the call is kept to one: `f((g()))`. */
-  keptToOne(nodes, values) {
-    const node = nodes[nodes.length - 1];
-    const last = values[values.length - 1];
-    if (!node || !last || !expandsToMany(last)) return values;
-    const type = this.options.types?.typeOf.get(node);
-    if (type && type.kind !== "any" && type.kind !== "unknown") return values;
-    return [...values.slice(0, -1), parenthesized(last)];
+   *  returns in the last place of an argument list or a `return`: it is
+   *  kept to one there, `f((g()))`. Every value is taken only where the
+   *  program asks for them, as an array's last element: `[g()]`. */
+  keptToOne(value) {
+    return expandsToMany(value) ? parenthesized(value) : value;
   }
   /** Is this `scriptArgs` the language's own, not a name the file declared? */
   isLanguageGlobal(node) {
     const id = this.bindingIdOf(node);
     return id === void 0 || this.scopes.bindings.get(id)?.kind === "global";
   }
-  /** A list of values — a call's arguments, a `return`'s, a declaration's,
-   *  an assignment's. `f(a, ...xs)` is Lua's own last-value expansion,
+  /** A call's arguments. `f(a, ...xs)` is Lua's own last-value expansion,
    *  `f(a, table.unpack(xs))`; a spread anywhere else cannot be, since only
    *  the last value of a list expands, so the whole list is built as an
-   *  array first and that is what expands.
-   *
-   *  `arguments` is set for a call's arguments, where Luau hands on every
-   *  value the last one returns — see `keptToOne`. */
-  values(list, asArguments = false) {
+   *  array first and that is what expands. A call written last is one
+   *  value — see `keptToOne`. */
+  arguments(written) {
+    const { items: list, many } = packs(written);
     const spreads = list.filter((a) => a.type === "SpreadElement");
     if (!spreads.length) {
       const lowered = list.map((a) => this.expression(a));
-      return asArguments ? this.keptToOne(list, lowered) : lowered;
+      const last2 = list.length - 1;
+      return lowered.length && !many.has(list[last2]) ? [...lowered.slice(0, -1), this.keptToOne(lowered[last2])] : lowered;
     }
     const unpack = (value) => call(member(this.builtin("table"), "unpack"), [value]);
     const last = list[list.length - 1];
@@ -1478,13 +1456,13 @@ end
         return index(object, this.expression(node.index));
       case "CallExpression": {
         const lowered = this.loweredGlobalCall(node);
-        const args = this.values(node.arguments, true);
+        const args = this.arguments(node.arguments);
         if (!lowered) return call(object, args);
         return call(calleePath(lowered.callee), [...lowered.prepend, ...args]);
       }
       case "MethodCallExpression": {
         const lowered = this.loweredMethodCall(node);
-        const args = this.values(node.arguments, true);
+        const args = this.arguments(node.arguments);
         if (lowered) {
           return call(calleePath(lowered.callee), [
             ...lowered.prepend,
@@ -1717,33 +1695,55 @@ end
   /** `[1, ...xs, 2]`. Without a spread it is a Luau sequence; with one, the
    *  runs of plain elements and the spread arrays are joined by `concat`. */
   arrayExpression(node) {
-    if (!node.elements.some((e) => e.type === "SpreadElement")) {
-      const elements = node.elements;
-      return table(this.keptToOne(elements, elements.map((e) => this.expression(e))).map((value) => ({ type: "TableFieldPositional", value })));
+    const elements = packs(node.elements).items;
+    if (!elements.some((e) => e.type === "SpreadElement")) {
+      return table(elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) })));
     }
     const parts = [];
     let current = [];
-    const flush = () => {
+    const flush = (last) => {
       if (!current.length) return;
       parts.push(table(current.map((e, i) => {
         const value = this.expression(e);
-        const last = i === current.length - 1;
-        return { type: "TableFieldPositional", value: last && expandsToMany(value) ? parenthesized(value) : value };
+        return { type: "TableFieldPositional", value: last || i < current.length - 1 ? value : this.keptToOne(value) };
       })));
       current = [];
     };
-    for (const element of node.elements) {
+    for (const element of elements) {
       if (element.type === "SpreadElement") {
-        flush();
+        flush(false);
         parts.push(this.expression(element.argument));
       } else {
         current.push(element);
       }
     }
-    flush();
+    flush(true);
     return call(this.helper("concat"), parts);
   }
 };
+function packs(list) {
+  const items = [];
+  const many = /* @__PURE__ */ new Set();
+  const add = (elements) => {
+    for (const element of elements) {
+      if (element.type === "SpreadElement" && element.argument.type === "ArrayExpression") {
+        const inner = element.argument.elements;
+        add(inner);
+        const last = inner[inner.length - 1];
+        if (last && (last.type === "CallExpression" || last.type === "MethodCallExpression")) many.add(last);
+      } else {
+        items.push(element);
+      }
+    }
+  };
+  add(list);
+  items.forEach((item, i) => {
+    if (!many.has(item) || i === items.length - 1) return;
+    many.delete(item);
+    items[i] = { type: "SpreadElement", argument: { type: "ArrayExpression", elements: [item], ...spanOf(item) }, ...spanOf(item) };
+  });
+  return { items, many };
+}
 function isLink(node) {
   return node.type === "MemberExpression" || node.type === "IndexExpression" || node.type === "CallExpression" || node.type === "MethodCallExpression";
 }
@@ -1792,10 +1792,19 @@ function memberChain(e) {
   }
   return void 0;
 }
+function declared(target) {
+  if (target.type === "MemberExpression" || target.type === "IndexExpression") {
+    throw new Error("a declaration binds names, not a member or an index");
+  }
+  return target;
+}
 function identifierPatterns(target) {
   switch (target.type) {
     case "IdentifierPattern":
       return [target];
+    case "MemberExpression":
+    case "IndexExpression":
+      return [];
     case "ObjectPattern":
       return [...target.properties.flatMap((p) => identifierPatterns(p.value)), ...target.rest ? identifierPatterns(target.rest) : []];
     case "ArrayPattern":
@@ -1809,7 +1818,7 @@ function topLevelDeclaration(statements, name) {
   for (const statement of statements) {
     const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
     if (declaration.type === "VariableDeclaration") {
-      const pattern = declaration.names.flatMap(identifierPatterns).find((p) => p.name === name);
+      const pattern = identifierPatterns(declaration.name).find((p) => p.name === name);
       if (pattern) return { type: "Declaration", node: pattern };
     } else if (declaration.type === "FunctionDeclaration" && declaration.name.name === name) {
       return { type: "Declaration", node: declaration.name };

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   lower,
   program,
   resolveConfig
-} from "./chunk-TBSJRVKA.js";
+} from "./chunk-3ZQ3EITC.js";
 
 // src/compile.ts
 import { readFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tilua/compiler",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "Compiles tilua to Luau: lowers the @tilua/parser AST to a luau-parser AST and prints it",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -37,7 +37,7 @@
   "type": "module",
   "dependencies": {
     "luau-parser": "^1.0.3",
-    "@tilua/parser": "^2.2.0"
+    "@tilua/parser": "^2.4.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.2",