@tilua/compiler 6.0.1 → 7.0.0

package/dist/cli.cjs

@@ -44,7 +44,7 @@ var index = (object2, key) => ({ type: "IndexExpression", object: object2, index
 var call = (callee, args2) => ({ type: "CallExpression", callee, arguments: args2, ...span() });
 var methodCall = (object2, method, args2) => ({ type: "MethodCallExpression", object: object2, method: identifier(method), arguments: args2, ...span() });
 var functionExpression = (func) => ({ type: "FunctionExpression", func, ...span() });
-var binary = (operator, left, right) => ({ type: "BinaryExpression", operator, left, right, ...span() });
+var binary = (operator, left, right) => ({ type: "BinaryExpression", operator, left: operator === "^" && left.type === "UnaryExpression" ? parenthesized(left) : left, right, ...span() });
 var unary = (operator, argument) => ({ type: "UnaryExpression", operator, argument, ...span() });
 var parenthesized = (expression) => ({ type: "ParenthesizedExpression", expression, ...span() });
 var table = (fields) => ({ type: "TableExpression", fields, ...span() });
@@ -103,19 +103,19 @@ var Names = class _Names {
    *  a name shared across modules (the module table) collides with none. */
   static from(...programs) {
     const taken = /* @__PURE__ */ new Set(["select", "pairs", "table", "tostring", "setmetatable", "error"]);
-    const walk = (value) => {
+    const walk2 = (value) => {
       if (!value || typeof value !== "object") return;
       if (Array.isArray(value)) {
-        for (const item of value) walk(item);
+        for (const item of value) walk2(item);
         return;
       }
       const node = value;
       if (typeof node.name === "string" && node.name) taken.add(node.name);
       for (const [key, child] of Object.entries(value)) {
-        if (key !== "line" && key !== "column") walk(child);
+        if (key !== "line" && key !== "column") walk2(child);
       }
     };
-    for (const program2 of programs) walk(program2);
+    for (const program2 of programs) walk2(program2);
     return new _Names(taken);
   }
   /** A copy that goes on to take names independently — one per module, each
@@ -123,6 +123,10 @@ var Names = class _Names {
   fork() {
     return new _Names(new Set(this.taken));
   }
+  /** `name`, chosen elsewhere, is not to be chosen again here. */
+  take(name) {
+    this.taken.add(name);
+  }
   /** `base`, or `base2`, `base3`, ... — whichever is free first. */
   fresh(base) {
     let name = base;
@@ -140,6 +144,7 @@ var implemented = (source) => new Set([...source.matchAll(/function __NAME__\.(\
 var array = read("array.luau");
 var string2 = read("string.luau");
 var object = read("object.luau");
+var json = read("json.luau");
 var arrayMethods = implemented(array);
 var stringMethods = implemented(string2);
 var objectMethods = implemented(object);
@@ -172,7 +177,7 @@ function objectKeys(type) {
   return { known, open: String(open) };
 }
 var plugin = {
-  runtime: { array, string: string2, object },
+  runtime: { array, string: string2, object, json },
   methodCall({ method, receiver, use }) {
     if (isString(receiver)) {
       return stringMethods.has(method) ? { callee: `${use("string")}.${method}` } : void 0;
@@ -261,6 +266,141 @@ var plugin2 = {
 var standardLowering = { plugin: plugin2, from: "tilua (standard library)" };
 
 // src/lower.ts
+function syntaxOf(lowerings) {
+  return new Set((lowerings ?? []).flatMap((l) => l.plugin.syntax ?? []));
+}
+var SharedRuntime = class {
+  constructor(names) {
+    this.names = names;
+  }
+  names;
+  byKey = /* @__PURE__ */ new Map();
+  /** Each group of names and the statements that declare them as locals,
+   *  in the order they were first defined: each after what it uses. */
+  definitions = [];
+  defined = /* @__PURE__ */ new Set();
+  /** The name the helper `key` goes by, in every module. */
+  name(key, base) {
+    let name = this.byKey.get(key);
+    if (!name) {
+      name = this.names.fresh(base);
+      this.byKey.set(key, name);
+    }
+    return name;
+  }
+  /** `statements` declare `names`. Only the first module to say so is heard:
+   *  the others' are the same. */
+  define(names, statements) {
+    if (names.every((name) => this.defined.has(name))) return;
+    for (const name of names) this.defined.add(name);
+    this.definitions.push({ names, statements });
+  }
+  /** Tree shaking: leave out of each runtime table the members nothing
+   *  reads. `code` is everything else the output holds — the modules —
+   *  and a member is read when it, or a member read already, names it:
+   *  `tilua_array.filter(xs, f)` keeps `filter`, and whatever `filter`
+   *  itself calls. A table used as anything but `table.member` — handed
+   *  on, walked, indexed by what only the running program knows — keeps
+   *  every member. */
+  shake(code) {
+    const names = new Set(this.definitions.flatMap((group) => group.names));
+    const read3 = /* @__PURE__ */ new Map();
+    const use = (name, key) => {
+      const now = read3.get(name);
+      if (now === "all") return;
+      if (key === void 0) {
+        read3.set(name, "all");
+        return;
+      }
+      read3.set(name, (now ?? /* @__PURE__ */ new Set()).add(key));
+    };
+    const isRead = (name, key) => {
+      const now = read3.get(name);
+      return now === "all" || (now?.has(key) ?? false);
+    };
+    const scan = (value) => {
+      if (!value || typeof value !== "object") return;
+      if (Array.isArray(value)) return void value.forEach(scan);
+      const node = value;
+      const object2 = node.object;
+      if (object2?.type === "Identifier" && names.has(object2.name)) {
+        if (node.type === "MemberExpression") return use(object2.name, node.property.name);
+        if (node.type === "MethodCallExpression") {
+          use(object2.name, node.method.name);
+          return scan(node.arguments);
+        }
+        if (node.type === "IndexExpression") {
+          const index2 = node.index;
+          if (index2.type === "StringLiteral") return use(object2.name, String(index2.value));
+        }
+      }
+      if (node.type === "Identifier" && names.has(node.name)) return use(node.name);
+      if (node.type === "LocalFunctionStatement") return scan(node.func);
+      for (const [key, child] of Object.entries(node)) {
+        if (key !== "line" && key !== "column") scan(child);
+      }
+    };
+    const defines = (statement, own) => {
+      if (statement.type === "FunctionDeclarationStatement") {
+        const target = statement.target;
+        if (own.includes(target.base.name) && target.path.length === 1 && !target.method) {
+          return { name: target.base.name, key: target.path[0].name, value: statement.func };
+        }
+      }
+      if (statement.type === "AssignmentStatement" && statement.targets.length === 1 && statement.values.length === 1) {
+        const target = statement.targets[0];
+        if (target.object?.type === "Identifier" && own.includes(target.object.name)) {
+          if (target.type === "MemberExpression") return { name: target.object.name, key: target.property.name, value: statement.values[0] };
+          if (target.type === "IndexExpression" && target.index?.type === "StringLiteral") {
+            return { name: target.object.name, key: String(target.index.value), value: statement.values[0] };
+          }
+        }
+      }
+      return void 0;
+    };
+    scan(code);
+    const scanned = /* @__PURE__ */ new Set();
+    let more = true;
+    while (more) {
+      more = false;
+      for (const group of this.definitions) {
+        for (const statement of group.statements) {
+          if (scanned.has(statement)) continue;
+          const definition = defines(statement, group.names);
+          if (definition && !isRead(definition.name, definition.key)) continue;
+          scanned.add(statement);
+          more = true;
+          scan(definition ? definition.value : statement);
+        }
+      }
+    }
+    for (const group of this.definitions) {
+      group.statements = group.statements.filter((statement) => {
+        const definition = defines(statement, group.names);
+        return !definition || isRead(definition.name, definition.key);
+      });
+    }
+  }
+  /** Luau setting up the helpers `used` for a chunk whose code names them:
+   *  `declare` goes before that code, which reads each as an upvalue, and
+   *  `define` after it — before any of it runs, and after what a helper
+   *  reads as it is set up (the line map). Each definition runs in a
+   *  function of its own, so what it keeps to itself stays there. */
+  chunk(used) {
+    const groups = this.definitions.filter((group) => group.names.some((name) => used.has(name)));
+    const all = groups.flatMap((group) => group.names);
+    const declare = [];
+    for (let i = 0; i < all.length; i += 100) declare.push(local(all.slice(i, i + 100), []));
+    const define = groups.map((group) => assign(
+      group.names.map((name) => identifier(name)),
+      [call(parenthesized(functionExpression(functionBody([], [
+        ...group.statements,
+        returns(group.names.map((name) => identifier(name)))
+      ]))), [])]
+    ));
+    return { declare, define };
+  }
+};
 function lower(program2, scopes, options = {}) {
   const result2 = new Lowerer(program2, scopes, options).run();
   dropUnreachable(result2.statements);
@@ -291,7 +431,7 @@ var Lowerer = class {
     this.source = source;
     this.scopes = scopes;
     this.options = options;
-    this.lua51 = options.target === "lua51";
+    this.syntax = syntaxOf(options.lowerings);
     this.names = options.names ? options.names.fork() : Names.from(source);
     this.exportsName = this.names.fresh("exports");
     for (const binding of scopes.bindings.values()) {
@@ -316,6 +456,11 @@ var Lowerer = class {
   names;
   diagnostics = [];
   helpers = /* @__PURE__ */ new Map();
+  /** The shared helpers this file names. */
+  sharedUsed = /* @__PURE__ */ new Set();
+  /** While a shared helper is written: it is defined outside every module,
+   *  where none of a module's own names shadows a global. */
+  rawGlobals = false;
   /** The binding each declaration node creates. */
   bindingByDeclaration = /* @__PURE__ */ new Map();
   /** tilua names that are Luau keywords, and what they are called instead. */
@@ -331,8 +476,8 @@ var Lowerer = class {
   tryFrames = [];
   /** The loops being lowered in the current function, innermost last. */
   loops = [];
-  /** Whether the output has to be plain Lua 5.1 rather than Luau. */
-  lua51;
+  /** What the output's Lua can write beyond Lua 5.1 (`syntaxOf`). */
+  syntax;
   /** The source line each emitted statement came from. */
   origins = /* @__PURE__ */ new WeakMap();
   /** The name each class written as a value is known by. */
@@ -340,15 +485,19 @@ var Lowerer = class {
   run() {
     const body = this.options.module ? this.module(this.options.module) : this.topLevel(this.source.body.statements);
     const scriptArgs = this.usesScriptArgs && !this.options.module ? [local(["scriptArgs"], [this.array(table([{ type: "TableFieldPositional", value: vararg() }]))])] : [];
+    this.rawGlobals = this.options.shared !== void 0;
     const helpers = this.helperDefinitions();
+    const classes = this.classRuntimeStatements();
+    this.rawGlobals = false;
     const captured = [...this.builtins].map(([global, local2]) => local([local2], [identifier(global)]));
     return {
-      statements: [...captured, ...helpers, ...scriptArgs, ...this.classRuntimeStatements(), ...body],
+      statements: [...captured, ...helpers, ...scriptArgs, ...classes, ...body],
       exportsName: this.exportsName,
       module: this.info,
       diagnostics: this.diagnostics,
       origins: this.origins,
-      usesScriptArgs: this.usesScriptArgs
+      usesScriptArgs: this.usesScriptArgs,
+      shared: [...this.sharedUsed]
     };
   }
   /** Whether the file reads `scriptArgs`, the language's own global. */
@@ -381,6 +530,7 @@ var Lowerer = class {
   /** A global the generated code calls — `pairs`, `table`, ... — under a name
    *  the source cannot have shadowed. */
   builtin(global) {
+    if (this.rawGlobals) return identifier(global);
     let local2 = this.builtins.get(global);
     if (!local2) {
       const shadowed = [...this.scopes.bindings.values()].some((b) => b.name === global && b.kind !== "global");
@@ -392,16 +542,31 @@ var Lowerer = class {
   }
   /** `table.move`. Lua 5.1 has none, and gets a function that does the same. */
   move() {
-    return this.lua51 ? this.helper("move") : member(this.builtin("table"), "move");
+    return this.helper("move");
   }
   helper(kind) {
     let name = this.helpers.get(kind);
     if (!name) {
-      name = this.names.fresh(`tilua_${kind === "array" ? "asArray" : kind}`);
+      name = this.sharedName(`helper:${kind}`, `tilua_${kind === "array" ? "asArray" : kind}`);
       this.helpers.set(kind, name);
     }
     return identifier(name);
   }
+  /** A fresh name for a helper — in a bundle, the one every module calls
+   *  that helper by. */
+  sharedName(key, base) {
+    const shared = this.options.shared;
+    if (!shared) return this.names.fresh(base);
+    const name = shared.name(key, base);
+    this.names.take(name);
+    this.sharedUsed.add(name);
+    return name;
+  }
+  /** `statements` declare `names`: in this file, or once for the bundle. */
+  define(names, statements, out2) {
+    if (this.options.shared) this.options.shared.define(names, statements);
+    else out2.push(...statements);
+  }
   // `typeof v` tells an array from an object, which Luau cannot: both are
   // tables. So every array the program makes — `[a, b]`, a rest parameter,
   // what `:map` answers — is written down as one, in a table that holds its
@@ -434,7 +599,8 @@ var Lowerer = class {
     const key = `${index2}:${runtime2}`;
     let name = this.loweringNames.get(key);
     if (!name) {
-      name = this.names.fresh(`tilua_${runtime2.replace(/[^A-Za-z0-9_]/g, "_")}`);
+      const lines = this.lowerings[index2].plugin.runtime?.[runtime2]?.includes("__LINES__") ? this.options.module?.lines : "";
+      name = this.sharedName(`lowering:${key}:${lines}`, `tilua_${runtime2.replace(/[^A-Za-z0-9_]/g, "_")}`);
       this.loweringNames.set(key, name);
       this.loweringUsed.push({ index: index2, runtime: runtime2, name });
     }
@@ -634,19 +800,25 @@ var Lowerer = class {
     const runtimes = this.runtimeDefinitions();
     if (this.helpers.has("concat")) this.helper("array");
     if (this.helpers.has("concat")) this.move();
+    const unpack = this.helpers.get("unpack");
+    if (unpack) {
+      this.define([unpack], (0, import_luau_parser.parse)(
+        `local ${unpack} = ${this.builtin("table").name}.unpack or ${this.builtin("unpack").name}`
+      ).body.statements, out2);
+    }
     const move = this.helpers.get("move");
     if (move) {
-      out2.push(...(0, import_luau_parser.parse)(`
-local function ${move}(from, first, last, at, to)
+      this.define([move], (0, import_luau_parser.parse)(`
+local ${move} = ${this.builtin("table").name}.move or function(from, first, last, at, to)
 	for i = first, last do
 		to[at + i - first] = from[i]
 	end
 	return to
-end`).body.statements);
+end`).body.statements, out2);
     }
     const each = this.helpers.get("each");
     if (each) {
-      out2.push(...(0, import_luau_parser.parse)(`
+      this.define([each], (0, import_luau_parser.parse)(`
 local function ${each}(source, ...)
 	if ${this.builtin("type").name}(source) == "function" then
 		return source, ...
@@ -656,7 +828,7 @@ local function ${each}(source, ...)
 		return meta.__iter(source)
 	end
 	return ${this.builtin("next").name}, source
-end`).body.statements);
+end`).body.statements, out2);
     }
     const marker = this.helpers.get("array");
     const typeOf = this.helpers.get("typeof");
@@ -664,19 +836,19 @@ end`).body.statements);
       const arrays = this.arrays();
       const own = this.helpers.get("arrays");
       if (own) {
-        out2.push(...(0, import_luau_parser.parse)(`local ${own} = ${this.builtin("setmetatable").name}({}, { __mode = "k" })`).body.statements);
+        this.define([own], (0, import_luau_parser.parse)(`local ${own} = ${this.builtin("setmetatable").name}({}, { __mode = "k" })`).body.statements, out2);
       }
       if (marker) {
-        out2.push(...(0, import_luau_parser.parse)(`
+        this.define([marker], (0, import_luau_parser.parse)(`
 local function ${marker}(t)
 	${arrays}[t] = true
 	return t
-end`).body.statements);
+end`).body.statements, out2);
       }
       if (typeOf) {
-        out2.push(...(0, import_luau_parser.parse)(`
+        this.define([typeOf], (0, import_luau_parser.parse)(`
 local function ${typeOf}(value, known)
-	local name = ${this.builtin(this.lua51 ? "type" : "typeof").name}(value)
+	local name = (${this.builtin("typeof").name} or ${this.builtin("type").name})(value)
 	if name ~= "table" then
 		return name
 	end
@@ -693,22 +865,22 @@ local function ${typeOf}(value, known)
 		return "array"
 	end
 	return "object"
-end`).body.statements);
+end`).body.statements, out2);
       }
     }
     const add = this.helpers.get("add");
     if (add) {
-      out2.push(...(0, import_luau_parser.parse)(`
+      this.define([add], (0, import_luau_parser.parse)(`
 local function ${add}(a, b)
 	if ${this.builtin("type").name}(a) == "string" or ${this.builtin("type").name}(b) == "string" then
 		return ${this.builtin("tostring").name}(a) .. ${this.builtin("tostring").name}(b)
 	end
 	return a + b
-end`).body.statements);
+end`).body.statements, out2);
     }
     const instanceOf = this.helpers.get("instanceof");
     if (instanceOf) {
-      out2.push(...(0, import_luau_parser.parse)(`
+      this.define([instanceOf], (0, import_luau_parser.parse)(`
 local function ${instanceOf}(value, class)
 	if ${this.builtin("type").name}(value) ~= "table" then
 		return false
@@ -721,11 +893,11 @@ local function ${instanceOf}(value, class)
 		current = current.ParentClass
 	end
 	return false
-end`).body.statements);
+end`).body.statements, out2);
     }
     const accessors = this.helpers.get("accessors");
     if (accessors) {
-      out2.push(...(0, import_luau_parser.parse)(`
+      this.define([accessors], (0, import_luau_parser.parse)(`
 local function ${accessors}(target, getters, setters)
 	return ${this.builtin("setmetatable").name}(target, {
 		-- Read by a spread, which copies what the getters give.
@@ -749,11 +921,11 @@ local function ${accessors}(target, getters, setters)
 			${this.builtin("rawset").name}(self, key, value)
 		end,
 	})
-end`).body.statements);
+end`).body.statements, out2);
     }
     const assign2 = this.helpers.get("assign");
     if (assign2) {
-      out2.push(...(0, import_luau_parser.parse)(`
+      this.define([assign2], (0, import_luau_parser.parse)(`
 local function ${assign2}(target, ...)
 	for i = 1, ${this.builtin("select").name}("#", ...) do
 		local source = (${this.builtin("select").name}(i, ...))
@@ -771,12 +943,12 @@ local function ${assign2}(target, ...)
 		end
 	end
 	return target
-end`).body.statements);
+end`).body.statements, out2);
     }
-    out2.push(...runtimes);
+    for (const { names, statements } of runtimes) this.define(names, statements, out2);
     const concat = this.helpers.get("concat");
     if (concat) {
-      out2.push(localFunction(concat, functionBody([], [
+      this.define([concat], [localFunction(concat, functionBody([], [
         local(["result"], [this.array(table([]))]),
         numericFor("i", number(1), selectCount(this.builtin("select")), [
           local(["part"], [call(this.builtin("select"), [identifier("i"), vararg()])]),
@@ -789,7 +961,7 @@ end`).body.statements);
           ]))
         ]),
         returns([identifier("result")])
-      ], true)));
+      ], true))], out2);
     }
     return out2;
   }
@@ -809,7 +981,12 @@ end`).body.statements);
       }
       const lines = this.options.module?.lines ?? "nil";
       const fail = this.options.module?.fail ?? "nil";
-      out2.push(...(0, import_luau_parser.parse)(source.replace(/__NAME__/g, name).replace(/__LINES__/g, lines).replace(/__FAIL__/g, fail).replace(/__ARRAY__/g, () => this.helper("array").name)).body.statements);
+      const group = {
+        names: [name],
+        statements: (0, import_luau_parser.parse)(source.replace(/__NAME__/g, name).replace(/__LINES__/g, lines).replace(/__FAIL__/g, fail).replace(/__ARRAYS__/g, () => this.arrays()).replace(/__ARRAY__/g, () => this.helper("array").name).replace(/__JSON__/g, () => this.loweringRuntime(0, "json"))).body.statements
+      };
+      if (index2 === 0 && runtime2 === "json") out2.unshift(group);
+      else out2.push(group);
     }
     return out2;
   }
@@ -824,7 +1001,8 @@ end`).body.statements);
    *    util = require("util")    -- the imports
    *    ...                       -- the rest, in source order */
   module(context) {
-    const statements = this.source.body.statements;
+    const shaken = this.options.shaken;
+    const statements = shaken ? this.source.body.statements.filter((s) => !shaken.removed.has(s)) : this.source.body.statements;
     const exportsTable = () => identifier(this.exportsName);
     const { names, links, stars } = this.info;
     const locals = [];
@@ -863,13 +1041,24 @@ end`).body.statements);
     };
     for (const statement of statements) {
       if (statement.type !== "ImportStatement" || statement.isTypeOnly) continue;
+      if (!statement.defaultImport && !statement.namespaceImport && !statement.specifiers.length) {
+        const key2 = resolve4(statement.source);
+        if (key2 !== void 0) load(key2);
+        continue;
+      }
       const specifiers = [
         ...statement.defaultImport ? [{ local: statement.defaultImport, imported: "default" }] : [],
         ...statement.namespaceImport ? [{ local: statement.namespaceImport, imported: void 0 }] : [],
         ...statement.specifiers.map((s) => ({ local: s.local, imported: s.imported.name }))
       ];
-      const used = specifiers.filter((s) => (this.bindingByDeclaration.get(s.local)?.references.length ?? 0) > 0);
-      if (!used.length) continue;
+      const used = specifiers.filter((s) => (this.bindingByDeclaration.get(s.local)?.references ?? []).some((reference) => !shaken?.dead.has(reference)));
+      if (!used.length) {
+        if (shaken?.runs(statement.source.value)) {
+          const key2 = resolve4(statement.source);
+          if (key2 !== void 0) load(key2);
+        }
+        continue;
+      }
       const key = resolve4(statement.source);
       if (key === void 0) continue;
       const local2 = moduleLocal(key);
@@ -911,6 +1100,7 @@ end`).body.statements);
           break;
         }
         case "ExportAllStatement": {
+          if (shaken && !shaken.needed(statement.source.value)) break;
           const key = resolve4(statement.source);
           if (key === void 0) break;
           load(key);
@@ -1185,7 +1375,7 @@ end`).body.statements);
       case "VariableDeclaration":
         return this.variableDeclaration(node, "declare");
       case "FunctionDeclaration":
-        return [{ ...localFunction(this.name(node.name.name), this.functionBody(node.func)), attributes: this.lua51 ? void 0 : node.attributes }];
+        return [{ ...localFunction(this.name(node.name.name), this.functionBody(node.func)), attributes: this.syntax.has("attributes") ? node.attributes : void 0 }];
       case "FunctionDeclarationStatement":
         return [this.functionDeclarationStatement(node)];
       case "ClassDeclaration":
@@ -1197,7 +1387,7 @@ end`).body.statements);
         const join2 = node.operator === "+=" ? this.options.types?.joins.get(node) : void 0;
         if (join2 === "dynamic") return this.dynamicAddition(node);
         const operator = join2 === "concat" ? "..=" : node.operator;
-        if (this.lua51) return this.compoundAssignment51(node, operator);
+        if (!this.syntax.has("compoundAssignment")) return this.compoundAssignment51(node, operator);
         return [{
           type: "CompoundAssignmentStatement",
           operator,
@@ -1235,10 +1425,10 @@ end`).body.statements);
       case "RepeatStatement": {
         const body = this.block(node.body);
         const condition = this.expression(node.condition);
-        if (this.lua51 && hasOwnJump(body.statements, "ContinueStatement")) {
+        if (!this.syntax.has("continue") && hasOwnJump(body.statements, "ContinueStatement")) {
           const hidden = declaredNames(body.statements).filter((name) => mentions(condition, name));
           if (hidden.length) {
-            this.report(node, `'continue' in a 'repeat' whose 'until' reads ${hidden.map((n) => `'${n}'`).join(", ")} cannot be compiled for Lua 5.1, which has no 'continue' to lower it to. Move what the condition reads out of the loop body, or use a 'while' loop.`);
+            this.report(node, `'continue' in a 'repeat' whose 'until' reads ${hidden.map((n) => `'${n}'`).join(", ")} cannot be compiled to Lua, which has no 'continue' to lower it to. Move what the condition reads out of the loop body, or use a 'while' loop \u2014 or load a library whose Lua has 'continue' ("luau").`);
           }
         }
         return [{ type: "RepeatStatement", body: this.loopBody51(body), condition, ...spanOf(node) }];
@@ -1279,8 +1469,8 @@ end`).body.statements);
         let source = this.expression(node.iterator);
         if (form.viaIter) source = methodCall(source, "__iter", []);
         const variables = form.walks === "values" ? [this.names.fresh("_"), item] : [item];
-        let iterators = form.walks === "iteration" ? [call(this.builtin("unpack"), [source, number(1), number(3)])] : [source];
-        if (this.lua51 && form.walks === "values") {
+        let iterators = form.walks === "iteration" ? [call(this.helper("unpack"), [source, number(1), number(3)])] : [source];
+        if (!this.syntax.has("iteration") && form.walks === "values") {
           const kind = form.viaIter ? void 0 : this.options.types?.typeOf.get(node.iterator)?.kind;
           iterators = [call(kind === "array" || kind === "tuple" ? this.builtin("ipairs") : this.helper("each"), [source])];
         }
@@ -1436,8 +1626,8 @@ end`).body.statements);
   classHelpers;
   classRuntime() {
     return this.classHelpers ??= {
-      build: this.names.fresh("tilua_class"),
-      accessors: this.names.fresh("tilua_accessors")
+      build: this.sharedName("class:build", "tilua_class"),
+      accessors: this.sharedName("class:accessors", "tilua_accessors")
     };
   }
   /** The helpers, as Luau — emitted only in a file that declares a class.
@@ -1455,7 +1645,8 @@ end`).body.statements);
     if (!this.classHelpers) return [];
     const { build, accessors } = this.classHelpers;
     const metamethods = `{ ${CLASS_METAMETHODS.map((name) => `"${name}"`).join(", ")} }`;
-    return (0, import_luau_parser.parse)(`
+    const out2 = [];
+    this.define([build, accessors], (0, import_luau_parser.parse)(`
 local function ${build}(base, name)
     local class = { __getters = {}, __setters = {} }
     class.__index = class
@@ -1493,7 +1684,8 @@ local function ${accessors}(class)
         rawset(this, key, value)
     end
 end
-`).body.statements;
+`).body.statements, out2);
+    return out2;
   }
   /** The class being lowered, so `super` knows what to name. */
   classContext;
@@ -1521,6 +1713,7 @@ end
       string(called)
     ]);
     const out2 = [declare !== void 0 ? local([declare], [create]) : assign([self], [create])];
+    const statics = [];
     const previous = this.classContext;
     this.classContext = node;
     try {
@@ -1528,7 +1721,7 @@ end
         switch (member2.type) {
           case "ClassField":
             if (member2.isStatic) {
-              out2.push(assign(
+              statics.push(assign(
                 [member(self, member2.name.name)],
                 [member2.init ? this.expression(member2.init) : nil()]
               ));
@@ -1559,6 +1752,7 @@ end
       out2.push(this.classInit(node, self));
       if (!node.isAbstract) out2.push(this.classNew(node, self));
       out2.push(callStatement(call(identifier(accessors), [self])));
+      out2.push(...statics);
     } finally {
       this.classContext = previous;
     }
@@ -1635,7 +1829,7 @@ end
       isMethod,
       func,
       // `@native` and the like are Luau's.
-      attributes: this.lua51 ? void 0 : node.attributes,
+      attributes: this.syntax.has("attributes") ? node.attributes : void 0,
       ...spanOf(node)
     };
   }
@@ -1875,7 +2069,7 @@ end
           if (join2 === "concat") return binary("..", left, right);
           if (join2 === "dynamic") return call(this.helper("add"), [this.keptToOne(left), this.keptToOne(right)]);
         }
-        if (this.lua51 && node.operator === "//") return this.floorDivide(left, right);
+        if (!this.syntax.has("floorDivision") && node.operator === "//") return this.floorDivide(left, right);
         return binary(node.operator, left, right);
       }
       case "UnaryExpression":
@@ -1909,7 +2103,7 @@ end
       case "AsConstExpression":
         return this.expression(node.expression);
       case "IfElseExpression":
-        if (this.lua51) return this.ifElse51(node);
+        if (!this.syntax.has("ifExpression")) return this.ifElse51(node);
         return {
           type: "IfElseExpression",
           clauses: node.clauses.map((c) => ({ condition: this.expression(c.condition), body: this.expression(c.body) })),
@@ -1956,7 +2150,7 @@ end
       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(this.lua51 ? this.builtin("unpack") : member(this.builtin("table"), "unpack"), [value]);
+    const unpack = (value) => call(this.helper("unpack"), [value]);
     const last = list[list.length - 1];
     if (spreads.length === 1 && last.type === "SpreadElement") {
       return [...list.slice(0, -1).map((a) => this.expression(a)), unpack(this.expression(last.argument))];
@@ -2070,7 +2264,7 @@ end
     const segments = this.segments(chain);
     const base = this.expression(chain.base);
     const last = chain.links[chain.links.length - 1];
-    if (!this.lua51 && base.type === "Identifier" && segments.length === 1 && last.type !== "CallExpression" && last.type !== "MethodCallExpression") {
+    if (this.syntax.has("ifExpression") && base.type === "Identifier" && segments.length === 1 && last.type !== "CallExpression" && last.type !== "MethodCallExpression") {
       return {
         type: "IfElseExpression",
         clauses: [{ condition: binary("==", base, nil()), body: nil() }],
@@ -2097,7 +2291,7 @@ end
   nullish(node) {
     const left = this.keptToOne(this.expression(node.left));
     const right = this.keptToOne(this.expression(node.right));
-    if (!this.lua51 && left.type === "Identifier") {
+    if (this.syntax.has("ifExpression") && left.type === "Identifier") {
       return {
         type: "IfElseExpression",
         clauses: [{ condition: binary("~=", left, nil()), body: left }],
@@ -2184,14 +2378,19 @@ end
     let target;
     if (node.target.type === "MemberExpression" || node.target.type === "IndexExpression") {
       const object2 = this.expression(node.target.object);
-      const objectName = this.names.fresh("target");
-      before.push(local([objectName], [object2]));
-      if (node.target.type === "MemberExpression") {
-        target = member(identifier(objectName), node.target.property.name);
+      const key = node.target.type === "IndexExpression" ? node.target.index : void 0;
+      if (object2.type === "Identifier" && (key === void 0 || key.type === "StringLiteral" || key.type === "NumberLiteral")) {
+        target = key === void 0 ? member(object2, node.target.property.name) : index(object2, this.expression(key));
       } else {
-        const keyName = this.names.fresh("key");
-        before.push(local([keyName], [this.expression(node.target.index)]));
-        target = index(identifier(objectName), identifier(keyName));
+        const objectName = this.names.fresh("target");
+        before.push(local([objectName], [object2]));
+        if (node.target.type === "MemberExpression") {
+          target = member(identifier(objectName), node.target.property.name);
+        } else {
+          const keyName = this.names.fresh("key");
+          before.push(local([keyName], [this.expression(node.target.index)]));
+          target = index(identifier(objectName), identifier(keyName));
+        }
       }
     } else {
       target = this.expression(node.target);
@@ -2212,7 +2411,7 @@ end
    *  done, and breaks for real there. A body with no `continue` is left
    *  exactly as it was. */
   loopBody51(body) {
-    if (!this.lua51 || !hasOwnJump(body.statements, "ContinueStatement")) return body;
+    if (this.syntax.has("continue") || !hasOwnJump(body.statements, "ContinueStatement")) return body;
     const flag = hasOwnJump(body.statements, "BreakStatement") ? this.names.fresh("broke") : void 0;
     const once = repeatUntil(rewriteOwnJumps(body.statements, flag), boolean(true));
     if (!flag) return block([once]);
@@ -2264,7 +2463,7 @@ end
    *  underscores and `0b1010` becomes the decimal it means. A hex literal
    *  keeps its base — 5.1 reads those. */
   numberRaw(node) {
-    if (!this.lua51) return node.raw;
+    if (this.syntax.has("numberLiterals")) return node.raw;
     if (/^0[bB]/.test(node.raw)) return String(node.value);
     return node.raw.replace(/_/g, "");
   }
@@ -2517,10 +2716,10 @@ function declaredNames(statements) {
 }
 function mentions(expression, name) {
   let found = false;
-  const walk = (value) => {
+  const walk2 = (value) => {
     if (found || !value || typeof value !== "object") return;
     if (Array.isArray(value)) {
-      for (const item of value) walk(item);
+      for (const item of value) walk2(item);
       return;
     }
     const node = value;
@@ -2529,10 +2728,10 @@ function mentions(expression, name) {
       return;
     }
     for (const [key, child] of Object.entries(value)) {
-      if (key !== "line" && key !== "column") walk(child);
+      if (key !== "line" && key !== "column") walk2(child);
     }
   };
-  walk(expression);
+  walk2(expression);
   return found;
 }
 function allNodes(root) {
@@ -2568,6 +2767,269 @@ var CLASS_METAMETHODS = [
   "__iter"
 ];
 
+// src/treeshake.ts
+function walk(node, visit, parent) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const item of node) walk(item, visit, parent);
+    return;
+  }
+  const n = node;
+  if (typeof n.type === "string" && visit(n, parent) === false) return;
+  for (const [key, child] of Object.entries(n)) {
+    if (key === "line" || key === "column") continue;
+    walk(child, visit, typeof n.type === "string" ? n : parent);
+  }
+}
+function pure(expression) {
+  let ok = true;
+  walk(expression, (node) => {
+    if (!ok) return false;
+    switch (node.type) {
+      case "CallExpression":
+      case "MethodCallExpression":
+      case "ImportExpression":
+      case "SuperExpression":
+        ok = false;
+        return false;
+      case "FunctionExpression":
+      case "FunctionBody":
+      case "ClassMethod":
+      case "ClassAccessor":
+      case "ClassConstructor":
+        return false;
+      case "ClassField":
+        if (!node.isStatic) return false;
+    }
+  });
+  return ok;
+}
+function declarationOf(statement) {
+  return statement.type === "ExportStatement" ? statement.declaration : statement;
+}
+function removable(statement) {
+  const declaration = declarationOf(statement);
+  switch (declaration.type) {
+    case "FunctionDeclaration":
+      return true;
+    case "ClassDeclaration":
+      return pure(declaration);
+    case "VariableDeclaration":
+      return declaration.init === void 0 || pure(declaration.init);
+    case "ExportDefaultStatement":
+      return pure(declaration.declaration);
+    default:
+      return false;
+  }
+}
+function structural(statement) {
+  switch (statement.type) {
+    case "TypeAliasStatement":
+    case "ExportTypeAliasStatement":
+    case "DeclareStatement":
+    case "DeclareClassStatement":
+    case "DeclareMetatableStatement":
+    case "ImportStatement":
+    case "ExportNamedStatement":
+    case "ExportAllStatement":
+      return true;
+    default:
+      return false;
+  }
+}
+function exportedNames(statement) {
+  switch (statement.type) {
+    case "ExportStatement": {
+      const declaration = statement.declaration;
+      if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") return [declaration.name.name];
+      const names = [];
+      walk(declaration.name, (node) => {
+        if (node.type === "IdentifierPattern") names.push(node.name);
+      });
+      return names;
+    }
+    case "ExportDefaultStatement":
+      return ["default"];
+    default:
+      return [];
+  }
+}
+function factsOf(module2) {
+  const tops = module2.program.body.statements;
+  const byNode = /* @__PURE__ */ new Map();
+  for (const binding of module2.scopes.bindings.values()) {
+    if (binding.declarationNode) byNode.set(binding.declarationNode, binding.id);
+  }
+  const declaredBy = /* @__PURE__ */ new Map();
+  const imported = /* @__PURE__ */ new Map();
+  for (const statement of tops) {
+    const declaration = declarationOf(statement);
+    const declare = (node) => {
+      const id = node && byNode.get(node);
+      if (id !== void 0) declaredBy.set(id, statement);
+    };
+    if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") declare(declaration.name);
+    else if (declaration.type === "VariableDeclaration") {
+      walk(declaration.name, (node) => {
+        if (node.type === "IdentifierPattern") declare(node);
+      });
+    } else if (declaration.type === "ImportStatement" && !declaration.isTypeOnly) {
+      const target = module2.resolve(declaration.source.value);
+      if (target === void 0) continue;
+      const add = (node, name) => {
+        const id = node && byNode.get(node);
+        if (id !== void 0) imported.set(id, { target, name });
+      };
+      if (declaration.defaultImport) add(declaration.defaultImport, "default");
+      if (declaration.namespaceImport) add(declaration.namespaceImport, "*");
+      for (const s of declaration.specifiers) add(s.local, s.imported.name);
+    }
+  }
+  const parents = /* @__PURE__ */ new WeakMap();
+  walk(module2.program.body, (node, parent) => {
+    if (parent) parents.set(node, parent);
+  });
+  const sideEffects = tops.some((s) => !structural(s) && !removable(s));
+  return { module: module2, tops, declaredBy, imported, parents, sideEffects };
+}
+function treeShake(modules, entry2) {
+  const facts = new Map(modules.map((m) => [m.file, factsOf(m)]));
+  const used = /* @__PURE__ */ new Map();
+  const live = /* @__PURE__ */ new Map();
+  const required = /* @__PURE__ */ new Set();
+  let changed = true;
+  const require2 = (file) => {
+    if (required.has(file) || !facts.has(file)) return;
+    required.add(file);
+    changed = true;
+  };
+  const read3 = (file, name) => {
+    if (!facts.has(file)) return;
+    require2(file);
+    const now = used.get(file);
+    if (now === "all") return;
+    if (name === "*") {
+      used.set(file, "all");
+      changed = true;
+      return;
+    }
+    const names = now ?? /* @__PURE__ */ new Set();
+    if (!names.has(name)) {
+      names.add(name);
+      used.set(file, names);
+      changed = true;
+    }
+  };
+  const isRead = (file, name) => {
+    const now = used.get(file);
+    return now === "all" || (now?.has(name) ?? false);
+  };
+  require2(entry2);
+  used.set(entry2, "all");
+  while (changed) {
+    changed = false;
+    for (const file of [...required]) {
+      const f = facts.get(file);
+      const kept = live.get(file) ?? /* @__PURE__ */ new Set();
+      live.set(file, kept);
+      const queue = [];
+      const keep = (statement) => {
+        if (!statement || kept.has(statement)) return;
+        kept.add(statement);
+        queue.push(statement);
+        changed = true;
+      };
+      for (const statement of f.tops) {
+        if (!structural(statement) && !removable(statement)) keep(statement);
+        if (exportedNames(statement).some((name) => isRead(file, name))) keep(statement);
+        const declaration = declarationOf(statement);
+        if (declaration.type === "ImportStatement" && !declaration.isTypeOnly && !declaration.defaultImport && !declaration.namespaceImport && !declaration.specifiers.length) {
+          const target = f.module.resolve(declaration.source.value);
+          if (target !== void 0) require2(target);
+        }
+        if (declaration.type === "ExportNamedStatement" && !declaration.typeOnly) {
+          const target = declaration.source ? f.module.resolve(declaration.source.value) : void 0;
+          for (const s of declaration.specifiers) {
+            if (!isRead(file, s.exported.name)) continue;
+            if (declaration.source) {
+              if (target !== void 0) read3(target, s.local.name);
+              continue;
+            }
+            const id = f.module.scopes.bindingOf.get(s.local);
+            const own = [...f.declaredBy].find(([bid, st]) => (id !== void 0 ? bid === id : false) || exportedLocal(st, s.local.name));
+            if (own) keep(own[1]);
+            const from = id !== void 0 ? f.imported.get(id) : void 0;
+            if (from) read3(from.target, from.name);
+          }
+        }
+        if (declaration.type === "ExportAllStatement") {
+          const target = f.module.resolve(declaration.source.value);
+          if (target === void 0) continue;
+          const mine = used.get(file);
+          if (mine === "all") read3(target, "*");
+          else for (const name of mine ?? []) if (!ownExport(f, name)) read3(target, name);
+        }
+      }
+      for (const statement of [...kept]) queue.push(statement);
+      while (queue.length) {
+        const statement = queue.pop();
+        walk(statement, (node) => {
+          if (node.type === "ImportExpression") {
+            const source = node.source;
+            const target = source?.type === "StringLiteral" ? f.module.resolve(source.value) : void 0;
+            if (target !== void 0) read3(target, "*");
+            return;
+          }
+          if (node.type !== "Identifier") return;
+          const id = f.module.scopes.bindingOf.get(node);
+          if (id === void 0) return;
+          const declaring = f.declaredBy.get(id);
+          if (declaring && declaring !== statement) keep(declaring);
+          const from = f.imported.get(id);
+          if (!from) return;
+          if (from.name !== "*") return read3(from.target, from.name);
+          const parent = f.parents.get(node);
+          if (parent?.type === "MemberExpression" && parent.object === node) read3(from.target, parent.property.name);
+          else read3(from.target, "*");
+        });
+      }
+      for (const statement of f.tops) {
+        if (statement.type !== "ImportStatement" || statement.isTypeOnly) continue;
+        const target = f.module.resolve(statement.source.value);
+        if (target !== void 0 && facts.get(target)?.sideEffects) require2(target);
+      }
+    }
+  }
+  const shaken = /* @__PURE__ */ new Map();
+  for (const [file, f] of facts) {
+    const kept = live.get(file) ?? /* @__PURE__ */ new Set();
+    const removed = new Set(f.tops.filter((s) => !kept.has(s) && removable(s)));
+    const dead = /* @__PURE__ */ new Set();
+    for (const statement of removed) walk(statement, (node) => {
+      if (node.type === "Identifier") dead.add(node);
+    });
+    shaken.set(file, { removed, dead });
+  }
+  return {
+    modules: shaken,
+    sideEffects: new Set([...facts].filter(([, f]) => f.sideEffects).map(([file]) => file)),
+    required
+  };
+}
+function exportedLocal(statement, name) {
+  const declaration = declarationOf(statement);
+  if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") return declaration.name.name === name;
+  if (declaration.type !== "VariableDeclaration") return false;
+  let found = false;
+  walk(declaration.name, (node) => {
+    if (node.type === "IdentifierPattern" && node.name === name) found = true;
+  });
+  return found;
+}
+function ownExport(f, name) {
+  return f.tops.some((statement) => exportedNames(statement).includes(name) || statement.type === "ExportNamedStatement" && statement.specifiers.some((s) => s.exported.name === name));
+}
+
 // src/linemap.ts
 var import_parser6 = require("@tilua/parser");
 function statementsOf(node) {
@@ -2658,8 +3120,8 @@ async function bundle(options) {
     sources.set(file, { file, name: nameOf(file), text, program: program3, scopes });
     const dynamic = (0, import_parser7.importExpressions)(program3).flatMap((node) => node.source.type === "StringLiteral" ? [node.source.value] : []);
     for (const specifier of [...importedSpecifiers(program3), ...dynamic]) {
-      const target2 = (0, import_parser7.resolveModulePath)(file, specifier, config2);
-      if (target2 && !target2.endsWith(".d.tilua")) queue.push(target2);
+      const target = (0, import_parser7.resolveModulePath)(file, specifier, config2);
+      if (target && !target.endsWith(".d.tilua")) queue.push(target);
     }
   }
   const analysis = analyzeModules([...sources.values()], config2);
@@ -2673,9 +3135,16 @@ async function bundle(options) {
   const requireExpression = member(identifier(G), "require");
   const importExpression = member(identifier(G), "import");
   const mode = options.output ?? config2?.output ?? "single";
-  const target = options.target ?? config2?.target ?? "luau";
+  const byPath = syntaxOf(lowerings).has("requireByPath");
   const modules = /* @__PURE__ */ new Map();
   const origins = /* @__PURE__ */ new WeakMap();
+  const shared = new SharedRuntime(names);
+  const shaking = options.treeShaking ?? config2?.treeShaking ?? false;
+  const resolveIn = (file) => (specifier) => {
+    const found = (0, import_parser7.resolveModulePath)(file, specifier, config2);
+    return found !== void 0 && sources.has(found) ? found : void 0;
+  };
+  const shaken = shaking ? treeShake([...sources.values()].map((s) => ({ file: s.file, program: s.program, scopes: s.scopes, resolve: resolveIn(s.file) })), entry2) : void 0;
   const pending = [entry2];
   while (pending.length) {
     const file = pending.shift();
@@ -2688,10 +3157,21 @@ async function bundle(options) {
       names,
       types: analysis.types.get(file),
       lowerings,
-      target,
       noLib: config2?.noLib,
       source: source.text,
       file: shown,
+      shared,
+      shaken: shaken && {
+        ...shaken.modules.get(file),
+        runs: (specifier) => {
+          const target = resolveIn(file)(specifier);
+          return target !== void 0 && shaken.sideEffects.has(target);
+        },
+        needed: (specifier) => {
+          const target = resolveIn(file)(specifier);
+          return target !== void 0 && shaken.required.has(target);
+        }
+      },
       module: {
         name: source.name,
         require: requireExpression,
@@ -2722,6 +3202,7 @@ async function bundle(options) {
       exportsName: lowered2.exportsName,
       info: lowered2.module,
       usesScriptArgs: lowered2.usesScriptArgs,
+      shared: lowered2.shared,
       imports,
       dynamicImports
     });
@@ -2747,16 +3228,17 @@ async function bundle(options) {
   if (diagnostics.some((d) => d.category === "syntax" || d.category === "scope" || d.category === "module")) {
     return { files: [], modules: moduleNames, diagnostics };
   }
+  if (shaking) shared.shake(lowered.flatMap((m) => m.statements));
   const several = mode !== "single";
   const layout = layoutOf(mode, modules.get(entry2), lowered, options.outFile);
   const usesScriptArgs = lowered.some((m) => m.usesScriptArgs);
   const elsewhere = /* @__PURE__ */ new Map();
   for (const file of layout.slice(1)) {
-    for (const module2 of file.modules) elsewhere.set(module2.name, loadPath(layout[0].path, file.path, target));
+    for (const module2 of file.modules) elsewhere.set(module2.name, loadPath(layout[0].path, file.path, byPath));
   }
   const program2 = (0, import_luau_parser2.parse)(runtime(G, {
     several,
-    target,
+    byPath,
     files: elsewhere,
     imports: lowered.some((m) => m.dynamicImports.size > 0)
   }));
@@ -2771,6 +3253,8 @@ async function bundle(options) {
   for (const module2 of layout[0].modules) {
     modulesTable.fields.push({ type: "TableFieldComputed", key: string(module2.name), value: moduleTable(module2) });
   }
+  const helpers = shared.chunk(new Set(layout[0].modules.flatMap((m) => m.shared)));
+  program2.body.statements.unshift(...helpers.declare);
   const ok = names.fresh("ok");
   const result2 = names.fresh("result");
   const entryStatements = (0, import_luau_parser2.parse)(`
@@ -2792,9 +3276,11 @@ ${modules.get(entry2).info.exports ? `return ${result2}` : ""}
     if (several) mapStatements.push(...mapRegistration(G, layout[0], `${G}.lines`));
     program2.body.statements.splice(program2.body.statements.length - entryStatements.length, 0, ...mapStatements);
   }
+  program2.body.statements.splice(program2.body.statements.length - entryStatements.length, 0, ...helpers.define);
   const files = [{ path: layout[0].path, code: (0, import_luau_parser2.print)(program2) + "\n", modules: layout[0].modules.map((m) => m.name) }];
   for (const file of layout.slice(1)) {
-    const body = [];
+    const fileHelpers = shared.chunk(new Set(file.modules.flatMap((m) => m.shared)));
+    const body = [...fileHelpers.declare];
     if (file.modules.some((m) => m.usesScriptArgs)) body.push(...(0, import_luau_parser2.parse)(`local scriptArgs = ${G}.scriptArgs`).body.statements);
     for (const module2 of file.modules) {
       body.push(assign(
@@ -2804,7 +3290,7 @@ ${modules.get(entry2).info.exports ? `return ${result2}` : ""}
     }
     const chunk = program([returns([functionExpression(functionBody([G], body))])]);
     const lines = buildLineMap(chunk, (0, import_luau_parser2.parse)((0, import_luau_parser2.print)(chunk)), origins);
-    body.push(...mapRegistration(G, file, lineMapSource(lines)));
+    body.push(...mapRegistration(G, file, lineMapSource(lines)), ...fileHelpers.define);
     files.push({ path: file.path, code: (0, import_luau_parser2.print)(chunk) + "\n", modules: file.modules.map((m) => m.name) });
   }
   return { code: files[0].code, files, modules: moduleNames, diagnostics };
@@ -2866,9 +3352,9 @@ function layoutOf(mode, entry2, modules, outFile) {
   }
   return files;
 }
-function loadPath(entryPath, file, target) {
+function loadPath(entryPath, file, byPath) {
   const path = import_node_path2.posix.relative(import_node_path2.posix.dirname(entryPath), file);
-  if (target === "lua51") return path;
+  if (!byPath) return path;
   const bare = path.slice(0, path.length - import_node_path2.posix.extname(path).length);
   return bare.startsWith("../") ? bare : `./${bare}`;
 }
@@ -2881,8 +3367,8 @@ function mapRegistration(G, file, map) {
     ...file.modules.map((module2) => `${G}.maps[${(0, import_parser7.luauString)(module2.name)}] = ${G}.sources[#${G}.sources][2]`)
   ].join("\n")).body.statements;
 }
-function loader(G, target) {
-  if (target === "lua51") {
+function loader(G, byPath) {
+  if (!byPath) {
     return `
         -- From beside this file, wherever that is: its own path says where.
         local folder = ""
@@ -3090,7 +3576,7 @@ ${several ? `
         if ${G}.loaded[file] then
             return
         end
-        ${G}.loaded[file] = true${loader(G, options.target)}
+        ${G}.loaded[file] = true${loader(G, options.byPath)}
     end,` : ""}${options.imports ? `
     -- \`import("./x")\`: the module's exports, asked for where the code runs
     -- rather than before its module does. \`require\` does the rest \u2014 and
@@ -3325,13 +3811,12 @@ function allStatements(statements) {
 }
 
 // src/cli.ts
-var usage = "usage: tilua <entry> [--out <file>] [--output single|chunks|modules] [--config <tilua.config.json>] [--noCheck] [--target luau|lua51]";
+var usage = "usage: tilua <entry> [--out <file>] [--output single|chunks|modules] [--config <tilua.config.json>] [--noCheck]";
 var args = process.argv.slice(2);
 var entry;
 var out;
 var config;
 var typeCheck = true;
-var buildTarget;
 var output;
 for (let i = 0; i < args.length; i++) {
   const arg = args[i];
@@ -3339,12 +3824,8 @@ for (let i = 0; i < args.length; i++) {
   else if (arg === "--config") config = args[++i];
   else if (arg === "--noCheck") typeCheck = false;
   else if (arg === "--target") {
-    const value = args[++i];
-    if (value !== "luau" && value !== "lua51") {
-      console.error(`--target must be 'luau' or 'lua51', not '${value}'`);
-      process.exit(2);
-    }
-    buildTarget = value;
+    console.error(`--target is gone: the output runs on Lua 5.1 to 5.4, LuaJIT and Luau, and a library says what more its Lua has \u2014 add "luau" to the config's 'types'`);
+    process.exit(2);
   } else if (arg === "--output") {
     const value = args[++i];
     if (value !== "single" && value !== "chunks" && value !== "modules") {
@@ -3370,7 +3851,6 @@ async function main(from) {
     entry: from,
     config,
     typeCheck,
-    target: buildTarget,
     output: mode,
     outFile: entryFile !== void 0 ? (0, import_node_path3.basename)(entryFile) : void 0
   });